@vistagenic/vista 0.2.16 → 0.3.2

package/dist/deploy/detect.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeResolvedTarget = normalizeResolvedTarget;
+exports.resolveDeployTarget = resolveDeployTarget;
+exports.resolveEffectiveOutput = resolveEffectiveOutput;
+exports.listKnownTargets = listKnownTargets;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+const PLATFORM_FILES = [
+    { target: 'render', file: 'render.yaml' },
+    { target: 'vercel', file: 'vercel.json' },
+    { target: 'cloudflare', file: 'wrangler.toml' },
+    { target: 'netlify', file: 'netlify.toml' },
+    { target: 'docker', file: 'Dockerfile' },
+];
+function detectFromEnv() {
+    if (process.env.VERCEL === '1' || process.env.NOW_REGION)
+        return 'vercel';
+    if (process.env.CF_PAGES === '1' || process.env.CLOUDFLARE_PAGES)
+        return 'cloudflare';
+    if (process.env.RENDER === 'true' || process.env.RENDER_SERVICE_ID)
+        return 'render';
+    if (process.env.NETLIFY === 'true' || process.env.NETLIFY_SITE_ID)
+        return 'netlify';
+    return null;
+}
+function detectFromProjectFiles(cwd) {
+    for (const entry of PLATFORM_FILES) {
+        if (fs_1.default.existsSync(path_1.default.join(cwd, entry.file))) {
+            return entry.target;
+        }
+    }
+    return null;
+}
+function normalizeResolvedTarget(raw) {
+    const value = String(raw ?? '')
+        .trim()
+        .toLowerCase();
+    if (value === 'render' ||
+        value === 'vercel' ||
+        value === 'cloudflare' ||
+        value === 'netlify' ||
+        value === 'docker') {
+        return value;
+    }
+    return null;
+}
+function resolveDeployTarget(cwd, deployConfig, cliTarget) {
+    const explicitCli = normalizeResolvedTarget(cliTarget);
+    if (explicitCli)
+        return explicitCli;
+    if (deployConfig.target !== 'auto') {
+        const fromConfig = normalizeResolvedTarget(deployConfig.target);
+        if (fromConfig)
+            return fromConfig;
+    }
+    const fromEnv = detectFromEnv();
+    if (fromEnv)
+        return fromEnv;
+    const fromFiles = detectFromProjectFiles(cwd);
+    if (fromFiles)
+        return fromFiles;
+    throw new Error('[vista:deploy] Unable to detect deployment target. Pass --target <render|vercel|cloudflare|netlify|docker> or set deploy.target in vista.config.ts.');
+}
+function resolveEffectiveOutput(deployConfig, target) {
+    if (deployConfig.output !== 'standalone') {
+        return deployConfig.output;
+    }
+    return (0, config_1.inferDeployOutputForTarget)(target);
+}
+function listKnownTargets() {
+    return ['auto', 'render', 'vercel', 'cloudflare', 'netlify', 'docker'];
+}

package/dist/deploy/index.d.ts

@@ -0,0 +1,24 @@
+import type { DeployResult } from './types';
+export { writeVercelBuildOutput, isVercelBuildEnvironment, hasUserVercelConfig } from './adapters/vercel';
+export { resolveDeployTarget, listKnownTargets } from './detect';
+export type { DeployContext, DeployResult, DeployAdapter, ResolvedDeployTarget } from './types';
+export interface RunDeployOptions {
+    cwd?: string;
+    target?: string | null;
+    dryRun?: boolean;
+    skipBuild?: boolean;
+    prod?: boolean;
+    preview?: boolean;
+    force?: boolean;
+    debug?: boolean;
+    log?: (message: string) => void;
+    warn?: (message: string) => void;
+    error?: (message: string) => void;
+    build?: (cwd: string) => Promise<void>;
+}
+export declare function runDeploy(options?: RunDeployOptions): Promise<DeployResult>;
+export declare function generateDeploymentOutputs(options: {
+    cwd: string;
+    vistaDir: string;
+    debug?: boolean;
+}): void;

