@vistagenic/vista 0.2.16 → 0.3.2

package/dist/build/rsc/client-reference-plugin.d.ts

@@ -1,37 +1,37 @@
-/**
- * Vista Client Reference Plugin
- *
- * Webpack plugin that transforms server component imports in the client bundle.
- *
- * When a client bundle imports a server component, this plugin:
- * 1. Replaces the import with a client reference proxy
- * 2. The proxy throws an error if used on the client (server components can't run on client)
- * 3. For valid patterns (passing server component as children), the reference works
- *
- * This ensures:
- * - Server code never leaks to the client bundle
- * - Server components contribute 0kb to client JavaScript
- * - Clear error messages when misusing server components
- */
-import webpack from 'webpack';
-export interface ClientReferencePluginOptions {
-    /** Path to the app directory */
-    appDir: string;
-    /** Path to client manifest JSON */
-    clientManifestPath: string;
-}
-/**
- * Client Reference Plugin
- *
- * Transforms imports of server components in the client bundle
- */
-export declare class ClientReferencePlugin {
-    private appDir;
-    private clientManifestPath;
-    private clientManifest;
-    constructor(options: ClientReferencePluginOptions);
-    apply(compiler: webpack.Compiler): void;
-    private loadManifest;
-    private getComponentId;
-    private generateRuntimeManifest;
-}
+/**
+ * Vista Client Reference Plugin
+ *
+ * Webpack plugin that transforms server component imports in the client bundle.
+ *
+ * When a client bundle imports a server component, this plugin:
+ * 1. Replaces the import with a client reference proxy
+ * 2. The proxy throws an error if used on the client (server components can't run on client)
+ * 3. For valid patterns (passing server component as children), the reference works
+ *
+ * This ensures:
+ * - Server code never leaks to the client bundle
+ * - Server components contribute 0kb to client JavaScript
+ * - Clear error messages when misusing server components
+ */
+import webpack from 'webpack';
+export interface ClientReferencePluginOptions {
+    /** Path to the app directory */
+    appDir: string;
+    /** Path to client manifest JSON */
+    clientManifestPath: string;
+}
+/**
+ * Client Reference Plugin
+ *
+ * Transforms imports of server components in the client bundle
+ */
+export declare class ClientReferencePlugin {
+    private appDir;
+    private clientManifestPath;
+    private clientManifest;
+    constructor(options: ClientReferencePluginOptions);
+    apply(compiler: webpack.Compiler): void;
+    private loadManifest;
+    private getComponentId;
+    private generateRuntimeManifest;
+}

package/dist/build/rsc/client-reference-plugin.js

