40+ Enhancement in TYPO3 v10 for Developers: Series 5

40+ Enhancement in TYPO3 v10 for Developers: Series 5

Welcome to the last blog of the  TYPO3 v10 Features Series!

The TYPO3 developers are the key people who are developing and maintaining either the whole system or custom TYPO3 extensions solutions.

TYPO3 Core team and Community working hard for a year to give developer-friendly CMS.

And,  TYPO3 v10 release party, although most of the parties are canceled due to  Covid-19, I recommend you to read this blog.

IMHO, In  Covid-19 lockdown, It's the right time to learn, explore and contribute to the  TYPO3 Community. So, Get ready to know in-depth about  TYPO3 v10.

We are publishing a Blog series for  TYPO3 v10 for  TYPO3 Editors, Integrators, Integrators, and Developers.

Now, as being a  TYPO3 Developer it’s our responsibility to always follow the latest standards. How can you help the  TYPO3 Community?

  • Always follow latest TYPO3 technologies and coding standards
  • Report bug/issue to TYPO3 team
  • Check change log and deprecation
  • Regularly update and make compatible your TYPO3 extensions at TER for community

Get ready to see some of the new features of  TYPO3 v10 which will be useful as a  TYPO3 Developer.

Step-by-step Guide and Feature-list for Developers in  TYPO3 v10

 TYPO3 v10 has introduced some of the new features as well as improvements to existing features.

Checkout one-by-one major features that will help TYPO3 Developers as follows.

1. Dashboard - Create Your Own Widget

Source: https://typo3.org/

Developers can create custom widgets for the Dashboard by extending one of the following widget abstracts:

  • AbstractWidget: A basic abstract that can be used as the start of simple widgets.
  • AbstractRssWidget: An abstract to create a widget that shows an RSS feed.
  • AbstractListWidget: An abstract to create a widget that shows a list of items.
  • AbstractCtaButtonWidget: An abstract to create a widget that shows a "call-to-action" button.

Step 1. Register your widgets

EXT:my_extension/Configuration/Services.yaml

Option 1: widget identifier as attribute

Vendor\MyExtension\Widgets\MyFirstWidget:
    tags:
        -
        name: dashboard.widget
        identifier: widget-identifier-1
        widgetGroups: ’general’

Option 2: custom service name allows multiple widget identifier to share one class

class: Vendor\MyExtension\Widgets\MySecondWidget
    tags:
        -
        name: dashboard.widget
        identifier: widget-identifier-2
        widgetGroups: ’general, typo3’

Step 2. Widget Groups

Every widget is attached to one or more widget groups. Those groups are shown in the modal when adding a new widget to your dashboard. Developers can configure custom widget groups by creating a file.

EXT:my_extension/Configuration/Backend/DashboardWidgetGroups.php
    return [
    ’widgetGroup-exampleGroup’ => [
        ’title’ => ’LLL:EXT:my_extension/Resources/Private/Language/locallang.xlf:widget_group_name’,
    ],
];

Step 3: Automatically create a dashboard for new users

options.dashboard.dashboardPresetsForNewUsers = default, dashboardPreset-myOwnPreset

2. Fix Breaking Changes

In TYPO3 v9, some PHP classes, interfaces, class aliases, properties, methods, constants, global options and variables, etc. were marked Deprecated.

In accordance with TYPO3's deprecation policy, these components have been removed in  TYPO3 v10.0. How can you make sure that all your functionality works without breaking? Perform the following steps.

Source: https://typo3.org/

  • Step 1.Enable deprecation log
  • Step 2.Use Extension Scanner for code-review and get a full report of incompatibilities of your custom extensions.

3. New Mail API

SwiftMailer has been superseded by more modern libraries:

symfony/mime // for creating mail messages
symfony/mailer // for sending emails

PHP function mail() is no longer supported. It is recommended to switch to sendmail or smtp instead.

