Implement splitting types per file per namespace

src/Actions/FormatTypeScriptAction.php

@@ -8,8 +8,10 @@ class FormatTypeScriptAction
 {
     protected TypeScriptTransformerConfig $config;
 
-    public function __construct(TypeScriptTransformerConfig $config)
-    {
+    public function __construct(
+        TypeScriptTransformerConfig $config,
+        protected string $outputFile
+    ) {
         $this->config = $config;
     }
 
@@ -21,6 +23,6 @@ public function execute(): void
             return;
         }
 
-        $formatter->format($this->config->getOutputFile());
+        $formatter->format($this->outputFile);
     }
 }

src/Actions/PersistTypesCollectionAction.php

@@ -9,32 +9,36 @@ class PersistTypesCollectionAction
 {
     protected TypeScriptTransformerConfig $config;
 
-    public function __construct(TypeScriptTransformerConfig $config)
+    public function __construct(TypeScriptTransformerConfig $config, protected string $outputFile)
     {
         $this->config = $config;
     }
 
-    public function execute(TypesCollection $collection): void
+    public function execute(TypesCollection $moduleCollection, ?TypesCollection $totalCollection = null): void
     {
+        if ($totalCollection === null) {
+            $totalCollection = $moduleCollection;
+        }
         $this->ensureOutputFileExists();
 
         $writer = $this->config->getWriter();
 
-        (new ReplaceSymbolsInCollectionAction())->execute(
-            $collection,
+        (new ReplaceIntermoduleSymbolsInCollectionAction())->execute(
+            $moduleCollection,
+            $totalCollection,
             $writer->replacesSymbolsWithFullyQualifiedIdentifiers()
         );
 
         file_put_contents(
-            $this->config->getOutputFile(),
-            $writer->format($collection)
+            $this->outputFile,
+            $writer->format($moduleCollection)
         );
     }
 
     protected function ensureOutputFileExists(): void
     {
-        if (! file_exists(pathinfo($this->config->getOutputFile(), PATHINFO_DIRNAME))) {
-            mkdir(pathinfo($this->config->getOutputFile(), PATHINFO_DIRNAME), 0755, true);
+        if (! file_exists(pathinfo($this->outputFile, PATHINFO_DIRNAME))) {
+            mkdir(pathinfo($this->outputFile, PATHINFO_DIRNAME), 0755, true);
         }
     }
 }

src/Actions/ReplaceIntermoduleSymbolsInCollectionAction.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Spatie\TypeScriptTransformer\Actions;
+
+use Spatie\TypeScriptTransformer\Structures\TranspilationResult;
+use Spatie\TypeScriptTransformer\Structures\TypesCollection;
+
+class ReplaceIntermoduleSymbolsInCollectionAction
+{
+    public function execute(
+        TypesCollection $moduleCollection,
+        TypesCollection $totalCollection,
+        $withFullyQualifiedNames = true
+    ): TypesCollection
+    {
+        $replaceSymbolsInTypeAction = new ReplaceSymbolsInTypeAction($totalCollection, $withFullyQualifiedNames);
+
+        foreach ($moduleCollection as $type) {
+            $type->transformed = $replaceSymbolsInTypeAction->execute($type);
+        }
+
+        return $moduleCollection;
+    }
+}

src/Actions/ReplaceSymbolsInTypeAction.php

@@ -4,6 +4,7 @@
 
 use Spatie\TypeScriptTransformer\Exceptions\CircularDependencyChain;
 use Spatie\TypeScriptTransformer\Structures\TransformedType;
+use Spatie\TypeScriptTransformer\Structures\TranspilationResult;
 use Spatie\TypeScriptTransformer\Structures\TypesCollection;
 
 class ReplaceSymbolsInTypeAction
@@ -18,7 +19,7 @@ public function __construct(TypesCollection $collection, $withFullyQualifiedName
         $this->withFullyQualifiedNames = $withFullyQualifiedNames;
     }
 
-    public function execute(TransformedType $type, array $chain = []): string
+    public function execute(TransformedType $type, array $chain = []): TranspilationResult
     {
         if (in_array($type->getTypeScriptName(), $chain)) {
             $chain = array_merge($chain, [$type->getTypeScriptName()]);

src/Actions/ResolveSplitTypesCollectionsAction.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace Spatie\TypeScriptTransformer\Actions;
+
+use Exception;
+use Generator;
+use ReflectionClass;
+use Spatie\TypeScriptTransformer\Exceptions\NoAutoDiscoverTypesPathsDefined;
+use Spatie\TypeScriptTransformer\Structures\TransformedType;
+use Spatie\TypeScriptTransformer\Structures\TypesCollection;
+use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
+use Symfony\Component\Finder\Finder;
+
+class ResolveSplitTypesCollectionsAction
+{
+    protected Finder $finder;
+
+    /** @var \Spatie\TypeScriptTransformer\Collectors\Collector[] */
+    protected array $collectors;
+
+    protected TypeScriptTransformerConfig $config;
+
+    public function __construct(Finder $finder, TypeScriptTransformerConfig $config)
+    {
+        $this->finder = $finder;
+
+        $this->config = $config;
+
+        $this->collectors = $config->getCollectors();
+    }
+
+    /**
+     * @return TypesCollection[]
+     * @throws NoAutoDiscoverTypesPathsDefined
+     */
+    public function execute(): array
+    {
+        $collections = [];
+
+        $paths = $this->config->getAutoDiscoverTypesPaths();
+
+        if (empty($paths)) {
+            throw NoAutoDiscoverTypesPathsDefined::create();
+        }
+
+        foreach ($this->resolveIterator($paths) as $class) {
+            $transformedType = $this->resolveTransformedType($class);
+
+            if ($transformedType === null) {
+                continue;
+            }
+            $namespace = implode('/', $transformedType->getNamespaceSegments());
+            if (!isset($collections[$namespace])) {
+                $collections[$namespace] = new TypesCollection();
+            }
+            $collections[$namespace][] = $transformedType;
+        }
+
+        return $collections;
+    }
+
+    protected function resolveIterator(array $paths): Generator
+    {
+        $paths = array_map(
+            fn (string $path) => is_dir($path) ? $path : dirname($path),
+            $paths
+        );
+
+        foreach ($this->finder->in($paths) as $fileInfo) {
+            try {
+                $classes = (new ResolveClassesInPhpFileAction())->execute($fileInfo);
+
+                foreach ($classes as $name) {
+                    yield $name => new ReflectionClass($name);
+                }
+            } catch (Exception $exception) {
+            }
+        }
+    }
+
+    protected function resolveTransformedType(ReflectionClass $class): ?TransformedType
+    {
+        foreach ($this->collectors as $collector) {
+            $transformedType = $collector->getTransformedType($class);
+
+            if ($transformedType !== null) {
+                return $transformedType;
+            }
+        }
+
+        return null;
+    }
+}