ferrovue 0.14.0 → 0.14.1

package/README.md

@@ -57,7 +57,7 @@ the configuration at your project root yourself:
 
 ```json
 {
-  "$schema": "https://cdn.jsdelivr.net/npm/ferrovue@0.14.0/schema.json",
+  "$schema": "https://cdn.jsdelivr.net/npm/ferrovue@0.14.1/schema.json",
   "components": "client/components",
   "out": "src/generated"
 }
@@ -226,7 +226,7 @@ ferrovue compiles `<script setup lang="ts">` components, and components with no
 |---|---|
 | Prop types | `string`, `number` (integers, `i64`, written and computed as JavaScript does, exact within ±2⁵³), `Float` from `ferrovue/types` (fractions, `f64`), `boolean`, unions of two or more string literals (`"sm" \| "md"`, an alias, or written in place), each a Rust enum generated for it (`Size::Md`, `"md".parse::<Size>()`, written and serialised as its literal; see the crate's [`props`](https://docs.rs/ferrovue/latest/ferrovue/guide/props/index.html#unions-of-string-literals) guide), or an enum of the application's own that `unions` names for the alias; a list of such a union, a list of its enum (`Size[]` is `Vec<Size>`); `T \| undefined`, `T \| null` (an `Option` written as `null`), arrays (`T[]`, `Array<T>`, `readonly T[]`), interfaces and object type aliases (recursive ones too), object types written in place, mapped types and `Record`s over a union of names, indexed types (`Card["size"]`), tuples (`[label: string, n: number]`, a tuple struct written as an array), dictionaries (`Record<string, T>`, `{ [key: string]: T }`, `ferrovue::props::Record` in Rust, which keeps JavaScript's order of keys), another component's exported `Props`, `TrustedHtml`, `InlineHtml`, `Date` (a prop, optional or nullable too, and inside lists, dictionaries and interfaces: `ferrovue::date::JsDate`, or `chrono::DateTime<Utc>` with the `chrono` feature) |
 | Shared types | Interfaces and type aliases imported from `.ts` files (generated once, into `types.rs`; imported by a relative path or through an alias the project declares, in its tsconfig.json's `compilerOptions.paths` or, with the Vite plugin, Vite's `resolve.alias`: `@/lib/format`), from a store's file, or from another component's `.vue` file; objects of a shared type can be passed between components. A TypeScript `enum` of string members is a Rust enum, as a union of string literals is, its variants named after its members; one of numbers is a number |
-| Constants | Constants imported from `.ts` files, object constants declared in `<script setup>`, and `enum`s (imported, or declared in the component, with members set to such constants or to earlier members), evaluated when the component is compiled: strings, numbers, booleans, `null`, arithmetic and joined strings of them as JavaScript evaluates them (`60 * MINUTE`, `` `${BASE}/feed` ``, `"#" + 1.5`, and `**` where it gives an exact integer within ±2⁵³), lists of them, objects of them read field by field (`LABELS.save`, `Tone.Loud`, `Rank[5]`), and lists of objects of them, which become a `const` in `types.rs` (`{ value, label }` items get a type named after the constant, `OptionsItem`, unless the constant is typed with an interface: `OPTIONS: Option[]`; a field that is `null` in some items is `T | null`); lookup tables: an object constant (`as const`, `Record<Size, T>` or untyped, keys computed from enum members too) read by a key whose type is a union of string or integer literals or an `enum` (a prop, a `computed`, a `v-for` item's field, a `?:` of literals, or built from one by `.toUpperCase()`, `.toLowerCase()` or a template literal), or by a constant number (`O[HALF]` reads `O["0.5"]`), compiled to a `match` over the members (over the variants of a union's enum, with no catch-all arm; a table of a union's members, `Record<Tone, Tone>`, reaches a union prop as a `match` from variant to variant), read on by field (`THEME[tone].fg`) in text, attributes, `:class` and `:style`, with `undefined` for a member the object lacks (`ICONS[kind] ?? "none"`, `ICONS[kind]?.label`, `v-if="ICONS[kind]"`, `kind && ICONS[kind]`); a free-text key tested with `Object.hasOwn(ROLES, key)`, against the object's own keys, which narrows the key for `ROLES[key]` in what follows; `Object.keys()` of an object constant; a constant `new Map([[key, value], …])` of string or integer keys, read with `.get(key)` (`undefined` for a key it lacks) and `.has(key)`. See the crate's [`props`](https://docs.rs/ferrovue/latest/ferrovue/guide/props/index.html#constants) guide |
+| Constants | Constants imported from `.ts` files (exported on their declaration, by name in `export { A, B as C }`, as `export default A`, or passed on with `export { A } from` and `export * from`), object constants declared in `<script setup>`, and `enum`s (imported, or declared in the component, with members set to such constants or to earlier members), evaluated when the component is compiled: strings, numbers, booleans, `null`, arithmetic and joined strings of them as JavaScript evaluates them (`60 * MINUTE`, `` `${BASE}/feed` ``, `"#" + 1.5`, and `**` where it gives an exact integer within ±2⁵³), lists of them, objects of them read field by field (`LABELS.save`, `Tone.Loud`, `Rank[5]`), and lists of objects of them, which become a `const` in `types.rs` (`{ value, label }` items get a type named after the constant, `OptionsItem`, unless the constant is typed with an interface: `OPTIONS: Option[]`; a field that is `null` in some items is `T | null`); lookup tables: an object constant (`as const`, `Record<Size, T>` or untyped, keys computed from enum members too) read by a key whose type is a union of string or integer literals or an `enum` (a prop, a `computed`, a `v-for` item's field, a `?:` of literals, or built from one by `.toUpperCase()`, `.toLowerCase()` or a template literal), or by a constant number (`O[HALF]` reads `O["0.5"]`), compiled to a `match` over the members (over the variants of a union's enum, with no catch-all arm; a table of a union's members, `Record<Tone, Tone>`, reaches a union prop as a `match` from variant to variant), read on by field (`THEME[tone].fg`) in text, attributes, `:class` and `:style`, with `undefined` for a member the object lacks (`ICONS[kind] ?? "none"`, `ICONS[kind]?.label`, `v-if="ICONS[kind]"`, `kind && ICONS[kind]`); a free-text key tested with `Object.hasOwn(ROLES, key)`, against the object's own keys, which narrows the key for `ROLES[key]` in what follows; `Object.keys()` of an object constant; a constant `new Map([[key, value], …])` of string or integer keys, read with `.get(key)` (`undefined` for a key it lacks) and `.has(key)`. See the crate's [`props`](https://docs.rs/ferrovue/latest/ferrovue/guide/props/index.html#constants) guide |
 | Props | Props declared in place, by an interface of the component, or by one imported from a `.ts` file by a relative path (`defineProps<CardProps>()`), extended or joined with `&`; `withDefaults`, destructured props with defaults and new names (`const { size = "md", label: text } = defineProps<…>()`), the props object (`const props = defineProps<…>()`, then `props.label` in the template or in script code), optional booleans (Vue casts an absent one to `false`), `defineModel` (named, required, with defaults), components with no props. A generic component (`<script setup generic="T extends Item">`) renders each type parameter as its constraint, which is all the template can rely on |
 | Setup | `ref`/`shallowRef`, `computed` (an expression, or a body of statements: see Statements; one that may throw, through `.repeat()`, `.padStart()`, a date, `$t` or a helper, is evaluated where the render first reads it, once, as Vue does), refs that start empty, typed by their type argument (`ref<Row[]>([])`, `ref<Row>()`, `ref<string \| undefined>(undefined)`), refs of a union of string literals, held as its enum (`ref<Choice>(props.tone ?? "")`, a member, a value of the union, a lookup table's value, or a `?:` or `??` of them), plain `const`/`let`, `.value` in script code, helpers with Rust twins, functions (see Functions), a plain `<script>` block beside setup. Lifecycle hooks, `watch` (not `immediate`), `defineEmits`, `defineSlots`, `defineOptions`, `defineExpose` and template refs (`ref(null)`, `useTemplateRef`) are client-only, as is a function only an event handler calls. The template may name them only from event handlers, which the server drops |
 | Statements | in a `computed`'s body and in a list method's callback (`.map()`, `.filter()`, `.find()`, `.some()`, `.reduce()`, a `.toSorted()` comparator and the others): `const` and `let` of any value the template may compute, destructured too (`const { name, posts: count } = author`); `if` / `else if` / `else` and early `return`, narrowing what follows as TypeScript narrows it (`if (!user) return ""; return user.name`, `if (!a \|\| !a.title) return "-"`); `switch` over a string or a number, with stacked `case`s, `default` and `break`; assignments to the body's `let`s (`=`, `+=`, `-=`, `*=`, `++`, `--` and the others), with the type TypeScript gives them; `for (const x of list)` over a list, `list.entries()`, `Object.keys()` or `Object.entries()`, `for (const ch of text)` over a string by its characters (a character beyond U+FFFF is one), and counting loops `for (let i = 0; i < n; i++)` to an integer bound, with `break`, `continue`, nested loops and `return` inside them, carrying strings, numbers and booleans from one item to the next (`let total = 0; for (const r of rows) total += r.n;`, thousands separators, the largest of a list). Each value is evaluated once, where JavaScript evaluates it, and only on the path that reaches it. `while`, `do…while` and `for…in` loops, assignments to props, refs, `const`s, parameters and fields, `try`, `throw`, `var` and a path that ends without `return` are refused. See the crate's [`script_logic`](https://docs.rs/ferrovue/latest/ferrovue/guide/script_logic/index.html) guide |

package/dist/attrs.d.ts

@@ -1,6 +1,7 @@
-import { type N, type Scope, type Val } from "./model.ts";
+import { type N, type Piece, type Scope, type Val } from "./model.ts";
 import { type ErrorCode } from "./errors.ts";
 import { Emitter } from "./emitter.ts";
+export declare function displayPieces(e: Emitter, pieces: Piece[]): void;
 export declare function display(e: Emitter, v: Val): boolean;
 export declare function interpolate(s: Scope, e: Emitter, v: Val, n: N): void;
 export declare function attrValue(e: Emitter, v: Val): void;

package/dist/attrs.js

@@ -6,23 +6,29 @@ import { CONFIG_FILE } from "./config.js";
 import { ctx } from "./context.js";
 import { describeTy, expr, shown } from "./expr.js";
 import { known, truthy } from "./narrowing.js";
-import { asCow, isTemporary, unquote } from "./strings.js";
-import { atom, bare, condition, ifElse, not, receiver, scrutinee, strArg } from "./parens.js";
+import { asCow, isTemporary, piecesOf, unquote } from "./strings.js";
+import { atom, bare, condition, ifElse, logical, not, receiver, scrutinee, strArg } from "./parens.js";
 import { Emitter } from "./emitter.js";
 import { isDollarAttrs } from "./fallthrough.js";
 import { claim } from "./plugin.js";
 import { classAttr, classPresent, literalClass, maybeEqual, renderClass } from "./classes.js";
 import { mergedStyle, renderStyle, styleAttr } from "./styles.js";
 const NUMBER_BYTES = 6;
-function piecesOf(v) {
-    const f = v.format;
-    if (v.ty.k !== "str" || f === undefined || v.code !== `&*format!(${rustStr(f.text)}, ${f.args.join(", ")})`)
-        return undefined;
-    return f.pieces;
-}
 function emptyTest(v) {
     if (neverEmpty(v.ty))
         return "false";
+    const branches = v.branches;
+    if (branches !== undefined && branches.of === v.code) {
+        const [yes, no] = [emptyTest(branches.yes), emptyTest(branches.no)];
+        const binds = branches.test.startsWith("let ");
+        if (yes === no && !binds)
+            return yes;
+        if (!binds && yes === "false")
+            return logical(not(branches.test), "&&", no);
+        if (!binds && no === "false")
+            return logical(branches.test, "&&", yes);
+        return `if ${branches.test} { ${yes} } else { ${no} }`;
+    }
     const pieces = piecesOf(v);
     if (pieces === undefined)
         return `${receiver(v.code)}.is_empty()`;
@@ -31,17 +37,32 @@ function emptyTest(v) {
         return "false";
     return strs.map((p) => `${receiver(p.code)}.is_empty()`).join(" && ");
 }
+export function displayPieces(e, pieces) {
+    for (const p of pieces) {
+        if (typeof p === "string")
+            e.lit(escapeHtml(p));
+        else if ("shown" in p)
+            e.stmt(`{ use std::fmt::Write as _; let _ = write!(out, "{}", ${p.shown}); }`);
+        else
+            display(e, p);
+    }
+}
 export function display(e, v) {
     const pieces = piecesOf(v);
     if (pieces !== undefined) {
-        for (const p of pieces) {
-            if (typeof p === "string")
-                e.lit(escapeHtml(p));
-            else if ("shown" in p)
-                e.stmt(`{ use std::fmt::Write as _; let _ = write!(out, "{}", ${p.shown}); }`);
-            else
-                display(e, p);
-        }
+        displayPieces(e, pieces);
+        return true;
+    }
+    const branches = v.branches;
+    if (branches !== undefined && branches.of === v.code) {
+        e.open(`if ${branches.test}`);
+        display(e, branches.yes);
+        e.close(" else {");
+        const at = e.lines.length;
+        display(e, branches.no);
+        e.close();
+        if (e.lines.length === at + 1)
+            e.lines.splice(at - 1, 2, e.lines[at - 1].replace(/\} else \{$/, "}"));
         return true;
     }
     if (v.ty.k === "str" && known(v) !== undefined)

package/dist/classes.d.ts

@@ -1,9 +1,10 @@
-import { type N, type Scope } from "./model.ts";
+import { type N, type Scope, type Val } from "./model.ts";
 import { Emitter } from "./emitter.ts";
 export type ClassItem = {
     lit: string;
 } | {
     code: string;
+    join?: Val;
 };
 export declare function classItems(s: Scope, n: N): ClassItem[];
 export declare function renderClass(s: Scope, e: Emitter, n: N, after?: boolean): void;

package/dist/classes.js

@@ -3,10 +3,10 @@ import { directiveOwner, fail, nothing, rustStr, STR } from "./model.js";
 import { expr } from "./expr.js";
 import { choice, cond, known, narrowing, narrowTo, presence, truthy } from "./narrowing.js";
 import { pickPresent } from "./constants.js";
-import { meet, unquote } from "./strings.js";
+import { meet, piecesOf, unquote } from "./strings.js";
 import { atom, bare, condition, logical, not, occurrences, strArg } from "./parens.js";
 import { Emitter } from "./emitter.js";
-import { stringAttr } from "./attrs.js";
+import { displayPieces, stringAttr } from "./attrs.js";
 import { fresh, jsHint } from "./names.js";
 export function classItems(s, n) {
     switch (n.type) {
@@ -79,7 +79,7 @@ export function classItems(s, n) {
     if (literal !== null && literal === literal.trim())
         return [{ lit: literal }];
     if (v.ty.k === "str")
-        return [{ code: v.code }];
+        return [piecesOf(v) === undefined ? { code: v.code } : { code: v.code, join: v }];
     if (v.ty.k === "opt" && v.ty.of.k === "str")
         return [{ code: `${atom(v.code)}.unwrap_or("")` }];
     if (nothing(v.ty))
@@ -118,10 +118,49 @@ export function renderClass(s, e, n, after = false) {
         e.lit((wrote ? " " : "") + escapeHtml(it.lit));
         wrote = true;
     }
-    if (i < items.length) {
-        const rest = items.slice(i).map((it) => ("lit" in it ? rustStr(it.lit) : it.code));
-        e.stmt(`fv::attrs::class_into(out, ${wrote}, &[${rest.join(", ")}]);`);
+    let group = [];
+    let at = null;
+    for (; i < items.length; i++) {
+        const it = items[i];
+        const parts = "join" in it && it.join !== undefined ? trimmedParts(it.join) : null;
+        if (parts === null) {
+            if (!group.length && !wrote && items.slice(i + 1).some((later) => "join" in later && later.join !== undefined)) {
+                at = fresh("at", "class");
+                e.stmt(`let ${at} = out.len();`);
+            }
+            group.push("lit" in it ? rustStr(it.lit) : it.code);
+            continue;
+        }
+        if (group.length)
+            e.stmt(`fv::attrs::class_into(out, ${wrote}, &[${group.join(", ")}]);`);
+        if (wrote)
+            e.lit(" ");
+        else if (group.length && at !== null)
+            e.stmt(`if out.len() != ${at} { out.push(' '); }`);
+        displayPieces(e, parts);
+        [group, at, wrote] = [[], null, true];
+    }
+    if (group.length)
+        e.stmt(`fv::attrs::class_into(out, ${wrote}, &[${group.join(", ")}]);`);
+}
+/** The pieces of a joined class name with the spaces `normalizeClass` trims taken off its ends,
+ * when only its first or last piece may hold them and the join writes a name: null otherwise. */
+function trimmedParts(v) {
+    const pieces = [...piecesOf(v)];
+    const solid = (p, start) => p !== undefined && (typeof p === "string" ? p !== "" && p === (start ? p.trimStart() : p.trimEnd()) : "shown" in p || p.ty.k !== "str");
+    for (const start of [true, false]) {
+        const edge = start ? 0 : pieces.length - 1;
+        const next = start ? 1 : pieces.length - 2;
+        const p = pieces[edge];
+        if (typeof p === "string")
+            pieces[edge] = start ? p.trimStart() : p.trimEnd();
+        if (solid(pieces[edge], start))
+            continue;
+        if (typeof p === "string" || "shown" in p || pieces.length < 2 || !solid(pieces[next], start))
+            return null;
+        pieces[edge] = { code: `fv::strings::js_trim_${start ? "start" : "end"}(${strArg(p.code)})`, ty: STR };
     }
+    return pieces;
 }
 const UNWRITTEN = new Set(["on", "if", "else-if", "else", "for", "slot", "once", "memo", "cloak", "pre"]);
 /** The class list of an element in content Vue renders from virtual nodes, in the order Vue's

package/dist/conditional.js

@@ -2,9 +2,9 @@ import { absence, enumOf, fail, FLOAT, joinAbsence, joinTy, literalsOf, literalT
 import { GenError } from "./errors.js";
 import { annotatedStr, exactlyEnum, intoEnum, knownLiteral } from "./enums.js";
 import { ctx } from "./context.js";
-import { atom, bare, enclosed, occurrences, strArg } from "./parens.js";
+import { atom, bare, condition, enclosed, occurrences, strArg } from "./parens.js";
 import { collected, sliced, typedEmpty, untypedEmpty } from "./lists.js";
-import { asCow, isTemporary, loneOf } from "./strings.js";
+import { asCow, isTemporary, loneOf, piecesOf } from "./strings.js";
 import { asF64, intFromF64, isCast, isNumber } from "./numbers.js";
 import { choice, known, literalNarrowing, narrowTo, presence, truthTested, truthy } from "./narrowing.js";
 import { ownedStruct, ownedStructs } from "./objects.js";
@@ -65,7 +65,14 @@ function branches(s, n, t) {
         a = { ...a, ty: b.ty };
     if (emptyB && a.ty.k === "list")
         b = { ...b, ty: a.ty };
-    return choiceOf({ comp, n, a, b, emptyA, emptyB, choose: chooser(t, p, name, a), lone: loneOf(a, b) });
+    const [x, y] = [a, b];
+    const head = () => {
+        if (!p)
+            return { test: condition(truthy(t)), yes: x, no: y };
+        const [present, absent] = p.negated ? [y, x] : [x, y];
+        return { test: occurrences(present.code, name) ? p.pattern(name) : condition(p.present), yes: present, no: absent };
+    };
+    return choiceOf({ comp, n, a, b, emptyA, emptyB, choose: chooser(t, p, name, a), head, lone: loneOf(a, b) });
 }
 function chooser(t, p, name, a) {
     const second = (code) => (a.ty.k === "str" ? strArg(code) : bare(code));
@@ -90,7 +97,9 @@ function choiceOf(c) {
     if (owned !== null)
         return owned;
     if (sameTy(a.ty, b.ty) && a.ty.k === "str" && (isTemporary(a) || isTemporary(b))) {
-        return { code: `&*(${choose(asCow(a), asCow(b))})`, ty: STR, ...lone };
+        const code = `&*(${choose(asCow(a), asCow(b))})`;
+        const joins = (v) => piecesOf(v) !== undefined || v.branches?.of === v.code;
+        return { code, ty: STR, ...lone, ...(joins(a) || joins(b) ? { branches: { of: code, ...c.head() } } : {}) };
     }
     if (sameTy(a.ty, b.ty) && a.ty.k === "list" && a.ty.of.k !== "undef")
         return listChoice(c);

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-import { type Component, type N, type Scope, type Val } from "./model.ts";
+import { type Component, type Fn, type N, type Scope, type Val } from "./model.ts";
 export type Const = {
     k: "scalar";
     js: Scalar;
@@ -25,10 +25,30 @@ 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>;
+/** A name a `.ts` file exports: one of its own, by its local name, or one of another file's, by the
+ * name that file exports it as (`null` for a module that is no `.ts` file of the project, or for a
+ * namespace, `export * as ns from`). */
+export type Export = {
+    local: string;
+} | {
+    file: string | null;
+    name: string | null;
+};
+/** What a `.ts` file exports: its names, and the files whose names `export * from` passes on. */
+export interface Exports {
+    names: Map<string, Export>;
+    stars: (string | null)[];
+}
+/** The names a `.ts` file exports: by `export const`, `export function`, `export enum`,
+ * `export { a, b as c }`, `export default a`, and from other files by `export { a } from` and `export * from`. */
+export declare function exportsOf(rel: string, body: N[]): Exports;
+/** The constant or enum a `.ts` file exports as `name`. */
+export declare function exportedConst(file: string, name: string): Declared | undefined;
+/** The function a `.ts` file exports as `name`. */
+export declare function exportedFunction(file: string, name: string): Fn | undefined;
 /** 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. */

package/dist/constants.js

@@ -2,7 +2,8 @@ import { absence, blankComponent, BOOL, distinctFields, enumOf, enumTy, fail, FL
 import { GenError } from "./errors.js";
 import { aliasEnum, knownLiteral, matchOver, overVariants } from "./enums.js";
 const TYPES_HOME = blankComponent("types", "types", "types");
-import { ONE_NOTHING, reachType, tyOfTs } from "./typescript.js";
+import { ONE_NOTHING, reachType, readTypeFile, tyOfTs } from "./typescript.js";
+import { resolveImport } from "./resolve.js";
 import { ctx } from "./context.js";
 import { asF64, exactPower, numberVal } from "./numbers.js";
 import { describeTy, expr } from "./expr.js";
@@ -18,19 +19,100 @@ let enumScope = null;
 export function declareConsts(home, body) {
     const found = new Map();
     for (const st of body) {
-        const exported = st.type === "ExportNamedDeclaration";
-        const d = exported ? st.declaration : st;
+        const d = st.type === "ExportNamedDeclaration" ? st.declaration : st;
         if (d?.type === "TSEnumDeclaration")
-            found.set(d.id.name, { node: d, home, exported });
+            found.set(d.id.name, { node: d, home });
         if (d?.type === "VariableDeclaration" && d.kind === "const") {
             for (const v of d.declarations)
                 if (v.id.type === "Identifier" && v.init)
-                    found.set(v.id.name, { node: v, home, exported });
+                    found.set(v.id.name, { node: v, home });
         }
     }
     files.set(home, found);
     return found;
 }
+/** The names a `.ts` file exports: by `export const`, `export function`, `export enum`,
+ * `export { a, b as c }`, `export default a`, and from other files by `export { a } from` and `export * from`. */
+export function exportsOf(rel, body) {
+    const names = new Map();
+    const stars = [];
+    const nameOf = (n) => n.name ?? n.value;
+    for (const st of body) {
+        if (st.type === "ExportDefaultDeclaration") {
+            const d = st.declaration;
+            names.set("default", { local: d.type === "Identifier" ? d.name : "default" });
+        }
+        if (st.exportKind === "type")
+            continue;
+        if (st.type === "ExportAllDeclaration") {
+            const file = resolveImport(rel, st.source.value);
+            if (st.exported)
+                names.set(nameOf(st.exported), { file: null, name: null });
+            else
+                stars.push(file);
+        }
+        if (st.type !== "ExportNamedDeclaration")
+            continue;
+        const d = st.declaration;
+        if (d?.type === "VariableDeclaration")
+            for (const v of d.declarations)
+                if (v.id.type === "Identifier")
+                    names.set(v.id.name, { local: v.id.name });
+        if (d?.id?.type === "Identifier")
+            names.set(d.id.name, { local: d.id.name });
+        if (d)
+            continue;
+        const from = st.source ? resolveImport(rel, st.source.value) : undefined;
+        for (const sp of st.specifiers) {
+            if (sp.exportKind === "type")
+                continue;
+            const as = nameOf(sp.exported);
+            if (sp.type === "ExportNamespaceSpecifier")
+                names.set(as, { file: null, name: null });
+            else if (sp.type === "ExportSpecifier")
+                names.set(as, from === undefined ? { local: sp.local.name } : { file: from, name: nameOf(sp.local) });
+        }
+    }
+    return { names, stars };
+}
+/** The file and local name of what a `.ts` file exports as `name`, followed through `export … from`
+ * and `export * from`; `undefined` when nothing is exported by that name, or two `export *` give it. */
+function exportOrigin(file, name, seen = new Set()) {
+    const key = `${file}\0${name}`;
+    if (seen.has(key))
+        return undefined;
+    seen.add(key);
+    readTypeFile(file);
+    const exports = ctx.tsModules.get(file)?.exports;
+    const e = exports?.names.get(name);
+    if (e !== undefined) {
+        if ("local" in e)
+            return { file, local: e.local };
+        return e.file === null || e.name === null ? undefined : exportOrigin(e.file, e.name, seen);
+    }
+    if (name === "default")
+        return undefined;
+    let found;
+    for (const star of exports?.stars ?? []) {
+        const o = star === null ? undefined : exportOrigin(star, name, new Set(seen));
+        if (o === undefined)
+            continue;
+        if (found !== undefined && (found.file !== o.file || found.local !== o.local))
+            return undefined;
+        found = o;
+    }
+    return found;
+}
+/** The constant or enum a `.ts` file exports as `name`. */
+export function exportedConst(file, name) {
+    const o = exportOrigin(file, name);
+    return o === undefined ? undefined : ctx.constDecls.get(o.file)?.get(o.local);
+}
+/** The function a `.ts` file exports as `name`. */
+export function exportedFunction(file, name) {
+    const o = exportOrigin(file, name);
+    return o === undefined ? undefined : ctx.tsModules.get(o.file)?.functions.get(o.local);
+}
 /** What a declared constant or enum stands for, evaluated once. */
 export function constOfDecl(d) {
     const done = evaluated.get(d.node);

package/dist/context.d.ts

@@ -1,6 +1,6 @@
 import type { Config, TypeName } from "./config.ts";
 import type { Plugin } from "./plugin.ts";
-import type { Declared } from "./constants.ts";
+import type { Declared, Exports } from "./constants.ts";
 import type { Alias } from "./compiler.ts";
 import type { TsProject } from "./resolve.ts";
 import { type Component, type EnumDef, type Fn, type N, type Struct, type Ty } from "./model.ts";
@@ -51,10 +51,8 @@ export declare const ctx: {
     tsModules: Map<string, {
         home: Component;
         body: N[];
-        functions: Map<string, {
-            fn: Fn;
-            exported: boolean;
-        }>;
+        functions: Map<string, Fn>;
+        exports: Exports;
     }>;
     typeConsts: Map<string, {
         of: unknown;

package/dist/dynamic.js

@@ -4,6 +4,7 @@ import { basename } from "node:path";
 import { camelize, directiveOwner, fail, isAttribute, literalsOf, placeOf, rustStr, templateAst } from "./model.js";
 import { GenError } from "./errors.js";
 import { ctx } from "./context.js";
+import { exportedConst } from "./constants.js";
 import { matchOver } from "./enums.js";
 import { expr } from "./expr.js";
 import { cond, known } from "./narrowing.js";
@@ -208,8 +209,8 @@ function tableOf(s, n) {
         if (!sp)
             continue;
         const file = resolveImport(s.comp.file, st.source.value);
-        const d = file === null ? undefined : ctx.constDecls.get(file)?.get(sp.imported.name ?? sp.imported.value);
-        if (!d?.exported || d.node.type !== "VariableDeclarator")
+        const d = file === null ? undefined : exportedConst(file, sp.imported.name ?? sp.imported.value);
+        if (!d || d.node.type !== "VariableDeclarator")
             return null;
         const entries = objectEntries(d.home, name, d.node.init);
         if (!entries)

package/dist/functions.d.ts

@@ -5,10 +5,7 @@ export declare function functionOf(st: N): {
     node: N;
 } | null;
 /** The functions a `.ts` file declares at its top level, exported or not. */
-export declare function declareFunctions(home: Component, body: N[], file: string): Map<string, {
-    fn: Fn;
-    exported: boolean;
-}>;
+export declare function declareFunctions(home: Component, body: N[], file: string): Map<string, Fn>;
 /** A call of a function the server translates: its arguments evaluated in order at the call, each
  * bound once, then its body, with JavaScript's defaults for what is not passed. */
 export declare function callFunction(s: Scope, name: string, fn: Fn, args: N[], n: N): Val;

package/dist/functions.js

@@ -1,6 +1,6 @@
 import { fail, placeOf } from "./model.js";
 import { GenError } from "./errors.js";
-import { constOfDecl } from "./constants.js";
+import { constOfDecl, exportedConst, exportedFunction } from "./constants.js";
 import { ctx } from "./context.js";
 import { expr, typedBy } from "./expr.js";
 import { bodyExpr, bound, destructured } from "./blocks.js";
@@ -21,16 +21,15 @@ export function declareFunctions(home, body, file) {
     const found = new Map();
     for (const st of body) {
         if (st.type === "ExportDefaultDeclaration" && (st.declaration.type === "FunctionDeclaration" || FUNCTION_INITS.has(st.declaration.type))) {
-            found.set("default", { fn: { name: st.declaration.id?.name ?? "default", node: st.declaration, home, file }, exported: true });
+            found.set("default", { name: st.declaration.id?.name ?? "default", node: st.declaration, home, file });
             continue;
         }
-        const exported = st.type === "ExportNamedDeclaration";
-        const d = exported ? st.declaration : st;
+        const d = st.type === "ExportNamedDeclaration" ? st.declaration : st;
         const decls = d?.type === "VariableDeclaration" && d.kind === "const" ? d.declarations : [d];
         for (const x of decls) {
             const f = functionOf(x);
             if (f)
-                found.set(f.name, { fn: { name: f.name, node: f.node, home, file }, exported });
+                found.set(f.name, { name: f.name, node: f.node, home, file });
         }
     }
     return found;
@@ -54,7 +53,7 @@ function moduleOf(file) {
             m.refusedBy.set(local, e);
         }
     };
-    for (const [name, { fn }] of read.functions) {
+    for (const [name, fn] of read.functions) {
         m.functions.set(name, fn);
         m.clientOnly.set(name, `it is a function of ${read.home.file}, which a template or a function may call, but not read as a value`);
     }
@@ -72,11 +71,11 @@ function moduleOf(file) {
             if (sp.importKind === "type")
                 continue;
             const imported = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : "default";
-            const f = other?.functions.get(imported);
-            const d = from !== null ? ctx.constDecls.get(from)?.get(imported) : undefined;
-            if (f?.exported)
-                m.functions.set(sp.local.name, f.fn);
-            else if (d?.exported && sp.type === "ImportSpecifier")
+            const f = from !== null ? exportedFunction(from, imported) : undefined;
+            const d = from !== null ? exportedConst(from, imported) : undefined;
+            if (f)
+                m.functions.set(sp.local.name, f);
+            else if (d && sp.type === "ImportSpecifier")
                 constant(sp.local.name, d, `it is imported from ${other.home.file}`);
             else
                 m.clientOnly.set(sp.local.name, `it is imported from \`${st.source.value}\`, which the server does not run`);

