ferrovue 0.3.0 → 0.4.0

package/dist/context.d.ts

@@ -1,5 +1,5 @@
-import type { I18nSetup } from "./i18n.ts";
-import { type Component, type N, type Struct, type Ty } from "./model.ts";
+import type { Plugin } from "./plugin.ts";
+import { type Component, type Struct, type Ty } from "./model.ts";
 /** A type a helper takes or returns, as the configuration spells it. */
 export type TypeName = "string" | "string?" | "int" | "int?" | "float" | "float?" | "bool";
 /** A function a template may call, and the Rust function that is its twin. */
@@ -64,48 +64,9 @@ export declare const CONFIG_FILE = "ferrovue.config.json";
 /** Read the project's configuration. */
 export declare function loadConfig(root: string, configPath?: string): Config;
 export declare function tyOfName(name: TypeName): Ty;
-/** A route as the routes file lists it: a vue-router path, and the name it may have. */
-export interface RouteDef {
-    /** The path as written: relative to the parent's unless it starts with \`/\`. */
-    path: string;
-    name?: string;
-    /** The routes nested in it. */
-    children?: RouteDef[];
-    /** The path with its ancestors', as vue-router normalises it. */
-    fullPath: string;
-}
-/** Every route, nested ones included, parents first. */
-export declare function allRoutes(routes: RouteDef[]): RouteDef[];
-/** A getter: the parameter naming the state (an option store's), and the expression it returns.
- * \`setup\` marks a setup store's \`computed\`, which reads the state's refs and the other getters by
- * name, through \`.value\`. */
-export interface StoreGetter {
-    param: string | null;
-    body: N;
-    file: string;
-    setup?: true;
-}
-/** A Pinia option store: `export const usePrefs = defineStore("prefs", { state: (): PrefsState => ... })`. */
-export interface Store {
-    /** `usePrefs` */
-    hook: string;
-    /** `prefs`: its key in `pinia.state.value`. */
-    id: string;
-    /** `prefs`: its field in the generated `Stores`. */
-    field: string;
-    /** `PrefsState`: the interface its state is. */
-    state: string;
-    /** The file, without its extension, as an import names it once resolved. */
-    module: string;
-    /** Its getters: name → the parameter that names the state, and the expression returned. */
-    getters: Map<string, StoreGetter>;
-}
 /** Where `TrustedHtml` comes from. Only that import names the type `v-html` will write raw. */
 export declare const TYPES_MODULE = "ferrovue/types";
-/** What the configuration being compiled says, and what has been read so far: set up by
- * `generate()` at the start of each run, which is synchronous, so one run never sees another's. */
 export declare const ctx: {
-    /** The helpers of the configuration being compiled: name → Rust twin, typed. */
     helpers: Record<string, {
         rust: string;
         params: Ty[];
@@ -114,38 +75,15 @@ export declare const ctx: {
     }>;
     helperModule: string | null;
     trustedHtml: string | null;
-    /** Custom directives declared to render nothing on the server. */
     clientDirectives: Set<string>;
-    /** The configured routes, when there are any. */
-    routes: RouteDef[] | null;
-    /** The history's base, and the class names active links take, from the configured router. */
-    routerBase: string;
-    linkActive: string;
-    linkExactActive: string;
-    /** The configured stores, by hook name, and every interface their files declare. */
-    stores: Map<string, Store>;
-    storeStructs: Map<string, Struct>;
-    /** The store file each of those interfaces is declared in. */
-    storeFiles: Map<string, string>;
-    /** The project root, for resolving a component's imports. */
+    plugins: readonly Plugin[];
+    runs: Map<Plugin<unknown, unknown>, unknown>;
     rootDir: string;
-    /** Interfaces and object types declared in shared `.ts` files that components import, and type
-     * aliases there; the file each comes from. They are written once, to `types.rs`. */
     typeStructs: Map<string, Struct>;
     typeAliases: Map<string, any>;
     typeFiles: Map<string, string>;
-    /** The shared files read so far. */
     typeRead: Set<string>;
-    /** Every component being compiled, by name, for a type that names another one's props. */
     components: Map<string, Component>;
-    /** Numbers the bindings narrowing introduces, restarted per component so that a file's text
-     * depends on its own source alone. */
     narrowCount: number;
-    /** The directory the components being compiled come from, for the generated headers. */
     componentsDir: string;
-    /** The configured locales and their messages, when there are any. */
-    i18n: I18nSetup | null;
-    /** How scope ids are computed, and the directory a component's path is hashed from. */
-    scopeId: ScopeIdMode;
-    viteRoot: string;
 };

package/dist/context.js

@@ -1,4 +1,3 @@
-/* The project's configuration, and the state one `generate()` run builds up. */
 import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { BOOL, FLOAT, GenError, INT, opt, STR } from "./model.js";
@@ -52,51 +51,21 @@ export function tyOfName(name) {
             throw new GenError(`unknown helper type \`${String(name)}\``);
     }
 }
