@kuratchi/js 0.0.15 → 0.0.16

package/dist/compiler/script-transform.js

@@ -0,0 +1,218 @@
+import ts from 'typescript';
+import { stripTopLevelImports } from './parser.js';
+function collectBindingNames(name, out) {
+    if (ts.isIdentifier(name)) {
+        out.add(name.text);
+        return;
+    }
+    for (const element of name.elements) {
+        if (ts.isOmittedExpression(element))
+            continue;
+        collectBindingNames(element.name, out);
+    }
+}
+function collectScopeBindings(node) {
+    const names = new Set();
+    const collectVariableStatement = (statement) => {
+        for (const declaration of statement.declarationList.declarations) {
+            collectBindingNames(declaration.name, names);
+        }
+    };
+    if (ts.isSourceFile(node)) {
+        for (const statement of node.statements) {
+            if (ts.isImportDeclaration(statement)) {
+                const clause = statement.importClause;
+                if (!clause)
+                    continue;
+                if (clause.name)
+                    names.add(clause.name.text);
+                if (clause.namedBindings) {
+                    if (ts.isNamedImports(clause.namedBindings)) {
+                        for (const element of clause.namedBindings.elements) {
+                            names.add(element.name.text);
+                        }
+                    }
+                    else if (ts.isNamespaceImport(clause.namedBindings)) {
+                        names.add(clause.namedBindings.name.text);
+                    }
+                }
+                continue;
+            }
+            if (ts.isVariableStatement(statement)) {
+                collectVariableStatement(statement);
+                continue;
+            }
+            if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) && statement.name) {
+                names.add(statement.name.text);
+            }
+        }
+        return names;
+    }
+    if (ts.isBlock(node) || ts.isModuleBlock(node)) {
+        for (const statement of node.statements) {
+            if (ts.isVariableStatement(statement)) {
+                collectVariableStatement(statement);
+                continue;
+            }
+            if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) && statement.name) {
+                names.add(statement.name.text);
+            }
+        }
+        return names;
+    }
+    if (ts.isCatchClause(node)) {
+        if (node.variableDeclaration) {
+            collectBindingNames(node.variableDeclaration.name, names);
+        }
+        return names;
+    }
+    if (ts.isFunctionLike(node)) {
+        if (node.name && ts.isIdentifier(node.name))
+            names.add(node.name.text);
+        for (const parameter of node.parameters) {
+            collectBindingNames(parameter.name, names);
+        }
+        return names;
+    }
+    return names;
+}
+function isScopeNode(node) {
+    return ts.isSourceFile(node)
+        || ts.isBlock(node)
+        || ts.isModuleBlock(node)
+        || ts.isCatchClause(node)
+        || ts.isFunctionLike(node);
+}
+function shouldRewriteEnvIdentifier(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    if (ts.isImportClause(parent) || ts.isImportSpecifier(parent) || ts.isNamespaceImport(parent) || ts.isNamedImports(parent))
+        return false;
+    if (ts.isVariableDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isParameter(parent) && parent.name === node)
+        return false;
+    if (ts.isFunctionDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isClassDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node)
+        return false;
+    if (ts.isQualifiedName(parent) && parent.right === node)
+        return false;
+    if (ts.isPropertyAssignment(parent) && parent.name === node)
+        return false;
+    if (ts.isShorthandPropertyAssignment(parent) && parent.name === node)
+        return true;
+    if (ts.isBindingElement(parent) && parent.name === node)
+        return false;
+    return true;
+}
+function transformSource(source, visitorFactory) {
+    const sourceFile = ts.createSourceFile('kuratchi-script.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const scopeStack = [];
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    const result = ts.transform(sourceFile, [context => {
+            const baseFactory = visitorFactory({
+                isShadowed(name) {
+                    for (let i = scopeStack.length - 1; i >= 0; i--) {
+                        if (scopeStack[i].names.has(name))
+                            return true;
+                    }
+                    return false;
+                },
+                factory: context.factory,
+            });
+            const visitNode = (node) => {
+                let pushed = false;
+                if (isScopeNode(node)) {
+                    scopeStack.push({ names: collectScopeBindings(node) });
+                    pushed = true;
+                }
+                const transformed = baseFactory(node);
+                const visited = ts.visitEachChild(transformed, visitNode, context);
+                if (pushed)
+                    scopeStack.pop();
+                return visited;
+            };
+            return file => ts.visitNode(file, visitNode);
+        }]);
+    const transformedFile = result.transformed[0];
+    const printed = printer.printFile(transformedFile);
+    result.dispose();
+    return printed;
+}
+export function rewriteImportedFunctionCalls(source, fnToModule) {
+    const fnEntries = Object.entries(fnToModule).filter(([fnName]) => /^[A-Za-z_$][\w$]*$/.test(fnName));
+    if (fnEntries.length === 0)
+        return source;
+    const fnSet = new Set(fnEntries.map(([fnName]) => fnName));
+    return transformSource(source, ({ isShadowed, factory }) => (node) => {
+        if (ts.isCallExpression(node)
+            && ts.isIdentifier(node.expression)
+            && fnSet.has(node.expression.text)
+            && !isShadowed(node.expression.text)) {
+            const moduleId = fnToModule[node.expression.text];
+            return factory.updateCallExpression(node, factory.createPropertyAccessExpression(factory.createIdentifier(moduleId), factory.createIdentifier(node.expression.text)), node.typeArguments, node.arguments);
+        }
+        return node;
+    });
+}
+export function rewriteWorkerEnvAliases(source, aliases) {
+    const aliasSet = new Set(aliases.filter((alias) => /^[A-Za-z_$][\w$]*$/.test(alias)));
+    if (aliasSet.size === 0)
+        return source;
+    return transformSource(source, ({ isShadowed, factory }) => (node) => {
+        if (ts.isIdentifier(node)
+            && aliasSet.has(node.text)
+            && !isShadowed(node.text)
+            && shouldRewriteEnvIdentifier(node)) {
+            return factory.createIdentifier('__env');
+        }
+        return node;
+    });
+}
+export function buildDevAliasDeclarations(aliases, isDev) {
+    if (!aliases || aliases.length === 0)
+        return '';
+    return aliases.map((alias) => `const ${alias} = ${isDev ? 'true' : 'false'};`).join('\n');
+}
+export function buildSegmentedScriptBody(opts) {
+    const { segments, fnToModule, importDecls, workerEnvAliases, devAliases, isDev, asyncMode } = opts;
+    const lines = [];
+    const routeDevDecls = buildDevAliasDeclarations(devAliases, isDev);
+    if (routeDevDecls)
+        lines.push(routeDevDecls);
+    if (importDecls)
+        lines.push(importDecls);
+    lines.push('const __segmentData: Record<string, any> = {};');
+    const availableVars = [];
+    let segmentIndex = 0;
+    for (const segment of segments) {
+        if (!segment.script)
+            continue;
+        let segmentBody = stripTopLevelImports(segment.script);
+        segmentBody = rewriteImportedFunctionCalls(segmentBody, fnToModule);
+        segmentBody = rewriteWorkerEnvAliases(segmentBody, workerEnvAliases);
+        if (!segmentBody.trim())
+            continue;
+        const returnVars = segment.dataVars.filter((name) => /^[A-Za-z_$][\w$]*$/.test(name));
+        const segmentVar = '__segment_' + segmentIndex++;
+        const invokePrefix = asyncMode ? 'await ' : '';
+        const factoryPrefix = asyncMode ? 'async ' : '';
+        lines.push('const ' + segmentVar + ' = ' + invokePrefix + '(' + factoryPrefix + '(__ctx: Record<string, any>) => {');
+        lines.push(segmentBody);
+        lines.push(returnVars.length > 0 ? 'return { ' + returnVars.join(', ') + ' };' : 'return {};');
+        lines.push('})(__segmentData);');
+        lines.push('Object.assign(__segmentData, ' + segmentVar + ');');
+        for (const name of returnVars) {
+            if (!availableVars.includes(name))
+                availableVars.push(name);
+        }
+    }
+    if (!asyncMode && availableVars.length > 0) {
+        lines.push('const { ' + availableVars.join(', ') + ' } = __segmentData;');
+    }
+    return lines.join('\n');
+}

package/dist/compiler/server-module-pipeline.d.ts

@@ -0,0 +1,13 @@
+export interface ServerModuleCompiler {
+    toModuleSpecifier(fromFileAbs: string, toFileAbs: string): string;
+    transformModule(entryAbsPath: string): string;
+    resolveCompiledImportPath(origPath: string, importerDir: string, outFileDir: string): string;
+}
+interface CreateServerModuleCompilerOptions {
+    projectDir: string;
+    srcDir: string;
+    doHandlerProxyPaths: Map<string, string>;
+    writeFile: (filePath: string, content: string) => void;
+}
+export declare function createServerModuleCompiler(options: CreateServerModuleCompilerOptions): ServerModuleCompiler;
+export {};

package/dist/compiler/server-module-pipeline.js

@@ -0,0 +1,124 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function resolveExistingModuleFile(absBase) {
+    const candidates = [
+        absBase,
+        absBase + '.ts',
+        absBase + '.js',
+        absBase + '.mjs',
+        absBase + '.cjs',
+        path.join(absBase, 'index.ts'),
+        path.join(absBase, 'index.js'),
+        path.join(absBase, 'index.mjs'),
+        path.join(absBase, 'index.cjs'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile())
+            return candidate;
+    }
+    return null;
+}
+export function createServerModuleCompiler(options) {
+    const { projectDir, srcDir, doHandlerProxyPaths, writeFile } = options;
+    const transformedServerModules = new Map();
+    const modulesOutDir = path.join(projectDir, '.kuratchi', 'modules');
+    const normalizedProjectDir = projectDir.replace(/\\/g, '/');
+    function toModuleSpecifier(fromFileAbs, toFileAbs) {
+        let rel = path.relative(path.dirname(fromFileAbs), toFileAbs).replace(/\\/g, '/');
+        if (!rel.startsWith('.'))
+            rel = './' + rel;
+        return rel;
+    }
+    function resolveDoProxyTarget(absPath) {
+        const normalizedNoExt = absPath.replace(/\\/g, '/').replace(/\.[^.\/]+$/, '');
+        const proxyNoExt = doHandlerProxyPaths.get(normalizedNoExt);
+        if (!proxyNoExt)
+            return null;
+        return resolveExistingModuleFile(proxyNoExt) ?? (fs.existsSync(proxyNoExt + '.js') ? proxyNoExt + '.js' : null);
+    }
+    function resolveImportTarget(importerAbs, spec) {
+        if (spec.startsWith('$')) {
+            const slashIdx = spec.indexOf('/');
+            const folder = slashIdx === -1 ? spec.slice(1) : spec.slice(1, slashIdx);
+            const rest = slashIdx === -1 ? '' : spec.slice(slashIdx + 1);
+            if (!folder)
+                return null;
+            const abs = path.join(srcDir, folder, rest);
+            return resolveExistingModuleFile(abs) ?? abs;
+        }
+        if (spec.startsWith('.')) {
+            const abs = path.resolve(path.dirname(importerAbs), spec);
+            return resolveExistingModuleFile(abs) ?? abs;
+        }
+        return null;
+    }
+    function transformModule(entryAbsPath) {
+        const resolved = resolveExistingModuleFile(entryAbsPath) ?? entryAbsPath;
+        const normalized = resolved.replace(/\\/g, '/');
+        const cached = transformedServerModules.get(normalized);
+        if (cached)
+            return cached;
+        const relFromProject = path.relative(projectDir, resolved);
+        const outPath = path.join(modulesOutDir, relFromProject);
+        transformedServerModules.set(normalized, outPath);
+        const outDir = path.dirname(outPath);
+        if (!fs.existsSync(outDir))
+            fs.mkdirSync(outDir, { recursive: true });
+        if (!/\.(ts|js|mjs|cjs)$/i.test(resolved) || !fs.existsSync(resolved)) {
+            transformedServerModules.set(normalized, resolved);
+            return resolved;
+        }
+        const source = fs.readFileSync(resolved, 'utf-8');
+        const rewriteSpecifier = (spec) => {
+            const target = resolveImportTarget(resolved, spec);
+            if (!target)
+                return spec;
+            const doProxyTarget = resolveDoProxyTarget(target);
+            if (doProxyTarget)
+                return toModuleSpecifier(outPath, doProxyTarget);
+            const normalizedTarget = target.replace(/\\/g, '/');
+            const inProject = normalizedTarget.startsWith(normalizedProjectDir + '/');
+            if (!inProject)
+                return spec;
+            const targetResolved = resolveExistingModuleFile(target) ?? target;
+            if (!/\.(ts|js|mjs|cjs)$/i.test(targetResolved))
+                return spec;
+            const rewrittenTarget = transformModule(targetResolved);
+            return toModuleSpecifier(outPath, rewrittenTarget);
+        };
+        let rewritten = source.replace(/(from\s+)(['"])([^'"]+)\2/g, (_match, prefix, quote, spec) => {
+            return `${prefix}${quote}${rewriteSpecifier(spec)}${quote}`;
+        });
+        rewritten = rewritten.replace(/(import\s*\(\s*)(['"])([^'"]+)\2(\s*\))/g, (_match, prefix, quote, spec, suffix) => {
+            return `${prefix}${quote}${rewriteSpecifier(spec)}${quote}${suffix}`;
+        });
+        writeFile(outPath, rewritten);
+        return outPath;
+    }
+    function resolveCompiledImportPath(origPath, importerDir, outFileDir) {
+        const isBareModule = !origPath.startsWith('.') && !origPath.startsWith('/') && !origPath.startsWith('$');
+        if (isBareModule)
+            return origPath;
+        let absImport;
+        if (origPath.startsWith('$')) {
+            const slashIdx = origPath.indexOf('/');
+            const folder = slashIdx === -1 ? origPath.slice(1) : origPath.slice(1, slashIdx);
+            const rest = slashIdx === -1 ? '' : origPath.slice(slashIdx + 1);
+            absImport = path.join(srcDir, folder, rest);
+        }
+        else {
+            absImport = path.resolve(importerDir, origPath);
+        }
+        const doProxyTarget = resolveDoProxyTarget(absImport);
+        const target = doProxyTarget ?? transformModule(absImport);
+        let relPath = path.relative(outFileDir, target).replace(/\\/g, '/');
+        if (!relPath.startsWith('.'))
+            relPath = './' + relPath;
+        return relPath;
+    }
+    return {
+        toModuleSpecifier,
+        transformModule,
+        resolveCompiledImportPath,
+    };
+}

package/dist/compiler/template.d.ts

@@ -19,13 +19,25 @@
  *   - Lines that are pure JS control flow (for/if/else/}) → emitted as JS
  *   - Everything else → emitted as HTML string with {expr} interpolation
  */
+export interface TemplateRenderSections {
+    bodyTemplate: string;
+    headTemplate: string;
+}
+export interface CompileTemplateOptions {
+    emitCall?: string;
+    enableFragmentManifest?: boolean;
+    appendNewline?: boolean;
+    clientRouteRegistry?: ClientRouteRegistry;
+}
+export declare function splitTemplateRenderSections(template: string): TemplateRenderSections;
 /**
  * Compile a template string into a JS render function body.
  *
  * The generated code expects `data` in scope (destructured load return)
  * and an `__esc` helper for HTML-escaping.
  */
-export declare function compileTemplate(template: string, componentNames?: Map<string, string>, actionNames?: Set<string>, rpcNameMap?: Map<string, string>): string;
+export declare function compileTemplate(template: string, componentNames?: Map<string, string>, actionNames?: Set<string>, rpcNameMap?: Map<string, string>, options?: CompileTemplateOptions): string;
+import type { ClientRouteRegistry } from './client-module-pipeline.js';
 /**
  * Generate the full render function source code.
  */