Data processors

The extension provides three data processors that integrate with the standard TypoScript dataProcessing chain inside HANDLEBARSTEMPLATE content objects.

process-variables

Class: \CPSIT\Typo3Handlebars\DataProcessing\ProcessVariablesProcessor

Processes a variables configuration block — exactly like the top-level variables of HANDLEBARSTEMPLATE — within a data processor chain. This is most useful when combined with other processors such as database-query, allowing per-record variable processing.

Data sources

When resolving configuration values, the processor draws from four data sources, tried in the order listed:

Data source identifier	Contains
`contentObjectRenderer`	Current record's field values
`contentObjectConfiguration`	Top-level `HANDLEBARSTEMPLATE` config
`processedData`	Accumulated output from previous processors
`processorConfiguration`	This processor's own config block

This is why options like table and as can be set by an outer processor and automatically picked up by a nested process-variables without being repeated explicitly. The preProcessing and postProcessing hooks receive the same collection, so they have access to all four sources as well.

Standalone usage

tt_content.my_element = HANDLEBARSTEMPLATE
tt_content.my_element {
    templateName = MyElement

    dataProcessing {
        10 = process-variables
        10 {
            variables {
                header = TEXT
                header.field = header

                teaser = TEXT
                teaser.field = bodytext
                teaser.parseFunc < lib.parseFunc_RTE
            }
        }
    }
}

Nested inside another processor

dataProcessing {
    10 = database-query
    10 {
        table = tx_myext_domain_model_item
        as = items

        dataProcessing {
            10 = process-variables
            10 {
                table = tx_myext_domain_model_item
                as = item
                variables {
                    title = TEXT
                    title.field = title

                    body = TEXT
                    body.field = bodytext
                    body.parseFunc < lib.parseFunc_RTE
                }
            }
        }
    }
}

Properties

variables: Variables to process. Same syntax as the top-level variables in HANDLEBARSTEMPLATE.
table: Database table of the record to use as the data source for field lookups. Defaults to the current content element table.
as: Target key in the processed data array. When set, the processed variables are stored under this key. When omitted, the processed variables replace (or merge into) the root of the processed data.
merge: Boolean. When 1 and as is omitted, the processed variables are merged into the existing processed data rather than replacing it. When as is set and the key already holds an array, the processed variables are merged into that array. Default: 0.
if: Standard TypoScript if condition. When the condition evaluates to false, the processor is skipped and the processed data is returned unchanged.
preProcessing: Data source aware processors run before variables are processed.
postProcessing: Data source aware processors run after variables are processed.

resolve-markers

Class: \CPSIT\Typo3Handlebars\DataProcessing\ResolveMarkersProcessor

Replaces marker-style keys (e.g., ###NAV_ITEMS###) in the processed data with the values stored under those keys. The typical pattern is to use a marker as a named placeholder early in the chain — either as the as target of a preceding processor or directly in a variables entry — and then resolve all markers to clean variable names in a final step. This keeps intermediate processors decoupled from the variable names the template expects.

tt_content.my_element = HANDLEBARSTEMPLATE
tt_content.my_element {
    templateName = MyElement

    dataProcessing {
        # Declare the expected output slots early using markers — these
        # names will become the final template variables
        10 = menu
        10 {
            as = ###mainNavigation###
            levels = 2
        }

        20 = menu
        20 {
            as = ###footerLinks###
            special = directory
            special.value = 42
        }

        # Resolve all markers to clean variable names in one final step
        90 = resolve-markers
        90.removeNonMatchingMarkers = 1
    }
}

After processing, the template receives mainNavigation and footerLinks as clean variable names. The markers at the top of the chain serve as upfront documentation of what the template expects, while the processors that follow fill those slots independently.

Properties

pattern: Regular expression used to identify marker keys. The first capture group becomes the resolved variable name. Default: ###(.*?)###
removeNonMatchingMarkers: Boolean. When 1, variable keys that still match the marker pattern after resolution (i.e., no value was found for them) are removed from the processed data. Default: 0.

unflatten-variable-names

Class: \CPSIT\Typo3Handlebars\DataProcessing\UnflattenVariableNamesProcessor

Converts dot-separated flat variable names into nested arrays. This is useful when other processors set their as key to a dotted path, representing the intended position in a nested data structure.

dataProcessing {
    10 = menu
    10 {
        as = page.nav.mainMenu
    }

    20 = menu
    20 {
        as = page.nav.footerLinks
        special = directory
        special.value = 42
    }

    90 = unflatten-variable-names
}

After processing, the template receives a nested page object:

{{#each page.nav.mainMenu}}
    <a href="{{link}}">{{title}}</a>
{{/each}}

The processor has no configuration properties and operates on the entire processed data array.