ferrovue 0.1.0 → 0.2.0

package/dist/fixture.d.ts

@@ -0,0 +1,38 @@
+import { type App, type Component } from "vue";
+import { type RouteRecordRaw } from "vue-router";
+export interface Fixture {
+    props: Record<string, unknown>;
+    slots: Record<string, string>;
+    route: string;
+    stores: Record<string, unknown>;
+    /** `$locale`: the locale the fixture renders in, when the project translates. */
+    locale?: string | null;
+}
+/** A fixture's JSON, split into the props and the rest. */
+export declare function readFixture(json: Record<string, unknown>): Fixture;
+/** A route as a routes file lists it: a path, or a path and a name. */
+export type RouteEntry = string | {
+    path: string;
+    name?: string;
+    children?: RouteEntry[];
+};
+/** The router options ferrovue reproduces, as the project's configuration gives them. */
+export interface RouterOptions {
+    base?: string;
+    linkActiveClass?: string;
+    linkExactActiveClass?: string;
+    /** vue-i18n, when the project translates: every locale's messages, the default locale, and the
+     * fallbacks. */
+    i18n?: {
+        messages: Record<string, unknown>;
+        locale: string;
+        fallbackLocale?: string | string[];
+    };
+    /** Render on the client with `createApp`, rather than hydrate what the server rendered: the scope
+     * ids a fresh client render writes, which the server's must equal for scoped styles to apply. */
+    client?: boolean;
+}
+/** Route records for vue-router, every route — nested ones too — given the fixture's view. */
+export declare function routeRecords(routes: RouteEntry[], View: Component): RouteRecordRaw[];
+/** An app rendering one fixture of `component`: with a router over `routes` when there are any. */
+export declare function fixtureApp(component: Component, fixture: Fixture, routes: RouteEntry[] | null, options?: RouterOptions): Promise<App>;

package/dist/fixture.js

@@ -0,0 +1,78 @@
+/* An app rendering one conformance fixture with the real Vue: its props, its slots' content, the
+ * location it is rendered at under the real vue-router, Pinia's state and vue-i18n's locale.
+ *
+ * A fixture is a JSON object of props, plus keys that are not props:
+ * - `$slots`: each slot's content as HTML, rendered as a static node so both sides write it
+ *   exactly as given; `routerView` is the page `<RouterView>` shows.
+ * - `$route`: the reader's location, `/` when absent.
+ * - `$stores`: Pinia's state, by store id — every store the component reads, in full, because a
+ *   store absent here is built from its own `state()`, which the server never runs.
+ * - `$locale`: the locale, when the project translates.
+ *
+ * Nothing here reads a file or compiles anything, so a browser bundle can import it too: the
+ * browser hydration tests (`packages/ferrovue/browser/`) build the same app there. */
+import { createApp, createSSRApp, createStaticVNode, defineComponent, h } from "vue";
+import { createPinia } from "pinia";
+import { createMemoryHistory, createRouter } from "vue-router";
+import { createI18n } from "vue-i18n";
+/** A fixture's JSON, split into the props and the rest. */
+export function readFixture(json) {
+    const { $slots, $route, $stores, $locale, ...props } = json;
+    return {
+        props,
+        slots: ($slots ?? {}),
+        route: $route ?? "/",
+        stores: ($stores ?? {}),
+        locale: $locale ?? null,
+    };
+}
+/** The top-level nodes in a piece of HTML, which a static node needs to hydrate. */
+function nodeCount(html) {
+    const t = document.createElement("template");
+    t.innerHTML = html;
+    return t.content.childNodes.length;
+}
+const staticNode = (html) => createStaticVNode(html, nodeCount(html));
+/** Route records for vue-router, every route — nested ones too — given the fixture's view. */
+export function routeRecords(routes, View) {
+    return routes.map((r) => typeof r === "string"
+        ? { path: r, component: View }
+        : { path: r.path, component: View, ...(r.name ? { name: r.name } : {}), ...(r.children ? { children: routeRecords(r.children, View) } : {}) });
+}
+/** An app rendering one fixture of `component`: with a router over `routes` when there are any. */
+export async function fixtureApp(component, fixture, routes, options = {}) {
+    const slots = Object.fromEntries(Object.entries(fixture.slots)
+        .filter(([name]) => name !== "routerView")
+        .map(([name, html]) => [name, () => [staticNode(html)]]));
+    const app = (options.client ? createApp : createSSRApp)({ render: () => h(component, fixture.props, slots) });
+    // As the client hydrates: the state the server rendered with, set before any store is first used.
+    const pinia = createPinia();
+    pinia.state.value = structuredClone(fixture.stores);
+    app.use(pinia);
+    if (options.i18n) {
+        // Messages read from the project's files at run time: their schema is not known to TypeScript.
+        const i18nOptions = {
+            legacy: false,
+            locale: fixture.locale ?? options.i18n.locale,
+            ...(options.i18n.fallbackLocale !== undefined ? { fallbackLocale: options.i18n.fallbackLocale } : {}),
+            messages: options.i18n.messages,
+            missingWarn: false,
+            fallbackWarn: false,
+        };
+        app.use(createI18n(i18nOptions));
+    }
+    if (routes) {
+        const view = fixture.slots.routerView ?? "";
+        const View = defineComponent({ render: () => staticNode(view) });
+        const router = createRouter({
+            history: createMemoryHistory(options.base),
+            routes: routeRecords(routes, View),
+            ...(options.linkActiveClass !== undefined ? { linkActiveClass: options.linkActiveClass } : {}),
+            ...(options.linkExactActiveClass !== undefined ? { linkExactActiveClass: options.linkExactActiveClass } : {}),
+        });
+        app.use(router);
+        await router.push(fixture.route);
+        await router.isReady();
+    }
+    return app;
+}

