ferrovue 0.8.0 → 0.9.0

package/dist/calls.d.ts

@@ -1,4 +1,8 @@
 import { type N, type Scope, type Val } from "./model.ts";
 export declare function call(s: Scope, n: N): Val;
+/** The globals of JavaScript a template may name, which the server translates only some of. */
+export declare const BUILTINS: Set<string>;
+/** Refuses `what`, a use of one of JavaScript's globals the server does not translate. */
+export declare function builtin(s: Scope, what: string, n: N): never;
 export declare function isObjectCall(n: N, method: string): boolean;
 export declare function helperCall(s: Scope, name: string, args: N[], n: N): Val;

package/dist/calls.js

@@ -2,11 +2,16 @@ import { BOOL, fail, FLOAT, INT, sameTy, STR } from "./model.js";
 import { ctx } from "./context.js";
 import { claim } from "./plugin.js";
 import { atom, bare, binary, condition, operand, receiver, strArg, UNARY } from "./parens.js";
-import { computedListMethod, isBoolean, items, listMethod, objectCall, presentLiteral } from "./lists.js";
-import { lonely, loneOf, meet, stringMethod, stringsEqual } from "./strings.js";
-import { asF64, intFromF64, isNumber } from "./numbers.js";
+import { computedListMethod, isBoolean, items, listMethod, objectCall, presentLiteral, spreadExtreme } from "./lists.js";
+import { formatted, lonely, loneOf, meet, stringMethod, stringOf, stringsEqual } from "./strings.js";
+import { asF64, intFromF64, isNumber, numberVal, power } from "./numbers.js";
 import { boolOf, truthy } from "./narrowing.js";