$email = GeneralUtility::makeInstance(MailMessage::class)
->to(new Address('[email protected]'), new Address('[email protected]', 'Benni Mack'))
->subject('This is an example email')
->text('This is the plain-text variant')
->html('Hello Benni.
Enjoy a HTML-readable email. We love TYPO3.');

$email->send();

4. Fluid-based Email Templating

TYPO3 now supports sending template-based emails for multi-part and HTML-based emails out-of-the-box. The email contents are built with Fluid Templating Engine.

$GLOBALS['TYPO3_CONF_VARS']['MAIL']['templateRootPaths'][700] = 'EXT:my_site_extension/Resources/Private/Templates/Email';
$GLOBALS['TYPO3_CONF_VARS']['MAIL']['layoutRootPaths'][700] = 'EXT:my_site_extension/Resources/Private/Layouts';

$email
    ->to('[email protected]')
    ->from(new Address('[email protected]', 'Jeremy'))
    ->subject('TYPO3 loves you - here is why')
    ->setFormat('html') // only HTML mail
    ->setTemplate('TipsAndTricks')
    ->assign('mySecretIngredient', 'Tomato and TypoScript');
GeneralUtility::makeInstance(Mailer::class)->send($email);

<f:section name="Subject"> New Login at "{typo3.sitename}"</f:section>

5. Symfony Dependency Management/Injection

The package symfony/dependency-injection has been integrated and is used to manage system-wide dependency management and dependency injection for classes.

Configuration options include:

# Configuration/Services.yaml
Services:
    _defaults:
        autowire: true
        autoconfigure: true
        public: false
    Your\Namespace\:
        resource: ’../Classes/*’

6. Event Dispatching

A new "EventDispatcher" system has been added which aims to replace the hooks and Signal/Slots concepts.

It is based on the PSR-14 standard which allows developers to inject logic into an application easily and consistently.

Step 1. Configuration/Services.yaml

services:
    Vendor\Example\EventListener\NullMailer:
    tags:
        - { name: event.listener, identifier: ’myListener’, event: TYPO3\CMS\Core\Mail\Event\
        AfterMailerInitializationEvent, before: ’redirects, anotherIdentifier’ }

Step 2. Implement your event object

List of available Event Listeners can be accessed in the backend: (requires system extension EXT:lowlevel)

7. BitSet Class

New class has been introduced to efficiently handle boolean ags:
TYPO3\CMS\Core\Type\BitSet

Example;

define(’PERMISSIONS_javascript’, 0b0); // 0
define(’PERMISSIONS_PAGE_SHOW’, 0b1); // 1
define(’PERMISSIONS_PAGE_EDIT’, 0b10); // 2
define(’PERMISSIONS_PAGE_DELETE’, 0b100); // 4
define(’PERMISSIONS_PAGE_NEW’, 0b1000); // 8
define(’PERMISSIONS_CONTENT_EDIT’, 0b10000); // 16
define(’PERMISSIONS_ALL’, 0b11111); // 31

$bitSet = new \TYPO3\CMS\Core\Type\BitSet(PERMISSIONS_PAGE_SHOW | PERMISSIONS_PAGE_NEW);
$bitSet->get(PERMISSIONS_PAGE_SHOW); // true
$bitSet->get(PERMISSIONS_CONTENT_EDIT); // false

8. Register TYPO3 Plugins/Modules

Registering plugins/modules require fully-qualified class names now

\TYPO3\CMS\Extbase\Utility\ExtensionUtility::configurePlugin()
\TYPO3\CMS\Extbase\Utility\ExtensionUtility::registerModule()

Also omit vendor name in the extension name (first argument). Use "ExampleBlog" instead of "Vendor.ExampleBlog".

For example:

\TYPO3\CMS\Extbase\Utility\ExtensionUtility::configurePlugin(
    ’ExampleBlog’, // previously: ’Vendor.ExampleBlog’
    ’pi1’,
    [
        \Vendor\Example\Controller\BlogController::class => ’list,update,delete’
    ],
    [
        \Vendor\Example\Controller\BlogController::class => ’list,update,delete’
    ]
);

9. Extbase Models DockBlocks

Extbase models now supports non fully-qualified class names in DocBlocks.

use TYPO3\CMS\Extbase\Persistence\ObjectStorage;
use ExtbaseTeam\BlogExample\Domain\Model\Comment;
class Post
{
    /**
    * @var ObjectStorage
    */
    public $comments;
}

10. Register Extbase Validators

Validators are not registered automatically in Extbase anymore. Validators need to be registered manually now.