package/dist/i18n.d.ts

@@ -0,0 +1,27 @@
+import { type N, type Scope, type Val } from "./model.ts";
+/** A locale's messages, each parsed by vue-i18n's own message compiler, by dotted key. */
+export interface LocaleMessages {
+    name: string;
+    file: string;
+    messages: Map<string, N>;
+}
+/** The configured vue-i18n setup, read once per run. */
+export interface I18nSetup {
+    /** The locale files' directory, as the configuration names it. */
+    dir: string;
+    locales: LocaleMessages[];
+    /** The locale a fixture renders in when it names none, and the fallbacks in order. */
+    locale: string;
+    fallback: string[];
+}
+/** Every message of every `*.json` locale file in the directory: nested objects joined with dots,
+ * as vue-i18n resolves a path — a nested key first, then a flat key of the same spelling. */
+export declare function readLocales(root: string, config: {
+    messages: string;
+    locale?: string;
+    fallbackLocale?: string | string[];
+}): I18nSetup;
+export declare function i18nSource(setup: I18nSetup): string;
+/** `t(key)`, `t(key, plural)`, `t(key, { named })`, `t(key, [list])`, `t(key, { named }, plural)`:
+ * the message translated in the request's locale. */
+export declare function translate(s: Scope, args: N[], n: N): Val;

package/dist/i18n.js