package/dist/deploy/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listKnownTargets = exports.resolveDeployTarget = exports.hasUserVercelConfig = exports.isVercelBuildEnvironment = exports.writeVercelBuildOutput = void 0;
+exports.runDeploy = runDeploy;
+exports.generateDeploymentOutputs = generateDeploymentOutputs;
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../constants");
+const config_1 = require("../config");
+const adapters_1 = require("./adapters");
+const detect_1 = require("./detect");
+const preflight_1 = require("./preflight");
+var vercel_1 = require("./adapters/vercel");
+Object.defineProperty(exports, "writeVercelBuildOutput", { enumerable: true, get: function () { return vercel_1.writeVercelBuildOutput; } });
+Object.defineProperty(exports, "isVercelBuildEnvironment", { enumerable: true, get: function () { return vercel_1.isVercelBuildEnvironment; } });
+Object.defineProperty(exports, "hasUserVercelConfig", { enumerable: true, get: function () { return vercel_1.hasUserVercelConfig; } });
+var detect_2 = require("./detect");
+Object.defineProperty(exports, "resolveDeployTarget", { enumerable: true, get: function () { return detect_2.resolveDeployTarget; } });
+Object.defineProperty(exports, "listKnownTargets", { enumerable: true, get: function () { return detect_2.listKnownTargets; } });
+function createContext(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const config = (0, config_1.loadConfig)(cwd);
+    const deployConfig = (0, config_1.resolveDeployConfig)(config);
+    const target = (0, detect_1.resolveDeployTarget)(cwd, deployConfig, options.target ?? null);
+    return {
+        cwd,
+        vistaDir: path_1.default.join(cwd, constants_1.BUILD_DIR),
+        config,
+        deployConfig,
+        target,
+        dryRun: Boolean(options.dryRun),
+        skipBuild: Boolean(options.skipBuild),
+        prod: options.preview ? false : options.prod !== false,
+        preview: Boolean(options.preview),
+        force: Boolean(options.force),
+        debug: options.debug,
+        log: options.log,
+        warn: options.warn,
+        error: options.error,
+    };
+}
+function printResult(ctx, result) {
+    const log = ctx.log ?? console.log;
+    const warn = ctx.warn ?? console.warn;
+    log('');
+    log(`[vista:deploy] Target: ${result.target}`);
+    log(`[vista:deploy] Status: ${result.status}`);
+    if (result.url) {
+        log(`[vista:deploy] URL: ${result.url}`);
+    }
+    if (result.artifactPaths?.length) {
+        log('[vista:deploy] Artifacts:');
+        for (const artifact of result.artifactPaths) {
+            log(`  - ${artifact}`);
+        }
+    }
+    if (result.warnings?.length) {
+        for (const message of result.warnings) {
+            warn(`[vista:deploy] Warning: ${message}`);
+        }
+    }
+    if (result.instructions?.length) {
+        log('[vista:deploy] Next steps:');
+        for (const instruction of result.instructions) {
+            log(`  - ${instruction}`);
+        }
+    }
+    log('');
+}
+async function runDeploy(options = {}) {
+    const ctx = createContext(options);
+    const adapter = (0, adapters_1.getDeployAdapter)(ctx.target);
+    const log = ctx.log ?? console.log;
+    const error = ctx.error ?? console.error;
+    if (!options.skipBuild) {
+        if (options.build) {
+            log('[vista:deploy] Running production build...');
+            await options.build(ctx.cwd);
+        }
+        else {
+            error('[vista:deploy] Internal error: build callback is required.');
+            return { status: 'failed', target: ctx.target, warnings: ['Missing build callback.'] };
+        }
+    }
+    const artifactErrors = (0, preflight_1.validateBuildArtifacts)(ctx);
+    if (artifactErrors.length > 0) {
+        for (const message of artifactErrors) {
+            error(`[vista:deploy] ${message}`);
+        }
+        return { status: 'failed', target: ctx.target, warnings: artifactErrors };
+    }
+    const preflightMessages = await adapter.preflight(ctx);
+    const { errors, warnings } = (0, preflight_1.splitPreflightMessages)(preflightMessages);
+    if (errors.length > 0) {
+        for (const message of errors) {
+            error(`[vista:deploy] ${message}`);
+        }
+        return { status: 'failed', target: ctx.target, warnings: [...warnings, ...errors] };
+    }
+    for (const message of warnings) {
+        (ctx.warn ?? console.warn)(`[vista:deploy] Warning: ${message}`);
+    }
+    const result = ctx.dryRun ? await adapter.emit(ctx) : await adapter.deploy(ctx);
+    printResult(ctx, result);
+    return result;
+}
+function generateDeploymentOutputs(options) {
+    const { writeVercelBuildOutput } = require('./adapters/vercel');
+    writeVercelBuildOutput({ ...options, force: false });
+}

