ferrovue 0.7.2 → 0.9.0

package/dist/rust.d.ts

@@ -7,7 +7,7 @@ export declare function structSource(st: Struct, comp: Component, doc: string):
 /** The version of generated code this compiler writes, which `mod.rs` hands `ferrovue::__compat!`:
  * the highest version the `ferrovue` crate of the same release supports. RELEASING.md says when
  * it changes. */
-export declare const GENERATED_VERSION = 1;
+export declare const GENERATED_VERSION = 3;
 /** How every file ferrovue writes begins. */
 export declare const GENERATED = "// @generated by ferrovue";
 export declare function header(source: string, edit?: string): string;

package/dist/rust.js

@@ -7,7 +7,7 @@ import { childOf } from "./expr.js";
 import { Emitter } from "./emitter.js";
 import { occurrences } from "./parens.js";
 import { statements } from "./template.js";
-import { inlineCssVars } from "./styles.js";
+import { cssVarsReads, inlineCssVars } from "./styles.js";
 import { slotFieldBorrows, slotFieldTy, slotTypeName } from "./slots.js";
 import { extraParams, fieldInit, takesSlots } from "./children.js";
 import { paramsOf, renderParams, slotContextOf, slotFieldsOf } from "./plugin.js";
@@ -33,6 +33,8 @@ export function needsLifetime(ty, comp, seen = new Set()) {
         }
         case "html":
             return !ty.inline && (ctx.trustedHtml?.includes("'a") ?? false);
+        case "date":
+            return ctx.dateType.includes("'a");
         default:
             return false;
     }
@@ -75,13 +77,26 @@ export function rustTy(ty, comp) {
             throw new GenError("FV0309", "no Rust type for `undefined`");
     }
 }
+/** The Rust type of a struct's field: a prop's own `Date` is the type `dateType` names. */
+function fieldTy(ty, comp) {
+    if (ty.k === "date")
+        return ctx.dateType;
+    if (ty.k === "opt" && ty.of.k === "date")
+        return `Option<${ctx.dateType}>`;
+    return rustTy(ty, comp);
+}
 function param(ty, comp, arg) {
     if (ty.k === "str")
         return { ty: "impl Into<Cow<'a, str>>", value: `${arg}.into()` };
     if (ty.k === "list" && ty.of.k === "str") {
         return { ty: "impl IntoIterator<Item = impl Into<Cow<'a, str>>>", value: `${arg}.into_iter().map(Into::into).collect()` };
     }
-    return { ty: rustTy(ty, comp), value: arg };
+    return { ty: fieldTy(ty, comp), value: arg };
+}
+function serdeAttrs(f) {
+    const absent = f.ty.k === "opt" && f.ty.none === undefined;
+    const date = f.ty.k === "date" ? ', with = "fv::date_prop"' : f.ty.k === "opt" && f.ty.of.k === "date" ? `${absent ? "" : ", default"}, with = "fv::opt_date_prop"` : "";
+    return `    #[serde(rename = ${rustStr(f.js)}${absent ? ', default, skip_serializing_if = "Option::is_none"' : ""}${date})]`;
 }
 function absentNote(optional) {
     const nulls = optional.filter((f) => f.ty.k === "opt" && f.ty.none === "null").length;
@@ -124,10 +139,7 @@ export function structSource(st, comp, doc) {
     const life = structLifetime(st, comp) ? "<'a>" : "";
     const fields = st.fields
         .map((f) => {
-        const attrs = f.ty.k === "opt" && f.ty.none === undefined
-            ? `    #[serde(rename = ${rustStr(f.js)}, default, skip_serializing_if = "Option::is_none")]`
-            : `    #[serde(rename = ${rustStr(f.js)})]`;
-        return `${attrs}\n    pub ${f.rust}: ${rustTy(f.ty, comp)},`;
+        return `${serdeAttrs(f)}\n    pub ${f.rust}: ${fieldTy(f.ty, comp)},`;
     })
         .join("\n");
     const derives = st.fields.some((f) => f.ty.k !== "opt") ? "Debug, Clone" : "Debug, Clone, Default";
@@ -141,7 +153,7 @@ ${ctx.builders ? `\n${builderSource(st, comp, life)}\n` : ""}`;
 /** The version of generated code this compiler writes, which `mod.rs` hands `ferrovue::__compat!`:
  * the highest version the `ferrovue` crate of the same release supports. RELEASING.md says when
  * it changes. */
-export const GENERATED_VERSION = 1;
+export const GENERATED_VERSION = 3;
 /** How every file ferrovue writes begins. */
 export const GENERATED = "// @generated by ferrovue";
 export function header(source, edit = "the `.vue` file") {
@@ -222,7 +234,7 @@ export function componentSource(comp, ast, ssr, components) {
     if (takesAttrs(comp) && comp.inheritAttrs && comp.attrsDropped) {
         fail(comp, "FV0416", `a root \`<Transition>\` or \`<KeepAlive>\` around a \`v-if\` in ${comp.name}, which a parent passes attributes: Vue's server drops them, where its client puts them on the element; set \`inheritAttrs: false\` and bind \`$attrs\` on the element`, comp.attrsDropped);
     }
