@kuratchi/js 0.0.14 → 0.0.16

package/dist/compiler/route-pipeline.js

@@ -0,0 +1,296 @@
+import { stripTopLevelImports } from './parser.js';
+import { transpileTypeScript } from './transpile.js';
+import { buildDevAliasDeclarations, buildSegmentedScriptBody, rewriteImportedFunctionCalls, rewriteWorkerEnvAliases, } from './script-transform.js';
+function dedupe(items) {
+    return Array.from(new Set(items));
+}
+function extractDeclaredConstName(statement) {
+    const match = statement.trim().match(/^const\s+([A-Za-z_$][\w$]*)\s*=/);
+    return match ? match[1] : null;
+}
+function buildLoadQueryStateCode(opts) {
+    const lines = [];
+    for (const query of opts.queries) {
+        const fnName = query.fnName;
+        const rpcId = query.rpcId || opts.rpcNameMap?.get(fnName) || fnName;
+        const argsExpr = (query.argsExpr || '').trim();
+        const asName = query.asName;
+        const defaultArgs = argsExpr ? `[${argsExpr}]` : '[]';
+        const moduleId = opts.fnToModule[fnName];
+        const qualifiedFn = moduleId ? `${moduleId}.${fnName}` : fnName;
+        lines.push(`let ${asName} = { state: 'loading', loading: true, error: null, data: null, empty: false, success: false };`);
+        lines.push(`const __qOverride_${asName} = __getLocals().__queryOverride;`);
+        lines.push(`const __qArgs_${asName} = ${defaultArgs};`);
+        lines.push(`const __qShouldRun_${asName} = !!(__qOverride_${asName} && __qOverride_${asName}.fn === '${rpcId}' && Array.isArray(__qOverride_${asName}.args) && JSON.stringify(__qOverride_${asName}.args) === JSON.stringify(__qArgs_${asName}));`);
+        lines.push(`if (__qShouldRun_${asName}) {`);
+        lines.push(`  try {`);
+        lines.push(`    const __qData_${asName} = await ${qualifiedFn}(...__qArgs_${asName});`);
+        lines.push(`    const __qEmpty_${asName} = Array.isArray(__qData_${asName}) ? __qData_${asName}.length === 0 : (__qData_${asName} == null);`);
+        lines.push(`    ${asName} = { state: __qEmpty_${asName} ? 'empty' : 'success', loading: false, error: null, data: __qData_${asName}, empty: __qEmpty_${asName}, success: !__qEmpty_${asName} };`);
+        lines.push(`  } catch (err) {`);
+        lines.push(`    const __qErr_${asName} = (err && err.message) ? String(err.message) : String(err);`);
+        lines.push(`    ${asName} = { state: 'error', loading: false, error: __qErr_${asName}, data: null, empty: false, success: false };`);
+        lines.push(`  }`);
+        lines.push(`}`);
+    }
+    return lines.join('\n');
+}
+function buildGeneratedLoadPlan(opts) {
+    const loadSections = [];
+    if (opts.scriptBody && opts.scriptUsesAwait) {
+        loadSections.push(opts.scriptBody);
+    }
+    if (opts.queries.length > 0) {
+        loadSections.push(buildLoadQueryStateCode({
+            queries: opts.queries,
+            fnToModule: opts.fnToModule,
+            rpcNameMap: opts.rpcNameMap,
+        }));
+    }
+    const queryVars = opts.queries.map((query) => query.asName);
+    const returnVars = dedupe([...opts.scriptReturnVars, ...queryVars]);
+    const loadLines = [];
+    if (loadSections.length > 0) {
+        loadLines.push(loadSections.join('\n'));
+    }
+    if (returnVars.length > 0) {
+        if (opts.hasSegmentedScripts && opts.scriptUsesAwait) {
+            const segmentReturnEntries = opts.scriptReturnVars.map((name) => `${name}: __segmentData.${name}`);
+            const queryReturnEntries = queryVars
+                .filter((name) => !opts.scriptReturnVars.includes(name))
+                .map((name) => name);
+            loadLines.push(`return { ${[...segmentReturnEntries, ...queryReturnEntries].join(', ')} };`);
+        }
+        else {
+            loadLines.push(`return { ${returnVars.join(', ')} };`);
+        }
+    }
+    return {
+        mode: 'generated',
+        code: `async load(__routeParams = {}) {\n      ${loadLines.join('\n      ')}\n    }`,
+        returnVars,
+        scriptUsesAwait: opts.scriptUsesAwait,
+    };
+}
+function assertRoutePlanInvariants(opts) {
+    const loadReturnSet = new Set(opts.loadReturnVars);
+    const leakedActions = opts.actionNames.filter((name) => loadReturnSet.has(name));
+    if (leakedActions.length > 0) {
+        throw new Error(`[kuratchi compiler] ${opts.pattern}\nGenerated load data cannot include action bindings: ${leakedActions.join(', ')}`);
+    }
+    const reservedQueryNames = opts.queryVars.filter((name) => opts.actionNames.includes(name));
+    if (reservedQueryNames.length > 0) {
+        throw new Error(`[kuratchi compiler] ${opts.pattern}\nQuery aliases cannot collide with action bindings: ${reservedQueryNames.join(', ')}`);
+    }
+}
+export function analyzeRouteBuild(opts) {
+    const { pattern, renderBody, renderHeadBody, isDev, parsed, fnToModule, rpcNameMap, componentStyles, clientModuleHref } = opts;
+    const hasFns = Object.keys(fnToModule).length > 0;
+    const queryDefs = parsed.dataGetQueries ?? [];
+    const queryVars = queryDefs.map((query) => query.asName);
+    const scriptSegments = (parsed.scriptSegments ?? []).filter((segment) => !!segment.script);
+    const hasSegmentedScripts = scriptSegments.length > 1;
+    const routeDevDecls = buildDevAliasDeclarations(parsed.devAliases, isDev);
+    const routeImportDeclLines = parsed.scriptImportDecls ?? [];
+    const routeImportDecls = routeImportDeclLines.join('\n');
+    const importedBindingNames = new Set(Object.keys(fnToModule));
+    const renderScopeActionNames = new Set(parsed.actionFunctions);
+    const renderImportPrelude = routeImportDeclLines
+        .filter((statement) => {
+        const declaredName = extractDeclaredConstName(statement);
+        return declaredName ? !renderScopeActionNames.has(declaredName) : true;
+    })
+        .join('\n');
+    let scriptBody = '';
+    let renderPreludeSource = '';
+    let scriptUsesAwait = false;
+    if (hasSegmentedScripts) {
+        const combinedScript = scriptSegments.map((segment) => stripTopLevelImports(segment.script)).join('\n');
+        scriptUsesAwait = /\bawait\b/.test(combinedScript);
+        scriptBody = buildSegmentedScriptBody({
+            segments: scriptSegments,
+            fnToModule,
+            importDecls: routeImportDecls,
+            workerEnvAliases: parsed.workerEnvAliases,
+            devAliases: parsed.devAliases,
+            isDev,
+            asyncMode: scriptUsesAwait,
+        });
+        renderPreludeSource = buildSegmentedScriptBody({
+            segments: scriptSegments,
+            fnToModule,
+            importDecls: renderImportPrelude,
+            workerEnvAliases: parsed.workerEnvAliases,
+            devAliases: parsed.devAliases,
+            isDev,
+            asyncMode: false,
+        });
+    }
+    else {
+        const strippedScriptBody = parsed.script
+            ? stripTopLevelImports(parsed.script)
+            : '';
+        scriptBody = [routeDevDecls, routeImportDecls, strippedScriptBody].filter(Boolean).join('\n');
+        renderPreludeSource = [routeDevDecls, renderImportPrelude, strippedScriptBody].filter(Boolean).join('\n');
+        scriptBody = rewriteImportedFunctionCalls(scriptBody, fnToModule);
+        scriptBody = rewriteWorkerEnvAliases(scriptBody, parsed.workerEnvAliases);
+        renderPreludeSource = rewriteImportedFunctionCalls(renderPreludeSource, fnToModule);
+        renderPreludeSource = rewriteWorkerEnvAliases(renderPreludeSource, parsed.workerEnvAliases);
+        scriptUsesAwait = /\bawait\b/.test(scriptBody);
+    }
+    let explicitLoadFunction = parsed.loadFunction
+        ? parsed.loadFunction.replace(/^export\s+/, '').trim()
+        : '';
+    if (explicitLoadFunction) {
+        explicitLoadFunction = [routeDevDecls, explicitLoadFunction].filter(Boolean).join('\n');
+        explicitLoadFunction = rewriteImportedFunctionCalls(explicitLoadFunction, fnToModule);
+        explicitLoadFunction = rewriteWorkerEnvAliases(explicitLoadFunction, parsed.workerEnvAliases);
+        if (routeImportDecls)
+            explicitLoadFunction = explicitLoadFunction.replace('{', `{\n${routeImportDecls}\n`);
+    }
+    if (explicitLoadFunction && scriptUsesAwait) {
+        throw new Error(`[kuratchi compiler] ${pattern}\nTop-level await cannot be mixed with export async function load(). Move async server work into load().`);
+    }
+    if (scriptBody) {
+        scriptBody = transpileTypeScript(scriptBody, `route-script:${pattern}.ts`);
+    }
+    if (renderPreludeSource) {
+        renderPreludeSource = transpileTypeScript(renderPreludeSource, `route-render:${pattern}.ts`);
+    }
+    if (explicitLoadFunction) {
+        explicitLoadFunction = transpileTypeScript(explicitLoadFunction, `route-load:${pattern}.ts`);
+    }
+    const scriptReturnVars = parsed.script
+        ? parsed.dataVars.filter((name) => !queryVars.includes(name) &&
+            !importedBindingNames.has(name) &&
+            !parsed.actionFunctions.includes(name) &&
+            !parsed.pollFunctions.includes(name))
+        : [];
+    const loadPlan = explicitLoadFunction
+        ? {
+            mode: 'explicit',
+            code: `load: ${explicitLoadFunction}`,
+            returnVars: [...parsed.loadReturnVars],
+            scriptUsesAwait: false,
+        }
+        : ((scriptBody && scriptUsesAwait) || queryDefs.length > 0)
+            ? buildGeneratedLoadPlan({
+                pattern,
+                scriptBody,
+                scriptUsesAwait,
+                scriptReturnVars,
+                queries: queryDefs,
+                hasSegmentedScripts,
+                fnToModule,
+                rpcNameMap,
+            })
+            : {
+                mode: 'none',
+                code: '',
+                returnVars: [],
+                scriptUsesAwait,
+            };
+    const actions = hasFns
+        ? parsed.actionFunctions.map((name) => {
+            const moduleId = fnToModule[name];
+            return { name, expression: moduleId ? `${moduleId}.${name}` : name };
+        })
+        : [];
+    const rpc = hasFns
+        ? parsed.pollFunctions.map((name) => {
+            const moduleId = fnToModule[name];
+            const rpcId = rpcNameMap?.get(name) || name;
+            return { name, rpcId, expression: moduleId ? `${moduleId}.${name}` : name };
+        })
+        : [];
+    assertRoutePlanInvariants({
+        pattern,
+        loadReturnVars: loadPlan.returnVars,
+        actionNames: actions.map((action) => action.name),
+        queryVars,
+    });
+    const renderDataVars = dedupe([
+        ...queryVars,
+        ...(scriptUsesAwait ? scriptReturnVars : []),
+        ...parsed.actionFunctions,
+        'params',
+        'breadcrumbs',
+    ]);
+    const renderPrelude = !scriptUsesAwait
+        ? renderPreludeSource
+        : renderImportPrelude;
+    return {
+        pattern,
+        load: loadPlan,
+        actions,
+        rpc,
+        render: {
+            prelude: renderPrelude,
+            dataVars: renderDataVars,
+            body: renderBody,
+            headBody: renderHeadBody,
+            componentStyles,
+            clientModuleHref: clientModuleHref ?? null,
+        },
+    };
+}
+export function emitRouteObject(plan) {
+    const parts = [];
+    parts.push(`    pattern: '${plan.pattern}'`);
+    if (plan.load.mode === 'explicit' || plan.load.mode === 'generated') {
+        parts.push(`    ${plan.load.code}`);
+    }
+    if (plan.actions.length > 0) {
+        const actionEntries = plan.actions
+            .map((action) => `'${action.name}': ${action.expression}`)
+            .join(', ');
+        parts.push(`    actions: { ${actionEntries} }`);
+    }
+    if (plan.rpc.length > 0) {
+        const rpcEntries = plan.rpc
+            .map((rpc) => `'${rpc.rpcId}': ${rpc.expression}`)
+            .join(', ');
+        parts.push(`    rpc: { ${rpcEntries} }`);
+    }
+    const destructure = `const { ${plan.render.dataVars.join(', ')} } = data;\n      `;
+    let finalHeadRenderBody = plan.render.headBody;
+    if (plan.render.componentStyles.length > 0) {
+        const lines = plan.render.headBody.split('\n');
+        const styleLines = plan.render.componentStyles.map((css) => `__html += \`${css}\\n\`;`);
+        finalHeadRenderBody = [lines[0], ...styleLines, ...lines.slice(1)].join('\n');
+    }
+    if (plan.render.clientModuleHref) {
+        finalHeadRenderBody += `\n__html += \`<script type="module" src="${plan.render.clientModuleHref}"></script>\\n\`;`;
+    }
+    parts.push(`    render(data) {
+      ${destructure}${plan.render.prelude ? plan.render.prelude + '\n      ' : ''}const __head = (() => {
+        ${finalHeadRenderBody}
+        return __html;
+      })();
+      const __rendered = (() => {
+        const __fragments = Object.create(null);
+        const __fragmentStack = [];
+        const __emit = (chunk) => {
+          const __value = chunk == null ? '' : String(chunk);
+          __html += __value;
+          for (const __fragmentId of __fragmentStack) {
+            __fragments[__fragmentId] = (__fragments[__fragmentId] || '') + __value;
+          }
+        };
+        const __pushFragment = (id) => {
+          const __key = String(id);
+          if (!Object.prototype.hasOwnProperty.call(__fragments, __key)) {
+            __fragments[__key] = '';
+          }
+          __fragmentStack.push(__key);
+        };
+        const __popFragment = () => {
+          __fragmentStack.pop();
+        };
+        ${plan.render.body}
+        return { html: __html, fragments: __fragments };
+      })();
+      return { html: __rendered.html, head: __head, fragments: __rendered.fragments };
+    }`);
+    return `  {\n${parts.join(',\n')}\n  }`;
+}

