ferrovue 0.3.0 → 0.5.0

package/dist/compiler.js

@@ -1,56 +1,32 @@
-/* ferrovue's compiler: `.vue` → Rust render functions.
- *
- * The input is not the template. It is what `@vue/compiler-sfc` compiles the template to for
- * server rendering — straight-line `_push` calls, `if`, `_ssrRenderList`, and a handful of
- * `@vue/server-renderer` helpers — so element structure, attribute order, whitespace and the
- * fragment markers are decided by Vue, and this file only has to translate a small, closed
- * vocabulary of JavaScript into Rust that writes the same bytes. The generated code calls the
- * `ferrovue` crate for everything Vue's runtime does.
- *
- * Anything outside that vocabulary is an error naming the component and the construct, never a
- * best guess: a guess that is wrong by one byte is a hydration mismatch in a browser, found by a
- * reader.
- *
- * A project describes itself in `ferrovue.config.json` at its root — see `Config` — and runs the
- * `ferrovue` command there. `generate()` is also what a drift test calls, so the committed files can
- * be held to exactly what this produces.
- *
- * This module is the public API; the translation lives in the modules beside it. */
 import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { basename, join } from "node:path";
 import { ctx, loadConfig, tyOfName } from "./context.js";
-import { readComponent } from "./component.js";
-import { readRoutes } from "./router.js";
-import { readStores } from "./stores.js";
-import { i18nSource, readLocales } from "./i18n.js";
+import { importsOf, readComponent } from "./component.js";
 import { scopeFor } from "./script.js";
-import { attrsFlow, scopeFlow } from "./scoped.js";
-import { componentSource, isIsland, modSource, routesSource, storesSource, typesSource } from "./rust.js";
+import { attrsFlow } from "./fallthrough.js";
+import { componentSource, isIsland, modSource } from "./rust.js";
+import { renderParams } from "./plugin.js";
+import { PLUGINS } from "./plugins/index.js";
 /** Every generated file, keyed by its name in the output directory. */
 export function generate(root, config = loadConfig(root)) {
     ctx.componentsDir = config.components.replace(/\/?$/, "/");
     ctx.helperModule = config.helpers?.module ?? null;
     ctx.trustedHtml = config.trustedHtml ?? null;
-    const router = config.router ?? (config.routes ? { routes: config.routes } : null);
-    ctx.routes = router ? readRoutes(root, router.routes) : null;
-    ctx.routerBase = router?.base ?? "";
+    ctx.builders = config.builders ?? true;
     ctx.clientDirectives = new Set(config.clientDirectives ?? []);
-    ctx.i18n = config.i18n ? readLocales(root, config.i18n) : null;
-    ctx.linkActive = router?.linkActiveClass ?? "router-link-active";
-    ctx.linkExactActive = router?.linkExactActiveClass ?? "router-link-exact-active";
     ctx.rootDir = root;
-    ctx.scopeId = config.scopeId ?? "filepath-source";
-    ctx.viteRoot = resolve(root, config.viteRoot ?? ".");
     ctx.typeStructs = new Map();
     ctx.typeAliases = new Map();
     ctx.typeFiles = new Map();
     ctx.typeRead = new Set();
-    if (config.stores)
-        readStores(root, config.stores);
-    else {
-        ctx.stores = new Map();
-        ctx.storeStructs = new Map();
-    }
+    ctx.constDecls = new Map();
+    ctx.typeConsts = new Map();
+    ctx.plugins = PLUGINS;
+    ctx.runs = new Map();
+    for (const p of PLUGINS)
+        ctx.runs.set(p, p.configure?.(config, root));
+    for (const p of PLUGINS)
+        p.prepare?.(root);
     ctx.helpers = Object.fromEntries(Object.entries(config.helpers?.functions ?? {}).map(([name, h]) => [
         name,
         { rust: h.rust, params: h.params.map(tyOfName), ret: tyOfName(h.returns), maxLen: h.maxLen ?? 0 },
@@ -60,59 +36,29 @@ export function generate(root, config = loadConfig(root)) {
         .filter((f) => f.endsWith(".vue"))
         .toSorted()
         .map((f) => join(dir, f));
-    const read = files.map((f) => readComponent(f, root));
+    const children = new Set(files.flatMap((f) => importsOf(readFileSync(f, "utf8")).filter((c) => c !== basename(f, ".vue"))));
+    const read = files.map((f) => readComponent(f, root, children.has(basename(f, ".vue"))));
     const components = new Map(read.map((r) => [r.comp.name, r.comp]));
     ctx.components = components;
-    // Whether a component reads a store or the route is known once its setup is read; both reach
-    // every component on the way down to one that does, and the route every one on the way down to
-    // a `<RouterLink>`.
     const scopes = read.map((r) => scopeFor(r.comp, r.ast, components).scope);
-    // Which roots may be handed scope ids, and which slot content given a slot scope id.
-    scopeFlow(read.map((r, i) => ({ comp: r.comp, ssr: r.ssr, children: scopes[i].children })));
-    // Which components may be passed attributes beyond their props.
-    attrsFlow(read.map((r, i) => ({ comp: r.comp, ssr: r.ssr, children: scopes[i].children, attrsBindings: scopes[i].attrsBindings })));
-    for (const c of components.values())
-        c.usesRoute = c.routerLink || c.readsRoute;
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const c of components.values()) {
-            if (!c.usesRoute && [...c.imports].some((i) => components.get(i)?.usesRoute)) {
-                c.usesRoute = changed = true;
-            }
-        }
-    }
-    for (const c of components.values())
-        c.usesI18n = c.readsI18n;
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const c of components.values()) {
-            if (!c.usesI18n && [...c.imports].some((i) => components.get(i)?.usesI18n)) {
-                c.usesI18n = changed = true;
-            }
-        }
-    }
-    for (const c of components.values())
-        c.usesTeleports = c.readsTeleports;
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const c of components.values()) {
-            if (!c.usesTeleports && [...c.imports].some((i) => components.get(i)?.usesTeleports)) {
-                c.usesTeleports = changed = true;
-            }
-        }
-    }
+    const all = read.map((r, i) => ({ comp: r.comp, ssr: r.ssr, children: scopes[i].children, attrsBindings: scopes[i].attrsBindings }));
+    for (const p of PLUGINS)
+        p.analyse?.(all);
+    attrsFlow(all);
     for (const c of components.values())
