@vesk/compiler 0.0.1

package/dist/vesk-plugin.js

@@ -0,0 +1,413 @@
+import * as acorn from 'acorn';
+function isWsChar(code) {
+    return code === 32 || code === 9 || code === 10 || code === 13 || code === 12;
+}
+function isStyleBoundary(code) {
+    return isWsChar(code) || code === 62 || code === 47 || code === 123;
+}
+function matchKeywordSequence(input, words) {
+    let p = 0;
+    while (p < input.length && isWsChar(input.charCodeAt(p)))
+        p++;
+    if (!input.startsWith(words[0], p))
+        return false;
+    p += words[0].length;
+    for (let i = 1; i < words.length; i++) {
+        const wsStart = p;
+        while (p < input.length && isWsChar(input.charCodeAt(p)))
+            p++;
+        if (p === wsStart)
+            return false;
+        if (!input.startsWith(words[i], p))
+            return false;
+        p += words[i].length;
+    }
+    if (p >= input.length)
+        return true;
+    const c = input.charCodeAt(p);
+    return isWsChar(c) || c === 123;
+}
+export function VeskParserPlugin(config = {}) {
+    return (Parser) => {
+        const tt = Parser.tokTypes || acorn.tokTypes;
+        const tstt = Parser.acornTypeScript?.tokTypes;
+        class VeskParser extends Parser {
+            #componentDepth = 0;
+            #closeTagName = null;
+            #jsxStartsStatement = false;
+            constructor(options, input) {
+                super(options, input);
+            }
+            #isBlockContext() {
+                const ctx = this.curContext();
+                return ctx && (ctx.token === '{' || ctx.token === 'function');
+            }
+            readToken(code) {
+                if (this.#componentDepth > 0 && code === 60 && this.#isBlockContext()) {
+                    const next = this.input.charCodeAt(this.pos + 1);
+                    if (next === 47 || (next >= 65 && next <= 90) || (next >= 97 && next <= 122)) {
+                        const startsNewStatement = this.hasPrecedingLineBreak();
+                        const inType = this.inType;
+                        const forceJsx = () => {
+                            const savedExprAllowed = this.exprAllowed;
+                            this.exprAllowed = true;
+                            const result = super.readToken(code);
+                            this.exprAllowed = savedExprAllowed;
+                            return result;
+                        };
+                        if (inType) {
+                            if (startsNewStatement) {
+                                this.#jsxStartsStatement = true;
+                                ++this.pos;
+                                return this.finishToken(tstt.jsxTagStart);
+                            }
+                        }
+                        else {
+                            const prev = this.type;
+                            const canEndExpr = prev === tt.name || prev === tt.num || prev === tt.string || prev === tt.regexp ||
+                                prev === tt.bracketR || prev === tt.backQuote || prev === tt.template ||
+                                prev === tt._this || prev === tt._super || prev === tt._true || prev === tt._false ||
+                                prev === tt._null || prev === tt.jsxTagEnd;
+                            if (!canEndExpr || startsNewStatement) {
+                                this.#jsxStartsStatement = true;
+                                return forceJsx();
+                            }
+                        }
+                    }
+                }
+                this.#jsxStartsStatement = false;
+                return super.readToken(code);
+            }
+            isLet(context) {
+                if (!this.isContextual('let'))
+                    return false;
+                let p = this.pos;
+                while (p < this.input.length && isWsChar(this.input.charCodeAt(p)))
+                    p++;
+                const nextCh = this.input.charCodeAt(p);
+                if (nextCh === 38) {
+                    const afterAmp = this.input.charCodeAt(p + 1);
+                    if (afterAmp === 123 || afterAmp === 91)
+                        return true;
+                }
+                return super.isLet(context);
+            }
+            parseBindingAtom() {
+                if (this.type === tt.bitwiseAND) {
+                    const charAfterAmp = this.input.charCodeAt(this.end);
+                    if (charAfterAmp === 123 || charAfterAmp === 91) {
+                        this.next();
+                        const pattern = super.parseBindingAtom();
+                        pattern.lazy = true;
+                        return pattern;
+                    }
+                }
+                return super.parseBindingAtom();
+            }
+            parseExpression(noIn, refDestructuringErrors) {
+                const expr = super.parseExpression(noIn, refDestructuringErrors);
+                if (tstt && this.type === tstt.jsxTagStart && !this.#jsxStartsStatement) {
+                    this.raise(this.start, "Adjacent JSX elements must be wrapped in an enclosing tag. Wrap them in a fragment: <><Comp1 /><Comp2 /></> or a single parent element.");
+                }
+                return expr;
+            }
+            parseStatement(context, ...args) {
+                if (this.type === tt.name && this.value === 'async') {
+                    const afterAsync = this.input.slice(this.end).trimStart();
+                    if (matchKeywordSequence(afterAsync, ['component'])) {
+                        this.next();
+                        const node = this.parseComponentDeclaration(true);
+                        return node;
+                    }
+                }
+                if (this.type === tt.name && this.value === 'component') {
+                    return this.parseComponentDeclaration(false);
+                }
+                if (this.type === tt._export) {
+                    const rest = this.input.slice(this.pos).trimStart();
+                    if (matchKeywordSequence(rest, ['default', 'async', 'component'])) {
+                        this.next();
+                        this.next();
+                        this.next();
+                        const node = this.startNode();
+                        node.declaration = this.parseComponentDeclaration(true);
+                        node.default = true;
+                        return this.finishNode(node, 'ExportDefaultDeclaration');
+                    }
+                    if (matchKeywordSequence(rest, ['async', 'component'])) {
+                        this.next();
+                        this.next();
+                        const node = this.startNode();
+                        node.declaration = this.parseComponentDeclaration(true);
+                        return this.finishNode(node, 'ExportNamedDeclaration');
+                    }
+                    if (matchKeywordSequence(rest, ['default', 'component'])) {
+                        const node = this.startNode();
+                        this.next();
+                        this.next();
+                        node.declaration = this.parseComponentDeclaration(false);
+                        node.default = true;
+                        return this.finishNode(node, 'ExportDefaultDeclaration');
+                    }
+                    if (matchKeywordSequence(rest, ['component'])) {
+                        const node = this.startNode();
+                        this.next();
+                        node.declaration = this.parseComponentDeclaration(false);
+                        return this.finishNode(node, 'ExportNamedDeclaration');
+                    }
+                }
+                if (tstt && this.type === tstt.jsxTagStart && this.#componentDepth > 0) {
+                    const node = this.jsx_parseElement();
+                    this.semicolon();
+                    return node;
+                }
+                if (this.#componentDepth > 0 && this.type === tt.privateId && (this.value === 'server' || this.value === 'client' || this.value === 'empty')) {
+                    let p = this.end;
+                    while (p < this.input.length && isWsChar(this.input.charCodeAt(p)))
+                        p++;
+                    if (this.input.charCodeAt(p) === 123) {
+                        const node = this.startNode();
+                        node.tag = this.value;
+                        node.body = [];
+                        this.next();
+                        this.expect(tt.braceL);
+                        this.parseTemplateBody(node.body);
+                        this.next();
+                        return this.finishNode(node, 'VeskBlock');
+                    }
+                }
+                if (this.#componentDepth > 0 && this.type === tt.name && this.value === 'empty') {
+                    let p = this.end;
+                    while (p < this.input.length && isWsChar(this.input.charCodeAt(p)))
+                        p++;
+                    if (this.input.charCodeAt(p) === 123) {
+                        const node = this.startNode();
+                        node.tag = 'empty';
+                        this.next();
+                        node.body = this.parseBlock(false).body;
+                        return this.finishNode(node, 'VeskBlock');
+                    }
+                }
+                return super.parseStatement(context, ...args);
+            }
+            parseBlock(createNewLexicalScope, node, exitStrict) {
+                if (this.#componentDepth > 0) {
+                    if (createNewLexicalScope === void 0)
+                        createNewLexicalScope = true;
+                    if (node === void 0)
+                        node = this.startNode();
+                    node.body = [];
+                    this.expect(tt.braceL);
+                    if (createNewLexicalScope) {
+                        this.enterScope(0);
+                    }
+                    this.parseTemplateBody(node.body);
+                    if (exitStrict) {
+                        this.strict = false;
+                    }
+                    this.exprAllowed = true;
+                    this.next();
+                    if (createNewLexicalScope) {
+                        this.exitScope();
+                    }
+                    return this.finishNode(node, 'BlockStatement');
+                }
+                return super.parseBlock(createNewLexicalScope, node, exitStrict);
+            }
+            parseTemplateBody(body) {
+                if (this.type === tt.braceL) {
+                    const peekChar = this.input.charCodeAt(this.start + 1);
+                    if (this.#closeTagName !== null && peekChar === 47) {
+                        let p = this.start + 2;
+                        const nameStart = p;
+                        while (p < this.input.length) {
+                            const c = this.input.charCodeAt(p);
+                            if ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95 || c === 36) {
+                                p++;
+                            }
+                            else
+                                break;
+                        }
+                        const closeTag = this.input.slice(nameStart, p);
+                        if (closeTag === this.#closeTagName && p < this.input.length && this.input.charCodeAt(p) === 125) {
+                            return;
+                        }
+                    }
+                    if (peekChar === 35) {
+                        let p = this.start + 2;
+                        const nameStart = p;
+                        while (p < this.input.length) {
+                            const c = this.input.charCodeAt(p);
+                            if ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95 || c === 36) {
+                                p++;
+                            }
+                            else
+                                break;
+                        }
+                        const tagName = this.input.slice(nameStart, p);
+                        if (tagName === 'server' || tagName === 'client') {
+                            if (p < this.input.length && this.input.charCodeAt(p) === 125) {
+                                const node = this.parseVeskBlock(tagName);
+                                body.push(node);
+                                this.parseTemplateBody(body);
+                                return;
+                            }
+                        }
+                    }
+                    const node = this.jsx_parseExpressionContainer();
+                    body.push(node);
+                }
+                else if (this.type === tt.braceR) {
+                    return;
+                }
+                else if (tstt && this.type === tstt.jsxTagStart) {
+                    const nextChar = this.input.charCodeAt(this.pos);
+                    if (nextChar === 47) {
+                        return;
+                    }
+                    const node = this.jsx_parseElement();
+                    body.push(node);
+                    this.exprAllowed = true;
+                }
+                else if (tstt && this.type === tstt.jsxText) {
+                    this.next();
+                }
+                else {
+                    const node = this.parseStatement(null);
+                    body.push(node);
+                    this.exprAllowed = true;
+                }
+                this.parseTemplateBody(body);
+            }
+            parseVeskBlock(tagName) {
+                const node = this.startNode();
+                node.tag = tagName;
+                node.body = [];
+                this.pos = this.start;
+                const endPos = this.start + 2 + tagName.length + 1;
+                if (endPos > this.input.length) {
+                    this.raise(this.start, `Unclosed ${tagName} block`);
+                }
+                this.pos++;
+                this.pos++;
+                this.pos += tagName.length;
+                this.pos++;
+                this.next();
+                const prevCloseTag = this.#closeTagName;
+                this.#closeTagName = tagName;
+                this.parseTemplateBody(node.body);
+                this.#closeTagName = prevCloseTag;
+                this.pos = this.start;
+                this.pos++;
+                this.pos++;
+                while (this.pos < this.input.length) {
+                    const c = this.input.charCodeAt(this.pos);
+                    if ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95 || c === 36) {
+                        this.pos++;
+                    }
+                    else
+                        break;
+                }
+                if (this.pos < this.input.length)
+                    this.pos++;
+                this.next();
+                return this.finishNode(node, 'VeskBlock');
+            }
+            parseComponentDeclaration(isAsync = false) {
+                const node = this.startNode();
+                node.async = isAsync;
+                this.next();
+                node.id = this.parseIdent();
+                if (typeof this.tsTryParseTypeParameters === 'function') {
+                    const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
+                    if (typeParameters)
+                        node.typeParameters = typeParameters;
+                }
+                // Mirror acorn's parseFunction: clear await/yield bookkeeping so a
+                // later component declaration doesn't trip checkYieldAwaitInDefaultParams
+                // on stale positions from a previous async component body.
+                const savedYield = this.yieldPos;
+                const savedAwait = this.awaitPos;
+                const savedAwaitIdent = this.awaitIdentPos;
+                const savedMaybeInArrow = this.maybeInArrowParameters;
+                this.yieldPos = 0;
+                this.awaitPos = 0;
+                this.awaitIdentPos = 0;
+                this.maybeInArrowParameters = false;
+                this.enterScope(2 | (isAsync ? 4 : 0));
+                node.client = (this.type === tt.name || this.type === tt.privateId) && this.value === 'client' ? (this.next(), true) : false;
+                if (this.type === tt.parenL) {
+                    this.parseFunctionParams(node);
+                }
+                else {
+                    node.params = [];
+                }
+                if (!node.client && (this.type === tt.name || this.type === tt.privateId) && this.value === 'client') {
+                    node.client = true;
+                    this.next();
+                }
+                this.#componentDepth++;
+                node.body = this.parseBlock(false);
+                this.#componentDepth--;
+                this.exitScope();
+                this.yieldPos = savedYield;
+                this.awaitPos = savedAwait;
+                this.awaitIdentPos = savedAwaitIdent;
+                this.maybeInArrowParameters = savedMaybeInArrow;
+                this.finishNode(node, 'ComponentDeclaration');
+                return node;
+            }
+            jsx_parseElementAt(startPos, startLoc) {
+                const prefixLen = Math.min(20, this.input.length - startPos);
+                const prefix = this.input.slice(startPos, startPos + prefixLen);
+                if (prefix.startsWith('<style') && isStyleBoundary(prefix.charCodeAt(6))) {
+                    return this.parseStyleElement(startPos, startLoc);
+                }
+                return super.jsx_parseElementAt(startPos, startLoc);
+            }
+            parseStyleElement(startPos, startLoc) {
+                const el = this.startNodeAt(startPos, startLoc);
+                const openNode = this.startNodeAt(startPos, startLoc);
+                let nodeName = this.jsx_parseElementName();
+                if (nodeName)
+                    openNode.name = nodeName;
+                openNode.attributes = [];
+                this.lastTokEnd = this.pos;
+                openNode.selfClosing = false;
+                const openingElement = this.finishNode(openNode, 'JSXOpeningElement');
+                if (openingElement.selfClosing) {
+                    el.openingElement = openingElement;
+                    el.children = [];
+                    return this.finishNode(el, 'JSXElement');
+                }
+                const contentStart = openingElement.end;
+                const closeIdx = this.input.indexOf('</style>', contentStart);
+                if (closeIdx < 0) {
+                    this.raise(contentStart, 'Unclosed <style> element: missing </style>');
+                }
+                const children = [];
+                if (closeIdx > contentStart) {
+                    const raw = this.input.slice(contentStart, closeIdx);
+                    children.push({ type: 'JSXText', value: raw });
+                }
+                this.pos = closeIdx;
+                this.next();
+                this.next();
+                this.eat(tt.slash);
+                this.lastTokEnd = this.pos;
+                const closingElement = this.jsx_parseClosingElementAt(closeIdx, undefined);
+                el.openingElement = openingElement;
+                el.closingElement = closingElement;
+                el.children = children;
+                return this.finishNode(el, 'JSXElement');
+            }
+            checkUnreserved(ref) {
+                if (ref.name === 'component') {
+                    this.raise(ref.start, '`component` is a reserved keyword and cannot be used as an identifier');
+                }
+                return super.checkUnreserved(ref);
+            }
+        }
+        return VeskParser;
+    };
+}

