ferrovue 0.6.0 → 0.7.0

package/dist/styles.js

@@ -1,10 +1,133 @@
 import { escapeHtml, hyphenate, parseStringStyle } from "@vue/shared";
 import { fail, nothing, rustStr } from "./model.js";
-import { expr } from "./expr.js";
-import { cond } from "./narrowing.js";
-import { condition, logical, not, strArg } from "./parens.js";
+import { describeTy, expr } from "./expr.js";
+import { cond, known } from "./narrowing.js";
+import { condition, logical, not, receiver, strArg } from "./parens.js";
 import { Emitter } from "./emitter.js";
 import { display, valueAttr } from "./attrs.js";
+import { isTemporary } from "./strings.js";
+/** Put the object Vue's server compiler declares as `_cssVars`, the `v-bind()` variables in
+ * `<style>`, in place of each use of it in the compiled template's statements, with each value
+ * marked to be written as `ssrRenderStyle` writes a variable. */
+export function inlineCssVars(comp, body) {
+    const at = body.findIndex((st) => st.type === "VariableDeclaration" && st.declarations[0]?.id?.name === "_cssVars");
+    if (at < 0)
+        return body;
+    const vars = body[at].declarations[0].init.properties[0].value.properties;
+    const place = (n, where) => {
+        if (Array.isArray(n))
+            return n.map((x) => place(x, where));
+        if (!n || typeof n !== "object")
+            return n;
+        const copy = {};
+        for (const [k, v] of Object.entries(n))
+            copy[k] = k === "loc" ? where.loc : place(v, where);
+        if (typeof n.type === "string")
+            copy.__fv = "source";
+        return copy;
+    };
+    const object = () => ({
+        type: "ObjectExpression",
+        properties: [{
+                type: "ObjectProperty",
+                computed: false,
+                key: { type: "Identifier", name: "style" },
+                value: {
+                    type: "ObjectExpression",
+                    properties: vars.map((p, i) => {
+                        const where = comp.cssVarsAt?.[i] ?? p;
+                        return {
+                            type: "ObjectProperty",
+                            computed: false,
+                            key: { type: "StringLiteral", value: String(p.key.value).replace(/^:/, "") },
+                            value: { type: "FvCssVar", value: place(p.value, where), loc: where.loc, __fv: where.__fv },
+                        };
+                    }),
+                },
+            }],
+    });
+    const swap = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        for (const [k, v] of Object.entries(n)) {
+            if (k === "loc")
+                continue;
+            if (Array.isArray(v)) {
+                v.forEach((x, i) => {
+                    if (x?.type === "Identifier" && x.name === "_cssVars")
+                        v[i] = object();
+                    else
+                        swap(x);
+                });
+            }
+            else if (v && typeof v === "object") {
+                if (v.type === "Identifier" && v.name === "_cssVars")
+                    n[k] = object();
+                else
+                    swap(v);
+            }
+        }
+    };
+    const rest = body.filter((_, i) => i !== at);
+    swap(rest);
+    return rest;
+}
+function cssVarOf(s, n) {
+    const v = expr(s, n.value);
+    const of = v.ty.k === "opt" ? v.ty.of : v.ty;
+    if (!nothing(v.ty) && of.k !== "str" && of.k !== "int" && of.k !== "float") {
+        fail(s.comp, "FV1006", `\`v-bind()\` in \`<style>\` of ${describeTy(of)}: Vue writes a string or a number, and warns of anything else`, n);
+    }
+    return v;
+}
+function writeCssVar(s, e, css, n) {
+    const one = (v) => {
+        if (nothing(v.ty)) {
+            e.lit(`${escapeHtml(css)}:initial;`);
+            return;
+        }
+        if (v.ty.k === "opt") {
+            e.open(`if let Some(v) = ${v.code}`);
+            one({ code: "v", ty: v.ty.of });
+            e.close(" else {");
+            e.lit(`${escapeHtml(css)}:initial;`);
+            e.close();
+            return;
+        }
+        e.lit(`${escapeHtml(css)}:`);
+        const k = v.ty.k === "str" ? known(v) : true;
+        if (k === false)
+            e.lit(" ");
+        else if (k === undefined && isTemporary(v))
+            e.stmt(`match AsRef::<str>::as_ref(${strArg(v.code)}) { "" => out.push(' '), v => fv::escape_into(out, v) }`);
+        else if (k === undefined) {
+            e.open(`if ${receiver(v.code)}.is_empty()`);
+            e.lit(" ");
+            e.close(" else {");
+            display(e, v);
+            e.close();
+        }
+        else
+            display(e, v);
+        e.lit(";");
+    };
+    one(cssVarOf(s, n));
+}
+function cssVarAttr(s, n) {
+    const one = (v) => {
+        if (nothing(v.ty))
+            return 'fv::Attr::str("initial")';
+        if (v.ty.k === "opt")
+            return `match ${v.code} { Some(v) => ${one({ code: "v", ty: v.ty.of })}, None => fv::Attr::str("initial") }`;
+        const k = v.ty.k === "str" ? known(v) : true;
+        if (k === false)
+            return 'fv::Attr::str(" ")';
+        if (k === undefined)
+            return `if ${receiver(v.code)}.is_empty() { fv::Attr::str(" ") } else { ${valueAttr(s, v, n)} }`;
+        return valueAttr(s, v, n);
+    };
+    return one(cssVarOf(s, n));
+}
 export function mergedStyle(s, e, n) {
     if (n.type === "StringLiteral") {
         renderStyle(s, e, { type: "ArrayExpression", elements: [n] });
@@ -38,7 +161,7 @@ export function styleAttr(s, n) {
                 const key = p.key.type === "Identifier" ? p.key.name : String(p.key.value);
                 if (/^\d+$/.test(key) || key.startsWith(":"))
                     fail(s.comp, "FV1009", `style property \`${key}\``, p);
-                return `(${rustStr(key)}, ${valueAttr(s, expr(s, p.value), p.value)})`;
+                return `(${rustStr(key)}, ${p.value.type === "FvCssVar" ? cssVarAttr(s, p.value) : valueAttr(s, expr(s, p.value), p.value)})`;
             });
             return `fv::Attr::style([${entries.join(", ")}])`;
         }