Eg, For a model named Vendor\Example\Domain\Model\Blog, Extbase automatically used the validator

Vendor\Example\Domain\Validator\BlogValidator
use Vendor\Example\Domain\Model\Blog;
use TYPO3\CMS\Extbase\Annotation as Extbase;
use TYPO3\CMS\Extbase\Mvc\Controller\ActionController;

class BlogController extends ActionController
{
    /**
    * @Extbase\Validate(param="blog", validator="Vendor\Example\Domain\Validator\BlogValidator")
    */

    public function showAction(Blog $blog)
    {
        // ...
    }
}

11. Notification Actions

JavaScript notifications in the backend support actions (buttons) now.

require([
'TYPO3/CMS/Backend/ActionButton/ImmediateAction',
'TYPO3/CMS/Backend/ActionButton/DeferredAction',
'TYPO3/CMS/Backend/Notification'
], function(ImmediateAction, DeferredAction, Notification) {
    const immediateActionCallback = new ImmediateAction(function () { /* your action code */ });
        Notification.info(
            'Great! We are almost done here...',
            'Common default settings have been applied based on your previous input.',
            0,
        [
            {label: 'Show settings', action: immediateActionCallback}
        ]
    );
});

12. New-way of Class Mapping

Persistence related class mapping using TypoScript is no longer supported eg., config.tx_example_blog.persistence.classes..

# Configuration/Extbase/Persistence/Classes.php:

    declare(strict_types = 1);
        return [
            \Vendor\Example\Domain\Model\Author::class > [
                ’tableName’ => ’fe_users’,
                ’properties’ => [
                ’fullname’ => [
                ’fieldName’ => ’name’
            ]
        ]
    ]
];

13. Cache Dependency Injection

Extension developers are encouraged to inject caches directly rather than using the CacheManager.

Old-way

class MyClass
{
    /**
    * @var TYPO3\CMS\Core\Cache\Frontend\FrontendInterface
    */

    private $cache;
    public function __construct()
    {
        $cacheManager = GeneralUtility::makeInstance(CacheManager::class);
        $this->cache = $cacheManager->getCache(’my_cache’);
    }
}

New-way

class MyClass
{
    /**
    * @var TYPO3\CMS\Core\Cache\Frontend\FrontendInterface
    */

    private $cache;
    public function __construct(FrontendInterface $cache)
    {
        $this->cache = $cache;
    }
}

...and the following container service con guration is required:

services:
    cache.my_cache:
    class: TYPO3\CMS\Core\Cache\Frontend\FrontendInterface
    factory: [’@TYPO3\CMS\Core\Cache\CacheManager’, ’getCache’]
    arguments: [’my_cache’]
MyClass:
    arguments:
    $cache: ’@cache.my_cache’

14. PSR-17 HTTP Message Factories

The PSR-17 HTTP Message Factories implementation has been added. HTTP Message Factory interfaces should be used as dependencies for request handlers or services that create PSR-7 message objects.

// PSR-17 consists of six factory interfaces:
\Psr\Http\Message\RequestFactoryInterface
\Psr\Http\Message\ResponseFactoryInterface
\Psr\Http\Message\ServerRequestFactoryInterface
\Psr\Http\Message\StreamFactoryInterface
\Psr\Http\Message\UploadedFileFactoryInterface
\Psr\Http\Message\UriFactoryInterface

15. PSR-18 HTTP Client

The PSR-18 HTTP Client implementation has been added. It lets developers generate HTTP requests based on PSR-7 message objects without relying on a specific HTTP client implementation.

// PSR-18 consists of a client interface and three exception interfaces:
\Psr\Http\Client\ClientInterface
\Psr\Http\Client\ClientExceptionInterface
\Psr\Http\Client\NetworkExceptionInterface
\Psr\Http\Client\RequestExceptionInterface

16. Custom File Processors

Developers can now register their own processors like you want to add a watermark to images.

// ext_localconf.php
$GLOBALS[’TYPO3_CONF_VARS’][’SYS’][’fal’][’processors’][’ExampleImageProcessor’] = [
    ’className’ => \Vendor\MyExtension\Resource\Processing\ExampleImageProcessor::class,
    ’before’ => ’LocalImageProcessor’,
];

17. Include YAML files

