@vesk/compiler 0.0.1

package/dist/actions.d.ts

@@ -0,0 +1,22 @@
+export interface ActionInfo {
+    id: string;
+    url: string;
+}
+export declare const ACTION_PREFIX = "/_vesk/action/";
+export declare function hashString(str: string): string;
+/**
+ * Transform a top-level statement's `defineAction(...)` calls.
+ *
+ * - `server`: inject a stable id as the first argument so the runtime
+ *   registers `defineAction("<id>", {...})` into the shared registry.
+ * - `client`: replace the call with a stub object literal carrying the same
+ *   id + endpoint URL. The `execute` handler (server-only code) is stripped
+ *   from the client bundle entirely.
+ *
+ * Both modes derive the id from the raw call source, so the ids match.
+ */
+export declare function rewriteTopLevelActions(code: string, mode: 'server' | 'client'): string;
+export declare function transformTopLevelForActions(topLevelCode: string[], mode: 'server' | 'client'): string[];
+/** Collect the stable action ids defined by a page source (for the manifest). */
+export declare function collectActionIds(source: string): string[];
+//# sourceMappingURL=actions.d.ts.map

package/dist/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,aAAa,mBAAmB,CAAC;AAE9C,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAW9C;AA6BD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAqCtF;AAeD,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,EAAE,CAOvG;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAsBzD"}

package/dist/actions.js

