New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

FEATURE: Add Fusion prototypes `Join`, `Loop`, `Map`, `Reduce` and `DataStructure` #2189

Merged
merged 1 commit into from Nov 5, 2018

Conversation

Projects
8 participants
@mficzel
Copy link
Member

mficzel commented Sep 21, 2018

The difference between RawArray, Array, RawCollection and Collection was often hard to get for new developers. To overcome this, the old confusing names are deprecated, and new prototypes are introduced which are easier to understand and emphasize the declarative nature of Fusion.

Neos.Fusion:Join

The prototype concatenates the fusion values of all fusion-properties and returns the result as a string. This prototype replaces Neos.Fusion:Array which is deprecated.

In addition to the behavior of the Array Join allows to define the @glue used for concatenating the parts.

Neos.Fusion:Loop

The Loop prototype iterates over the given items with the itemRenderer and returns the concatenated result as a string. The prototype replaces Neos.Fusion:Collection which is deprecated.

Other than in Collection the items are passed with the key items instead of collection.

In addition to the behavior of the classic Collection Loop allows defining the @glue used for concatenating the items.

Neos.Fusion:DataStructure

The DataStructure prototype returns an associative array with all fusion keys evaluated. The prototype replaces Neos.Fusion:RawArray which is deprecated.

Neos.Fusion:Map

The Map iterates over the given items and returns the result as an array. The prototype replaces Neos.Fusion:RawCollection which is deprecated.

Other than RawCollection the items are passed with the key items instead of collection and the keys of the given items are preserved.

Neos.Fusion:Reduce