-/** Every route, nested ones included, parents first. */
-export function allRoutes(routes) {
-    return routes.flatMap((r) => [r, ...allRoutes(r.children ?? [])]);
-}
 /** Where `TrustedHtml` comes from. Only that import names the type `v-html` will write raw. */
 export const TYPES_MODULE = "ferrovue/types";
-/** What the configuration being compiled says, and what has been read so far: set up by
- * `generate()` at the start of each run, which is synchronous, so one run never sees another's. */
 export const ctx = {
-    /** The helpers of the configuration being compiled: name → Rust twin, typed. */
     helpers: {},
     helperModule: null,
     trustedHtml: null,
-    /** Custom directives declared to render nothing on the server. */
     clientDirectives: new Set(),
-    /** The configured routes, when there are any. */
-    routes: null,
-    /** The history's base, and the class names active links take, from the configured router. */
-    routerBase: "",
-    linkActive: "router-link-active",
-    linkExactActive: "router-link-exact-active",
-    /** The configured stores, by hook name, and every interface their files declare. */
-    stores: new Map(),
-    storeStructs: new Map(),
-    /** The store file each of those interfaces is declared in. */
-    storeFiles: new Map(),
-    /** The project root, for resolving a component's imports. */
+    plugins: [],
+    runs: new Map(),
     rootDir: "",
-    /** Interfaces and object types declared in shared `.ts` files that components import, and type
-     * aliases there; the file each comes from. They are written once, to `types.rs`. */
     typeStructs: new Map(),
     typeAliases: new Map(),
     typeFiles: new Map(),
-    /** The shared files read so far. */
     typeRead: new Set(),
-    /** Every component being compiled, by name, for a type that names another one's props. */
     components: new Map(),
-    /** Numbers the bindings narrowing introduces, restarted per component so that a file's text
-     * depends on its own source alone. */
     narrowCount: 0,
-    /** The directory the components being compiled come from, for the generated headers. */
     componentsDir: "",
-    /** The configured locales and their messages, when there are any. */
-    i18n: null,
-    /** How scope ids are computed, and the directory a component's path is hashed from. */
-    scopeId: "filepath-source",
-    viteRoot: "",
 };

package/dist/diff.d.ts

@@ -1,4 +1 @@
-/** A unified diff of a module, as \`diff -u\` writes it, with three lines of context: what
- * \`ferrovue\` would write against what is committed. Lines the two share at the start and the end
- * are set aside first, so that a module changed in one place is compared over that place alone. */
 export declare function unifiedDiff(path: string, before: string, after: string): string;

package/dist/diff.js

