@vistagenic/vista 0.3.6 → 0.3.9

package/dist/metadata/routes.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Next-compatible MetadataRoute helpers for robots.txt, sitemap.xml, and web manifests.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeRobots = serializeRobots;
+exports.serializeSitemap = serializeSitemap;
+exports.robots = robots;
+exports.sitemap = sitemap;
+exports.manifest = manifest;
+exports.metadataRouteToResponse = metadataRouteToResponse;
+function asArray(value) {
+    if (value === undefined)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function formatLastModified(value) {
+    if (!value)
+        return undefined;
+    if (value instanceof Date)
+        return value.toISOString();
+    return value;
+}
+/** Serialize a Robots object to robots.txt body text. */
+function serializeRobots(data) {
+    const rules = asArray(data.rules);
+    const lines = [];
+    for (const rule of rules) {
+        const agents = asArray(rule.userAgent);
+        if (agents.length === 0) {
+            lines.push('User-agent: *');
+        }
+        else {
+            for (const agent of agents) {
+                lines.push(`User-agent: ${agent}`);
+            }
+        }
+        for (const allow of asArray(rule.allow)) {
+            lines.push(`Allow: ${allow}`);
+        }
+        for (const disallow of asArray(rule.disallow)) {
+            lines.push(`Disallow: ${disallow}`);
+        }
+        if (typeof rule.crawlDelay === 'number') {
+            lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+        }
+        if (rule.other) {
+            for (const [key, raw] of Object.entries(rule.other)) {
+                for (const entry of asArray(raw)) {
+                    lines.push(`${key}: ${entry}`);
+                }
+            }
+        }
+        lines.push('');
+    }
+    if (data.host) {
+        lines.push(`Host: ${data.host}`);
+    }
+    for (const sitemapUrl of asArray(data.sitemap)) {
+        lines.push(`Sitemap: ${sitemapUrl}`);
+    }
+    return `${lines.join('\n').replace(/\n+$/, '')}\n`;
+}
+/** Serialize sitemap entries to XML. */
+function serializeSitemap(entries) {
+    const urls = entries
+        .map((entry) => {
+        const parts = [`<loc>${escapeXml(entry.url)}</loc>`];
+        const lastmod = formatLastModified(entry.lastModified);
+        if (lastmod)
+            parts.push(`<lastmod>${escapeXml(lastmod)}</lastmod>`);
+        if (entry.changeFrequency) {
+            parts.push(`<changefreq>${escapeXml(entry.changeFrequency)}</changefreq>`);
+        }
+        if (typeof entry.priority === 'number') {
+            parts.push(`<priority>${entry.priority}</priority>`);
+        }
+        if (entry.alternates?.languages) {
+            for (const [lang, href] of Object.entries(entry.alternates.languages)) {
+                parts.push(`<xhtml:link rel="alternate" hreflang="${escapeXml(lang)}" href="${escapeXml(href)}" />`);
+            }
+        }
+        for (const image of entry.images || []) {
+            parts.push(`<image:image><image:loc>${escapeXml(image)}</image:loc></image:image>`);
+        }
+        return `<url>${parts.join('')}</url>`;
+    })
+        .join('');
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">${urls}</urlset>`;
+}
+const DEFAULT_CACHE = 'public, max-age=0, s-maxage=3600';
+/** Build a robots.txt Response. */
+function robots(data) {
+    return new Response(serializeRobots(data), {
+        headers: {
+            'Content-Type': 'text/plain; charset=utf-8',
+            'Cache-Control': DEFAULT_CACHE,
+        },
+    });
+}
+/** Build a sitemap.xml Response. */
+function sitemap(entries) {
+    return new Response(serializeSitemap(entries), {
+        headers: {
+            'Content-Type': 'application/xml; charset=utf-8',
+            'Cache-Control': DEFAULT_CACHE,
+        },
+    });
+}
+/** Build a webmanifest JSON Response. */
+function manifest(data) {
+    return new Response(JSON.stringify(data, null, 2), {
+        headers: {
+            'Content-Type': 'application/manifest+json; charset=utf-8',
+            'Cache-Control': DEFAULT_CACHE,
+        },
+    });
+}
+/** Convert a MetadataRoute default-export payload into a Response. */
+function metadataRouteToResponse(stem, payload) {
+    if (payload instanceof Response)
+        return payload;
+    if (payload == null)
+        return null;
+    if (stem === 'robots' && typeof payload === 'object') {
+        return robots(payload);
+    }
+    if (stem === 'sitemap' && Array.isArray(payload)) {
+        return sitemap(payload);
+    }
+    if (stem === 'manifest' && typeof payload === 'object') {
+        return manifest(payload);
+    }
+    return null;
+}

package/dist/metadata/types.d.ts

@@ -8,7 +8,7 @@
  * Template string for title with inheritance support
  */
 export type TemplateString = {
-    default: string;
+    default?: string;
     template?: string;
     absolute?: string;
 };

package/dist/metadata/types.js

@@ -11,5 +11,7 @@ exports.isTemplateString = isTemplateString;
 // Export type guard
 // ============================================================================
 function isTemplateString(title) {
-    return typeof title === 'object' && title !== null && 'default' in title;
+    if (typeof title !== 'object' || title === null)
+        return false;
+    return 'default' in title || 'absolute' in title || 'template' in title;
 }

package/dist/og/image-response.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ImageResponse — Next/Astro-compatible OG image generation via Satori + resvg.
+ */
+import type { ReactElement } from 'react';
+export type ImageResponseOptions = {
+    width?: number;
+    height?: number;
+    status?: number;
+    statusText?: string;
+    headers?: HeadersInit;
+    fonts?: Array<{
+        name: string;
+        data: ArrayBuffer | Buffer;
+        weight?: number;
+        style?: 'normal' | 'italic';
+    }>;
+    debug?: boolean;
+};
+/**
+ * Generate a PNG Response from a JSX tree (Satori subset of CSS).
+ *
+ * @example
+ * ```tsx
+ * import { ImageResponse } from 'vista/og'
+ *
+ * export default function OpenGraphImage() {
+ *   return new ImageResponse(
+ *     <div style={{ fontSize: 64, background: '#111', color: 'white', width: '100%', height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+ *       Vista
+ *     </div>,
+ *     { width: 1200, height: 630 }
+ *   )
+ * }
+ * ```
+ */
+export declare class ImageResponse extends Response {
+    constructor(element: ReactElement, options?: ImageResponseOptions);
+}

package/dist/og/image-response.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * ImageResponse — Next/Astro-compatible OG image generation via Satori + resvg.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageResponse = void 0;
+async function loadSatori() {
+    const mod = await import('satori');
+    return mod.default || mod;
+}
+async function renderSvgToPng(svg) {
+    const resvgMod = await import('@resvg/resvg-wasm');
+    const { Resvg, initWasm } = resvgMod;
+    if (typeof initWasm === 'function') {
+        try {
+            // Prefer bundled wasm; fall back silently if already initialized.
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const wasmUrl = require.resolve('@resvg/resvg-wasm/index_bg.wasm');
+            const fs = await import('fs');
+            const wasm = fs.readFileSync(wasmUrl);
+            await initWasm(wasm);
+        }
+        catch {
+            try {
+                await initWasm();
+            }
+            catch {
+                // Already initialized in this process.
+            }
+        }
+    }
+    const resvg = new Resvg(svg, {
+        fitTo: { mode: 'original' },
+    });
+    const pngData = resvg.render();
+    return pngData.asPng();
+}
+/**
+ * Generate a PNG Response from a JSX tree (Satori subset of CSS).
+ *
+ * @example
+ * ```tsx
+ * import { ImageResponse } from 'vista/og'
+ *
+ * export default function OpenGraphImage() {
+ *   return new ImageResponse(
+ *     <div style={{ fontSize: 64, background: '#111', color: 'white', width: '100%', height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+ *       Vista
+ *     </div>,
+ *     { width: 1200, height: 630 }
+ *   )
+ * }
+ * ```
+ */
+class ImageResponse extends Response {
+    constructor(element, options = {}) {
+        const width = options.width ?? 1200;
+        const height = options.height ?? 630;
+        const status = options.status ?? 200;
+        const statusText = options.statusText;
+        const headers = new Headers(options.headers);
+        headers.set('Content-Type', 'image/png');
+        if (!headers.has('Cache-Control')) {
+            headers.set('Cache-Control', 'public, immutable, no-transform, max-age=31536000');
+        }
+        const body = new ReadableStream({
+            async start(controller) {
+                try {
+                    const satori = await loadSatori();
+                    const svg = await satori(element, {
+                        width,
+                        height,
+                        fonts: options.fonts,
+                        embedFont: true,
+                    });
+                    const png = await renderSvgToPng(svg);
+                    controller.enqueue(png);
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+        super(body, { status, statusText, headers });
+    }
+}
+exports.ImageResponse = ImageResponse;

package/dist/og/index.d.ts

@@ -0,0 +1,2 @@
+export { ImageResponse } from './image-response';
+export type { ImageResponseOptions } from './image-response';

package/dist/og/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageResponse = void 0;
+var image_response_1 = require("./image-response");
+Object.defineProperty(exports, "ImageResponse", { enumerable: true, get: function () { return image_response_1.ImageResponse; } });

package/dist/rust/index.d.ts

@@ -0,0 +1,13 @@
+export interface ClassifiedSegment {
+    kind: string;
+    segment: string;
+}
+export declare function nativeBindingsLoaded(): boolean;
+export declare function classifyAppSegment(folder: string): ClassifiedSegment;
+export declare function routePattern(folders: string[]): string;
+export declare function encodeVistaErrorCode(code: string): string;
+export declare function findVistaErrorCodes(source: string): string[];
+export declare function tasklessSteps(enabled: boolean): string[];
+export declare function classifyAppSegmentFallback(folder: string): ClassifiedSegment;
+export declare function routePatternFallback(folders: string[]): string;
+export declare function readBoundPipeline(cwd?: string): Record<string, unknown> | null;

package/dist/rust/index.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeBindingsLoaded = nativeBindingsLoaded;
+exports.classifyAppSegment = classifyAppSegment;
+exports.routePattern = routePattern;
+exports.encodeVistaErrorCode = encodeVistaErrorCode;
+exports.findVistaErrorCodes = findVistaErrorCodes;
+exports.tasklessSteps = tasklessSteps;
+exports.classifyAppSegmentFallback = classifyAppSegmentFallback;
+exports.routePatternFallback = routePatternFallback;
+exports.readBoundPipeline = readBoundPipeline;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+let native;
+function loadNative() {
+    if (native !== undefined)
+        return native;
+    const candidates = [
+        path_1.default.resolve(__dirname, '../../../crates/vista-napi'),
+        path_1.default.resolve(__dirname, '../../../../crates/vista-napi'),
+        path_1.default.resolve(process.cwd(), 'crates/vista-napi'),
+        path_1.default.resolve(process.cwd(), '../crates/vista-napi'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            native = require(candidate);
+            return native;
+        }
+        catch {
+            // Try the next location. The TypeScript fallback stays correct either way.
+        }
+    }
+    native = null;
+    return null;
+}
+function nativeBindingsLoaded() {
+    return loadNative() !== null;
+}
+function classifyAppSegment(folder) {
+    const bound = loadNative();
+    if (bound?.classifyAppSegmentInfo)
+        return bound.classifyAppSegmentInfo(folder);
+    return classifyAppSegmentFallback(folder);
+}
+function routePattern(folders) {
+    const bound = loadNative();
+    if (bound?.routePattern)
+        return bound.routePattern(folders);
+    return routePatternFallback(folders);
+}
+function isValidCode(code) {
+    return code.length > 0 && /^[A-Z0-9_]+$/.test(code);
+}
+function encodeVistaErrorCode(code) {
+    const bound = loadNative();
+    if (bound?.encodeVistaErrorCode)
+        return bound.encodeVistaErrorCode(code);
+    if (code.startsWith('VISTA_') && isValidCode(code.slice('VISTA_'.length)))
+        return code;
+    return `VISTA_${code}`;
+}
+function findVistaErrorCodes(source) {
+    const bound = loadNative();
+    if (bound?.findVistaErrorCodes)
+        return bound.findVistaErrorCodes(source);
+    const found = [];
+    const pattern = /VISTA_([A-Z0-9_]+)/g;
+    for (const match of source.matchAll(pattern)) {
+        if (!found.includes(match[1]))
+            found.push(match[1]);
+    }
+    return found;
+}
+function tasklessSteps(enabled) {
+    const bound = loadNative();
+    if (bound?.tasklessSteps)
+        return bound.tasklessSteps(enabled);
+    return enabled ? ['scan', 'reuse-state', 'serve'] : ['scan', 'queue-work', 'serve'];
+}
+function classifyAppSegmentFallback(folder) {
+    if (!folder)
+        return { kind: 'static', segment: '' };
+    if (folder.startsWith('(...)') ||
+        folder.startsWith('(..)(..)') ||
+        folder.startsWith('(..)') ||
+        folder.startsWith('(.)')) {
+        return { kind: 'interception', segment: folder };
+    }
+    if (folder.startsWith('(') && folder.endsWith(')') && folder.length >= 2) {
+        return { kind: 'group', segment: folder.slice(1, -1) };
+    }
+    if (folder.startsWith('@') && folder.length > 1) {
+        return { kind: 'parallel', segment: folder.slice(1) };
+    }
+    if (folder.startsWith('[[...') && folder.endsWith(']]') && folder.length > '[[...]]'.length) {
+        return { kind: 'optional-catch-all', segment: folder.slice(5, -2) };
+    }
+    if (folder.startsWith('[...') && folder.endsWith(']') && folder.length > '[...]'.length) {
+        return { kind: 'catch-all', segment: folder.slice(4, -1) };
+    }
+    if (folder.startsWith('[') && folder.endsWith(']') && folder.length >= 2) {
+        return { kind: 'dynamic', segment: folder.slice(1, -1) };
+    }
+    return { kind: 'static', segment: folder };
+}
+function routePatternFallback(folders) {
+    const parts = [];
+    for (const folder of folders) {
+        const classified = classifyAppSegmentFallback(folder);
+        if (classified.kind === 'group' || classified.kind === 'parallel' || classified.kind === 'interception') {
+            continue;
+        }
+        if (classified.kind === 'dynamic')
+            parts.push(`:${classified.segment}`);
+        else if (classified.kind === 'catch-all')
+            parts.push(`:${classified.segment}*`);
+        else if (classified.kind === 'optional-catch-all')
+            parts.push(`:${classified.segment}*?`);
+        else
+            parts.push(classified.segment);
+    }
+    return parts.length === 0 ? '/' : `/${parts.join('/')}`;
+}
+function readBoundPipeline(cwd = process.cwd()) {
+    const file = path_1.default.join(cwd, '.flash', 'pipeline', 'bound.json');
+    if (!fs_1.default.existsSync(file))
+        return null;
+    return JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+}

package/dist/server/engine.js

@@ -341,6 +341,15 @@ function startServer(port = 3003, compiler) {
                 })
                     .filter((entry) => entry.trim().length > 0);
                 (0, logger_1.logEvent)('Build error detected, pushing to browser...');
+                console.error('');
+                (0, logger_1.logError)(`Build failed with ${errorMessages.length} error${errorMessages.length === 1 ? '' : 's'}`);
+                for (const message of errorMessages) {
+                    const text = message.replace(/\u001b\[[0-9;]*m/g, '').trim();
+                    if (!text)
+                        continue;
+                    console.error(text);
+                    console.error('');
+                }
                 pushCompileError(errorMessages);
             }
             else {
@@ -588,22 +597,23 @@ function startServer(port = 3003, compiler) {
                 const pageDir = path_1.default.dirname(pagePath);
                 const layouts = (0, root_resolver_1.resolveLayoutChain)(cwd, pageDir, isDev);
                 // Metadata extraction - merge all layout metadata + page metadata
+                const { deepMergeMetadata } = require('../metadata/merge');
                 let metadata = {};
                 for (const layout of layouts) {
                     if (layout.metadata) {
-                        metadata = { ...metadata, ...layout.metadata };
+                        metadata = deepMergeMetadata(metadata, layout.metadata);
                     }
                 }
                 // Get page static metadata (overrides layouts)
                 if (PageModule.metadata) {
-                    metadata = { ...metadata, ...PageModule.metadata };
+                    metadata = deepMergeMetadata(metadata, PageModule.metadata);
                 }
                 // Get dynamic metadata from generateMetadata function
                 if (typeof PageModule.generateMetadata === 'function') {
                     try {
                         const dynamicMeta = await PageModule.generateMetadata({ params, searchParams: req.query }, metadata // parent metadata
                         );
-                        metadata = { ...metadata, ...dynamicMeta };
+                        metadata = deepMergeMetadata(metadata, dynamicMeta);
                     }
                     catch (e) {
                         console.error('Error in generateMetadata:', e);

package/dist/server/logger.js

@@ -99,7 +99,8 @@ function printServerReady(info) {
     const localUrl = `http://localhost:${port}`;
     const networkUrl = networkAddr ? `http://${networkAddr}:${port}` : null;
     console.log(VISTA_BANNER);
-    console.log(`  ${green('▼')} ${bold('Vista.Js')} ${dim(`v${getVistaVersion()}`)}`);
+    const engineLabel = process.env.VISTA_ENGINE === 'flashpack' ? ` ${cyan('(flashpack)')}` : '';
+    console.log(`  ${green('▼')} ${bold('Vista.Js')} ${dim(`v${getVistaVersion()}`)}${engineLabel}`);
     console.log('');
     console.log(`  ${dim('┃')} ${bold('Local:')}        ${cyan(localUrl)}`);
     if (networkUrl) {

package/dist/server/project-alias-resolver.d.ts

@@ -2,3 +2,10 @@ export interface ProjectAliasResolver {
     resolve: (request: string) => string | null;
 }
 export declare function createProjectAliasResolver(cwd: string, resolveFromWorkspace: (specifier: string, cwd: string) => string): ProjectAliasResolver | null;
+/**
+ * Webpack resolve.alias entries for the project's tsconfig/jsconfig `paths`.
+ * Wildcard `@/*` becomes the prefix alias `@` so client bundles resolve `@/data/site`.
+ */
+export declare function loadProjectWebpackAliases(cwd: string): Record<string, string>;
+/** True when a module request is covered by a webpack path alias. */
+export declare function requestUsesProjectAlias(request: string, aliases: Record<string, string>): boolean;

package/dist/server/project-alias-resolver.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createProjectAliasResolver = createProjectAliasResolver;
+exports.loadProjectWebpackAliases = loadProjectWebpackAliases;
+exports.requestUsesProjectAlias = requestUsesProjectAlias;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const projectAliasCache = new Map();
@@ -215,3 +217,71 @@ function createProjectAliasResolver(cwd, resolveFromWorkspace) {
     projectAliasCache.set(cwd, resolver);
     return resolver;
 }
+/**
+ * Webpack resolve.alias entries for the project's tsconfig/jsconfig `paths`.
+ * Wildcard `@/*` becomes the prefix alias `@` so client bundles resolve `@/data/site`.
+ */
+function loadProjectWebpackAliases(cwd) {
+    const configPath = ['tsconfig.json', 'jsconfig.json']
+        .map((filename) => path_1.default.join(cwd, filename))
+        .find((filename) => fs_1.default.existsSync(filename));
+    if (!configPath)
+        return {};
+    let compilerOptions = null;
+    try {
+        const rawConfig = fs_1.default.readFileSync(configPath, 'utf-8');
+        const parsedConfig = JSON.parse(stripJsonComments(rawConfig));
+        compilerOptions = parsedConfig.compilerOptions ?? null;
+    }
+    catch {
+        return {};
+    }
+    const rawPaths = compilerOptions?.paths;
+    if (!rawPaths || typeof rawPaths !== 'object')
+        return {};
+    const configDir = path_1.default.dirname(configPath);
+    const baseDir = path_1.default.resolve(configDir, typeof compilerOptions?.baseUrl === 'string' && compilerOptions.baseUrl.trim()
+        ? compilerOptions.baseUrl
+        : '.');
+    const aliases = {};
+    for (const [pattern, targetsValue] of Object.entries(rawPaths)) {
+        const targets = Array.isArray(targetsValue)
+            ? targetsValue.filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+            : [];
+        const target = targets[0];
+        if (!target)
+            continue;
+        if (pattern.includes('*')) {
+            const starIndex = pattern.indexOf('*');
+            const requestPrefix = pattern.slice(0, starIndex);
+            const targetStar = target.indexOf('*');
+            const targetPrefix = targetStar === -1 ? target : target.slice(0, targetStar);
+            if (!requestPrefix)
+                continue;
+            // enhanced-resolve matches `name` or `${name}/`. A tsconfig prefix of
+            // `@/` must be registered as `@`, or the resolver looks for `@//`.
+            const aliasName = requestPrefix.endsWith('/')
+                ? requestPrefix.slice(0, -1)
+                : requestPrefix;
+            if (!aliasName)
+                continue;
+            // The matched remainder already begins with `/`. path.resolve drops a
+            // trailing separator, so do not add one back.
+            aliases[aliasName] = path_1.default.resolve(baseDir, targetPrefix);
+            continue;
+        }
+        const resolved = resolveAliasTargetPath(path_1.default.resolve(baseDir, target));
+        if (resolved) {
+            aliases[pattern] = resolved;
+        }
+    }
+    return aliases;
+}
+/** True when a module request is covered by a webpack path alias. */
+function requestUsesProjectAlias(request, aliases) {
+    for (const key of Object.keys(aliases)) {
+        if (request === key || request.startsWith(`${key}/`))
+            return true;
+    }
+    return false;
+}