vite-plugin-ferry 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NiftyCo, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# vite-plugin-ferry
+
+> A Vite plugin that ferries your Laravel backend types to the frontend as fully-typed TypeScript.
+
+## What it does
+
+Ferry watches your Laravel application and automatically generates TypeScript definitions so your frontend always stays
+in sync with your backend.
+
+- **Enums** — Generates types and runtime constants from `app/Enums/`
+- **Resources** — Generates response types from `app/Http/Resources/`
+
+## Installation
+
+```bash
+npm install vite-plugin-ferry --save-dev
+```
+
+Add it to your `vite.config.ts`:
+
+```ts
+import { defineConfig } from 'vite';
+import ferry from 'vite-plugin-ferry';
+
+export default defineConfig({
+  plugins: [ferry()],
+});
+```
+
+## Usage
+
+Import your backend types directly in your frontend code:
+
+```ts
+import { OrderStatus } from '@ferry/enums';
+import { UserResource } from '@ferry/resources';
+```
+
+## License
+
+See [LICENSE](LICENSE) for details.

package/dist/generators/enums.d.ts

@@ -0,0 +1,23 @@
+import { type EnumDefinition } from '../utils/php-parser.js';
+export type EnumGeneratorOptions = {
+    enumsDir: string;
+    outputDir: string;
+    packageName: string;
+};
+/**
+ * Generate TypeScript type declarations for enums.
+ */
+export declare function generateEnumTypeScript(enums: Record<string, EnumDefinition>): string;
+/**
+ * Generate runtime JavaScript for enums.
+ */
+export declare function generateEnumRuntime(enums: Record<string, EnumDefinition>): string;
+/**
+ * Collect all enum definitions from the enums directory.
+ */
+export declare function collectEnums(enumsDir: string): Record<string, EnumDefinition>;
+/**
+ * Generate enum files (TypeScript declarations and runtime JavaScript).
+ */
+export declare function generateEnums(options: EnumGeneratorOptions): void;
+//# sourceMappingURL=enums.d.ts.map

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

@@ -0,0 +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"}

package/dist/generators/enums.js

@@ -0,0 +1,125 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { getPhpFiles, writeFileEnsureDir } from '../utils/file.js';
+import { parseEnumFile } from '../utils/php-parser.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('');
+    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('');
+        }
+        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('');
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate runtime JavaScript for enums.
+ */
+export function generateEnumRuntime(enums) {
+    const lines = [];
+    lines.push('// Auto-generated by primcloud Vite plugin');
+    lines.push('');
+    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, "\\'");
+            if (hasLabels) {
+                const label = c.label ? String(c.label).replace(/'/g, "\\'") : val;
+                lines.push(`  ${c.key}: { value: '${val}', label: '${label}' },`);
+            }
+            else {
+                lines.push(`  ${c.key}: '${val}',`);
+            }
+        }
+        lines.push('};');
+        lines.push('');
+    }
+    lines.push('export default {};');
+    return lines.join('\n');
+}
+/**
+ * Collect all enum definitions from the enums directory.
+ */
+export function collectEnums(enumsDir) {
+    const enums = {};
+    if (!existsSync(enumsDir)) {
+        return enums;
+    }
+    const enumFiles = getPhpFiles(enumsDir);
+    for (const file of enumFiles) {
+        try {
+            const enumPath = join(enumsDir, file);
+            const def = parseEnumFile(enumPath);
+            if (def) {
+                enums[def.name] = def;
+            }
+        }
+        catch (e) {
+            // Ignore parse errors
+            console.warn(`Failed to parse enum file: ${file}`, e);
+        }
+    }
+    return enums;
+}
+/**
+ * Generate enum files (TypeScript declarations and runtime JavaScript).
+ */
+export function generateEnums(options) {
+    const { enumsDir, outputDir, packageName } = options;
+    // Collect all enums
+    const enums = collectEnums(enumsDir);
+    // Generate TypeScript declarations
+    const dtsContent = generateEnumTypeScript(enums);
+    const dtsPath = join(outputDir, 'index.d.ts');
+    writeFileEnsureDir(dtsPath, dtsContent);
+    // Generate runtime JavaScript
+    const jsContent = generateEnumRuntime(enums);
+    const jsPath = join(outputDir, 'index.js');
+    writeFileEnsureDir(jsPath, jsContent);
+    // Generate package.json
+    const pkgJson = JSON.stringify({
+        name: packageName,
+        version: '0.0.0',
+        main: 'index.js',
+        types: 'index.d.ts',
+    }, null, 2);
+    const pkgPath = join(outputDir, 'package.json');
+    writeFileEnsureDir(pkgPath, pkgJson);
+}

