vite-plugin-ferry 0.1.1 → 0.1.3

package/README.md

@@ -10,10 +10,14 @@ in sync with your backend.
 - **Enums** — Generates types and runtime constants from `app/Enums/`
 - **Resources** — Generates response types from `app/Http/Resources/`
 
+## Requirements
+
+- **TypeScript ^5.0** — Required as a peer dependency for code generation
+
 ## Installation
 
 ```bash
-npm install vite-plugin-ferry --save-dev
+npm install vite-plugin-ferry typescript@^5 --save-dev
 ```
 
 Add it to your `vite.config.ts`:
@@ -33,7 +37,77 @@ Import your backend types directly in your frontend code:
 
 ```ts
 import { OrderStatus } from '@ferry/enums';
-import { UserResource } from '@ferry/resources';
+import type { UserResource } from '@ferry/resources';
+```
+
+## Examples
+
+### Enums
+
+A PHP enum with labels:
+
+```php
+// app/Enums/OrderStatus.php
+enum OrderStatus: string
+{
+    case Pending = 'pending';
+    case Shipped = 'shipped';
+    case Delivered = 'delivered';
+
+    public function label(): string
+    {
+        return match ($this) {
+            self::Pending => 'Pending Order',
+            self::Shipped => 'Shipped',
+            self::Delivered => 'Delivered',
+        };
+    }
+}
+```
+
+Generates:
+
+```ts
+// @ferry/enums
+export declare const OrderStatus: {
+  Pending: { value: 'pending'; label: 'Pending Order' };
+  Shipped: { value: 'shipped'; label: 'Shipped' };
+  Delivered: { value: 'delivered'; label: 'Delivered' };
+};
+```
+
+### Resources
+
+A Laravel JsonResource:
+
+```php
+// app/Http/Resources/UserResource.php
+class UserResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->resource->id,
+            'name' => $this->resource->name,
+            'email' => $this->resource->email,
+            'created_at' => $this->resource->created_at,
+            'posts' => PostResource::collection($this->whenLoaded('posts')),
+        ];
+    }
+}
+```
+
+Generates:
+
+```ts
+// @ferry/resources
+export type UserResource = {
+  id: string;
+  name: string;
+  email: string;
+  created_at: string;
+  posts?: PostResource[];
+};
 ```
 
 ## License

package/dist/generators/enums.d.ts

@@ -3,6 +3,7 @@ export type EnumGeneratorOptions = {
     enumsDir: string;
     outputDir: string;
     packageName: string;
+    prettyPrint?: boolean;
 };
 /**
  * Generate TypeScript type declarations for enums.
@@ -11,9 +12,10 @@ export declare function generateEnumTypeScript(enums: Record<string, EnumDefinit
 /**
  * Generate runtime JavaScript for enums.
  */
