fimo 0.7.0-experimental.1 → 0.7.0-experimental.10

package/dist/scripts/frameworks/next/wiring.test.js

@@ -0,0 +1,174 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureNextLayoutWiring, ensureNextWiring } from './wiring.js';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'next-wiring-'));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(dir, rel);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, content);
+    }
+    return dir;
+};
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+const CREATE_NEXT_APP_LAYOUT = `import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = { title: 'Harbor Docs' };
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body className="antialiased">{children}</body>
+    </html>
+  );
+}
+`;
+describe('ensureNextLayoutWiring', () => {
+    it('wires the create-next-app default layout end to end', () => {
+        const root = project({ 'app/layout.tsx': CREATE_NEXT_APP_LAYOUT });
+        const result = ensureNextLayoutWiring(root, { appDir: 'app' });
+        const code = readFileSync(join(root, 'app/layout.tsx'), 'utf8');
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual(['wired Fimo providers into app/layout.tsx']);
+        expect(code).toContain('import { FimoNextProviders, FimoNextScripts } from "fimo/next";');
+        expect(code).toContain('import { loadFimoConfig, loadFimoLabels } from "fimo/next/server";');
+        expect(code).toContain('export default async function RootLayout');
+        expect(code).toContain('const config = loadFimoConfig();');
+        expect(code).toContain('const labels = await loadFimoLabels();');
+        expect(code).toContain('<body className="antialiased"><FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders></body>');
+        expect(code).toContain('<head>');
+        expect(code).toContain('<FimoNextScripts />');
+        // Head lands inside <html>, before <body>.
+        expect(code.indexOf('<FimoNextScripts />')).toBeGreaterThan(code.indexOf('<html'));
+        expect(code.indexOf('<FimoNextScripts />')).toBeLessThan(code.indexOf('<body'));
+    });
+    it('wires the root layout under a [locale] segment (next-intl)', () => {
+        const root = project({ 'src/app/[locale]/layout.tsx': CREATE_NEXT_APP_LAYOUT });
+        const result = ensureNextLayoutWiring(root, { appDir: 'src/app' });
+        const code = readFileSync(join(root, 'src/app/[locale]/layout.tsx'), 'utf8');
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual(['wired Fimo providers into src/app/[locale]/layout.tsx']);
+        expect(code).toContain('<FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders>');
+        expect(code).toContain('<FimoNextScripts />');
+    });
+    it('picks the <html> layout when a passthrough app/layout also exists', () => {
+        const root = project({
+            'src/app/layout.tsx': 'export default function Root({ children }) {\n  return children;\n}\n',
+            'src/app/[locale]/layout.tsx': CREATE_NEXT_APP_LAYOUT,
+        });
+        const result = ensureNextLayoutWiring(root, { appDir: 'src/app' });
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual(['wired Fimo providers into src/app/[locale]/layout.tsx']);
+        // the passthrough root layout stays untouched
+        expect(readFileSync(join(root, 'src/app/layout.tsx'), 'utf8')).not.toContain('FimoNextProviders');
+    });
+    it('treats a [locale] layout already wired by hand as a no-op', () => {
+        const root = project({
+            'src/app/[locale]/layout.tsx': CREATE_NEXT_APP_LAYOUT.replace('{children}', '<FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders>'),
+        });
+        const result = ensureNextLayoutWiring(root, { appDir: 'src/app' });
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual([]);
+    });
+    it('reuses an existing <head> element and keeps an async layout async', () => {
+        const root = project({
+            'src/app/layout.jsx': `export default async function Layout({ children }) {
+  return (
+    <html>
+      <head>
+        <link rel="icon" href="/favicon.ico" />
+      </head>
+      <body>
+        <div id="shell">{children}</div>
+      </body>
+    </html>
+  );
+}
+`,
+        });
+        const result = ensureNextLayoutWiring(root, { appDir: 'src/app' });
+        const code = readFileSync(join(root, 'src/app/layout.jsx'), 'utf8');
+        expect(result.wired).toBe(true);
+        expect(code).not.toContain('async async');
+        expect(code).toContain('<head><FimoNextScripts />');
+        // children was NOT a direct body child — the nested container still wraps.
+        expect(code).toContain('<FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders>');
+        expect(code.match(/<head>/g)).toHaveLength(1);
+    });
+    it('is a no-op when the layout is already wired', () => {
+        const wired = CREATE_NEXT_APP_LAYOUT.replace('{children}', '<FimoNextProviders>{children}</FimoNextProviders>');
+        const root = project({ 'app/layout.tsx': wired });
+        const result = ensureNextLayoutWiring(root, { appDir: 'app' });
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual([]);
+        expect(readFileSync(join(root, 'app/layout.tsx'), 'utf8')).toBe(wired);
+    });
+    it('bails on pages-router-only projects', () => {
+        const root = project({ 'pages/index.tsx': 'export default function Home() { return <p>hi</p>; }\n' });
+        const result = ensureNextLayoutWiring(root, { appDir: undefined });
+        expect(result.wired).toBe(false);
+        expect(result.warnings[0]).toContain('pages-router');
+    });
+    it('bails when the default export is not a plain function', () => {
+        const source = `const Layout = ({ children }) => <html><body>{children}</body></html>;
+export default Layout;
+`;
+        const root = project({ 'app/layout.tsx': source });
+        const result = ensureNextLayoutWiring(root, { appDir: 'app' });
+        expect(result.wired).toBe(false);
+        expect(result.warnings[0]).toContain('not a plain function declaration');
+        expect(readFileSync(join(root, 'app/layout.tsx'), 'utf8')).toBe(source);
+    });
+    it('bails when no {children} expression exists inside <body>', () => {
+        const root = project({
+            'app/layout.tsx': `export default function Layout(props) {
+  return (
+    <html>
+      <body>{props.children}</body>
+    </html>
+  );
+}
+`,
+        });
+        const result = ensureNextLayoutWiring(root, { appDir: 'app' });
+        expect(result.wired).toBe(false);
+        expect(result.warnings[0]).toContain('no {children} expression');
+    });
+});
+describe('ensureNextWiring config patch', () => {
+    it('patches the named nextConfig binding', () => {
+        const root = project({
+            'next.config.ts': `const nextConfig = {\n  reactStrictMode: true,\n};\nexport default nextConfig;\n`,
+        });
+        const result = ensureNextWiring(root);
+        expect(result.changes).toEqual(['added allowedDevOrigins to next.config.ts']);
+        expect(readFileSync(join(root, 'next.config.ts'), 'utf8')).toContain("allowedDevOrigins: ['*.preview.fimo.ai'],");
+    });
+    it('patches a direct export default object literal (.mjs)', () => {
+        const root = project({
+            'next.config.mjs': `/** @type {import('next').NextConfig} */\nexport default {};\n`,
+        });
+        const result = ensureNextWiring(root);
+        expect(result.changes).toEqual(['added allowedDevOrigins to next.config.mjs']);
+        const code = readFileSync(join(root, 'next.config.mjs'), 'utf8');
+        expect(code).toContain("allowedDevOrigins: ['*.preview.fimo.ai'],");
+        expect(code).toContain('export default {');
+    });
+    it('patches module.exports form and warns on unrecognized shapes', () => {
+        const cjs = project({ 'next.config.cjs': `module.exports = {\n  poweredByHeader: false,\n};\n` });
+        expect(ensureNextWiring(cjs).changes).toHaveLength(1);
+        rmSync(cjs, { recursive: true, force: true });
+        const weird = project({ 'next.config.js': `module.exports = buildConfig();\n` });
+        const result = ensureNextWiring(weird);
+        expect(result.changes).toEqual([]);
+        expect(result.warnings[0]).toContain('Could not patch next.config.js');
+    });
+});