@@ -0,0 +1,175 @@
+/* vue-i18n: the locale files read and compiled to Rust tables, and `$t` / `useI18n().t` calls. */
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { createParser } from "@intlify/message-compiler";
+import { fail, GenError, rustStr, STR } from "./model.js";
+import { ctx } from "./context.js";
+import { expr } from "./expr.js";
+import { bare, strArg } from "./parens.js";
+import { header } from "./rust.js";
+/** The modifiers vue-i18n defines for linked messages; any other would throw in the browser. */
+const MODIFIERS = new Set(["upper", "lower", "capitalize"]);
+/** Every message of every `*.json` locale file in the directory: nested objects joined with dots,
+ * as vue-i18n resolves a path — a nested key first, then a flat key of the same spelling. */
+export function readLocales(root, config) {
+    const dir = join(root, config.messages);
+    const files = readdirSync(dir).filter((f) => f.endsWith(".json")).toSorted();
+    const parser = createParser({});
+    const locales = files.map((f) => {
+        const file = join(config.messages, f);
+        let data;
+        try {
+            data = JSON.parse(readFileSync(join(dir, f), "utf8"));
+        }
+        catch (e) {
+            throw new GenError(`${file}: ${e.message}`);
+        }
+        const messages = new Map();
+        const nested = new Map();
+        const flat = new Map();
+        const walk = (value, path) => {
+            if (typeof value === "string") {
+                const key = path.join(".");
+                // A key spelled with dots is reached only when no nested path is.
+                (path.length > 1 ? nested : flat).set(key, value);
+            }
+            else if (value && typeof value === "object" && !Array.isArray(value)) {
+                for (const [k, v] of Object.entries(value))
+                    walk(v, [...path, k]);
+            }
+        };
+        walk(data, []);
+        for (const [key, text] of [...flat, ...nested]) {
+            try {
+                messages.set(key, parser.parse(text));
+            }
+            catch (e) {
+                throw new GenError(`${file}: message \`${key}\`: ${e.message}`);
+            }
+        }
+        return { name: basename(f, ".json"), file, messages };
+    });
+    const fallback = config.fallbackLocale === undefined ? [] : Array.isArray(config.fallbackLocale) ? config.fallbackLocale : [config.fallbackLocale];
+    return { dir: config.messages, locales, locale: config.locale ?? "en", fallback };
+}
+/** A message's AST as the Rust `Message` literal: its cases, each a list of `Part`s. */
+function messageSource(file, key, ast) {
+    const body = ast.body;
+    const cases = body.type === 1 ? body.cases : [body];
+    const part = (item) => {
+        switch (item.type) {
+            case 3:
+                return `Part::Text(${rustStr(item.value)})`;
+            case 4:
+                return `Part::Named(${rustStr(item.key)})`;
+            case 5:
+                return `Part::List(${item.index})`;
+            case 9:
+                return `Part::Literal(${rustStr(item.value)})`;
+            case 6: {
+                if (item.key?.type !== 7)
+                    throw new GenError(`${file}: message \`${key}\` links to a key chosen at run time, which is not supported`);
+                const modifier = item.modifier?.value;
+                if (modifier !== undefined && !MODIFIERS.has(modifier)) {
+                    throw new GenError(`${file}: message \`${key}\` uses the modifier \`${modifier}\`, which vue-i18n does not define`);
+                }
+                return `Part::Linked { key: ${rustStr(item.key.value)}, modifier: ${modifier === undefined ? "None" : `Some(${rustStr(modifier)})`} }`;
+            }
+            default:
+                throw new GenError(`${file}: message \`${key}\` holds a construct ferrovue does not render (node type ${item.type})`);
+        }
+    };
+    const items = (c) => c.items ?? (c.static !== undefined ? [{ type: 3, value: c.static }] : []);
+    return `Message { cases: &[${cases.map((c) => `&[${items(c).map(part).join(", ")}]`).join(", ")}] }`;
+}
+/** Keys in the order Rust's `str` sorts them — byte order — for the table's binary search. */
+function byteOrder(a, b) {
+    return Buffer.compare(Buffer.from(a), Buffer.from(b));
+}
+export function i18nSource(setup) {
+    const locales = setup.locales
+        .map((l) => {
+        const keys = [...l.messages.keys()].toSorted(byteOrder);
+        const entries = keys.map((k) => `            (${rustStr(k)}, ${messageSource(l.file, k, l.messages.get(k))}),`).join("\n");
+        return `    Locale {
+        name: ${rustStr(l.name)},
+        messages: &[
+${entries}
+        ],
+    },`;
+    })
+        .join("\n");
+    return `${header(setup.dir.replace(/\/?$/, "/"), "the locale files")}
+//! The messages of every locale, compiled by vue-i18n's own message compiler.
+
+use ferrovue::i18n::{Locale, Message, Part};
+
+/// The locale a page renders in when it names none.
+pub const LOCALE: &str = ${rustStr(setup.locale)};
+
+/// The locales a missing message falls back to, in order.
+pub const FALLBACK: &[&str] = &[${setup.fallback.map(rustStr).join(", ")}];
+
+/// Every locale's messages.
+pub static LOCALES: &[Locale] = &[
+${locales}
+];
+
+/// The messages in \`locale\`, with the configured fallbacks: build one per request.
+pub fn i18n(locale: &str) -> ferrovue::I18n {
+    ferrovue::I18n::new(LOCALES, locale, FALLBACK)
+}
+`;
+}
+/** A value interpolated into a message, as \`ferrovue::i18n::Value\`. */
+function i18nValue(s, n) {
+    const v = expr(s, n);
+    switch (v.ty.k) {
+        case "str":
+            return `fv::i18n::Value::Str(${strArg(v.code)})`;
+        case "int":
+            return `fv::i18n::Value::Int(${bare(v.code)})`;
+        case "float":
+            return `fv::i18n::Value::Float(${bare(v.code)})`;
+        case "bool":
+            return `fv::i18n::Value::Bool(${bare(v.code)})`;
+        default:
+            return fail(s.comp, "a value given to `t()` is a string, a number or a boolean that is present: narrow an optional one with `v-if` first", n);
+    }
+}
+/** `t(key)`, `t(key, plural)`, `t(key, { named })`, `t(key, [list])`, `t(key, { named }, plural)`:
+ * the message translated in the request's locale. */
+export function translate(s, args, n) {
+    if (!ctx.i18n)
+        fail(s.comp, "`t()` needs `i18n` in ferrovue.config.json: where the locale files are", n);
+    if (args.length < 1 || args.length > 3)
+        fail(s.comp, "`t()` takes a key, then named values, a list or a plural number", n);
+    const key = expr(s, args[0]);
+    if (key.ty.k !== "str")
+        fail(s.comp, "the key given to `t()` is a string", args[0]);
+    let named = "&[]";
+    let list = "&[]";
+    let plural = "None";
+    for (const a of args.slice(1)) {
+        if (a.type === "ObjectExpression") {
+            const pairs = a.properties.map((p) => {
+                if (p.type !== "ObjectProperty" || p.computed)
+                    fail(s.comp, "named values hold plain keys", p);
+                return `(${rustStr(String(p.key.name ?? p.key.value))}, ${i18nValue(s, p.value)})`;
+            });
+            named = `&[${pairs.join(", ")}]`;
+        }
+        else if (a.type === "ArrayExpression") {
+            list = `&[${a.elements.map((el) => i18nValue(s, el)).join(", ")}]`;
+        }
+        else {
+            const v = expr(s, a);
+            if (v.ty.k === "str")
+                fail(s.comp, "a default message given to `t()` is not supported: add the message to the locale files", a);
+            if (v.ty.k !== "int")
+                fail(s.comp, "the plural number given to `t()` is an integer", a);
+            plural = `Some(${bare(v.code)})`;
+        }
+    }
+    return { code: `&*fv_i18n.t(${strArg(key.code)}, &fv::i18n::Args { named: ${named}, list: ${list}, plural: ${plural} })`, ty: STR };
+}