package/dist/deploy/preflight.d.ts

@@ -0,0 +1,8 @@
+import type { DeployContext } from './types';
+export declare function validateBuildArtifacts(ctx: DeployContext): string[];
+export declare function runStaticHostPreflight(ctx: DeployContext): Promise<string[]>;
+export declare function runStandalonePreflight(ctx: DeployContext): Promise<string[]>;
+export declare function splitPreflightMessages(messages: string[]): {
+    errors: string[];
+    warnings: string[];
+};

package/dist/deploy/preflight.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBuildArtifacts = validateBuildArtifacts;
+exports.runStaticHostPreflight = runStaticHostPreflight;
+exports.runStandalonePreflight = runStandalonePreflight;
+exports.splitPreflightMessages = splitPreflightMessages;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+const artifact_validator_1 = require("../server/artifact-validator");
+const utils_1 = require("./utils");
+function hasDynamicOnlyRoutes(vistaDir) {
+    const routesManifest = (0, utils_1.readJsonSafe)(path_1.default.join(vistaDir, 'routes-manifest.json'));
+    const prerenderManifest = (0, utils_1.readJsonSafe)(path_1.default.join(vistaDir, 'prerender-manifest.json'));
+    const dynamicCount = routesManifest?.dynamicRoutes?.length ?? 0;
+    const staticCount = routesManifest?.staticRoutes?.length ?? 0;
+    const prerenderedCount = Object.keys(prerenderManifest?.routes ?? {}).length;
+    const dynamicPrerenderCount = Object.keys(prerenderManifest?.dynamicRoutes ?? {}).length;
+    if (dynamicCount > 0 && staticCount === 0 && prerenderedCount === 0) {
+        return true;
+    }
+    if (dynamicPrerenderCount > 0 && prerenderedCount === 0) {
+        return true;
+    }
+    return false;
+}
+function validateBuildArtifacts(ctx) {
+    const missing = (0, artifact_validator_1.validateVistaArtifacts)(ctx.cwd, 'rsc');
+    if (missing.length > 0) {
+        return missing.map((entry) => `Missing build artifact: ${entry}`);
+    }
+    return [];
+}
+async function runStaticHostPreflight(ctx) {
+    const warnings = [];
+    const errors = [];
+    const staticPagesDir = path_1.default.join(ctx.vistaDir, 'static', 'pages');
+    if (!fs_1.default.existsSync(staticPagesDir)) {
+        errors.push('No pre-rendered pages found at .vista/static/pages. Static hosts require SSG output from "vista build".');
+    }
+    if (hasDynamicOnlyRoutes(ctx.vistaDir)) {
+        errors.push('This app appears to rely on dynamic server rendering without static fallbacks. Deploy to Render or Docker for full runtime support.');
+    }
+    const typedApi = (0, config_1.resolveTypedApiConfig)(ctx.config);
+    if (typedApi.enabled) {
+        errors.push('Typed API is enabled. Static CDN hosts cannot run typed API runtime. Use deploy.target "render" or "docker".');
+    }
+    const appApiDir = path_1.default.join(ctx.cwd, 'app', 'api');
+    if (fs_1.default.existsSync(appApiDir)) {
+        warnings.push('Found app/api routes. Server-side API routes are not supported on static CDN deploy targets.');
+    }
+    if (ctx.config.images && ctx.config.images.unoptimized !== true) {
+        warnings.push('Consider setting images.unoptimized: true in vista.config.ts for static hosts without /_vista/image optimization.');
+    }
+    return [...errors, ...warnings.map((entry) => `warning:${entry}`)];
+}
+async function runStandalonePreflight(ctx) {
+    const errors = [];
+    const standaloneServer = path_1.default.join(ctx.vistaDir, 'standalone', 'server.js');
+    if (!fs_1.default.existsSync(standaloneServer)) {
+        errors.push('Missing .vista/standalone/server.js. Run "vista build" before deploying to Node hosts.');
+    }
+    return errors;
+}
+function splitPreflightMessages(messages) {
+    const errors = [];
+    const warnings = [];
+    for (const message of messages) {
+        if (message.startsWith('warning:')) {
+            warnings.push(message.slice('warning:'.length));
+        }
+        else {
+            errors.push(message);
+        }
+    }
+    return { errors, warnings };
+}