package/dist/scripts/frameworks/nuxt/routes.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** Nuxt file-based routes under pages/ (index.vue maps to the dir path). */
+export declare function discoverNuxtRoutes(pagesDir: string): DiscoveredRoute[];

package/dist/scripts/frameworks/nuxt/routes.js

@@ -0,0 +1,54 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const titleCase = (seg) => seg
+    .replace(/[_\-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join(' ');
+function pushRoute(routes, parts) {
+    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
+    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
+    routes.push({
+        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
+        path: routePath,
+        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
+    });
+}
+const toSegment = (name) => name.replace(/^\[\.\.\.(.+)\]$/, ':$1').replace(/^\[(.+)\]$/, ':$1');
+/** Nuxt file-based routes under pages/ (index.vue maps to the dir path). */
+export function discoverNuxtRoutes(pagesDir) {
+    const routes = [];
+    const walk = (dir, segments) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                walk(full, [...segments, toSegment(entry)]);
+                continue;
+            }
+            if (!entry.endsWith('.vue')) {
+                continue;
+            }
+            const base = entry.replace(/\.vue$/, '');
+            pushRoute(routes, base === 'index' ? segments : [...segments, toSegment(base)]);
+        }
+    };
+    walk(pagesDir, []);
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

package/dist/scripts/frameworks/nuxt/template-style.d.ts