package/dist/compiler/route-state-pipeline.d.ts

@@ -0,0 +1,25 @@
+import { type ParsedFile } from './parser.js';
+import type { RouteImportEntry } from './import-linking.js';
+export interface RouteScriptSegment {
+    script: string;
+    dataVars: string[];
+}
+export interface MergedRouteParsed extends ParsedFile {
+    scriptImportDecls: string[];
+    scriptSegments: RouteScriptSegment[];
+}
+export interface RouteStatePlan {
+    effectiveTemplate: string;
+    routeImportDecls: string[];
+    routeScriptReferenceSource: string;
+    routeServerImportEntries: RouteImportEntry[];
+    routeClientImportEntries: RouteImportEntry[];
+    routeBrowserImportEntries: RouteImportEntry[];
+    mergedParsed: MergedRouteParsed;
+}
+export declare function assembleRouteState(opts: {
+    parsed: ParsedFile;
+    fullPath: string;
+    routesDir: string;
+    layoutRelativePaths: string[];
+}): RouteStatePlan;

package/dist/compiler/route-state-pipeline.js

@@ -0,0 +1,139 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parseFile, stripTopLevelImports } from './parser.js';
+function pushUnique(target, value) {
+    if (!target.includes(value))
+        target.push(value);
+}
+function isSharedImport(line) {
+    return /\bfrom\s+['"]\$shared\//.test(line);
+}
+export function assembleRouteState(opts) {
+    const { parsed, fullPath, routesDir, layoutRelativePaths } = opts;
+    let effectiveTemplate = parsed.template;
+    const routeScriptParts = [];
+    const routeScriptSegments = [];
+    const routeServerImportEntries = parsed.serverImports.map((line) => ({
+        line,
+        importerDir: path.dirname(fullPath),
+    }));
+    const routeClientImportEntries = parsed.clientImports.map((line) => ({
+        line,
+        importerDir: path.dirname(fullPath),
+    }));
+    const routeBrowserImportEntries = [
+        ...parsed.routeClientImports.map((line) => ({
+            line,
+            importerDir: path.dirname(fullPath),
+        })),
+        ...parsed.serverImports.filter(isSharedImport).map((line) => ({
+            line,
+            importerDir: path.dirname(fullPath),
+        })),
+    ];
+    const mergedActionFunctions = [...parsed.actionFunctions];
+    const mergedDataVars = [...parsed.dataVars];
+    const mergedPollFunctions = [...parsed.pollFunctions];
+    const mergedDataGetQueries = parsed.dataGetQueries.map((query) => ({ ...query }));
+    const mergedComponentImports = { ...parsed.componentImports };
+    const mergedWorkerEnvAliases = [...parsed.workerEnvAliases];
+    const mergedDevAliases = [...parsed.devAliases];
+    const mergedRouteClientImports = [...parsed.routeClientImports];
+    const mergedRouteClientImportBindings = [...parsed.routeClientImportBindings];
+    for (const layoutRelPath of layoutRelativePaths) {
+        if (layoutRelPath === 'layout.html')
+            continue;
+        const layoutPath = path.join(routesDir, layoutRelPath);
+        if (!fs.existsSync(layoutPath))
+            continue;
+        const layoutSource = fs.readFileSync(layoutPath, 'utf-8');
+        const layoutParsed = parseFile(layoutSource, { kind: 'layout', filePath: layoutPath });
+        if (layoutParsed.loadFunction) {
+            throw new Error(`${layoutRelPath} cannot export load(); nested layouts currently share the child route load lifecycle.`);
+        }
+        const layoutSlot = layoutParsed.template.match(/<slot\s*><\/slot>|<slot\s*\/>/);
+        if (!layoutSlot) {
+            throw new Error(`${layoutRelPath} must contain <slot></slot> or <slot />`);
+        }
+        if (layoutParsed.script) {
+            routeScriptParts.push(layoutParsed.script);
+            routeScriptSegments.push({ script: layoutParsed.script, dataVars: [...layoutParsed.dataVars] });
+        }
+        for (const line of layoutParsed.serverImports) {
+            routeServerImportEntries.push({ line, importerDir: path.dirname(layoutPath) });
+        }
+        for (const line of layoutParsed.clientImports) {
+            routeClientImportEntries.push({ line, importerDir: path.dirname(layoutPath) });
+        }
+        for (const line of layoutParsed.routeClientImports) {
+            routeBrowserImportEntries.push({ line, importerDir: path.dirname(layoutPath) });
+            pushUnique(mergedRouteClientImports, line);
+        }
+        for (const line of layoutParsed.serverImports.filter(isSharedImport)) {
+            routeBrowserImportEntries.push({ line, importerDir: path.dirname(layoutPath) });
+        }
+        for (const binding of layoutParsed.routeClientImportBindings) {
+            pushUnique(mergedRouteClientImportBindings, binding);
+        }
+        for (const fnName of layoutParsed.actionFunctions) {
+            pushUnique(mergedActionFunctions, fnName);
+        }
+        for (const varName of layoutParsed.dataVars) {
+            pushUnique(mergedDataVars, varName);
+        }
+        for (const fnName of layoutParsed.pollFunctions) {
+            pushUnique(mergedPollFunctions, fnName);
+        }
+        for (const query of layoutParsed.dataGetQueries) {
+            if (!mergedDataGetQueries.some((existing) => existing.asName === query.asName)) {
+                mergedDataGetQueries.push({ ...query });
+            }
+        }
+        for (const [pascalName, fileName] of Object.entries(layoutParsed.componentImports)) {
+            mergedComponentImports[pascalName] = fileName;
+        }
+        for (const alias of layoutParsed.workerEnvAliases) {
+            pushUnique(mergedWorkerEnvAliases, alias);
+        }
+        for (const alias of layoutParsed.devAliases) {
+            pushUnique(mergedDevAliases, alias);
+        }
+        effectiveTemplate = layoutParsed.template.replace(layoutSlot[0], effectiveTemplate);
+    }
+    if (parsed.script) {
+        routeScriptParts.push(parsed.script);
+        routeScriptSegments.push({ script: parsed.script, dataVars: [...parsed.dataVars] });
+    }
+    const routeImportDecls = [];
+    const routeScriptReferenceSource = [
+        ...routeScriptParts.map((script) => stripTopLevelImports(script)),
+        parsed.loadFunction || '',
+    ].join('\n');
+    const mergedParsed = {
+        ...parsed,
+        template: effectiveTemplate,
+        script: routeScriptParts.length > 0 ? routeScriptParts.join('\n\n') : parsed.script,
+        serverImports: routeServerImportEntries.map((entry) => entry.line),
+        clientImports: routeClientImportEntries.map((entry) => entry.line),
+        routeClientImports: mergedRouteClientImports,
+        routeClientImportBindings: mergedRouteClientImportBindings,
+        actionFunctions: mergedActionFunctions,
+        dataVars: mergedDataVars,
+        componentImports: mergedComponentImports,
+        pollFunctions: mergedPollFunctions,
+        dataGetQueries: mergedDataGetQueries,
+        workerEnvAliases: mergedWorkerEnvAliases,
+        devAliases: mergedDevAliases,
+        scriptImportDecls: routeImportDecls,
+        scriptSegments: routeScriptSegments,
+    };
+    return {
+        effectiveTemplate,
+        routeImportDecls,
+        routeScriptReferenceSource,
+        routeServerImportEntries,
+        routeClientImportEntries,
+        routeBrowserImportEntries,
+        mergedParsed,
+    };
+}

package/dist/compiler/routes-module-feature-blocks.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateRoutesModuleOptions, RoutesModuleFeatureBlocks } from './routes-module-types.js';
+export declare function buildRoutesModuleFeatureBlocks(opts: GenerateRoutesModuleOptions): RoutesModuleFeatureBlocks;