@vesk/compiler 0.0.1

package/dist/parser.js

@@ -0,0 +1,242 @@
+import * as acorn from 'acorn';
+import { tsPlugin } from './acorn-ts-plugin/index.js';
+import { VeskParserPlugin } from '@vesk/compiler/src/vesk-plugin';
+import { containsForOfIn } from '@vesk/compiler/src/scan';
+function isIdentChar(code) {
+    return ((code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 48 && code <= 57) || code === 95 || code === 36);
+}
+function isWhitespaceChar(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r' || ch === '\f' || ch === '\v' || ch === '\u00a0' || ch === '\ufeff';
+}
+/**
+ * Scans the source and blanks `; key <expr>` / `; index <ident>` clauses
+ * found in `for (...)` headers, returning the rewritten code (same length
+ * as the input, so every source offset is preserved) plus annotations.
+ */
+export function preprocessForClauses(source) {
+    const annotations = [];
+    const chars = source.split('');
+    const isString = (ch) => ch === '"' || ch === "'" || ch === '`';
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i];
+        // Skip strings and comments (nested backtick templates keep depth).
+        if (isString(ch)) {
+            const quote = ch;
+            let j = i + 1;
+            let tplDepth = 0;
+            while (j < source.length) {
+                const c = source[j];
+                if (c === '\\') {
+                    j += 2;
+                    continue;
+                }
+                if (quote === '`' && c === '$' && source[j + 1] === '{') {
+                    tplDepth++;
+                    j += 2;
+                    continue;
+                }
+                if (quote === '`' && c === '}' && tplDepth > 0) {
+                    tplDepth--;
+                    j++;
+                    continue;
+                }
+                if (c === quote && tplDepth === 0) {
+                    j++;
+                    break;
+                }
+                j++;
+            }
+            i = j;
+            continue;
+        }
+        if (ch === '/' && source[i + 1] === '/') {
+            let j = i + 2;
+            while (j < source.length && source[j] !== '\n')
+                j++;
+            i = j;
+            continue;
+        }
+        if (ch === '/' && source[i + 1] === '*') {
+            let j = i + 2;
+            while (j < source.length && !(source[j] === '*' && source[j + 1] === '/'))
+                j++;
+            i = Math.min(j + 2, source.length);
+            continue;
+        }
+        // `for` keyword followed by `(` — scan the header.
+        if (ch === 'f' && source.startsWith('for', i)) {
+            const before = i === 0 ? ' ' : source[i - 1];
+            if (!isIdentChar(source.charCodeAt(i + 3) || 0) && (i === 0 || !isIdentChar(before.charCodeAt(0)))) {
+                let p = i + 3;
+                while (p < source.length && isWhitespaceChar(source[p]))
+                    p++;
+                if (source[p] === '(') {
+                    let depth = 0;
+                    let j = p;
+                    while (j < source.length) {
+                        const c = source[j];
+                        if (isString(c)) {
+                            const quote = c;
+                            let k = j + 1;
+                            while (k < source.length) {
+                                if (source[k] === '\\') {
+                                    k += 2;
+                                    continue;
+                                }
+                                if (source[k] === quote) {
+                                    k++;
+                                    break;
+                                }
+                                k++;
+                            }
+                            j = k;
+                            continue;
+                        }
+                        if (c === '(' || c === '[' || c === '{')
+                            depth++;
+                        else if (c === ')' || c === ']' || c === '}') {
+                            depth--;
+                            if (c === ')' && depth === 0)
+                                break;
+                        }
+                        j++;
+                    }
+                    const headerEnd = Math.min(j, source.length - 1);
+                    // Only `for (... of ...)` / `for (... in ...)` headers may carry
+                    // `; key` / `; index` clauses. Classic for-loops keep their `;`
+                    // separated clauses untouched (`for (let key = 0; key < 5; ...)`
+                    // must not be blanked).
+                    let firstSemi = -1;
+                    let depth1 = 0;
+                    for (let q = p + 1; q < headerEnd; q++) {
+                        const c = source[q];
+                        if (c === '(' || c === '[' || c === '{')
+                            depth1++;
+                        else if (c === ')' || c === ']' || c === '}')
+                            depth1--;
+                        else if (c === ';' && depth1 === 0) {
+                            firstSemi = q;
+                            break;
+                        }
+                    }
+                    const preSemi = source.slice(p + 1, firstSemi === -1 ? headerEnd : firstSemi);
+                    if (!containsForOfIn(preSemi)) {
+                        i = headerEnd;
+                        continue;
+                    }
+                    // Collect top-level `;` clause starts inside the header.
+                    const clauseStarts = [];
+                    let depth2 = 0;
+                    for (let q = p + 1; q < headerEnd; q++) {
+                        const c = source[q];
+                        if (isString(c)) {
+                            const quote = c;
+                            let k = q + 1;
+                            while (k < source.length) {
+                                if (source[k] === '\\') {
+                                    k += 2;
+                                    continue;
+                                }
+                                if (source[k] === quote) {
+                                    k++;
+                                    break;
+                                }
+                                k++;
+                            }
+                            q = k - 1;
+                            continue;
+                        }
+                        if (c === '(' || c === '[' || c === '{')
+                            depth2++;
+                        else if (c === ')' || c === ']' || c === '}')
+                            depth2--;
+                        else if (c === ';' && depth2 === 0)
+                            clauseStarts.push(q);
+                    }
+                    for (let c = 0; c < clauseStarts.length; c++) {
+                        const start = clauseStarts[c];
+                        const end = c + 1 < clauseStarts.length ? clauseStarts[c + 1] : headerEnd;
+                        // `clause` includes the leading `;` — it must be blanked too,
+                        // otherwise the header no longer parses as a for-of/for-in.
+                        const clause = source.slice(start, end);
+                        let clauseCode = clause;
+                        let keyRange;
+                        let indexName;
+                        // `clause` starts with the `;` — parse the keyword by hand so no
+                        // regex is involved: `; key <expr>` or `; index <ident>`.
+                        let q = start;
+                        if (source[q] === ';')
+                            q++;
+                        while (q < end && isWhitespaceChar(source[q]))
+                            q++;
+                        let kwStart = q;
+                        while (q < end && isIdentChar(source.charCodeAt(q)))
+                            q++;
+                        const keyword = source.slice(kwStart, q);
+                        if (keyword === 'key') {
+                            let k = q;
+                            while (k < end && isWhitespaceChar(source[k]))
+                                k++;
+                            const expr = source.slice(k, end).trim();
+                            if (expr) {
+                                keyRange = [k, start + clause.length];
+                                clauseCode = ' '.repeat(clause.length);
+                            }
+                        }
+                        else if (keyword === 'index') {
+                            let k = q;
+                            while (k < end && isWhitespaceChar(source[k]))
+                                k++;
+                            const identStart = k;
+                            while (k < end && isIdentChar(source.charCodeAt(k)))
+                                k++;
+                            const ident = source.slice(identStart, k);
+                            let m = k;
+                            while (m < end && isWhitespaceChar(source[m]))
+                                m++;
+                            if (ident && m === end) {
+                                indexName = ident;
+                                clauseCode = ' '.repeat(clause.length);
+                            }
+                        }
+                        if (keyRange || indexName) {
+                            for (let q = 0; q < clause.length; q++)
+                                chars[start + q] = clauseCode[q];
+                            annotations.push({
+                                kind: 'for-clause',
+                                forStart: i,
+                                clauseStart: start,
+                                clauseEnd: end,
+                                ...(keyRange ? { keyRange } : {}),
+                                ...(indexName !== undefined ? { indexName } : {}),
+                            });
+                        }
+                    }
+                    i = headerEnd;
+                    continue;
+                }
+            }
+        }
+        i++;
+    }
+    return { code: chars.join(''), annotations };
+}
+export function createBaseParser() {
+    return acorn.Parser.extend(tsPlugin({}), VeskParserPlugin());
+}
+export function parse(source, options = {}) {
+    const ParserClass = createBaseParser();
+    const { code, annotations } = preprocessForClauses(source);
+    const ast = ParserClass.parse(code, {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+        locations: true,
+        ranges: true,
+        ...(options.filename ? { sourceFilename: options.filename } : {}),
+    });
+    if (annotations.length > 0) {
+        ast.__vskAnnotations = annotations;
+    }
+    return ast;
+}