package/dist/deploy/types.d.ts

@@ -0,0 +1,48 @@
+import type { DeployTarget, ResolvedDeployConfig, VistaConfig } from '../config';
+export type ResolvedDeployTarget = Exclude<DeployTarget, 'auto'>;
+export type DeployResultStatus = 'deployed' | 'emitted' | 'failed';
+export interface DeployContext {
+    cwd: string;
+    vistaDir: string;
+    config: VistaConfig;
+    deployConfig: ResolvedDeployConfig;
+    target: ResolvedDeployTarget;
+    dryRun: boolean;
+    skipBuild: boolean;
+    prod: boolean;
+    preview: boolean;
+    force: boolean;
+    debug?: boolean;
+    log?: (message: string) => void;
+    warn?: (message: string) => void;
+    error?: (message: string) => void;
+}
+export interface DeployResult {
+    status: DeployResultStatus;
+    target: ResolvedDeployTarget;
+    url?: string;
+    artifactPaths?: string[];
+    instructions?: string[];
+    warnings?: string[];
+}
+export interface DeployAdapter {
+    id: ResolvedDeployTarget;
+    requiredOutput: 'standalone' | 'static';
+    supportsFullRuntime: boolean;
+    preflight(ctx: DeployContext): Promise<string[]>;
+    emit(ctx: DeployContext): Promise<DeployResult>;
+    deploy(ctx: DeployContext): Promise<DeployResult>;
+}
+export interface CliRunResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+    command: string;
+    missingCli?: boolean;
+}
+export interface BuildHookOptions {
+    cwd: string;
+    vistaDir: string;
+    debug?: boolean;
+    force?: boolean;
+}

package/dist/deploy/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/deploy/utils.d.ts

@@ -0,0 +1,18 @@
+export declare function ensureDir(absolutePath: string): void;
+export declare function copyDirectoryRecursive(sourceDir: string, targetDir: string): void;
+export declare function copyFileIfPresent(sourceFile: string, targetFile: string): void;
+export declare function writeFileIfAllowed(targetFile: string, content: string, force: boolean): {
+    written: boolean;
+    skipped: boolean;
+};
+export declare function readJsonSafe<T>(absolutePath: string): T | null;
+export declare const STATIC_HOST_ROUTE_RULES: ({
+    handle: "filesystem";
+    src?: undefined;
+    dest?: undefined;
+} | {
+    src: string;
+    dest: string;
+    handle?: undefined;
+})[];
+export declare function copyStaticHostAssets(cwd: string, vistaDir: string, targetDir: string): void;