package/dist/generators/resources.d.ts

@@ -0,0 +1,26 @@
+export type ResourceGeneratorOptions = {
+    resourcesDir: string;
+    enumsDir: string;
+    modelsDir: string;
+    outputDir: string;
+    packageName: string;
+};
+type FieldInfo = {
+    type: string;
+    optional: boolean;
+};
+/**
+ * Generate TypeScript type declarations for resources.
+ */
+export declare function generateResourceTypeScript(resources: Record<string, Record<string, FieldInfo>>, fallbacks: string[], referencedEnums: Set<string>): string;
+/**
+ * Generate runtime JavaScript for resources.
+ * Resources are type-only, so this just exports an empty object.
+ */
+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

@@ -0,0 +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"}

package/dist/generators/resources.js

@@ -0,0 +1,282 @@
+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 { mapDocTypeToTs, mapPhpTypeToTs, parseTsObjectStringToPairs } from '../utils/type-mapper.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;
+        }
+    }
+    return mapPhpTypeToTs(cast);
+}
+/**
+ * Infer TypeScript type from a PHP resource value expression.
+ */
+function inferTypeFromValue(value, key, resourceClass, resourcesDir, modelsDir, enumsDir, collectedEnums) {
+    let optional = false;
+    // Resource::collection
+    const collMatch = value.match(/([A-Za-z0-9_]+)::collection\s*\(\s*(.*?)\s*\)/);
+    if (collMatch) {
+        const res = collMatch[1];
+        const inside = collMatch[2];
+        if (inside.includes('whenLoaded('))
+            optional = true;
+        return { type: `${res}[]`, optional };
+    }
+    // whenLoaded
+    const whenLoadedMatch = value.match(/whenLoaded\(\s*["']([A-Za-z0-9_]+)["']\s*\)/);
+    if (whenLoadedMatch) {
+        const name = whenLoadedMatch[1];
+        optional = true;
+        const candidate = `${name[0].toUpperCase()}${name.slice(1)}Resource`;
+        const resPath = join(resourcesDir, `${candidate}.php`);
+        if (existsSync(resPath)) {
+            return { type: candidate, optional };
+        }
+        return { type: 'Record<string, any>', optional };
+    }
+    // $this->resource->property
+    const propMatch = value.match(/\$this->resource->([A-Za-z0-9_]+)/);
+    if (propMatch) {
+        const prop = propMatch[1];
+        // Boolean checks
+        if (/\?\s*true\s*:\s*false|===\s*(true|false)|==\s*(true|false)/i.test(value)) {
+            return { type: 'boolean', optional: false };
+        }
+        if (/\$this->resource->(is|has)[A-Za-z0-9_]*\s*\(/i.test(value)) {
+            return { type: 'boolean', optional: false };
+        }
+        const lower = prop.toLowerCase();
+        if (lower.startsWith('is_') || lower.startsWith('has_') || /^(is|has)[A-Z]/.test(prop)) {
+            return { type: 'boolean', optional: false };
+        }
+        // IDs and UUIDs
+        if (prop === 'id' || prop.endsWith('_id') || lower === 'uuid') {
+            return { type: 'string', optional: false };
+        }
+        // Check model casts
+        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 };
+            }
+        }
+        // Number heuristics
+        if (['last4', 'count', 'total'].includes(prop) || /\d$/.test(prop)) {
+            return { type: 'number', optional: false };
+        }
+        // String heuristics
+        if (['id', 'uuid', 'slug', 'name', 'repository', 'region', 'email'].includes(prop)) {
+            return { type: 'string', optional: false };
+        }
+        // Timestamps
+        if (prop.endsWith('_at') || ['created_at', 'updated_at', 'lastActive'].includes(prop)) {
+            return { type: 'string', optional: false };
+        }
+        return { type: 'string', optional: false };
+    }
+    return { type: 'any', optional: false };
+}
+/**
+ * Parse fields from a PHP array block (from toArray() method).
+ */
+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++) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith('//'))
+            continue;
+        const match = line.match(/["'](?<key>[A-Za-z0-9_]+)["']\s*=>\s*(?<value>.*?)(?:,\s*$|$)/);
+        if (!match || !match.groups)
+            continue;
+        const key = match.groups.key;
+        let value = match.groups.value.trim();
+        // Boolean heuristic
+        const lowerKey = key.toLowerCase();
+        if (lowerKey.startsWith('is_') || lowerKey.startsWith('has_') || /^(is|has)[A-Z]/.test(key)) {
+            fields[key] = { type: 'boolean', optional: false };
+            continue;
+        }
+        // Handle nested arrays
+        if (value.startsWith('[')) {
+            let bracketDepth = (value.match(/\[/g) || []).length - (value.match(/\]/g) || []).length;
+            const innerLines = [];
+            const rest = value.replace(/^\[\s*/, '');
+            if (rest)
+                innerLines.push(rest);
+            let j = i + 1;
+            while (j < lines.length && bracketDepth > 0) {
+                const l = lines[j];
+                bracketDepth += (l.match(/\[/g) || []).length - (l.match(/\]/g) || []).length;
+                innerLines.push(l.trim());
+                j++;
+            }
+            i = j - 1;
+            const innerBlock = innerLines.join('\n');
+            const nested = parseFieldsFromArrayBlock(innerBlock, resourceClass, docShape, resourcesDir, modelsDir, enumsDir, collectedEnums);
+            // Apply docblock shape if available
+            if (docShape && docShape[key]) {
+                const docType = docShape[key].trim();
+                if (docType.startsWith('{')) {
+                    const docInner = parseTsObjectStringToPairs(docType);
+                    for (const dk of Object.keys(docInner)) {
+                        nested[dk] = { type: docInner[dk], optional: false };
+                    }
+                }
+            }
+            const props = [];
+            for (const nkey of Object.keys(nested)) {
+                const ninfo = nested[nkey];
+                const ntype = ninfo.type || 'any';
+                const nopt = ninfo.optional ? '?' : '';
+                props.push(`${nkey}${nopt}: ${ntype}`);
+            }
+            const inline = `{ ${props.join('; ')} }`;
+            fields[key] = { type: inline, optional: false };
+            continue;
+        }
+        // Use docblock type if available
+        if (docShape && docShape[key]) {
+            fields[key] = { type: docShape[key], optional: false };
+            continue;
+        }
+        // Infer type from value
+        const info = inferTypeFromValue(value, key, resourceClass, resourcesDir, modelsDir, enumsDir, collectedEnums);
+        if (docShape && docShape[key] && (!info.type || info.type === 'any')) {
+            info.type = docShape[key];
+            info.optional = info.optional ?? false;
+        }
+        fields[key] = info;
+    }
+    return fields;
+}
+/**
+ * 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('');
+    // 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('');
+    }
+    // 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('');
+            continue;
+        }
+        lines.push(`export type ${className} = {`);
+        for (const key of Object.keys(fields)) {
+            const info = fields[key];
+            const type = info.type || 'any';
+            const optional = info.optional ? '?' : '';
+            lines.push(`    ${key}${optional}: ${type};`);
+        }
+        lines.push('};');
+        lines.push('');
+    }
+    return lines.join('\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');
+}
+/**
+ * Generate resource type files (TypeScript declarations and runtime JavaScript).
+ */
+export function generateResources(options) {
+    const { resourcesDir, enumsDir, modelsDir, outputDir, packageName } = options;
+    const collectedEnums = {};
+    const resources = {};
+    const fallbacks = [];
+    if (!existsSync(resourcesDir)) {
+        console.warn(`Resources directory not found: ${resourcesDir}`);
+        return;
+    }
+    const files = getPhpFiles(resourcesDir);
+    for (const file of files) {
+        try {
+            const filePath = join(resourcesDir, file);
+            const content = readFileSafe(filePath) || '';
+            const className = parse(file).name;
+            const docShape = extractDocblockArrayShape(content);
+            const arrayBlock = extractReturnArrayBlock(content);
+            if (!arrayBlock) {
+                fallbacks.push(className);
+                resources[className] = {};
+            }
+            else {
+                const fields = parseFieldsFromArrayBlock(arrayBlock, className, docShape ? mapDocTypeToTsForShape(docShape) : null, resourcesDir, modelsDir, enumsDir, collectedEnums);
+                resources[className] = fields;
+            }
+        }
+        catch (e) {
+            console.warn(`Failed to parse resource file: ${file}`, e);
+        }
+    }
+    // Track which enums are actually referenced
+    const referencedEnums = new Set(Object.keys(collectedEnums));
+    // Generate TypeScript declarations
+    const dtsContent = generateResourceTypeScript(resources, fallbacks, referencedEnums);
+    const dtsPath = join(outputDir, 'index.d.ts');
+    writeFileEnsureDir(dtsPath, dtsContent);
+    // Generate runtime JavaScript
+    const jsContent = generateResourceRuntime();
+    const jsPath = join(outputDir, 'index.js');
+    writeFileEnsureDir(jsPath, jsContent);
+    // Generate package.json
+    const pkgJson = JSON.stringify({
+        name: packageName,
+        version: '0.0.0',
+        main: 'index.js',
+        types: 'index.d.ts',
+    }, null, 2);
+    const pkgPath = join(outputDir, 'package.json');
+    writeFileEnsureDir(pkgPath, pkgJson);
+}
+/**
+ * Map docblock types to TypeScript for each field in a shape.
+ */
+function mapDocTypeToTsForShape(docShape) {
+    const result = {};
+    for (const [key, type] of Object.entries(docShape)) {
+        result[key] = mapDocTypeToTs(type);
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from 'vite';
+export type ResourceTypesPluginOptions = {
+    cwd?: string;
+};
+/**
+ * Vite plugin for generating TypeScript types from Laravel PHP files.
+ *
+ * This plugin generates separate packages for each type:
+ * - @app/enums - PHP enums with labels
+ * - @app/resources - Laravel JsonResource types
+ * - @app/schemas - (future) Zod schemas from FormRequests
+ */
+export default function ferry(options?: ResourceTypesPluginOptions): Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAOnC,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,CAwFR"}

package/dist/index.js

@@ -0,0 +1,97 @@
+import { join } from 'node:path';
+import { generateEnums } from './generators/enums.js';
+import { generateResources } from './generators/resources.js';
+import { displayBanner } from './utils/banner.js';
+import { setupEnumWatcher } from './watchers/enums.js';
+import { setupResourceWatcher } from './watchers/resources.js';
+/**
+ * Vite plugin for generating TypeScript types from Laravel PHP files.
+ *
+ * This plugin generates separate packages for each type:
+ * - @app/enums - PHP enums with labels
+ * - @app/resources - Laravel JsonResource types
+ * - @app/schemas - (future) Zod schemas from FormRequests
+ */
+export default function ferry(options = {
+    cwd: process.cwd(),
+}) {
+    const namespace = '@ferry';
+    const name = 'vite-plugin-ferry';
+    // Directory paths
+    const enumsDir = join(options.cwd, 'app/Enums');
+    const resourcesDir = join(options.cwd, 'app/Http/Resources');
+    const modelsDir = join(options.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');
+    /**
+     * Generate all packages.
+     */
+    function generateAll() {
+        // Generate @app/enums package
+        generateEnums({
+            enumsDir,
+            outputDir: enumsOutputDir,
+            packageName: `${namespace}/enums`,
+        });
+        // Generate @app/resources package
+        generateResources({
+            resourcesDir,
+            enumsDir,
+            modelsDir,
+            outputDir: resourcesOutputDir,
+            packageName: `${namespace}/resources`,
+        });
+    }
+    return {
+        name,
+        enforce: 'pre',
+        // Run generation during config resolution so files exist before other plugins need them
+        config() {
+            try {
+                generateAll();
+            }
+            catch (e) {
+                console.error(`[${name}] Error generating types during config():`, e);
+            }
+            return null;
+        },
+        // Run generation when build starts
+        buildStart() {
+            try {
+                generateAll();
+            }
+            catch (e) {
+                console.error(`[${name}] Error generating types during buildStart():`, e);
+            }
+        },
+        // Set up watchers for dev server
+        configureServer(server) {
+            // Display startup banner
+            server.httpServer?.once('listening', () => {
+                setTimeout(() => {
+                    displayBanner({
+                        packages: [`${namespace}/enums`, `${namespace}/resources`],
+                        version: '1.0.0',
+                    });
+                }, 200);
+            });
+            // Set up enum watcher
+            setupEnumWatcher({
+                enumsDir,
+                outputDir: enumsOutputDir,
+                packageName: `${namespace}/enums`,
+                server,
+            });
+            // Set up resource watcher
+            setupResourceWatcher({
+                resourcesDir,
+                enumsDir,
+                modelsDir,
+                outputDir: resourcesOutputDir,
+                packageName: `${namespace}/resources`,
+                server,
+            });
+        },
+    };
+}

package/dist/utils/banner.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Display a startup banner for the plugin.
+ */
+export declare function displayBanner(options: {
+    packages: string[];
+    version?: string;
+}): void;
+/**
+ * Log a file change event.
+ */
+export declare function logFileChange(packageName: string, fileName: string): void;
+/**
+ * Log a regeneration event.
+ */
+export declare function logRegeneration(packageName: string): void;
+/**
+ * Log an error.
+ */
+export declare function logError(packageName: string, message: string, error?: any): void;
+//# sourceMappingURL=banner.d.ts.map

package/dist/utils/banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"banner.d.ts","sourceRoot":"","sources":["../../src/utils/banner.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAYrF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAIzE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAIzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,IAAI,CAMhF"}

package/dist/utils/banner.js

@@ -0,0 +1,40 @@
+import pc from 'picocolors';
+/**
+ * Display a startup banner for the plugin.
+ */
+export function displayBanner(options) {
+    const { packages, version = '1.0.0' } = options;
+    console.log('');
+    console.log(pc.cyan('  PRIMCLOUD') + pc.dim(` resource-types ${pc.bold(`v${version}`)}`));
+    console.log('');
+    for (const pkg of packages) {
+        console.log(pc.green('  ➜') + '  ' + pc.bold(pkg));
+    }
+    console.log('');
+}
+/**
+ * Log a file change event.
+ */
+export function logFileChange(packageName, fileName) {
+    const pkgLabel = pc.cyan(`[${packageName}]`);
+    const fileLabel = pc.dim(fileName);
+    console.log(`${pkgLabel} File changed: ${fileLabel}`);
+}
+/**
+ * Log a regeneration event.
+ */
+export function logRegeneration(packageName) {
+    const pkgLabel = pc.cyan(`[${packageName}]`);
+    const message = pc.green('✓') + ' Regenerated types';
+    console.log(`${pkgLabel} ${message}`);
+}
+/**
+ * Log an error.
+ */
+export function logError(packageName, message, error) {
+    const pkgLabel = pc.red(`[${packageName}]`);
+    console.error(`${pkgLabel} ${pc.red('✗')} ${message}`);
+    if (error) {
+        console.error(pc.dim(error.stack || error.message || String(error)));
+    }
+}

package/dist/utils/file.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Safely read a file, returning null if it doesn't exist or can't be read.
+ */
+export declare function readFileSafe(filePath: string): string | null;
+/**
+ * Write a file, ensuring the directory exists.
+ */
+export declare function writeFileEnsureDir(filePath: string, content: string): void;
+/**
+ * Get all PHP files from a directory.
+ */
+export declare function getPhpFiles(dir: string): string[];
+//# sourceMappingURL=file.d.ts.map

package/dist/utils/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/utils/file.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM5D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAI1E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAKjD"}

package/dist/utils/file.js

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+/**
+ * Safely read a file, returning null if it doesn't exist or can't be read.
+ */
+export function readFileSafe(filePath) {
+    try {
+        return readFileSync(filePath, 'utf8');
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Write a file, ensuring the directory exists.
+ */
+export function writeFileEnsureDir(filePath, content) {
+    const dir = dirname(filePath);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, content, 'utf8');
+}
+/**
+ * Get all PHP files from a directory.
+ */
+export function getPhpFiles(dir) {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    return readdirSync(dir).filter((f) => f.endsWith('.php'));
+}

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

@@ -0,0 +1,31 @@
+export type EnumCase = {
+    key: string;
+    value: string;
+    label?: string;
+};
+export type EnumDefinition = {
+    name: string;
+    backing: string | null;
+    cases: EnumCase[];
+};
+/**
+ * Parse a PHP enum file and extract its definition.
+ */
+export declare function parseEnumFile(enumPath: string): EnumDefinition | null;
+/**
+ * Parse PHP array pairs from a string like "'key' => 'value'".
+ */
+export declare function parsePhpArrayPairs(inside: 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.
+ */
+export declare function extractDocblockArrayShape(phpContent: string): Record<string, string> | null;
+/**
+ * Extract the return array block from a toArray() method in a PHP resource.
+ */
+export declare function extractReturnArrayBlock(phpContent: string): string | null;
+//# sourceMappingURL=php-parser.d.ts.map

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

@@ -0,0 +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"}

package/dist/utils/php-parser.js

@@ -0,0 +1,180 @@
+import { readFileSafe } from './file.js';
+/**
+ * Parse a PHP enum file and extract its definition.
+ */
+export function parseEnumFile(enumPath) {
+    const content = readFileSafe(enumPath);
+    if (!content)
+        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)
+        return null;
+    const name = enumMatch[1];
+    const backing = enumMatch[2] ? enumMatch[2].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] });
+        }
+    }
+    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] });
+        }
+    }
+    // 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;
+            }
+        }
+    }
+    return { name, backing, cases };
+}
+/**
+ * Parse PHP array pairs from a string like "'key' => 'value'".
+ */
+export function parsePhpArrayPairs(inside) {
+    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);
+        }
+        pairs[m.groups.key] = val;
+    }
+    return pairs;
+}
+/**
+ * Extract model casts from a PHP model file.
+ */
+export function getModelCasts(modelPath) {
+    const content = readFileSafe(modelPath);
+    if (!content)
+        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]);
+    }
+    // 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;
+    }
+    return res;
+}
+/**
+ * Extract docblock array shape from PHP file content.
+ */
+export function extractDocblockArrayShape(phpContent) {
+    const match = phpContent.match(/@return\s+array\s*\{/s);
+    if (!match)
+        return null;
+    const startPos = match.index;
+    const openBracePos = phpContent.indexOf('{', startPos);
+    if (openBracePos === -1)
+        return null;
+    // Find matching closing brace
+    let depth = 0;
+    let pos = openBracePos;
+    let endPos = null;
+    while (pos < phpContent.length) {
+        const ch = phpContent[pos];
+        if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0) {
+                endPos = pos;
+                break;
+            }
+        }
+        pos++;
+    }
+    if (endPos === null)
+        return null;
+    const inside = phpContent.slice(openBracePos + 1, endPos);
+    const pairs = {};
+    let i = 0;
+    while (i < inside.length) {
+        // Skip whitespace and commas
+        while (i < inside.length && (inside[i].match(/\s/) || inside[i] === ','))
+            i++;
+        if (i >= inside.length)
+            break;
+        // Extract key
+        const keyMatch = inside.slice(i).match(/^[A-Za-z0-9_]+/);
+        if (!keyMatch)
+            break;
+        const key = keyMatch[0];
+        i += key.length;
+        // Skip to colon
+        while (i < inside.length && /\s/.test(inside[i]))
+            i++;
+        if (i >= inside.length || inside[i] !== ':')
+            break;
+        i++;
+        // Extract type
+        while (i < inside.length && /\s/.test(inside[i]))
+            i++;
+        const typeStart = i;
+        let depthCur = 0;
+        while (i < inside.length) {
+            const ch = inside[i];
+            if (ch === '{' || ch === '<' || ch === '(')
+                depthCur++;
+            else if (ch === '}' || ch === '>' || ch === ')') {
+                if (depthCur > 0)
+                    depthCur--;
+            }
+            else if (ch === ',' && depthCur === 0)
+                break;
+            i++;
+        }
+        const type = inside.slice(typeStart, i).trim();
+        if (type)
+            pairs[key] = type;
+        if (i < inside.length && inside[i] === ',')
+            i++;
+    }
+    return pairs;
+}
+/**
+ * Extract the return array block from a toArray() method in a PHP resource.
+ */
+export function extractReturnArrayBlock(phpContent) {
+    const match = phpContent.match(/function\s+toArray\s*\([^)]*\)\s*:\s*array\s*\{([\s\S]*?)\n\s*\}/);
+    if (!match)
+        return null;
+    const body = match[1];
+    const returnMatch = body.match(/return\s*\[\s*([\s\S]*?)\s*\];/);
+    if (!returnMatch)
+        return null;
+    return returnMatch[1];
+}

