@vesk/compiler 0.2.42 → 0.2.43

package/dist/vesk-plugin.js

@@ -156,6 +156,24 @@ function matchKeywordSequence(input, words) {
     const c = input.charCodeAt(p);
     return isWsChar(c) || c === 123;
 }
+/**
+ * True only while `tokenizeCode` drives the tokenizer directly. Acorn's
+ * `getOptions` copies only known option keys, so the request cannot travel on
+ * the options object — it is scoped here instead. Tokenizing is synchronous,
+ * so the save/restore is safe.
+ */
+let standaloneTokens = false;
+/** Runs `fn` with JSX tag recognition enabled without a parser driving it. */
+export function withStandaloneTokens(fn) {
+    const prev = standaloneTokens;
+    standaloneTokens = true;
+    try {
+        return fn();
+    }
+    finally {
+        standaloneTokens = prev;
+    }
+}
 export function VeskParserPlugin(config = {}) {
     return (Parser) => {
         const tt = Parser.tokTypes || acorn.tokTypes;
@@ -170,6 +188,15 @@ export function VeskParserPlugin(config = {}) {
             #jsxChildDepthStack = [];
             constructor(options, input) {
                 super(options, input);
+                // The standalone tokenizer (`tokenizeCode`) drives `getToken()` without
+                // ever running the parser, so `component X { … }` never raises
+                // #componentDepth and every JSX tag would be read as relational
+                // operators. Callers that only need a token stream still need JSX, so
+                // they opt in explicitly; parser-driven parses are unaffected.
+            }
+            /** True when JSX tags are recognised without parser-driven componentDepth. */
+            #jsxAllowed() {
+                return this.#componentDepth > 0 || standaloneTokens;
             }
             #isBlockContext() {
                 const ctx = this.curContext();
@@ -461,7 +488,7 @@ export function VeskParserPlugin(config = {}) {
                     }
                     return super.readToken(this.input.codePointAt(this.pos));
                 }
-                if (this.#componentDepth > 0 && code === 60 && this.#isBlockContext()) {
+                if (this.#jsxAllowed() && code === 60 && this.#isBlockContext()) {
                     const next = this.input.charCodeAt(this.pos + 1);
                     const startsNewStatement = this.hasPrecedingLineBreak();
                     const inType = this.inType;

package/dist/vsk-imports.d.ts

@@ -16,7 +16,58 @@ export declare function vskImportTarget(importText: string): string | null;
  */
 export declare function extractImportStatements(source: string): string[];
 export declare function collectVskImportPaths(imports: string[], sourcePath: string): string[];
+/**
+ * Resolves `export ... from './path.vsk'` targets the same way imports resolve,
+ * so a `.vsk` barrel re-export is followed and compiled into the importing
+ * file's component registry instead of being emitted as a bare re-export.
+ */
+export declare function collectVskReexportPaths(reexportSources: string[], sourcePath: string): string[];
+/**
+ * Local names bound by *named* value imports from a `.vsk` module.
+ *
+ * `.vsk` imports are value-less for component resolution (components are
+ * registry entries), but a `.vsk` module may still export plain values —
+ * `export const MAX = 10`, `export function format(x) {}`. Those live in the
+ * sub-file's `__vesk` and are hoisted into the importer, so the importer's
+ * component scope must destructure them.
+ *
+ * Returned separately from `localValueImportNames` because a name bound this
+ * way must NOT be treated as a direct-call target at a JSX call site: it may be
+ * a component, which resolves through the registry, not through a scope local.
+ */
+export declare function vskImportValueNames(imports: string[]): string[];
 export declare function vskImportLines(source: string): string[];
+/**
+ * Registry aliases contributed by one file's export/import statements.
+ *
+ * `.vsk` modules are not real ES modules — a component is a registry entry
+ * keyed by its declared name, not a top-level binding — so neither
+ * `export { A as B }` nor `import { A as B } from './x.vsk'` can be satisfied
+ * by emitting JS. Both are instead recorded as registry aliases so `<B />`
+ * resolves to the same function as `<A />`. Each pair is
+ * `{ local: <canonical name>, exported: <name the tag uses> }`.
+ *
+ * `default` and `*` are deliberately skipped: the registry is keyed by the
+ * component's *declared* name, which is unrelated to the `default` specifier.
+ */
+export declare function vskRegistryAliases(importLines: string[], exportAliases: Array<{
+    local: string;
+    exported: string;
+}>): Array<{
+    local: string;
+    exported: string;
+}>;
+/**
+ * Registers every alias in `aliases` against `componentMap`, pointing each
+ * exported name at the function its local name already resolves to. Names that
+ * do not resolve (a non-component value, or a component from a file that was
+ * not compiled) are left untouched so the original "not found" diagnostic
+ * still names the real missing component.
+ */
+export declare function applyVskRegistryAliases(componentMap: Map<string, Function>, aliases: Array<{
+    local: string;
+    exported: string;
+}>): void;
 /**
  * True when an `ImportDeclaration` is type-only: an `import type { ... }`
  * statement, or a value import whose specifiers are all `type` specifiers.

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

@@ -1 +1 @@
-{"version":3,"file":"vsk-imports.d.ts","sourceRoot":"","sources":["../src/vsk-imports.ts"],"names":[],"mappings":"AAQA;;;;;;;GAOG;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,CAerF;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,CAsBhE"}
+{"version":3,"file":"vsk-imports.d.ts","sourceRoot":"","sources":["../src/vsk-imports.ts"],"names":[],"mappings":"AAQA;;;;;;;GAOG;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;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ/F;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAW/D;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EAAE,EACrB,aAAa,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,GACxD,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAgB5C;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EACnC,OAAO,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,GAClD,IAAI,CAMN;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,CAsBhE"}

package/dist/vsk-imports.js

@@ -3,7 +3,7 @@ import { existsSync } from 'node:fs';
 import { print } from 'esrap';
 import ts from 'esrap/languages/ts';
 import { parse } from '@vesk/compiler/src/parser';
-import { resolveImportPath } from '@vesk/compiler/src/module-imports';
+import { importBindingPairs, resolveImportPath } from '@vesk/compiler/src/module-imports';
 import { importModuleTarget, tokenizeCode } from '@vesk/compiler/src/tokens';
 /**
  * Resolve `import ... from './path.vsk'` statements so helper components can
@@ -88,21 +88,118 @@ export function collectVskImportPaths(imports, sourcePath) {
         const target = vskImportTarget(imp);
         if (!target)
             continue;
-        if (target.startsWith('.')) {
-            const full = resolve(dirname(sourcePath), target);
-            if (existsSync(full))
-                out.push(full);
+        const full = resolveVskTarget(target, sourcePath);
+        if (full)
+            out.push(full);
+    }
+    return out;
+}
+/**
+ * Resolves `export ... from './path.vsk'` targets the same way imports resolve,
+ * so a `.vsk` barrel re-export is followed and compiled into the importing
+ * file's component registry instead of being emitted as a bare re-export.
+ */
+export function collectVskReexportPaths(reexportSources, sourcePath) {
+    const out = [];
+    for (const spec of reexportSources) {
+        if (!spec.endsWith('.vsk'))
             continue;
-        }
-        const aliased = resolveImportPath(target, dirname(sourcePath));
-        if (aliased !== target && existsSync(aliased))
-            out.push(aliased);
+        const full = resolveVskTarget(spec, sourcePath);
+        if (full)
+            out.push(full);
     }
     return out;
 }
+function resolveVskTarget(target, sourcePath) {
+    if (target.startsWith('.')) {
+        const full = resolve(dirname(sourcePath), target);
+        return existsSync(full) ? full : null;
+    }
+    const aliased = resolveImportPath(target, dirname(sourcePath));
+    return aliased !== target && existsSync(aliased) ? aliased : null;
+}
+/**
+ * Local names bound by *named* value imports from a `.vsk` module.
+ *
+ * `.vsk` imports are value-less for component resolution (components are
+ * registry entries), but a `.vsk` module may still export plain values —
+ * `export const MAX = 10`, `export function format(x) {}`. Those live in the
+ * sub-file's `__vesk` and are hoisted into the importer, so the importer's
+ * component scope must destructure them.
+ *
+ * Returned separately from `localValueImportNames` because a name bound this
+ * way must NOT be treated as a direct-call target at a JSX call site: it may be
+ * a component, which resolves through the registry, not through a scope local.
+ */
+export function vskImportValueNames(imports) {
+    const names = [];
+    for (const imp of imports) {
+        if (stripTypeImport(imp) === null)
+            continue;
+        if (vskImportTarget(imp) === null)
+            continue;
+        for (const pair of importBindingPairs(imp)) {
+            if (pair.imported === 'default' || pair.imported === '*')
+                continue;
+            names.push(pair.local);
+        }
+    }
+    return names;
+}
 export function vskImportLines(source) {
     return extractImportStatements(source).filter((imp) => vskImportTarget(imp) !== null && stripTypeImport(imp) !== null);
 }
+/**
+ * Registry aliases contributed by one file's export/import statements.
+ *
+ * `.vsk` modules are not real ES modules — a component is a registry entry
+ * keyed by its declared name, not a top-level binding — so neither
+ * `export { A as B }` nor `import { A as B } from './x.vsk'` can be satisfied
+ * by emitting JS. Both are instead recorded as registry aliases so `<B />`
+ * resolves to the same function as `<A />`. Each pair is
+ * `{ local: <canonical name>, exported: <name the tag uses> }`.
+ *
+ * `default` and `*` are deliberately skipped: the registry is keyed by the
+ * component's *declared* name, which is unrelated to the `default` specifier.
+ */
+export function vskRegistryAliases(importLines, exportAliases) {
+    const aliases = [];
+    for (const alias of exportAliases) {
+        if (alias.local !== alias.exported)
+            aliases.push({ local: alias.local, exported: alias.exported });
+    }
+    for (const imp of importLines) {
+        if (stripTypeImport(imp) === null)
+            continue;
+        if (vskImportTarget(imp) === null)
+            continue;
+        for (const pair of importBindingPairs(imp)) {
+            if (pair.imported === 'default' || pair.imported === '*')
+                continue;
+            // `import { A as B }` → the CANONICAL name is `pair.imported` ('A') and
+            // the ALIAS the tag actually uses is `pair.local` ('B').
+            if (pair.local !== pair.imported)
+                aliases.push({ local: pair.imported, exported: pair.local });
+        }
+    }
+    return aliases;
+}
+/**
+ * Registers every alias in `aliases` against `componentMap`, pointing each
+ * exported name at the function its local name already resolves to. Names that
+ * do not resolve (a non-component value, or a component from a file that was
+ * not compiled) are left untouched so the original "not found" diagnostic
+ * still names the real missing component.
+ */
+export function applyVskRegistryAliases(componentMap, aliases) {
+    for (const { local, exported } of aliases) {
+        if (componentMap.has(exported))
+            continue;
+        const fn = componentMap.get(local);
+        if (fn)
+            componentMap.set(exported, fn);
+    }
+}
 /**
  * True when an `ImportDeclaration` is type-only: an `import type { ... }`
  * statement, or a value import whose specifiers are all `type` specifiers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vesk/compiler",
-  "version": "0.2.42",
+  "version": "0.2.43",
   "type": "module",
   "description": "Vesk compiler — lexer, parser, semantic analysis, IR, codegen",
   "main": "./dist/index.js",
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "@sveltejs/acorn-typescript": "^1.0.0",
-    "@vesk/types": "^0.2.42",
+    "@vesk/types": "^0.2.43",
     "acorn": "^8.15.0",
     "esrap": "^2.3.0",
     "is-reference": "^3.0.0",