@@ -0,0 +1,9 @@
+import type { TemplateWrapStyle } from '../../apply-wrap-templates.js';
+/**
+ * Nuxt template wraps: the useFimoT composable is client-safe (fimo/nuxt
+ * never pulls server loaders into the bundle) and transfers the dictionary
+ * through the Nuxt payload, so a single `<script setup>` line wires a file.
+ * Options-API scripts have no safe injection point (top-level await needs
+ * setup) — those files stay agent work.
+ */
+export declare const nuxtTemplateWrapStyle: TemplateWrapStyle;

package/dist/scripts/frameworks/nuxt/template-style.js

@@ -0,0 +1,27 @@
+/**
+ * Nuxt template wraps: the useFimoT composable is client-safe (fimo/nuxt
+ * never pulls server loaders into the bundle) and transfers the dictionary
+ * through the Nuxt payload, so a single `<script setup>` line wires a file.
+ * Options-API scripts have no safe injection point (top-level await needs
+ * setup) — those files stay agent work.
+ */
+export const nuxtTemplateWrapStyle = {
+    ext: '.vue',
+    head: "import { useFimoT } from 'fimo/nuxt'\nconst t = await useFimoT()",
+    headMarker: /useFimoT/,
+    open: '{{ t(',
+    close: ') }}',
+    injectHead: (code, head) => {
+        // An SFC may carry BOTH <script> and <script setup>: target the setup
+        // block specifically (top-level await is only legal there).
+        const setup = code.match(/<script[^>]*\bsetup\b[^>]*>\r?\n?/);
+        if (setup && setup.index !== undefined) {
+            const at = setup.index + setup[0].length;
+            return `${code.slice(0, at)}${head}\n${code.slice(at)}`;
+        }
+        if (/<script\b/.test(code)) {
+            return null;
+        }
+        return `<script setup>\n${head}\n</script>\n\n${code}`;
+    },
+};

package/dist/scripts/frameworks/remix/routes.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** Remix v2 flat routes under app/routes: dots are slashes, $param is dynamic. */
+export declare function discoverRemixRoutes(routesDir: string): DiscoveredRoute[];

package/dist/scripts/frameworks/remix/routes.js

