This package contains general-purpose Fusion objects, which are usable both within Neos and standalone.
Render multiple nested definitions and concatenate the results.
[key]: | (string) A nested definition (simple value, expression or object) that evaluates to a string |
---|---|
[key].@ignoreProperties: | (array) A list of properties to ignore from being "rendered" during evaluation |
[key].@position: | (string/integer) Define the ordering of the nested definition |
The order in which nested definitions are evaluated are specified using their
@position
meta property. For this argument, the following sort order applies:
start [priority]
positions. The higher the priority, the earlier the object is added. If no priority is given, the element is sorted after allstart
elements with a priority.[numeric ordering]
positions, ordered ascending.end [priority]
positions. The higher the priority, the later the element is added. If no priority is given, the element is sorted before allend
elements with a priority.
Furthermore, you can specify that an element should be inserted before or after a given
other named element, using before
and after
syntax as follows:
before [namedElement] [optionalPriority]
: add this element beforenamedElement
; the higher the priority the more in front ofnamedElement
we will add it if multiplebefore [namedElement]
statements exist. Statements without[optionalPriority]
are added the farthest before the element.If
[namedElement]
does not exist, the element is added after allstart
positions.after [namedElement] [optionalPriority]
: add this element afternamedElement
; the higher the priority the more closely afternamedElement
we will add it if multipleafter [namedElement]
statements exist. Statements without[optionalPriority]
are added farthest after the element.If
[namedElement]
does not exist, the element is added before all allend
positions.
Example Ordering:
# in this example, we would not need to use any @position property; # as the default (document order) would then be used. However, the # order (o1 ... o9) is *always* fixed, no matter in which order the # individual statements are defined. myArray = Neos.Fusion:Array { o1 = Neos.NodeTypes:Text o1.@position = 'start 12' o2 = Neos.NodeTypes:Text o2.@position = 'start 5' o2 = Neos.NodeTypes:Text o2.@position = 'start' o3 = Neos.NodeTypes:Text o3.@position = '10' o4 = Neos.NodeTypes:Text o4.@position = '20' o5 = Neos.NodeTypes:Text o5.@position = 'before o6' o6 = Neos.NodeTypes:Text o6.@position = 'end' o7 = Neos.NodeTypes:Text o7.@position = 'end 20' o8 = Neos.NodeTypes:Text o8.@position = 'end 30' o9 = Neos.NodeTypes:Text o9.@position = 'after o8' }
If no @position
property is defined, the array key is used. However, we suggest
to use @position
and meaningful keys in your application, and not numeric ones.
Example of numeric keys (discouraged):
myArray = Neos.Fusion:Array { 10 = Neos.NodeTypes:Text 20 = Neos.NodeTypes:Text }
Render each item in collection
using itemRenderer
.
collection: | (array/Iterable, required) The array or iterable to iterate over |
---|---|
itemName: | (string, defaults to item ) Context variable name for each item |
itemKey: | (string, defaults to itemKey ) Context variable name for each item key, when working with array |
iterationName: | (string, defaults to iterator ) A context variable with iteration information will be available under the given name: index (zero-based), cycle (1-based), isFirst , isLast |
itemRenderer: | (string, required) The renderer definition (simple value, expression or object) will be called once for every collection element, and its results will be concatenated |
Example using an object itemRenderer
:
myCollection = Neos.Fusion:Collection { collection = ${[1, 2, 3]} itemName = 'element' itemRenderer = Neos.Fusion:Template { templatePath = 'resource://...' element = ${element} } }
Example using an expression itemRenderer
:
myCollection = Neos.Fusion:Collection { collection = ${[1, 2, 3]} itemName = 'element' itemRenderer = ${element * 2} }
Render each item in collection
using itemRenderer
and return the result as an array (opposed to string for :ref:`Neos_Fusion__Collection`)
collection: | (array/Iterable, required) The array or iterable to iterate over |
---|---|
itemName: | (string, defaults to item ) Context variable name for each item |
itemKey: | (string, defaults to itemKey ) Context variable name for each item key, when working with array |
iterationName: | (string, defaults to iterator ) A context variable with iteration information will be available under the given name: index (zero-based), cycle (1-based), isFirst , isLast |
itemRenderer: | (string, required) The renderer definition (simple value, expression or object) will be called once for every collection element |
Conditionally evaluate nested definitions.
Evaluates all nested definitions until the first condition
evaluates to TRUE
. The Case object will
evaluate to a result using either renderer
, renderPath
or type
on the matching definition.
[key]: | A matcher definition |
---|---|
[key].condition: | (boolean, required) A simple value, expression or object that will be used as a condition for this matcher |
[key].type: | (string) Object type to render (as string) |
[key].element.*: | (mixed) Properties for the rendered object (when using type ) |
[key].renderPath: | (string) Relative or absolute path to render, overrules type |
[key].renderer: | (mixed) Rendering definition (simple value, expression or object), overrules renderPath and type |
[key].@position: | (string/integer) Define the ordering of the nested definition |
Simple Example:
myCase = Neos.Fusion:Case { someCondition { condition = ${q(node).is('[instanceof MyNamespace:My.Special.SuperType]')} type = 'MyNamespace:My.Special.Type' } otherCondition { @position = 'start' condition = ${q(documentNode).property('layout') == 'special'} renderer = ${'<marquee>' + q(node).property('content') + '</marquee>'} } fallback { condition = ${true} renderPath = '/myPath' } }
The ordering of matcher definitions can be specified with the @position
property (see :ref:`Neos_Fusion__Array`).
Thus, the priority of existing matchers (e.g. the default Neos document rendering) can be changed by setting or
overriding the @position
property.
Note
The internal Neos.Fusion:Matcher
object type is used to evaluate the matcher definitions which
is based on the Neos.Fusion:Renderer
.
The Renderer object will evaluate to a result using either renderer
, renderPath
or type
from the configuration.
type: | (string) Object type to render (as string) |
---|---|
element.*: | (mixed) Properties for the rendered object (when using type ) |
renderPath: | (string) Relative or absolute path to render, overrules type |
renderer: | (mixed) Rendering definition (simple value, expression or object), overrules renderPath and type |
Simple Example:
myCase = Neos.Fusion:Renderer { type = 'Neos.Fusion:Value' element.value = 'hello World' }
Note
This is especially handy if the prototype that should be rendered is determined via eel or passed via @context.
Shows the result of Fusion Expressions directly.
title: | (optional) Title for the debug output |
---|---|
plaintext: | (boolean) If set true, the result will be shown as plaintext |
[key]: | (mixed) A nested definition (simple value, expression or object), [key] will be used as key for the resulting output |
Example:
debugObject = Debug { title = 'Debug of hello world' # If only the "value"-key is given it is debugged directly, # otherwise all keys except "title" and "plaintext" are debugged. value = "hello neos world" # Additional values for debugging documentTitle = ${q(documentNode).property('title')} documentPath = ${documentNode.path} } # the value of this object is the formatted debug output of all keys given to the object
Create a component that adds all properties to the props context and afterward evaluates the renderer.
renderer: | (mixed, required) The value which gets rendered |
---|
Example:
prototype(Vendor.Site:Component) < prototype(Neos.Fusion:Component) { title = 'Hello World' titleTagName = 'h1' description = 'Description of the Neos World' bold = false renderer = Neos.Fusion:Tag { attributes.class = Neos.Fusion:RawArray { component = 'component' bold = ${props.bold ? 'component--bold' : false} } content = Neos.Fusion:Array { headline = Neos.Fusion:Tag { tagName = ${props.titleTagName} content = ${props.title} } description = Neos.Fusion:Tag { content = ${props.description} } } } }
Modify given html content and add attributes. The augmenter can be used as processor or as a standalone prototype
content: | (string) The content that shall be augmented |
---|---|
fallbackTagName: | (string, defaults to div ) If no single tag that can be augmented is found the content is wrapped into the fallback-tag before augmentation |
[key]: | All other fusion properties are added to the html content as html attributes |
Example as a standalone augmenter:
augmentedContent = Neos.Fusion:Augmenter { content = Neos.Fusion:Array { title = Neos.Fusion:Tag { @if.hasContent = ${this.content} tagName = 'h2' content = ${q(node).property('title')} } text = Neos.Fusion:Tag { @if.hasContent = ${this.content} tagName = 'p' content = ${q(node).property('text')} } } fallbackTagName = 'header' class = 'header' data-foo = 'bar' }
Example as a processor augmenter:
augmentedContent = Neos.Fusion:Tag { tagName = 'h2' content = 'Hello World' @process.augment = Neos.Fusion:Augmenter { class = 'header' data-foo = 'bar' } }
Render a Fluid template specified by templatePath
.
templatePath: | (string, required) Path and filename for the template to be rendered, often a resource:// URI |
---|---|
partialRootPath: | (string) Path where partials are found on the file system |
layoutRootPath: | (string) Path where layouts are found on the file system |
sectionName: | (string) The Fluid <f:section> to be rendered, if given |
[key]: | (mixed) All remaining properties are directly passed into the Fluid template as template variables |
Example:
myTemplate = Neos.Fusion:Template { templatePath = 'resource://My.Package/Private/Templates/FusionObjects/MyTemplate.html' someDataAvailableInsideFluid = 'my data' } <div class="hero"> {someDataAvailableInsideFluid} </div>
Evaluate any value as a Fusion object
value: | (mixed, required) The value to evaluate |
---|
Example:
myValue = Neos.Fusion:Value { value = 'Hello World' }
Note
Most of the time this can be simplified by directly assigning the value instead of using the Value
object.
Evaluate nested definitions as an array (opposed to string for :ref:`Neos_Fusion__Array`)
[key]: | (mixed) A nested definition (simple value, expression or object), [key] will be used for the resulting array key |
---|---|
[key].@position: | (string/integer) Define the ordering of the nested definition |
Tip
For simple cases an expression with an array literal ${[1, 2, 3]}
might be easier to read
Render an HTML tag with attributes and optional body
tagName: | (string) Tag name of the HTML element, defaults to div |
---|---|
omitClosingTag: | (boolean) Whether to render the element content and the closing tag, defaults to FALSE |
selfClosingTag: | (boolean) Whether the tag is a self-closing tag with no closing tag. Will be resolved from tagName by default, so default HTML tags are treated correctly. |
content: | (string) The inner content of the element, will only be rendered if the tag is not self-closing and the closing tag is not omitted |
attributes: | (:ref:`Neos_Fusion__Attributes`) Tag attributes |
htmlTag = Neos.Fusion:Tag { tagName = 'html' omitClosingTag = TRUE attributes { version = 'HTML+RDFa 1.1' xmlns = 'http://www.w3.org/1999/xhtml' } }
Evaluates to:
<html version="HTML+RDFa 1.1" xmlns="http://www.w3.org/1999/xhtml">
A Fusion object to render HTML tag attributes. This object is used by the :ref:`Neos_Fusion__Tag` object to render the attributes of a tag. But it's also useful standalone to render extensible attributes in a Fluid template.
[key]: | (string) A single attribute, array values are joined with whitespace. Boolean values will be rendered as an empty or absent attribute. |
---|---|
@allowEmpty: | (boolean) Whether empty attributes (HTML5 syntax) should be used for empty, false or null attribute values |
attributes = Neos.Fusion:Attributes { foo = 'bar' class = Neos.Fusion:RawArray { class1 = 'class1' class2 = 'class2' } }
Evaluates to:
foo="bar" class="class1 class2"
It's possible to unset an attribute by assigning false
or ${null}
as a value. No attribute will be rendered for
this case.
A prototype based on :ref:`Neos_Fusion__Array` for rendering an HTTP message (response). It should be used to render documents since it generates a full HTTP response and allows to override the HTTP status code and headers.
httpResponseHead: | (:ref:`Neos_Fusion__Http_ResponseHead`) An HTTP response head with properties to adjust the status and headers, the position in the Array defaults to the very beginning |
---|---|
[key]: | (string) A nested definition (see :ref:`Neos_Fusion__Array`) |
// Page extends from Http.Message // // prototype(Neos.Neos:Page) < prototype(Neos.Fusion:Http.Message) // page = Neos.Neos:Page { httpResponseHead.headers.Content-Type = 'application/json' }
A helper object to render the head of an HTTP response
statusCode: | (integer) The HTTP status code for the response, defaults to 200 |
---|---|
headers.*: | (string) An HTTP header that should be set on the response, the property name (e.g. headers.Content-Type ) will be used for the header name |
Built a URI to a controller action
package: | (string) The package key (e.g. 'My.Package' ) |
---|---|
subpackage: | (string) The subpackage, empty by default |
controller: | (string) The controller name (e.g. 'Registration' ) |
action: | (string) The action name (e.g. 'new' ) |
arguments: | (array) Arguments to the action by named key |
format: | (string) An optional request format (e.g. 'html' ) |
section: | (string) An optional fragment (hash) for the URI |
additionalParams: | (array) Additional URI query parameters by named key |
addQueryString: | (boolean) Whether to keep the query parameters of the current URI |
argumentsToBeExcludedFromQueryString: | (array) Query parameters to exclude for addQueryString |
absolute: | (boolean) Whether to create an absolute URI |
Example:
uri = Neos.Fusion:UriBuilder { package = 'My.Package' controller = 'Registration' action = 'new' }
Build a URI to a static or persisted resource
path: | (string) Path to resource, either a path relative to Public and package or a resource:// URI |
---|---|
package: | (string) The package key (e.g. 'My.Package' ) |
resource: | (Resource) A Resource object instead of path and package |
localize: | (boolean) Whether resource localization should be used, defaults to true |
Example:
scriptInclude = Neos.Fusion:Tag { tagName = 'script' attributes { src = Neos.Fusion:ResourceUri { path = 'resource://My.Package/Public/Scripts/App.js' } } }
Check whether a Fusion prototype can be rendered. For being renderable a prototype must exist and have an implementation class, or inherit from an existing renderable prototype. The implementation class can be defined indirectly via base prototypes.
type: | (string) The prototype name that is checked |
---|
Example:
canRender = Neos.Fusion:CanRender { type = 'My.Package:Prototype' }
The Fusion objects defined in the Neos package contain all Fusion objects which are needed to integrate a site. Often, it contains generic Fusion objects which do not need a particular node type to work on.
Subclass of :ref:`Neos_Fusion__Http_Message`, which is based on :ref:`Neos_Fusion__Array`. Main entry point
into rendering a page; responsible for rendering the <html>
tag and everything inside.
doctype: | (string) Defaults to <!DOCTYPE html> |
---|---|
htmlTag: | (:ref:`Neos_Fusion__Tag`) The opening <html> tag |
htmlTag.attributes: | (:ref:`Neos_Fusion__Attributes`) Attributes for the <html> tag |
headTag: | (:ref:`Neos_Fusion__Tag`) The opening <head> tag |
head: | (:ref:`Neos_Fusion__Array`) HTML markup for the <head> tag |
head.titleTag: | (:ref:`Neos_Fusion__Tag`) The <title> tag |
head.javascripts: | (:ref:`Neos_Fusion__Array`) Script includes in the head should go here |
head.stylesheets: | (:ref:`Neos_Fusion__Array`) Link tags for stylesheets in the head should go here |
body.templatePath: | (string) Path to a fluid template for the page body |
bodyTag: | (:ref:`Neos_Fusion__Tag`) The opening <body> tag |
bodyTag.attributes: | (:ref:`Neos_Fusion__Attributes`) Attributes for the <body> tag |
body: | (:ref:`Neos_Fusion__Template`) HTML markup for the <body> tag |
body.javascripts: | (:ref:`Neos_Fusion__Array`) Body footer JavaScript includes |
body.[key]: | (mixed) Body template variables |
page = Page page.body.templatePath = 'resource://My.Package/Private/MyTemplate.html' // the following line is optional, but recommended for base CSS inclusions etc page.body.sectionName = 'main'
Fusion:
page.body { sectionName = 'body' content.main = PrimaryContent { nodePath = 'main' } }
Fluid:
<html> <body> <f:section name="body"> <div class="container"> {content.main -> f:format.raw()} </div> </f:section> </body> </html
page.head.stylesheets.mySite = Neos.Fusion:Template { templatePath = 'resource://My.Package/Private/MyTemplate.html' sectionName = 'stylesheets' }
page.bodyTag.attributes.class = 'body-css-class1 body-css-class2'
Render nested content from a ContentCollection
node. Individual nodes are rendered using the
:ref:`Neos_Neos__ContentCase` object.
nodePath: | (string, required) The relative node path of the ContentCollection (e.g. 'main' ) |
---|---|
@context.node: | (Node) The content collection node, resolved from nodePath by default |
tagName: | (string) Tag name for the wrapper element |
attributes: | (:ref:`Neos_Fusion__Attributes`) Tag attributes for the wrapper element |
Example:
page.body { content { main = Neos.Neos:PrimaryContent { nodePath = 'main' } footer = Neos.Neos:ContentCollection { nodePath = 'footer' } } }
Primary content rendering, extends :ref:`Neos_Fusion__Case`. This is a prototype that can be used from packages to extend the default content rendering (e.g. to handle specific document node types).
nodePath: | (string, required) The relative node path of the ContentCollection (e.g. 'main' ) |
---|---|
default: | Default matcher that renders a ContentCollection |
[key]: | Additional matchers (see :ref:`Neos_Fusion__Case`) |
Example for basic usage:
page.body { content { main = Neos.Neos:PrimaryContent { nodePath = 'main' } } }
Example for custom matcher:
prototype(Neos.Neos:PrimaryContent) { myArticle { condition = ${q(node).is('[instanceof My.Site:Article]')} renderer = My.Site:ArticleRenderer } }
Render a content node, extends :ref:`Neos_Fusion__Case`. This is a prototype that is used by the default content rendering (:ref:`Neos_Neos__ContentCollection`) and can be extended to add custom matchers.
default: | Default matcher that renders a prototype of the same name as the node type name |
---|---|
[key]: | Additional matchers (see :ref:`Neos_Fusion__Case`) |
Base type to render content nodes, extends :ref:`Neos_Fusion__Template`. This prototype is extended by the
auto-generated Fusion to define prototypes for each node type extending Neos.Neos:Content
.
templatePath: | (string) The template path and filename, defaults to 'resource://[packageKey]/Private/Templates/NodeTypes/[nodeType].html' (for auto-generated prototypes) |
---|---|
[key]: | (mixed) Template variables, all node type properties are available by default (for auto-generated prototypes) |
attributes: | (:ref:`Neos_Fusion__Attributes`) Extensible attributes, used in the default templates |
Example:
prototype(My.Package:MyContent) < prototype(Neos.Neos:Content) { templatePath = 'resource://My.Package/Private/Templates/NodeTypes/MyContent.html' # Auto-generated for all node type properties # title = ${q(node).property('title')} }
Base type to render component based content-nodes, extends :ref:`Neos_Fusion__Component`.
renderer: | (mixed, required) The value which gets rendered |
---|
Create an editable tag for a property. In the frontend, only the content of the property gets rendered.
node: | (node) A node instance that should be used to read the property. Default to ${node} |
---|---|
property: | (string) The name of the property which should be accessed |
block: | (boolean) Decides if the editable tag should be a block element (div) or an inline element (span). Default to true |
Example:
title = Neos.Neos:Editable { property = 'title' block = false }
Base type to render plugin content nodes or static plugins. A plugin is a Flow controller that can implement arbitrary logic.
package: | (string, required) The package key (e.g. 'My.Package') |
---|---|
subpackage: | (string) The subpackage, defaults to empty |
controller: | (array) The controller name (e.g. 'Registration') |
action: | (string) The action name, defaults to 'index' |
argumentNamespace: | (string) Namespace for action arguments, will be resolved from node type by default |
[key]: | (mixed) Pass an internal argument to the controller action (access with argument name _key ) |
Example:
prototype(My.Site:Registration) < prototype(Neos.Neos:Plugin) { package = 'My.Site' controller = 'Registration' }
Render a menu with items for nodes. Extends :ref:`Neos_Fusion__Template`.
templatePath: | (string) Override the template path |
---|---|
entryLevel: | (integer) Start the menu at the given depth |
maximumLevels: | (integer) Restrict the maximum depth of items in the menu (relative to entryLevel ) |
startingPoint: | (Node) The parent node of the first menu level (defaults to node context variable) |
lastLevel: | (integer) Restrict the menu depth by node depth (relative to site node) |
filter: | (string) Filter items by node type (e.g. '!My.Site:News,Neos.Neos:Document' ), defaults to 'Neos.Neos:Document' |
renderHiddenInIndex: | (boolean) Whether nodes with hiddenInIndex should be rendered, defaults to false |
itemCollection: | (array) Explicitly set the Node items for the menu (alternative to startingPoints and levels) |
attributes: | (:ref:`Neos_Fusion__Attributes`) Extensible attributes for the whole menu |
normal.attributes: | (:ref:`Neos_Fusion__Attributes`) Attributes for normal state |
active.attributes: | (:ref:`Neos_Fusion__Attributes`) Attributes for active state |
current.attributes: | (:ref:`Neos_Fusion__Attributes`) Attributes for current state |
node: | (Node) A node instance (with resolved shortcuts) that should be used to link to the item |
---|---|
originalNode: | (Node) Original node for the item |
state: | (string) Menu state of the item: 'normal' , 'current' (the current node) or 'active' (ancestor of current node) |
label: | (string) Full label of the node |
menuLevel: | (integer) Menu level the item is rendered on |
menu = Neos.Neos:Menu { entryLevel = 1 maximumLevels = 3 templatePath = 'resource://My.Site/Private/Templates/FusionObjects/MyMenu.html' }
menu = Neos.Neos:Menu { itemCollection = ${q(site).add(q(site).children('[instanceof Neos.Neos:Document]')).get()} }
menu = Neos.Neos:Menu { entryLevel = 2 maximumLevels = 1 startingPoint = ${q(site).children('[uriPathSegment="metamenu"]').get(0)} }
Render a breadcrumb (ancestor documents), based on :ref:`Neos_Neos__Menu`.
Example:
breadcrumb = Neos.Neos:BreadcrumbMenu
Create links to other node variants (e.g. variants of the current node in other dimensions) by using this Fusion object.
If the dimension
setting is given, the menu will only include items for this dimension, with all other configured
dimension being set to the value(s) of the current node. Without any dimension
being configured, all possible
variants will be included.
If no node variant exists for the preset combination, a NULL
node will be included in the item with a state absent
.
dimension: | (optional, string): name of the dimension which this menu should be based on. Example: "language". |
---|---|
presets: | (optional, array): If set, the presets rendered will be taken from this list of preset identifiers |
includeAllPresets: | (boolean, default false) If TRUE, include all presets, not only allowed combinations |
renderHiddenInIndex: | (boolean, default true) If TRUE, render nodes which are marked as "hidded-in-index" |
In the template for the menu, each item
has the following properties:
node: | (Node) A node instance (with resolved shortcuts) that should be used to link to the item |
---|---|
state: | (string) Menu state of the item: normal , current (the current node), absent |
label: | (string) Label of the item (the dimension preset label) |
menuLevel: | (integer) Menu level the item is rendered on |
dimensions: | (array) Dimension values of the node, indexed by dimension name |
targetDimensions: | (array) The target dimensions, indexed by dimension name and values being arrays with value , label and isPinnedDimension |
Note
The DimensionMenu
is an alias to DimensionsMenu
, available for compatibility reasons only.
Minimal Example, outputting a menu with all configured dimension combinations:
variantMenu = Neos.Neos:DimensionsMenu
This example will create two menus, one for the 'language' and one for the 'country' dimension:
languageMenu = Neos.Neos:DimensionsMenu { dimension = 'language' } countryMenu = Neos.Neos:DimensionsMenu { dimension = 'country' }
If you only want to render a subset of the available presets or manually define a specific order for a menu, you can override the "presets":
languageMenu = Neos.Neos:DimensionsMenu { dimension = 'language' presets = ${['en_US', 'de_DE']} # no matter how many languages are defined, only these two are displayed. }
In some cases, it can be good to ignore the availability of variants when rendering a dimensions menu. Consider a situation with two independent menus for country and language, where the following variants of a node exist (language / country):
- english / Germany
- german / Germany
- english / UK
If the user selects UK, only english will be linked in the language selector. German is only available again, if the
user switches back to Germany first. This can be changed by setting the includeAllPresets
option:
languageMenu = Neos.Neos:DimensionsMenu { dimension = 'language' includeAllPresets = true }
Now the language menu will try to find nodes for all languages, if needed the menu items will point to a different country than currently selected. The menu tries to find a node to link to by using the current preset for the language (in this example) and the default presets for any other dimensions. So if fallback rules are in place and a node can be found, it is used.
Note
The item.targetDimensions
will contain the "intended" dimensions, so that information can be used to
inform the user about the potentially unexpected change of dimensions when following such a link.
Only if the current node is not available at all (even after considering default presets with their fallback rules),
no node be assigned (so no link will be created and the items will have the absent
state.)
Build a URI to a node. Accepts the same arguments as the node link/uri view helpers.
node: | (string/Node) A node object or a node path (relative or absolute) or empty to resolve the current document node |
---|---|
format: | (string) An optional request format (e.g. 'html' ) |
section: | (string) An optional fragment (hash) for the URI |
additionalParams: | (array) Additional URI query parameters. |
argumentsToBeExcludedFromQueryString: | (array) Query parameters to exclude for addQueryString |
addQueryString: | (boolean) Whether to keep current query parameters, defaults to FALSE |
absolute: | (boolean) Whether to create an absolute URI, defaults to FALSE |
baseNodeName: | (string) Base node context variable name (for relative paths), defaults to 'documentNode' |
Example:
nodeLink = Neos.Neos:NodeUri { node = ${q(node).parent().get(0)} }
Get a URI to a (thumbnail) image for an asset.
asset: | (Asset) An asset object (Image , ImageInterface or other AssetInterface ) |
---|---|
width: | (integer) Desired width of the image |
maximumWidth: | (integer) Desired maximum height of the image |
height: | (integer) Desired height of the image |
maximumHeight: | (integer) Desired maximum width of the image |
allowCropping: | (boolean) Whether the image should be cropped if the given sizes would hurt the aspect ratio, defaults to FALSE |
allowUpScaling: | (boolean) Whether the resulting image size might exceed the size of the original image, defaults to FALSE |
async (boolean): | Return asynchronous image URI in case the requested image does not exist already, defaults to FALSE |
preset: | (string) Preset used to determine image configuration, if set all other resize attributes will be ignored |
Example:
logoUri = Neos.Neos:ImageUri { asset = ${q(node).property('image')} width = 100 height = 100 allowCropping = TRUE allowUpScaling = TRUE }
Render an image tag for an asset.
*: | All :ref:`Neos_Neos__ImageUri` properties |
---|---|
attributes: | (:ref:`Neos_Fusion__Attributes`) Image tag attributes |
Example:
logoImage = Neos.Neos:ImageTag { asset = ${q(node).property('image')} maximumWidth = 400 attributes.alt = 'A company logo' }
Convert internal node and asset URIs (node://...
or asset://...
) in a string to public URIs and allows for
overriding the target attribute for external links and resource links.
value: | (string) The string value, defaults to the value context variable to work as a processor by default |
---|---|
node: | (Node) The current node as a reference, defaults to the node context variable |
externalLinkTarget: | (string) Override the target attribute for external links, defaults to _blank . Can be disabled with an empty value. |
resourceLinkTarget: | (string) Override the target attribute for resource links, defaults to _blank . Can be disabled with an empty value. |
forceConversion: | (boolean) Whether to convert URIs in a non-live workspace, defaults to FALSE |
absolute: | (boolean) Can be used to convert node URIs to absolute links, defaults to FALSE |
Example:
prototype(My.Site:Special.Type) { title.@process.convertUris = Neos.Neos:ConvertUris }
Processor to augment rendered HTML code with node metadata that allows the Neos UI to select the node and show
node properties in the inspector. This is especially useful if your renderer prototype is not derived from Neos.Neos:Content
.
The processor expects being applied on HTML code with a single container tag that is augmented.
node: | (Node) The node of the content element. Optional, will use the Fusion context variable node by default. |
---|
Example:
prototype(Vendor.Site:ExampleContent) { value = '<div>Example</div>' # The following line must not be removed as it adds required meta data # to edit content elements in the backend @process.contentElementWrapping = Neos.Neos:ContentElementWrapping { @position = 'end' } }
Processor to augment an HTML tag with metadata for inline editing to make a rendered representation of a property editable.
The processor expects beeing applied to an HTML tag with the content of the edited property.
node: | (Node) The node of the content element. Optional, will use the Fusion context variable node by default. |
---|---|
property: | (string) Node property that should be editable |
Example:
renderer = Neos.Fusion:Tag { tagName = 'h1' content = ${q(node).property('title')} @process.contentElementEditableWrapping = Neos.Neos:ContentElementEditable { property = 'title' } }