-    const { scope, lets } = scopeFor(comp, ast, components);
+    const { scope, lets, lazies } = scopeFor(comp, ast, components);
     const program = parseJs(ssr, { sourceType: "module" }).program;
     tagAst(program, "template");
     const fn = program.body.find((s) => s.type === "ExportNamedDeclaration" && s.declaration?.id?.name === "ssrRender")?.declaration;
@@ -230,7 +242,8 @@ export function componentSource(comp, ast, ssr, components) {
         fail(comp, "FV0006", "the compiled template has no `ssrRender`");
     const e = new Emitter();
     const preludes = ctx.plugins.flatMap((p) => (p.prelude ? [p.prelude(scope)] : []));
-    const opening = [...preludes.flatMap((p) => p.before), ...lets, ...preludes.flatMap((p) => p.after)];
+    const forced = [...cssVarsReads(fn.body.body)].flatMap((name) => (lazies.has(name) ? [`std::cell::LazyCell::force(&${lazies.get(name)});`] : []));
+    const opening = [...preludes.flatMap((p) => p.before), ...lets, ...forced, ...preludes.flatMap((p) => p.after)];
     for (const l of opening)
         e.stmt(l);
     statements(scope, e, inlineCssVars(comp, fn.body.body));

package/dist/schema.js

@@ -37,6 +37,7 @@ export const CONFIG_SCHEMA = {
             },
         },
         trustedHtml: STRING,
+        dateType: { type: "string", default: "ferrovue::JsDate" },
         routes: ROUTES,
         router: {
             type: "object",

package/dist/script.d.ts

@@ -10,4 +10,5 @@ export declare function asyncChildren(comp: Component, ast: N[]): Map<string, st
 export declare function scopeFor(comp: Component, ast: N[], components: Map<string, Component>): {
     scope: Scope;
     lets: string[];
+    lazies: Map<string, string>;
 };

package/dist/script.js

@@ -6,7 +6,7 @@ import { constOfDecl, declareConsts } from "./constants.js";
 import { localTy } from "./rust.js";
 import { expr, fieldVal, typedBy } from "./expr.js";
 import { collected, heldList } from "./lists.js";
-import { bare, operand, UNARY } from "./parens.js";
+import { bare, occurrences, operand, UNARY } from "./parens.js";
 import { known } from "./narrowing.js";
 import { heldStr, isTemporary } from "./strings.js";
 import { intFromF64 } from "./numbers.js";
@@ -126,6 +126,36 @@ export function asyncChildren(comp, ast) {
     }
     return found;
 }
