!!! FEATURE: Neos 9.0 compatibility

Classes/Fusion/Eel/FlowQueryOperations/FilterByDateOperation.php

@@ -1,15 +1,16 @@
 <?php
+
 namespace Flowpack\Listable\Fusion\Eel\FlowQueryOperations;
 
 /*                                                                        *
  * This script belongs to the Flow package "Flowpack.Listable".           *
  *                                                                        */
 
+use Neos\ContentRepository\Core\Projection\ContentGraph\Node;
 use Neos\Eel\FlowQuery\FlowQueryException;
 use Neos\Eel\FlowQuery\Operations\AbstractOperation;
 use Neos\Eel\FlowQuery\FlowQuery;
 use Neos\Flow\Annotations as Flow;
-use Neos\ContentRepository\Domain\Model\NodeInterface;
 
 /**
  * FlowQuery operation to filter Nodes by a date property
@@ -33,7 +34,7 @@ class FilterByDateOperation extends AbstractOperation
      */
     public function canEvaluate($context)
     {
-        return (!isset($context[0]) || ($context[0] instanceof NodeInterface));
+        return (!isset($context[0]) || ($context[0] instanceof Node));
     }
 
     /**
@@ -65,7 +66,7 @@ public function evaluate(FlowQuery $flowQuery, array $arguments)
 
         $filteredNodes = [];
         foreach ($flowQuery->getContext() as $node) {
-            /** @var NodeInterface $node */
+            /** @var Node $node */
             $propertyValue = $node->getProperty($filterByPropertyPath);
             if (($compareOperator === '>' && $propertyValue > $date) || ($compareOperator === '<' && $propertyValue < $date)) {
                 $filteredNodes[] = $node;

Classes/Fusion/Eel/FlowQueryOperations/FilterByReferenceOperation.php

@@ -1,15 +1,16 @@
 <?php
+
 namespace Flowpack\Listable\Fusion\Eel\FlowQueryOperations;
 
 /*                                                                        *
  * This script belongs to the Flow package "Flowpack.Listable".           *
  *                                                                        */
 
+use Neos\ContentRepository\Core\Projection\ContentGraph\Node;
 use Neos\Eel\FlowQuery\FlowQuery;
 use Neos\Eel\FlowQuery\FlowQueryException;
 use Neos\Eel\FlowQuery\Operations\AbstractOperation;
 use Neos\Flow\Annotations as Flow;
-use Neos\ContentRepository\Domain\Model\NodeInterface;
 
 /**
  * FlowQuery operation to filter by properties of type reference or references
@@ -33,7 +34,7 @@ class FilterByReferenceOperation extends AbstractOperation
      */
     public function canEvaluate($context)
     {
-        return (!isset($context[0]) || ($context[0] instanceof NodeInterface));
+        return (!isset($context[0]) || ($context[0] instanceof Node));
     }
 
     /**
@@ -55,12 +56,12 @@ public function evaluate(FlowQuery $flowQuery, array $arguments)
             throw new FlowQueryException('filterByReference() needs node reference by which nodes should be filtered', 1332493263);
         }
 
-        /** @var NodeInterface $nodeReference */
+        /** @var Node $nodeReference */
         list($filterByPropertyPath, $nodeReference) = $arguments;
 
         $filteredNodes = [];
         foreach ($flowQuery->getContext() as $node) {
-            /** @var NodeInterface $node */
+            /** @var Node $node */
             $propertyValue = $node->getProperty($filterByPropertyPath);
             if ($nodeReference == $propertyValue || (is_array($propertyValue) && in_array($nodeReference, $propertyValue, false))) {
                 $filteredNodes[] = $node;

Classes/Fusion/Eel/FlowQueryOperations/SortRecursiveByIndexOperation.php

@@ -1,17 +1,24 @@
 <?php
+
 namespace Flowpack\Listable\Fusion\Eel\FlowQueryOperations;
 
 /*                                                                        *
  * This script belongs to the Flow package "Flowpack.Listable".           *
  *                                                                        */
 
+use Neos\ContentRepository\Core\Projection\ContentGraph\Filter\FindAncestorNodesFilter;
+use Neos\ContentRepository\Core\Projection\ContentGraph\Filter\FindChildNodesFilter;
+use Neos\ContentRepository\Core\Projection\ContentGraph\Node;
+use Neos\ContentRepository\Core\Projection\ContentGraph\Nodes;
+use Neos\ContentRepository\Core\SharedModel\Node\NodeAggregateId;
+use Neos\ContentRepositoryRegistry\ContentRepositoryRegistry;
 use Neos\Flow\Annotations as Flow;
-use Neos\ContentRepository\Domain\Model\NodeInterface;
 use Neos\Eel\FlowQuery\FlowQuery;
 use Neos\Eel\FlowQuery\Operations\AbstractOperation;
 
 /**
- * Sort Nodes by their position in the node tree.
+ * Sort nodes by their position in the node tree. Please use with care, as this can become a very expensive
+ * operation, if you operate on bigger subtrees.
  *
  * Use it like this:
  *
@@ -29,14 +36,17 @@ class SortRecursiveByIndexOperation extends AbstractOperation
      */
     protected static $priority = 100;
 
+    #[\Neos\Flow\Annotations\Inject]
+    protected ContentRepositoryRegistry $contentRepositoryRegistry;
+
     /**
      * {@inheritdoc}
      *
      * We can only handle CR Nodes.
      */
     public function canEvaluate($context)
     {
-        return (isset($context[0]) && ($context[0] instanceof NodeInterface));
+        return (isset($context[0]) && ($context[0] instanceof Node)) || (is_array($context) && count($context) === 0);
     }
 
     /**
@@ -50,42 +60,78 @@ public function evaluate(FlowQuery $flowQuery, array $arguments)
         if (!empty($arguments[0]) && in_array($arguments[0], ['ASC', 'DESC'], true)) {
             $sortOrder = $arguments[0];
         }
-        
+
         $nodes = $flowQuery->getContext();
+        if (count($nodes) <= 1) {
+            return;
+        }
 
-        $indexPathCache = [];
+        $pathMap = [];
+        $subgraph = $this->contentRepositoryRegistry->subgraphForNode($nodes[0]);
 
-        /** @var NodeInterface $node */
+        // Collect all NodeAggregateId paths
+        /** @var Node $node */
         foreach ($nodes as $node) {
-            // Collect the list of sorting indices for all parents of the node and the node itself
-            $nodeIdentifier = $node->getIdentifier();
-            $indexPath = [$node->getIndex()];
-            while ($node = $node->getParent()) {
-                $indexPath[] = $node->getIndex();
-            }
-            $indexPathCache[$nodeIdentifier] = $indexPath;
+            $nodeIdentifier = $node->aggregateId->value;
+            $ancestors = $subgraph->findAncestorNodes($node->aggregateId, FindAncestorNodesFilter::create());
+            $pathMap[$nodeIdentifier] = array_merge([$node->aggregateId], array_map(static fn($ancestor) => $ancestor->aggregateId, iterator_to_array($ancestors)));
         }
 
         $flip = $sortOrder === 'DESC' ? -1 : 1;
 
-        usort($nodes, function (NodeInterface $a, NodeInterface $b) use ($indexPathCache, $flip) {
-            if ($a === $b) {
+        usort($nodes, function (Node $a, Node $b) use ($subgraph, $pathMap, $flip) {
+            // Both nodes are equal
+            if ($a->equals($b)) {
                 return 0;
             }
 
-            // Compare index path starting from the site root until a difference is found
-            $aIndexPath = $indexPathCache[$a->getIdentifier()];
-            $bIndexPath = $indexPathCache[$b->getIdentifier()];
-            while (count($aIndexPath) > 0 && count($bIndexPath) > 0) {
-                $diff = (array_pop($aIndexPath) - array_pop($bIndexPath));
-                if ($diff !== 0) {
-                    return $flip * $diff < 0 ? -1 : 1;
+            $commonParentPathSegmentNodeAggregateId = null;
+            $childNodesCache = [];
+
+            // Compare path starting from the site root until a difference is found.
+            $aPath = $pathMap[$a->aggregateId->value];
+            $bPath = $pathMap[$b->aggregateId->value];
+            while (count($aPath) > 0 && count($bPath) > 0) {
+
+                /** @var NodeAggregateId $aPathSegmentNodeAggregateId */
+                $aPathSegmentNodeAggregateId = array_pop($aPath);
+                /** @var NodeAggregateId $bPathSegmentNodeAggregateId */
+                $bPathSegmentNodeAggregateId = array_pop($bPath);
+
+                $pathDiff = (!$aPathSegmentNodeAggregateId->equals($bPathSegmentNodeAggregateId));
+
+                if ($pathDiff === true) {
+                    // Path is different at this segment, so we need to figure out their position under the last common parent.
+                    if ($commonParentPathSegmentNodeAggregateId === null) {
+                        return 0;
+                    }
+
+                    if (!isset($childNodesCache[$commonParentPathSegmentNodeAggregateId->value])) {
+                        $childNodesCache[$commonParentPathSegmentNodeAggregateId->value] = $subgraph->findChildNodes($commonParentPathSegmentNodeAggregateId, FindChildNodesFilter::create());
+                    }
+
+                    $positionDiff = $this->getIndexOfNodeAggregateIdInNodes($childNodesCache[$commonParentPathSegmentNodeAggregateId->value], $aPathSegmentNodeAggregateId)
+                        - $this->getIndexOfNodeAggregateIdInNodes($childNodesCache[$commonParentPathSegmentNodeAggregateId->value], $bPathSegmentNodeAggregateId);
+                    return $flip * $positionDiff < 0 ? -1 : 1;
                 }
+                // No diff in path, we need to go deeper, or they are eventually equal
+                $commonParentPathSegmentNodeAggregateId = $aPathSegmentNodeAggregateId;
             }
 
             return 0;
         });
 
         $flowQuery->setContext($nodes);
     }
+
+    private function getIndexOfNodeAggregateIdInNodes(Nodes $childNodes, NodeAggregateId $nodeAggregateId): int
+    {
+        foreach ($childNodes as $key => $childNode) {
+            if ($childNode->aggregateId->value === $nodeAggregateId->value) {
+                return $key;
+            }
+        }
+
+        throw new \Exception("Exception on sorting nodes by there position in content tree.");
+    }
 }

Configuration/Routes.yaml

@@ -1,12 +1,12 @@
 -
   name: 'Paginate for Flowpack.Listable'
-  uriPattern: '{node}<pageSeparator>{currentPage}<defaultUriSuffix>'
+  uriPattern: '{node}<pageSeparator>{currentPage}'
   defaults:
     '@package': 'Neos.Neos'
     '@controller': 'Frontend\Node'
     '@format': 'html'
     '@action': 'show'
   routeParts:
     node:
-      handler: Neos\Neos\Routing\FrontendNodeRoutePartHandlerInterface
+      handler: Neos\Neos\FrontendRouting\FrontendNodeRoutePartHandlerInterface
   appendExceedingArguments: TRUE

README.md

@@ -153,8 +153,8 @@ Filter nodes by properties of type reference or references.
 
 ## sortRecursiveByIndex
 
-Sort nodes recursively by their sorting property.
+Sort nodes by their position in the node tree. Please use with care, as this can become a very expensive operation, if you operate on bigger subtrees.
 
 Example:
 
-    ${q(site).find('[instanceof Neos.Neos:Document]').sortRecursiveByIndex('DESC').get()}
+    ${q(node).children("main").sortRecursiveByIndex(['ASC'|'DESC']).get()}

Resources/Private/Fusion/Collection.fusion

@@ -1,10 +1,10 @@
-prototype(Flowpack.Listable:Collection) < prototype(Neos.Fusion:Collection) {
+prototype(Flowpack.Listable:Collection) < prototype(Neos.Fusion:Loop) {
     listClass = ''
     itemClass = ''
     @context.itemClass = ${this.itemClass}
     @process.tmpl = ${'<ul class="' + this.listClass + '">' + value + '</ul>'}
 
-    collection = 'must-be-set'
+    items = 'must-be-set'
     itemName = 'node'
     iterationName = 'iteration'
     itemRenderer = Flowpack.Listable:ContentCaseShort

Resources/Private/Fusion/List.fusion

@@ -15,7 +15,7 @@ prototype(Flowpack.Listable:List) < prototype(Neos.Fusion:Component) {
         @if.listNotEmpty = ${props.list != null}
 
         attributes.class = ${props.wrapClass}
-        content = Neos.Fusion:Array {
+        content = Neos.Fusion:Join {
             listTitleTag = Neos.Fusion:Tag {
                 tagName = 'h2'
                 attributes.class = ${props.listTitleClass}

Resources/Private/Fusion/PaginatedCollection.fusion

@@ -9,8 +9,8 @@ prototype(Flowpack.Listable:PaginatedCollection) < prototype(Neos.Fusion:Compone
     showPreviousNextLinks = false
     listRenderer = 'Flowpack.Listable:Collection'
 
-    renderer = Neos.Fusion:Array {
-        @context.data = Neos.Fusion:RawArray {
+    renderer = Neos.Fusion:Join {
+        @context.data = Neos.Fusion:DataStructure {
             collection = Neos.Fusion:Case {
                 @context.limit = ${props.currentPage * props.itemsPerPage}
                 @context.offset = ${(props.currentPage - 1) * props.itemsPerPage}
@@ -33,7 +33,7 @@ prototype(Flowpack.Listable:PaginatedCollection) < prototype(Neos.Fusion:Compone
 
         list = Neos.Fusion:Renderer {
             type = ${props.listRenderer}
-            element.collection = ${data.collection}
+            element.items = ${data.collection}
         }
         pagination = Flowpack.Listable:Pagination {
             currentPage = ${props.currentPage}
@@ -47,7 +47,7 @@ prototype(Flowpack.Listable:PaginatedCollection) < prototype(Neos.Fusion:Compone
     @cache {
         mode = 'dynamic'
         entryIdentifier {
-            node = ${node}
+            node = ${Neos.Caching.entryIdentifierForNode(node)}
         }
         entryDiscriminator = ${request.arguments.currentPage}
         context {

Resources/Private/Fusion/Pagination.fusion

@@ -7,7 +7,7 @@ prototype(Flowpack.Listable:PaginationArray) {
     showPreviousNextLinks = false
 }
 
-prototype(Flowpack.Listable:PaginationParameters) < prototype(Neos.Fusion:RawArray)
+prototype(Flowpack.Listable:PaginationParameters) < prototype(Neos.Fusion:DataStructure)
 
 prototype(Flowpack.Listable:Pagination) < prototype(Neos.Fusion:Component) {
     totalCount = 'to-be-set'
@@ -20,10 +20,10 @@ prototype(Flowpack.Listable:Pagination) < prototype(Neos.Fusion:Component) {
     currentItemClass = 'isCurrent'
     currentPage = ${request.arguments.currentPage || 1}
 
-    renderer = Neos.Fusion:Collection {
+    renderer = Neos.Fusion:Loop {
         @if.paginationNeeded = ${(props.totalCount/props.itemsPerPage) > 1}
         @process.tmpl = ${'<ul class="' + props.class + '">' + value + '</ul>'}
-        collection = Flowpack.Listable:PaginationArray {
+        items = Flowpack.Listable:PaginationArray {
             currentPage = ${props.currentPage}
             maximumNumberOfLinks = ${props.maximumNumberOfLinks}
             totalCount = ${props.totalCount}

Resources/Private/Fusion/Utility.fusion

@@ -3,6 +3,6 @@ prototype(Flowpack.Listable:ContentCaseShort) < prototype(Neos.Neos:ContentCase)
     default {
         @position = 'end'
         condition = true
-        type = ${q(node).property('_nodeType.name') + '.Short'}
+        type = ${node.nodeTypeName + '.Short'}
     }
 }

composer.json

@@ -7,7 +7,8 @@
     "description": "Tiny extension for listing things",
     "license": "MIT",
     "require": {
-        "neos/neos": "^3.3 || ^4.0 || ^5.0 || ^7.0 ||  ^8.0 || dev-master"
+        "php": ">=8.2",
+        "neos/neos": "^9.0"
     },
     "autoload": {
         "psr-4": {