YAML files can already be included by other YAML les using the following syntax:

imports:
    - { resource: "EXT:my_extension/Configuration/FooBar/Example.yaml" }
another:
    option: true

This has been extended to import resources relative to the current YAML file

imports:
    - { resource: "subfolder/AnotherExample.yaml" }
    - { resource: "../path/to/configuration/AnotherExample.yaml" }
another:
    option: true

18. f:widget ViewHelper

Widget ViewHelpers set a session cookie in the frontend under certain circumstances. As this is not always desired (for example due to  GDPR), this can be controlled now.

A boolean storeSession has been introduced that lets developers enable/disable this feature.

<f:widget.autocomplete for="name" objects="{posts}" searchProperty="author" storeSession="false" />

19. PSR-14 Events in the TYPO3 Core

A number of new PSR-14 Events replace Signal/Slots in the TYPO3 core:

TYPO3\CMS\Core\Imaging\Event\ModifyIconForResourcePropertiesEvent
TYPO3\CMS\Core\DataHandling\Event\IsTableExcludedFromReferenceIndexEvent
TYPO3\CMS\Core\DataHandling\Event\AppendLinkHandlerElementsEvent
TYPO3\CMS\Core\Configuration\Event\AfterTcaCompilationEvent
TYPO3\CMS\Core\Database\Event\AlterTableDefinitionStatementsEvent
TYPO3\CMS\Core\Tree\Event\ModifyTreeDataEvent
TYPO3\CMS\Backend\Backend\Event\SystemInformationToolbarCollectorEvent

20. Introduced PageTsConfigLoader and PageTsConfigParser

Two new PHP classes have been introduced to load and parse PageTSconfig:

TYPO3\CMS\Core\Configuration\Loader\PageTsConfigLoader
TYPO3\CMS\Core\Configuration\Parser\PageTsConfigParser

For example:

// Fetch all available PageTS of a page/rootline:
$loader = GeneralUtility::makeInstance(PageTsConfigLoader::class);
$tsConfigString = $loader->load($rootLine);

// Parse the string and apply conditions:
$parser = GeneralUtility::makeInstance(
PageTsConfigParser::class, $typoScriptParser, $hashCache
);
$pagesTSconfig = $parser->parse($tsConfigString, $conditionMatcher);

21. Site Language Awareness

A SiteLanguageAwareInterface has been introduced. The interface can be used to denote a class as aware of the site language.

Routing aspects, that take the site language into account, are now using the SiteLanguageAwareInterface in addition to the SiteLanguageAwareTrait.

22. Removed System Log API

The following options have been removed from TYPO3's default configuration, Extension authors are advised to use the Logging API and remove the systemLog options.

$GLOBALS[’TYPO3_CONF_VARS’][’SYS’][’systemLog’]
$GLOBALS[’TYPO3_CONF_VARS’][’SYS’][’systemLogLevel’]

23. Introduction to Pagination Feature

Native support for the pagination of lists such as arrays or QueryResults of Extbase has been introduced.

The PaginatorInterface holds a basic set of methods. The AbstractPaginator class holds the main pagination logic. This enables developers to implement all kinds of paginators.

use TYPO3\CMS\Core\Pagination\ArrayPaginator;

$items = [’apple’, ’banana’, ’strawberry’, ’raspberry’, ’ananas’];
$currentPageNumber = 3;
$itemsPerPage = 2;

$paginator = new ArrayPaginator($itemsToBePaginated, $currentPageNumber, $itemsPerPage);
$paginator->getNumberOfPages(); // returns 3
$paginator->getCurrentPageNumber(); // returns 3
$paginator->getKeyOfFirstPaginatedItem(); // returns 5
$paginator->getKeyOfLastPaginatedItem(); // returns 5

24. Edit Only Specific Field: ViewHelper editRecord

An optional argument field has been added to the uri.editRecord and link.editRecord ViewHelpers. If set, the FormEngine creates a form to only edit the given database field(s).

The following example creates a link to edit the tt_content.bodytext field of record with the UID 42.

<code class="language-markup"><be:link.editRecord uid="42" table="tt_content" fields="bodytext" returnUrl="foo/bar">
    Edit record
</be:link.editRecord>

25. Add Custom JS/CSS through Fluid