package/dist/utils/type-mapper.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Map PHP types to TypeScript types.
+ */
+export declare function mapPhpTypeToTs(phpType: string): string;
+/**
+ * Map docblock types to TypeScript types.
+ */
+export declare function mapDocTypeToTs(docType: string): string;
+/**
+ * Parse TypeScript object string to key-value pairs.
+ */
+export declare function parseTsObjectStringToPairs(tsObj: string): Record<string, string>;
+//# sourceMappingURL=type-mapper.d.ts.map

package/dist/utils/type-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-mapper.d.ts","sourceRoot":"","sources":["../../src/utils/type-mapper.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAWtD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAiGtD;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA8ChF"}

package/dist/utils/type-mapper.js

@@ -0,0 +1,158 @@
+/**
+ * Map PHP types to TypeScript types.
+ */
+export function mapPhpTypeToTs(phpType) {
+    const lower = phpType.toLowerCase();
+    if (['int', 'integer'].includes(lower))
+        return 'number';
+    if (['real', 'float', 'double', 'decimal'].includes(lower))
+        return 'number';
+    if (lower === 'string')
+        return 'string';
+    if (['bool', 'boolean'].includes(lower))
+        return 'boolean';
+    if (['array', 'json'].includes(lower))
+        return 'any[]';
+    if (['datetime', 'date', 'immutable_datetime', 'immutable_date'].includes(lower))
+        return 'string';
+    return 'any';
+}
+/**
+ * Map docblock types to TypeScript types.
+ */
+export function mapDocTypeToTs(docType) {
+    let type = docType.trim();
+    let nullable = false;
+    if (type.startsWith('?')) {
+        nullable = true;
+        type = type.slice(1);
+    }
+    // Handle array shapes like "array {key: type, ...}"
+    const arrShape = type.match(/^array\s*\{(.+)\}$/s);
+    if (arrShape) {
+        const inside = arrShape[1];
+        const parts = [];
+        const innerRe = /(?<key>[A-Za-z0-9_]+)\s*:\s*(?<type>[^,\n}]+)/g;
+        for (const mm of inside.matchAll(innerRe)) {
+            const k = mm.groups.key;
+            const t = mm.groups.type.trim();
+            parts.push(`${k}: ${mapDocTypeToTs(t)}`);
+        }
+        const obj = `{ ${parts.join('; ')} }`;
+        return nullable ? `${obj} | null` : obj;
+    }
+    // Handle union types
+    const parts = type
+        .split('|')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    const mapped = [];
+    for (const p of parts) {
+        const low = p.toLowerCase();
+        if (low === 'null') {
+            mapped.push('null');
+            continue;
+        }
+        if (low === 'mixed') {
+            mapped.push('any');
+            continue;
+        }
+        if (low === 'array') {
+            mapped.push('any[]');
+            continue;
+        }
+        if (['int', 'integer', 'float', 'double', 'number', 'decimal'].includes(low)) {
+            mapped.push('number');
+            continue;
+        }
+        if (['bool', 'boolean'].includes(low)) {
+            mapped.push('boolean');
+            continue;
+        }
+        if (low.startsWith('string')) {
+            mapped.push('string');
+            continue;
+        }
+        if (low === 'object' || low === 'stdclass') {
+            mapped.push('Record<string, any>');
+            continue;
+        }
+        // Handle array notation like "Foo[]"
+        const arrMatch = p.match(/^(?<inner>[A-Za-z0-9_\\]+)\[\]$/);
+        if (arrMatch) {
+            const inner = arrMatch.groups.inner.replace(/\\\\/g, '');
+            mapped.push(`${inner}[]`);
+            continue;
+        }
+        // Handle generic array like "array<Foo>"
+        const genMatch = p.match(/array\s*<\s*([^,>\s]+)\s*>/i);
+        if (genMatch) {
+            const inner = genMatch[1].replace(/[^A-Za-z0-9_]/g, '');
+            mapped.push(`${inner}[]`);
+            continue;
+        }
+        // Handle Record types
+        if (/record\s*<\s*[^>]+>/i.test(p) || p.includes('Record')) {
+            mapped.push(p.replace('mixed', 'any'));
+            continue;
+        }
+        // Default: sanitize and use as-is
+        const san = p.replace(/[^A-Za-z0-9_\\[\]]/g, '').replace(/\\/g, '');
+        mapped.push(san === '' ? 'any' : san);
+    }
+    if (nullable && !mapped.includes('null')) {
+        mapped.push('null');
+    }
+    return Array.from(new Set(mapped)).join(' | ');
+}
+/**
+ * Parse TypeScript object string to key-value pairs.
+ */
+export function parseTsObjectStringToPairs(tsObj) {
+    const pairs = {};
+    let inside = tsObj.trim();
+    if (!inside.startsWith('{') || !inside.endsWith('}'))
+        return pairs;
+    inside = inside.slice(1, -1);
+    let i = 0;
+    while (i < inside.length) {
+        // Skip whitespace and separators
+        while (i < inside.length && (/\s/.test(inside[i]) || inside[i] === ';' || inside[i] === ','))
+            i++;
+        // Extract key
+        const keyMatch = inside.slice(i).match(/^[A-Za-z0-9_]+\??/);
+        if (!keyMatch)
+            break;
+        const keyRaw = keyMatch[0];
+        i += keyRaw.length;
+        const key = keyRaw.endsWith('?') ? keyRaw.slice(0, -1) : keyRaw;
+        // Skip to colon
+        while (i < inside.length && /\s/.test(inside[i]))
+            i++;
+        if (i >= inside.length || inside[i] !== ':')
+            break;
+        i++;
+        // Extract type
+        while (i < inside.length && /\s/.test(inside[i]))
+            i++;
+        const typeStart = i;
+        let depth = 0;
+        while (i < inside.length) {
+            const ch = inside[i];
+            if (ch === '{' || ch === '(' || ch === '<')
+                depth++;
+            else if (ch === '}' || ch === ')' || ch === '>') {
+                if (depth > 0)
+                    depth--;
+            }
+            else if ((ch === ';' || ch === ',') && depth === 0)
+                break;
+            i++;
+        }
+        const type = inside.slice(typeStart, i).trim();
+        pairs[key] = type === '' ? 'any' : type;
+        if (i < inside.length && (inside[i] === ';' || inside[i] === ','))
+            i++;
+    }
+    return pairs;
+}