package/dist/link-routes.d.ts

@@ -20,7 +20,7 @@ export interface LinkRoutesOptions {
 /** A Vue plugin giving `<RouterLink>` and `useRoute()` the page's route, with no router. */
 export interface LinkRoutes {
     /** Registers vue-router's `<RouterLink>` and provides the page's route to it, to `useRoute()`
-     * and to `$route`. */
+     * and to `$route`, and the small router to `useRouter()` and `$router`. */
     install(app: App): void;
     /** `to` resolved as vue-router's `router.resolve(to)` resolves it on this page. */
     resolve(to: RouteLocationRaw): RouteLocationResolved;

package/dist/link-routes.js

@@ -427,7 +427,8 @@ export function linkRoutes(routes, options) {
         resolve: resolve,
         install(app) {
             app.component("RouterLink", RouterLink);
-            app.config.globalProperties.$route = current;
+            app.config.globalProperties.$router = router;
+            Object.defineProperty(app.config.globalProperties, "$route", { enumerable: true, get: () => router.currentRoute.value });
             app.provide(routerKey, router);
             app.provide(routeLocationKey, reactive);
         },

package/dist/model.d.ts

@@ -82,6 +82,14 @@ export interface Val {
         args: string[];
         pieces: Piece[];
     };
+    /** For a string `?:` chooses where a branch is a join: the test the Rust `if` takes and the
+     * value of each branch, while `code` is `of`. */
+    branches?: {
+        of: string;
+        test: string;
+        yes: Val;
+        no: Val;
+    };
     owned?: true;
     /** For a value of a generated enum, the Rust expression of the enum (an `Option` of it when the
      * value is optional), where `code` is its string. */

package/dist/plugins/loaders.js

@@ -1,7 +1,7 @@
 import { absence, distinctFields, enumOf, fail, nothing, rustStr, sameTy, snake } from "../model.js";
 import { GenError } from "../errors.js";
 import { ctx } from "../context.js";
-import {} from "../constants.js";
+import { exportedConst } from "../constants.js";
 import { resolveImport } from "../resolve.js";
 import { bareDates, datePlan, lookupStruct, markHome, readTypeFile, tyOfTs } from "../typescript.js";
 import { coerce, describeTy, expr, fieldVal } from "../expr.js";
@@ -368,12 +368,11 @@ export const loaders = {
         if (file === null)
             return false;
         readTypeFile(file);
-        const decls = ctx.constDecls.get(file);
         for (const sp of st.specifiers) {
             if (sp.type !== "ImportSpecifier" || sp.importKind === "type")
                 continue;
-            const d = decls?.get(sp.imported.name ?? sp.imported.value);
-            if (d?.exported && isLoader(d, file))
+            const d = exportedConst(file, sp.imported.name ?? sp.imported.value);
+            if (d && isLoader(d, file))
                 scopeOf(loaders, s).locals.set(sp.local.name, { d, file });
         }
         return false;

package/dist/plugins/provide.js

@@ -1,6 +1,6 @@
 import { absence, blankComponent, camelize, fail, nothing, opt, sameTy, snake } from "../model.js";
 import { ctx } from "../context.js";
-import {} from "../constants.js";
+import { exportedConst } from "../constants.js";
 import { lookupStruct, markHome, refuseDates, tyOfTs } from "../typescript.js";
 import { resolveImport } from "../resolve.js";
 import { describeTy, expr } from "../expr.js";
@@ -8,7 +8,6 @@ import { slotFieldBorrows, slotFieldTy, slotFieldValue } from "../slots.js";
 import { fieldInit, ownInto } from "../children.js";
 import { setupSource } from "../script.js";
 import { header } from "../rust.js";
-import { relativePath } from "../paths.js";
 import { heldStr, isTemporary } from "../strings.js";
 import { runOf, scopeOf, slotFieldsOf } from "../plugin.js";
 const REF_CALLS = new Set(["ref", "shallowRef", "computed", "toRef", "customRef", "defineModel"]);
@@ -105,10 +104,11 @@ function keyOf(comp, n, script) {
     if (n?.type === "Identifier") {
         const imported = importOf(script, n.name);
         const file = imported ? resolveImport(comp.file, imported.from) : null;
-        const decl = file !== null ? ctx.constDecls.get(file)?.get(imported.name) : undefined;
-        if (decl?.exported && decl.node.type === "VariableDeclarator" && symbolInit(decl.node.init)) {
-            const rel = relativePath(ctx.rootDir, file);
-            return keyNamed(comp, n, `${rel}#${imported.name}`, `\`${imported.name}\``, rel, snake(imported.name), () => declaredOf(decl));
+        const decl = file !== null ? exportedConst(file, imported.name) : undefined;
+        if (decl?.node.type === "VariableDeclarator" && symbolInit(decl.node.init)) {
+            const rel = decl.home.file;
+            const own = decl.node.id.name;
+            return keyNamed(comp, n, `${rel}#${own}`, `\`${own}\``, rel, snake(own), () => declaredOf(decl));
         }
     }
     return fail(comp, "FV1601", "an injection key is a string literal, or a `Symbol` exported from one of the project's `.ts` files: `export const ThemeKey: InjectionKey<string> = Symbol()`", n);

package/dist/script.js

@@ -5,7 +5,7 @@ import { CONFIG_FILE } from "./config.js";
 import { ctx } from "./context.js";
 import { definePropsType, readTypeFile, refuseDates, tyOfTs } from "./typescript.js";
 import { resolveImport } from "./resolve.js";
-import { constOfDecl, declareConsts } from "./constants.js";
+import { constOfDecl, declareConsts, exportedConst, exportedFunction } from "./constants.js";
 import { localTy } from "./rust.js";
 import { expr, fieldVal, typedBy } from "./expr.js";
 import { atom, occurrences } from "./parens.js";
@@ -278,29 +278,27 @@ function importedKey(sp) {
         return sp.imported.name ?? sp.imported.value;
     return sp.type === "ImportDefaultSpecifier" ? "default" : undefined;
 }
-function importedValue(scope, sp, decls, fns) {
+function importedValue(scope, sp, file) {
     const key = importedKey(sp);
     if (key === undefined)
         return;
-    const f = fns?.get(key);
-    if (f?.exported) {
-        scope.functions.set(sp.local.name, f.fn);
-        scope.clientOnly.set(sp.local.name, `it is a function imported from ${f.fn.home.file}, which the template and a \`computed\` may call, and only an event handler may name without calling it`);
+    const f = exportedFunction(file, key);
+    if (f) {
+        scope.functions.set(sp.local.name, f);
+        scope.clientOnly.set(sp.local.name, `it is a function imported from ${f.home.file}, which the template and a \`computed\` may call, and only an event handler may name without calling it`);
         return;
     }
-    const d = decls.get(key);
-    if (d?.exported)
+    const d = exportedConst(file, key);
+    if (d)
         evaluable(scope, sp.local.name, d, `it is imported from ${d.home.file}, where it is not a constant the compiler evaluates`);
 }
 function moduleValues(scope, st, file) {
     if (st.specifiers.some((sp) => sp.type === "ImportDefaultSpecifier"))
         readTypeFile(file);
-    const decls = ctx.constDecls.get(file);
-    if (decls === undefined)
+    if (!ctx.constDecls.has(file))
         return;
-    const fns = ctx.tsModules.get(file)?.functions;
     for (const sp of st.specifiers)
-        importedValue(scope, sp, decls, fns);
+        importedValue(scope, sp, file);
 }
 function moduleImport(scope, st, from) {
     const typeOnly = st.importKind === "type";

package/dist/strings.d.ts

@@ -1,4 +1,4 @@
-import { type Component, type N, type Scope, type Ty, type Val } from "./model.ts";
+import { type Component, type N, type Piece, type Scope, type Ty, type Val } from "./model.ts";
 import type { ErrorCode } from "./errors.ts";
 /** \`/pattern/flags.test(s)\` of a regular expression literal. */
 export declare function regexTest(s: Scope, re: N, args: N[], n: N): Val;
@@ -25,6 +25,8 @@ export declare function stringOf(comp: Component, v: Val, n: N, what: string, co
 /** Whether every character `ty` may write as text is ASCII: a number, a boolean, an absent value
  * (`undefined`, `null`), a string known to be ASCII, or a list of them. */
 export declare function writesAscii(ty: Ty): boolean;
+/** The pieces of a string `format!` builds, while its code is that `format!`. */
+export declare function piecesOf(v: Val): Piece[] | undefined;
 export declare function formatted(comp: Component, given: (string | Val)[], n: N, what: string): Val;
 type Surrogates = "none" | "all" | "some";
 interface RegexPiece {

package/dist/strings.js

@@ -190,6 +190,13 @@ export function writesAscii(ty) {
 function mayBeEmpty(v) {
     return v.ty.k === "str" && !nonEmptyLiteral(v);
 }
+/** The pieces of a string `format!` builds, while its code is that `format!`. */
+export function piecesOf(v) {
+    const f = v.format;
+    if (v.ty.k !== "str" || f === undefined || v.code !== `&*format!(${rustStr(f.text)}, ${f.args.join(", ")})`)
+        return undefined;
+    return f.pieces;
+}
 export function formatted(comp, given, n, what) {
     let fmt = "";
     const args = [];

package/dist/typescript.js

@@ -9,7 +9,7 @@ import { CONFIG_FILE, TYPES_MODULE } from "./config.js";
 import { ctx, INLINE_HTML } from "./context.js";
 import { childOf } from "./expr.js";
 import { claim } from "./plugin.js";
-import { declareConsts, enumType } from "./constants.js";
+import { declareConsts, enumType, exportsOf } from "./constants.js";
 import { parseTs } from "./files.js";
 import { declareFunctions } from "./functions.js";
 import { refuseUnresolved, resolveImport } from "./resolve.js";
@@ -360,7 +360,7 @@ export function readTypeFile(file) {
     tagAst(body, "source");
     typesImports(home, body);
     ctx.constDecls.set(file, declareConsts(home, body));
-    ctx.tsModules.set(file, { home, body, functions: declareFunctions(home, body, file) });
+    ctx.tsModules.set(file, { home, body, functions: declareFunctions(home, body, file), exports: exportsOf(rel, body) });
     for (const d of declareTypes(home, body, new Map(), ctx.typeAliases)) {
         const known = ctx.typeDecls.get(d.name);
         if (known === undefined && ctx.typeStructs.has(d.name))
@@ -378,7 +378,8 @@ export function readTypeFile(file) {
         ctx.typeFiles.set(d.name, rel);
     }
     for (const st of body) {
-        if (st.type !== "ImportDeclaration" || st.source.value === TYPES_MODULE || st.source.value.endsWith(".vue"))
+        const forwards = (st.type === "ExportNamedDeclaration" && st.source) || st.type === "ExportAllDeclaration";
+        if ((st.type !== "ImportDeclaration" && !forwards) || st.source.value === TYPES_MODULE || st.source.value.endsWith(".vue"))
             continue;
         const imported = resolveImport(rel, st.source.value);
         if (imported !== null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ferrovue",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "Vue templates compiled to Rust render functions: server-side rendering with no JavaScript at run time",
   "license": "MIT OR Apache-2.0",
   "repository": {