wip

Author: rubenvanassche

src/Attributes/LiteralTypeScriptType.php

@@ -3,12 +3,16 @@
 namespace Spatie\TypeScriptTransformer\Attributes;
 
 use Attribute;
-use phpDocumentor\Reflection\Type;
+use ReflectionClass;
 use Spatie\TypeScriptTransformer\Types\StructType;
 use Spatie\TypeScriptTransformer\Types\TypeScriptType;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptNode;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptObject;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptProperty;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptRaw;
 
 #[Attribute]
-class LiteralTypeScriptType implements TypeScriptTransformableAttribute
+class LiteralTypeScriptType implements TypeScriptTypeAttributeContract
 {
     private string|array $typeScript;
 
@@ -17,17 +21,19 @@ public function __construct(string|array $typeScript)
         $this->typeScript = $typeScript;
     }
 
-    public function getType(): Type
+    public function getType(ReflectionClass $class): TypeScriptNode
     {
         if (is_string($this->typeScript)) {
-            return new TypeScriptType($this->typeScript);
+            return new TypeScriptRaw($this->typeScript);
         }
 
-        $types = array_map(
-            fn (string $type) => new TypeScriptType($type),
-            $this->typeScript
-        );
+        $properties = collect($this->typeScript)
+            ->map(fn (string $type, string $name) => new TypeScriptProperty(
+                $name,
+                new TypeScriptRaw($type)
+            ))
+            ->all();
 
-        return new StructType($types);
+        return new TypeScriptObject($properties);
     }
 }

src/Attributes/TypeScript.php

@@ -7,10 +7,12 @@
 #[Attribute]
 class TypeScript
 {
-    public ?string $name;
-
-    public function __construct(?string $name = null)
-    {
-        $this->name = $name;
+    /**
+     * @param array<string>|null $location
+     */
+    public function __construct(
+        public ?string $name = null,
+        public ?array $location = null,
+    ) {
     }
 }

src/Attributes/TypeScriptTransformableAttribute.php

@@ -3,13 +3,17 @@
 namespace Spatie\TypeScriptTransformer\Attributes;
 
 use Attribute;
-use phpDocumentor\Reflection\Type;
-use phpDocumentor\Reflection\TypeResolver;
+use ReflectionClass;
+use Spatie\TypeScriptTransformer\Actions\TranspilePhpStanTypeToTypeScriptTypeAction;
 use Spatie\TypeScriptTransformer\Exceptions\UnableToTransformUsingAttribute;
+use Spatie\TypeScriptTransformer\TypeResolvers\DocTypeResolver;
 use Spatie\TypeScriptTransformer\Types\StructType;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptNode;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptObject;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptProperty;
 
 #[Attribute]
-class TypeScriptType implements TypeScriptTransformableAttribute
+class TypeScriptType implements TypeScriptTypeAttributeContract
 {
     private array|string $type;
 
@@ -18,17 +22,22 @@ public function __construct(string|array $type)
         $this->type = $type;
     }
 
-    public function getType(): Type
+    public function getType(ReflectionClass $class): TypeScriptNode
     {
+        $docResolver = new DocTypeResolver();
+        $transpiler = new TranspilePhpStanTypeToTypeScriptTypeAction();
+
         if (is_string($this->type)) {
-            return (new TypeResolver())->resolve($this->type);
+            return $transpiler->execute($docResolver->type($this->type), $class);
         }
 
-        /** @psalm-suppress RedundantCondition  */
-        if (is_array($this->type)) {
-            return StructType::fromArray($this->type);
-        }
+        $properties = collect($this->type)
+            ->map(fn (string $type, string $name) => new TypeScriptProperty(
+                $name,
+                $transpiler->execute($docResolver->type($type), $class)
+            ))
+            ->all();
 
-        throw UnableToTransformUsingAttribute::create($this->type);
+        return new TypeScriptObject($properties);
     }
 }

src/Attributes/TypeScriptTransformer.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Spatie\TypeScriptTransformer\Attributes;
+
+use ReflectionClass;
+use Spatie\TypeScriptTransformer\TypeScript\TypeScriptNode;
+
+interface TypeScriptTypeAttributeContract
+{
+    public function getType(ReflectionClass $class): TypeScriptNode;
+}