package/dist/router.d.ts

@@ -0,0 +1,31 @@
+import type { RouteNode } from '@vesk/compiler/src/types';
+export interface ScanOptions {
+    layoutCompName?: string;
+    pageCompName?: string;
+    compName?: string;
+}
+export interface MatchResult {
+    nodes: RouteNode[];
+    params: Record<string, string>;
+}
+/**
+ * Extracts `export (async) function middleware(params) { body }` from
+ * middleware source text. Parses with acorn (via the Vesk parser) so
+ * default params, nested parens and strings in the parameter list are
+ * handled correctly; falls back to the old regex + brace balance when the
+ * source does not parse.
+ */
+export declare function extractMiddlewareParts(src: string): {
+    params: string;
+    body: string;
+} | null;
+export declare function extractMiddleware(sourcePath: string): string | null;
+export declare function scanRoutes(appDir: string, options?: ScanOptions): RouteNode[];
+export declare function scanComponents(componentsDir: string): Map<string, string>;
+export declare function collectSources(tree: RouteNode[]): Map<string, string>;
+export interface RouteManifestOptions {
+    importPrefix?: string;
+}
+export declare function generateRouteManifest(tree: RouteNode[], options?: RouteManifestOptions): string;
+export declare function matchUrl(tree: RouteNode[], pathname: string): MatchResult | null;
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAM1D,MAAM,WAAW,WAAW;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAsB3F;AAkDD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUnE;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,SAAS,EAAE,CAKjF;AAMD,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BzE;AAmHD,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAcrE;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,OAAO,GAAE,oBAAyB,GAAG,MAAM,CAgCnG;AAkBD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAiFhF"}