package/dist/watchers/enums.d.ts

@@ -0,0 +1,10 @@
+import type { ViteDevServer } from 'vite';
+import { type EnumGeneratorOptions } from '../generators/enums.js';
+export type EnumWatcherOptions = EnumGeneratorOptions & {
+    server: ViteDevServer;
+};
+/**
+ * Set up a watcher for enum files.
+ */
+export declare function setupEnumWatcher(options: EnumWatcherOptions): void;
+//# sourceMappingURL=enums.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../src/watchers/enums.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGlF,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GAAG;IACtD,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CA6BlE"}

package/dist/watchers/enums.js

@@ -0,0 +1,30 @@
+import { join, basename } from 'node:path';
+import { generateEnums } from '../generators/enums.js';
+import { logError, logFileChange, logRegeneration } from '../utils/banner.js';
+/**
+ * Set up a watcher for enum files.
+ */
+export function setupEnumWatcher(options) {
+    const { enumsDir, outputDir, packageName, server } = options;
+    const enumPattern = join(enumsDir, '*.php');
+    const generatedJsPath = join(outputDir, 'index.js');
+    // Watch PHP enum files
+    server.watcher.add(enumPattern);
+    // Also watch the generated JS file (for HMR)
+    server.watcher.add(generatedJsPath);
+    server.watcher.on('change', (filePath) => {
+        if (filePath.startsWith(enumsDir)) {
+            try {
+                logFileChange('enums', basename(filePath));
+                // Regenerate enum files
+                generateEnums({ enumsDir, outputDir, packageName });
+                // Tell Vite the generated file changed (triggers normal HMR)
+                server.watcher.emit('change', generatedJsPath);
+                logRegeneration('enums');
+            }
+            catch (e) {
+                logError('enums', 'Error regenerating enum types', e);
+            }
+        }
+    });
+}