package/dist/vsk-imports.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resolve `import ... from './path.vsk'` statements so helper components can
+ * live in arbitrary `.vsk` files and be imported into any page, layout,
+ * component or route file.
+ */
+export declare function vskImportTarget(importText: string): string | null;
+/**
+ * Extracts import statements from a `.vsk` source file. The source is parsed
+ * with the Vesk parser so imports inside strings, comments or template
+ * literals are never mistaken for real imports, and multi-line import lists
+ * are handled correctly. Falls back to a tokenizer scan when the file does
+ * not parse (e.g. mid-edit content in tooling).
+ */
+export declare function extractImportStatements(source: string): string[];
+export declare function collectVskImportPaths(imports: string[], sourcePath: string): string[];
+export declare function vskImportLines(source: string): string[];
+/**
+ * True when an `ImportDeclaration` is type-only: an `import type { ... }`
+ * statement, or a value import whose specifiers are all `type` specifiers.
+ * Type imports carry no runtime value and must never reach emitted JS.
+ */
+export declare function isTypeOnlyImport(stmt: any): boolean;
+/**
+ * Returns the import source with `type` specifiers removed, or `null` when the
+ * whole statement is type-only (nothing left to import at runtime). The
+ * original source is returned untouched when it cannot be parsed or reprinted,
+ * so value imports are never dropped or mangled.
+ */
+export declare function stripTypeImport(importSrc: string): string | null;
+//# sourceMappingURL=vsk-imports.d.ts.map