@@ -1,7 +1,3 @@
-/* `ferrovue --check --diff`: what would be written, against what is committed. */
-/** A unified diff of a module, as \`diff -u\` writes it, with three lines of context: what
- * \`ferrovue\` would write against what is committed. Lines the two share at the start and the end
- * are set aside first, so that a module changed in one place is compared over that place alone. */
 export function unifiedDiff(path, before, after) {
     const lines = (text) => (text === "" ? [] : text.replace(/\n$/, "").split("\n"));
     const a = lines(before);
@@ -16,7 +12,6 @@ export function unifiedDiff(path, before, after) {
     const midB = b.slice(head, b.length - tail);
     if (!midA.length && !midB.length)
         return "";
-    // The longest common subsequence of the middle, by dynamic programming over its lines.
     const lcs = Array.from({ length: midA.length + 1 }, () => new Uint32Array(midB.length + 1));
     for (let i = midA.length - 1; i >= 0; i--) {
         for (let j = midB.length - 1; j >= 0; j--) {
@@ -26,7 +21,6 @@ export function unifiedDiff(path, before, after) {
     const edits = a.slice(0, head).map((text) => ({ op: " ", text }));
     let i = 0;
     let j = 0;
-    // Of two ways to keep as many lines, a removal comes first, as `diff -u` orders them.
     while (i < midA.length || j < midB.length) {
         if (i < midA.length && j < midB.length && midA[i] === midB[j]) {
             edits.push({ op: " ", text: midA[i++] });
@@ -38,7 +32,6 @@ export function unifiedDiff(path, before, after) {
             edits.push({ op: "-", text: midA[i++] });
     }
     edits.push(...a.slice(a.length - tail).map((text) => ({ op: " ", text })));
-    // Each changed line with three lines around it, runs that touch joined into one hunk.
     const CONTEXT = 3;
     const hunks = [];
     edits.forEach((e, k) => {
@@ -53,7 +46,6 @@ export function unifiedDiff(path, before, after) {
             hunks.push([from, to]);
     });
     const out = [`--- ${a.length ? `a/${path}` : "/dev/null"}`, `+++ ${b.length ? `b/${path}` : "/dev/null"}`];
-    // Line numbers in each file where every edit starts.
     let lineA = 1;
     let lineB = 1;
     const at = edits.map((e) => {
@@ -68,7 +60,6 @@ export function unifiedDiff(path, before, after) {
         const span = edits.slice(from, to + 1);
         const countA = span.filter((e) => e.op !== "+").length;
         const countB = span.filter((e) => e.op !== "-").length;
-        // An empty side is numbered by the line before it, as `diff -u` numbers it.
         const startA = countA ? at[from][0] : at[from][0] - 1;
         const startB = countB ? at[from][1] : at[from][1] - 1;
         out.push(`@@ -${startA},${countA} +${startB},${countB} @@`, ...span.map((e) => `${e.op}${e.text}`));

package/dist/emitter.d.ts

@@ -1,23 +1,15 @@
-/** Statements, with adjacent literal pushes merged into one `push_str`. */
 export declare class Emitter {
     lines: string[];
-    /** Bytes of markup written once per render, part of what `render` reserves up front: the literal
-     * markup, and what the numbers written at run time are expected to take. */
     literalBytes: number;
-    /** Rust expressions for the rest of the reservation: a loop's markup once per item. */
     perItem: string[];
     private pending;
     private depth;
     lit(s: string): void;
-    /** `bytes` more expected of a value written at run time. */
     expect(bytes: number): void;
     stmt(code: string): void;
     open(code: string): void;
     close(tail?: string): void;
-    /** Whether the lines from \`from\` on read \`name\`. Literals are skipped, so markup that happens to
-     * spell the name does not count, and so are fields of that name. */
     reads(name: string, from: number): boolean;
-    /** Replace \`from\` with \`to\` in line \`index\`: an unused binding renamed to \`_\`. */
     replace(index: number, from: string, to: string): void;
     flush(): void;
 }

package/dist/emitter.js

@@ -1,13 +1,8 @@
-/* The Rust statements a render is written as. */
 import { rustChar, rustStr } from "./model.js";
 import { occurrences } from "./parens.js";
-/** Statements, with adjacent literal pushes merged into one `push_str`. */
 export class Emitter {
     lines = [];
-    /** Bytes of markup written once per render, part of what `render` reserves up front: the literal
-     * markup, and what the numbers written at run time are expected to take. */
     literalBytes = 0;
-    /** Rust expressions for the rest of the reservation: a loop's markup once per item. */
     perItem = [];
     pending = "";
     depth = 1;
@@ -15,7 +10,6 @@ export class Emitter {
         this.pending += s;
         this.literalBytes += Buffer.byteLength(s);
     }
-    /** `bytes` more expected of a value written at run time. */
     expect(bytes) {
         this.literalBytes += bytes;
     }
@@ -31,19 +25,14 @@ export class Emitter {
         this.flush();
         this.depth--;
         this.lines.push("    ".repeat(this.depth) + "}" + tail);
-        // `} else {` closes one block and opens the next.
         if (tail.endsWith("{"))
             this.depth++;
     }
-    /** Whether the lines from \`from\` on read \`name\`. Literals are skipped, so markup that happens to
-     * spell the name does not count, and so are fields of that name. */
     reads(name, from) {
         this.flush();
         return occurrences(this.lines.slice(from).join("\n"), name) > 0;
     }
-    /** Replace \`from\` with \`to\` in line \`index\`: an unused binding renamed to \`_\`. */
     replace(index, from, to) {
-        // A function, so a `$&` or `$'` in the generated text is not read as a replacement pattern.
         this.lines[index] = this.lines[index].replace(from, () => to);
     }
     flush() {
@@ -51,7 +40,6 @@ export class Emitter {
             return;
         const text = this.pending;
         this.pending = "";
-        // One character is pushed as a `char`.
         const push = /^.$/su.test(text) ? `out.push(${rustChar(text)});` : `out.push_str(${rustStr(text)});`;
         this.lines.push("    ".repeat(this.depth) + push);
     }

package/dist/expr.d.ts

@@ -1,76 +1,6 @@
 import { type Component, type N, type Scope, type Ty, type Val } from "./model.ts";
-/** The refusal for a string that may hold half of a surrogate pair, used where that half matters. */
-export declare function lonely(what: string): string;
-/** Two strings meeting, where a half of a surrogate pair — which ferrovue holds as U+FFFD — would
- * change the result:
- * - `equal`: two halves may differ, and a half never equals a literal U+FFFD;
- * - `order`: a half orders as a surrogate, below U+E000, where U+FFFD orders above — the same only
- *   against a literal of characters below U+D800, which both order after;
- * - `search`: a half searched for (`b`) matches half of a whole pair in `a`;
- * - `join`: two halves side by side join into one character.
- * A string holding U+FFFD in the data still equals, or is found in, a half: README, "Strings". */
-export declare function meet(comp: Component, a: Val, b: Val, what: string, n: N, how: "equal" | "order" | "search" | "join"): void;
-/** Whether a string expression borrows from a temporary it builds — \`&*format!(…)\`, a call that
- * returns a \`String\` — rather than from the props or the state. Such a borrow ends with the block
- * it is in, so a branch of \`?:\` or \`||\` must hand back the string itself. */
-export declare function isTemporary(v: Val): boolean;
-/** A string as a \`Cow\`: borrowed when it lives on, owned when it is a temporary. The \`Cow\` is
- * itself a temporary of the whole statement, so the \`&str\` taken from it lives to its end. A
- * \`String\` built for the purpose is moved into it, and one that is already a \`Cow\` — a branch
- * of \`?:\` or \`||\` — is taken as it is. */
-export declare function asCow(v: Val): string;
-/** Whether built code is a `Cow<str>` already: a runtime routine that borrows when it can
- * (`js_slice`, `js_replace`, `js_pad_start`, …), or a fallback taken from one (`.unwrap_or(Cow…)`). */
-export declare function yieldsCow(code: string): boolean;
-/** Whether a value is a JavaScript number: an integer or a fraction. */
-export declare function isNumber(ty: Ty): boolean;
-/** A number as an `f64`, as JavaScript holds every number. */
-export declare function asF64(v: Val): string;
-/** A type as an error names it. */
 export declare function describeTy(ty: Ty): string;
 export declare function fieldVal(comp: Component, base: string, ty: Ty, js: string, node: N): Val;
-/** A value's truthiness when it is known at generation time: a boolean constant, a string literal,
- * a number JavaScript computed. */
-export declare function known(v: Val): boolean | undefined;
-export declare function truthy(v: Val): string;
-/** A value passed where `want` is expected: a present value into an optional slot is wrapped. */
 export declare function coerce(comp: Component, v: Val, want: Ty, node: N): string;
-/** The JavaScript path an expression names — `$props.user`, `item.author.name` — or `null` when it
- * is not a plain chain of names. */
-export declare function pathOf(n: N): string | null;
-/** A test that an optional value is present, as TypeScript narrows on it: `x`, `x !== undefined`,
- * and, `negated`, `!x` and `x === undefined`, after which the value is present in the other branch. */
-export interface Presence {
-    path: string;
-    /** The value bound where it is present, and its type there. */
-    pattern: (name: string) => string;
-    /** The `Option` the pattern matches: the value, or for a truthiness test only its truthy values. */
-    option: string;
-    /** The test alone, for a branch that never reads the value. */
-    present: string;
-    of: Ty;
-    negated: boolean;
-    /** Tested by truthiness, so the test itself is a boolean only when it is negated. */
-    truthy: boolean;
-}
-export declare function presence(s: Scope, n: N): Presence | null;
-/** The scope with `p`'s value present, bound as `name`. */
-export declare function narrowTo(s: Scope, p: Presence, name: string): Scope;
-export declare function cond(s: Scope, n: N): string;
 export declare function childOf(name: string): Component;
-/** The reader's route, which the component then takes. */
-export declare function theRoute(s: Scope, n: N): Val;
-/** A field of the route: what `useRoute()` gives that the server knows as vue-router does. */
-export declare function routeField(s: Scope, base: Val, prop: string, n: N): Val;
-/** A Pinia getter read from a store's state, `prefs.doubled`: its expression, translated with the
- * state it takes bound to that state. `null` when `name` is not a getter of that store. */
-export declare function storeGetter(s: Scope, base: Val, name: string, node: N): Val | null;
-/** A Rust string literal's text. */
-export declare function unquote(literal: string): string;
 export declare function expr(s: Scope, n: N): Val;
-/** A boolean computed at run time, or known now when it folded to a constant. */
-export declare function boolOf(code: string): Val;
-export declare function call(s: Scope, n: N): Val;
-/** Whether `n` is `Object.<method>(…)`. */
-export declare function isObjectCall(n: N, method: string): boolean;
-export declare function helperCall(s: Scope, name: string, args: N[], n: N): Val;