package/dist/watchers/resources.d.ts

@@ -0,0 +1,10 @@
+import type { ViteDevServer } from 'vite';
+import { type ResourceGeneratorOptions } from '../generators/resources.js';
+export type ResourceWatcherOptions = ResourceGeneratorOptions & {
+    server: ViteDevServer;
+};
+/**
+ * Set up a watcher for resource and model files.
+ */
+export declare function setupResourceWatcher(options: ResourceWatcherOptions): void;
+//# sourceMappingURL=resources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/watchers/resources.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,EAAqB,KAAK,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAG9F,MAAM,MAAM,sBAAsB,GAAG,wBAAwB,GAAG;IAC9D,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAqC1E"}

package/dist/watchers/resources.js

@@ -0,0 +1,36 @@
+import { join, basename } from 'node:path';
+import { generateResources } from '../generators/resources.js';
+import { logError, logFileChange, logRegeneration } from '../utils/banner.js';
+/**
+ * Set up a watcher for resource and model files.
+ */
+export function setupResourceWatcher(options) {
+    const { resourcesDir, enumsDir, modelsDir, outputDir, packageName, server } = options;
+    const resourcePattern = join(resourcesDir, '*.php');
+    const modelPattern = join(modelsDir, '*.php');
+    const generatedDtsPath = join(outputDir, 'index.d.ts');
+    // Watch PHP resource and model files
+    server.watcher.add(resourcePattern);
+    server.watcher.add(modelPattern);
+    // Also watch the generated .d.ts file
+    server.watcher.add(generatedDtsPath);
+    const handleChange = (filePath) => {
+        if (filePath.startsWith(resourcesDir) || filePath.startsWith(modelsDir)) {
+            try {
+                const isModel = filePath.startsWith(modelsDir);
+                const fileType = isModel ? 'model' : 'resource';
+                logFileChange(fileType, basename(filePath));
+                // Regenerate resource types
+                generateResources({ resourcesDir, enumsDir, modelsDir, outputDir, packageName });
+                // Tell Vite the generated type file changed
+                // TypeScript will pick up changes automatically
+                server.watcher.emit('change', generatedDtsPath);
+                logRegeneration('resources');
+            }
+            catch (e) {
+                logError('resources', 'Error regenerating resource types', e);
+            }
+        }
+    };
+    server.watcher.on('change', handleChange);
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "vite-plugin-ferry",
+  "prettier": "@aniftyco/prettier",
+  "description": "Ferries Laravel types to your TypeScript frontend",
+  "type": "module",
+  "version": "0.1.0",
+  "repository": "https://github.com/aniftyco/vite-plugin-ferry",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "tsc --watch",
+    "build": "rm -rf dist/ && tsc",
+    "prepublishOnly": "rm -rf dist/ && tsc"
+  },
+  "devDependencies": {
+    "@aniftyco/prettier": "^1.3.0",
+    "@types/node": "^24",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "vite": "^7.3.0"
+  }
+}