@@ -123,6 +246,10 @@ export function renderStyle(s, e, n) {
         }
     }
     const write = (css, value) => {
+        if (value.type === "FvCssVar") {
+            writeCssVar(s, e, css, value);
+            return;
+        }
         if (value.type === "StringLiteral" || value.type === "NumericLiteral") {
             e.lit(escapeHtml(`${css}:${String(value.value)};`));
             return;

package/dist/testing.d.ts

@@ -1,4 +1,5 @@
 export { attachSsrRender } from "./ssr.ts";
 export { conformanceSuite, type ConformanceOptions } from "./conformance.ts";
 export { fixtureApp, readFixture, routeRecords, type Fixture, type RouteEntry, type RouterOptions } from "./fixture.ts";
-export { hydrateRecordedPage, type RecordedPage } from "./hydration.ts";
+export { hydrateRecordedPage, renderRecordedPage, type RecordedPage } from "./hydration.ts";
+export type { IslandComponent, MountOptions, PageOptions, PagePart, PageRecord, RenderPageOptions } from "./client.ts";

package/dist/testing.js

@@ -1,4 +1,4 @@
 export { attachSsrRender } from "./ssr.js";
 export { conformanceSuite } from "./conformance.js";
 export { fixtureApp, readFixture, routeRecords } from "./fixture.js";
-export { hydrateRecordedPage } from "./hydration.js";
+export { hydrateRecordedPage, renderRecordedPage } from "./hydration.js";

package/dist/typescript.d.ts

@@ -3,8 +3,18 @@ export declare function typesImports(comp: Component, body: N[]): void;
 export declare const ONE_NOTHING = "its Rust type is an `Option`, whose `None` cannot be both, as `=== null` and the props sent to the client would need";
 export declare function tyOfTs(comp: Component, t: N, structs: Map<string, Struct>, seen?: Set<string>): Ty;
 export declare function declareTypes(comp: Component, body: N[], structs: Map<string, Struct>, aliases: Map<string, N>): N[];
+export declare function refusePrelude(comp: Component, d: N): void;
 export declare function resolveImport(fromFile: string, spec: string): string | null;
 export declare function readTypeFile(file: string): void;
+/** Translate a type a `.ts` file declares, the first time something the server renders reaches it. */
+export declare function reachType(name: string): void;
+/** Translate an interface a component declares, the first time something the server renders reaches it. */
+export declare function reachLocal(comp: Component, name: string): void;
+/** Refuse a type whose every field a value of it must carry, as props and store state do, where one
+ * of its fields, or of the types it holds, has no Rust type. */
+export declare function requireWhole(comp: Component, ty: Ty, seen?: Set<Struct>): void;
+/** Whether `types.rs` holds the type: one built from a constant list, or a declared one something reached. */
+export declare function typeWritten(name: string): boolean;
 export declare function markHome(ty: Ty, home: string): Ty;
 export declare function lookupStruct(comp: Component, ty: Ty & {
     k: "struct";
@@ -13,7 +23,7 @@ export declare function lookupStruct(comp: Component, ty: Ty & {
     owner: Component;
     path: string;
 };
-export declare function structOf(comp: Component, name: string, members: N[], structs: Map<string, Struct>): Struct;
+export declare function structOf(comp: Component, name: string, members: N[], structs: Map<string, Struct>, lenient?: boolean): Struct;
 export declare function definePropsType(call: N): N | null;
 export declare function runtimeDefaults(comp: Component, content: string): Map<string, N>;
 export declare function defaultValue(comp: Component, f: Field, node: N, written?: N): string;

package/dist/typescript.js

@@ -1,11 +1,13 @@
 import { parse as parseJs } from "@babel/parser";
 import { readFileSync, statSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
+import { relativePath } from "./paths.js";
 import { absence, blankComponent, BOOL, fail, FLOAT, GenError, INT, joinAbsence, opt, RUST_PRELUDE, rustStr, sameTy, snake, STR, tagAst, withAbsence } from "./model.js";
 import { CONFIG_FILE, ctx, INLINE_HTML, TYPES_MODULE } from "./context.js";
 import { childOf } from "./expr.js";
 import { claim } from "./plugin.js";
 import { declareConsts, enumType } from "./constants.js";
+import { parseTs } from "./files.js";
 export function typesImports(comp, body) {
     for (const s of body) {
         if (s.type !== "ImportDeclaration" || s.source.value !== TYPES_MODULE)
@@ -92,8 +94,13 @@ export function tyOfTs(comp, t, structs, seen = new Set()) {
                     fail(comp, "FV0313", "a `Record` is keyed by `string`", key);
                 return recordOf(comp, value, structs, seen);
             }
-            if (structs.has(name))
+            if (structs.has(name)) {
+                if (structs === ctx.typeStructs)
+                    reachType(name);
+                else if (structs === comp.structs)
+                    reachLocal(comp, name);
                 return { k: "struct", name };
+            }
             if (comp.childProps.has(name))
                 return { k: "child", name: comp.childProps.get(name) };
             if (comp.floatName !== null && name === comp.floatName)
@@ -107,8 +114,11 @@ export function tyOfTs(comp, t, structs, seen = new Set()) {
                 return ctx.trustedHtml === INLINE_HTML ? { k: "html", inline: true } : { k: "html" };
             }
             const imported = comp.importedTypes.get(name);
-            if (imported)
+            if (imported) {
+                if (imported.k === "struct" && imported.home === "types")
+                    reachType(imported.name);
                 return imported;
+            }
             const alias = comp.aliases.get(name);
             if (alias) {
                 if (seen.has(name))
@@ -150,14 +160,15 @@ export function declareTypes(comp, body, structs, aliases) {
             }
         }
     }
-    for (const d of decls) {
-        if (RUST_PRELUDE.has(d.name)) {
-            fail(comp, "FV0318", `an interface called \`${d.name}\` would hide Rust's own \`${d.name}\` in the generated code; rename it`, d.node);
-        }
+    for (const d of decls)
         structs.set(d.name, { name: d.name, fields: [] });
-    }
     return decls;
 }
+export function refusePrelude(comp, d) {
+    if (RUST_PRELUDE.has(d.name)) {
+        fail(comp, "FV0318", `an interface called \`${d.name}\` would hide Rust's own \`${d.name}\` in the generated code; rename it`, d.node);
+    }
+}
 export function resolveImport(fromFile, spec) {
     if (!spec.startsWith("."))
         return null;
@@ -176,30 +187,88 @@ export function readTypeFile(file) {
     if (ctx.typeRead.has(file))
         return;
     ctx.typeRead.add(file);
-    const rel = relative(ctx.rootDir, file);
+    const rel = relativePath(ctx.rootDir, file);
     const home = blankComponent(basename(rel), "types", rel, ctx.typeStructs);
     home.aliases = ctx.typeAliases;
     home.source = readFileSync(file, "utf8");
-    const body = parseJs(home.source, { sourceType: "module", plugins: ["typescript"] }).program.body;
+    const body = parseTs(home);
     tagAst(body, "source");
     typesImports(home, body);
     ctx.constDecls.set(file, declareConsts(home, body));
-    const before = new Set(ctx.typeStructs.keys());
-    const local = new Map();
-    const decls = declareTypes(home, body, local, ctx.typeAliases);
-    for (const d of decls) {
-        if (before.has(d.name))
+    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))
             fail(home, "FV0319", `\`${d.name}\` is declared by ${ctx.typeFiles.get(d.name)} too`, d.node);
-        ctx.typeStructs.set(d.name, local.get(d.name));
+        if (known !== undefined && ctx.typeReached.has(d.name))
+            fail(home, "FV0319", `\`${d.name}\` is declared by ${known[0].home.file} too`, d.node);
+        if (known !== undefined) {
+            if (known.at(-1).home.file === rel)
+                known.pop();
+            known.push({ home, members: d.members, node: d.node });
+            continue;
+        }
+        ctx.typeDecls.set(d.name, [{ home, members: d.members, node: d.node }]);
+        ctx.typeStructs.set(d.name, { name: d.name, fields: [] });
         ctx.typeFiles.set(d.name, rel);
     }
-    for (const d of decls) {
-        const st = structOf(home, d.name, d.members, ctx.typeStructs);
+}
+/** Translate a type a `.ts` file declares, the first time something the server renders reaches it. */
+export function reachType(name) {
+    const decls = ctx.typeDecls.get(name);
+    if (decls === undefined || ctx.typeReached.has(name))
+        return;
+    ctx.typeReached.add(name);
+    try {
+        const [first, again] = decls;
+        if (again !== undefined)
+            fail(again.home, "FV0319", `\`${name}\` is declared by ${first.home.file} too`, again.node);
+        refusePrelude(first.home, { name, node: first.node });
+        const st = structOf(first.home, name, first.members, ctx.typeStructs, true);
         for (const f of st.fields)
             f.ty = markHome(f.ty, "types");
-        ctx.typeStructs.set(d.name, st);
+        ctx.typeStructs.set(name, st);
+    }
+    catch (e) {
+        ctx.typeReached.delete(name);
+        throw e;
+    }
+}
+/** Translate an interface a component declares, the first time something the server renders reaches it. */
+export function reachLocal(comp, name) {
+    const decl = comp.typeDecls.get(name);
+    if (decl === undefined || comp.reached.has(name))
+        return;
+    comp.reached.add(name);
+    try {
+        refusePrelude(comp, { name, node: decl.node });
+        comp.structs.set(name, structOf(comp, name, decl.members, comp.structs, true));
+    }
+    catch (e) {
+        comp.reached.delete(name);
+        throw e;
     }
 }
+/** Refuse a type whose every field a value of it must carry, as props and store state do, where one
+ * of its fields, or of the types it holds, has no Rust type. */
+export function requireWhole(comp, ty, seen = new Set()) {
+    if (ty.k === "opt" || ty.k === "list" || ty.k === "record")
+        return requireWhole(comp, ty.of, seen);
+    if (ty.k !== "struct")
+        return;
+    const { st, owner } = lookupStruct(comp, ty);
+    if (st === undefined || seen.has(st))
+        return;
+    seen.add(st);
+    const refused = st.refused?.values().next().value;
+    if (refused !== undefined)
+        throw refused;
+    for (const f of st.fields)
+        requireWhole(owner, f.ty, seen);
+}
+/** Whether `types.rs` holds the type: one built from a constant list, or a declared one something reached. */
+export function typeWritten(name) {
+    return !ctx.typeDecls.has(name) || ctx.typeReached.has(name);
+}
 export function markHome(ty, home) {
     if (ty.k === "struct" && !claim((p) => p.struct?.(ty)) && !ty.home && ty.name !== "Props")
         return { ...ty, home };
@@ -211,31 +280,53 @@ export function lookupStruct(comp, ty) {
     const own = claim((p) => p.struct?.(ty));
     if (own)
         return { st: own.st, owner: comp, path: comp.module === own.module ? "" : `super::${own.module}::` };
-    if (ty.home === "types")
+    if (ty.home === "types") {
+        reachType(ty.name);
         return { st: ctx.typeStructs.get(ty.name), owner: comp, path: comp.module === "types" ? "" : "super::types::" };
+    }
     if (ty.home !== undefined && ty.home !== comp.name) {
         const owner = childOf(ty.home);
+        reachLocal(owner, ty.name);
         return { st: owner.structs.get(ty.name), owner, path: `super::${owner.module}::` };
     }
-    return { st: ty.name === "Props" ? comp.props : comp.structs.get(ty.name), owner: comp, path: "" };
+    if (ty.name === "Props")
+        return { st: comp.props, owner: comp, path: "" };
+    reachLocal(comp, ty.name);
+    return { st: comp.structs.get(ty.name), owner: comp, path: "" };
 }
-export function structOf(comp, name, members, structs) {
+export function structOf(comp, name, members, structs, lenient = false) {
     const fields = [];
+    const refused = new Map();
     for (const m of members) {
-        if (m.type !== "TSPropertySignature" || m.key.type !== "Identifier") {
-            fail(comp, "FV0320", `\`${name}\` may only hold plain named fields`, m);
-        }
-        const base = tyOfTs(comp, m.typeAnnotation.typeAnnotation, structs);
-        if (m.optional && absence(base) === "null") {
-            fail(comp, "FV0321", `\`${m.key.name}?: T | null\` may be absent, which is \`undefined\`, or \`null\`: ${ONE_NOTHING}; declare it \`${m.key.name}: T | null\` or \`${m.key.name}?: T\``, m);
+        try {
+            fields.push(fieldOf(comp, name, m, structs));
         }
-        if (m.optional && base.k === "opt") {
-            fields.push({ js: m.key.name, rust: snake(m.key.name), ty: base });
-            continue;
+        catch (e) {
+            if (!lenient || !(e instanceof GenError))
+                throw e;
+            const key = memberKey(m);
+            if (!refused.has(key))
+                refused.set(key, e);
         }
-        fields.push({ js: m.key.name, rust: snake(m.key.name), ty: m.optional ? opt(base) : base });
     }
-    return { name, fields };
+    return refused.size ? { name, fields, refused } : { name, fields };
+}
+function memberKey(m) {
+    if (m.type !== "TSPropertySignature" && m.type !== "TSMethodSignature")
+        return "";
+    if (m.computed)
+        return "";
+    return m.key.type === "Identifier" ? m.key.name : m.key.type === "StringLiteral" ? m.key.value : "";
+}
+function fieldOf(comp, name, m, structs) {
+    if (m.type !== "TSPropertySignature" || m.key.type !== "Identifier") {
+        fail(comp, "FV0320", `\`${name}\` may only hold plain named fields`, m);
+    }
+    const base = tyOfTs(comp, m.typeAnnotation.typeAnnotation, structs);
+    if (m.optional && absence(base) === "null") {
+        fail(comp, "FV0321", `\`${m.key.name}?: T | null\` may be absent, which is \`undefined\`, or \`null\`: ${ONE_NOTHING}; declare it \`${m.key.name}: T | null\` or \`${m.key.name}?: T\``, m);
+    }
+    return { js: m.key.name, rust: snake(m.key.name), ty: m.optional && base.k !== "opt" ? opt(base) : base };
 }
 export function definePropsType(call) {
     if (call?.type === "CallExpression" && call.callee.type === "Identifier" && call.callee.name === "withDefaults") {

package/dist/vite.d.ts

@@ -1,26 +1,34 @@
 import type { Plugin, ResolvedConfig } from "vite";
 import { type FileRoute } from "./file-routes.ts";
+export type { FileRoute } from "./file-routes.ts";
 export interface FerrovueOptions {
-    /** The directory holding `ferrovue.config.json`: Vite's working directory by default. */
+    /** The project root, which the configuration's paths are relative to: Vite's working directory
+     * by default. */
     root?: string;
+    /** The configuration file, relative to `root`, as the CLI's `--config` takes it:
+     * `ferrovue.config.json` by default. */
+    config?: string;
 }
-/** Whether a changed file can change what is generated: a component, a store or type file, the
- * routes or the configuration: anything but the output itself, dependencies and build output. */
-export declare function affects(root: string, file: string): boolean;
 /** How `@vitejs/plugin-vue`, as this build configures it, computes a `<style scoped>` id: from the
- * path alone or the path and source, hashed from Vite's root. `null` without the plugin, or with an
- * id generator of its own. */
+ * path alone or the path and source, hashed from Vite's root; and whether it compiles for production.
+ * `null` without the plugin, or with an id generator of its own. */
 export declare function vueScopeIds(config: ResolvedConfig): {
     mode: "filepath" | "filepath-source";
     root: string;
+    production: boolean;
 } | null;
-/** Why the server's scope ids would differ from the client's, when a component has `<style scoped>`
- * and `ferrovue.config.json` computes them otherwise than plugin-vue: a page would hydrate cleanly
- * and show unstyled. */
+/** Why the server's scope ids, or the CSS variables `v-bind()` sets, would differ from the client's,
+ * when a component has `<style scoped>` or `v-bind()` in `<style>` and the configuration,
+ * `configFile`, computes them otherwise than plugin-vue: a page would hydrate and show unstyled. */
 export declare function scopeIdMismatch(root: string, vue: {
     mode: string;
     root: string;
-} | null): string | null;
+    production?: boolean;
+} | null, configFile?: string): string | null;
+/** Why the class names of the server's CSS modules would differ from those Vite gives the client,
+ * when a component has `<style module>` and Vite's `css`, run from `cwd`, names them otherwise than
+ * `cssModules` in the configuration, `configFile`. */
+export declare function cssModulesMismatch(root: string, css: ResolvedConfig["css"] | undefined, cwd: string, configFile?: string): string | null;
 /** The `ferrovue/routes` module: the routes vue-router's file-based routing builds from the pages,
  * as vue-router's records with each page loaded lazily (`routes`), and as a routes file lists them
  * (the default export), for `routeRecords` and `linkRouter`. */