Retroactive fix port Maravel-Framework 10.51.18 feature-fix for php/php-src#20262 (comment) and laravel/framework#57528

Author: Pantea Marius-ciclistu

src/Helpers/GeneralHelper.php

@@ -59,4 +59,54 @@ public static function isDebug(): bool
             && \function_exists('request')
             && null !== \request('sqlDebug');
     }
+
+    /**
+     * Backward compatible array_unique($items, SORT_REGULAR) fix
+     * see https://github.com/php/php-src/issues/20262#issuecomment-3441217772
+     * see https://github.com/laravel/framework/pull/57501#issuecomment-3441380946
+     * see https://github.com/laravel/framework/issues/57528
+     */
+    public static function arrayUniqueSortRegular(array $items): array
+    {
+        $ui = $us = $u = $sp = [];
+
+        foreach ($items as $k => $v) {
+            if (\is_string($v)) {
+                $us[$v] ??= $k;
+
+                continue;
+            }
+
+            if (\is_int($v)) {
+                $ui[$v] ??= $k;
+
+                continue;
+            }
+
+            if (null === $v) {
+                $sp['null'] ??= $k;
+
+                continue;
+            }
+
+            if (false === $v) {
+                $sp['false'] ??= $k;
+
+                continue;
+            }
+
+            if (true === $v) {
+                $sp['true'] ??= $k;
+
+                continue;
+            }
+
+            $u[$k] = $v;
+        }
+
+        return \array_intersect_key(
+            $items,
+            \array_flip($ui) + \array_flip($us) + \array_flip($sp) + \array_unique($u, SORT_REGULAR)
+        );
+    }
 }

src/Models/BaseModel.php

@@ -492,4 +492,67 @@ public function __call($method, $parameters)
 
         return parent::__call($method, $parameters);
     }
+
+    /**
+     * @inheritdoc
+     */
+    public function newCollection(array $models = []): \Illuminate\Database\Eloquent\Collection
+    {
+        return \function_exists('arrayUniqueSortRegular')
+            && \Composer\InstalledVersions::isInstalled('macropay-solutions/maravel-framework') ?
+                parent::newCollection($models) :
+                new class ($models) extends \Illuminate\Database\Eloquent\Collection {
+                    /**
+                     * @inheritdoc
+                     */
+                    public function toBase(): Collection
+                    {
+                        return new class ($this) extends Collection {
+                            /**
+                             * Return only unique items from the collection array.
+                             *
+                             * @param mixed $key
+                             * @param bool $strict
+                             * @param int $flags [optional] <p>
+                             *  The optional second parameter sort_flags
+                             *  may be used to modify the sorting behavior using these values:
+                             *  </p>
+                             *  <p>
+                             *  Sorting type flags:
+                             *  </p><ul>
+                             *  <li>
+                             *  <b>SORT_REGULAR</b> - compare items normally
+                             *  (don't change types)
+                             *  </li>
+                             *  <li>
+                             *  <b>SORT_NUMERIC</b> - compare items numerically
+                             *  </li>
+                             *  <li>
+                             *  <b>SORT_STRING</b> - compare items as strings
+                             *  </li>
+                             *  <li>
+                             *  <b>SORT_LOCALE_STRING</b> - compare items as strings,
+                             *  based on the current locale
+                             *  </li>
+                             *  </ul>
+                             * @return static
+                             */
+                            public function unique($key = null, $strict = false): Collection
+                            {
+                                if ($key === null && $strict === false) {
+                                    $flags = \func_get_args()[2] ?? SORT_REGULAR;
+
+                                    return new static(
+                                        SORT_REGULAR === $flags ?
+                                            GeneralHelper::arrayUniqueSortRegular($this->items) :
+                                            \array_unique($this->items, $flags)
+                                    );
+                                }
+
+                                return parent::unique($key, $strict);
+                            }
+                        };
+                    }
+                };
+    }
 }