package/dist/lists.d.ts

@@ -0,0 +1,19 @@
+import { type N, type Scope, type Ty, type Val } from "./model.ts";
+/** A list as an iterator of its items, in the form a computed list holds them. */
+export declare function items(v: Val): string;
+/** A computed list: its iterator, and its items collected as `code` for anything that needs a
+ * `Vec`. */
+export declare function computed(iter: string, of: Ty, lone?: boolean): Val;
+/** A list of any kind as the `Vec` of items a computed list collects: what a branch of `?:` or a
+ * setup `let` holds, so that both branches have one type. Kept beyond the statement, its strings
+ * own their text, which may live in a temporary (`name.toUpperCase().split(" ")`). */
+export declare function collected(v: Val): string;
+/** The computed list a setup `let` named `name` holds, read again by item. */
+export declare function heldList(name: string, of: Ty, lone?: boolean): Val;
+/** A list method other than `includes` and `join`: `null` when `method` is not one of them. */
+export declare function listMethod(s: Scope, target: Val, method: string, args: N[], n: N): Val | null;
+/** `Object.keys(r)`, `Object.values(r)`, and `Object.entries(r)`, which is only a `v-for`'s source. */
+export declare function objectCall(s: Scope, method: string, args: N[], n: N): Val;
+/** `list.includes(x)` and `list.join(sep)` of a computed list, or of a list of fractions or
+ * booleans. */
+export declare function computedListMethod(s: Scope, target: Val, method: string, args: N[], n: N): Val | null;