@@ -1,160 +1,160 @@
-"use strict";
-/**
- * Vista Client Reference Plugin
- *
- * Webpack plugin that transforms server component imports in the client bundle.
- *
- * When a client bundle imports a server component, this plugin:
- * 1. Replaces the import with a client reference proxy
- * 2. The proxy throws an error if used on the client (server components can't run on client)
- * 3. For valid patterns (passing server component as children), the reference works
- *
- * This ensures:
- * - Server code never leaks to the client bundle
- * - Server components contribute 0kb to client JavaScript
- * - Clear error messages when misusing server components
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientReferencePlugin = void 0;
-const webpack_1 = __importDefault(require("webpack"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-/**
- * Check if a file is a client component by reading 'use client' directive
- */
-function isClientComponent(filePath) {
-    try {
-        const content = fs_1.default.readFileSync(filePath, 'utf-8');
-        const trimmed = content.trim();
-        return trimmed.startsWith("'use client'") || trimmed.startsWith('"use client"');
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Client Reference Plugin
- *
- * Transforms imports of server components in the client bundle
- */
-class ClientReferencePlugin {
-    appDir;
-    clientManifestPath;
-    clientManifest = null;
-    constructor(options) {
-        this.appDir = options.appDir;
-        this.clientManifestPath = options.clientManifestPath;
-    }
-    apply(compiler) {
-        const pluginName = 'VistaClientReferencePlugin';
-        // Load client manifest
-        compiler.hooks.beforeCompile.tap(pluginName, () => {
-            this.loadManifest();
-        });
-        // Provide virtual module for server component proxies
-        compiler.hooks.normalModuleFactory.tap(pluginName, (nmf) => {
-            nmf.hooks.beforeResolve.tap(pluginName, (resolveData) => {
-                if (!resolveData)
-                    return;
-                // Check if this is importing a server component from client code
-                const request = resolveData.request;
-                if (request === 'vista/server-component-proxy') {
-                    // Virtual module - allow it to continue
-                    return;
-                }
-            });
-            nmf.hooks.afterResolve.tap(pluginName, (resolveData) => {
-                if (!resolveData || !resolveData.createData)
-                    return;
-                const resourcePath = resolveData.createData.resource;
-                if (!resourcePath)
-                    return;
-                // Check if this is a file in the app directory
-                if (!resourcePath.startsWith(this.appDir))
-                    return;
-                // Check if this is a TypeScript/JavaScript file
-                if (!/\.[jt]sx?$/.test(resourcePath))
-                    return;
-                // Check if this is a server component (NOT a client component)
-                if (!isClientComponent(resourcePath)) {
-                    // This is a server component being imported in client bundle
-                    // We need to replace it with a proxy
-                    // Mark it for replacement (use any to add custom properties)
-                    resolveData.createData.vistaServerComponent = true;
-                    resolveData.createData.vistaComponentId = this.getComponentId(resourcePath);
-                }
-            });
-        });
-        // Transform the module content for server components
-        compiler.hooks.compilation.tap(pluginName, (compilation) => {
-            // Add the server component proxy to the beginning of affected modules
-            compilation.hooks.succeedModule.tap(pluginName, (module) => {
-                if (module.vistaServerComponent) {
-                    // This module is a server component - it should be replaced with a proxy
-                    // In practice, we handle this via the loader
-                }
-            });
-        });
-        // Add a loader to handle server component replacement
-        compiler.options.module?.rules?.push({
-            test: /\.[jt]sx?$/,
-            include: this.appDir,
-            enforce: 'pre',
-            use: [
-                {
-                    loader: require.resolve('./server-component-loader'),
-                    options: {
-                        appDir: this.appDir,
-                        clientManifestPath: this.clientManifestPath,
-                    },
-                },
-            ],
-        });
-        compiler.hooks.compilation.tap(pluginName, (compilation) => {
-            compilation.hooks.processAssets.tap({
-                name: pluginName,
-                stage: webpack_1.default.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-            }, () => {
-                if (!this.clientManifest)
-                    return;
-                const runtimeManifest = this.generateRuntimeManifest();
-                const manifestSource = JSON.stringify(runtimeManifest, null, 2);
-                compilation.emitAsset('client-reference-manifest.json', new webpack_1.default.sources.RawSource(manifestSource));
-            });
-        });
-    }
-    loadManifest() {
-        try {
-            if (fs_1.default.existsSync(this.clientManifestPath)) {
-                const content = fs_1.default.readFileSync(this.clientManifestPath, 'utf-8');
-                this.clientManifest = JSON.parse(content);
-            }
-        }
-        catch (e) {
-            console.warn('[Vista] Failed to load client manifest:', e);
-        }
-    }
-    getComponentId(filePath) {
-        const relative = path_1.default.relative(this.appDir, filePath);
-        return `server:${relative.replace(/\\/g, '/').replace(/\.[jt]sx?$/, '')}`;
-    }
-    generateRuntimeManifest() {
-        if (!this.clientManifest)
-            return {};
-        return {
-            clientModules: Object.keys(this.clientManifest.clientModules).reduce((acc, key) => {
-                const entry = this.clientManifest.clientModules[key];
-                acc[key] = {
-                    id: entry.id,
-                    chunks: [entry.chunkName],
-                    name: entry.exports[0] || 'default',
-                };
-                return acc;
-            }, {}),
-        };
-    }
-}
-exports.ClientReferencePlugin = ClientReferencePlugin;
+"use strict";
+/**
+ * Vista Client Reference Plugin
+ *
+ * Webpack plugin that transforms server component imports in the client bundle.
+ *
+ * When a client bundle imports a server component, this plugin:
+ * 1. Replaces the import with a client reference proxy
+ * 2. The proxy throws an error if used on the client (server components can't run on client)
+ * 3. For valid patterns (passing server component as children), the reference works
+ *
+ * This ensures:
+ * - Server code never leaks to the client bundle
+ * - Server components contribute 0kb to client JavaScript
+ * - Clear error messages when misusing server components
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientReferencePlugin = void 0;
+const webpack_1 = __importDefault(require("webpack"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Check if a file is a client component by reading 'use client' directive
+ */
+function isClientComponent(filePath) {
+    try {
+        const content = fs_1.default.readFileSync(filePath, 'utf-8');
+        const trimmed = content.trim();
+        return trimmed.startsWith("'use client'") || trimmed.startsWith('"use client"');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Client Reference Plugin
+ *
+ * Transforms imports of server components in the client bundle
+ */
+class ClientReferencePlugin {
+    appDir;
+    clientManifestPath;
+    clientManifest = null;
+    constructor(options) {
+        this.appDir = options.appDir;
+        this.clientManifestPath = options.clientManifestPath;
+    }
+    apply(compiler) {
+        const pluginName = 'VistaClientReferencePlugin';
+        // Load client manifest
+        compiler.hooks.beforeCompile.tap(pluginName, () => {
+            this.loadManifest();
+        });
+        // Provide virtual module for server component proxies
+        compiler.hooks.normalModuleFactory.tap(pluginName, (nmf) => {
+            nmf.hooks.beforeResolve.tap(pluginName, (resolveData) => {
+                if (!resolveData)
+                    return;
+                // Check if this is importing a server component from client code
+                const request = resolveData.request;
+                if (request === 'vista/server-component-proxy') {
+                    // Virtual module - allow it to continue
+                    return;
+                }
+            });
+            nmf.hooks.afterResolve.tap(pluginName, (resolveData) => {
+                if (!resolveData || !resolveData.createData)
+                    return;
+                const resourcePath = resolveData.createData.resource;
+                if (!resourcePath)
+                    return;
+                // Check if this is a file in the app directory
+                if (!resourcePath.startsWith(this.appDir))
+                    return;
+                // Check if this is a TypeScript/JavaScript file
+                if (!/\.[jt]sx?$/.test(resourcePath))
+                    return;
+                // Check if this is a server component (NOT a client component)
+                if (!isClientComponent(resourcePath)) {
+                    // This is a server component being imported in client bundle
+                    // We need to replace it with a proxy
+                    // Mark it for replacement (use any to add custom properties)
+                    resolveData.createData.vistaServerComponent = true;
+                    resolveData.createData.vistaComponentId = this.getComponentId(resourcePath);
+                }
+            });
+        });
+        // Transform the module content for server components
+        compiler.hooks.compilation.tap(pluginName, (compilation) => {
+            // Add the server component proxy to the beginning of affected modules
+            compilation.hooks.succeedModule.tap(pluginName, (module) => {
+                if (module.vistaServerComponent) {
+                    // This module is a server component - it should be replaced with a proxy
+                    // In practice, we handle this via the loader
+                }
+            });
+        });
+        // Add a loader to handle server component replacement
+        compiler.options.module?.rules?.push({
+            test: /\.[jt]sx?$/,
+            include: this.appDir,
+            enforce: 'pre',
+            use: [
+                {
+                    loader: require.resolve('./server-component-loader'),
+                    options: {
+                        appDir: this.appDir,
+                        clientManifestPath: this.clientManifestPath,
+                    },
+                },
+            ],
+        });
+        compiler.hooks.compilation.tap(pluginName, (compilation) => {
+            compilation.hooks.processAssets.tap({
+                name: pluginName,
+                stage: webpack_1.default.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+            }, () => {
+                if (!this.clientManifest)
+                    return;
+                const runtimeManifest = this.generateRuntimeManifest();
+                const manifestSource = JSON.stringify(runtimeManifest, null, 2);
+                compilation.emitAsset('client-reference-manifest.json', new webpack_1.default.sources.RawSource(manifestSource));
+            });
+        });
+    }
+    loadManifest() {
+        try {
+            if (fs_1.default.existsSync(this.clientManifestPath)) {
+                const content = fs_1.default.readFileSync(this.clientManifestPath, 'utf-8');
+                this.clientManifest = JSON.parse(content);
+            }
+        }
+        catch (e) {
+            console.warn('[Vista] Failed to load client manifest:', e);
+        }
+    }
+    getComponentId(filePath) {
+        const relative = path_1.default.relative(this.appDir, filePath);
+        return `server:${relative.replace(/\\/g, '/').replace(/\.[jt]sx?$/, '')}`;
+    }
+    generateRuntimeManifest() {
+        if (!this.clientManifest)
+            return {};
+        return {
+            clientModules: Object.keys(this.clientManifest.clientModules).reduce((acc, key) => {
+                const entry = this.clientManifest.clientModules[key];
+                acc[key] = {
+                    id: entry.id,
+                    chunks: [entry.chunkName],
+                    name: entry.exports[0] || 'default',
+                };
+                return acc;
+            }, {}),
+        };
+    }
+}
+exports.ClientReferencePlugin = ClientReferencePlugin;

package/dist/build/rsc/native-scanner.d.ts

@@ -1,123 +1,135 @@
-/**
- * Vista RSC Native Scanner
- *
- * Uses Rust-powered native bindings for blazing fast component scanning.
- * Falls back to TypeScript implementation if native module unavailable.
- */
-export interface NapiScannedComponent {
-    absolutePath: string;
-    relativePath: string;
-    isClient: boolean;
-    directiveLine: number;
-    componentType: string;
-    exports: string[];
-    clientHooksUsed: string[];
-    hasMetadata: boolean;
-    hasGenerateMetadata: boolean;
-}
-export interface NapiServerComponentError {
-    file: string;
-    message: string;
-    hooks: string[];
-}
-export interface NapiScanResult {
-    clientComponents: NapiScannedComponent[];
-    serverComponents: NapiScannedComponent[];
-    pages: NapiScannedComponent[];
-    layouts: NapiScannedComponent[];
-    apiRoutes: NapiScannedComponent[];
-    errors: NapiServerComponentError[];
-    totalFiles: number;
-    scanTimeMs: number;
-}
-export interface NapiClientModuleEntry {
-    id: string;
-    path: string;
-    absolutePath: string;
-    chunkName: string;
-    exports: string[];
-    asyncLoad: boolean;
-}
-export interface NapiClientManifest {
-    buildId: string;
-    clientModules: NapiClientModuleEntry[];
-}
-export interface NapiRouteEntry {
-    pattern: string;
-    pagePath: string;
-    layoutPaths: string[];
-    loadingPath: string | null;
-    errorPath: string | null;
-    routeType: string;
-}
-export interface NapiServerModuleEntry {
-    id: string;
-    path: string;
-    absolutePath: string;
-    componentType: string;
-    hasMetadata: boolean;
-    hasGenerateMetadata: boolean;
-}
-export interface NapiServerManifest {
-    buildId: string;
-    serverModules: NapiServerModuleEntry[];
-    routes: NapiRouteEntry[];
-}
-/**
- * Check if native module is available
- */
-export declare function isNativeAvailable(): boolean;
-/**
- * Scan app directory using Rust native code
- * Returns null if native module is not available
- */
-export declare function scanAppNative(appDir: string): NapiScanResult | null;
-/**
- * Generate client manifest using Rust native code
- */
-export declare function generateClientManifestNative(appDir: string, buildId: string): NapiClientManifest | null;
-/**
- * Generate server manifest using Rust native code
- */
-export declare function generateServerManifestNative(appDir: string, buildId: string): NapiServerManifest | null;
-/**
- * Generate unique mount ID for client component
- */
-export declare function generateMountIdNative(): string | null;
-/**
- * Reset mount ID counter (call at start of each request)
- */
-export declare function resetMountCounterNative(): boolean;
-/**
- * Convert NAPI scan result to internal format
- */
-export declare function convertScanResult(result: NapiScanResult): {
-    clientComponents: {
-        absolutePath: string;
-        relativePath: string;
-        isClient: boolean;
-        directiveLine: number;
-        componentType: string;
-        exports: string[];
-        clientHooksUsed: string[];
-        hasMetadata: boolean;
-        hasGenerateMetadata: boolean;
-    }[];
-    serverComponents: {
-        absolutePath: string;
-        relativePath: string;
-        isClient: boolean;
-        directiveLine: number;
-        componentType: string;
-        exports: string[];
-        clientHooksUsed: any[];
-        hasMetadata: boolean;
-        hasGenerateMetadata: boolean;
-    }[];
-    pages: NapiScannedComponent[];
-    layouts: NapiScannedComponent[];
-    apiRoutes: NapiScannedComponent[];
-    errors: NapiServerComponentError[];
-    totalFiles: number;
-    scanTimeMs: number;
-};
+/**
+ * Vista RSC Native Scanner
+ *
+ * Uses Rust-powered native bindings for blazing fast component scanning.
+ * Falls back to TypeScript implementation if native module unavailable.
+ */
+export interface NapiScannedComponent {
+    absolutePath: string;
+    relativePath: string;
+    isClient: boolean;
+    directiveLine: number;
+    componentType: string;
+    exports: string[];
+    clientHooksUsed: string[];
+    hasMetadata: boolean;
+    hasGenerateMetadata: boolean;
+}
+export interface NapiServerComponentError {
+    file: string;
+    message: string;
+    hooks: string[];
+}
+export interface NapiScanResult {
+    clientComponents: NapiScannedComponent[];
+    serverComponents: NapiScannedComponent[];
+    pages: NapiScannedComponent[];
+    layouts: NapiScannedComponent[];
+    apiRoutes: NapiScannedComponent[];
+    errors: NapiServerComponentError[];
+    totalFiles: number;
+    scanTimeMs: number;
+}
+export interface NapiClientModuleEntry {
+    id: string;
+    path: string;
+    absolutePath: string;
+    chunkName: string;
+    exports: string[];
+    asyncLoad: boolean;
+}
+export interface NapiClientManifest {
+    buildId: string;
+    clientModules: NapiClientModuleEntry[];
+}
+export interface NapiRouteEntry {
+    pattern: string;
+    pagePath: string;
+    layoutPaths: string[];
+    loadingPath: string | null;
+    errorPath: string | null;
+    routeType: string;
+}
+export interface NapiServerModuleEntry {
+    id: string;
+    path: string;
+    absolutePath: string;
+    componentType: string;
+    hasMetadata: boolean;
+    hasGenerateMetadata: boolean;
+}
+export interface NapiServerManifest {
+    buildId: string;
+    serverModules: NapiServerModuleEntry[];
+    routes: NapiRouteEntry[];
+}
+export interface NapiClientScanRoot {
+    dir: string;
+    prefix: string;
+}
+/**
+ * Check if native module is available
+ */
+export declare function isNativeAvailable(): boolean;
+/**
+ * Scan app directory using Rust native code
+ * Returns null if native module is not available
+ */
+export declare function scanAppNative(appDir: string): NapiScanResult | null;
+/**
+ * Generate client manifest using Rust native code
+ */
+export declare function generateClientManifestNative(appDir: string, buildId: string): NapiClientManifest | null;
+/**
+ * Generate client manifest from an explicit project root plus `app/`
+ */
+export declare function generateClientManifestForProjectNative(cwd: string, appDir: string, buildId: string): NapiClientManifest | null;
+/**
+ * Discover project-level client scan roots using Rust native code
+ */
+export declare function discoverProjectClientRootsNative(cwd: string): NapiClientScanRoot[] | null;
+/**
+ * Generate server manifest using Rust native code
+ */
+export declare function generateServerManifestNative(appDir: string, buildId: string): NapiServerManifest | null;
+/**
+ * Generate unique mount ID for client component
+ */
+export declare function generateMountIdNative(): string | null;
+/**
+ * Reset mount ID counter (call at start of each request)
+ */
+export declare function resetMountCounterNative(): boolean;
+/**
+ * Convert NAPI scan result to internal format
+ */
+export declare function convertScanResult(result: NapiScanResult): {
+    clientComponents: {
+        absolutePath: string;
+        relativePath: string;
+        isClient: boolean;
+        directiveLine: number;
+        componentType: string;
+        exports: string[];
+        clientHooksUsed: string[];
+        hasMetadata: boolean;
+        hasGenerateMetadata: boolean;
+    }[];
+    serverComponents: {
+        absolutePath: string;
+        relativePath: string;
+        isClient: boolean;
+        directiveLine: number;
+        componentType: string;
+        exports: string[];
+        clientHooksUsed: any[];
+        hasMetadata: boolean;
+        hasGenerateMetadata: boolean;
+    }[];
+    pages: NapiScannedComponent[];
+    layouts: NapiScannedComponent[];
+    apiRoutes: NapiScannedComponent[];
+    errors: NapiServerComponentError[];
+    totalFiles: number;
+    scanTimeMs: number;
+};