@@ -0,0 +1,50 @@
+import { readdirSync } from 'node:fs';
+const titleCase = (seg) => seg
+    .replace(/[_\-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join(' ');
+function pushRoute(routes, parts) {
+    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
+    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
+    routes.push({
+        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
+        path: routePath,
+        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
+    });
+}
+const FILE_EXT = /\.(tsx|jsx|ts|js|mdx)$/;
+/** Remix v2 flat routes under app/routes: dots are slashes, $param is dynamic. */
+export function discoverRemixRoutes(routesDir) {
+    const routes = [];
+    let entries;
+    try {
+        entries = readdirSync(routesDir);
+    }
+    catch {
+        return routes;
+    }
+    for (const entry of entries) {
+        if (!FILE_EXT.test(entry)) {
+            continue;
+        }
+        const base = entry.replace(FILE_EXT, '');
+        if (base === '_index') {
+            pushRoute(routes, []);
+            continue;
+        }
+        // Pathless layout segments start with _ ; trailing ._index maps to the parent.
+        const parts = base
+            .replace(/\._index$/, '')
+            .split('.')
+            .filter((seg) => !seg.startsWith('_'))
+            .map((seg) => (seg.startsWith('$') ? `:${seg.slice(1) || 'splat'}` : seg));
+        if (parts.length > 0) {
+            pushRoute(routes, parts);
+        }
+    }
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

package/dist/scripts/frameworks/support.d.ts

@@ -0,0 +1,75 @@
+import type { FrameworkDetection } from '../detect-framework.js';
+/**
+ * A host dependency the wrap gates on, with the floor Fimo's runtime requires.
+ * The floor is honest to the API surface the in-tree runtime actually uses —
+ * React frameworks gate on `react` 18 (the runtime touches `useSyncExternalStore`),
+ * Vue/Svelte/Astro on their own framework floor. The version gate is what turns
+ * an unsupported host into one actionable sentence instead of an npm `ERESOLVE`
+ * or an install-then-crash.
+ */
+export interface SupportCheck {
+    pkg: string;
+    /** Floor, `X.Y.Z`. */
+    min: string;
+    label: string;
+    /** Why this floor exists — shown to the user. */
+    reason: string;
+    /** One actionable next step — shown as the error hint. */
+    remedy: string;
+}
+/**
+ * The runtime-floor checks for a detected framework. React-based frameworks all
+ * gate on `react`; the template frameworks gate on their own package. Frameworks
+ * with no runtime coupling (or none detected) return [] — nothing to gate.
+ */
+export declare function supportChecksFor(detection: Pick<FrameworkDetection, 'framework' | 'react'>): SupportCheck[];
+interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    /** The original spec, for display. */
+    raw: string;
+}
+/**
+ * The lowest concrete version a spec implies. Handles the shapes seen in real
+ * package.json / installed manifests: `^18.2.0`, `~3.4`, `>=2.0.0`, `18 || 19`,
+ * `18.3.1`, ` >= 14.0.0 `, bare `18`. Returns null for anything without a
+ * numeric floor (`latest`, `*`, `workspace:*`, `catalog:`, a git/file url) — we
+ * never gate on a version we cannot read.
+ */
+export declare function parseVersionFloor(spec: string): ParsedVersion | null;
+/**
+ * The host's version of `pkg`. Prefers the INSTALLED manifest
+ * (`node_modules/<pkg>/package.json`) — the ground truth of what will run —
+ * and falls back to the declared range floor in the host package.json (a fresh
+ * clone before install). Returns null when neither is readable.
+ */
+export declare function readHostVersion(cwd: string, pkg: string): ParsedVersion | null;
+export interface HostSupportViolation {
+    subject: string;
+    /** The version we found on the host. */
+    found: string;
+    /** The floor Fimo requires. */
+    min: string;
+    /** Headline sentence for the error message. */
+    headline: string;
+    /** Actionable next step for the error hint. */
+    remedy: string;
+}
+export interface HostSupportResult {
+    ok: boolean;
+    violations: HostSupportViolation[];
+    /** Versions read successfully — for the summary line ("React 18.3.1"). */
+    detected: Array<{
+        label: string;
+        version: string;
+    }>;
+}
+/**
+ * Gate the wrap on the host's framework/runtime versions. Silent for supported
+ * hosts (the common case); returns one violation per below-floor dependency so
+ * the caller can stop with a clear message. A version we cannot read is never a
+ * violation — the peer range and the install still catch a genuinely absent dep.
+ */
+export declare function checkHostSupport(cwd: string, detection: Pick<FrameworkDetection, 'framework' | 'react'>): HostSupportResult;
+export {};

package/dist/scripts/frameworks/support.js

@@ -0,0 +1,165 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const REACT_CHECK = {
+    pkg: 'react',
+    min: '18.0.0',
+    label: 'React',
+    reason: "Fimo's inline-editing runtime uses React 18 APIs (useSyncExternalStore).",
+    remedy: 'Upgrade React to 18 or newer. The content still migrates on older React; only inline editing needs 18+.',
+};
+/**
+ * The runtime-floor checks for a detected framework. React-based frameworks all
+ * gate on `react`; the template frameworks gate on their own package. Frameworks
+ * with no runtime coupling (or none detected) return [] — nothing to gate.
+ */
+export function supportChecksFor(detection) {
+    switch (detection.framework) {
+        case 'next':
+        case 'remix':
+        case 'react-router':
+            return [REACT_CHECK];
+        case 'vite':
+            return detection.react ? [REACT_CHECK] : [];
+        case 'nuxt':
+            return [
+                {
+                    pkg: 'nuxt',
+                    min: '3.0.0',
+                    label: 'Nuxt',
+                    reason: 'Fimo supports Nuxt 3+ (Vue 3). Nuxt 2 is end-of-life.',
+                    remedy: 'Upgrade to Nuxt 3 or newer.',
+                },
+            ];
+        case 'vue':
+            return [
+                {
+                    pkg: 'vue',
+                    min: '3.0.0',
+                    label: 'Vue',
+                    reason: 'Fimo supports Vue 3+. Vue 2 is end-of-life.',
+                    remedy: 'Upgrade to Vue 3 or newer.',
+                },
+            ];
+        case 'astro':
+            return [
+                {
+                    pkg: 'astro',
+                    min: '4.0.0',
+                    label: 'Astro',
+                    reason: 'Fimo supports Astro 4+.',
+                    remedy: 'Upgrade Astro to 4 or newer.',
+                },
+            ];
+        case 'sveltekit':
+            return [
+                {
+                    pkg: '@sveltejs/kit',
+                    min: '2.0.0',
+                    label: 'SvelteKit',
+                    reason: 'Fimo supports SvelteKit 2+.',
+                    remedy: 'Upgrade @sveltejs/kit to 2 or newer.',
+                },
+            ];
+        default:
+            return [];
+    }
+}
+/**
+ * The lowest concrete version a spec implies. Handles the shapes seen in real
+ * package.json / installed manifests: `^18.2.0`, `~3.4`, `>=2.0.0`, `18 || 19`,
+ * `18.3.1`, ` >= 14.0.0 `, bare `18`. Returns null for anything without a
+ * numeric floor (`latest`, `*`, `workspace:*`, `catalog:`, a git/file url) — we
+ * never gate on a version we cannot read.
+ */
+export function parseVersionFloor(spec) {
+    if (!spec) {
+        return null;
+    }
+    // A `||` union — the floor is the lowest branch, i.e. the first token.
+    const first = spec.split('||')[0];
+    const match = first.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: match[2] ? Number(match[2]) : 0,
+        patch: match[3] ? Number(match[3]) : 0,
+        raw: spec.trim(),
+    };
+}
+function isBelowFloor(found, min) {
+    const floor = parseVersionFloor(min);
+    if (!floor) {
+        return false;
+    }
+    if (found.major !== floor.major) {
+        return found.major < floor.major;
+    }
+    if (found.minor !== floor.minor) {
+        return found.minor < floor.minor;
+    }
+    return found.patch < floor.patch;
+}
+/**
+ * The host's version of `pkg`. Prefers the INSTALLED manifest
+ * (`node_modules/<pkg>/package.json`) — the ground truth of what will run —
+ * and falls back to the declared range floor in the host package.json (a fresh
+ * clone before install). Returns null when neither is readable.
+ */
+export function readHostVersion(cwd, pkg) {
+    const installed = join(cwd, 'node_modules', pkg, 'package.json');
+    if (existsSync(installed)) {
+        try {
+            const version = JSON.parse(readFileSync(installed, 'utf8')).version;
+            const parsed = parseVersionFloor(String(version));
+            if (parsed) {
+                return parsed;
+            }
+        }
+        catch {
+            // fall through to the declared range
+        }
+    }
+    const rootPkg = join(cwd, 'package.json');
+    if (existsSync(rootPkg)) {
+        try {
+            const pkgJson = JSON.parse(readFileSync(rootPkg, 'utf8'));
+            const spec = { ...pkgJson.dependencies, ...pkgJson.devDependencies }[pkg];
+            if (spec) {
+                return parseVersionFloor(String(spec));
+            }
+        }
+        catch {
+            // unreadable — nothing to gate on
+        }
+    }
+    return null;
+}
+/**
+ * Gate the wrap on the host's framework/runtime versions. Silent for supported
+ * hosts (the common case); returns one violation per below-floor dependency so
+ * the caller can stop with a clear message. A version we cannot read is never a
+ * violation — the peer range and the install still catch a genuinely absent dep.
+ */
+export function checkHostSupport(cwd, detection) {
+    const violations = [];
+    const detected = [];
+    for (const check of supportChecksFor(detection)) {
+        const found = readHostVersion(cwd, check.pkg);
+        if (!found) {
+            continue;
+        }
+        detected.push({ label: check.label, version: found.raw });
+        if (isBelowFloor(found, check.min)) {
+            violations.push({
+                subject: check.label,
+                found: found.raw,
+                min: check.min,
+                headline: `${check.label} ${found.raw} is below Fimo's floor of ${check.label} ${check.min}. ${check.reason}`,
+                remedy: check.remedy,
+            });
+        }
+    }
+    return { ok: violations.length === 0, violations, detected };
+}

package/dist/scripts/frameworks/support.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/frameworks/support.test.js

@@ -0,0 +1,87 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { checkHostSupport, parseVersionFloor, readHostVersion } from './support.js';
+let dir;
+function project(pkg, installed = {}) {
+    dir = mkdtempSync(join(tmpdir(), 'host-support-'));
+    writeFileSync(join(dir, 'package.json'), JSON.stringify(pkg));
+    for (const [name, version] of Object.entries(installed)) {
+        const modDir = join(dir, 'node_modules', name);
+        mkdirSync(modDir, { recursive: true });
+        writeFileSync(join(modDir, 'package.json'), JSON.stringify({ name, version }));
+    }
+    return dir;
+}
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('parseVersionFloor', () => {
+    it('reads the lowest concrete version from real spec shapes', () => {
+        expect(parseVersionFloor('^18.2.0')).toMatchObject({ major: 18, minor: 2, patch: 0 });
+        expect(parseVersionFloor('>=2.0.0')).toMatchObject({ major: 2, minor: 0, patch: 0 });
+        expect(parseVersionFloor('~3.4')).toMatchObject({ major: 3, minor: 4, patch: 0 });
+        expect(parseVersionFloor('18')).toMatchObject({ major: 18, minor: 0, patch: 0 });
+        // a `||` union floors on the lowest (first) branch
+        expect(parseVersionFloor('^17.0.0 || ^18.0.0')).toMatchObject({ major: 17 });
+    });
+    it('returns null for specs with no numeric floor', () => {
+        expect(parseVersionFloor('latest')).toBeNull();
+        expect(parseVersionFloor('*')).toBeNull();
+        expect(parseVersionFloor('workspace:*')).toBeNull();
+        expect(parseVersionFloor('')).toBeNull();
+    });
+});
+describe('readHostVersion', () => {
+    it('prefers the installed manifest over the declared range', () => {
+        const cwd = project({ dependencies: { react: '^18.0.0' } }, { react: '18.3.1' });
+        expect(readHostVersion(cwd, 'react')).toMatchObject({ major: 18, minor: 3, patch: 1 });
+    });
+    it('falls back to the declared range when nothing is installed', () => {
+        const cwd = project({ dependencies: { react: '^19.0.0' } });
+        expect(readHostVersion(cwd, 'react')).toMatchObject({ major: 19, minor: 0, patch: 0 });
+    });
+    it('returns null when the dependency is absent', () => {
+        const cwd = project({ dependencies: {} });
+        expect(readHostVersion(cwd, 'react')).toBeNull();
+    });
+});
+describe('checkHostSupport', () => {
+    it('passes a Next.js site on React 18', () => {
+        const cwd = project({ dependencies: { next: '16.2.11', react: '^18.2.0' } }, { react: '18.3.1' });
+        const result = checkHostSupport(cwd, { framework: 'next' });
+        expect(result.ok).toBe(true);
+        expect(result.violations).toEqual([]);
+        expect(result.detected).toContainEqual({ label: 'React', version: '18.3.1' });
+    });
+    it('passes a Next.js site on React 19', () => {
+        const cwd = project({ dependencies: { next: '16.2.11', react: '^19.0.0' } }, { react: '19.0.0' });
+        expect(checkHostSupport(cwd, { framework: 'next' }).ok).toBe(true);
+    });
+    it('flags a React 17 site below the floor with an actionable message', () => {
+        const cwd = project({ dependencies: { next: '13.0.0', react: '^17.0.2' } }, { react: '17.0.2' });
+        const result = checkHostSupport(cwd, { framework: 'next' });
+        expect(result.ok).toBe(false);
+        expect(result.violations).toHaveLength(1);
+        expect(result.violations[0]).toMatchObject({ subject: 'React', min: '18.0.0' });
+        expect(result.violations[0].headline).toContain('React 17.0.2');
+        expect(result.violations[0].remedy).toMatch(/upgrade react/i);
+    });
+    it('flags a Nuxt 2 site below the floor', () => {
+        const cwd = project({ dependencies: { nuxt: '^2.17.0' } }, { nuxt: '2.17.0' });
+        const result = checkHostSupport(cwd, { framework: 'nuxt' });
+        expect(result.ok).toBe(false);
+        expect(result.violations[0]).toMatchObject({ subject: 'Nuxt', min: '3.0.0' });
+    });
+    it('does not gate a non-React bare Vite site', () => {
+        const cwd = project({ dependencies: { vite: '^5.0.0' } });
+        expect(checkHostSupport(cwd, { framework: 'vite', react: false }).ok).toBe(true);
+    });
+    it('does not gate on a version it cannot read', () => {
+        const cwd = project({ dependencies: { next: '16.0.0', react: 'workspace:*' } });
+        expect(checkHostSupport(cwd, { framework: 'next' }).ok).toBe(true);
+    });
+});

package/dist/scripts/frameworks/sveltekit/routes.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** SvelteKit routes: every directory under src/routes holding a +page file. */
+export declare function discoverSvelteKitRoutes(routesDir: string): DiscoveredRoute[];