fimo 0.9.0-experimental.1 → 0.9.0

package/dist/scripts/frameworks/vite/wiring.js

@@ -1,99 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { parseSync } from 'oxc-parser';
-/**
- * Vite React SPA root wiring: wrap the root render argument with
- * `FimoSpaProviders` (client-side label fetch; inline fallbacks until it
- * resolves) and import the project's fimo-config.json. Only the mainstream
- * entry shape is touched — a `createRoot(…).render(<JSX/>)` (or legacy
- * `ReactDOM.render(<JSX/>, …)`) call whose first argument is a JSX element.
- * Anything else bails with the reason and stays agent work via the recipe.
- */
-export function ensureSpaEntryWiring(cwd) {
-    const entryFile = ['src/main.tsx', 'src/main.jsx', 'src/index.tsx', 'src/index.jsx']
-        .map((candidate) => path.join(cwd, candidate))
-        .find((candidate) => fs.existsSync(candidate));
-    const bail = (reason, rel = 'src/main.tsx') => ({
-        changes: [],
-        warnings: [`Root wiring not applied: ${reason} — follow the SPA recipe in the agent prompt (${rel}).`],
-        wired: false,
-    });
-    if (!entryFile) {
-        return bail('no src/main or src/index entry file found');
-    }
-    const rel = path.relative(cwd, entryFile);
-    const code = fs.readFileSync(entryFile, 'utf8');
-    if (code.includes('FimoSpaProviders')) {
-        return { changes: [], warnings: [], wired: true };
-    }
-    let program;
-    try {
-        program = parseSync(entryFile, code).program;
-    }
-    catch {
-        return bail('entry file could not be parsed', rel);
-    }
-    // The JSX argument of the root render call, found structurally: a call
-    // whose callee property is `render` with a JSX element first argument
-    // (covers `createRoot(…).render(<X/>)` and `ReactDOM.render(<X/>, node)`).
-    const renderArg = (function find(node) {
-        if (!node || typeof node !== 'object') {
-            return null;
-        }
-        const candidate = node;
-        if (candidate.type === 'CallExpression' &&
-            candidate.callee?.type === 'MemberExpression' &&
-            candidate.callee?.property?.name === 'render' &&
-            (candidate.arguments?.[0]?.type === 'JSXElement' || candidate.arguments?.[0]?.type === 'JSXFragment')) {
-            return candidate.arguments[0];
-        }
-        for (const value of Object.values(candidate)) {
-            if (Array.isArray(value)) {
-                for (const entry of value) {
-                    const found = find(entry);
-                    if (found) {
-                        return found;
-                    }
-                }
-            }
-            else if (value && typeof value === 'object') {
-                const found = find(value);
-                if (found) {
-                    return found;
-                }
-            }
-        }
-        return null;
-    })(program);
-    if (!renderArg) {
-        return bail('no root render call with a JSX argument found', rel);
-    }
-    const configImportPath = path
-        .relative(path.dirname(entryFile), path.join(cwd, 'fimo-config.json'))
-        .split(path.sep)
-        .join('/');
-    const jsx = code.slice(renderArg.start, renderArg.end);
-    const open = '<FimoSpaProviders\n' +
-        '    config={fimoConfig}\n' +
-        '    apiUrl={import.meta.env.VITE_API_URL}\n' +
-        '    previewScriptUrl={import.meta.env.DEV ? import.meta.env.VITE_FIMO_PREVIEW_SCRIPT_URL : undefined}\n' +
-        '  >';
-    let next = code.slice(0, renderArg.start) + `${open}\n    ${jsx}\n  </FimoSpaProviders>` + code.slice(renderArg.end);
-    // AST-positioned like ensureFimoImport: a multiline import's first line is
-    // not the end of the imports.
-    const importBlock = `import { FimoSpaProviders } from 'fimo/react';\nimport fimoConfig from '${configImportPath.startsWith('.') ? configImportPath : `./${configImportPath}`}';`;
-    let lastImportEnd = -1;
-    for (const node of program.body ?? []) {
-        if (node.type === 'ImportDeclaration') {
-            lastImportEnd = node.end;
-        }
-    }
-    // The wrap edit above only touched positions at/after renderArg.start,
-    // which is always beyond the import block, so import spans still hold.
-    next =
-        lastImportEnd >= 0
-            ? `${next.slice(0, lastImportEnd)}\n${importBlock}${next.slice(lastImportEnd)}`
-            : `${importBlock}\n${next}`;
-    fs.writeFileSync(entryFile, next);
-    return { changes: [`wired FimoSpaProviders into ${rel}`], warnings: [], wired: true };
-}

package/dist/scripts/i18n-namespace.d.ts