package/dist/lists.js

@@ -0,0 +1,253 @@
+/* Lists a template computes: array methods taking arrow functions (`filter`, `map`, `some`,
+ * `every`, `find`, `findIndex`), `slice`, and `Object.keys` / `values` of a record.
+ *
+ * A computed list is an iterator of its items, each in one form whatever list it came from: a
+ * string as a `Cow<str>` (borrowed from the props, or owned when `map` made it), a number or a
+ * boolean copied, an object borrowed. That is what lets one method's result feed the next, a
+ * `v-for`, `.join` or `.length`, without knowing where it came from. */
+import { BOOL, fail, FLOAT, INT, opt, sameTy, STR } from "./model.js";
+import { ctx } from "./context.js";
+import { asCow, yieldsCow, asF64, cond, expr, fieldVal, isNumber, isTemporary, lonely, meet } from "./expr.js";
+import { atom, operand, strArg, UNARY } from "./parens.js";
+const COW = "std::borrow::Cow::<str>";
+/** The type of a list's items, which must be one these methods can pass along. */
+function itemsTy(s, v, n) {
+    if (v.ty.k !== "list")
+        return fail(s.comp, "not a list", n);
+    const of = v.ty.of;
+    if (!["str", "int", "float", "bool", "struct", "child"].includes(of.k)) {
+        fail(s.comp, "this method takes a list of strings, numbers, booleans or objects", n);
+    }
+    return of;
+}
+/** A list as an iterator of its items, in the form a computed list holds them. */
+export function items(v) {
+    if (v.iter !== undefined)
+        return v.iter;
+    const of = v.ty.k === "list" || v.ty.k === "record" ? v.ty.of : v.ty;
+    // A list of strings holds `Cow`s, an array literal `&str`s: either way `&**v` is the `&str`.
+    if (of.k === "str")
+        return `${atom(v.code)}.iter().map(|v| ${COW}::Borrowed(&**v))`;
+    if (of.k === "struct" || of.k === "child")
+        return `${atom(v.code)}.iter()`;
+    return `${atom(v.code)}.iter().copied()`;
+}
+/** A computed list: its iterator, and its items collected as `code` for anything that needs a
+ * `Vec`. */
+export function computed(iter, of, lone) {
+    return { code: `${iter}.collect::<Vec<_>>()`, ty: { k: "list", of }, iter, ...(lone ? { lone } : {}) };
+}
+/** A list of any kind as the `Vec` of items a computed list collects: what a branch of `?:` or a
+ * setup `let` holds, so that both branches have one type. Kept beyond the statement, its strings
+ * own their text, which may live in a temporary (`name.toUpperCase().split(" ")`). */
+export function collected(v) {
+    const of = v.ty.k === "list" ? v.ty.of : v.ty;
+    return `${items(v)}${of.k === "str" ? `.map(|v| ${COW}::Owned(v.into_owned()))` : ""}.collect::<Vec<_>>()`;
+}
+/** The computed list a setup `let` named `name` holds, read again by item. */
+export function heldList(name, of, lone) {
+    const iter = of.k === "str" ? `${name}.iter().map(|v| ${COW}::Borrowed(&**v))` : `${name}.iter().copied()`;
+    return { code: name, ty: { k: "list", of }, iter, ...(lone ? { lone } : {}) };
+}
+/** An item as the closure that a method hands it to sees it: `byRef` for `filter` and `find`, which
+ * pass `&item`. */
+function itemVal(of, param, byRef, lone) {
+    // An object's fields are read through the reference; a number or a boolean is copied out of it.
+    const scalar = of.k === "int" || of.k === "float" || of.k === "bool";
+    const code = of.k === "str" ? (byRef ? `&**${param}` : `&*${param}`) : byRef && scalar ? `*${param}` : param;
+    return { code, ty: of, ...(lone ? { lone } : {}) };
+}
+/** An arrow function's body, translated with its parameters bound — the item, and the index when it
+ * names one — as the closure a method takes. `enumerate` says the items must come numbered. */
+function arrow(s, fn, list, of, byRef, method, body) {
+    const comp = s.comp;
+    if (fn?.type !== "ArrowFunctionExpression" || fn.async || fn.params.length > 2) {
+        fail(comp, `\`.${method}()\` takes an arrow function of the item, and of its index: \`x => …\`, \`(x, i) => …\``, fn);
+    }
+    if (fn.body.type === "BlockStatement")
+        fail(comp, `\`.${method}()\` takes an arrow function whose body is an expression, without \`{ return … }\``, fn);
+    const [item, index] = fn.params;
+    if (index && index.type !== "Identifier")
+        fail(comp, "an arrow function's index is a plain name", index);
+    const n = ++ctx.narrowCount;
+    // A string item is named apart: `map` cannot hand back a borrow of it (see `mapped`).
+    const p = of.k === "str" ? `fv_s${n}` : `fv_a${n}`;
+    const i = `fv_i${n}`;
+    const v = itemVal(of, p, byRef, list.lone);
+    const locals = new Map(s.locals);
+    const bound = [];
+    if (item?.type === "Identifier") {
+        locals.set(item.name, v);
+        bound.push(item.name);
+    }
+    else if (item?.type === "ObjectPattern" && (of.k === "struct" || of.k === "child")) {
+        // `({ id, label }) => …`: each name is that field of the item.
+        for (const prop of item.properties) {
+            if (prop.type !== "ObjectProperty" || prop.computed || prop.value.type !== "Identifier") {
+                fail(comp, "a destructured arrow function parameter binds plain names, without defaults", prop);
+            }
+            locals.set(prop.value.name, fieldVal(comp, v.code, of, prop.key.name ?? prop.key.value, prop));
+            bound.push(prop.value.name);
+        }
+    }
+    else if (item)
+        fail(comp, "an arrow function's item is a name, or an object pattern of an object", item);
+    if (index) {
+        locals.set(index.name, { code: i, ty: INT });
+        bound.push(index.name);
+    }
+    // The parameters hide whatever an outer `v-if` narrowed under the same names.
+    const narrowed = new Map([...s.narrowed].filter(([path]) => !bound.some((b) => path === b || path.startsWith(`${b}.`))));
+    const code = body({ ...s, locals, narrowed });
+    const reads = (name) => new RegExp(`\\b${name}\\b`).test(code);
+    const pName = reads(p) ? p : "_";
+    if (!index)
+        return { closure: `|${pName}| ${code}`, enumerate: false };
+    const lets = (reads(i) ? `let ${i} = ${i} as i64; ` : "");
+    if (byRef) {
+        const e = `fv_e${n}`;
+        const itemLet = reads(p) ? `let ${p} = &${e}.1; ` : "";
+        const indexLet = reads(i) ? `let ${i} = ${e}.0 as i64; ` : "";
+        return { closure: `|${itemLet || indexLet ? e : "_"}| { ${itemLet}${indexLet}${code} }`, enumerate: true };
+    }
+    return { closure: `|(${reads(i) ? i : "_"}, ${pName})| { ${lets}${code} }`, enumerate: true };
+}
+/** What `map` makes of each item: a string as a `Cow` — owned when it was built, or borrows the
+ * item, which the closure owns — a number or a boolean as it is, an object borrowed. */
+function mapped(s, v, n) {
+    switch (v.ty.k) {
+        case "str":
+            // A routine's `Cow` may borrow the item, which the closure owns: owned.
+            if (v.code.startsWith("&*fv::") && yieldsCow(v.code.slice(2)))
+                return `${COW}::Owned(${v.code.slice(2)}.into_owned())`;
+            // An item itself, of this list or one outside it, which the closure only borrows: copied.
+            const item = /^&\**(fv_s\d+)$/.exec(v.code)?.[1];
+            if (item !== undefined)
+                return `${COW}::Owned(${item}.to_string())`;
+            if (isTemporary(v))
+                return asCow(v);
+            return /\bfv_s\d+\b/.test(v.code) ? `${COW}::Owned(${atom(v.code)}.to_owned())` : `${COW}::Borrowed(${strArg(v.code)})`;
+        case "int":
+        case "float":
+        case "bool":
+            return v.code;
+        case "struct":
+        case "child":
+            return `&${operand(v.code, UNARY)}`;
+        default:
+            return fail(s.comp, `\`.map()\` makes a list of strings, numbers, booleans or objects, not ${v.ty.k === "opt" ? "optional values" : "these"}`, n);
+    }
+}
+/** A list method other than `includes` and `join`: `null` when `method` is not one of them. */
+export function listMethod(s, target, method, args, n) {
+    const comp = s.comp;
+    if (!["filter", "map", "some", "every", "find", "findIndex", "slice"].includes(method))
+        return null;
+    const of = itemsTy(s, target, n);
+    const it = items(target);
+    if (method === "slice") {
+        if (args.length < 1 || args.length > 2)
+            fail(comp, "`.slice()` takes a start, and an end", n);
+        const [start, end] = args.map((a) => expr(s, a));
+        const index = (v) => {
+            if (v === undefined || v.ty.k === "undef")
+                return null;
+            if (!isNumber(v.ty))
+                fail(comp, "`.slice()` takes numbers", n);
+            return asF64(v);
+        };
+        const from = index(start) ?? "0.0";
+        const to = index(end);
+        return computed(`fv::js_slice_items(${it}, ${from}, ${to === null ? "None" : `Some(${to})`})`, of, target.lone);
+    }
+    if (args.length !== 1)
+        fail(comp, `\`.${method}()\` takes one arrow function`, n);
+    const fn = args[0];
+    switch (method) {
+        case "filter": {
+            const { closure, enumerate } = arrow(s, fn, target, of, true, method, (inner) => cond(inner, fn.body));
+            return computed(enumerate ? `${it}.enumerate().filter(${closure}).map(|(_, v)| v)` : `${it}.filter(${closure})`, of, target.lone);
+        }
+        case "map": {
+            let out;
+            const { closure, enumerate } = arrow(s, fn, target, of, false, method, (inner) => {
+                out = expr(inner, fn.body);
+                // An integer negated, multiplied or taken modulo may be JavaScript's -0, which a list of
+                // `i64` loses: a list of fractions then. (Generated code spaces a binary `-`, never a unary one.)
+                if (out.ty.k === "int" && out.f64 !== undefined && /-[\w(]|\s[*%]\s/.test(out.f64))
+                    out = { ...out, code: out.f64, ty: FLOAT };
+                return mapped(inner, out, fn.body);
+            });
+            return computed(`${it}${enumerate ? ".enumerate()" : ""}.map(${closure})`, out.ty, out.lone);
+        }
+        case "some":
+        case "every": {
+            const { closure, enumerate } = arrow(s, fn, target, of, false, method, (inner) => cond(inner, fn.body));
+            return { code: `${it}${enumerate ? ".enumerate()" : ""}.${method === "some" ? "any" : "all"}(${closure})`, ty: BOOL };
+        }
+        case "find": {
+            const { closure, enumerate } = arrow(s, fn, target, of, true, method, (inner) => cond(inner, fn.body));
+            const found = enumerate ? `${it}.enumerate().find(${closure}).map(|(_, v)| v)` : `${it}.find(${closure})`;
+            const lone = target.lone ? { lone: true } : {};
+            // A string found is a `Cow` the statement holds, read as the `&str` an optional string is; one
+            // kept beyond the statement owns its text, which may live in a temporary.
+            if (of.k === "str")
+                return { code: `${atom(found)}.as_deref()`, ty: opt(STR), held: `${found}.map(|v| ${COW}::Owned(v.into_owned()))`, ...lone };
+            return { code: found, ty: opt(of), ...lone };
+        }
+        default: {
+            const { closure, enumerate } = arrow(s, fn, target, of, false, method, (inner) => cond(inner, fn.body));
+            return { code: `${it}${enumerate ? ".enumerate()" : ""}.position(${closure}).map_or(-1, |i| i as i64)`, ty: INT };
+        }
+    }
+}
+/** `Object.keys(r)`, `Object.values(r)`, and `Object.entries(r)`, which is only a `v-for`'s source. */
+export function objectCall(s, method, args, n) {
+    const comp = s.comp;
+    const r = args.length === 1 ? expr(s, args[0]) : null;
+    if (r?.ty.k !== "record")
+        return fail(comp, `\`Object.${method}()\` takes a \`Record<string, T>\``, n);
+    const of = r.ty.of;
+    if (method === "keys")
+        return computed(`${atom(r.code)}.keys().map(${COW}::Borrowed)`, STR);
+    if (method === "values") {
+        if (of.k === "list")
+            fail(comp, "`Object.values()` of a record of lists, which these methods cannot walk", n);
+        const values = of.k === "str" ? `.values().map(|v| ${COW}::Borrowed(&**v))` : of.k === "struct" || of.k === "child" ? ".values()" : ".values().copied()";
+        return computed(`${atom(r.code)}${values}`, of);
+    }
+    if (method === "entries")
+        return fail(comp, "`Object.entries()` is supported as the source of a `v-for`: `([key, value], i) in Object.entries(r)`", n);
+    return fail(comp, `\`Object.${method}()\` is not supported: \`keys\`, \`values\` and \`entries\` of a record are`, n);
+}
+/** `list.includes(x)` and `list.join(sep)` of a computed list, or of a list of fractions or
+ * booleans. */
+export function computedListMethod(s, target, method, args, n) {
+    if (target.ty.k !== "list")
+        return null;
+    const of = target.ty.of;
+    if (method === "includes" && args.length === 1) {
+        const x = expr(s, args[0]);
+        if (!sameTy(x.ty, of) || !["str", "int", "float", "bool"].includes(of.k))
+            fail(s.comp, "`.includes()` looks for a value of the list's own type", args[0]);
+        if (of.k === "str")
+            meet(s.comp, target, x, "`.includes()`", n, "equal");
+        // `includes` finds `NaN`, which `==` never equals.
+        const test = of.k === "str" ? `*v == ${x.code.startsWith("&*") ? `*${x.code.slice(2)}` : `*${operand(x.code, UNARY)}`}` : of.k === "float" ? `v == ${x.code} || (v.is_nan() && ${atom(x.code)}.is_nan())` : `v == ${x.code}`;
+        return { code: `${items(target)}.any(|v| ${test})`, ty: BOOL };
+    }
+    if (method === "join" && args.length <= 1) {
+        if (!["str", "int", "float", "bool"].includes(of.k))
+            return null;
+        const sep = args.length ? expr(s, args[0]) : { code: '","', ty: STR };
+        if (sep.ty.k !== "str")
+            fail(s.comp, "`.join()` takes a string", args[0]);
+        // Two halves of a pair would meet where items are joined without a separator between them.
+        const parted = /^"[^"]/.test(sep.code);
+        if (of.k === "str" && target.lone && (!parted || sep.lone))
+            fail(s.comp, lonely("`.join()` with no literal separator"), n);
+        const each = of.k === "str" ? "" : of.k === "bool" ? `.map(|v| if v { "true" } else { "false" })` : ".map(|v| fv::Js(v).to_string())";
+        return { code: `&*${items(target)}${each}.collect::<Vec<_>>().join(${strArg(sep.code)})`, ty: STR, ...(target.lone || sep.lone ? { lone: true } : {}) };
+    }
+    return null;
+}