package/dist/deploy/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATIC_HOST_ROUTE_RULES = void 0;
+exports.ensureDir = ensureDir;
+exports.copyDirectoryRecursive = copyDirectoryRecursive;
+exports.copyFileIfPresent = copyFileIfPresent;
+exports.writeFileIfAllowed = writeFileIfAllowed;
+exports.readJsonSafe = readJsonSafe;
+exports.copyStaticHostAssets = copyStaticHostAssets;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function ensureDir(absolutePath) {
+    fs_1.default.mkdirSync(absolutePath, { recursive: true });
+}
+function copyDirectoryRecursive(sourceDir, targetDir) {
+    if (!fs_1.default.existsSync(sourceDir))
+        return;
+    ensureDir(targetDir);
+    const entries = fs_1.default.readdirSync(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const from = path_1.default.join(sourceDir, entry.name);
+        const to = path_1.default.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            copyDirectoryRecursive(from, to);
+        }
+        else if (entry.isFile()) {
+            fs_1.default.copyFileSync(from, to);
+        }
+    }
+}
+function copyFileIfPresent(sourceFile, targetFile) {
+    if (!fs_1.default.existsSync(sourceFile))
+        return;
+    ensureDir(path_1.default.dirname(targetFile));
+    fs_1.default.copyFileSync(sourceFile, targetFile);
+}
+function writeFileIfAllowed(targetFile, content, force) {
+    if (fs_1.default.existsSync(targetFile) && !force) {
+        return { written: false, skipped: true };
+    }
+    ensureDir(path_1.default.dirname(targetFile));
+    fs_1.default.writeFileSync(targetFile, content, 'utf8');
+    return { written: true, skipped: false };
+}
+function readJsonSafe(absolutePath) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(absolutePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+exports.STATIC_HOST_ROUTE_RULES = [
+    { handle: 'filesystem' },
+    { src: '^/_vista/(.*)$', dest: '/$1' },
+    { src: '^/(?:rsc|_rsc)/?$', dest: '/static/pages/index.rsc' },
+    { src: '^/(?:rsc|_rsc)/(.+)$', dest: '/static/pages/$1.rsc' },
+    { src: '^/$', dest: '/static/pages/index.html' },
+    { src: '^/(.+)$', dest: '/static/pages/$1.html' },
+];
+function copyStaticHostAssets(cwd, vistaDir, targetDir) {
+    copyDirectoryRecursive(path_1.default.join(cwd, 'public'), targetDir);
+    copyDirectoryRecursive(path_1.default.join(vistaDir, 'static'), path_1.default.join(targetDir, 'static'));
+    const clientCssPath = path_1.default.join(vistaDir, 'client.css');
+    copyFileIfPresent(clientCssPath, path_1.default.join(targetDir, 'client.css'));
+    copyFileIfPresent(clientCssPath, path_1.default.join(targetDir, 'styles.css'));
+}

package/dist/dev-error.d.ts

@@ -4,18 +4,32 @@
  * Standalone dev error UI with Next.js-style pagination and controls.
  */
 import React from 'react';
+export interface VistaErrorLocation {
+    file: string;
+    line?: number;
+    column?: number;
+    codeFrame?: string;
+    kind?: 'source' | 'server' | 'client' | 'log';
+}
 export interface VistaError {
     type: 'build' | 'runtime' | 'hydration';
+    source?: 'server' | 'client';
     message: string;
     stack?: string;
     file?: string;
     line?: number;
     column?: number;
     codeFrame?: string;
+    related?: VistaErrorLocation[];
+    hint?: string;
 }
 interface ErrorOverlayProps {
     errors: VistaError[];
 }
+export declare function fromCaughtError(error: unknown, options?: {
+    type?: VistaError['type'];
+    source?: 'server' | 'client';
+}): VistaError;
 /**
  * Render a full HTML error page.
  * Engines should send this directly: `res.status(500).send(renderErrorHTML(...))`.