@@ -1,27 +0,0 @@
-/**
- * Shared next-intl namespace resolution for the two independent label-key
- * scanners (`extract-translations` for `fimo validate`, `scan-wrappable` for
- * `migrate wrap --check`). Both must record the SAME key form the i18n
- * ingestion stores, or the seeding gate can never go green.
- *
- * `const t = useTranslations("plans.checkout")` scopes every `t("buyNow")` in
- * that component to `plans.checkout.buyNow`. Root-scoped `useTranslations()`
- * (namespace `""`) and server `getTranslations` are handled; a bare `t(...)`
- * with no binding (Fimo's own label call) keeps its key unchanged.
- */
-export declare const isFunctionLike: (node: any) => boolean;
-export declare function collectScopedBindings(fnNode: any): Map<string, string | null>;
-/**
- * Resolve a `<name>("leaf")` call to its full key given the scope stack
- * (innermost first).
- * - `scoped`: the callee is a resolved `useTranslations` binding — namespace
- *   prepended (unless root `""`).
- * - `unresolvable`: the callee is a passed-in parameter — its namespace lives in
- *   the caller and cannot be known here, so the caller should count the call as
- *   covered but NOT demand the (bare) key.
- */
-export declare function resolveScopedKey(calleeName: string, leafKey: string, scopes: Array<Map<string, string | null>>): {
-    key: string;
-    scoped: boolean;
-    unresolvable: boolean;
-};

package/dist/scripts/i18n-namespace.js

@@ -1,155 +0,0 @@
-/**
- * Shared next-intl namespace resolution for the two independent label-key
- * scanners (`extract-translations` for `fimo validate`, `scan-wrappable` for
- * `migrate wrap --check`). Both must record the SAME key form the i18n
- * ingestion stores, or the seeding gate can never go green.
- *
- * `const t = useTranslations("plans.checkout")` scopes every `t("buyNow")` in
- * that component to `plans.checkout.buyNow`. Root-scoped `useTranslations()`
- * (namespace `""`) and server `getTranslations` are handled; a bare `t(...)`
- * with no binding (Fimo's own label call) keeps its key unchanged.
- */
-export const isFunctionLike = (node) => node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
-/** Collect `useTranslations`/`getTranslations` bindings declared in a function's
- *  direct body: variable name → namespace (`""` for root scope). */
-const unwrapAwait = (node) => (node?.type === 'AwaitExpression' ? node.argument : node);
-/**
- * The namespace of a `useTranslations`/`getTranslations` call, or null if the
- * node is not such a call. Handles the string arg (`getTranslations("seo")`),
- * the object arg (`getTranslations({ locale, namespace: "seo" })`), and no arg
- * (root scope → `""`). A dynamic namespace resolves to `""` (best effort).
- */
-function translationCallNamespace(node) {
-    if (node?.type !== 'CallExpression' || node.callee?.type !== 'Identifier') {
-        return null;
-    }
-    if (node.callee.name !== 'useTranslations' && node.callee.name !== 'getTranslations') {
-        return null;
-    }
-    const arg = node.arguments?.[0];
-    if (!arg) {
-        return '';
-    }
-    if (arg.type === 'Literal' && typeof arg.value === 'string') {
-        return arg.value;
-    }
-    if (arg.type === 'ObjectExpression') {
-        for (const prop of arg.properties ?? []) {
-            const keyName = prop?.key?.name ?? prop?.key?.value;
-            if (keyName === 'namespace' && prop.value?.type === 'Literal' && typeof prop.value.value === 'string') {
-                return prop.value.value;
-            }
-        }
-    }
-    return '';
-}
-/** Mark every identifier bound by a parameter pattern (plain, defaulted, or
- *  destructured — `t`, `t = x`, `{ t }`, `[t]`) as unresolvable (null). */
-function markParamBindings(node, bindings) {
-    if (!node) {
-        return;
-    }
-    switch (node.type) {
-        case 'Identifier':
-            if (!bindings.has(node.name)) {
-                bindings.set(node.name, null);
-            }
-            break;
-        case 'AssignmentPattern':
-            markParamBindings(node.left, bindings);
-            break;
-        case 'RestElement':
-            markParamBindings(node.argument, bindings);
-            break;
-        case 'ArrayPattern':
-            for (const element of node.elements ?? []) {
-                markParamBindings(element, bindings);
-            }
-            break;
-        case 'ObjectPattern':
-            for (const prop of node.properties ?? []) {
-                markParamBindings(prop.type === 'RestElement' ? prop.argument : prop.value, bindings);
-            }
-            break;
-        default:
-            break;
-    }
-}
-export function collectScopedBindings(fnNode) {
-    const bindings = new Map();
-    const body = fnNode.body;
-    const statements = body && Array.isArray(body.body) ? body.body : [];
-    for (const stmt of statements) {
-        if (stmt?.type !== 'VariableDeclaration') {
-            continue;
-        }
-        for (const decl of stmt.declarations ?? []) {
-            const init = unwrapAwait(decl?.init);
-            // `const t = [await] useTranslations/getTranslations(...)`
-            if (decl?.id?.type === 'Identifier') {
-                const namespace = translationCallNamespace(init);
-                if (namespace !== null) {
-                    bindings.set(decl.id.name, namespace);
-                }
-                continue;
-            }
-            // `const [a, t] = await Promise.all([...])` or `= use(Promise.all([...]))`
-            if (decl?.id?.type === 'ArrayPattern') {
-                // Unwrap React's `use()` wrapper around the promise.
-                const source = init?.type === 'CallExpression' && init.callee?.type === 'Identifier' && init.callee.name === 'use'
-                    ? unwrapAwait(init.arguments?.[0])
-                    : init;
-                const promiseAll = source?.type === 'CallExpression' &&
-                    source.callee?.type === 'MemberExpression' &&
-                    source.callee.object?.name === 'Promise' &&
-                    source.callee.property?.name === 'all';
-                const elements = promiseAll
-                    ? source.arguments?.[0]?.type === 'ArrayExpression'
-                        ? source.arguments[0].elements
-                        : null
-                    : source?.type === 'ArrayExpression'
-                        ? source.elements
-                        : null;
-                if (elements) {
-                    decl.id.elements?.forEach((el, index) => {
-                        if (el?.type !== 'Identifier') {
-                            return;
-                        }
-                        const namespace = translationCallNamespace(unwrapAwait(elements[index]));
-                        if (namespace !== null) {
-                            bindings.set(el.name, namespace);
-                        }
-                    });
-                }
-            }
-        }
-    }
-    // Function parameters are bound by the CALLER: a `t` passed in carries the
-    // caller's namespace, unknowable here. Mark them null so their t() calls are
-    // counted as covered but never demanded by the seeding gate as a bare leaf.
-    for (const param of fnNode.params ?? []) {
-        markParamBindings(param, bindings);
-    }
-    return bindings;
-}
-/**
- * Resolve a `<name>("leaf")` call to its full key given the scope stack
- * (innermost first).
- * - `scoped`: the callee is a resolved `useTranslations` binding — namespace
- *   prepended (unless root `""`).
- * - `unresolvable`: the callee is a passed-in parameter — its namespace lives in
- *   the caller and cannot be known here, so the caller should count the call as
- *   covered but NOT demand the (bare) key.
- */
-export function resolveScopedKey(calleeName, leafKey, scopes) {
-    for (let i = scopes.length - 1; i >= 0; i -= 1) {
-        if (scopes[i].has(calleeName)) {
-            const namespace = scopes[i].get(calleeName);
-            if (namespace === null || namespace === undefined) {
-                return { key: leafKey, scoped: false, unresolvable: true };
-            }
-            return { key: namespace ? `${namespace}.${leafKey}` : leafKey, scoped: true, unresolvable: false };
-        }
-    }
-    return { key: leafKey, scoped: false, unresolvable: false };
-}