-import { coerce, expr } from "./expr.js";
+import { coerce, describeTy, expr } from "./expr.js";
+const DIGITS = new Map([
+    ["toFixed", ["FV0705", 0, "number of digits"]],
+    ["toPrecision", ["FV0716", 1, "precision"]],
+    ["toExponential", ["FV0717", 0, "number of digits"]],
+]);
 export function call(s, n) {
     const comp = s.comp;
     const callee = n.callee;
@@ -43,7 +48,10 @@ export function call(s, n) {
             return helperCall(s, helper, args, n);
         if (isBoolean(s, callee) && args.length === 1)
             return boolOf(truthy(expr(s, args[0])));
-        if (callee.name === "String" && args.length === 1) {
+        const global = !s.locals.has(callee.name) && !s.setup.has(callee.name);
+        if (callee.name === "String" && global) {
+            if (args.length !== 1)
+                return fail(comp, "FV0723", "`String()` takes one value", n);
             const a = expr(s, args[0]);
             if (a.ty.k === "str")
                 return a;
@@ -51,6 +59,17 @@ export function call(s, n) {
                 return { code: `&*fv::Js(${bare(a.code)}).to_string()`, ty: STR };
             if (a.ty.k === "bool")
                 return { code: `if ${condition(a.code)} { "true" } else { "false" }`, ty: STR };
+            return formatted(comp, [stringOf(comp, a, args[0], "`String()`", "FV0723")], n, "`String()`");
+        }
+        if ((callee.name === "encodeURIComponent" || callee.name === "encodeURI") && global) {
+            const name = `\`${callee.name}()\``;
+            if (args.length !== 1)
+                return fail(comp, "FV0723", `${name} takes one value`, n);
+            const a = expr(s, args[0]);
+            if (a.lone)
+                fail(comp, "FV0706", `${lonely(name)}; it throws a \`URIError\` on a half`, n);
+            const text = a.ty.k === "str" ? a : formatted(comp, [stringOf(comp, a, args[0], name, "FV0723")], n, name);
+            return { code: `&*fv::js_${callee.name === "encodeURI" ? "encode_uri" : "encode_uri_component"}(${strArg(text.code)})`, ty: STR };
         }
         if (callee.name === "Number" && args.length === 1) {
             const a = expr(s, args[0]);
@@ -74,6 +93,10 @@ export function call(s, n) {
             }
             return { code: `fv::js_parse_int(${strArg(a.code)}, ${radix ? radix.value : 0})`, ty: FLOAT };
         }
+        if ((callee.name === "isNaN" || callee.name === "isFinite") && global)
+            return numberTest(s, callee.name, args, n, true);
+        if (global && BUILTINS.has(callee.name))
+            return builtin(s, `${callee.name}()`, n);
         return fail(comp, "FV0601", `\`${callee.name}()\` is not available when rendering on the server`, n);
     }
     if (callee.type === "MemberExpression" && !callee.computed) {
@@ -88,12 +111,17 @@ export function call(s, n) {
         }
         if (callee.object.type === "Identifier" && callee.object.name === "Object")
             return objectCall(s, method, args, n);
+        if (callee.object.type === "Identifier" && callee.object.name === "Number" && NUMBER_TESTS.has(method))
+            return numberTest(s, method, args, n, false);
         if (callee.object.type === "Identifier" && callee.object.name === "JSON" && method === "stringify" && args.length === 1) {
             const v = expr(s, args[0]);
             if (v.ty.k === "bool")
                 return { code: `if ${condition(v.code)} { "true" } else { "false" }`, ty: STR };
             return { code: `&*${json(s, v, args[0])}`, ty: STR };
         }
+        if (callee.object.type === "Identifier" && callee.object.name === "JSON" && method === "stringify") {
+            return fail(comp, "FV0633", "`JSON.stringify()` with a replacer or an indentation, which the server does not write: give it one value, `JSON.stringify(x)`", n);
+        }
         const own = claim((p) => p.call?.(s, n));
         if (own)
             return own;
@@ -105,6 +133,13 @@ export function call(s, n) {
                 return fail(comp, "FV0613", `\`${method}\` is set up in a way the server cannot evaluate: ${s.clientOnly.get(method)}`, n);
         }
         if (callee.object.type === "Identifier" && callee.object.name === "Math") {
+            if ((method === "max" || method === "min") && args.some((a) => a?.type === "SpreadElement"))
+                return spreadExtreme(s, method, args);
+            if (method === "pow" && args.length === 2)
+                return power(s, args[0], args[1], n, "`Math.pow()`");
+            if (ROUNDED_BY_EACH.has(method)) {
+                return fail(comp, "FV0719", `\`Math.${method}()\` is computed by each JavaScript engine's own routine, which need not round its result as another engine or Rust does, so the page could show digits the browser's render does not: compute it in Rust and pass it as a prop`, n);
+            }
             const vals = args.map((a) => expr(s, a));
             if (vals.length && vals.every((v) => isNumber(v.ty))) {
                 const ints = vals.every((v) => v.ty.k === "int");
@@ -121,9 +156,25 @@ export function call(s, n) {
                         return { code: `fv::js_round(${bare(asF64(x))})`, ty: FLOAT };
                     if (method === "floor" || method === "ceil" || method === "trunc")
                         return { code: `${receiver(asF64(x))}.${method}()`, ty: FLOAT };
+                    if (method === "sqrt")
+                        return x.num !== undefined ? numberVal(Math.sqrt(x.num), false) : { code: `${receiver(asF64(x))}.sqrt()`, ty: FLOAT };
+                    if (method === "sign") {
+                        if (x.num !== undefined)
+                            return numberVal(Math.sign(x.num), ints);
+                        const sign = `fv::js_sign(${bare(asF64(x))})`;
+                        return ints ? intFromF64(sign) : { code: sign, ty: FLOAT };
+                    }
                 }
             }
-            return fail(comp, "FV0704", `\`Math.${method}()\` is supported on numbers as \`max\`, \`min\`, \`abs\`, \`round\`, \`floor\`, \`ceil\` and \`trunc\``, n);
+            return fail(comp, "FV0704", `\`Math.${method}()\` is supported on numbers as \`max\`, \`min\`, \`abs\`, \`round\`, \`floor\`, \`ceil\`, \`trunc\`, \`sqrt\`, \`sign\` and \`pow\``, n);
+        }
+        if (callee.object.type === "Identifier" && BUILTINS.has(callee.object.name) && !s.locals.has(callee.object.name) && !s.setup.has(callee.object.name)) {
+            return builtin(s, `${callee.object.name}.${method}()`, n);
+        }
+        if ((method === "sort" || method === "reverse") && callee.object.type === "ArrayExpression") {
+            const copy = expr(s, callee.object);
+            if (copy.ty.k === "list")
+                return listMethod(s, copy, method === "sort" ? "toSorted" : "toReversed", args, n);
         }
         const literal = method === "filter" && args.length === 1 && isBoolean(s, args[0]) && callee.object.type === "ArrayExpression";
         const target = (literal ? presentLiteral(s, callee.object) : null) ?? expr(s, callee.object);
@@ -138,7 +189,10 @@ export function call(s, n) {
                 case "trimStart":
                     return { code: `fv::js_trim_start(${strArg(target.code)})`, ty: STR, ...lone };
                 case "trimEnd":
+                case "trimRight":
                     return { code: `fv::js_trim_end(${strArg(target.code)})`, ty: STR, ...lone };
+                case "trimLeft":
+                    return { code: `fv::js_trim_start(${strArg(target.code)})`, ty: STR, ...lone };
                 case "toUpperCase":
                     return { code: `&*${receiver(target.code)}.to_uppercase()`, ty: STR, ...lone };
                 case "toLowerCase":
@@ -150,12 +204,21 @@ export function call(s, n) {
             if (m)
                 return m;
         }
-        if (isNumber(target.ty) && method === "toFixed" && args.length <= 1) {
-            const d = args.length ? args[0] : { type: "NumericLiteral", value: 0 };
-            if (d.type !== "NumericLiteral" || !Number.isInteger(d.value) || d.value < 0 || d.value > 100) {
-                fail(comp, "FV0705", "`.toFixed()` takes a literal number of digits, from 0 to 100", n);
-            }
-            return { code: `&*fv::js_to_fixed(${bare(asF64(target))}, ${d.value})`, ty: STR };
+        const digits = isNumber(target.ty) && args.length <= 1 ? DIGITS.get(method) : undefined;
+        if (digits) {
+            const [code, low, what] = digits;
+            const a = args[0];
+            const given = a === undefined || (a.type === "Identifier" && a.name === "undefined") ? undefined : a.type === "NumericLiteral" ? Math.trunc(a.value) : NaN;
+            if (given !== undefined && !(given >= low && given <= 100))
+                fail(comp, code, `\`.${method}()\` takes a literal ${what}, from ${low} to 100`, n);
+            const x = bare(asF64(target));
+            if (method === "toFixed")
+                return { code: `&*fv::js_to_fixed(${x}, ${given ?? 0})`, ty: STR };
+            if (method === "toExponential")
+                return { code: `&*fv::js_to_exponential(${x}, ${given === undefined ? "None" : `Some(${given})`})`, ty: STR };
+            if (given === undefined)
+                return { code: `&*fv::Js(${bare(target.code)}).to_string()`, ty: STR };
+            return { code: `&*fv::js_to_precision(${x}, ${given})`, ty: STR };
         }
         if (isNumber(target.ty) && method === "toString" && args.length === 0) {
             return { code: `&*fv::Js(${bare(target.code)}).to_string()`, ty: STR };
@@ -191,6 +254,71 @@ export function call(s, n) {
     }
     return fail(comp, "FV0603", "this call is not supported", n);
 }
+const NUMBER_TESTS = new Set(["isNaN", "isFinite", "isInteger", "isSafeInteger"]);
+const ROUNDED_BY_EACH = new Set("acos acosh asin asinh atan atan2 atanh cbrt cos cosh exp expm1 hypot log log10 log1p log2 sin sinh tan tanh".split(" "));
+/** The globals of JavaScript a template may name, which the server translates only some of. */
+export const BUILTINS = new Set("Array BigInt Boolean JSON Map Math Number Object RegExp Set String Symbol console decodeURI decodeURIComponent encodeURI encodeURIComponent isFinite isNaN parseFloat parseInt".split(" "));
+const OF_BUILTINS = {
+    Array: "`Array.isArray(x)`",
+    Boolean: "`Boolean(x)` and `.filter(Boolean)`",
+    JSON: "`JSON.stringify(x)`",
+    Math: "`Math.max`, `min`, `abs`, `round`, `floor`, `ceil`, `trunc`, `sqrt`, `sign` and `pow`, and its constants",
+    Number: "`Number(x)`, `Number.isNaN`, `isFinite`, `isInteger` and `isSafeInteger`, and its constants",
+    Object: "`Object.keys`, `Object.values` and `Object.entries` of a record",
+    String: "`String(x)`",
+    encodeURI: "`encodeURI(s)`",
+    encodeURIComponent: "`encodeURIComponent(s)`",
+    isFinite: "`isFinite(n)`",
+    isNaN: "`isNaN(n)`",
+    parseFloat: "`parseFloat(s)`",
+    parseInt: "`parseInt(s)` and `parseInt(s, radix)`",
+};
+/** Refuses `what`, a use of one of JavaScript's globals the server does not translate. */
+export function builtin(s, what, n) {
+    const name = /^\w+/.exec(what)[0];
+    const of = OF_BUILTINS[name];
+    return fail(s.comp, "FV0633", `\`${what}\` is not supported: ${of ? `of \`${name}\`, the server translates ${of}` : `the server does not translate \`${name}\``}`, n);
+}
+function floatTest(method, x) {
+    switch (method) {
+        case "isNaN":
+            return `${receiver(x)}.is_nan()`;
+        case "isFinite":
+            return `${receiver(x)}.is_finite()`;
+        case "isInteger":
+            return `${receiver(x)}.fract() == 0.0`;
+        default:
+            return /^[\w.]+$/.test(x) ? `${x}.fract() == 0.0 && ${x}.abs() <= 9_007_199_254_740_991.0` : `matches!(${bare(x)}, v if v.fract() == 0.0 && v.abs() <= 9_007_199_254_740_991.0)`;
+    }
+}
+function intTest(method, x) {
+    if (method === "isSafeInteger")
+        return `(-9_007_199_254_740_991..=9_007_199_254_740_991).contains(&${operand(x, UNARY)})`;
+    return String(method !== "isNaN");
+}
+function numberTest(s, method, args, n, global) {
+    const name = global ? `\`${method}()\`` : `\`Number.${method}()\``;
+    if (args.length !== 1)
+        return fail(s.comp, "FV0718", `${name} takes one number`, n);
+    const v = expr(s, args[0]);
+    if (isNumber(v.ty)) {
+        if (v.num !== undefined) {
+            const konst = Number[method](v.num);
+            return { code: String(konst), ty: BOOL, konst };
+        }
+        return boolOf(v.ty.k === "int" ? intTest(method, v.code) : floatTest(method, v.code));
+    }
+    if (!global && v.ty.k === "opt" && isNumber(v.ty.of)) {
+        const each = v.ty.of.k === "int" ? intTest(method, "v") : floatTest(method, "v");
+        if (each === "false")
+            return { code: "false", ty: BOOL, konst: false };
+        return boolOf(each === "true" ? `${atom(v.code)}.is_some()` : `${atom(v.code)}.is_some_and(|v| ${each})`);
+    }
+    if (global) {
+        return fail(s.comp, "FV0718", `${name} converts its argument as \`Number()\` does, which the server does for a number only: write \`Number.${method}(Number(x))\` for a string, or pass a present number`, args[0]);
+    }
+    return fail(s.comp, "FV0718", `${name} of ${describeTy(v.ty)}, for which it is \`false\` whatever it holds, since it does not convert its argument: pass a number, present or optional`, args[0]);
+}
 export function isObjectCall(n, method) {
     return (n?.type === "CallExpression" && n.callee.type === "MemberExpression" && !n.callee.computed &&
         n.callee.object.type === "Identifier" && n.callee.object.name === "Object" && n.callee.property.name === method);
@@ -209,7 +337,7 @@ function json(s, v, n) {
             case "bool":
                 return `(if ${condition(code)} { "true" } else { "false" }).to_owned()`;
             default:
-                return fail(s.comp, "FV0707", "`JSON.stringify()` of a string, a number, a boolean or a list of those, present", n);
+                return claim((p) => p.values?.json?.({ code, ty })) ?? fail(s.comp, "FV0707", "`JSON.stringify()` of a string, a number, a boolean, a date or a list of those, present", n);
         }
     };
     if (v.ty.k === "list") {

package/dist/children.js

@@ -321,6 +321,14 @@ export function ownInto(comp, v, want, node) {
         if (v.ty.k === "opt" && v.ty.of.k === "str")
             return `${atom(v.code)}.map(std::borrow::Cow::Borrowed)`;
     }
+    if (want.k === "date" && v.ty.k === "date")
+        return `fv::js_date_prop(${bare(v.code)})`;
+    if (want.k === "opt" && want.of.k === "date") {
+        if (v.ty.k === "date")
+            return `Some(fv::js_date_prop(${bare(v.code)}))`;
+        if (v.ty.k === "opt" && v.ty.of.k === "date")
+            return `${atom(v.code)}.map(fv::js_date_prop)`;
+    }
     if (sameTy(v.ty, want) && (want.k === "int" || want.k === "float" || want.k === "bool"))
         return v.code;
     if (want.k === "opt" && sameTy(v.ty, want.of) && (v.ty.k === "int" || v.ty.k === "float" || v.ty.k === "bool"))

package/dist/client.d.ts

@@ -1,6 +1,13 @@
 import { type App, type Component, type Plugin } from "vue";
 import type { Pinia } from "pinia";
 import type { Router } from "vue-router";
+/** The props a component is given, with each prop it declares a `Date` turned from what JSON
+ * carries, the ISO string `toISOString()` writes or a number of milliseconds (`NaN` for an invalid
+ * date), back into a `Date`, as the server rendered it. Vue's compiler declares a prop typed `Date`
+ * as `{ type: Date }`, and one typed `Date | null` as `{ type: [Date, null] }`. `mountIslands`,
+ * `mountPage` and `renderPage` call it; an app that hands a component props it read from JSON
+ * itself calls it too. */
+export declare function reviveDates<P extends Record<string, unknown> | null>(component: Component, props: P): P;
 /** The state of a page already read: the text of its state's script, as `readPage` gives it. */
 export interface StateText {
     text: string | undefined;

package/dist/client.js

@@ -11,6 +11,28 @@ function parseJson(text) {
     const quoted = text.replace(BARE, (match) => (match.startsWith('"') ? match : `"${escaped}${match}"`));
     return JSON.parse(quoted, (_key, value) => (typeof value === "string" && value.startsWith(tag) ? NON_FINITE[value.slice(tag.length)] : value));
 }
+function declaresDate(declared) {
+    const type = declared !== null && typeof declared === "object" && "type" in declared ? declared.type : declared;
+    return type === Date || (Array.isArray(type) && type.includes(Date));
+}
+/** The props a component is given, with each prop it declares a `Date` turned from what JSON
+ * carries, the ISO string `toISOString()` writes or a number of milliseconds (`NaN` for an invalid
+ * date), back into a `Date`, as the server rendered it. Vue's compiler declares a prop typed `Date`
+ * as `{ type: Date }`, and one typed `Date | null` as `{ type: [Date, null] }`. `mountIslands`,
+ * `mountPage` and `renderPage` call it; an app that hands a component props it read from JSON
+ * itself calls it too. */
+export function reviveDates(component, props) {
+    const declared = component.props;
+    if (!props || !declared || typeof declared !== "object" || Array.isArray(declared))
+        return props;
+    let revived = null;
+    for (const [key, type] of Object.entries(declared)) {
+        const value = props[key];
+        if ((typeof value === "string" || typeof value === "number") && declaresDate(type))
+            (revived ??= { ...props })[key] = new Date(value);
+    }
+    return (revived ?? props);
+}
 /** Give Pinia the state the server rendered with (what `ferrovue::state_script_into` wrote) before
  * the app mounts, so every store starts from it and the markup agrees with the server's. The state
  * is read from the script with the `id` given (`__pinia` by default) in `doc`, or given as
@@ -303,7 +325,7 @@ export async function mountIslands(components, options = {}) {
         // One island that throws as it mounts (its setup, a plugin) is reported, and leaves the others
         // to hydrate.
         try {
-            const app = createSSRApp(component, props);
+            const app = createSSRApp(component, reviveDates(component, props));
             if (options.pinia)
                 app.use(options.pinia);
             if (options.router)
@@ -415,9 +437,9 @@ async function load(component) {
 export function createPageApp(layout, record, components, options = {}) {
     const slots = Object.fromEntries(Object.entries(record.slots).map(([name, parts]) => [
         name,
-        () => (parts.length ? parts.map((part) => h(components[part.c], part.p)) : [createTextVNode("")]),
+        () => (parts.length ? parts.map((part) => h(components[part.c], reviveDates(components[part.c], part.p))) : [createTextVNode("")]),
     ]));
-    const app = (options.hydrate === false ? createApp : createSSRApp)({ name: "FerrovuePage", render: () => h(layout, record.props, slots) });
+    const app = (options.hydrate === false ? createApp : createSSRApp)({ name: "FerrovuePage", render: () => h(layout, reviveDates(layout, record.props), slots) });
     if (options.pinia)
         app.use(options.pinia);
     if (options.router)

package/dist/compiler.js

@@ -1,7 +1,7 @@
 import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { relativePath } from "./paths.js";
-import { ctx, loadConfig, tyOfName } from "./context.js";
+import { ctx, JS_DATE, loadConfig, tyOfName } from "./context.js";
 import { failIn, snake } from "./model.js";
 import { readComponent, refuseOptionsApi } from "./component.js";
 import { listDir } from "./files.js";
@@ -9,7 +9,7 @@ import { scopeFor } from "./script.js";
 import { attrsFlow } from "./fallthrough.js";
 import { prepareDynamic } from "./dynamic.js";
 import { componentSource, GENERATED, isIsland, modSource } from "./rust.js";
-import { requireWhole } from "./typescript.js";
+import { refuseNestedDates, requireWhole } from "./typescript.js";
 import { renderParams } from "./plugin.js";
 import { PLUGINS } from "./plugins/index.js";
 /** Every generated file, keyed by its name in the output directory. `sources` holds the text of
@@ -19,6 +19,7 @@ export function generate(root, config = loadConfig(root), sources = new Map()) {
     ctx.componentsDir = config.components.replace(/\/?$/, "/");
     ctx.helperModule = config.helpers?.module ?? null;
     ctx.trustedHtml = config.trustedHtml ?? null;
+    ctx.dateType = config.dateType ?? JS_DATE;
     ctx.builders = config.builders ?? true;
     ctx.clientDirectives = new Set(config.clientDirectives ?? []);
     ctx.rootDir = root;
@@ -74,6 +75,8 @@ export function generate(root, config = loadConfig(root), sources = new Map()) {
     for (const c of components.values())
         for (const f of c.props.fields)
             requireWhole(c, f.ty);
+    for (const c of components.values())
+        refuseNestedDates(c, c.props.fields, c.propsAt);
     const scopes = read.map((r) => scopeFor(r.comp, r.ast, components).scope);
     const analysed = prepareDynamic(read.map((r, i) => ({ ...r, scope: scopes[i] })));
     const all = read.map((r, i) => ({ comp: r.comp, ssr: analysed[i], children: scopes[i].children, attrsBindings: scopes[i].attrsBindings }));

package/dist/component.js

@@ -213,10 +213,10 @@ export function readComponent(file, root, name = basename(file, ".vue")) {
     if (!propsTy) {
     }
     else if (propsTy.type === "TSTypeLiteral") {
-        comp.props = structOf(comp, "Props", propsTy.members, comp.structs);
+        comp.props = structOf(comp, "Props", propsTy.members, comp.structs, false, true);
     }
     else if (propsTy.type === "TSTypeReference" && comp.structs.has(propsTy.typeName.name)) {
-        reachLocal(comp, propsTy.typeName.name);
+        reachLocal(comp, propsTy.typeName.name, true);
         const st = comp.structs.get(propsTy.typeName.name);
         const refused = st.refused?.values().next().value;
         if (refused !== undefined)
@@ -246,6 +246,7 @@ export function readComponent(file, root, name = basename(file, ".vue")) {
             comp.models.set(d.id.name, named);
         }
     }
+    comp.propsAt = propsTy;
     const defaults = runtimeDefaults(comp, script?.content ?? "");
     for (const f of comp.props.fields) {
         if (f.ty.k !== "opt")

package/dist/context.d.ts

@@ -49,6 +49,10 @@ export interface Config {
      * `crate::render::Trusted<'a>`. `ferrovue::InlineHtml` makes every `TrustedHtml` prop inline HTML.
      * Without it, only an `InlineHtml` prop may reach `v-html`. */
     trustedHtml?: string;
+    /** The Rust type a `Date` prop is, which must implement `ferrovue::JsTime`:
+     * `ferrovue::JsDate` by default, or `chrono::DateTime<chrono::Utc>` with the crate's `chrono`
+     * feature. */
+    dateType?: string;
     /** A JSON file listing the app's routes as vue-router paths (`/users/:id`), which `<RouterLink>`
      * resolves against, or `{ pages }`: a folder of pages whose file names give the routes, as
      * vue-router's file-based routing reads them. Without it, a component cannot use `<RouterLink>`. */
@@ -126,6 +130,8 @@ export declare function checkConfig(raw: unknown, file: string, warn: (warning:
 export declare function tyOfName(name: TypeName): Ty;
 /** The Rust type of an `InlineHtml` prop, and of a `TrustedHtml` one when `trustedHtml` names it. */
 export declare const INLINE_HTML = "ferrovue::InlineHtml";
+/** The Rust type of a `Date` prop when `dateType` names none. */
+export declare const JS_DATE = "ferrovue::JsDate";
 /** Where `TrustedHtml` comes from. Only that import names the type `v-html` will write raw. */
 export declare const TYPES_MODULE = "ferrovue/types";
 export declare const ctx: {
@@ -137,6 +143,7 @@ export declare const ctx: {
     }>;
     helperModule: string | null;
     trustedHtml: string | null;
+    dateType: string;
     builders: boolean;
     clientDirectives: Set<string>;
     plugins: readonly Plugin[];

package/dist/context.js

@@ -100,7 +100,7 @@ export function checkConfig(raw, file, warn, schema = CONFIG_SCHEMA) {
     if (raw.builders !== undefined && typeof raw.builders !== "boolean") {
         throw new GenError("FV1106", `\`builders\` in ${file} is \`true\` or \`false\`: whether each props struct gets \`new()\` and a setter per optional field`, { file });
     }
-    for (const key of ["$schema", "stores", "trustedHtml", "viteRoot"])
+    for (const key of ["$schema", "stores", "trustedHtml", "dateType", "viteRoot"])
         string(raw, key, key);
     if (raw.isProduction !== undefined && typeof raw.isProduction !== "boolean")
         wrong("isProduction", "`true` or `false`: whether `@vitejs/plugin-vue` compiles for production");
@@ -216,12 +216,15 @@ export function tyOfName(name) {
 }
 /** The Rust type of an `InlineHtml` prop, and of a `TrustedHtml` one when `trustedHtml` names it. */
 export const INLINE_HTML = "ferrovue::InlineHtml";
+/** The Rust type of a `Date` prop when `dateType` names none. */
+export const JS_DATE = "ferrovue::JsDate";
 /** Where `TrustedHtml` comes from. Only that import names the type `v-html` will write raw. */
 export const TYPES_MODULE = "ferrovue/types";
 export const ctx = {
     helpers: {},
     helperModule: null,
     trustedHtml: null,
+    dateType: JS_DATE,
     builders: true,
     clientDirectives: new Set(),
     plugins: [],

package/dist/errors.d.ts

@@ -325,7 +325,7 @@ export declare const ERRORS: {
         readonly title: "Unsupported call";
     };
     readonly FV0604: {
-        readonly title: "Field read on a value that is not an object";
+        readonly title: "Field read on a value that is not an object, or that may be absent";
     };
     readonly FV0605: {
         readonly title: "Field the type does not have";
@@ -343,7 +343,7 @@ export declare const ERRORS: {
         readonly title: "Comparison between unsupported or absent values";
     };
     readonly FV0610: {
-        readonly title: "Spread or hole in an array literal";
+        readonly title: "Hole in an array literal";
     };
     readonly FV0611: {
         readonly title: "Array literal of different types";
@@ -399,6 +399,23 @@ export declare const ERRORS: {
     readonly FV0628: {
         readonly title: "`as` or `satisfies` stating a type the value does not have";
     };
+    readonly FV0629: {
+        readonly title: "Optional call `?.()`";
+    };
+    readonly FV0630: {
+        readonly title: "`??` between a list an optional chain computes and another list";
+    };
+    readonly FV0631: {
+        readonly title: "`in` or `instanceof`";
+        readonly detail: "`in` and `instanceof` read an object's keys and prototype as the page renders, which the server's typed values do not carry. Test a record's key with `Object.keys(r).includes(key)`.";
+    };
+    readonly FV0632: {
+        readonly title: "Bitwise or shift operator";
+    };
+    readonly FV0633: {
+        readonly title: "Part of JavaScript's own globals the server does not translate";
+        readonly detail: "`JSON`, `Math`, `Number`, `String` and the other globals a template may name are translated only in part: `JSON.stringify(x)` of one value, `String(x)`, `Number(x)` and the `Number.is…()` tests, the `Math` methods and constants the [`numbers`](crate::guide::numbers) page lists, `encodeURI` and `encodeURIComponent`. The message names what the server translates of the one used.";
+    };
     readonly FV0701: {
         readonly title: "`Number()` of an unsupported value";
     };
@@ -415,14 +432,14 @@ export declare const ERRORS: {
         readonly title: "`.toFixed()` without a literal number of digits from 0 to 100";
     };
     readonly FV0706: {
-        readonly title: "String that may hold half of a surrogate pair compared, searched or joined";
-        readonly detail: "`slice`, `substring`, `at`, `charAt` and `split(\"\")` can cut a surrogate pair in half. JavaScript keeps the half where ferrovue holds U+FFFD, so two such strings may compare, search or join differently. See [`strings`](crate::guide::strings#halves-of-surrogate-pairs).";
+        readonly title: "String that may hold half of a surrogate pair compared, searched, joined or encoded";
+        readonly detail: "`slice`, `substring`, `substr`, `at`, `charAt` and `split(\"\")` can cut a surrogate pair in half. JavaScript keeps the half where ferrovue holds U+FFFD, so two such strings may compare, search or join differently, `charCodeAt` and `codePointAt` would read U+FFFD's code, and `encodeURI` and `encodeURIComponent`, which throw a `URIError` on a half, would encode U+FFFD. See [`strings`](crate::guide::strings#halves-of-surrogate-pairs).";
     };
     readonly FV0707: {
         readonly title: "`JSON.stringify()` of an unsupported value";
     };
     readonly FV0708: {
-        readonly title: "Template literal of values that are not present strings, numbers or booleans";
+        readonly title: "Template literal of a value it cannot write";
     };
     readonly FV0709: {
         readonly title: "String method with the wrong number of arguments";
@@ -445,6 +462,33 @@ export declare const ERRORS: {
     readonly FV0715: {
         readonly title: "Case mapping by the server's locale";
     };
+    readonly FV0716: {
+        readonly title: "`.toPrecision()` without a literal precision from 1 to 100";
+    };
+    readonly FV0717: {
+        readonly title: "`.toExponential()` without a literal number of digits from 0 to 100";
+    };
+    readonly FV0718: {
+        readonly title: "`isNaN()`, `isFinite()` or a `Number.is…()` test of a value that is not a number";
+        readonly detail: "`Number.isNaN()`, `Number.isFinite()`, `Number.isInteger()` and `Number.isSafeInteger()` take a number, present or optional, and are `false` for any other value, which they do not convert; the global `isNaN()` and `isFinite()` convert theirs as `Number()` does and take a present number. Test a date with `Number.isNaN(d.getTime())`, and a string with `Number.isNaN(Number(s))`.";
+    };
+    readonly FV0719: {
+        readonly title: "`Math` function engines round differently";
+        readonly detail: "`Math.cbrt`, `Math.hypot`, `Math.exp`, `Math.log`, the trigonometric functions and their kin are computed by each JavaScript engine's own routine, which the specification leaves free to round differently, and Rust's do not promise V8's digits either. Compute the value in Rust and pass it as a prop.";
+    };
+    readonly FV0720: {
+        readonly title: "`**` or `Math.pow()` other than an exact integer power known when compiling";
+        readonly detail: "Engines compute powers by different routines: Node 22's V8 writes `10 ** -20` as `1.0000000000000001e-20`, Node 24's and Firefox's as `1e-20`, and above 2⁵³ they round in their own ways. The compiler works out `a ** b` and `Math.pow(a, b)` when both are known, `a` an integer and `b` a whole number from 0, with a result within ±2⁵³, which every engine gives exactly.";
+    };
+    readonly FV0721: {
+        readonly title: "Value that may be `null` or `undefined` written as a string";
+    };
+    readonly FV0722: {
+        readonly title: "`typeof` the compiler cannot work out";
+    };
+    readonly FV0723: {
+        readonly title: "`String()`, `.concat()` or `encodeURI…()` of a value it cannot write";
+    };
     readonly FV0801: {
         readonly title: "`.includes()` of a value of another type than the list's";
     };
@@ -514,6 +558,36 @@ export declare const ERRORS: {
     readonly FV0823: {
         readonly title: "`v-for` key or index that is not a plain name";
     };
+    readonly FV0824: {
+        readonly title: "List item read by an index that is not an integer";
+    };
+    readonly FV0825: {
+        readonly title: "`.at()` of a list given anything but one number";
+    };
+    readonly FV0826: {
+        readonly title: "`.indexOf()` or `.lastIndexOf()` given anything but one value of the list's type";
+    };
+    readonly FV0827: {
+        readonly title: "`.concat()` of anything but lists of the same item type";
+    };
+    readonly FV0828: {
+        readonly title: "`.reduce()` or `.reduceRight()` without an initial value";
+    };
+    readonly FV0829: {
+        readonly title: "`.reduce()` or `.reduceRight()` whose accumulator changes type or is not a string, number or boolean";
+    };
+    readonly FV0830: {
+        readonly title: "`.toSorted()` with a comparator of a shape the server does not order by";
+    };
+    readonly FV0831: {
+        readonly title: "`.toSorted()` without a comparator of a list of objects";
+    };
+    readonly FV0832: {
+        readonly title: "`.sort()` or `.reverse()` of a list in place";
+    };
+    readonly FV0833: {
+        readonly title: "Array spread of anything but lists of the same item type";
+    };
     readonly FV0901: {
         readonly title: "Slots that are not an object literal";
     };
@@ -782,6 +856,7 @@ export declare const ERRORS: {
     };
     readonly FV1234: {
         readonly title: "`typeof` of anything but a query value";
+        readonly retired: "0.9.0";
     };
     readonly FV1235: {
         readonly title: "`??` after a query value with a fallback that is not a string";
@@ -1083,12 +1158,28 @@ export declare const ERRORS: {
     };
     readonly FV1804: {
         readonly title: "`Date` method or function ferrovue does not translate";
-        readonly detail: "A date is read with `.toISOString()`, `.getTime()`, `.valueOf()` and the `.getUTC…()` methods, which do not depend on the time zone. The local getters (`.getFullYear()`, `.getHours()`), `.getTimezoneOffset()` and `.toString()` read the time zone of the machine running them, which differs between the server and the reader's browser. See [`dates_and_prices`](crate::guide::dates_and_prices).";
+        readonly detail: "A date is read with `.toISOString()`, `.toUTCString()`, `.toJSON()`, `.getTime()`, `.valueOf()` and the `.getUTC…()` methods, which do not depend on the time zone. The local getters (`.getFullYear()`, `.getHours()`), `.getTimezoneOffset()` and `.toString()` read the time zone of the machine running them, which differs between the server and the reader's browser. See [`dates_and_prices`](crate::guide::dates_and_prices).";
     };
     readonly FV1805: {
         readonly title: "Locale formatting with `Intl`, `.toLocaleString()`, `.localeCompare()`, `$d` or `$n`";
         readonly detail: "`Intl` formats from locale data each JavaScript engine ships, and Node, Chromium, Firefox and Safari write some dates, times and numbers differently (spaces, separators, abbreviations), so no server can write what every reader's browser writes. This refusal is permanent. Format the value in Rust and pass it as a string prop, or write it with `.toFixed()` and `.toISOString()` into a message `$t` translates. See [`dates_and_prices`](crate::guide::dates_and_prices).";
     };
+    readonly FV1806: {
+        readonly title: "`Date` anywhere but a component's own prop";
+        readonly detail: "A prop typed `Date` (optional or nullable too) is a `ferrovue::JsDate`, or the type `dateType` names, and an island's `data-props` carries it as its ISO string, which the client turns back into a `Date` because the prop's declared type says it is one. A `Date` inside a list, a dictionary or an object prop, and one in an interface the props do not declare, in Pinia state, `inject`, `ref` or `defineModel`, have no declared type the client could read, so they would reach the browser as strings. Pass the ISO string or the number of milliseconds and build the date with `new Date()`. See [`dates_and_prices`](crate::guide::dates_and_prices).";
+    };
+    readonly FV1807: {
+        readonly title: "`Date.UTC()` of anything but one to seven numbers that are present";
+        readonly detail: "`Date.UTC(year, month, date, hours, minutes, seconds, ms)` takes numbers, each truncated toward zero, the month counted from 0. A value that may be absent would give `NaN` for `undefined` and `0` for `null`: narrow it with `v-if` or give it a default. See [`dates_and_prices`](crate::guide::dates_and_prices).";
+    };
+    readonly FV1808: {
+        readonly title: "`Date.UTC()` of parts engines compute differently";
+        readonly detail: "V8 computes a year beyond ±1,000,000, a month beyond ±10,000,000 and a year before −399,999 by rules of its own, which Firefox and Safari do not share, so a day or hours that bring the date back within the range give another date in each; and Node rounds a part worth more than 2⁵³ ms that the others bring back within the range otherwise than the browsers. Literal parts are checked when the component is compiled; parts from the props are checked as it renders, and `js_date_utc` panics on them. See [`dates_and_prices`](crate::guide::dates_and_prices).";
+    };
+    readonly FV1809: {
+        readonly title: "`===`, `!==`, `==` or `!=` with a `Date`";
+        readonly detail: "Two `Date`s are equal in JavaScript only when they are one object, so two dates of the same time are unequal, and `==` with a string compares the date's `.toString()`, in the time zone of the machine running it. Compare time values: `a.getTime() === b.getTime()`. `<`, `<=`, `>` and `>=` between two dates compare their time values, and are false when either is invalid. See [`dates_and_prices`](crate::guide::dates_and_prices).";
+    };
 };
 /** A stable error code, as `FV0604`. */
 export type Code = keyof typeof ERRORS;