+const PANICS = /\bfv::js_(?:repeat|pad_start|pad_end|date_parse|date_utc|to_iso_string)\(|\bfv_i18n\.t\(/;
+function mayPanic(scope, lazies, init) {
+    if (PANICS.test(init))
+        return true;
+    if ([...scope.helpers.values()].some((h) => init.includes(`${ctx.helpers[h].rust}(`)))
+        return true;
+    return [...lazies.values()].some((name) => occurrences(init, name) > 0);
+}
+function binding(v) {
+    const lone = v.lone ? { lone: true } : {};
+    if (v.slice)
+        return { init: bare(v.code), read: (at) => ({ code: at, ty: v.ty, slice: true, ...lone }) };
+    if (v.ty.k === "list" && v.iter !== undefined)
+        return { init: collected(v), read: (at) => heldList(at, v.ty.k === "list" ? v.ty.of : v.ty, v.lone) };
+    if (v.held !== undefined)
+        return { init: v.held, read: (at) => ({ code: `${at}.as_deref()`, ty: v.ty, ...lone }) };
+    if (v.ty.k === "int" && v.f64 !== undefined && (v.code.endsWith(" as i64") || Object.is(v.num, -0))) {
+        return {
+            init: bare(v.f64),
+            read: (at) => ({ ...intFromF64(at), ...lone, ...(v.num !== undefined ? { num: v.num } : {}), ...(v.konst !== undefined ? { konst: v.konst } : {}) }),
+        };
+    }
+    if (isTemporary(v))
+        return { init: heldStr(v), read: (at) => ({ code: `&*${at}`, ty: v.ty, ...lone }) };
+    const place = v.ty.k === "list" || v.ty.k === "record" || v.ty.k === "struct" || v.ty.k === "child";
+    return {
+        init: place ? `&${operand(v.code, UNARY)}` : bare(v.code),
+        read: (at) => ({ code: at, ty: v.ty, ...lone, ...(v.konst !== undefined ? { konst: v.konst } : {}) }),
+    };
+}
 export function scopeFor(comp, ast, components) {
     const scope = {
         comp,
@@ -168,6 +198,7 @@ export function scopeFor(comp, ast, components) {
     };
     const locals = declareConsts(comp, ast);
     const lets = [];
+    const lazies = new Map();
     const asyncs = asyncChildren(comp, ast);
     let useAttrsName = null;
     let useSlotsName = null;
@@ -284,6 +315,7 @@ export function scopeFor(comp, ast, components) {
             const isRef = init0.type === "CallExpression" && init0.callee.type === "Identifier" && ["ref", "shallowRef", "computed"].includes(init0.callee.name);
             if (isRef)
                 scope.refs.add(local);
+            const isComputed = isRef && init0.callee.name === "computed";
             const typed = isRef ? init0.typeParameters?.params?.[0] : (d.id.typeAnnotation?.typeAnnotation ?? statedTy(init0));
             const untyped = setupSource(init0);
             const source = untyped && typed ? typedBy(untyped, typed) : untyped;
@@ -299,7 +331,7 @@ export function scopeFor(comp, ast, components) {
             catch (e) {
                 if (!(e instanceof GenError))
                     throw e;
-                scope.clientOnly.set(local, e.message.replace(/^[^:]*: /, ""));
+                scope.clientOnly.set(local, e.what);
                 continue;
             }
             if (nothing(v.ty) || (v.ty.k === "str" && known(v) !== undefined)) {
@@ -307,36 +339,13 @@ export function scopeFor(comp, ast, components) {
                 continue;
             }
             const name = `s_${snake(local).replace(/^r#/, "")}`;
-            const lone = v.lone ? { lone: true } : {};
-            if (v.slice) {
-                lets.push(`let ${name} = ${bare(v.code)};`);
-                scope.setup.set(local, { code: name, ty: v.ty, slice: true, ...lone });
-                continue;
-            }
-            if (v.ty.k === "list" && v.iter !== undefined) {
-                lets.push(`let ${name} = ${collected(v)};`);
-                scope.setup.set(local, heldList(name, v.ty.of, v.lone));
-                continue;
-            }
-            if (v.held !== undefined) {
-                lets.push(`let ${name} = ${v.held};`);
-                scope.setup.set(local, { code: `${name}.as_deref()`, ty: v.ty, ...lone });
-                continue;
-            }
-            if (v.ty.k === "int" && v.f64 !== undefined && (v.code.endsWith(" as i64") || Object.is(v.num, -0))) {
-                lets.push(`let ${name} = ${bare(v.f64)};`);
-                scope.setup.set(local, { ...intFromF64(name), ...lone, ...(v.num !== undefined ? { num: v.num } : {}), ...(v.konst !== undefined ? { konst: v.konst } : {}) });
-                continue;
-            }
-            if (isTemporary(v)) {
-                lets.push(`let ${name} = ${heldStr(v)};`);
-                scope.setup.set(local, { code: `&*${name}`, ty: v.ty, ...lone });
-                continue;
-            }
-            const place = v.ty.k === "list" || v.ty.k === "record" || v.ty.k === "struct" || v.ty.k === "child";
-            lets.push(`let ${name} = ${place ? `&${operand(v.code, UNARY)}` : bare(v.code)};`);
-            scope.setup.set(local, { code: name, ty: v.ty, ...lone, ...(v.konst !== undefined ? { konst: v.konst } : {}) });
+            const { init, read } = binding(v);
+            const lazy = isComputed && mayPanic(scope, lazies, init);
+            lets.push(lazy ? `let ${name} = std::cell::LazyCell::new(|| ${init});` : `let ${name} = ${init};`);
+            scope.setup.set(local, read(lazy ? `(*${name})` : name));
+            if (lazy)
+                lazies.set(local, name);
         }
     }
-    return { scope, lets };
+    return { scope, lets, lazies };
 }

package/dist/strings.d.ts

@@ -1,4 +1,5 @@
 import { type Component, type N, type Scope, type Val } from "./model.ts";
+import type { Code } from "./errors.ts";
 export declare function lonely(what: string): string;
 export declare function meet(comp: Component, a: Val, b: Val, what: string, n: N, how: "equal" | "order" | "search" | "join"): void;
 export declare function loneOf(...vs: (Val | undefined)[]): {
@@ -12,5 +13,12 @@ export declare function heldStr(v: Val): string;
 export declare function yieldsCow(code: string): boolean;
 export declare function unquote(literal: string): string;
 export declare function stringsEqual(a: Val, b: Val): string;
-export declare function formatted(comp: Component, parts: (string | Val)[], n: N, what: string): Val;
+/**
+ * `v` as JavaScript's `String()` and a template literal write it, where that is not the value
+ * itself: an absent value as `undefined` or `null`, a list as its items joined by `,` (an absent
+ * item as nothing). Strings, numbers and booleans are returned as they are; any other value is
+ * refused with `code`.
+ */
+export declare function stringOf(comp: Component, v: Val, n: N, what: string, code: Code): Val;
+export declare function formatted(comp: Component, given: (string | Val)[], n: N, what: string): Val;
 export declare function stringMethod(s: Scope, target: Val, method: string, args: N[], n: N): Val | null;

package/dist/strings.js

@@ -1,7 +1,7 @@
-import { BOOL, fail, INT, opt, rustStr, STR } from "./model.js";
+import { BOOL, fail, FLOAT, INT, nothing, opt, rustStr, STR } from "./model.js";
 import { atom, bare, binary, condition, enclosed, receiver, strArg } from "./parens.js";
-import { computed } from "./lists.js";
-import { expr } from "./expr.js";
+import { computed, items } from "./lists.js";
+import { describeTy, expr } from "./expr.js";
 import { known } from "./narrowing.js";
 import { asF64, isNumber } from "./numbers.js";
 export function lonely(what) {
@@ -30,7 +30,7 @@ export function isTemporary(v) {
     const trimmed = /^fv::js_trim(?:_start|_end)?\(([^]*)\)$/.exec(v.code);
     if (trimmed?.[1] !== undefined)
         return isTemporary({ code: trimmed[1].replace(/^&(?!\*)/, "&*"), ty: v.ty });
-    return /^&\*(?!\**[\w.]+$)/.test(v.code) || /\.unwrap_or\(&\*(?!\**[\w.]+\)$)/.test(v.code);
+    return /^&\*(?!\**[\w.]+$|\(\*\w+\)$)/.test(v.code) || /\.unwrap_or\(&\*(?!\**[\w.]+\)$)/.test(v.code);
 }
 export function asCow(v) {
     if (!isTemporary(v))
@@ -54,7 +54,7 @@ export function heldStr(v) {
     return owned !== undefined && enclosed(`(${owned})`) ? owned : cow;
 }
 export function yieldsCow(code) {
-    const routine = /^fv::js_(?:slice|substring|replace|replace_all|pad_start|pad_end)(?=\()/.exec(code);
+    const routine = /^fv::js_(?:slice|substring|substr|replace|replace_all|pad_start|pad_end)(?=\()/.exec(code);
     if (routine !== null)
         return enclosed(code.slice(routine[0].length));
     const marker = ".unwrap_or(";
@@ -78,10 +78,64 @@ export function stringsEqual(a, b) {
         return `${receiver(a.code === '""' ? b.code : a.code)}.is_empty()`;
     return binary(a.code, "==", b.code);
 }
-export function formatted(comp, parts, n, what) {
+const SCALAR = new Set(["str", "int", "float", "bool"]);
+/**
+ * `v` as JavaScript's `String()` and a template literal write it, where that is not the value
+ * itself: an absent value as `undefined` or `null`, a list as its items joined by `,` (an absent
+ * item as nothing). Strings, numbers and booleans are returned as they are; any other value is
+ * refused with `code`.
+ */
+export function stringOf(comp, v, n, what, code) {
+    if (SCALAR.has(v.ty.k))
+        return v;
+    if (nothing(v.ty))
+        return { code: rustStr(v.ty.k === "null" ? "null" : "undefined"), ty: STR };
+    const lone = loneOf(v);
+    const written = (arg) => ({ code: `&*format!("{}", ${arg})`, ty: STR, format: { text: "{}", args: [arg] }, ...lone });
+    if (v.ty.k === "opt" && SCALAR.has(v.ty.of.k)) {
+        if (v.ty.none === "either") {
+            fail(comp, "FV0721", `${what} of a value that may be \`null\` or \`undefined\`, which JavaScript writes as \`null\` or \`undefined\` and its Rust \`Option\` cannot tell apart: give it a fallback with \`??\``, n);
+        }
+        const word = rustStr(v.ty.none === "null" ? "null" : "undefined");
+        switch (v.ty.of.k) {
+            case "str":
+                return { code: `${atom(v.code)}.unwrap_or(${word})`, ty: STR, ...lone };
+            case "bool":
+                return written(`fv::JsOr(${atom(v.code)}.map(|v| if v { "true" } else { "false" }), ${word})`);
+            default:
+                return written(`fv::JsOr(${atom(v.code)}.map(fv::Js), ${word})`);
+        }
+    }
+    if (v.ty.k === "list") {
+        const of = v.ty.of;
+        const joined = (each) => ({ code: `&*${each}.collect::<Vec<_>>().join(",")`, ty: STR, ...lone });
+        if (of.k === "undef")
+            return { code: '""', ty: STR };
+        if (of.k === "str")
+            return joined(items(v));
+        if (of.k === "bool")
+            return joined(`${items(v)}.map(|v| if v { "true" } else { "false" })`);
+        if (of.k === "int" || of.k === "float")
+            return joined(`${items(v)}.map(|v| fv::Js(v).to_string())`);
+        if (of.k === "opt" && v.iter === undefined && SCALAR.has(of.of.k)) {
+            const each = `${atom(v.code)}.iter()`;
+            if (of.of.k === "str")
+                return joined(`${each}.map(|v| v.as_deref().unwrap_or(""))`);
+            if (of.of.k === "bool")
+                return joined(`${each}.map(|v| match v { Some(true) => "true", Some(false) => "false", None => "" })`);
+            return joined(`${each}.map(|v| v.map_or_else(String::new, |v| fv::Js(v).to_string()))`);
+        }
+    }
+    return fail(comp, code, `${what} of ${describeTy(v.ty)}: it writes strings, numbers and booleans, present or optional, and lists of them`, n);
+}
+function mayBeEmpty(v) {
+    return v.ty.k === "str" && !nonEmptyLiteral(v);
+}
+export function formatted(comp, given, n, what) {
     let fmt = "";
     const args = [];
     let before;
+    const parts = given.map((p) => (typeof p === "string" ? p : stringOf(comp, p, n, what, "FV0708")));
     const lone = loneOf(...parts.map((p) => (typeof p === "string" ? undefined : p)));
     for (const part of parts) {
         if (typeof part === "string" || (part.ty.k === "str" && known(part) !== undefined)) {
@@ -93,7 +147,8 @@ export function formatted(comp, parts, n, what) {
         }
         if (before)
             meet(comp, before, part, what, n, "join");
-        before = part;
+        if (!before?.lone || part.lone || !mayBeEmpty(part))
+            before = part;
         if (part.format) {
             fmt += part.format.text;
             args.push(...part.format.args);
@@ -103,10 +158,8 @@ export function formatted(comp, parts, n, what) {
             args.push(receiver(part.code).replace(/^(fv::Js\(.*\))\.to_string\(\)$/s, "$1"));
         else if (isNumber(part.ty))
             args.push(`fv::Js(${bare(part.code)})`);
-        else if (part.ty.k === "bool")
-            args.push(`if ${condition(part.code)} { "true" } else { "false" }`);
         else
-            fail(comp, "FV0708", "a template literal interpolates strings, numbers and booleans that are present", n);
+            args.push(`if ${condition(part.code)} { "true" } else { "false" }`);
         fmt += "{}";
     }
     if (!args.length)
@@ -114,6 +167,8 @@ export function formatted(comp, parts, n, what) {
     const one = parts.filter((p) => (typeof p === "string" ? p !== "" : p.code !== '""'));
     if (fmt === "{}" && one.length === 1 && typeof one[0] !== "string" && one[0].ty.k === "str")
         return one[0];
+    if (fmt === "{}" && one.length === 1 && typeof one[0] !== "string" && one[0].ty.k === "bool")
+        return { code: args[0], ty: STR };
     return { code: `&*format!(${rustStr(fmt)}, ${args.join(", ")})`, ty: STR, format: { text: fmt, args }, ...lone };
 }
 export function stringMethod(s, target, method, args, n) {
@@ -132,43 +187,76 @@ export function stringMethod(s, target, method, args, n) {
             fail(comp, "FV0711", `\`.${method}()\` takes a string that is present`, args[i]);
         return v;
     };
-    const num = (i, fallback) => {
+    const num = (i, fallback, absent) => {
         if (args[i] === undefined)
             return fallback;
         const v = expr(s, args[i]);
         if (v.ty.k === "undef")
             return fallback;
+        if (v.ty.k === "null")
+            return "0.0";
+        if (v.ty.k === "opt" && isNumber(v.ty.of) && v.ty.none !== "either") {
+            return `${atom(v.code)}.map_or(${v.ty.none === "null" ? "0.0" : absent}, |v| ${v.ty.of.k === "int" ? "v as f64" : "v"})`;
+        }
         if (!isNumber(v.ty))
-            fail(comp, "FV0712", `\`.${method}()\` takes a number that is present`, args[i]);
+            fail(comp, "FV0712", `\`.${method}()\` takes a number, present or optional`, args[i]);
         return asF64(v);
     };
     const cut = { lone: true };
+    const noHalves = () => {
+        if (target.lone)
+            fail(comp, "FV0706", lonely(`\`.${method}()\``), n);
+    };
     switch (method) {
         case "includes":
         case "startsWith":
         case "endsWith": {
-            arity(1, 1);
+            arity(1, 2);
             const x = str(0);
             meet(comp, target, x, `\`.${method}()\``, n, "search");
+            const at = num(1, "", method === "endsWith" ? "f64::INFINITY" : "0.0");
+            if (at) {
+                const rust = { includes: "includes_from", startsWith: "starts_with_at", endsWith: "ends_with_at" }[method];
+                return { code: `fv::js_${rust}(${t}, ${strArg(x.code)}, ${bare(at)})`, ty: BOOL };
+            }
             const rust = { includes: "contains", startsWith: "starts_with", endsWith: "ends_with" }[method];
             return { code: `${receiver(target.code)}.${rust}(${bare(x.code)})`, ty: BOOL };
         }
         case "indexOf":
         case "lastIndexOf": {
-            arity(1, 1);
+            arity(1, 2);
             const x = str(0);
             meet(comp, target, x, `\`.${method}()\``, n, "search");
-            return { code: `fv::js_${method === "indexOf" ? "index_of" : "last_index_of"}(${t}, ${strArg(x.code)})`, ty: INT };
+            const at = num(1, "", method === "indexOf" ? "0.0" : "f64::NAN");
+            const rust = method === "indexOf" ? "index_of" : "last_index_of";
+            if (at)
+                return { code: `fv::js_${rust}_from(${t}, ${strArg(x.code)}, ${bare(at)})`, ty: INT };
+            return { code: `fv::js_${rust}(${t}, ${strArg(x.code)})`, ty: INT };
         }
+        case "substr": {
+            arity(0, 2);
+            const length = num(1, "", "f64::INFINITY");
+            return { code: `&*fv::js_substr(${t}, ${num(0, "0.0", "0.0")}, ${length ? `Some(${bare(length)})` : "None"})`, ty: STR, ...cut };
+        }
+        case "charCodeAt":
+            arity(0, 1);
+            noHalves();
+            return { code: `fv::js_char_code_at(${t}, ${num(0, "0.0", "0.0")})`, ty: FLOAT };
+        case "codePointAt":
+            arity(0, 1);
+            noHalves();
+            return { code: `fv::js_code_point_at(${t}, ${num(0, "0.0", "0.0")})`, ty: opt(INT) };
+        case "concat":
+            return formatted(comp, [target, ...args.map((a) => stringOf(comp, expr(s, a), a, "`.concat()`", "FV0723"))], n, "`.concat()`");
         case "slice":
         case "substring": {
             arity(0, 2);
-            const end = num(1, "");
-            return { code: `&*fv::js_${method}(${t}, ${num(0, "0.0")}, ${end ? `Some(${end})` : "None"})`, ty: STR, ...cut };
+            const end = num(1, "", "f64::INFINITY");
+            return { code: `&*fv::js_${method}(${t}, ${num(0, "0.0", "0.0")}, ${end ? `Some(${end})` : "None"})`, ty: STR, ...cut };
         }
         case "at": {
             arity(1, 1);
-            const at = `fv::js_at(${t}, ${num(0, "0.0")})`;
+            const at = `fv::js_at(${t}, ${num(0, "0.0", "0.0")})`;
             if (!isTemporary(target))
                 return { code: at, ty: opt(STR), ...cut };
             const held = `${at}.map(|v| std::borrow::Cow::<str>::Owned(v.to_owned()))`;
@@ -176,12 +264,14 @@ export function stringMethod(s, target, method, args, n) {
         }
         case "charAt":
             arity(0, 1);
-            return { code: `${isTemporary(target) ? "&*" : ""}fv::js_char_at(${t}, ${num(0, "0.0")})`, ty: STR, ...cut };
+            return { code: `${isTemporary(target) ? "&*" : ""}fv::js_char_at(${t}, ${num(0, "0.0", "0.0")})`, ty: STR, ...cut };
         case "split": {
-            arity(1, 1);
+            arity(1, 2);
             const sep = str(0);
             meet(comp, target, sep, "`.split()`", n, "search");
-            return computed(`fv::js_split(${t}, ${strArg(sep.code)}).into_iter()`, STR, target.lone || !nonEmptyLiteral(sep));
+            const limit = num(1, "", "4_294_967_295.0");
+            const pieces = limit ? `fv::js_split_limit(${t}, ${strArg(sep.code)}, ${bare(limit)})` : `fv::js_split(${t}, ${strArg(sep.code)})`;
+            return computed(`${pieces}.into_iter()`, STR, target.lone || !nonEmptyLiteral(sep));
         }
         case "replace":
         case "replaceAll": {
@@ -202,7 +292,7 @@ export function stringMethod(s, target, method, args, n) {
             const whole = fill.code.startsWith('"') && !/[\u{10000}-\u{10FFFF}]/u.test(fill.code);
             if (fill.lone || (method === "padStart" && target.lone && !whole))
                 fail(comp, "FV0706", lonely(`\`.${method}()\``), n);
-            return { code: `&*fv::js_${method === "padStart" ? "pad_start" : "pad_end"}(${t}, ${num(0, "0.0")}, ${strArg(fill.code)})`, ty: STR, ...(target.lone || !whole ? cut : {}) };
+            return { code: `&*fv::js_${method === "padStart" ? "pad_start" : "pad_end"}(${t}, ${num(0, "0.0", "0.0")}, ${strArg(fill.code)})`, ty: STR, ...(target.lone || !whole ? cut : {}) };
         }
         case "repeat": {
             arity(1, 1);
@@ -212,7 +302,7 @@ export function stringMethod(s, target, method, args, n) {
             }
             if (target.lone)
                 fail(comp, "FV0706", lonely("`.repeat()`"), n);
-            return { code: `&*fv::js_repeat(${t}, ${num(0, "0.0")})`, ty: STR };
+            return { code: `&*fv::js_repeat(${t}, ${num(0, "0.0", "0.0")})`, ty: STR };
         }
         case "toLocaleUpperCase":
         case "toLocaleLowerCase":

package/dist/styles.d.ts

@@ -4,6 +4,9 @@ import { Emitter } from "./emitter.ts";
  * `<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 declare function inlineCssVars(comp: Component, body: N[]): N[];
+/** The setup bindings the `_cssVars` object reads, which Vue's server evaluates as its render
+ * starts. */
+export declare function cssVarsReads(body: N[]): Set<string>;
 export declare function mergedStyle(s: Scope, e: Emitter, n: N): void;
 export declare function styleAttr(s: Scope, n: N): string;
 export interface StyleItem {

package/dist/styles.js

@@ -72,6 +72,28 @@ export function inlineCssVars(comp, body) {
     swap(rest);
     return rest;
 }
+/** The setup bindings the `_cssVars` object reads, which Vue's server evaluates as its render
+ * starts. */
+export function cssVarsReads(body) {
+    const names = new Set();
+    const declared = body.find((st) => st.type === "VariableDeclaration" && st.declarations[0]?.id?.name === "_cssVars");
+    const walk = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        if (Array.isArray(n))
+            return n.forEach(walk);
+        if (n.type === "MemberExpression" && n.object.type === "Identifier" && (n.object.name === "$setup" || n.object.name === "_ctx")) {
+            const name = n.computed ? n.property.value : n.property.name;
+            if (typeof name === "string")
+                names.add(name);
+        }
+        for (const [k, v] of Object.entries(n))
+            if (k !== "loc" && v && typeof v === "object")
+                walk(v);
+    };
+    walk(declared?.declarations[0].init);
+    return names;
+}
 function cssVarOf(s, n) {
     const v = expr(s, n.value);
     const of = v.ty.k === "opt" ? v.ty.of : v.ty;

package/dist/typescript.d.ts

@@ -1,18 +1,26 @@
 import { type Component, type Field, type N, type Struct, type Ty } from "./model.ts";
 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 const DATE_PROPS_ONLY = "only a component's own prop may be a `Date`, which the client turns back into one from the prop's declared type: pass an ISO string or a number of milliseconds and build the date with `new Date()` (see the `dates_and_prices` guide)";
+/** A TypeScript type's type, where `dates` says whether it may be a `Date`: a component's own prop,
+ * which may be optional or nullable too. */
+export declare function tyOfTs(comp: Component, t: N, structs: Map<string, Struct>, seen?: Set<string>, dates?: boolean): 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;
+/** Translate an interface a component declares, the first time something the server renders
+ * reaches it; `dates` when it is the component's props. */
+export declare function reachLocal(comp: Component, name: string, dates?: boolean): 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 a value of the type holds a `Date` inside a list, a dictionary or an object. */
+export declare function holdsDate(comp: Component, ty: Ty, seen?: Set<Struct | Component>): boolean;
+/** Refuse a prop that holds a `Date` anywhere but as itself, optional or nullable. */
+export declare function refuseNestedDates(comp: Component, fields: Field[], node: N): 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;
@@ -23,7 +31,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>, lenient?: boolean): Struct;
+export declare function structOf(comp: Component, name: string, members: N[], structs: Map<string, Struct>, lenient?: boolean, dates?: 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;