-export declare function generateEnumRuntime(enums: Record<string, EnumDefinition>): string;
+export declare function generateEnumRuntime(enums: Record<string, EnumDefinition>, prettyPrint?: boolean): string;
 /**
  * Collect all enum definitions from the enums directory.
+ * This is a plugin-level function that handles file I/O.
  */
 export declare function collectEnums(enumsDir: string): Record<string, EnumDefinition>;
 /**

package/dist/generators/enums.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../src/generators/enums.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE5E,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,MAAM,CAyCpF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,MAAM,CAyBjF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAuB7E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CA6BjE"}
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../src/generators/enums.ts"],"names":[],"mappings":"AAIA,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAc/E,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,MAAM,CA4BpF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAAE,WAAW,UAAO,GAAG,MAAM,CAgCrG;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CA0B7E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CA6BjE"}

package/dist/generators/enums.js

@@ -1,81 +1,71 @@
+import ts from 'typescript';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { getPhpFiles, writeFileEnsureDir } from '../utils/file.js';
-import { parseEnumFile } from '../utils/php-parser.js';
+import { getPhpFiles, readFileSafe, writeFileEnsureDir } from '../utils/file.js';
+import { parseEnumContent } from '../utils/php-parser.js';
+import { printNodes, createEnum, createConstObject, createObjectLiteral, createDeclareConstWithType, createTypeLiteral, createStringLiteral, createNumericLiteral, createExportDefault, printNode, } from '../utils/ts-generator.js';
 /**
  * Generate TypeScript type declarations for enums.
  */
 export function generateEnumTypeScript(enums) {
-    const lines = [];
-    lines.push('// This file is auto-generated by the primcloud Vite plugin.');
-    lines.push('// Do not edit directly.');
-    lines.push('');
+    const nodes = [];
     for (const enumName of Object.keys(enums)) {
         const enumDef = enums[enumName];
         const hasLabels = enumDef.cases.some((c) => c.label);
         if (hasLabels) {
-            // Generate a const object with typed properties for enums with labels
-            lines.push(`export declare const ${enumDef.name}: {`);
-            for (const c of enumDef.cases) {
-                const val = String(c.value).replace(/'/g, "\\'");
-                const label = c.label ? String(c.label).replace(/'/g, "\\'") : val;
-                lines.push(`    ${c.key}: { value: '${val}'; label: '${label}' };`);
-            }
-            lines.push('};');
-            lines.push('');
+            // Generate a declare const with typed properties for enums with labels
+            const properties = enumDef.cases.map((c) => ({
+                name: c.key,
+                type: createTypeLiteral([
+                    { name: 'value', type: ts.factory.createLiteralTypeNode(createStringLiteral(String(c.value))) },
+                    {
+                        name: 'label',
+                        type: ts.factory.createLiteralTypeNode(createStringLiteral(c.label || String(c.value))),
+                    },
+                ]),
+            }));
+            nodes.push(createDeclareConstWithType(enumDef.name, createTypeLiteral(properties)));
         }
         else {
-            // Generate a traditional enum for enums without labels
-            lines.push(`export enum ${enumDef.name} {`);
-            for (const c of enumDef.cases) {
-                const val = c.value;
-                if (enumDef.backing === 'int' || enumDef.backing === 'integer') {
-                    if (!isNaN(Number(val))) {
-                        lines.push(`    ${c.key} = ${val},`);
-                    }
-                    else {
-                        lines.push(`    ${c.key} = '${val}',`);
-                    }
-                }
-                else {
-                    lines.push(`    ${c.key} = '${String(val).replace(/'/g, "\\'")}',`);
-                }
-            }
-            lines.push('}');
-            lines.push('');
+            // Generate a traditional enum
+            nodes.push(createEnum(enumDef.name, enumDef.cases.map((c) => ({ key: c.key, value: c.value }))));
         }
     }
-    return lines.join('\n');
+    return nodes.length > 0 ? printNodes(nodes) + '\n' : '';
 }
 /**
  * Generate runtime JavaScript for enums.
  */
-export function generateEnumRuntime(enums) {
-    const lines = [];
-    lines.push('// Auto-generated by primcloud Vite plugin');
-    lines.push('');
+export function generateEnumRuntime(enums, prettyPrint = true) {
+    const nodes = [];
     for (const enumName of Object.keys(enums)) {
         const enumDef = enums[enumName];
         const hasLabels = enumDef.cases.some((c) => c.label);
-        lines.push(`export const ${enumDef.name} = {`);
-        for (const c of enumDef.cases) {
-            const val = String(c.value).replace(/'/g, "\\'");
+        const properties = enumDef.cases.map((c) => {
+            let value;
             if (hasLabels) {
-                const label = c.label ? String(c.label).replace(/'/g, "\\'") : val;
-                lines.push(`  ${c.key}: { value: '${val}', label: '${label}' },`);
+                value = createObjectLiteral([
+                    { key: 'value', value: createStringLiteral(String(c.value)) },
+                    { key: 'label', value: createStringLiteral(c.label || String(c.value)) },
+                ], prettyPrint);
+            }
+            else if (typeof c.value === 'number') {
+                value = createNumericLiteral(c.value);
             }
             else {
-                lines.push(`  ${c.key}: '${val}',`);
+                value = createStringLiteral(String(c.value));
             }
-        }
-        lines.push('};');
-        lines.push('');
+            return { key: c.key, value };
+        });
+        nodes.push(createConstObject(enumDef.name, properties));
     }
-    lines.push('export default {};');
-    return lines.join('\n');
+    // Add export default {}
+    nodes.push(createExportDefault(ts.factory.createObjectLiteralExpression([])));
+    return nodes.map(printNode).join('\n\n') + '\n';
 }
 /**
  * Collect all enum definitions from the enums directory.
+ * This is a plugin-level function that handles file I/O.
  */
 export function collectEnums(enumsDir) {
     const enums = {};
@@ -86,7 +76,10 @@ export function collectEnums(enumsDir) {
     for (const file of enumFiles) {
         try {
             const enumPath = join(enumsDir, file);
-            const def = parseEnumFile(enumPath);
+            const content = readFileSafe(enumPath);
+            if (!content)
+                continue;
+            const def = parseEnumContent(content);
             if (def) {
                 enums[def.name] = def;
             }
@@ -102,7 +95,7 @@ export function collectEnums(enumsDir) {
  * Generate enum files (TypeScript declarations and runtime JavaScript).
  */
 export function generateEnums(options) {
-    const { enumsDir, outputDir, packageName } = options;
+    const { enumsDir, outputDir, packageName, prettyPrint = true } = options;
     // Collect all enums
     const enums = collectEnums(enumsDir);
     // Generate TypeScript declarations
@@ -110,7 +103,7 @@ export function generateEnums(options) {
     const dtsPath = join(outputDir, 'index.d.ts');
     writeFileEnsureDir(dtsPath, dtsContent);
     // Generate runtime JavaScript
-    const jsContent = generateEnumRuntime(enums);
+    const jsContent = generateEnumRuntime(enums, prettyPrint);
     const jsPath = join(outputDir, 'index.js');
     writeFileEnsureDir(jsPath, jsContent);
     // Generate package.json

package/dist/generators/resources.d.ts

@@ -1,14 +1,20 @@
+import { type EnumDefinition } from '../utils/php-parser.js';
 export type ResourceGeneratorOptions = {
     resourcesDir: string;
     enumsDir: string;
     modelsDir: string;
     outputDir: string;
     packageName: string;
+    prettyPrint?: boolean;
 };
-type FieldInfo = {
+export type FieldInfo = {
     type: string;
     optional: boolean;
 };
+/**
+ * Parse fields from a PHP array block (from toArray() method).
+ */
+export declare function parseFieldsFromArrayBlock(block: string, resourceClass: string, docShape: Record<string, string> | null, resourcesDir: string, modelsDir: string, enumsDir: string, collectedEnums: Record<string, EnumDefinition>): Record<string, FieldInfo>;
 /**
  * Generate TypeScript type declarations for resources.
  */
@@ -22,5 +28,4 @@ export declare function generateResourceRuntime(): string;
  * Generate resource type files (TypeScript declarations and runtime JavaScript).
  */
 export declare function generateResources(options: ResourceGeneratorOptions): void;
-export {};
 //# sourceMappingURL=resources.d.ts.map

package/dist/generators/resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/generators/resources.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAiOF;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,EACpD,SAAS,EAAE,MAAM,EAAE,EACnB,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAC3B,MAAM,CAmCR;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAOhD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,CAqEzE"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/generators/resources.ts"],"names":[],"mappings":"AAIA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAC;AAUhC,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAgIF;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,EACvC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GAC7C,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAyF3B;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,EACpD,SAAS,EAAE,MAAM,EAAE,EACnB,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAC3B,MAAM,CAuCR;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,CAqEzE"}

package/dist/generators/resources.js

@@ -1,23 +1,27 @@
+import ts from 'typescript';
 import { existsSync } from 'node:fs';
 import { join, parse } from 'node:path';
 import { getPhpFiles, readFileSafe, writeFileEnsureDir } from '../utils/file.js';
-import { extractDocblockArrayShape, extractReturnArrayBlock, getModelCasts, parseEnumFile, } from '../utils/php-parser.js';
+import { extractDocblockArrayShape, extractReturnArrayBlock, parseEnumContent, parseModelCasts, } from '../utils/php-parser.js';
 import { mapDocTypeToTs, mapPhpTypeToTs, parseTsObjectStringToPairs } from '../utils/type-mapper.js';
+import { printNode, createTypeAlias, createImportType, parseTypeString, createTypeLiteral, } from '../utils/ts-generator.js';
 /**
  * Map a PHP cast to a TypeScript type, potentially collecting enum references.
  */
 function mapCastToType(cast, enumsDir, collectedEnums) {
     const original = cast;
-    const lower = cast.toLowerCase();
     // Try to find enum in app/Enums
     const match = original.match(/([A-Za-z0-9_\\]+)$/);
     const short = match ? match[1].replace(/^\\+/, '') : original;
     const enumPath = join(enumsDir, `${short}.php`);
     if (existsSync(enumPath)) {
-        const def = parseEnumFile(enumPath);
-        if (def) {
-            collectedEnums[def.name] = def;
-            return def.name;
+        const content = readFileSafe(enumPath);
+        if (content) {
+            const def = parseEnumContent(content);
+            if (def) {
+                collectedEnums[def.name] = def;
+                return def.name;
+            }
         }
     }
     return mapPhpTypeToTs(cast);
@@ -71,14 +75,17 @@ function inferTypeFromValue(value, key, resourceClass, resourcesDir, modelsDir,
         const modelCandidate = resourceClass.replace(/Resource$/, '');
         const modelPath = join(modelsDir, `${modelCandidate}.php`);
         if (existsSync(modelPath)) {
-            const casts = getModelCasts(modelPath);
-            if (casts[prop]) {
-                const cast = casts[prop];
-                const trim = cast.trim();
-                const tsType = trim.startsWith('{') || trim.includes(':') || /array\s*\{/.test(trim)
-                    ? trim
-                    : mapCastToType(cast, enumsDir, collectedEnums);
-                return { type: tsType, optional: false };
+            const modelContent = readFileSafe(modelPath);
+            if (modelContent) {
+                const casts = parseModelCasts(modelContent);
+                if (casts[prop]) {
+                    const cast = casts[prop];
+                    const trim = cast.trim();
+                    const tsType = trim.startsWith('{') || trim.includes(':') || /array\s*\{/.test(trim)
+                        ? trim
+                        : mapCastToType(cast, enumsDir, collectedEnums);
+                    return { type: tsType, optional: false };
+                }
             }
         }
         // Number heuristics
@@ -100,7 +107,7 @@ function inferTypeFromValue(value, key, resourceClass, resourcesDir, modelsDir,
 /**
  * Parse fields from a PHP array block (from toArray() method).
  */
-function parseFieldsFromArrayBlock(block, resourceClass, docShape, resourcesDir, modelsDir, enumsDir, collectedEnums) {
+export function parseFieldsFromArrayBlock(block, resourceClass, docShape, resourcesDir, modelsDir, enumsDir, collectedEnums) {
     const lines = block.split(/\r?\n/);
     const fields = {};
     for (let i = 0; i < lines.length; i++) {
@@ -175,47 +182,45 @@ function parseFieldsFromArrayBlock(block, resourceClass, docShape, resourcesDir,
  * Generate TypeScript type declarations for resources.
  */
 export function generateResourceTypeScript(resources, fallbacks, referencedEnums) {
-    const lines = [];
-    lines.push('// This file is auto-generated by the primcloud Vite plugin.');
-    lines.push('// Do not edit directly.');
-    lines.push('');
+    const nodes = [];
     // Import referenced enums from @app/enums
     if (referencedEnums.size > 0) {
-        const enumImports = Array.from(referencedEnums).sort().join(', ');
-        lines.push(`import type { ${enumImports} } from '@app/enums';`);
-        lines.push('');
+        const enumImports = Array.from(referencedEnums).sort();
+        nodes.push(createImportType(enumImports, '@app/enums'));
     }
     // Generate resource types
     for (const className of Object.keys(resources)) {
         const fields = resources[className];
         if (fallbacks.includes(className)) {
-            lines.push(`export type ${className} = Record<string, any>;`);
-            lines.push('');
+            // Fallback type: Record<string, any>
+            const recordType = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+            ]);
+            nodes.push(createTypeAlias(className, recordType));
             continue;
         }
-        lines.push(`export type ${className} = {`);
-        for (const key of Object.keys(fields)) {
+        // Create type literal with all fields
+        const properties = Object.keys(fields).map((key) => {
             const info = fields[key];
-            const type = info.type || 'any';
-            const optional = info.optional ? '?' : '';
-            lines.push(`    ${key}${optional}: ${type};`);
-        }
-        lines.push('};');
-        lines.push('');
+            return {
+                name: key,
+                type: parseTypeString(info.type || 'any'),
+                optional: info.optional,
+            };
+        });
+        nodes.push(createTypeAlias(className, createTypeLiteral(properties)));
     }
-    return lines.join('\n');
+    if (nodes.length === 0)
+        return '';
+    return nodes.map(printNode).join('\n\n') + '\n';
 }
 /**
  * Generate runtime JavaScript for resources.
  * Resources are type-only, so this just exports an empty object.
  */
 export function generateResourceRuntime() {
-    const lines = [];
-    lines.push('// Auto-generated by primcloud Vite plugin');
-    lines.push('// Resources are type-only exports');
-    lines.push('');
-    lines.push('export default {};');
-    return lines.join('\n');
+    return 'export default {};';
 }
 /**
  * Generate resource type files (TypeScript declarations and runtime JavaScript).

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { Plugin } from 'vite';
 export type ResourceTypesPluginOptions = {
     cwd?: string;
+    prettyPrint?: boolean;
 };
 /**
  * Vite plugin for generating TypeScript types from Laravel PHP files.

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAMnC,MAAM,MAAM,0BAA0B,GAAG;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,OAAO,GAAE,0BAER,GACA,MAAM,CA8ER"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAMnC,MAAM,MAAM,0BAA0B,GAAG;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,OAAO,GAAE,0BAA+B,GAAG,MAAM,CAyF9E"}

package/dist/index.js

@@ -11,18 +11,19 @@ import { setupResourceWatcher } from './watchers/resources.js';
  * - @app/resources - Laravel JsonResource types
  * - @app/schemas - (future) Zod schemas from FormRequests
  */
-export default function ferry(options = {
-    cwd: process.cwd(),
-}) {
+export default function ferry(options = {}) {
     const namespace = '@ferry';
     const name = 'vite-plugin-ferry';
+    // Apply defaults
+    const cwd = options.cwd ?? process.cwd();
+    const prettyPrint = options.prettyPrint ?? true;
     // Directory paths
-    const enumsDir = join(options.cwd, 'app/Enums');
-    const resourcesDir = join(options.cwd, 'app/Http/Resources');
-    const modelsDir = join(options.cwd, 'app/Models');
+    const enumsDir = join(cwd, 'app/Enums');
+    const resourcesDir = join(cwd, 'app/Http/Resources');
+    const modelsDir = join(cwd, 'app/Models');
     // Output directories for each package
-    const enumsOutputDir = join(options.cwd, 'node_modules', ...namespace.split('/'), 'enums');
-    const resourcesOutputDir = join(options.cwd, 'node_modules', ...namespace.split('/'), 'resources');
+    const enumsOutputDir = join(cwd, 'node_modules', ...namespace.split('/'), 'enums');
+    const resourcesOutputDir = join(cwd, 'node_modules', ...namespace.split('/'), 'resources');
     /**
      * Generate all packages.
      */
@@ -32,6 +33,7 @@ export default function ferry(options = {
             enumsDir,
             outputDir: enumsOutputDir,
             packageName: `${namespace}/enums`,
+            prettyPrint,
         });
         // Generate @app/resources package
         generateResources({
@@ -40,6 +42,7 @@ export default function ferry(options = {
             modelsDir,
             outputDir: resourcesOutputDir,
             packageName: `${namespace}/resources`,
+            prettyPrint,
         });
     }
     return {
@@ -53,7 +56,11 @@ export default function ferry(options = {
             catch (e) {
                 console.error(`[${name}] Error generating types during config():`, e);
             }
-            return null;
+            return {
+                optimizeDeps: {
+                    exclude: [`${namespace}/enums`, `${namespace}/resources`],
+                },
+            };
         },
         // Run generation when build starts
         buildStart() {

package/dist/utils/php-parser.d.ts

@@ -1,6 +1,6 @@
 export type EnumCase = {
     key: string;
-    value: string;
+    value: string | number;
     label?: string;
 };
 export type EnumDefinition = {
@@ -9,23 +9,23 @@ export type EnumDefinition = {
     cases: EnumCase[];
 };
 /**
- * Parse a PHP enum file and extract its definition.
+ * Parse PHP enum content and extract its definition.
+ * This is a pure function that takes PHP source code as input.
  */
-export declare function parseEnumFile(enumPath: string): EnumDefinition | null;
+export declare function parseEnumContent(phpContent: string): EnumDefinition | null;
 /**
- * Parse PHP array pairs from a string like "'key' => 'value'".
+ * Parse model casts from PHP model content.
+ * This is a pure function that takes PHP source code as input.
  */
-export declare function parsePhpArrayPairs(inside: string): Record<string, string>;
+export declare function parseModelCasts(phpContent: string): Record<string, string>;
 /**
- * Extract model casts from a PHP model file.
- */
-export declare function getModelCasts(modelPath: string): Record<string, string>;
-/**
- * Extract docblock array shape from PHP file content.
+ * Extract docblock array shape from PHP content.
+ * This is a pure function that takes PHP source code as input.
  */
 export declare function extractDocblockArrayShape(phpContent: string): Record<string, string> | null;
 /**
- * Extract the return array block from a toArray() method in a PHP resource.
+ * Extract the return array block from a toArray() method in PHP content.
+ * This is a pure function that takes PHP source code as input.
  */
 export declare function extractReturnArrayBlock(phpContent: string): string | null;
 //# sourceMappingURL=php-parser.d.ts.map

package/dist/utils/php-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"php-parser.d.ts","sourceRoot":"","sources":["../../src/utils/php-parser.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CA8CrE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoBzE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA4BvE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAqE3F;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASzE"}
+{"version":3,"file":"php-parser.d.ts","sourceRoot":"","sources":["../../src/utils/php-parser.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB,CAAC;AA6FF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAsF1E;AA4CD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwC1E;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAwE3F;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASzE"}

package/dist/utils/php-parser.js

@@ -1,96 +1,267 @@
-import { readFileSafe } from './file.js';
+// Import php-parser (CommonJS module with constructor)
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const PhpParser = require('php-parser');
+// Initialize the PHP parser (PHP 8+ only)
+const parser = new PhpParser({
+    parser: {
+        extractDoc: true,
+        php8: true,
+    },
+    ast: {
+        withPositions: false,
+    },
+});
 /**
- * Parse a PHP enum file and extract its definition.
+ * Parse PHP content and return the AST.
+ * Uses parseEval which doesn't require <?php tags or filenames.
  */
-export function parseEnumFile(enumPath) {
-    const content = readFileSafe(enumPath);
-    if (!content)
+function parsePhp(content) {
+    try {
+        // Strip <?php tag if present (parseEval expects raw PHP code)
+        let code = content.trimStart();
+        if (code.startsWith('<?php')) {
+            code = code.slice(5);
+        }
+        else if (code.startsWith('<?')) {
+            code = code.slice(2);
+        }
+        return parser.parseEval(code);
+    }
+    catch {
         return null;
-    // Extract enum name and backing type
-    const enumMatch = content.match(/enum\s+([A-Za-z0-9_]+)\s*(?:\:\s*([A-Za-z0-9_]+))?/);
-    if (!enumMatch)
+    }
+}
+/**
+ * Walk all child nodes in an AST node.
+ */
+function walkChildren(node, callback) {
+    const obj = node;
+    for (const key of Object.keys(obj)) {
+        const val = obj[key];
+        if (val && typeof val === 'object' && val.kind) {
+            if (callback(val))
+                return true;
+        }
+        else if (Array.isArray(val)) {
+            for (const item of val) {
+                if (item && typeof item === 'object' && item.kind) {
+                    if (callback(item))
+                        return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Find a node by kind in the AST.
+ */
+function findNodeByKind(ast, kind) {
+    if (ast.kind === kind)
+        return ast;
+    let result = null;
+    walkChildren(ast, (child) => {
+        const found = findNodeByKind(child, kind);
+        if (found) {
+            result = found;
+            return true;
+        }
+        return false;
+    });
+    return result;
+}
+/**
+ * Find all nodes of a specific kind in the AST.
+ */
+function findAllNodesByKind(ast, kind) {
+    const results = [];
+    function walk(node) {
+        if (node.kind === kind) {
+            results.push(node);
+        }
+        walkChildren(node, (child) => {
+            walk(child);
+            return false;
+        });
+    }
+    walk(ast);
+    return results;
+}
+/**
+ * Extract string value from a PHP literal node.
+ */
+function getStringValue(node) {
+    if (node.kind === 'string') {
+        return node.value;
+    }
+    if (node.kind === 'number') {
+        return String(node.value);
+    }
+    return null;
+}
+/**
+ * Parse PHP enum content and extract its definition.
+ * This is a pure function that takes PHP source code as input.
+ */
+export function parseEnumContent(phpContent) {
+    const ast = parsePhp(phpContent);
+    if (!ast)
+        return null;
+    // Find the enum declaration
+    const enumNode = findNodeByKind(ast, 'enum');
+    if (!enumNode)
         return null;
-    const name = enumMatch[1];
-    const backing = enumMatch[2] ? enumMatch[2].toLowerCase() : null;
+    const name = typeof enumNode.name === 'string' ? enumNode.name : enumNode.name.name;
+    const backing = enumNode.valueType ? enumNode.valueType.name.toLowerCase() : null;
     // Extract enum cases
     const cases = [];
-    const explicitCases = [...content.matchAll(/case\s+([A-Za-z0-9_]+)\s*=\s*'([^']*)'\s*;/g)];
-    if (explicitCases.length) {
-        for (const match of explicitCases) {
-            cases.push({ key: match[1], value: match[2] });
+    const enumCases = findAllNodesByKind(enumNode, 'enumcase');
+    for (const enumCase of enumCases) {
+        // Name can be an Identifier or string
+        const key = typeof enumCase.name === 'string'
+            ? enumCase.name
+            : enumCase.name.name;
+        let value;
+        if (enumCase.value !== null && enumCase.value !== undefined) {
+            // Value is a String or Number node (types say string|number but runtime is Node)
+            const valueNode = enumCase.value;
+            if (typeof valueNode === 'object' && valueNode.kind) {
+                if (valueNode.kind === 'number') {
+                    // php-parser returns number values as strings, convert to actual number
+                    value = Number(valueNode.value);
+                }
+                else {
+                    const extracted = getStringValue(valueNode);
+                    value = extracted !== null ? extracted : key;
+                }
+            }
+            else {
+                value = String(enumCase.value);
+            }
         }
-    }
-    else {
-        const implicitCases = [...content.matchAll(/case\s+([A-Za-z0-9_]+)\s*;/g)];
-        for (const match of implicitCases) {
-            cases.push({ key: match[1], value: match[1] });
+        else {
+            value = key;
         }
+        cases.push({ key, value });
     }
-    // Parse getLabel() method if it exists
-    const labelMethodMatch = content.match(/function\s+getLabel\s*\(\s*\)\s*:\s*string\s*\{[\s\S]*?return\s+match\s*\(\s*\$this\s*\)\s*\{([\s\S]*?)\};/);
-    if (labelMethodMatch) {
-        const matchBody = labelMethodMatch[1];
-        const labelMatches = [...matchBody.matchAll(/self::([A-Za-z0-9_]+)\s*=>\s*'([^']*)'/g)];
-        for (const labelMatch of labelMatches) {
-            const caseKey = labelMatch[1];
-            const labelValue = labelMatch[2];
-            const enumCase = cases.find((c) => c.key === caseKey);
-            if (enumCase) {
-                enumCase.label = labelValue;
+    // Parse label() method if it exists
+    const methods = findAllNodesByKind(enumNode, 'method');
+    const labelMethod = methods.find((m) => {
+        const methodName = typeof m.name === 'string' ? m.name : m.name.name;
+        return methodName === 'label';
+    });
+    if (labelMethod && labelMethod.body) {
+        // Find match expression in the method
+        const matchNode = findNodeByKind(labelMethod.body, 'match');
+        if (matchNode && matchNode.arms) {
+            for (const arm of matchNode.arms) {
+                if (arm.conds) {
+                    for (const cond of arm.conds) {
+                        // Handle self::CASE_NAME
+                        if (cond.kind === 'staticlookup') {
+                            const lookup = cond;
+                            const offset = lookup.offset;
+                            const caseName = typeof offset === 'string'
+                                ? offset
+                                : offset.kind === 'identifier'
+                                    ? offset.name
+                                    : null;
+                            if (caseName) {
+                                const labelValue = getStringValue(arm.body);
+                                if (labelValue !== null) {
+                                    const enumCase = cases.find((c) => c.key === caseName);
+                                    if (enumCase) {
+                                        enumCase.label = labelValue;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
         }
     }
     return { name, backing, cases };
 }
 /**
- * Parse PHP array pairs from a string like "'key' => 'value'".
+ * Extract key-value pairs from a PHP array node.
  */
-export function parsePhpArrayPairs(inside) {
+function extractArrayPairs(arrayNode) {
     const pairs = {};
-    const re = /["'](?<key>[A-Za-z0-9_]+)["']\s*=>\s*(?<val>[^,\n]+)/g;
-    for (const m of inside.matchAll(re)) {
-        let val = m.groups.val.trim();
-        val = val.replace(/[,\s]*$/g, '');
-        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
-            val = val.slice(1, -1);
-        }
-        if (val.endsWith('::class')) {
-            val = val.slice(0, -7);
+    for (const item of arrayNode.items) {
+        if (item.kind === 'entry') {
+            const entry = item;
+            const key = entry.key ? getStringValue(entry.key) : null;
+            if (!key)
+                continue;
+            const value = entry.value;
+            let strValue = null;
+            if (value.kind === 'string' || value.kind === 'number') {
+                strValue = getStringValue(value);
+            }
+            else if (value.kind === 'staticlookup') {
+                // Handle Foo::class
+                const lookup = value;
+                const offset = lookup.offset;
+                if (offset &&
+                    offset.kind === 'identifier' &&
+                    offset.name === 'class') {
+                    const what = lookup.what;
+                    if (what.kind === 'name') {
+                        strValue = what.name.replace(/^\\+/, '');
+                    }
+                }
+            }
+            if (strValue !== null) {
+                pairs[key] = strValue;
+            }
         }
-        pairs[m.groups.key] = val;
     }
     return pairs;
 }
 /**
- * Extract model casts from a PHP model file.
+ * Parse model casts from PHP model content.
+ * This is a pure function that takes PHP source code as input.
  */
-export function getModelCasts(modelPath) {
-    const content = readFileSafe(modelPath);
-    if (!content)
+export function parseModelCasts(phpContent) {
+    const ast = parsePhp(phpContent);
+    if (!ast)
         return {};
-    // Try protected $casts property
-    const castsMatch = content.match(/protected\s+\$casts\s*=\s*\[([^\]]*)\]/s);
-    if (castsMatch) {
-        return parsePhpArrayPairs(castsMatch[1]);
-    }
-    // Try casts() method
-    const castsMethodMatch = content.match(/function\s+casts\s*\([^)]*\)\s*\{[^}]*return\s*\[([^\]]*)\]/s);
-    if (castsMethodMatch) {
-        return parsePhpArrayPairs(castsMethodMatch[1]);
+    // Find the class
+    const classNode = findNodeByKind(ast, 'class');
+    if (!classNode)
+        return {};
+    // Look for protected $casts property
+    const propertyStatements = findAllNodesByKind(classNode, 'propertystatement');
+    for (const propStmt of propertyStatements) {
+        for (const prop of propStmt.properties) {
+            // prop.name can be a string or Identifier
+            const propName = typeof prop.name === 'string'
+                ? prop.name
+                : prop.name.name;
+            if (propName === 'casts' && prop.value && prop.value.kind === 'array') {
+                return extractArrayPairs(prop.value);
+            }
+        }
     }
-    // Try class-based casts
-    const matches = [...content.matchAll(/["'](?<key>[A-Za-z0-9_]+)["']\s*=>\s*(?<class>[A-Za-z0-9_\\]+)::class/g)];
-    const res = {};
-    for (const m of matches) {
-        const k = m.groups.key;
-        let v = m.groups.class;
-        v = v.replace(/^\\+/, '');
-        res[k] = v;
+    // Look for casts() method
+    const methods = findAllNodesByKind(classNode, 'method');
+    const castsMethod = methods.find((m) => {
+        const methodName = typeof m.name === 'string' ? m.name : m.name.name;
+        return methodName === 'casts';
+    });
+    if (castsMethod && castsMethod.body) {
+        // Find return statement with array
+        const returnNode = findNodeByKind(castsMethod.body, 'return');
+        if (returnNode && returnNode.expr && returnNode.expr.kind === 'array') {
+            return extractArrayPairs(returnNode.expr);
+        }
     }
-    return res;
+    return {};
 }
 /**
- * Extract docblock array shape from PHP file content.
+ * Extract docblock array shape from PHP content.
+ * This is a pure function that takes PHP source code as input.
  */
 export function extractDocblockArrayShape(phpContent) {
     const match = phpContent.match(/@return\s+array\s*\{/s);
@@ -119,7 +290,9 @@ export function extractDocblockArrayShape(phpContent) {
     }
     if (endPos === null)
         return null;
-    const inside = phpContent.slice(openBracePos + 1, endPos);
+    // Extract content and strip docblock asterisks from multiline format
+    let inside = phpContent.slice(openBracePos + 1, endPos);
+    inside = inside.replace(/^\s*\*\s?/gm, '');
     const pairs = {};
     let i = 0;
     while (i < inside.length) {
@@ -166,7 +339,8 @@ export function extractDocblockArrayShape(phpContent) {
     return pairs;
 }
 /**
- * Extract the return array block from a toArray() method in a PHP resource.
+ * Extract the return array block from a toArray() method in PHP content.
+ * This is a pure function that takes PHP source code as input.
  */
 export function extractReturnArrayBlock(phpContent) {
     const match = phpContent.match(/function\s+toArray\s*\([^)]*\)\s*:\s*array\s*\{([\s\S]*?)\n\s*\}/);

package/dist/utils/ts-generator.d.ts

@@ -0,0 +1,67 @@
+import ts from 'typescript';
+/**
+ * Print a TypeScript node to a string.
+ */
+export declare function printNode(node: ts.Node): string;
+/**
+ * Print multiple TypeScript nodes to a string with blank lines between them.
+ */
+export declare function printNodes(nodes: ts.Node[]): string;
+/**
+ * Create a string literal type node.
+ */
+export declare function createStringLiteral(value: string): ts.StringLiteral;
+/**
+ * Create a numeric literal node.
+ */
+export declare function createNumericLiteral(value: number): ts.NumericLiteral;
+/**
+ * Create an enum declaration.
+ */
+export declare function createEnum(name: string, members: Array<{
+    key: string;
+    value: string | number;
+}>): ts.EnumDeclaration;
+/**
+ * Create an object literal expression.
+ */
+export declare function createObjectLiteral(properties: Array<{
+    key: string;
+    value: ts.Expression;
+}>, multiLine?: boolean): ts.ObjectLiteralExpression;
+/**
+ * Create a const declaration with an object literal.
+ */
+export declare function createConstObject(name: string, properties: Array<{
+    key: string;
+    value: ts.Expression;
+}>, multiLine?: boolean): ts.VariableStatement;
+/**
+ * Create a declare const statement with a typed object.
+ */
+export declare function createDeclareConstWithType(name: string, type: ts.TypeNode): ts.VariableStatement;
+/**
+ * Create a type alias declaration.
+ */
+export declare function createTypeAlias(name: string, type: ts.TypeNode): ts.TypeAliasDeclaration;
+/**
+ * Create a type literal with property signatures.
+ */
+export declare function createTypeLiteral(properties: Array<{
+    name: string;
+    type: ts.TypeNode;
+    optional?: boolean;
+}>): ts.TypeLiteralNode;
+/**
+ * Create an import type declaration.
+ */
+export declare function createImportType(names: string[], from: string): ts.ImportDeclaration;
+/**
+ * Parse a type string into a TypeNode.
+ */
+export declare function parseTypeString(typeStr: string): ts.TypeNode;
+/**
+ * Create an export default statement.
+ */
+export declare function createExportDefault(expression: ts.Expression): ts.ExportAssignment;
+//# sourceMappingURL=ts-generator.d.ts.map

package/dist/utils/ts-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-generator.d.ts","sourceRoot":"","sources":["../../src/utils/ts-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAI5B;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAG/C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,GAAG,MAAM,CAEnD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC,aAAa,CAEnE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC,cAAc,CAErE;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC,GACtD,EAAE,CAAC,eAAe,CAWpB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAA;CAAE,CAAC,EACxD,SAAS,UAAO,GACf,EAAE,CAAC,uBAAuB,CAK5B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAA;CAAE,CAAC,EACxD,SAAS,UAAO,GACf,EAAE,CAAC,iBAAiB,CAUtB;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,EAAE,CAAC,iBAAiB,CAQhG;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,EAAE,CAAC,oBAAoB,CAOxF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,GACzE,EAAE,CAAC,eAAe,CAUpB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,iBAAiB,CAcpF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,EAAE,CAAC,QAAQ,CAiD5D;AAkDD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,gBAAgB,CAElF"}

package/dist/utils/ts-generator.js

@@ -0,0 +1,179 @@
+import ts from 'typescript';
+const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+/**
+ * Print a TypeScript node to a string.
+ */
+export function printNode(node) {
+    const sourceFile = ts.createSourceFile('output.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+}
+/**
+ * Print multiple TypeScript nodes to a string with blank lines between them.
+ */
+export function printNodes(nodes) {
+    return nodes.map(printNode).join('\n\n');
+}
+/**
+ * Create a string literal type node.
+ */
+export function createStringLiteral(value) {
+    return ts.factory.createStringLiteral(value);
+}
+/**
+ * Create a numeric literal node.
+ */
+export function createNumericLiteral(value) {
+    return ts.factory.createNumericLiteral(value);
+}
+/**
+ * Create an enum declaration.
+ */
+export function createEnum(name, members) {
+    const enumMembers = members.map((m) => {
+        const initializer = typeof m.value === 'number' ? createNumericLiteral(m.value) : createStringLiteral(m.value);
+        return ts.factory.createEnumMember(ts.factory.createIdentifier(m.key), initializer);
+    });
+    return ts.factory.createEnumDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(name), enumMembers);
+}
+/**
+ * Create an object literal expression.
+ */
+export function createObjectLiteral(properties, multiLine = true) {
+    const objectProperties = properties.map((p) => ts.factory.createPropertyAssignment(ts.factory.createIdentifier(p.key), p.value));
+    return ts.factory.createObjectLiteralExpression(objectProperties, multiLine);
+}
+/**
+ * Create a const declaration with an object literal.
+ */
+export function createConstObject(name, properties, multiLine = true) {
+    const objectLiteral = createObjectLiteral(properties, multiLine);
+    return ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier(name), undefined, undefined, objectLiteral)], ts.NodeFlags.Const));
+}
+/**
+ * Create a declare const statement with a typed object.
+ */
+export function createDeclareConstWithType(name, type) {
+    return ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword), ts.factory.createModifier(ts.SyntaxKind.DeclareKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier(name), undefined, type, undefined)], ts.NodeFlags.Const));
+}
+/**
+ * Create a type alias declaration.
+ */
+export function createTypeAlias(name, type) {
+    return ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(name), undefined, type);
+}
+/**
+ * Create a type literal with property signatures.
+ */
+export function createTypeLiteral(properties) {
+    const members = properties.map((p) => ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(p.name), p.optional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined, p.type));
+    return ts.factory.createTypeLiteralNode(members);
+}
+/**
+ * Create an import type declaration.
+ */
+export function createImportType(names, from) {
+    const importSpecifiers = names.map((name) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(name)));
+    return ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(true, // isTypeOnly
+    undefined, ts.factory.createNamedImports(importSpecifiers)), ts.factory.createStringLiteral(from));
+}
+/**
+ * Parse a type string into a TypeNode.
+ */
+export function parseTypeString(typeStr) {
+    // Handle common types
+    switch (typeStr) {
+        case 'string':
+            return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+        case 'number':
+            return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+        case 'boolean':
+            return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+        case 'any':
+            return ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword);
+        case 'null':
+            return ts.factory.createLiteralTypeNode(ts.factory.createNull());
+        case 'undefined':
+            return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);
+    }
+    // Handle array types like "string[]" or "User[]"
+    if (typeStr.endsWith('[]')) {
+        const elementType = parseTypeString(typeStr.slice(0, -2));
+        return ts.factory.createArrayTypeNode(elementType);
+    }
+    // Handle union types like "string | null"
+    if (typeStr.includes(' | ')) {
+        const types = typeStr.split(' | ').map((t) => parseTypeString(t.trim()));
+        return ts.factory.createUnionTypeNode(types);
+    }
+    // Handle Record<K, V>
+    const recordMatch = typeStr.match(/^Record<([^,]+),\s*([^>]+)>$/);
+    if (recordMatch) {
+        const keyType = parseTypeString(recordMatch[1].trim());
+        const valueType = parseTypeString(recordMatch[2].trim());
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [keyType, valueType]);
+    }
+    // Handle inline object types like "{ key: type; ... }"
+    if (typeStr.startsWith('{') && typeStr.endsWith('}')) {
+        const inner = typeStr.slice(1, -1).trim();
+        if (!inner) {
+            return ts.factory.createTypeLiteralNode([]);
+        }
+        const properties = parseObjectTypeProperties(inner);
+        return createTypeLiteral(properties);
+    }
+    // Default to type reference (custom types like "UserResource")
+    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeStr), undefined);
+}
+/**
+ * Parse object type properties from a string like "key: type; key2: type2"
+ */
+function parseObjectTypeProperties(inner) {
+    const properties = [];
+    let depth = 0;
+    let current = '';
+    let i = 0;
+    while (i < inner.length) {
+        const ch = inner[i];
+        if (ch === '{' || ch === '<' || ch === '(')
+            depth++;
+        else if (ch === '}' || ch === '>' || ch === ')')
+            depth--;
+        if ((ch === ';' || ch === ',') && depth === 0) {
+            const prop = parsePropertyString(current.trim());
+            if (prop)
+                properties.push(prop);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+        i++;
+    }
+    // Handle last property
+    const lastProp = parsePropertyString(current.trim());
+    if (lastProp)
+        properties.push(lastProp);
+    return properties;
+}
+/**
+ * Parse a single property string like "key: type" or "key?: type"
+ */
+function parsePropertyString(propStr) {
+    if (!propStr)
+        return null;
+    const match = propStr.match(/^([A-Za-z0-9_]+)(\?)?:\s*(.+)$/);
+    if (!match)
+        return null;
+    const [, name, optional, typeStr] = match;
+    return {
+        name,
+        type: parseTypeString(typeStr.trim()),
+        optional: !!optional,
+    };
+}
+/**
+ * Create an export default statement.
+ */
+export function createExportDefault(expression) {
+    return ts.factory.createExportAssignment(undefined, false, expression);
+}

package/package.json

@@ -3,7 +3,7 @@
   "prettier": "@aniftyco/prettier",
   "description": "Ferries Laravel types to your TypeScript frontend",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "repository": "https://github.com/aniftyco/vite-plugin-ferry",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,13 +13,21 @@
   "scripts": {
     "start": "tsc --watch",
     "build": "rm -rf dist/ && tsc",
-    "prepublishOnly": "rm -rf dist/ && tsc"
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "php-parser": "^3.2.5"
   },
   "devDependencies": {
     "@aniftyco/prettier": "^1.3.0",
     "@types/node": "^24",
     "prettier": "^3.6.2",
     "typescript": "^5.9.2",
-    "vite": "^7.3.0"
+    "vite": "^7.3.0",
+    "vitest": "^4.0.16"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
   }
 }