package/dist/scripts/render-parity/capture.d.ts

@@ -1,56 +0,0 @@
-import { type ParityBaseline } from './types.js';
-export interface CaptureOptions {
-    cwd: string;
-    packageManager: string;
-    routes: Array<{
-        path: string;
-    }>;
-    framework: string | null;
-    bootTimeoutMs?: number;
-    routeTimeoutMs?: number;
-    /** Reuse an already-running dev server instead of booting one: the warm
-     *  server recompiles incrementally, so repeated checks cost seconds. The
-     *  server is probed once and never stopped. */
-    serverOrigin?: string;
-    /** Concrete values for dynamic route params so `[locale]`-style routes are
-     *  actually captured instead of skipped. A route resolves (and is captured)
-     *  only when EVERY `:param` in it has a value here; both baseline and check
-     *  read the same values, so the comparison stays symmetric. */
-    paramValues?: Record<string, string>;
-    onProgress?: (message: string) => void;
-}
-/** Substitute known params into a `:param` route path; returns the concrete
- *  path, or null when a param has no value (still unresolvable → skip). */
-export declare function resolveRoutePath(routePath: string, paramValues: Record<string, string>): string | null;
-export declare class CaptureError extends Error {
-    readonly stderrTail: string;
-    constructor(message: string, stderrTail?: string);
-}
-export declare function findFreePort(): Promise<number>;
-/**
- * Build workspace packages the app needs BEFORE booting its dev server. Fimo
- * runs the app's bare `next dev`, but in a Turborepo/pnpm monorepo the
- * internal deps (`@repo/*`) aren't built by that — `turbo dev` would build
- * them first. This detects unbuilt internal deps and runs the monorepo's
- * build once (the root `build` script, else `turbo run build`); turbo's cache
- * makes an already-built repo near-instant. A build failure is surfaced with
- * an actionable message instead of a cryptic `Cannot find module` at boot.
- */
-export declare function ensureWorkspaceDepsBuilt(cwd: string, packageManager: string, onProgress?: (message: string) => void): void;
-interface DevServer {
-    origin: string;
-    stderrTail: () => string;
-    stop: () => Promise<void>;
-}
-export declare function startDevServer(opts: {
-    cwd: string;
-    packageManager: string;
-    bootTimeoutMs: number;
-}): Promise<DevServer>;
-/**
- * Boot the project's own dev server, capture every static route's normalized
- * signature, and tear the server down. Baseline and check both run through
- * this identical pipeline — that symmetry is the gate's correctness property.
- */
-export declare function captureParityBaseline(opts: CaptureOptions): Promise<ParityBaseline>;
-export {};