[LiveComponent] Add compatibility layer for Type::accepts() too (only available in TypeInfo 7.3)

Author: Kocal

.github/workflows/.utils.sh

@@ -25,9 +25,9 @@ install_property_info_for_version() {
   local min_stability="$2"
 
   if [ "$php_version" = "8.2" ]; then
-    composer require symfony/property-info:7.1.* symfony/type-info:7.3.*
+    composer require symfony/property-info:7.1.* symfony/type-info:7.2.*
   elif [ "$php_version" = "8.3" ]; then
-    composer require symfony/property-info:7.2.* symfony/type-info:7.3.*
+    composer require symfony/property-info:7.2.* symfony/type-info:7.2.*
   elif [ "$php_version" = "8.4" ] && [ "$min_stability" = "stable" ]; then
     composer require symfony/property-info:7.3.* symfony/type-info:7.3.*
   elif [ "$php_version" = "8.4" ] && [ "$min_stability" = "dev" ]; then

src/LiveComponent/composer.json

@@ -57,6 +57,7 @@
     },
     "conflict": {
         "symfony/config": "<5.4.0",
+        "symfony/type-info": "<7.1",
         "symfony/property-info": "~7.0.0"
     },
     "config": {

src/LiveComponent/src/LiveComponentHydrator.php

@@ -585,7 +585,7 @@ private function dehydrateValue(mixed $value, LivePropMetadata|LegacyLivePropMet
                 foreach ($collectionValueType ? TypeHelper::traverse($collectionValueType) : [] as $t) {
                     if ($t instanceof ObjectType) {
                         foreach ($value as $key => $objectItem) {
-                            if (!$t->accepts($objectItem)) {
+                            if (!TypeHelper::accepts($t, $objectItem)) {
                                 throw new \LogicException(\sprintf('The LiveProp "%s" on component "%s" is an array. We determined the array is full of %s objects, but at least one key had a different value of %s', $propMetadata->getName(), $parentObject::class, $t->getClassName(), get_debug_type($objectItem)));
                             }
 

src/LiveComponent/src/Util/QueryStringPropsExtractor.php

@@ -97,7 +97,7 @@ private function isValueTypeConsistent(mixed $value, LivePropMetadata|LegacyLive
         } else {
             $type = $livePropMetadata->getType();
 
-            return null === $type || $type->accepts($value);
+            return null === $type || TypeHelper::accepts($type, $value);
         }
     }
 }

src/LiveComponent/src/Util/TypeHelper.php

@@ -14,6 +14,7 @@
 use Symfony\Component\TypeInfo\Type;
 use Symfony\Component\TypeInfo\Type\CompositeTypeInterface;
 use Symfony\Component\TypeInfo\Type\WrappingTypeInterface;
+use Symfony\Component\TypeInfo\TypeIdentifier;
 
 /**
  * @author Hugo Alliaume <hugo@alliau.me>
@@ -22,6 +23,113 @@
  */
 final class TypeHelper
 {
+    /**
+     * TODO: To remove when supporting symfony/type-info >=7.3 only.
+     */
+    public static function accepts(Type $type, mixed $value): bool
+    {
+        $parentAccepts = function (Type $_type0, mixed $_value0): bool {
+            $specification = static function (Type $_type1) use (&$specification, $_value0): bool {
+                if ($_type1 instanceof WrappingTypeInterface) {
+                    return $_type1->wrappedTypeIsSatisfiedBy($specification);
+                }
+
+                if ($_type1 instanceof CompositeTypeInterface) {
+                    return $_type1->composedTypesAreSatisfiedBy($specification);
+                }
+
+                return TypeHelper::accepts($_type1, $_value0);
+            };
+
+            return $_type0->isSatisfiedBy($specification);
+        };
+
+        if ($type instanceof Type\ArrayShapeType) {
+            if (!\is_array($value)) {
+                return false;
+            }
+
+            foreach ($type->getShape() as $key => $shapeValue) {
+                if (!($shapeValue['optional'] ?? false) && !\array_key_exists($key, $value)) {
+                    return false;
+                }
+            }
+
+            foreach ($value as $key => $itemValue) {
+                $valueType = $type->getShape()[$key]['type'] ?? false;
+
+                if ($valueType && !TypeHelper::accepts($valueType, $itemValue)) {
+                    return false;
+                }
+
+                if (!$valueType && ($type->isSealed() || !TypeHelper::accepts($type->getExtraKeyType(), $key) || !TypeHelper::accepts($type->getExtraValueType(), $itemValue))) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        // Also supports EnumType and BackedEnumType
+        if ($type instanceof Type\ObjectType) {
+            $className = $type->getClassName();
+            return $value instanceof $className;
+        }
+
+        if ($type instanceof Type\BuiltinType) {
+            return match ($type->getTypeIdentifier()) {
+                TypeIdentifier::ARRAY => \is_array($value),
+                TypeIdentifier::BOOL => \is_bool($value),
+                TypeIdentifier::CALLABLE => \is_callable($value),
+                TypeIdentifier::FALSE => false === $value,
+                TypeIdentifier::FLOAT => \is_float($value),
+                TypeIdentifier::INT => \is_int($value),
+                TypeIdentifier::ITERABLE => is_iterable($value),
+                TypeIdentifier::MIXED => true,
+                TypeIdentifier::NULL => null === $value,
+                TypeIdentifier::OBJECT => \is_object($value),
+                TypeIdentifier::RESOURCE => \is_resource($value),
+                TypeIdentifier::STRING => \is_string($value),
+                TypeIdentifier::TRUE => true === $value,
+                default => false,
+            };
+        }
+
+        if ($type instanceof Type\CollectionType) {
+            if (!$parentAccepts($type, $value)) {
+                return false;
+            }
+
+            if ($type->isList() && (!\is_array($value) || !array_is_list($value))) {
+                return false;
+            }
+
+            $keyType = $type->getCollectionKeyType();
+            $valueType = $type->getCollectionValueType();
+
+            if (is_iterable($value)) {
+                foreach ($value as $k => $v) {
+                    // key or value do not match
+                    if (!TypeHelper::accepts($keyType, $k) || !TypeHelper::accepts($valueType, $v)) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        if ($type instanceof Type\NullableType) {
+            return null === $value || $parentAccepts($type, $value);
+        }
+
+        if ($type instanceof Type\GenericType || $type instanceof Type\TemplateType || $type instanceof Type\UnionType || $type instanceof Type\IntersectionType) {
+            return $parentAccepts($type, $value);
+        }
+
+        return false;
+    }
+
     /**
      * TODO: To remove when supporting symfony/type-info >=7.3 only.
      *