@vesk/compiler 0.2.42 → 0.2.44

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-collision.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Same-name component declarations across `.vsk` files.
+ *
+ * `.vsk` components are not module-local bindings — every component a bundle
+ * compiles is registered in ONE global registry under its declared name
+ * (`__components["Helper"]`, `__registry.get("Helper")`). Two files that each
+ * declare `component Helper` therefore land on the same key, and which one wins
+ * depends on the order the bundle graph happened to walk. There is no type
+ * error and no runtime error: the page just renders somebody else's component.
+ *
+ * That is the failure mode worth reporting. It is *not* the same as importing a
+ * non-exported component: making `export` load-bearing would not prevent a
+ * collision, because two files can both `export component Helper` and still
+ * overwrite one key. So this check looks only at declaration names, never at
+ * the registry (the registry holds no ownership metadata and cannot say which
+ * file a symbol came from).
+ *
+ * Deliberately a WARNING, not an error. The loose name-keyed registry is
+ * long-standing and load-bearing, and a hard error here would break builds that
+ * render correctly today.
+ */
+export interface VskComponentCollision {
+    name: string;
+    files: string[];
+}
+export declare class VskComponentOwners {
+    private owners;
+    /** Records that `file` declares a component called `name`. */
+    claim(name: string, file: string): void;
+    /** Names declared by more than one file, each with its declaring files. */
+    collisions(): VskComponentCollision[];
+    /**
+     * Warns once per colliding name. Returns the message per collision so a
+     * caller (or a test) can assert on the text without capturing stderr.
+     *
+     * Deduped by name for the life of the process: the SSR path compiles one
+     * file graph per `compileFile` call, so without this a single build would
+     * repeat the same warning once per entry page.
+     */
+    report(context: string): string[];
+}
+/** Test hook: forget which collisions have been reported. */
+export declare function resetVskCollisionReports(): void;
+//# sourceMappingURL=vsk-collision.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vsk-collision.d.ts","sourceRoot":"","sources":["../src/vsk-collision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAkC;IAEhD,8DAA8D;IAC9D,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IASvC,2EAA2E;IAC3E,UAAU,IAAI,qBAAqB,EAAE;IAQrC;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;CAelC;AAQD,6DAA6D;AAC7D,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C"}

package/dist/vsk-collision.js

@@ -0,0 +1,73 @@
+/**
+ * Same-name component declarations across `.vsk` files.
+ *
+ * `.vsk` components are not module-local bindings — every component a bundle
+ * compiles is registered in ONE global registry under its declared name
+ * (`__components["Helper"]`, `__registry.get("Helper")`). Two files that each
+ * declare `component Helper` therefore land on the same key, and which one wins
+ * depends on the order the bundle graph happened to walk. There is no type
+ * error and no runtime error: the page just renders somebody else's component.
+ *
+ * That is the failure mode worth reporting. It is *not* the same as importing a
+ * non-exported component: making `export` load-bearing would not prevent a
+ * collision, because two files can both `export component Helper` and still
+ * overwrite one key. So this check looks only at declaration names, never at
+ * the registry (the registry holds no ownership metadata and cannot say which
+ * file a symbol came from).
+ *
+ * Deliberately a WARNING, not an error. The loose name-keyed registry is
+ * long-standing and load-bearing, and a hard error here would break builds that
+ * render correctly today.
+ */
+export class VskComponentOwners {
+    owners = new Map();
+    /** Records that `file` declares a component called `name`. */
+    claim(name, file) {
+        let set = this.owners.get(name);
+        if (!set) {
+            set = new Set();
+            this.owners.set(name, set);
+        }
+        set.add(file);
+    }
+    /** Names declared by more than one file, each with its declaring files. */
+    collisions() {
+        const out = [];
+        for (const [name, files] of this.owners) {
+            if (files.size > 1)
+                out.push({ name, files: [...files] });
+        }
+        return out.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * Warns once per colliding name. Returns the message per collision so a
+     * caller (or a test) can assert on the text without capturing stderr.
+     *
+     * Deduped by name for the life of the process: the SSR path compiles one
+     * file graph per `compileFile` call, so without this a single build would
+     * repeat the same warning once per entry page.
+     */
+    report(context) {
+        const collisions = this.collisions();
+        const fresh = [];
+        for (const { name, files } of collisions) {
+            if (reportedCollisions.has(name))
+                continue;
+            reportedCollisions.add(name);
+            fresh.push(`${name}: ${files.join(', ')}`);
+            console.warn(`[vesk] ${context}: component "${name}" is declared in ${files.length} files and resolves to only one of them — `
+                + `${files.join(', ')}. Which one wins depends on compile order, and the client and server registries pick differently, `
+                + `so this can render a different component in the browser than in the SSR HTML. Rename one of them.`);
+        }
+        return fresh;
+    }
+}
+/**
+ * Names already warned about. The client bundle and the SSR path each compile
+ * overlapping file graphs, so a per-instance set would double-report.
+ */
+const reportedCollisions = new Set();
+/** Test hook: forget which collisions have been reported. */
+export function resetVskCollisionReports() {
+    reportedCollisions.clear();
+}

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.44",
   "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.44",
     "acorn": "^8.15.0",
     "esrap": "^2.3.0",
     "is-reference": "^3.0.0",