The initial steps of integrating an AssetCollector have been implemented. The concept allows developers to add custom CSS/JS code (inline or external) multiple times, but TYPO3 outputs it only once.

In this regards, two new Fluid ViewHelpers have been added:

<f:asset.css identifier="identifier123" href="EXT:my_ext/Resources/Public/Css/foo.css" />
<f:asset.css identifier="identifier123">
    .foo { color: black; }
</f:asset.css>

<f:asset.script identifier="identifier123" src="EXT:my_ext/Resources/Public/JavaScript/foo.js" />
<f:asset.script identifier="identifier123">
    alert('hello world');
</f:asset.script>
GeneralUtility::makeInstance(AssetCollector::class)
->addJavaScript('my_ext_foo', 'EXT:my_ext/Resources/Public/JavaScript/foo.js', ['data-foo' => 'bar']])

In the long run, the AssetCollector aims to replace the various existing TypoScript options that are rather confusing.

26. Allow to Change hreflang-tag

It is now possible to modify hreflang tags before they get rendered. Developers can achieve this by registering an event listener for the following event:

TYPO3\CMS\Frontend\Event\ModifyHrefLangTagsEvent

27.  CKEditor: Customization

The following PSR-14-based events have been introduced which allow to modify the  CKEditor configuration:

TYPO3\CMS\RteCKEditor\Form\Element\Event\AfterGetExternalPluginsEvent
TYPO3\CMS\RteCKEditor\Form\Element\Event\BeforeGetExternalPluginsEvent
TYPO3\CMS\RteCKEditor\Form\Element\Event\AfterPrepareConfigurationForEditorEvent
TYPO3\CMS\RteCKEditor\Form\Element\Event\BeforePrepareConfigurationForEditorEvent

Example

// EXT:my_extension/Configuration/Services.yaml
services:
    Vendor\MyExtension\EventListener\RteConfigEnhancer:
    tags:
    - name: event.listener
        identifier: 'ext-myextension/rteConfigEnhancer'
        method: 'beforeGetExternalPlugins'
        event: TYPO3\CMS\RteCKEditor\Form\Element\Event\BeforeGetExternalPluginsEvent
    - name: event.listener
        identifier: 'ext-myextension/rteConfigEnhancer'
        method: 'beforePrepareConfiguration'
        event:
TYPO3\CMS\RteCKEditor\Form\Element\Event\BeforePrepareConfigurationForEditorEvent
// EXT:my_extension/Classes/EventListener/RteConfigEnhancer.php
namespace Vendor\MyExtension\EventListener;

use TYPO3\CMS\RteCKEditor\Form\Element\Event\BeforeGetExternalPluginsEvent;
use TYPO3\CMS\RteCKEditor\Form\Element\Event\BeforePrepareConfigurationForEditorEvent;

class RteConfigEnhancer
{
    public function beforePrepareConfiguration(BeforePrepareConfigurationForEditorEvent $event): void
    {
        $data = $event->getData();
        // @todo make useful decisions on fetched data
        $configuration = $event->getConfiguration();
        $configuration['extraPlugins'][] = 'example_plugin';
        $event->setConfiguration($configuration);
    }
}

28. Admin Panel Gets PSR-14 Events

The Admin Panel shows all PSR-14 events that have been dispatched in the current request.

29. Forget jQuery for AJAX Implementation: Fetch API

The Fetch API has been introduced to perform AJAX requests and to make TYPO3 less dependent on jQuery.

The API provides a generic definition of Request and Response objects (and other things involved with network requests).

Example of GET requests

require(['TYPO3/CMS/Core/Ajax/AjaxRequest'], function (AjaxRequest) {
const request = new AjaxRequest('https://httpbin.org/json');
    request.get().then(
        async function (response) {
            const data = await response.resolve();
            console.log(data);
        }, function (error) {
            console.error('Request failed because of error: ' + error.status + ' ' + error.statusText);
        }
    );
});

30. Action Buttons in Modals

Modal popups now support action buttons. As an alternative to the existing trigger option, the new option action can be used.

For example:

Modal.confirm(’Header’, ’Some content’, Severity.error, [
    {
        text: ’Based on trigger()’,
        trigger: function () {
            console.log(’Vintage!’);
        }
    },
    {
        text: ’Based on action()’,
        action: new DeferredAction(() => {
            return new AjaxRequest(’/any/endpoint’).post({});
        })
    }
]);

31. JavaScript Events API

More and more JavaScripts core APIs are launching to avoid unnecessary other frameworks like jQuery. A new Event API enables JavaScript developers to have a stable event listening interface.

require(['TYPO3/CMS/Core/Event/RegularEvent'], function (RegularEvent) {
    new RegularEvent('click', function (e) {
        // Do something
    }).bindTo(document.querySelector('#my-element'));
});

32. Allow Get Default Value of Class

It is now possible to get the default value of a class property when using the TYPO3\CMS\Extbase\Reflection\ReflectionService.

class MyClass
{
    public $myProperty = 'foo';
}

$property = GeneralUtility::makeInstance(\TYPO3\CMS\Extbase\Reflection\ReflectionService::class)
    ->getClassSchema(MyClass::class)
    ->getProperty('myProperty');

$defaultValue = $property->getDefaultValue(); // "foo"

33. Render fieldControl for SelectSingleElement

It is now possible to use the fieldControl option for SelectSingleElements to add nodes and wizards. For example, add a link popup button to a select called “field_name” of the pages table:

$GLOBALS['TCA']['pages']['columns']['field_name']['config']['fieldControl']['linkPopup'] = [
    'renderType' => 'linkPopup',
];

34. Customize special page icons by docktype

The page icon in the pagetree can now be fully customized for own docktypes.

EXT:my_extension/Configuration/TCA/Overrides/pages.php
    'ctrl' => [
        'typeicon_classes' => [
        '123' => "your-icon",
        '123-contentFromPid' => "your-icon-contentFromPid",
        '123-root' => "your-icon-root",
        '123-hideinmenu' => "your-icon-hideinmenu",
    ],
]

35. Custom icons for Record-browser

The icons for the record browser button can now be customized.

TYPO3:
    CMS:
        Form:
            prototypes:
                standard:
                    formElementsDefinition:
                        ContentElement:
                            formEditor:
                                editors:
                                    # ...
                                    300:
                                    identifier: contentElement
                                    # ...
                                    browsableType: tt_content
                                    iconIdentifier: mimetypes-x-content-text
                                    propertyPath: properties.contentElementUid
                                    # ...

37. EXT:felogin Hook to Validate Password

Now we can easily validate password through EXT:felogin hook

$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['felogin']['password_changed'][] = \Your\Namespace\Hooks\MyBeautifulHook::class . '->passwordChanged';

public function passwordChanged(array &$params)
{
    if($params['newPasswordUnencrypted']==='password'){
        $params['passwordValid']=FALSE;
        $params['passwordInvalidMessage']='Do not use password as password';
    }
}

38. Import Environment Variables into Sites

Environment variables are now resolved in imports of site configuration YAML files.

imports:
    -
    resource: 'Env_%env("foo")%.yaml'

39. $queryBuilder->set() Get Fourth Argument

TYPO3\CMS\Core\Database\Query\QueryBuilder::set() accepts as additional fourth parameter a type the query value should be casted to when the third parameter (createNamedParameter) is true. Per default string (\PDO::PARAM_STR) is used.

$queryBuilder-$gt;set($fieldName, $fieldValue, true, \PDO::PARAM_INT);

40. Configuration for ipLocking

Added more configuration for New Locking API

// typo3conf/AdditionalConfiguration.php
$GLOBALS['TYPO3_CONF_VARS']['SYS']['locking']['strategies'][\TYPO3\CMS\Core\Locking\FileLockStrategy::class]['priority'] = 10;
// The directory specified here must exist und must be a subdirectory of `Environment::getProjectPath()`
$GLOBALS['TYPO3_CONF_VARS']['SYS']['locking']['strategies'][\TYPO3\CMS\Core\Locking\FileLockStrategy::class]['lockFileDir'] = 'mylockdir';

// Your Class
public static function getPriority()
{
    return $GLOBALS['TYPO3_CONF_VARS']['SYS']['locking']['strategies'][self::class]['priority']
    ?? self::DEFAULT_PRIORITY;
}

41. CLI scheduler:run Command Allows Multiple Tasks

