Add visitor support

Author: rubenvanassche

src/Actions/ConnectReferencesAction.php

@@ -5,8 +5,11 @@
 use Spatie\TypeScriptTransformer\Collections\ReferenceMap;
 use Spatie\TypeScriptTransformer\Support\TransformedCollection;
 use Spatie\TypeScriptTransformer\Support\TypeScriptTransformerLog;
+use Spatie\TypeScriptTransformer\Transformed\Transformed;
 use Spatie\TypeScriptTransformer\TypeScript\TypeReference;
 use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
+use Spatie\TypeScriptTransformer\Visitor\Visitor;
+use Spatie\TypeScriptTransformer\Visitor\VisitTypeScriptTreeAction;
 
 class ConnectReferencesAction
 {
@@ -27,25 +30,30 @@ public function execute(TransformedCollection $collection): ReferenceMap
             }
         }
 
-        foreach ($collection as $transformed) {
-            $references = [];
+        $visitor = Visitor::create()->before(function (TypeReference $typeReference, array $metadata) use ($referenceMap, &$references) {
+            $reference = $typeReference->reference;
+
+            if (! $referenceMap->has($reference)) {
+                /** @var Transformed $transformed */
+                $transformed = $metadata['transformed'];
+
+                $this->log->warning("Tried replacing reference to `{$reference->humanFriendlyName()}` in `{$transformed->reference->humanFriendlyName()}` but it was not found in the transformed types");
 
-            $this->visitTypeScriptTreeAction->execute(
-                $transformed->typeScriptNode,
-                function (TypeReference $typeReference) use ($referenceMap, &$references, $transformed) {
-                    $reference = $typeReference->reference;
+                return;
+            }
+
+            $references[] = $reference;
+            $typeReference->connect($referenceMap->get($reference));
+        }, [TypeReference::class]);
 
-                    if (! $referenceMap->has($reference)) {
-                        $this->log->warning("Tried replacing reference to `{$reference->humanFriendlyName()}` in `{$transformed->reference->humanFriendlyName()}` but it was not found in the transformed types");
+        foreach ($collection as $transformed) {
+            $references = [];
 
-                        return;
-                    }
+            $metadata = [
+                'transformed' => $transformed,
+            ];
 
-                    $references[] = $reference;
-                    $typeReference->connect($referenceMap->get($reference));
-                },
-                [TypeReference::class]
-            );
+            $visitor->execute($transformed->typeScriptNode, $metadata);
 
             $transformed->references = $references;
         }

src/Actions/DiscoverTypesAction.php

@@ -9,18 +9,16 @@
 
 class DiscoverTypesAction
 {
-    public function __construct(
-        public TypeScriptTransformerConfig $config,
-        public TypeScriptTransformerLog $log,
-    ) {
-    }
-
-    /** @return array<string> */
-    public function execute(): array
-    {
+    /**
+     * @param array<string> $directories
+     * @return array<class-string>
+     */
+    public function execute(
+        array $directories = [],
+    ): array {
         // Idea / TODO : make it possible for other packages to hook in to find types in other directories, like their vendor dir
 
-        return Discover::in(...$this->config->directories)
+        return Discover::in(...$directories)
             ->types(
                 DiscoveredStructureType::ClassDefinition,
                 DiscoveredStructureType::Enum,

src/Actions/AppendDefaultTypesAction.php renamed to src/Actions/ProvideTypesAction.php

@@ -2,12 +2,12 @@
 
 namespace Spatie\TypeScriptTransformer\Actions;
 
-use Spatie\TypeScriptTransformer\DefaultTypeProviders\DefaultTypesProvider;
+use Spatie\TypeScriptTransformer\TypeProviders\TypesProvider;
 use Spatie\TypeScriptTransformer\Support\TransformedCollection;
 use Spatie\TypeScriptTransformer\Support\TypeScriptTransformerLog;
 use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
 
-class AppendDefaultTypesAction
+class ProvideTypesAction
 {
     public function __construct(
         protected TypeScriptTransformerConfig $config,
@@ -17,12 +17,16 @@ public function __construct(
 
     public function execute(TransformedCollection $collection): void
     {
-        foreach ($this->config->defaultTypeProviders as $defaultTypeProvider) {
-            $defaultTypeProvider = $defaultTypeProvider instanceof DefaultTypesProvider
+        foreach ($this->config->typeProviders as $defaultTypeProvider) {
+            $defaultTypeProvider = $defaultTypeProvider instanceof TypesProvider
                 ? $defaultTypeProvider
                 : new $defaultTypeProvider;
 
-            $collection->add(...$defaultTypeProvider->provide());
+            $defaultTypeProvider->provide(
+                $this->config,
+                $this->log,
+                $collection
+            );
         }
     }
 }

src/Actions/TransformTypeAction.php

@@ -16,7 +16,7 @@ public function __construct(
     public function execute(
         TransformedCollection $transformedCollection,
     ) {
-        Watch::paths($this->config->directories)
+        Watch::paths($this->config->directoriesToWatch)
             ->onAnyChange(function (string $type, string $path) {
                 echo $type.'|'.$path;
             })

src/Actions/TransformTypesAction.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Spatie\TypeScriptTransformer\Laravel\ClassPropertyProcessors;
+
+use PHPStan\PhpDocParser\Ast\Type\TypeNode;
+use ReflectionProperty;
+use Spatie\TypeScriptTransformer\Transformers\ClassPropertyProcessors\ClassPropertyProcessor;
+use Spatie\TypeScriptTransformer\TypeScript\TypeReference;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptProperty;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptUnion;
+
+class RemoveDataLazyTypeClassPropertyProcessor implements ClassPropertyProcessor
+{
+    public function execute(ReflectionProperty $reflection, ?TypeNode $annotation, TypeScriptProperty $property): ?TypeScriptProperty
+    {
+        if (! $property->type instanceof TypeScriptUnion) {
+            return $property;
+        }
+
+        for ($i = 0; $i < count($property->type->types); $i++) {
+            $subType = $property->type->types[$i];
+
+            if ($subType instanceof TypeReference && is_a($subType->reference, \Spatie\LaravelData\Lazy::class, true)) {
+                $property->isOptional = true;
+
+                unset($property->type->types[$i]);
+            }
+        }
+
+        $property->type->types = array_values($property->type->types);
+
+        return $property;
+    }
+}

src/Actions/VisitTypeScriptTreeAction.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Spatie\TypeScriptTransformer\Laravel\ClassPropertyProcessors;
+
+use Illuminate\Support\Collection;
+use PHPStan\PhpDocParser\Ast\Type\TypeNode;
+use ReflectionProperty;
+use Spatie\TypeScriptTransformer\References\ClassStringReference;
+use Spatie\TypeScriptTransformer\Transformers\ClassPropertyProcessors\ClassPropertyProcessor;
+use Spatie\TypeScriptTransformer\TypeScript\TypeReference;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptGeneric;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptProperty;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptString;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptUnion;
+use Spatie\TypeScriptTransformer\Visitor\VisitTypeScriptTreeAction;
+
+class ReplaceLaravelCollectionByArrayClassPropertyProcessor implements ClassPropertyProcessor
+{
+    public function __construct(
+        protected VisitTypeScriptTreeAction $visitTypeScriptTreeAction = new VisitTypeScriptTreeAction(),
+    ) {
+    }
+
+    public function execute(
+        ReflectionProperty $reflection,
+        ?TypeNode $annotation,
+        TypeScriptProperty $property
+    ): ?TypeScriptProperty {
+        $this->visitTypeScriptTreeAction->execute($property->type, function (TypeScriptGeneric $generic) {
+            $isCollection = $generic->type instanceof TypeReference
+                && $generic->type->reference instanceof ClassStringReference
+                && is_a($generic->type->reference->classString, Collection::class, true);
+
+            if (! $isCollection) {
+                return;
+            }
+
+            if (count($generic->genericTypes) !== 2) {
+                // Someone messed with the type, let's skip it
+                return;
+            }
+
+            $isRecord = $generic->genericTypes[0] instanceof TypeScriptUnion || $generic->genericTypes[0] instanceof TypeScriptString;
+
+//            $generic->type = new
+
+            if ($isCollection) {
+//                $generic->type = new TypeReference(new TypeScriptArray());
+            }
+        }, [TypeScriptGeneric::class]);
+
+        return $property;
+    }
+}