-        c.usesStores = c.readsStores;
+        c.takes = new Set(renderParams().filter((p) => p.reads(c)).map((p) => p.name));
     for (let changed = true; changed;) {
         changed = false;
         for (const c of components.values()) {
-            if (!c.usesStores && [...c.imports].some((i) => components.get(i)?.usesStores)) {
-                c.usesStores = changed = true;
+            for (const name of [...c.imports].flatMap((i) => [...(components.get(i)?.takes ?? [])])) {
+                if (!c.takes.has(name)) {
+                    c.takes.add(name);
+                    changed = true;
+                }
             }
         }
     }
     const out = new Map();
-    // A child before its parents, which read the props its scoped slots pass.
     const ordered = [];
     const placed = new Set();
     const place = (r) => {
@@ -128,19 +74,13 @@ export function generate(root, config = loadConfig(root)) {
     };
     read.forEach(place);
     for (const r of ordered) {
-        // Numbered per component, so a file's text depends on its own source alone.
         ctx.narrowCount = 0;
         out.set(`${r.comp.module}.rs`, componentSource(r.comp, r.ast, r.ssr, components));
     }
-    out.set("mod.rs", modSource(read.map((r) => r.comp)));
-    if (ctx.routes)
-        out.set("route_table.rs", routesSource(ctx.routes, router.routes));
-    if (ctx.stores.size)
-        out.set("stores.rs", storesSource(config.stores.replace(/\/?$/, "/")));
-    if (ctx.typeStructs.size)
-        out.set("types.rs", typesSource());
-    if (ctx.i18n)
-        out.set("i18n.rs", i18nSource(ctx.i18n));
+    const modules = PLUGINS.flatMap((p) => p.modules?.() ?? []);
+    out.set("mod.rs", modSource(read.map((r) => r.comp), modules.map(([file]) => file)));
+    for (const [file, text] of modules)
+        out.set(file, text);
     return out;
 }
 /** Write what \`generate\` produces to the configured directory: only the files whose text changed,
@@ -157,7 +97,6 @@ export function write(root, config = loadConfig(root)) {
             old = readFileSync(join(target, name), "utf8");
         }
         catch {
-            // A new file.
         }
         if (old !== text) {
             writeFileSync(join(target, name), text);

package/dist/component.d.ts

@@ -1,5 +1,7 @@
 import { type Component, type N } from "./model.ts";
-export declare function readComponent(file: string, root: string): {
+/** The `.vue` files a component imports, by name. */
+export declare function importsOf(source: string): string[];
+export declare function readComponent(file: string, root: string, isChild: boolean): {
     comp: Component;
     ast: N[];
     ssr: string;

package/dist/component.js

@@ -1,14 +1,13 @@
-/* One `.vue` file read: its props, models, imported types, and Vue's SSR compilation of its template. */
+import { parse as parseJs } from "@babel/parser";
 import { compileScript, compileTemplate, parse as parseSfc } from "@vue/compiler-sfc";
-import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { SourceMapConsumer } from "source-map-js";
-import { basename, relative, resolve, sep } from "node:path";
-import { fail, opt, snake, tagAst } from "./model.js";
+import { basename, relative } from "node:path";
+import { absence, blankComponent, fail, GenError, opt, snake, sourceAt, tagAst } from "./model.js";
 import { ctx } from "./context.js";
-import { typesImports, declareTypes, defaultValue, definePropsType, readTypeFile, resolveImport, runtimeDefaults, structOf, tyOfTs } from "./typescript.js";
-/** A Vue compiler error's position as a node \`fail\` can point at: its line and 1-based column,
- * offset by where the template starts when the error is in the template's content. */
+import { typesImports, declareTypes, defaultValue, definePropsType, ONE_NOTHING, readTypeFile, resolveImport, runtimeDefaults, structOf, tyOfTs } from "./typescript.js";
+import { claim } from "./plugin.js";
+import { asyncChildren } from "./script.js";
 function vueErrorNode(err, within) {
     const loc = err.loc;
     if (!loc)
@@ -17,17 +16,6 @@ function vueErrorNode(err, within) {
     const at = !within ? { line, column: column - 1 } : line === 1 ? { line: within.line, column: within.column - 1 + column - 1 } : { line: within.line + line - 1, column: column - 1 };
     return { type: "VueError", loc: { start: at }, __fv: "source" };
 }
-/** `getHash` in `@vitejs/plugin-vue`: the first 8 hex digits of the SHA-256 of the file's path from
- * Vite's root, with `/` between its parts, followed in `"filepath-source"` mode by its source. */
-function scopeHash(file, source) {
-    const path = relative(ctx.viteRoot, resolve(file)).split(sep).join("/");
-    return createHash("sha256")
-        .update(ctx.scopeId === "filepath" ? path : path + source)
-        .digest("hex")
-        .slice(0, 8);
-}
-/** `inheritAttrs` as `defineOptions({ inheritAttrs })` or a plain `<script>`'s `export default`
- * sets it: a literal, since it decides what reaches the root. */
 function inheritAttrs(comp, statements) {
     let found = true;
     for (const st of statements) {
@@ -43,73 +31,117 @@ function inheritAttrs(comp, statements) {
             if (p.type !== "ObjectProperty" || p.computed || (p.key.name ?? p.key.value) !== "inheritAttrs")
                 continue;
             if (p.value.type !== "BooleanLiteral")
-                fail(comp, "`inheritAttrs` is `true` or `false`", p.value);
+                fail(comp, "FV0101", "`inheritAttrs` is `true` or `false`", p.value);
             found = p.value.value;
         }
     }
     return found;
 }
-export function readComponent(file, root) {
+function sourceDefault(ast, key) {
+    const named = (p) => (p.key?.name ?? p.key?.value) === key;
+    for (const st of ast) {
+        for (const d of st.type === "VariableDeclaration" ? st.declarations : []) {
+            if (d.id.type !== "ObjectPattern" || !definePropsType(d.init))
+                continue;
+            const p = d.id.properties.find((q) => q.type === "ObjectProperty" && named(q));
+            if (p?.value.type === "AssignmentPattern")
+                return p.value.right;
+        }
+        const call = st.type === "ExpressionStatement" ? st.expression : st.type === "VariableDeclaration" ? st.declarations[0]?.init : null;
+        if (call?.type !== "CallExpression" || call.callee.name !== "withDefaults" || call.arguments[1]?.type !== "ObjectExpression")
+            continue;
+        const p = call.arguments[1].properties.find((q) => q.type === "ObjectProperty" && named(q));
+        if (p)
+            return p.value;
+    }
+    return null;
+}
+function blockAt(source, block) {
+    return sourceAt(source, source.lastIndexOf(`<${block.type}`, block.loc.start.offset));
+}
+/** The `.vue` files a component imports, by name. */
+export function importsOf(source) {
+    return [...source.matchAll(/\bfrom\s*["'](?:[^"']*\/)?([^"'/]+)\.vue["']/g)].map((m) => m[1]);
+}
+function generics(comp, source, block) {
+    const text = block.attrs.generic;
+    if (typeof text !== "string")
+        return;
+    const open = source.lastIndexOf("<script", block.loc.start.offset);
+    const attr = source.slice(open, block.loc.start.offset).search(/\bgeneric\s*=\s*["']/);
+    const valueAt = open + attr + /^generic\s*=\s*["']/.exec(source.slice(open + attr))[0].length;
+    const at = sourceAt(source, valueAt).loc.start;
+    const prefix = "type T<";
+    let params;
+    try {
+        params = parseJs(`${prefix}${text}> = 0;`, { sourceType: "module", plugins: ["typescript"] }).program.body[0].typeParameters.params;
+    }
+    catch {
+        return fail(comp, "FV0301", "`generic` is a list of type parameters, as `T extends string`", sourceAt(source, valueAt));
+    }
+    const rebase = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        if (Array.isArray(n))
+            return n.forEach(rebase);
+        const start = n.loc?.start;
+        if (start && typeof n.type === "string") {
+            n.loc = { ...n.loc, start: start.line === 1 ? { line: at.line, column: at.column + start.column - prefix.length } : { line: at.line + start.line - 1, column: start.column } };
+        }
+        for (const [k, v] of Object.entries(n))
+            if (k !== "loc" && v && typeof v === "object")
+                rebase(v);
+    };
+    rebase(params);
+    tagAst(params, "source");
+    for (const p of params) {
+        const name = typeof p.name === "string" ? p.name : p.name.name;
+        if (!p.constraint)
+            fail(comp, "FV0302", `\`${name}\` in \`generic\` has no constraint: the server renders \`${name}\` as the type it extends, \`${name} extends string\``, p);
+        comp.aliases.set(name, p.constraint);
+    }
+}
+function scriptOf(comp, descriptor) {
+    try {
+        return compileScript(descriptor, { id: comp.name });
+    }
+    catch (e) {
+        if (!(e instanceof SyntaxError))
+            throw e;
+        const at = e.loc;
+        const block = descriptor.scriptSetup.loc.start;
+        const where = !at || descriptor.script ? {} : at.line === 1 ? { line: block.line, column: block.column + at.column } : { line: block.line + at.line - 1, column: at.column + 1 };
+        throw new GenError("FV0001", e.message, { file: comp.file, ...where }, e.message.split("\n")[0]);
+    }
+}
+export function readComponent(file, root, isChild) {
     const name = basename(file, ".vue");
     const source = readFileSync(file, "utf8");
     const { descriptor, errors } = parseSfc(source, { filename: file });
     const rel = relative(root, file);
-    const comp = {
-        name,
-        module: snake(name),
-        file: rel,
-        props: { name: "Props", fields: [] },
-        structs: new Map(),
-        trustedName: null,
-        floatName: null,
-        childProps: new Map(),
-        imports: new Set(),
-        slotNames: [],
-        routerView: false,
-        routerLink: false,
-        readsRoute: false,
-        usesRoute: false,
-        readsStores: false,
-        usesStores: false,
-        readsI18n: false,
-        usesI18n: false,
-        readsTeleports: false,
-        usesTeleports: false,
-        models: new Map(),
-        aliases: new Map(),
-        importedTypes: new Map(),
-        slotShapes: new Map(),
-        scopeId: null,
-        slotted: false,
-        inheritAttrs: true,
-        inherits: false,
-        passesSlotIds: false,
-        attrNames: new Set(),
-        idsInAttrs: false,
-    };
+    const comp = blankComponent(name, snake(name), rel);
     comp.source = source;
     if (errors.length)
-        fail(comp, String(errors[0]), vueErrorNode(errors[0]));
-    if (!descriptor.scriptSetup || !descriptor.template) {
-        fail(comp, "an island needs `<script setup lang=\"ts\">` and a `<template>`");
+        fail(comp, "FV0002", String(errors[0]), vueErrorNode(errors[0]));
+    if (descriptor.script && !descriptor.scriptSetup) {
+        const needs = isChild ? "a child component must have" : "an island needs";
+        fail(comp, "FV0003", `${needs} \`<script setup lang="ts">\`, or no script at all: a \`<script>\` without \`setup\` (the Options API, \`defineComponent\`) is not translated`, blockAt(source, descriptor.script));
     }
-    // A global `<style>` block changes no markup. A scoped one adds `data-v-…` attributes, whose id is
-    // computed here as the bundler computes it. A CSS module renames classes, and `v-bind()` in CSS
-    // writes variables onto the root, neither of which the server reproduces.
+    if (!descriptor.template)
+        fail(comp, "FV0004", "a component needs a `<template>`: a render function is not translated", sourceAt(source, 0));
     for (const st of descriptor.styles) {
         if (st.module)
-            fail(comp, "`<style module>` renames classes in the bundler; use a global or scoped `<style>`, or a stylesheet");
+            fail(comp, "FV1005", "`<style module>` renames classes in the bundler; use a global or scoped `<style>`, or a stylesheet", blockAt(source, st));
     }
+    const cssVar = descriptor.styles.find((st) => /\bv-bind\s*\(/.test(st.content));
     if (descriptor.cssVars.length)
-        fail(comp, "`v-bind()` in `<style>` sets variables the server does not render; bind `:style` instead");
-    if (descriptor.styles.some((st) => st.scoped))
-        comp.scopeId = `data-v-${scopeHash(file, source)}`;
-    comp.slotted = descriptor.slotted;
-    const script = compileScript(descriptor, { id: name });
-    const ast = script.scriptSetupAst ?? [];
+        fail(comp, "FV1006", "`v-bind()` in `<style>` sets variables the server does not render; bind `:style` instead", cssVar ? blockAt(source, cssVar) : undefined);
+    for (const p of ctx.plugins)
+        p.sfc?.(comp, descriptor, file, source);
+    const script = descriptor.scriptSetup ? scriptOf(comp, descriptor) : null;
+    const ast = script?.scriptSetupAst ?? [];
     tagAst(ast, "source");
-    // A plain `<script>` beside the setup one may declare the types the setup block uses.
-    const plainAst = script.scriptAst ?? [];
+    const plainAst = script?.scriptAst ?? [];
     tagAst(plainAst, "source");
     for (const s of [...plainAst, ...ast]) {
         if (s.type !== "ImportDeclaration" || !s.source.value.endsWith(".vue"))
@@ -123,9 +155,10 @@ export function readComponent(file, root) {
             }
         }
     }
+    for (const loaded of asyncChildren(comp, ast).values())
+        comp.imports.add(loaded);
     typesImports(comp, [...plainAst, ...ast]);
     comp.inheritAttrs = inheritAttrs(comp, [...plainAst, ...ast]);
-    // Types imported from elsewhere: a store's file, a shared `.ts` file, or another component.
     for (const st of [...plainAst, ...ast]) {
         if (st.type !== "ImportDeclaration")
             continue;
@@ -143,12 +176,8 @@ export function readComponent(file, root) {
             const typeFile = resolveImport(comp.file, from);
             if (!typeFile)
                 continue;
-            const module = typeFile.replace(/\.ts$/, "");
-            if ([...ctx.stores.values()].some((x) => x.module === module)) {
-                if (ctx.storeStructs.has(typeName))
-                    comp.importedTypes.set(sp.local.name, { k: "struct", name: typeName, store: true });
+            if (ctx.plugins.some((p) => p.importedType?.(comp, typeFile, typeName, sp.local.name)))
                 continue;
-            }
             if (ctx.helperModule !== null && from === ctx.helperModule && !isType)
                 continue;
             readTypeFile(typeFile);
@@ -158,8 +187,8 @@ export function readComponent(file, root) {
                 comp.aliases.set(sp.local.name, ctx.typeAliases.get(typeName));
         }
     }
-    // Interfaces in two passes: every name first, so one may name another declared after it, or
-    // itself — a tree node's children are tree nodes.
+    if (descriptor.scriptSetup)
+        generics(comp, source, descriptor.scriptSetup);
     const decls = declareTypes(comp, [...plainAst, ...ast], comp.structs, comp.aliases);
     for (const d of decls)
         comp.structs.set(d.name, structOf(comp, d.name, d.members, comp.structs));
@@ -168,15 +197,13 @@ export function readComponent(file, root) {
         const call = s.type === "ExpressionStatement" ? s.expression : s.type === "VariableDeclaration" ? s.declarations[0]?.init : null;
         const inner = call?.type === "CallExpression" && call.callee.type === "Identifier" && call.callee.name === "withDefaults" ? call.arguments[0] : call;
         if (inner?.type === "CallExpression" && inner.callee.type === "Identifier" && inner.callee.name === "defineProps" && !inner.typeParameters) {
-            fail(comp, "props are declared with a type, `defineProps<{ ... }>()`: a runtime declaration has no Rust type", inner);
+            fail(comp, "FV0303", "props are declared with a type, `defineProps<{ ... }>()`: a runtime declaration has no Rust type", inner);
         }
         const found = definePropsType(call);
         if (found)
             propsTy = found;
     }
-    // A component without `defineProps` takes no props.
     if (!propsTy) {
-        // nothing to read
     }
     else if (propsTy.type === "TSTypeLiteral") {
         comp.props = structOf(comp, "Props", propsTy.members, comp.structs);
@@ -185,9 +212,8 @@ export function readComponent(file, root) {
         comp.props = { name: "Props", fields: comp.structs.get(propsTy.typeName.name).fields };
     }
     else {
-        fail(comp, "`defineProps` takes a type literal or an interface declared in the same block", propsTy);
+        fail(comp, "FV0304", "`defineProps` takes a type literal or an interface declared in the same block", propsTy);
     }
-    // `defineModel`: a prop of its own (`modelValue` unless named), which the binding reads.
     for (const st of ast) {
         if (st.type !== "VariableDeclaration")
             continue;
@@ -197,41 +223,40 @@ export function readComponent(file, root) {
                 continue;
             const t = call.typeParameters?.params?.[0];
             if (!t)
-                fail(comp, "`defineModel` needs its type: `defineModel<string>()`", call);
+                fail(comp, "FV0305", "`defineModel` needs its type: `defineModel<string>()`", call);
             const named = call.arguments[0]?.type === "StringLiteral" ? call.arguments[0].value : "modelValue";
             const options = call.arguments.find((a) => a.type === "ObjectExpression");
             const required = options?.properties.some((p) => p.type === "ObjectProperty" && (p.key.name ?? p.key.value) === "required" && p.value.type === "BooleanLiteral" && p.value.value);
             const base = tyOfTs(comp, t, comp.structs);
+            if (!required && absence(base) === "null")
+                fail(comp, "FV0306", `a \`defineModel\` of \`T | null\` that is not \`required\` may be absent, which is \`undefined\`, or \`null\`: ${ONE_NOTHING}`, call);
             comp.props.fields.push({ js: named, rust: snake(named), ty: required ? base : opt(base) });
             comp.models.set(d.id.name, named);
         }
     }
-    // What Vue uses for an absent optional prop: the default `compileScript` resolved — from
-    // `withDefaults`, a destructured default, or `defineModel`'s options — or `false` for a boolean.
-    const defaults = runtimeDefaults(comp, script.content);
+    const defaults = runtimeDefaults(comp, script?.content ?? "");
     for (const f of comp.props.fields) {
         if (f.ty.k !== "opt")
             continue;
         const node = defaults.get(f.js);
+        if (f.ty.none !== undefined) {
+            if (node)
+                fail(comp, "FV0307", `a default for \`${f.js}\`, which is \`T | null\`: Vue gives it only when \`${f.js}\` is absent, which its Rust type, an \`Option\`, cannot be; fall back in the template with \`??\``, sourceDefault(ast, f.js) ?? node);
+            continue;
+        }
         if (node)
-            f.dflt = defaultValue(comp, f, node);
+            f.dflt = defaultValue(comp, f, node, sourceDefault(ast, f.js) ?? undefined);
         else if (f.ty.of.k === "bool")
             f.dflt = "false";
     }
     const compiled = compileTemplate({
         source: descriptor.template.content,
         filename: file,
-        // As `@vitejs/plugin-vue` compiles it: the scope id written onto every element, and passed to
-        // slot content only with `:slotted()` styles.
-        id: comp.scopeId ?? name,
-        scoped: comp.scopeId !== null,
-        slotted: comp.slotted,
+        ...(claim((p) => p.templateOptions?.(comp)) ?? { id: name, scoped: false, slotted: false }),
         ssr: true,
         ssrCssVars: [],
-        compilerOptions: { bindingMetadata: script.bindings, sourceMap: true },
+        compilerOptions: { ...(script ? { bindingMetadata: script.bindings } : {}), sourceMap: true },
     });
-    // `ssrInjectFallthroughAttrs`: a root `<Transition>` or `<KeepAlive>` passes `_attrs` on only to
-    // a lone element or component without `v-if` or `v-for`.
     const kids = (n) => n.children.filter((c) => c.type !== 3 && !(c.type === 2 && !c.content.trim()));
     const roots = descriptor.template.ast ? kids(descriptor.template.ast) : [];
     const wrapper = roots.length === 1 && roots[0].type === 1 && roots[0].tagType === 1 && ["Transition", "transition", "KeepAlive", "keep-alive"].includes(roots[0].tag) ? roots[0] : null;
@@ -241,24 +266,18 @@ export function readComponent(file, root) {
         if (!lone)
             comp.attrsDropped = { type: "VueTemplate", loc: { start: { line: wrapper.loc.start.line, column: wrapper.loc.start.column - 1 } }, __fv: "source" };
     }
+    comp.templateAst = descriptor.template.ast;
     const start = descriptor.template.loc.start;
     comp.templateStart = { line: start.line, column: start.column };
     if (compiled.map)
         comp.templateMap = new SourceMapConsumer(compiled.map);
-    // A template error's position is within the template's content.
     if (compiled.errors.length)
-        fail(comp, String(compiled.errors[0]), vueErrorNode(compiled.errors[0], comp.templateStart));
+        fail(comp, "FV0005", String(compiled.errors[0]), vueErrorNode(compiled.errors[0], comp.templateStart));
     for (const m of compiled.code.matchAll(/_ssrRenderSlot\(_ctx\.\$slots, "([^"]+)"/g)) {
         if (!comp.slotNames.includes(m[1]))
             comp.slotNames.push(m[1]);
     }
-    // Resolved by name, as globally registered components are, or imported from `vue-router`.
-    const imported = (exported) => [...plainAst, ...ast].some((st) => st.type === "ImportDeclaration" && st.source.value === "vue-router" &&
-        st.specifiers.some((sp) => sp.type === "ImportSpecifier" && (sp.imported.name ?? sp.imported.value) === exported));
-    comp.routerLink = compiled.code.includes('_resolveComponent("RouterLink")') || imported("RouterLink");
-    comp.routerView = compiled.code.includes('_resolveComponent("RouterView")') || imported("RouterView");
-    comp.readsRoute = compiled.code.includes("_ctx.$route");
-    comp.readsI18n = compiled.code.includes("_ctx.$t(");
-    comp.readsTeleports = compiled.code.includes("_ssrRenderTeleport(");
+    for (const p of ctx.plugins)
+        p.compiled?.(comp, compiled.code, [...plainAst, ...ast]);
     return { comp, ast, ssr: compiled.code };
 }

package/dist/constants.d.ts

@@ -0,0 +1,42 @@
+import { type Component, type N, type Scope, type Val } from "./model.ts";
+export type Const = {
+    k: "scalar";
+    js: Scalar;
+} | {
+    k: "list";
+    items: Const[];
+    node: N;
+    home: Component;
+    path: string;
+    typed: string | null;
+} | {
+    k: "object";
+    fields: Map<string, Const>;
+    node: N;
+    home: Component;
+    name: string;
+};
+type Scalar = string | number | boolean | null;
+export interface Declared {
+    node: N;
+    home: Component;
+    exported: boolean;
+}
+/** Remember the constants and enums a file declares at its top level, to evaluate when one is used. */
+export declare function declareConsts(home: Component, body: N[]): Map<string, Declared>;
+/** What a declared constant or enum stands for, evaluated once. */
+export declare function constOfDecl(d: Declared): Const;
+/** The type an enum stands for: the union of its members' literal types. */
+export declare function enumType(home: Component, d: N): N;
+/** What a constant is as a value in Rust; an object has none, only its fields. */
+export declare function constVal(c: Const, at: {
+    comp: Component;
+    node: N;
+    what: string;
+}): Val;
+/** The constant an expression names: an imported or enum binding, or a field of one. */
+export declare function constOf(s: Scope, n: N): {
+    c: Const;
+    what: string;
+} | null;
+export {};