src/Attributes/TypeScriptType.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Spatie\TypeScriptTransformer\Transformers;
+
+use ReflectionClass;
+use Spatie\TypeScriptTransformer\Attributes\TypeScript;
+use Spatie\TypeScriptTransformer\Support\TransformationContext;
+use Spatie\TypeScriptTransformer\Transformed\Transformed;
+use Spatie\TypeScriptTransformer\Transformed\Untransformable;
+
+class AttributeTransformer extends ClassTransformer
+{
+    public function shouldTransform(ReflectionClass $reflection): bool
+    {
+        return count($reflection->getAttributes(TypeScript::class)) > 0;
+    }
+
+    public function transform(ReflectionClass $reflectionClass, TransformationContext $context): Transformed|Untransformable
+    {
+        $transformed = parent::transform($reflectionClass, $context);
+
+        if ($transformed instanceof Untransformable) {
+            return $transformed;
+        }
+
+        /** @var TypeScript $attribute */
+        $attribute = $reflectionClass->getAttributes(TypeScript::class)[0]->newInstance();
+
+        if ($attribute->name !== null) {
+            $transformed->name = $attribute->name;
+        }
+
+        if ($attribute->location !== null) {
+            $transformed->location = $attribute->location;
+        }
+
+        return $transformed;
+    }
+}

src/Attributes/TypeScriptTypeAttributeContract.php

@@ -8,6 +8,7 @@
 use Spatie\TypeScriptTransformer\Actions\TranspilePhpStanTypeToTypeScriptTypeAction;
 use Spatie\TypeScriptTransformer\Actions\TranspileReflectionTypeToTypeScriptTypeAction;
 use Spatie\TypeScriptTransformer\Attributes\Optional;
+use Spatie\TypeScriptTransformer\Attributes\TypeScriptTypeAttributeContract;
 use Spatie\TypeScriptTransformer\References\ReflectionClassReference;
 use Spatie\TypeScriptTransformer\Support\TransformationContext;
 use Spatie\TypeScriptTransformer\Transformed\Transformed;
@@ -38,6 +39,30 @@ public function transform(ReflectionClass $reflectionClass, TransformationContex
             return Untransformable::create();
         }
 
+
+        return new Transformed(
+            new TypeScriptExport(
+                new TypeScriptAlias(
+                    new TypeScriptIdentifier($context->name),
+                    $this->getTypeScriptNode($reflectionClass)
+                )
+            ),
+            new ReflectionClassReference($reflectionClass),
+            $context->name,
+            true,
+            $context->nameSpaceSegments,
+        );
+    }
+
+    abstract public function shouldTransform(ReflectionClass $reflection): bool;
+
+    protected function getTypeScriptNode(
+        ReflectionClass $reflectionClass
+    ): TypeScriptNode {
+        if ($resolvedAttributeType = $this->resolveTypeByAttribute($reflectionClass)) {
+            return $resolvedAttributeType;
+        }
+
         $classAnnotations = $this->docTypeResolver->class($reflectionClass)?->properties ?? [];
 
         $constructorAnnotations = $reflectionClass->hasMethod('__construct')
@@ -55,16 +80,26 @@ public function transform(ReflectionClass $reflectionClass, TransformationContex
             );
         }
 
-        return new Transformed(
-            new TypeScriptExport(new TypeScriptAlias(new TypeScriptIdentifier($context->name), new TypeScriptObject($properties))),
-            new ReflectionClassReference($reflectionClass),
-            $context->name,
-            true,
-            $context->nameSpaceSegments,
-        );
+        return new TypeScriptObject($properties);
     }
 
-    abstract public function shouldTransform(ReflectionClass $reflection): bool;
+    protected function resolveTypeByAttribute(
+        ReflectionClass $reflectionClass,
+        ?ReflectionProperty $property = null,
+    ): ?TypeScriptNode {
+        $subject = $property ?? $reflectionClass;
+
+        foreach ($subject->getAttributes() as $attribute) {
+            if (is_a($attribute->getName(), TypeScriptTypeAttributeContract::class, true)) {
+                /** @var TypeScriptTypeAttributeContract $attributeInstance */
+                $attributeInstance = $attribute->newInstance();
+
+                return $attributeInstance->getType($reflectionClass);
+            }
+        }
+
+        return null;
+    }
 
     protected function getProperties(ReflectionClass $reflection): array
     {
@@ -103,6 +138,10 @@ protected function resolveTypeForProperty(
         ReflectionProperty $reflectionProperty,
         ?ParsedNameAndType $annotation,
     ): TypeScriptNode {
+        if ($resolvedAttributeType = $this->resolveTypeByAttribute($reflectionClass, $reflectionProperty)) {
+            return $resolvedAttributeType;
+        }
+
         if ($annotation) {
             return $this->transpilePhpStanTypeToTypeScriptTypeAction->execute(
                 $annotation->type,