wip

Author: rubenvanassche

README.md

@@ -817,8 +817,7 @@ A `TypesProvider` implements the `TypeProvider` interface:
 ```php
 namespace Spatie\TypeScriptTransformer\TypeProviders;
 
-use Spatie\TypeScriptTransformer\Support\TransformedCollection;
-use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
+use Spatie\TypeScriptTransformer\Collections\TransformedCollection;use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
 
 interface TypesProvider
 {

src/Actions/ConnectReferencesAction.php

@@ -2,8 +2,7 @@
 
 namespace Spatie\TypeScriptTransformer\Actions;
 
-use Spatie\TypeScriptTransformer\Collections\ReferenceMap;
-use Spatie\TypeScriptTransformer\Support\TransformedCollection;
+use Spatie\TypeScriptTransformer\Collections\TransformedCollection;
 use Spatie\TypeScriptTransformer\Support\TypeScriptTransformerLog;
 use Spatie\TypeScriptTransformer\Transformed\Transformed;
 use Spatie\TypeScriptTransformer\TypeScriptNodes\TypeReference;
@@ -20,58 +19,50 @@ public function __construct(
     }
 
     /**
-     * @param TransformedCollection|array<Transformed> $collection
+     * @param TransformedCollection $collection
      */
-    public function execute(TransformedCollection|array $collection): ReferenceMap
+    public function execute(TransformedCollection $collection): void
     {
-        $referenceMap = new ReferenceMap();
-
-        foreach ($collection as $transformed) {
-            $referenceMap->add($transformed);
-        }
-
-        foreach ($collection as $transformed) {
+        foreach ($collection->onlyChanged() as $transformed) {
             $metadata = [
                 'transformed' => $transformed,
-                'referenceMap' => $referenceMap,
+                'collection' => $collection,
             ];
 
             $this->visitor->execute($transformed->typeScriptNode, $metadata);
         }
-
-        return $referenceMap;
     }
 
     protected function resolveVisitor(): Visitor
     {
         return Visitor::create()->before(function (TypeReference $typeReference, array &$metadata) {
-            /** @var Transformed $transformed */
-            $transformed = $metadata['transformed'];
+            /** @var Transformed $currentTransformed */
+            $currentTransformed = $metadata['transformed'];
+
+            /** @var TransformedCollection $collection */
+            $collection = $metadata['collection'];
 
-            /** @var ReferenceMap $referenceMap */
-            $referenceMap = $metadata['referenceMap'];
+            $foundTransformed = $collection->get($typeReference->reference);
 
-            if (! $referenceMap->has($typeReference->reference)) {
-                $transformed->addMissingReference($typeReference->reference, $typeReference);
+            if ($foundTransformed === null) {
+                $currentTransformed->addMissingReference($typeReference->reference, $typeReference);
 
-                $this->log->warning("Tried replacing reference to `{$typeReference->reference->humanFriendlyName()}` in `{$transformed->reference->humanFriendlyName()}` but it was not found in the transformed types");
+                $this->log->warning("Tried replacing reference to `{$typeReference->reference->humanFriendlyName()}` in `{$currentTransformed->reference->humanFriendlyName()}` but it was not found in the transformed types");
 
                 return;
             }
 
-            $transformedReference = $referenceMap->get($typeReference->reference);
-
-            if(! $transformed->references->offsetExists($transformedReference)) {
-                $transformed->references[$transformedReference] = [];
+            if (! array_key_exists($foundTransformed->reference->getKey(), $currentTransformed->references)) {
+                $currentTransformed->references[$foundTransformed->reference->getKey()] = [];
             }
 
-            $transformed->references[$transformedReference][] = $typeReference;
-            $transformedReference->referencedBy[$transformed] = $transformed->reference->getKey();
+            $currentTransformed->references[$foundTransformed->reference->getKey()][] = $typeReference;
+            $foundTransformed->referencedBy[] = $currentTransformed->reference->getKey();
 
-            $typeReference->connect($transformedReference);
+            $typeReference->connect($foundTransformed);
 
-            if (array_key_exists($typeReference->reference->getKey(), $transformed->missingReferences)) {
-                unset($transformed->missingReferences[$typeReference->reference->getKey()]);
+            if (array_key_exists($foundTransformed->reference->getKey(), $currentTransformed->missingReferences)) {
+                unset($currentTransformed->missingReferences[$foundTransformed->reference->getKey()]);
             }
         }, [TypeReference::class]);
     }

src/Actions/ExecuteConnectedClosuresAction.php

@@ -2,10 +2,11 @@
 
 namespace Spatie\TypeScriptTransformer\Actions;
 
-use Spatie\TypeScriptTransformer\Support\TransformedCollection;
-use Spatie\TypeScriptTransformer\TypeScriptNodes\TypeScriptNode;
+use Spatie\TypeScriptTransformer\Collections\TransformedCollection;
+use Spatie\TypeScriptTransformer\Transformed\Transformed;
 use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
 use Spatie\TypeScriptTransformer\Visitor\Visitor;
+use Traversable;
 
 class ExecuteConnectedClosuresAction
 {
@@ -18,19 +19,17 @@ public function __construct(
     }
 
     /**
-     * @param TransformedCollection|array<TypeScriptNode> $nodes
+     * @param TransformedCollection|Traversable<Transformed> $nodes
      */
     public function execute(
-        TransformedCollection|array $nodes,
+        TransformedCollection|Traversable $nodes,
     ): void {
         if (empty($this->config->providedVisitorClosures)) {
             return;
         }
 
-        $isTransformedCollection = $nodes instanceof TransformedCollection;
-
         foreach ($nodes as $node) {
-            $this->visitor->execute($isTransformedCollection ? $node->typeScriptNode : $node);
+            $this->visitor->execute($node->typeScriptNode);
         }
     }
 }

src/Actions/ExecuteProvidedClosuresAction.php

@@ -2,10 +2,11 @@
 
 namespace Spatie\TypeScriptTransformer\Actions;
 
-use Spatie\TypeScriptTransformer\Support\TransformedCollection;
-use Spatie\TypeScriptTransformer\TypeScriptNodes\TypeScriptNode;
+use Spatie\TypeScriptTransformer\Collections\TransformedCollection;
+use Spatie\TypeScriptTransformer\Transformed\Transformed;
 use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
 use Spatie\TypeScriptTransformer\Visitor\Visitor;
+use Traversable;
 
 class ExecuteProvidedClosuresAction
 {
@@ -18,19 +19,17 @@ public function __construct(
     }
 
     /**
-     * @param TransformedCollection|array<TypeScriptNode> $nodes
+     * @param TransformedCollection|Traversable<Transformed> $nodes
      */
     public function execute(
-        TransformedCollection|array $nodes,
+        TransformedCollection|Traversable $nodes,
     ): void {
         if (empty($this->config->providedVisitorClosures)) {
             return;
         }
 
-        $isTransformedCollection = $nodes instanceof TransformedCollection;
-
         foreach ($nodes as $node) {
-            $this->visitor->execute($isTransformedCollection ? $node->typeScriptNode : $node);
+            $this->visitor->execute($node->typeScriptNode);
         }
     }
 }

src/Actions/ProvideTypesAction.php

@@ -2,7 +2,7 @@
 
 namespace Spatie\TypeScriptTransformer\Actions;
 
-use Spatie\TypeScriptTransformer\Support\TransformedCollection;
+use Spatie\TypeScriptTransformer\Collections\TransformedCollection;
 use Spatie\TypeScriptTransformer\TypeProviders\TypesProvider;
 use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
 

src/Actions/ResolveModuleImportsAction.php

@@ -4,6 +4,7 @@
 
 use Closure;
 use Spatie\TypeScriptTransformer\Collections\ImportsCollection;
+use Spatie\TypeScriptTransformer\Collections\TransformedCollection;
 use Spatie\TypeScriptTransformer\Support\ImportName;
 use Spatie\TypeScriptTransformer\Support\Location;
 use Spatie\TypeScriptTransformer\Transformed\Transformed;
@@ -21,6 +22,7 @@ public function __construct(
 
     public function execute(
         Location $location,
+        TransformedCollection $transformedCollection,
     ): ImportsCollection {
         $collection = new ImportsCollection();
 
@@ -29,7 +31,9 @@ public function execute(
         );
 
         foreach ($location->transformed as $transformedItem) {
-            foreach ($transformedItem->references as $referencedTransformed => $typeReferences) {
+            foreach ($transformedItem->references as $referencedTransformedKey => $typeReferences) {
+                $referencedTransformed = $transformedCollection->get($referencedTransformedKey);
+
                 if ($referencedTransformed->location === $location->segments) {
                     continue;
                 }

src/Actions/SplitTransformedPerLocationAction.php

@@ -2,8 +2,8 @@
 
 namespace Spatie\TypeScriptTransformer\Actions;
 
+use Spatie\TypeScriptTransformer\Collections\TransformedCollection;
 use Spatie\TypeScriptTransformer\Support\Location;
-use Spatie\TypeScriptTransformer\Support\TransformedCollection;
 use Spatie\TypeScriptTransformer\Transformed\Transformed;
 
 class SplitTransformedPerLocationAction

src/Collections/ReferenceMap.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Spatie\TypeScriptTransformer\Collections;
+
+use ArrayIterator;
+use Generator;
+use IteratorAggregate;
+use Spatie\TypeScriptTransformer\References\FilesystemReference;
+use Spatie\TypeScriptTransformer\References\Reference;
+use Spatie\TypeScriptTransformer\Transformed\Transformed;
+use Traversable;
+
+/**
+ * @implements IteratorAggregate<Transformed>
+ */
+class TransformedCollection implements IteratorAggregate
+{
+    /** @var array<string, Transformed> */
+    protected array $items = [];
+
+    /** @var array<string, Transformed> */
+    protected array $fileMapping = [];
+
+    public function __construct(
+        array $items = [],
+    ) {
+        $this->add(...$items);
+    }
+
+    public function add(Transformed ...$transformed): self
+    {
+        foreach ($transformed as $item) {
+            $this->items[$item->reference->getKey()] = $item;
+
+            if ($item->reference instanceof FilesystemReference) {
+                $this->fileMapping[$this->cleanupFilePath($item->reference->getFilesystemOriginPath())] = $item;
+            }
+        }
+
+        return $this;
+    }
+
+    public function has(Reference|string $reference): bool
+    {
+        return array_key_exists(is_string($reference) ? $reference : $reference->getKey(), $this->items);
+    }
+
+    public function get(Reference|string $reference): ?Transformed
+    {
+        return $this->items[is_string($reference) ? $reference : $reference->getKey()] ?? null;
+    }
+
+    public function remove(Reference|string $reference): void
+    {
+        $transformed = $this->get($reference);
+
+        if ($transformed === null) {
+            return;
+        }
+
+        foreach (array_unique($transformed->referencedBy) as $referencedBy) {
+            $referencedBy = $this->get($referencedBy);
+
+            $referencedBy->markReferenceMissing($transformed);
+            $referencedBy->markAsChanged();
+        }
+
+        unset($this->items[$transformed->reference->getKey()]);
+
+        if($transformed->reference instanceof FilesystemReference) {
+            $path = $this->cleanupFilePath($transformed->reference->getFilesystemOriginPath());
+
+            unset($this->fileMapping[$path]);
+        }
+    }
+
+    public function getIterator(): Traversable
+    {
+        return new ArrayIterator($this->items);
+    }
+
+    public function all(): array
+    {
+        return $this->items;
+    }
+
+    public function onlyChanged(): Generator
+    {
+        foreach ($this->items as $item) {
+            if ($item->changed) {
+                yield $item;
+            }
+        }
+    }
+
+    public function findTransformedByPath(string $path): ?Transformed
+    {
+        $path = $this->cleanupFilePath($path);
+
+        return $this->fileMapping[$path] ?? null;
+    }
+
+    public function hasChanges(): bool
+    {
+        foreach ($this->items as $item) {
+            if ($item->changed) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    protected function cleanupFilePath(string $path): string
+    {
+        return realpath($path);
+    }
+}