@kuratchi/js 0.0.14 → 0.0.16

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

@@ -0,0 +1,257 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { collectReferencedIdentifiers, parseImportStatement } from './import-linking.js';
+import { transpileTypeScript } from './transpile.js';
+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;
+}
+function buildAsset(name, content) {
+    return {
+        name,
+        content,
+        mime: 'text/javascript; charset=utf-8',
+        etag: '"' + crypto.createHash('md5').update(content).digest('hex').slice(0, 12) + '"',
+    };
+}
+function toRelativeSpecifier(fromAssetName, toAssetName) {
+    let rel = path.posix.relative(path.posix.dirname(fromAssetName), toAssetName);
+    if (!rel.startsWith('.'))
+        rel = './' + rel;
+    return rel;
+}
+function rewriteImportSpecifiers(source, rewriteSpecifier) {
+    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}`;
+    });
+    return rewritten;
+}
+function resolveClientImportTarget(srcDir, 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 !== 'client' && folder !== 'shared') {
+            throw new Error(`[kuratchi compiler] Unsupported browser import realm "${spec}". Only $client/* and $shared/* may be loaded in the browser.`);
+        }
+        const abs = path.join(srcDir, folder, rest);
+        const resolved = resolveExistingModuleFile(abs);
+        if (!resolved) {
+            throw new Error(`[kuratchi compiler] Browser import not found: ${spec}`);
+        }
+        return resolved;
+    }
+    if (spec.startsWith('.')) {
+        const abs = path.resolve(path.dirname(importerAbs), spec);
+        const resolved = resolveExistingModuleFile(abs);
+        if (!resolved) {
+            throw new Error(`[kuratchi compiler] Browser import not found: ${spec}`);
+        }
+        return resolved;
+    }
+    throw new Error(`[kuratchi compiler] Browser modules currently only support project-local imports ($client, $shared, or relative). Unsupported import: ${spec}`);
+}
+class CompilerBackedClientRouteRegistry {
+    compiler;
+    bindingMap = new Map();
+    clientOnlyBindings = new Set();
+    handlerByKey = new Map();
+    routeId;
+    constructor(compiler, scopeId, importEntries) {
+        this.compiler = compiler;
+        this.routeId = scopeId;
+        for (const entry of importEntries) {
+            const parsed = parseImportStatement(entry.line);
+            if (!parsed.moduleSpecifier)
+                continue;
+            const isClient = parsed.moduleSpecifier.startsWith('$client/');
+            const isShared = parsed.moduleSpecifier.startsWith('$shared/');
+            if (!isClient && !isShared)
+                continue;
+            for (const binding of parsed.bindings) {
+                this.bindingMap.set(binding.local, {
+                    importLine: entry.line,
+                    importerDir: entry.importerDir,
+                    localName: binding.local,
+                    moduleSpecifier: parsed.moduleSpecifier,
+                });
+                if (isClient)
+                    this.clientOnlyBindings.add(binding.local);
+            }
+            if (parsed.namespaceImport) {
+                this.bindingMap.set(parsed.namespaceImport, {
+                    importLine: entry.line,
+                    importerDir: entry.importerDir,
+                    localName: parsed.namespaceImport,
+                    moduleSpecifier: parsed.moduleSpecifier,
+                });
+                if (isClient)
+                    this.clientOnlyBindings.add(parsed.namespaceImport);
+            }
+        }
+    }
+    hasBindings() {
+        return this.bindingMap.size > 0;
+    }
+    hasBindingReference(expression) {
+        const refs = collectReferencedIdentifiers(expression);
+        for (const ref of refs) {
+            if (this.bindingMap.has(ref))
+                return true;
+        }
+        return false;
+    }
+    registerEventHandler(_eventName, expression) {
+        const parsed = this.parseClientExpression(expression);
+        if (!parsed)
+            return null;
+        const binding = this.bindingMap.get(parsed.rootBinding);
+        if (!binding)
+            return null;
+        if (parsed.argsExpr) {
+            const argRefs = collectReferencedIdentifiers(parsed.argsExpr);
+            const leakedClientRefs = Array.from(argRefs).filter((ref) => this.clientOnlyBindings.has(ref));
+            if (leakedClientRefs.length > 0) {
+                throw new Error(`[kuratchi compiler] Client event arguments cannot depend on $client bindings: ${leakedClientRefs.join(', ')}.\n` +
+                    `Only server/shared values can be serialized into event handler arguments.`);
+            }
+        }
+        const key = `${parsed.calleeExpr}::${parsed.argsExpr || ''}`;
+        let existing = this.handlerByKey.get(key);
+        if (!existing) {
+            existing = {
+                id: `h${this.handlerByKey.size}`,
+                calleeExpr: parsed.calleeExpr,
+                rootBinding: parsed.rootBinding,
+            };
+            this.handlerByKey.set(key, existing);
+        }
+        return {
+            routeId: this.routeId,
+            handlerId: existing.id,
+            argsExpr: parsed.argsExpr,
+        };
+    }
+    buildEntryAsset() {
+        if (this.handlerByKey.size === 0)
+            return null;
+        const usedImportLines = new Map();
+        for (const record of this.handlerByKey.values()) {
+            const binding = this.bindingMap.get(record.rootBinding);
+            if (!binding)
+                continue;
+            if (!usedImportLines.has(binding.importLine)) {
+                usedImportLines.set(binding.importLine, {
+                    line: binding.importLine,
+                    importerDir: binding.importerDir,
+                });
+            }
+        }
+        const assetName = `__kuratchi/client/routes/${this.routeId}.js`;
+        const importLines = [];
+        for (const entry of usedImportLines.values()) {
+            const parsed = parseImportStatement(entry.line);
+            if (!parsed.moduleSpecifier)
+                continue;
+            const targetAbs = resolveClientImportTarget(this.compiler.srcDir, path.join(entry.importerDir, '__route__.ts'), parsed.moduleSpecifier);
+            const targetAssetName = this.compiler.transformClientModule(targetAbs);
+            const relSpecifier = toRelativeSpecifier(assetName, targetAssetName);
+            importLines.push(entry.line.replace(parsed.moduleSpecifier, relSpecifier));
+        }
+        const registrationEntries = Array.from(this.handlerByKey.values()).map((record) => {
+            return `${JSON.stringify(record.id)}: (args, event, element) => ${record.calleeExpr}(...args, event, element)`;
+        });
+        const source = transpileTypeScript([
+            ...importLines,
+            `window.__kuratchiClient?.register(${JSON.stringify(this.routeId)}, {`,
+            registrationEntries.map((entry) => `  ${entry},`).join('\n'),
+            `});`,
+        ].join('\n'), `client-route:${this.routeId}.ts`);
+        const asset = buildAsset(assetName, source);
+        this.compiler.registerAsset(asset);
+        return { assetName, asset };
+    }
+    parseClientExpression(expression) {
+        const trimmed = expression.trim();
+        if (!trimmed)
+            return null;
+        const callMatch = trimmed.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\(([\s\S]*)\)$/);
+        if (callMatch) {
+            const calleeExpr = callMatch[1];
+            const rootBinding = calleeExpr.split('.')[0];
+            const argsExpr = (callMatch[2] || '').trim();
+            return { calleeExpr, rootBinding, argsExpr: argsExpr || null };
+        }
+        const refMatch = trimmed.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)$/);
+        if (!refMatch)
+            return null;
+        const calleeExpr = refMatch[1];
+        const rootBinding = calleeExpr.split('.')[0];
+        return { calleeExpr, rootBinding, argsExpr: null };
+    }
+}
+class CompilerBackedClientModuleCompiler {
+    projectDir;
+    srcDir;
+    compiledAssets = new Map();
+    transformedModules = new Map();
+    constructor(projectDir, srcDir) {
+        this.projectDir = projectDir;
+        this.srcDir = srcDir;
+    }
+    createRegistry(scopeId, importEntries) {
+        return new CompilerBackedClientRouteRegistry(this, scopeId, importEntries);
+    }
+    createRouteRegistry(routeIndex, importEntries) {
+        return this.createRegistry(`route_${routeIndex}`, importEntries);
+    }
+    getCompiledAssets() {
+        return Array.from(this.compiledAssets.values());
+    }
+    registerAsset(asset) {
+        this.compiledAssets.set(asset.name, asset);
+    }
+    transformClientModule(entryAbsPath) {
+        const resolved = resolveExistingModuleFile(entryAbsPath) ?? entryAbsPath;
+        const normalized = resolved.replace(/\\/g, '/');
+        const cached = this.transformedModules.get(normalized);
+        if (cached)
+            return cached;
+        const relFromSrc = path.relative(this.srcDir, resolved).replace(/\\/g, '/');
+        const assetName = `__kuratchi/client/modules/${relFromSrc.replace(/\.(ts|js|mjs|cjs)$/i, '.js')}`;
+        this.transformedModules.set(normalized, assetName);
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`[kuratchi compiler] Browser module not found: ${resolved}`);
+        }
+        const source = fs.readFileSync(resolved, 'utf-8');
+        let rewritten = transpileTypeScript(source, `client-module:${relFromSrc}`);
+        rewritten = rewriteImportSpecifiers(rewritten, (spec) => {
+            const targetAbs = resolveClientImportTarget(this.srcDir, resolved, spec);
+            const targetAssetName = this.transformClientModule(targetAbs);
+            return toRelativeSpecifier(assetName, targetAssetName);
+        });
+        this.registerAsset(buildAsset(assetName, rewritten));
+        return assetName;
+    }
+}
+export function createClientModuleCompiler(opts) {
+    return new CompilerBackedClientModuleCompiler(opts.projectDir, opts.srcDir);
+}

package/dist/compiler/compiler-shared.d.ts

@@ -0,0 +1,55 @@
+export interface OrmDatabaseEntry {
+    binding: string;
+    schemaImportPath: string;
+    schemaExportName: string;
+    skipMigrations: boolean;
+    type: 'd1' | 'do';
+}
+export interface AuthConfigEntry {
+    cookieName: string;
+    secretEnvKey: string;
+    sessionEnabled: boolean;
+    hasCredentials: boolean;
+    hasActivity: boolean;
+    hasRoles: boolean;
+    hasOAuth: boolean;
+    hasGuards: boolean;
+    hasRateLimit: boolean;
+    hasTurnstile: boolean;
+    hasOrganization: boolean;
+}
+export interface DoConfigEntry {
+    binding: string;
+    className: string;
+    stubId?: string;
+    files?: string[];
+}
+export interface WorkerClassConfigEntry {
+    binding: string;
+    className: string;
+    file: string;
+    exportKind: 'named' | 'default';
+}
+export interface ConventionClassEntry {
+    className: string;
+    file: string;
+    exportKind: 'named' | 'default';
+}
+export interface DoClassMethodEntry {
+    name: string;
+    visibility: 'public' | 'private' | 'protected';
+    isStatic: boolean;
+    isAsync: boolean;
+    hasWorkerContextCalls: boolean;
+    callsThisMethods: string[];
+}
+export interface DoHandlerEntry {
+    fileName: string;
+    absPath: string;
+    binding: string;
+    mode: 'class' | 'function';
+    className?: string;
+    classMethods: DoClassMethodEntry[];
+    exportedFunctions: string[];
+}
+export declare function toSafeIdentifier(input: string): string;

package/dist/compiler/compiler-shared.js

@@ -0,0 +1,4 @@
+export function toSafeIdentifier(input) {
+    const normalized = input.replace(/[^A-Za-z0-9_$]/g, '_');
+    return /^[A-Za-z_$]/.test(normalized) ? normalized : `_${normalized}`;
+}

package/dist/compiler/component-pipeline.d.ts

@@ -0,0 +1,15 @@
+export interface ComponentCompiler {
+    ensureCompiled(fileName: string): string | null;
+    collectComponentMap(componentImports: Record<string, string>): Map<string, string>;
+    getActionPropNames(fileName: string): Set<string>;
+    collectStyles(componentNames: Map<string, string>): string[];
+    resolveActionProps(template: string, componentNames: Map<string, string>, shouldInclude?: (fnName: string) => boolean): Set<string>;
+    getCompiledComponents(): string[];
+}
+interface CreateComponentCompilerOptions {
+    projectDir: string;
+    srcDir: string;
+    isDev: boolean;
+}
+export declare function createComponentCompiler(options: CreateComponentCompilerOptions): ComponentCompiler;
+export {};

package/dist/compiler/component-pipeline.js

@@ -0,0 +1,163 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parseFile, stripTopLevelImports } from './parser.js';
+import { compileTemplate } from './template.js';
+import { transpileTypeScript } from './transpile.js';
+import { buildDevAliasDeclarations } from './script-transform.js';
+function resolvePackageComponent(projectDir, pkgName, componentFile) {
+    const nmPath = path.join(projectDir, 'node_modules', pkgName, 'src', 'lib', componentFile + '.html');
+    if (fs.existsSync(nmPath))
+        return nmPath;
+    const pkgDirName = pkgName.replace(/^@/, '').replace(/\//g, '-');
+    const workspaceRoot = path.resolve(projectDir, '../..');
+    const wsPath = path.join(workspaceRoot, 'packages', pkgDirName, 'src', 'lib', componentFile + '.html');
+    if (fs.existsSync(wsPath))
+        return wsPath;
+    const rootNmPath = path.join(workspaceRoot, 'node_modules', pkgName, 'src', 'lib', componentFile + '.html');
+    if (fs.existsSync(rootNmPath))
+        return rootNmPath;
+    return '';
+}
+function escapeTemplateLiteral(source) {
+    return source.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+function scopeComponentCss(source, scopeHash) {
+    return source.replace(/([^{}]+)\{/g, (_match, selectors) => {
+        const scoped = selectors
+            .split(',')
+            .map((selector) => `.${scopeHash} ${selector.trim()}`)
+            .join(', ');
+        return scoped + ' {';
+    });
+}
+export function createComponentCompiler(options) {
+    const { projectDir, srcDir, isDev } = options;
+    const libDir = path.join(srcDir, 'lib');
+    const compiledComponentCache = new Map();
+    const componentStyleCache = new Map();
+    const componentActionCache = new Map();
+    function ensureCompiled(fileName) {
+        if (compiledComponentCache.has(fileName))
+            return compiledComponentCache.get(fileName);
+        let filePath;
+        let funcName;
+        const pkgMatch = fileName.match(/^(@[^:]+):(.+)$/);
+        if (pkgMatch) {
+            const pkgName = pkgMatch[1];
+            const componentFile = pkgMatch[2];
+            funcName = '__c_' + componentFile.replace(/[\/\-]/g, '_');
+            filePath = resolvePackageComponent(projectDir, pkgName, componentFile);
+            if (!filePath || !fs.existsSync(filePath))
+                return null;
+        }
+        else {
+            funcName = '__c_' + fileName.replace(/[\/\-]/g, '_');
+            filePath = path.join(libDir, fileName + '.html');
+            if (!fs.existsSync(filePath))
+                return null;
+        }
+        const scopeHash = 'dz-' + crypto.createHash('md5').update(fileName).digest('hex').slice(0, 6);
+        const rawSource = fs.readFileSync(filePath, 'utf-8');
+        const parsed = parseFile(rawSource, { kind: 'component', filePath });
+        const propsCode = parsed.script ? stripTopLevelImports(parsed.script) : '';
+        const devDecls = buildDevAliasDeclarations(parsed.devAliases, isDev);
+        const effectivePropsCode = [devDecls, propsCode].filter(Boolean).join('\n');
+        const transpiledPropsCode = propsCode
+            ? transpileTypeScript(effectivePropsCode, `component-script:${fileName}.ts`)
+            : devDecls
+                ? transpileTypeScript(devDecls, `component-script:${fileName}.ts`)
+                : '';
+        let source = parsed.template;
+        let styleBlock = '';
+        const styleMatch = source.match(/<style[\s>][\s\S]*?<\/style>/i);
+        if (styleMatch) {
+            styleBlock = styleMatch[0];
+            source = source.replace(styleMatch[0], '').trim();
+        }
+        let scopedStyle = '';
+        if (styleBlock) {
+            const cssContent = styleBlock.replace(/<style[^>]*>/i, '').replace(/<\/style>/i, '').trim();
+            scopedStyle = `<style>${scopeComponentCss(cssContent, scopeHash)}</style>`;
+        }
+        componentStyleCache.set(fileName, scopedStyle ? escapeTemplateLiteral(scopedStyle) : '');
+        source = source.replace(/<slot\s*><\/slot>/g, '{@raw props.children || ""}');
+        source = source.replace(/<slot\s*\/>/g, '{@raw props.children || ""}');
+        const subComponentNames = collectComponentMap(parsed.componentImports);
+        for (const subFileName of subComponentNames.values()) {
+            const subStyle = componentStyleCache.get(subFileName);
+            if (subStyle) {
+                const existing = componentStyleCache.get(fileName) || '';
+                if (!existing.includes(subStyle)) {
+                    componentStyleCache.set(fileName, existing + subStyle);
+                }
+            }
+        }
+        const actionPropNames = new Set();
+        for (const match of source.matchAll(/\baction=\{([A-Za-z_$][\w$]*)\}/g)) {
+            actionPropNames.add(match[1]);
+        }
+        componentActionCache.set(fileName, actionPropNames);
+        const body = compileTemplate(source, subComponentNames, undefined, undefined);
+        const scopeOpen = `__html += '<div class="${scopeHash}">';`;
+        const scopeClose = `__html += '</div>';`;
+        const bodyLines = body.split('\n');
+        const scopedBody = [bodyLines[0], scopeOpen, ...bodyLines.slice(1), scopeClose].join('\n');
+        const fnBody = transpiledPropsCode ? `${transpiledPropsCode}\n  ${scopedBody}` : scopedBody;
+        const compiled = `function ${funcName}(props, __esc) {\n  ${fnBody}\n  return __html;\n}`;
+        compiledComponentCache.set(fileName, compiled);
+        return compiled;
+    }
+    function collectComponentMap(componentImports) {
+        const componentNames = new Map();
+        for (const [pascalName, fileName] of Object.entries(componentImports)) {
+            ensureCompiled(fileName);
+            componentNames.set(pascalName, fileName);
+        }
+        return componentNames;
+    }
+    function getActionPropNames(fileName) {
+        return componentActionCache.get(fileName) ?? new Set();
+    }
+    function collectStyles(componentNames) {
+        const styles = [];
+        for (const fileName of componentNames.values()) {
+            const css = componentStyleCache.get(fileName);
+            if (css)
+                styles.push(css);
+        }
+        return styles;
+    }
+    function resolveActionProps(template, componentNames, shouldInclude) {
+        const names = new Set();
+        for (const [pascalName, compFileName] of componentNames.entries()) {
+            const actionPropNames = getActionPropNames(compFileName);
+            const compTagRegex = new RegExp(`<${pascalName}\\b([\\s\\S]*?)(?:/?)>`, 'g');
+            for (const tagMatch of template.matchAll(compTagRegex)) {
+                const attrs = tagMatch[1];
+                for (const propName of actionPropNames) {
+                    const propRegex = new RegExp(`\\b${propName}=\\{([A-Za-z_$][\\w$]*)\\}`);
+                    const propMatch = attrs.match(propRegex);
+                    if (!propMatch)
+                        continue;
+                    const fnName = propMatch[1];
+                    if (!shouldInclude || shouldInclude(fnName)) {
+                        names.add(fnName);
+                    }
+                }
+            }
+        }
+        return names;
+    }
+    function getCompiledComponents() {
+        return Array.from(compiledComponentCache.values());
+    }
+    return {
+        ensureCompiled,
+        collectComponentMap,
+        getActionPropNames,
+        collectStyles,
+        resolveActionProps,
+        getCompiledComponents,
+    };
+}

package/dist/compiler/config-reading.d.ts

@@ -0,0 +1,11 @@
+import { type AuthConfigEntry, type DoConfigEntry, type OrmDatabaseEntry, type WorkerClassConfigEntry } from './compiler-shared.js';
+export declare function readUiTheme(projectDir: string): string | null;
+export declare function readUiConfigValues(projectDir: string): {
+    theme: string;
+    radius: string;
+} | null;
+export declare function readOrmConfig(projectDir: string): OrmDatabaseEntry[];
+export declare function readAuthConfig(projectDir: string): AuthConfigEntry | null;
+export declare function readDoConfig(projectDir: string): DoConfigEntry[];
+export declare function readWorkerClassConfig(projectDir: string, key: 'containers' | 'workflows'): WorkerClassConfigEntry[];
+export declare function readAssetsPrefix(projectDir: string): string;