The new feature allows the execution of tasks in a given order. This can be used to debug side effects between tasks that are executed within the same scheduler run.

./typo3/sysext/core/bin/typo3 scheduler:run --task 1 --task 2

42. Introduce CacheHashConfiguration

Settings for $GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash'] are modelled in class CacheHashConfiguration which takes care of validating configuration. It also determines whether corresponding aspects apply to a given URL parameter.

#LocalConfiguration.php
$GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash'] = [
    'excludedParameters' => [
        'utm_source',
        'utm_medium',
        '^utm_', // making previous two obsolete
    ],
    'excludedParametersIfEmpty' => [
        '^tx_my_plugin[aspects]',
        'tx_my_plugin[filter]',
    ],
];

43. Security: Status Reports

The DebugExceptionHandler possibly outputs sensitive data that could result in an information disclosure vulnerability. A new status report has been introduced to warn administrators.

WARNING, if the context is set to development and the error output is enabled:

ERROR, if the context is set to production and the error output is enabled:

44. Security: Password Hash Algorithms

The hashing algorithm Argon2i ("i") was introduced with TYPO3 v9 LTS.

  • Argon2id ("id") is now also available in TYPO3 if the PHP version supports it.
  • Argon2id is a hybrid of Argon2i and Argon2d and is more resistant against side-channel attacks.
  • Argon2id is typically available on systems with PHP version 7.3 or higher.

AtoZ About  TYPO3 v10

What’s New Slides

All the above features and screenshot has been taken from What’s New Slides. We recommend to check out those slides to know AtoZ like deprecation, TypoScript, Fluid and PHP code-level changes, etc.

Change Log of  TYPO3 v10

You can also get detailed change-log of  TYPO3 v10 at

https://docs.typo3.org/c/typo3/cms-core/master/en-us/Changelog-10.html

Wrap-up!

That’s it!

I hope you enjoyed and liked our blog with insight details of  TYPO3 v10.

Here is the quick recap which you should go through for  TYPO3 v10.

  • Be passionate with vibrant  TYPO3 Community - Get prepared for  TYPO3 v10
  • Try  TYPO3 v10 and write feedback to the TYPO3 core team & community
  • Keep practicing and developing the next website with  TYPO3 v10 standards
  • Update your TYPO3 extensions with  TYPO3 v10 at TER.
  • Go through practically each TYPO3 features and code-level which will help you as Integrator
  • Let's viral #TYPO3v10

As a  TYPO3 Developer, What’s your favorite feature in  TYPO3 v10 or looking for any new feature? Do you have any questions on  TYPO3 v10? Just write down in the comment box below and we will be happy to answer you.

Have a Happy  TYPO3 v10!


We are publishing a Blog series for  TYPO3 v10 for  TYPO3 Editors, Integrators, Integrators, and Developers.

Post Comment

Your email address will not be published. Required fields are marked *

×

Name is required!

Enter valid name

Valid email is required!

Enter valid email address

Comment is required!

Google Captcha Is Required!

Comments :

  • Lucas Schmidt July 6, 2020 At 12:16 pm
    This is some serious in-depth look at the TYPO3 version 10! Thank you, Sanjay for such a fantastic and helpful article.
  • Tobias Jones July 6, 2020 At 12:05 pm
    I fell in love with this TYPO3 v 10 newly released update! As usual, TYPO3 is the best in the business.

Subscribe ForNewsletter

Launch Your Free TYPO3 AWS in 5 mins!

Launch Your Free TYPO3 AWS in 5 mins!

Are you looking for beginner level TYPO3 AWS installation and configuration? Then here go, In this article, you will install free…

How to Build a TYPO3 website in minutes with TYPO3 SaaS?

How to Build a TYPO3 website in minutes with TYPO3 SaaS?

Introducing TYPO3 SaaS to build a fast, User-friendly SaaS website without worrying about coding, design, and hosting. Everything…

How to Manage TYPO3 Site Configuration (Easy Guide - 2020)

How to Manage TYPO3 Site Configuration? (Easy Guide - 2020)

Since TYPO3 9, We have one of most awaiting TYPO3 site configuration features with a dedicated backend module called “TYPO3 Site…

Stay up to date with our recent TYPO3 Blogs, news, & updates