@@ -0,0 +1,167 @@
+import { walk } from 'zimmerframe';
+import { print } from 'esrap';
+import ts from 'esrap/languages/ts';
+import { parse } from '@vesk/compiler/src/parser';
+import { stripTsTypes, hasTsSyntax, isTypeOnlyStatement, stripCodeTypes } from '@vesk/compiler/src/strip-ts';
+export const ACTION_PREFIX = '/_vesk/action/';
+export function hashString(str) {
+    let h1 = 0x811c9dc5;
+    let h2 = 0x01000193;
+    for (let i = 0; i < str.length; i++) {
+        const c = str.charCodeAt(i);
+        h1 ^= c;
+        h1 = Math.imul(h1, 0x01000193) >>> 0;
+        h2 ^= c;
+        h2 = Math.imul(h2, 0x01000193) >>> 0;
+    }
+    return (h1 ^ h2).toString(36).slice(0, 12);
+}
+function literal(value) {
+    return { type: 'Literal', value };
+}
+function memberExpr(object, property) {
+    return {
+        type: 'MemberExpression',
+        object,
+        property: { type: 'Identifier', name: property },
+        computed: false,
+        optional: false,
+    };
+}
+function isDefineActionCall(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'defineAction');
+}
+function actionUrl(id) {
+    return `${ACTION_PREFIX}${id}`;
+}
+/**
+ * Transform a top-level statement's `defineAction(...)` calls.
+ *
+ * - `server`: inject a stable id as the first argument so the runtime
+ *   registers `defineAction("<id>", {...})` into the shared registry.
+ * - `client`: replace the call with a stub object literal carrying the same
+ *   id + endpoint URL. The `execute` handler (server-only code) is stripped
+ *   from the client bundle entirely.
+ *
+ * Both modes derive the id from the raw call source, so the ids match.
+ */
+export function rewriteTopLevelActions(code, mode) {
+    if (!code.includes('defineAction'))
+        return stripCodeTypes(code);
+    let ast;
+    try {
+        ast = parse(code);
+    }
+    catch {
+        return code;
+    }
+    const hadTs = hasTsSyntax(ast);
+    ast = walk(ast, null, {
+        CallExpression(node, context) {
+            if (isDefineActionCall(node)) {
+                const id = hashString(code.slice(node.start ?? 0, node.end ?? code.length));
+                if (mode === 'client') {
+                    return {
+                        type: 'ObjectExpression',
+                        properties: [
+                            { type: 'Property', kind: 'init', method: false, shorthand: false, computed: false, key: { type: 'Identifier', name: '__veskAction' }, value: literal(true) },
+                            { type: 'Property', kind: 'init', method: false, shorthand: false, computed: false, key: { type: 'Identifier', name: 'id' }, value: literal(id) },
+                            { type: 'Property', kind: 'init', method: false, shorthand: false, computed: false, key: { type: 'Identifier', name: 'url' }, value: literal(actionUrl(id)) },
+                        ],
+                    };
+                }
+                return {
+                    type: 'CallExpression',
+                    callee: { type: 'Identifier', name: 'defineAction' },
+                    arguments: [literal(id), ...(node.arguments || [])],
+                    optional: false,
+                };
+            }
+            return context.next();
+        },
+    });
+    return printWithTypesStripped(ast, code, hadTs);
+}
+function printWithTypesStripped(ast, code, hadTs = hasTsSyntax(ast)) {
+    if (!hadTs)
+        return code;
+    const stripped = stripTsTypes(ast);
+    if (stripped.type === 'Program' && Array.isArray(stripped.body)) {
+        stripped.body = stripped.body.filter((n) => !isTypeOnlyStatement(n));
+    }
+    try {
+        return print(stripped, ts()).code;
+    }
+    catch {
+        return code;
+    }
+}
+export function transformTopLevelForActions(topLevelCode, mode) {
+    const out = [];
+    for (const c of topLevelCode) {
+        const rewritten = rewriteTopLevelActions(c, mode);
+        if (rewritten !== '')
+            out.push(rewritten);
+    }
+    return out;
+}
+/** Collect the stable action ids defined by a page source (for the manifest). */
+export function collectActionIds(source) {
+    const ids = [];
+    const stmts = collectTopLevelStatements(source);
+    for (const code of stmts) {
+        if (!code.includes('defineAction'))
+            continue;
+        let ast;
+        try {
+            ast = parse(code);
+        }
+        catch {
+            continue;
+        }
+        walk(ast, null, {
+            CallExpression(node, context) {
+                if (isDefineActionCall(node)) {
+                    ids.push(hashString(code.slice(node.start ?? 0, node.end ?? code.length)));
+                    return;
+                }
+                return context.next();
+            },
+        });
+    }
+    return ids;
+}
+function collectTopLevelStatements(source) {
+    try {
+        const ast = parse(source);
+        const statements = [];
+        for (const node of ast.body) {
+            const type = node.type;
+            if (type === 'ImportDeclaration')
+                continue;
+            if (type === 'ExportNamedDeclaration' && node.declaration)
+                continue;
+            if (type === 'ExportDefaultDeclaration') {
+                const d = node.declaration;
+                if (d && typeof d.start === 'number' && typeof d.end === 'number') {
+                    statements.push(source.slice(d.start, d.end));
+                }
+                continue;
+            }
+            if (type === 'ComponentDeclaration')
+                continue;
+            if (type === 'ClassDeclaration')
+                continue;
+            if (typeof node.start === 'number' && typeof node.end === 'number') {
+                statements.push(source.slice(node.start, node.end));
+            }
+        }
+        return statements;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/api-routes.d.ts

@@ -0,0 +1,30 @@
+import type { ApiRouteNode } from '@vesk/compiler/src/types';
+export declare function scanApiRoutes(apiDir: string): ApiRouteNode[];
+export declare function matchApiUrl(tree: ApiRouteNode[], pathname: string): {
+    node: ApiRouteNode;
+    params: Record<string, string>;
+} | null;
+export declare function parseCookies(str: string): Record<string, string>;
+export interface DevCache extends Map<string, number> {
+}
+export type BuildWebRequestInput = {
+    method?: string;
+    headers?: Record<string, string | string[] | number | undefined>;
+    socket?: {
+        remoteAddress?: string;
+    };
+    [Symbol.asyncIterator](): AsyncIterableIterator<Buffer | Uint8Array | string>;
+};
+/**
+ * Build a standard Web API Request from a Node.js IncomingMessage.
+ *
+ * When `body` is omitted, the body is read lazily from the Node stream and
+ * `json()`/`text()` are patched accordingly. A `cookies` getter is attached
+ * (NextRequest-compatible).
+ */
+export declare function buildWebRequest(nodeReq: BuildWebRequestInput, url: string, body?: BodyInit | null): Request & {
+    cookies: Record<string, string>;
+    query: Record<string, string>;
+};
+export declare function executeApiRoute(filePath: string, method: string, request: Request, params?: Record<string, string>, locals?: Record<string, unknown>, devCache?: DevCache): Promise<Response | null>;
+//# sourceMappingURL=api-routes.d.ts.map

package/dist/api-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-routes.d.ts","sourceRoot":"","sources":["../src/api-routes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAS7D,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE,CAG5D;AA+ED,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CAoDjI;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWhE;AAED,MAAM,WAAW,QAAS,SAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;CAAG;AAExD,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;IACjE,MAAM,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,qBAAqB,CAAC,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC,CAAC;CAC/E,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,oBAAoB,EAC7B,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GACrB,OAAO,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAqC9E;AAED,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACnC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACpC,QAAQ,CAAC,EAAE,QAAQ,GAClB,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAkI1B"}

package/dist/api-routes.js

@@ -0,0 +1,350 @@
+import { readdirSync, statSync, existsSync } from 'fs';
+import { join } from 'path';
+function basename(p) {
+    const idx = p.lastIndexOf('/');
+    return idx === -1 ? p : p.slice(idx + 1);
+}
+export function scanApiRoutes(apiDir) {
+    if (!existsSync(apiDir))
+        return [];
+    return scanApiDir(apiDir, apiDir, '/');
+}
+function scanApiDir(rootDir, dir, parentPath) {
+    const nodes = [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return nodes;
+    }
+    let hasRoute = false;
+    let routeFileName = null;
+    for (const entry of entries) {
+        if (entry === 'route.js' || entry === 'route.ts') {
+            hasRoute = true;
+            routeFileName = entry;
+            break;
+        }
+    }
+    const segName = basename(dir);
+    const isDynamic = segName.startsWith('[') && segName.endsWith(']') && !segName.startsWith('[...');
+    const isCatchAll = segName.startsWith('[...') && segName.endsWith(']');
+    const isPrivate = segName.startsWith('_');
+    const isRouteGroup = segName.startsWith('(') && segName.endsWith(')');
+    if (isPrivate && dir !== rootDir)
+        return nodes;
+    if (isRouteGroup) {
+        for (const entry of entries) {
+            const entryPath = join(dir, entry);
+            let entryStat;
+            try {
+                entryStat = statSync(entryPath);
+            }
+            catch {
+                continue;
+            }
+            if (entryStat.isDirectory()) {
+                const childNodes = scanApiDir(rootDir, entryPath, parentPath);
+                nodes.push(...childNodes);
+            }
+        }
+        return nodes;
+    }
+    let seg = '';
+    if (dir === rootDir) {
+        seg = '';
+    }
+    else if (isDynamic) {
+        seg = ':' + segName.slice(1, -1);
+    }
+    else if (isCatchAll) {
+        seg = ':' + segName.slice(4, -1);
+    }
+    else {
+        seg = segName;
+    }
+    const fullPath = seg
+        ? (parentPath === '/' ? '/' : parentPath + '/') + seg
+        : (parentPath || '/');
+    const node = {
+        path: seg,
+        fullPath: fullPath.replace(/\/+/g, '/') || '/',
+        isDynamic,
+        isCatchAll,
+        filePath: hasRoute && routeFileName ? join(dir, routeFileName) : null,
+        children: [],
+    };
+    for (const entry of entries) {
+        const entryPath = join(dir, entry);
+        let entryStat;
+        try {
+            entryStat = statSync(entryPath);
+        }
+        catch {
+            continue;
+        }
+        if (entryStat.isDirectory()) {
+            const childNodes = scanApiDir(rootDir, entryPath, fullPath);
+            node.children.push(...childNodes);
+        }
+    }
+    if (node.filePath || node.children.length > 0) {
+        nodes.push(node);
+    }
+    return nodes;
+}
+export function matchApiUrl(tree, pathname) {
+    const normalized = (pathname.split('?')[0].split('#')[0]).replace(/^\/api(\/|$)/, '/');
+    const parts = normalized.split('/').filter(Boolean);
+    const params = {};
+    function matchNodes(nodes, partIndex) {
+        for (const node of nodes) {
+            if (node.fullPath === '/') {
+                if (partIndex >= parts.length && node.filePath)
+                    return node;
+                return matchNodes(node.children, partIndex);
+            }
+            if (partIndex >= parts.length) {
+                if (node.filePath)
+                    return node;
+                continue;
+            }
+            const part = parts[partIndex];
+            if (node.isCatchAll) {
+                const paramName = node.path.startsWith(':') ? node.path.slice(1) : node.path;
+                params[paramName] = parts.slice(partIndex).map(decodeURIComponent).join('/');
+                return node;
+            }
+            if (node.isDynamic) {
+                const paramName = node.path.startsWith(':') ? node.path.slice(1) : node.path;
+                params[paramName] = decodeURIComponent(part);
+                if (node.children.length > 0) {
+                    const result = matchNodes(node.children, partIndex + 1);
+                    if (result)
+                        return result;
+                }
+                if (node.filePath)
+                    return node;
+                delete params[paramName];
+                continue;
+            }
+            if (node.path === part) {
+                if (node.children.length > 0) {
+                    const result = matchNodes(node.children, partIndex + 1);
+                    if (result)
+                        return result;
+                }
+                if (node.filePath)
+                    return node;
+                continue;
+            }
+        }
+        return null;
+    }
+    const matched = matchNodes(tree, 0);
+    if (!matched)
+        return null;
+    return { node: matched, params: { ...params } };
+}
+export function parseCookies(str) {
+    const obj = {};
+    if (!str)
+        return obj;
+    for (const pair of str.split(';')) {
+        const eq = pair.indexOf('=');
+        if (eq === -1)
+            continue;
+        const k = pair.slice(0, eq).trim();
+        const v = pair.slice(eq + 1).trim();
+        if (k)
+            obj[k] = v;
+    }
+    return obj;
+}
+/**
+ * Build a standard Web API Request from a Node.js IncomingMessage.
+ *
+ * When `body` is omitted, the body is read lazily from the Node stream and
+ * `json()`/`text()` are patched accordingly. A `cookies` getter is attached
+ * (NextRequest-compatible).
+ */
+export function buildWebRequest(nodeReq, url, body) {
+    const parsedUrl = new URL(url, `http://${nodeReq.headers?.host || 'localhost'}`);
+    const method = nodeReq.method || 'GET';
+    const headers = {};
+    for (const [k, v] of Object.entries(nodeReq.headers || {})) {
+        headers[k] = Array.isArray(v) ? v.join(', ') : v === undefined ? '' : String(v);
+    }
+    const webRequest = new Request(parsedUrl, { method, headers, body: body ?? null });
+    if (body === undefined) {
+        let _bodyBuffer = null;
+        const getBody = async () => {
+            if (_bodyBuffer)
+                return _bodyBuffer;
+            const chunks = [];
+            for await (const chunk of nodeReq)
+                chunks.push(chunk);
+            _bodyBuffer = Buffer.concat(chunks);
+            return _bodyBuffer;
+        };
+        Object.defineProperty(webRequest, 'json', {
+            value: async () => { try {
+                return JSON.parse((await getBody()).toString());
+            }
+            catch {
+                return null;
+            } },
+            configurable: true,
+        });
+        Object.defineProperty(webRequest, 'text', {
+            value: async () => (await getBody()).toString('utf-8'),
+            configurable: true,
+        });
+    }
+    const rawCookies = parseCookies(String(nodeReq.headers?.cookie || ''));
+    Object.defineProperty(webRequest, 'cookies', { get: () => rawCookies, enumerable: true });
+    const query = {};
+    for (const [k, v] of parsedUrl.searchParams.entries())
+        query[k] = v;
+    Object.defineProperty(webRequest, 'query', { get: () => query, enumerable: true });
+    return webRequest;
+}
+export async function executeApiRoute(filePath, method, request, params = {}, locals = {}, devCache) {
+    let mod;
+    try {
+        if (devCache && devCache.has(filePath)) {
+            const t = devCache.get(filePath);
+            const url = new URL('file://' + filePath);
+            url.searchParams.set('t', String(t));
+            mod = await import(url.href);
+        }
+        else {
+            mod = await import(filePath);
+        }
+    }
+    catch (e) {
+        return new Response(JSON.stringify({ error: 'Failed to load route module', details: e.message }), {
+            status: 500, headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    const routeConfig = (mod.config || {});
+    const handler = mod[method];
+    if (!handler) {
+        if (method === 'OPTIONS') {
+            const allowed = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']
+                .filter(m => mod[m]);
+            return new Response(null, {
+                status: 204,
+                headers: { Allow: allowed.join(', ') },
+            });
+        }
+        return new Response(JSON.stringify({ error: `Method ${method} not allowed` }), {
+            status: 405, headers: { 'Content-Type': 'application/json', Allow: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'].filter(m => mod[m]).join(', ') },
+        });
+    }
+    const ctx = {
+        headers: Object.fromEntries([...request.headers.entries()].map(([k, v]) => [k, Array.isArray(v) ? v.join(', ') : v])),
+        url: request.url,
+        method: request.method,
+        cookies: parseCookies(request.headers.get('cookie') || ''),
+        locals,
+        _request: request,
+        params,
+    };
+    Object.defineProperty(request, 'locals', {
+        get: () => locals,
+        enumerable: true,
+    });
+    const prev = globalThis.__vesk_request;
+    globalThis.__vesk_request = ctx;
+    try {
+        let signal = request.signal;
+        if (routeConfig.maxDuration) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(new Error(`Request timed out after ${routeConfig.maxDuration}s`)), routeConfig.maxDuration * 1000);
+            signal = controller.signal;
+            Object.defineProperty(request, 'signal', { value: signal, writable: false });
+        }
+        const beforeHooks = (mod.beforeRequest || []);
+        for (const hook of beforeHooks) {
+            const hookResult = await hook(request, { params, locals });
+            if (hookResult instanceof Response)
+                return hookResult;
+        }
+        const { runHooks: execHooks } = await import('@vesk/runtime/server');
+        let globalHookResult = await execHooks('beforeRequest', request, { params, locals });
+        if (globalHookResult instanceof Response)
+            return globalHookResult;
+        let response;
+        try {
+            response = await handler(request, { params: Promise.resolve(params) });
+        }
+        catch (e) {
+            let errorResult = await execHooks('onError', e, request);
+            if (errorResult instanceof Response)
+                return errorResult;
+            throw e;
+        }
+        const afterHooks = (mod.afterRequest || []);
+        for (const hook of afterHooks) {
+            const hookResult = await hook(request, response);
+            if (hookResult instanceof Response)
+                response = hookResult;
+        }
+        let globalAfterResult = await execHooks('afterRequest', request, response);
+        if (globalAfterResult instanceof Response)
+            response = globalAfterResult;
+        const respObj = response;
+        if (typeof respObj?.build === 'function') {
+            respObj.build();
+        }
+        if (response instanceof Response) {
+            const rewriteUrl = response.headers.get('x-vesk-rewrite');
+            if (rewriteUrl) {
+                return executeRewrite(rewriteUrl, request);
+            }
+            if (response.headers.get('x-vesk-next')) {
+                return null;
+            }
+            return response;
+        }
+        return new Response(JSON.stringify(response), {
+            status: 200, headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    catch (e) {
+        const err = e;
+        if (err.name === 'Redirect') {
+            return new Response(null, {
+                status: err.status || 302,
+                headers: { Location: err.url || '' },
+            });
+        }
+        if (err.name === 'NotFoundError') {
+            return new Response(JSON.stringify({ error: 'Not Found' }), {
+                status: 404, headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        return new Response(JSON.stringify({ error: err.message }), {
+            status: 500, headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    finally {
+        globalThis.__vesk_request = prev;
+    }
+}
+async function executeRewrite(url, originalRequest) {
+    const rewriteReq = new Request(url, {
+        method: originalRequest.method,
+        headers: originalRequest.headers,
+        body: originalRequest.body,
+    });
+    if (originalRequest.locals) {
+        Object.defineProperty(rewriteReq, 'locals', {
+            get: () => originalRequest.locals,
+            enumerable: true,
+        });
+    }
+    return rewriteReq;
+}

package/dist/client-codegen.d.ts

@@ -0,0 +1,19 @@
+import type { IRNode } from '@vesk/compiler/src/ir';
+import { DynamicBinding, RuntimeStatement } from '@vesk/compiler/src/ir';
+import type { Expression } from '@vesk/compiler/src/ir';
+export interface TrackedInfo {
+    cellName: string;
+    kind: 'virtual' | 'cell';
+}
+export declare function semicolonizeStatement(code: string): string;
+export declare function transformTracked(irNode: Expression | RuntimeStatement | DynamicBinding, tracked: Map<string, TrackedInfo>): string;
+export declare function collectTrackedNames(body: IRNode[]): Map<string, TrackedInfo>;
+declare function isStaticIR(body: IRNode[]): boolean;
+export declare function escapeHtml(str: string): string;
+export declare function compileClient(source: string, _componentName: string | null, options?: {
+    forceClient?: boolean;
+    hydrate?: boolean;
+    includeTopLevel?: boolean;
+}): string;
+export { compileClient as compile, isStaticIR };
+//# sourceMappingURL=client-codegen.d.ts.map

package/dist/client-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-codegen.d.ts","sourceRoot":"","sources":["../src/client-codegen.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAuB,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAGL,cAAc,EAQd,gBAAgB,EAOjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAsCxD,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;CAC1B;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI1D;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,gBAAgB,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,MAAM,CAwGlI;AAID,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAU5E;AAqjCD,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAe3C;AA2HD,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO9C;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,MAAM,CA0D1K;AAED,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,UAAU,EAAE,CAAC"}