package/dist/vsk-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vsk-imports.d.ts","sourceRoot":"","sources":["../src/vsk-imports.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQjE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAahE;AA0BD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAUrF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAKnD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAoBhE"}

package/dist/vsk-imports.js

@@ -0,0 +1,141 @@
+import { dirname, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { print } from 'esrap';
+import ts from 'esrap/languages/ts';
+import { parse } from '@vesk/compiler/src/parser';
+import { importModuleTarget, tokenizeCode } from '@vesk/compiler/src/tokens';
+/**
+ * Resolve `import ... from './path.vsk'` statements so helper components can
+ * live in arbitrary `.vsk` files and be imported into any page, layout,
+ * component or route file.
+ */
+export function vskImportTarget(importText) {
+    const spec = importModuleTarget(importText);
+    if (spec === null || !spec.endsWith('.vsk'))
+        return null;
+    const tokens = tokenizeCode(importText);
+    if (tokens === null)
+        return null;
+    const hasFrom = tokens.some((t) => t.label === 'name' && t.value === 'from');
+    if (!hasFrom)
+        return null;
+    return spec;
+}
+/**
+ * Extracts import statements from a `.vsk` source file. The source is parsed
+ * with the Vesk parser so imports inside strings, comments or template
+ * literals are never mistaken for real imports, and multi-line import lists
+ * are handled correctly. Falls back to a tokenizer scan when the file does
+ * not parse (e.g. mid-edit content in tooling).
+ */
+export function extractImportStatements(source) {
+    try {
+        const ast = parse(source, { filename: 'imports.vsk' });
+        const out = [];
+        for (const stmt of ast.body) {
+            if (stmt.type === 'ImportDeclaration') {
+                out.push(source.slice(stmt.start, stmt.end));
+            }
+        }
+        return out;
+    }
+    catch {
+        return tokenExtractImportStatements(source);
+    }
+}
+function tokenExtractImportStatements(source) {
+    const tokens = tokenizeCode(source);
+    if (tokens === null)
+        return [];
+    const out = [];
+    for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i].label !== 'import')
+            continue;
+        const start = tokens[i].start;
+        let lastStringEnd = -1;
+        let end = -1;
+        let j = i + 1;
+        while (j < tokens.length) {
+            if (tokens[j].label === ';') {
+                end = tokens[j].end;
+                break;
+            }
+            if (tokens[j].label === 'import')
+                break;
+            if (tokens[j].label === 'string')
+                lastStringEnd = tokens[j].end;
+            j++;
+        }
+        if (end === -1)
+            end = lastStringEnd !== -1 ? lastStringEnd : tokens[i].end;
+        const stmt = source.slice(start, end).trim();
+        if (stmt)
+            out.push(stmt);
+        if (tokens[j] && tokens[j].label === ';')
+            i = j;
+    }
+    return out;
+}
+export function collectVskImportPaths(imports, sourcePath) {
+    const out = [];
+    for (const imp of imports) {
+        if (stripTypeImport(imp) === null)
+            continue;
+        const target = vskImportTarget(imp);
+        if (!target || !target.startsWith('.'))
+            continue;
+        const full = resolve(dirname(sourcePath), target);
+        if (existsSync(full))
+            out.push(full);
+    }
+    return out;
+}
+export function vskImportLines(source) {
+    return extractImportStatements(source).filter((imp) => vskImportTarget(imp) !== null && stripTypeImport(imp) !== null);
+}
+/**
+ * True when an `ImportDeclaration` is type-only: an `import type { ... }`
+ * statement, or a value import whose specifiers are all `type` specifiers.
+ * Type imports carry no runtime value and must never reach emitted JS.
+ */
+export function isTypeOnlyImport(stmt) {
+    if (!stmt || stmt.type !== 'ImportDeclaration')
+        return false;
+    if (stmt.importKind === 'type')
+        return true;
+    const specs = stmt.specifiers || [];
+    return specs.length > 0 && specs.every((s) => s.importKind === 'type');
+}
+/**
+ * Returns the import source with `type` specifiers removed, or `null` when the
+ * whole statement is type-only (nothing left to import at runtime). The
+ * original source is returned untouched when it cannot be parsed or reprinted,
+ * so value imports are never dropped or mangled.
+ */
+export function stripTypeImport(importSrc) {
+    let ast;
+    try {
+        ast = parse(importSrc, { filename: 'import.mjs' });
+    }
+    catch {
+        return importSrc;
+    }
+    const stmt = (ast.body || []).find((n) => n.type === 'ImportDeclaration');
+    if (!stmt)
+        return importSrc;
+    if (isTypeOnlyImport(stmt))
+        return null;
+    const specs = stmt.specifiers || [];
+    const kept = specs.filter((s) => s.importKind !== 'type');
+    if (kept.length === 0)
+        return null;
+    if (kept.length === specs.length)
+        return importSrc;
+    try {
+        const rewritten = { ...stmt, specifiers: kept };
+        return print({ type: 'Program', body: [rewritten], sourceType: 'module' }, ts()).code.trim();
+    }
+    catch {
+        return importSrc;
+    }
+}

package/dist/vsk-tsx.d.ts

@@ -0,0 +1,3 @@
+export declare function vskToTsx(source: string): string;
+export declare function generateVskDts(source: string): string;
+//# sourceMappingURL=vsk-tsx.d.ts.map

package/dist/vsk-tsx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vsk-tsx.d.ts","sourceRoot":"","sources":["../src/vsk-tsx.ts"],"names":[],"mappings":"AAmfA,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA8C/C;AAWD,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAmDrD"}