The Neos.Fusion:Reduce prototype is added which reduces the given items to a single value by using itemRenderer with the following properties.

  • items (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 an array
  • carryName: (string, defaults to carry) Context variable that contains the result of the last iteration
  • 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
  • itemReducer: (mixed, required) The reducer definition (simple value, expression or object) that will be applied for every item.
  • initialValue: (mixed, defaults to null) The value that is passed to the first iteration or returned if the items are empty

@mficzel mficzel force-pushed the mficzel:feature/replaceConfusingRawFusionPrototypes branch 2 times, most recently from a1d71ad to 7b23a04 Sep 21, 2018

@@ -364,6 +424,21 @@ Evaluate nested definitions as an array (opposed to *string* for :ref:`Neos_Fusi

.. tip:: For simple cases an expression with an array literal ``${[1, 2, 3]}`` might be easier to read

.. note:: The Neos.Fusion:RawArray object has been renamed to Neos.Fusion:Dictionary the old name is <b>(DEPRECATED)</b>

This comment has been minimized.

@daniellienert

daniellienert Sep 21, 2018

Member

Is <b> intended here?

This comment has been minimized.

@mficzel

mficzel Sep 21, 2018

Member

I simply found that in another deprecation notice. Not much intention from my side other than that

@@ -18,6 +18,7 @@
*
* //tsPath collection *Collection
* //tsPath itemRenderer the TS object which is triggered for each element in the node collection
* @deprecated since Neos 4.2 in favor of IterationImplementation

This comment has been minimized.

@daniellienert

daniellienert Sep 21, 2018

Member

Would be good to name the version, where it will be removed (5.0 ?)

This comment has been minimized.

@mficzel

mficzel Sep 24, 2018

Member

I am not sure. I think we should allow some time util we remove those prototypes since.

This comment has been minimized.

@jonnitto

jonnitto Oct 31, 2018

Member

I would wait until version 6 since it is a massive change. Especially for package developer: They would have to handle multiple versions. If we remove it later, the transition would be smoother

This comment has been minimized.

@albe

albe Oct 31, 2018

Member

Doesn't a simple renaming code migration solve the major issue? AFAIS the usages are fully b/c otherwise apart from the namechange, no?

@@ -106,6 +117,8 @@ Render each item in ``collection`` using ``itemRenderer``.
: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

.. note:: The Neos.Fusion:Collection object is <b>(DEPRECATED)</b> use Neos.Fusion:Iteration instead.

This comment has been minimized.

@daniellienert

daniellienert Sep 21, 2018

Member

Is <b> intended here?

@daniellienert

This comment has been minimized.

Copy link
Member

daniellienert commented Sep 21, 2018

Hey @mficzel,
Thats a good idea! Thanks. It so sad that array is taken by the wrong thing. Dictionary is an unknown term both in PHP and JS - but I wasn't able to find something better.

Have you thought about writing migrations?

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Sep 21, 2018

No migrations yet as I plan to introduce this as a feature in 4.2. Migrations should be in 5.0 when we remove the old names and also adjust the fusion code in the Neos.Neos package. For now this is just an extra option

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Sep 21, 2018

Maybe it is wise if we still keep the names until 6.0 but add the migrations at still in version 5 and stop using the old names

@dimaip

This comment has been minimized.

Copy link
Member

dimaip commented Sep 24, 2018

Wow, great initiative!
The naming sounds a bit weird to me, but it may be hard to come up with anything much better.
Concat is a good name, nothing against it.
Iteration is not just an abstract iteration, but actually mapping + concat, so could be great if they were named somehow similarly.
Dictionary is an unfamiliar term, but not sure if there are better alternatives either, since both collection and array are already taken.

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Sep 24, 2018

@dimaip Iteration makes a lot of sense in AFX but i am totally open to better names. I also plan to add a Reduction prototype soonish.

@dimaip

This comment has been minimized.

Copy link
Member

dimaip commented Sep 24, 2018

Yep, as said, I don't have anything better to offer, so I just shared my concerns. Maybe somebody would have ideas, if not we could leave it as you suggest.

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Sep 24, 2018

@dimaip

This comment has been minimized.

Copy link
Member

dimaip commented Sep 24, 2018

Ah, already forgot about that discussion. But there was an idea to rename RawArray into Map, why did you give up on it?

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Sep 24, 2018

@dimaip Map is not an established term at all. But Dictionary may not be common in JS or PHP but in computer science in general it is a well known concept.

From JS Object would be correct but this would lead to talking about the Object-FusionObject and cause even more confusion. Another candidate would be Shape but this is only common in the react-world and would cause confusion for otthers aswell.

@dimaip

This comment has been minimized.

Copy link
Member

dimaip commented Sep 24, 2018

Map is a JS data type (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) and also called this way in other programming languages (e.g. Java). It definitely sounds more familiar to my ear than Dictionary.

@mficzel mficzel force-pushed the mficzel:feature/replaceConfusingRawFusionPrototypes branch from 9618b15 to e3f2b69 Sep 25, 2018

@mficzel mficzel changed the title FEATURE: Add Fusion prototypes `Concat`, `Dictionary`, `Mapping` and `Iteration` FEATURE: Add Fusion prototypes `Concat`, `Dictionary`, `Mapping`, `Iteration` and `Reduction` Sep 25, 2018

@mficzel mficzel force-pushed the mficzel:feature/replaceConfusingRawFusionPrototypes branch from 0c7320b to 23e8a89 Sep 26, 2018

@mficzel mficzel changed the title FEATURE: Add Fusion prototypes `Concat`, `Dictionary`, `Mapping`, `Iteration` and `Reduction` FEATURE: Add Fusion prototypes `Concatention`, `Dictionary`, `Mapping`, `Iteration` and `Reduction` Sep 26, 2018

@mficzel mficzel requested a review from grebaldi Sep 26, 2018

@mficzel mficzel changed the title FEATURE: Add Fusion prototypes `Concatention`, `Dictionary`, `Mapping`, `Iteration` and `Reduction` FEATURE: Add Fusion prototypes `Concatenation`, `Dictionary`, `Mapping`, `Iteration` and `Reduction` Sep 26, 2018

@mficzel mficzel force-pushed the mficzel:feature/replaceConfusingRawFusionPrototypes branch 2 times, most recently from 41bd54c to f38463e Sep 26, 2018

@mficzel mficzel removed the I: WIP label Sep 27, 2018

@albe
Copy link
Member

albe left a comment

One thing that kind of bugs me:

Concatenation, Mapping, Iteration, Reduction are all names for a process. Dictionary is a name for a structure. This some how feels out of line.

While looking at the code, I noticed that Dictionary is actually about sorting the elements. So what about calling it Sorting? (see also other comment as to why that might further sense)

/**
* Evaluate sub objects to an array (instead of a string as ConcatImplementation does)
*/
class DictionaryImplementation extends ArrayImplementation

This comment has been minimized.

@albe

albe Sep 28, 2018

Member

Shouldn't DictionaryImplementation extend ConcatenationImplementation directly, instead of the deprecated ArrayImplementation? But then again, a Dictionary really isn't a Concatenation in any way, so this hints at some improper naming or inheritance. So what's the common ground? The sorting. Actually, Dictionary doesn't do much else. What about Dictionary becoming a Sorting and Concatenation extending that?

This comment has been minimized.

@mficzel

mficzel Sep 28, 2018

Member

@albe the names try to describe the expected result instead of the operation or process. Imho this is what reflects the declarative nature of fusion best.

@mficzel mficzel force-pushed the mficzel:feature/replaceConfusingRawFusionPrototypes branch from ee7325a to 33475e2 Sep 28, 2018

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Sep 28, 2018

@albe Thank you for the hint regarding inheritence, i adjusted the code accordingly. The reason why it looked like this in the first place was that RawArray also was based on array. A good time to fix this.

Regarding the naming i tried to name the objects after the expected result and not the process or the operation. That is why i ended up with Dictionary.

In general i think we should emphasize the declarative nature of fusion way more. Fusion Objects encapsulate the imperative logic and allow the Integrators to declare the requirements.

@albe

This comment has been minimized.

Copy link
Member

albe commented Sep 28, 2018

Thanks. That looks better already. So what actually speaks against Sorting? The result is a sorted associative array. Does it not fit? I'm not really deep into Fusion, so maybe I miss something.

@danielkestler

This comment has been minimized.

Copy link

danielkestler commented Oct 4, 2018

Leaving backwards compatibility aside, just some ideas:

Neos.Fusion:Array and Neos.Fusion:ArrayString
Neos.Fusion:Iteration and Neos.Fusion:IterationString

... or ...ToString / ...AsString / ...StringRepresentation?

@danielkestler

This comment has been minimized.

Copy link

danielkestler commented Oct 4, 2018

We could also leave the string variants behind and promote to use a Stringify-processor.

@kitsunet

This comment has been minimized.

Copy link
Member

kitsunet commented Oct 4, 2018

We could also leave the string variants behind and promote to use a Stringify-processor.

I like that idea. Alternatively Concatenation could also be something like a Join or JoinStrings.

Although Concatenation works fine for me.

Neos.Fusion:Dictionary could maybe be a DataStructure? That is pretty straight forward and not as theoretical or even a DataObject. Or KeyValueMap, just to throw in some more options. I don't dislike Dictionary but I feel it's rather abstract and theoretical.

Technically Iteration is a specialised Reduction right? That feels slightly off. Maybe very expressive RenderAndJoin. I think Iteration is the one I am most on the fence about but also the one I really have no great idea about... I will let it sink a bit more.

Mapping works pretty nicely I think. Reduction also works fine IMHO. Not sure about performance and caching implications, but seems like a nice addition.

@kitsunet

This comment has been minimized.

Copy link
Member

kitsunet commented Oct 4, 2018

Additional note. We must make sure we don't make it all too technical. Fusion is meant to be an integrators tool after all. Yes you would usually expect some JS knowledge and with that an understanding for the used terminology BUT I would try to avoid making it too technical if possible. :)

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Oct 5, 2018

@kitsunet DataStructure sounds nice for me aswell. If others like it too i will adjust the code.

Regarding Concatenation vs Join i think that the latter should offer a glue-option wich will not work with the current way we use Fusion Array. If we have an idea how to configure the glue (maybe via @context.glue="") we should make it configurable and maybe use Join. However Join does not describe the result but the operation so we should look at it from the integration standpoint and describe the result.

For the Iteration it is the same. The most important question for me is what looks intuitive in afx when we do things like this:

<ul><Neos.Fusion:Iteration items={props.item}>
  <li @path="itemRenderer">{item.title}</li>
</Neos.Fusion:Iteration></ul>
@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Oct 5, 2018

An option that just came to my mind as possible alternative to Iteration is Loop that would look like this.

<ul><Neos.Fusion:Loop items={props.item}>
  <li @path="itemRenderer">{item.title}</li>
</Neos.Fusion:Loop></ul>

I would love to support content as fallback to itemRenderer to avoid the @children or @path annotation.

@kitsunet

This comment has been minimized.

Copy link
Member

kitsunet commented Oct 24, 2018

@mficzel why wouldn't the Join thing work with how we use array? We could just add the glue option with a default that is the same that we do internally at the moment.

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Oct 25, 2018

@kitsunet we expect all keys of an arrayFusionObject to be rendered so there is no possible key we can use to define the glue for the join. It also feels wrong to have an api where all keys but glue do not matter.

I would consider a configureable glue important for a thing called Join but not for a Concatenation. However if we have a good idea how to configure the glue calling the thing Join is a good idea.

@bwaidelich

This comment has been minimized.

Copy link
Member

bwaidelich commented Oct 25, 2018

I agree that we should look at this from the integrators point of view to find out what "feels" right and obviously don't use technical terms for something they don't represent.

To wrap my head around this I had to come up with a (frankly somewhat wacky) example that uses the prototypes in question:
A person component that renders the full name and a list of friends

Today

prototype(My.Package:Person) < prototype(Neos.Fusion:Component) {
    givenName = ''
    familyName = ''
    friends = Neos.Fusion:RawArray

    renderer = afx`
        <section>
            <h1><My.Package:Person.Name givenName={props.givenName} familyName={props.familyName} /></h1>
            <ul @if.hasFriends="{!Array.empty(props.friends)}">
                <Neos.Fusion:Collection collection={props.friends} itemName="friend" @children="itemRenderer">
                    <li><My.Package:Person.Name givenName={friend.givenName} familyName={friend.familyName} /></li>
                </Neos.Fusion:Collection>
            </ul>
        </section>
    `
}

prototype(My.Package:Person.Name) < prototype(Neos.Fusion:Component) {
    givenName = ''
    familyName = ''

    renderer = Neos.Fusion:Array {
        givenName = ${props.givenName}
        space = ' '
        space.@if.hasFamilyName = ${props.familyName}
        familyName = ${props.familyName}
    }
}

Usage:

root = My.Package:Person {
    givenName = ${q(personNode).property('givenName')}
    familyName = ${q(personNode).property('familyName')}
    friends = Neos.Fusion:RawCollection {
        collection = ${q(personNode).property('friends')}
        itemName = 'friendNode'
        itemRenderer = Neos.Fusion:RawArray {
            givenName = ${q(friendNode).property('givenName')}
            familyName = ${q(friendNode).property('givenName')}
        }
    }
}

Suggestion

prototype(My.Package:Person) < prototype(Neos.Fusion:Component) {
    givenName = ''
    familyName = ''
    friends = ${[]}

    renderer = afx`
        <section>
            <h1><My.Package:Person.Name givenName={props.givenName} familyName={props.familyName} /></h1>
            <ul @if.hasFriends="{!Array.empty(props.friends)}">
                <Neos.Fusion:Loop items={props.friends} itemName="friend">
                    <li><My.Package:Person.Name givenName={friend.givenName} familyName={friend.familyName} /></li>
                </Neos.Fusion:Loop>
            </ul>
        </section>
    `
}

prototype(My.Package:Person.Name) < prototype(Neos.Fusion:Component) {
    givenName = ''
    familyName = ''

    renderer = Neos.Fusion:Concat {
        givenName = ${props.givenName}
        space = ' '
        space.@if.hasFamilyName = ${props.familyName}
        familyName = ${props.familyName}
    }
}

Usage:

root = My.Package:Person {
    givenName = ${q(personNode).property('givenName')}
    familyName = ${q(personNode).property('familyName')}
    friends = Neos.Fusion:Mapping {
        collection = ${q(personNode).property('friends')}
        itemName = 'friendNode'
        itemRenderer = Neos.Fusion:Dictionary {
            givenName = ${q(friendNode).property('givenName')}
            familyName = ${q(friendNode).property('givenName')}
        }
    }
}

My feelings after this experiment

  • Loop works very well for me (but Iteration would be fine, too)
  • I like Concat as replacement for Array (but Join would work, too. And some "glue" would be nice for either and would make the space.@if condition above obsolete. But IMO that could be added as a separate feature)
  • I prefer Dictionary over Map for the reason mentioned here

One more point regarding the latter:
I replaced the friends = Neos.Fusion:RawArray with friends = ${[]} above because Dictionary would be very confusing there.
That made me think: Maybe we can add a similar syntactic sugar for associative arrays to Fusion:

 itemRenderer = Neos.Fusion:Dictionary {
  givenName = //...
  familyName = //...
}

=>

 itemRenderer = {
  givenName = //...
  familyName = //...
}

but that's out of scope of this change

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Oct 25, 2018

In a hangout we agreed on the following names

Neos.Fusion:Array => Neos.Fusion:Join (with @glue)
Neos.Fusion:Collection => Neos.Fusion:Loop (with @glue, collection > items)
Neos.Fusion:RawArray => Neos.Fusion:DataStructure
Neos.Fusion:RawCollection => Neos.Fusion:Map (collection > items)
---  new --- => Neos.Fusion:Reduce 

I will adjust the pr sonnish to that

@bwaidelich

This comment has been minimized.

Copy link
Member

bwaidelich commented Oct 25, 2018

^ as discussed with @mficzel @kitsunet and @danielkestler

PS: @mficzel the (collection > items) at DataStructure belongs to Loop :)

With the suggested names, my example above would look like this:

prototype(My.Package:Person) < prototype(Neos.Fusion:Component) {
    givenName = ''
    familyName = ''
    friends = ${[]}

    renderer = afx`
        <section>
            <h1><My.Package:Person.Name givenName={props.givenName} familyName={props.familyName} /></h1>
            <ul @if.hasFriends="{!Array.empty(props.friends)}">
                <Neos.Fusion:Loop items={props.friends} itemName="friend">
                    <li><My.Package:Person.Name givenName={friend.givenName} familyName={friend.familyName} /></li>
                </Neos.Fusion:Loop>
            </ul>
        </section>
    `
}

prototype(My.Package:Person.Name) < prototype(Neos.Fusion:Component) {
    givenName = ''
    familyName = ''

    renderer = Neos.Fusion:Join {
        @glue = ' '
        givenName = ${props.givenName}
        familyName = ${props.familyName}
    }
}

Usage:

root = My.Package:Person {
    givenName = ${q(personNode).property('givenName')}
    familyName = ${q(personNode).property('familyName')}
    friends = Neos.Fusion:Map {
        items = ${q(personNode).property('friends')}
        itemName = 'friendNode'
        itemRenderer = Neos.Fusion:DataStructure {
            givenName = ${q(friendNode).property('givenName')}
            familyName = ${q(friendNode).property('givenName')}
        }
    }
}

I like

@mficzel mficzel changed the title FEATURE: Add Fusion prototypes `Concatenation`, `Dictionary`, `Mapping`, `Iteration` and `Reduction` FEATURE: Add Fusion prototypes `Join`, `Loop`, `Map`, `Reduce` and `DataStructure` Oct 26, 2018

*/
public function getGlue()
{
return $this->fusionValue('__meta/glue') ?: '';

This comment has been minimized.

@bwaidelich

bwaidelich Oct 26, 2018

Member

Shouldn't that use the null coalescing operator instead?

Suggested change Beta
return $this->fusionValue('__meta/glue') ?: '';
return $this->fusionValue('__meta/glue') ?? '';

This comment has been minimized.

@bwaidelich

bwaidelich Oct 26, 2018

Member

Nah, nevermind, should not make a difference in this case. (I just wanted to use the new "suggest change" feature :)

@mficzel mficzel requested review from kitsunet and jonnitto Oct 26, 2018

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Oct 29, 2018

This pr is imho ready now. Please review and let us get this finally merged.

@jonnitto
Copy link
Member

jonnitto left a comment

Looks very nice! 👍

I approve it only from a conceptual point of view, as I am not a PHP developer

@mficzel mficzel force-pushed the mficzel:feature/replaceConfusingRawFusionPrototypes branch 2 times, most recently from 9e995f4 to 6a67c76 Nov 2, 2018

FEATURE: Add Fusion prototypes `Join`, `Loop`, `Map`, `Reduce` and `D…
…ataStructure`

The difference between ``RawArray``, ``Array``, ``RawCollection`` and ``Collection`` was often hard to get for new developers. To overcome this the old confusing names are deprecated and new prototypes are introduced wich are easier to get and emphasize the declarative nature of Fusion.

``Neos.Fusion:Join``

The prototype concatenates the fusion values of all fusion-properties and returns the result as a string. This prototype replaces ``Neos.Fusion:Array`` wich is deprecated.

In addition to the behavior of the ``Array`` ``Join`` allows to define the ``@glue`` used for concatenating the parts.

``Neos.Fusion:Loop``

The ``Loop`` prototype iterates over the given items with the itemRenderer and returns the concatenated result as a string. The prototype replaces ``Neos.Fusion:Collection`` wich is deprecated.

Other than in ``Collection`` the items are passed with the key ``items`` instead of ``collection``.

In addition to the behavior of the classic ``Collection`` ``Loop ``  allows to define the ``@glue`` used for concatenating the items.

``Neos.Fusion:DataStructure``

The ``DataStructure`` prototype returns an associative array with all fusion keys evaluated. The prototype replaces ``Neos.Fusion:RawArray`` wich is deprecated.

``Neos.Fusion:Map``

The ``Map`` iterates over the given ``items`` and returns the result as array.  The prototype replaces ``Neos.Fusion:RawCollection`` wich is deprecated.

Other than ``RawCollection`` the items are passed with the key ``items`` instead of ``collection`` and the keys of the given ``items`` are preserved.

``Neos.Fusion:Reduce``

The `Neos.Fusion:Reduce` prototype is added wich reduces the given items to a single value by using ``itemRenderer`` with the following properties.

- `items` (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
- `carryName`: (string, defaults to `carry`) Context variable that contains the result of the last iteration
- `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``
- `itemReducer`: (mixed, **required**) The reducer definition (simple value, expression or object) that will be applied for every item.
- `initialValue`: (mixed, defaults to `null`) The value that is passed to the first iteration or returned if the items are empty

@mficzel mficzel force-pushed the mficzel:feature/replaceConfusingRawFusionPrototypes branch from 6a67c76 to b97ff41 Nov 5, 2018

@kitsunet kitsunet merged commit 80424b8 into neos:master Nov 5, 2018

2 checks passed

continuous-integration/styleci/pr The analysis has passed
Details
continuous-integration/travis-ci/pr The Travis CI build passed
Details

Neos 4.2 & Flow 5.2 Release Board automation moved this from Needs review to Done Nov 5, 2018

@jonnitto

This comment has been minimized.

Copy link
Member

jonnitto commented Nov 10, 2018

@kitsunet @mficzel Would it make sense to update the used prototypes in the development collection?

@mficzel

This comment has been minimized.

Copy link
Member

mficzel commented Nov 10, 2018

@jonnito I plan to remove our usages of the old fusion-names in Neos 5. Feels more appropriate to do this in a major and now just introduce the new prototypes as an option. However if anyone wants do this faster i will not object.

@jonnitto

This comment has been minimized.

Copy link
Member

jonnitto commented Nov 10, 2018

That's fine with me 👍

@danielkestler

This comment has been minimized.

Shouldn't it be "Neos.Fusion:Map"?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment