ferrovue 0.2.0 → 0.4.0

package/dist/calls.js

@@ -0,0 +1,219 @@
+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, items, listMethod, objectCall } from "./lists.js";
+import { lonely, loneOf, meet, stringMethod, stringsEqual } from "./strings.js";
+import { asF64, intFromF64, isNumber } from "./numbers.js";
+import { boolOf, truthy } from "./narrowing.js";
+import { coerce, expr } from "./expr.js";
+export function call(s, n) {
+    const comp = s.comp;
+    const callee = n.callee;
+    const args = n.arguments;
+    if (callee.type === "Identifier") {
+        switch (callee.name) {
+            case "_ssrLooseEqual": {
+                const a = expr(s, args[0]);
+                const b = expr(s, args[1]);
+                if (a.ty.k === "str" && b.ty.k === "str") {
+                    meet(comp, a, b, "`v-model`", n, "equal");
+                    return boolOf(stringsEqual(a, b));
+                }
+                return fail(comp, "`v-model` comparison between these types", n);
+            }
+            case "_ssrIncludeBooleanAttr": {
+                const a = expr(s, args[0]);
+                if (a.konst !== undefined)
+                    return a;
+                if (a.ty.k === "str")
+                    return { code: "true", ty: BOOL, konst: true };
+                if (a.ty.k === "opt" && a.ty.of.k === "str")
+                    return { code: `${atom(a.code)}.is_some()`, ty: BOOL };
+                return boolOf(truthy(a));
+            }
+            case "_ssrLooseContain":
+                return fail(comp, "`v-model` over an array", n);
+        }
+        const own = claim((p) => p.call?.(s, n));
+        if (own)
+            return own;
+        const helper = s.helpers.get(callee.name);
+        if (helper)
+            return helperCall(s, helper, args, n);
+        if (callee.name === "String" && args.length === 1) {
+            const a = expr(s, args[0]);
+            if (a.ty.k === "str")
+                return a;
+            if (isNumber(a.ty))
+                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 };
+        }
+        if (callee.name === "Number" && args.length === 1) {
+            const a = expr(s, args[0]);
+            if (a.ty.k === "str")
+                return { code: `fv::js_number(${strArg(a.code)})`, ty: FLOAT };
+            if (isNumber(a.ty))
+                return a;
+            if (a.ty.k === "bool")
+                return { code: `i64::from(${bare(a.code)})`, ty: INT };
+            return fail(comp, "`Number()` takes a string, a number or a boolean that is present", n);
+        }
+        if ((callee.name === "parseInt" && (args.length === 1 || args.length === 2)) || (callee.name === "parseFloat" && args.length === 1)) {
+            const a = expr(s, args[0]);
+            if (a.ty.k !== "str")
+                fail(comp, `\`${callee.name}()\` takes a string`, args[0]);
+            if (callee.name === "parseFloat")
+                return { code: `fv::js_parse_float(${strArg(a.code)})`, ty: FLOAT };
+            const radix = args[1];
+            if (radix && !(radix.type === "NumericLiteral" && (radix.value === 10 || radix.value === 16))) {
+                fail(comp, "`parseInt()` takes a radix of 10 or 16, written as a literal", radix);
+            }
+            return { code: `fv::js_parse_int(${strArg(a.code)}, ${radix ? radix.value : 0})`, ty: FLOAT };
+        }
+        return fail(comp, `\`${callee.name}()\` is not available when rendering on the server`, n);
+    }
+    if (callee.type === "MemberExpression" && !callee.computed) {
+        const method = callee.property.name;
+        if (callee.object.type === "Identifier" && callee.object.name === "Array" && method === "isArray") {
+            const a = expr(s, args[0]);
+            const own = claim((p) => p.values?.isArray?.(a));
+            if (own)
+                return own;
+            const is = a.ty.k === "list";
+            return { code: String(is), ty: BOOL, konst: is };
+        }
+        if (callee.object.type === "Identifier" && callee.object.name === "Object")
+            return objectCall(s, method, args, n);
+        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 };
+        }
+        const own = claim((p) => p.call?.(s, n));
+        if (own)
+            return own;
+        if (callee.object.type === "Identifier" && (callee.object.name === "$setup" || callee.object.name === "_ctx")) {
+            const helper = s.helpers.get(method);
+            if (helper)
+                return helperCall(s, helper, args, n);
+        }
+        if (callee.object.type === "Identifier" && callee.object.name === "Math") {
+            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");
+                if ((method === "max" || method === "min") && vals.length >= 2) {
+                    if (ints)
+                        return { code: vals.slice(1).reduce((acc, v) => `${atom(acc)}.${method}(${bare(v.code)})`, vals[0].code), ty: INT };
+                    return { code: vals.slice(1).reduce((acc, v) => `fv::js_${method}(${bare(acc)}, ${bare(asF64(v))})`, asF64(vals[0])), ty: FLOAT };
+                }
+                if (vals.length === 1) {
+                    const x = vals[0];
+                    if (method === "abs")
+                        return ints ? intFromF64(`${receiver(asF64(x))}.abs()`) : { code: `${receiver(x.code)}.abs()`, ty: FLOAT };
+                    if (method === "round")
+                        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 };
+                }
+            }
+            return fail(comp, `\`Math.${method}()\` is supported on numbers as \`max\`, \`min\`, \`abs\`, \`round\`, \`floor\`, \`ceil\` and \`trunc\``, n);
+        }
+        const target = expr(s, callee.object);
+        if (target.ty.k === "str") {
+            const lone = loneOf(target);
+            switch (args.length === 0 ? method : "") {
+                case "trim":
+                    return { code: `fv::js_trim(${strArg(target.code)})`, ty: STR, ...lone };
+                case "trimStart":
+                    return { code: `fv::js_trim_start(${strArg(target.code)})`, ty: STR, ...lone };
+                case "trimEnd":
+                    return { code: `fv::js_trim_end(${strArg(target.code)})`, ty: STR, ...lone };
+                case "toUpperCase":
+                    return { code: `&*${receiver(target.code)}.to_uppercase()`, ty: STR, ...lone };
+                case "toLowerCase":
+                    return { code: `&*${receiver(target.code)}.to_lowercase()`, ty: STR, ...lone };
+                case "toString":
+                    return target;
+            }
+            const m = stringMethod(s, target, method, args, 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, "`.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 };
+        }
+        if (isNumber(target.ty) && method === "toString" && args.length === 0) {
+            return { code: `&*fv::Js(${bare(target.code)}).to_string()`, ty: STR };
+        }
+        if (target.ty.k === "list") {
+            const inPlace = target.iter === undefined && !target.lone && (target.ty.of.k === "str" || target.ty.of.k === "int");
+            const listed = listMethod(s, target, method, args, n) ?? (inPlace ? null : computedListMethod(s, target, method, args, n));
+            if (listed)
+                return listed;
+        }
+        if (target.ty.k === "list" && (target.ty.of.k === "str" || target.ty.of.k === "int")) {
+            const of = target.ty.of;
+            if (method === "includes" && args.length === 1) {
+                const v = expr(s, args[0]);
+                if (!sameTy(v.ty, of))
+                    fail(comp, "`.includes()` looks for a value of the list's own type", args[0]);
+                if (of.k === "int")
+                    return { code: `${atom(target.code)}.contains(&${operand(v.code, UNARY)})`, ty: BOOL };
+                const test = v.code === '""' ? "v.is_empty()" : binary("&**v", "==", v.code);
+                return { code: `${atom(target.code)}.iter().any(|v| ${test})`, ty: BOOL };
+            }
+            if (method === "join" && args.length <= 1) {
+                const sep = args.length ? expr(s, args[0]) : { code: '","', ty: STR };
+                if (sep.ty.k !== "str")
+                    fail(comp, "`.join()` takes a string", args[0]);
+                const each = of.k === "str" ? `${atom(target.code)}.iter().map(|v| &**v)` : `${atom(target.code)}.iter().map(|v| fv::Js(*v).to_string())`;
+                return { code: `&*${each}.collect::<Vec<_>>().join(${strArg(sep.code)})`, ty: STR, ...loneOf(sep) };
+            }
+        }
+        return fail(comp, `\`.${method}()\` is not supported`, n);
+    }
+    return fail(comp, "this call is not supported", n);
+}
+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);
+}
+function json(s, v, n) {
+    if (v.lone)
+        fail(s.comp, lonely("`JSON.stringify()`"), n);
+    const one = (code, ty) => {
+        switch (ty.k) {
+            case "str":
+                return `fv::js_json_string(${code === "v" ? "&v" : strArg(code)})`;
+            case "int":
+                return `fv::Js(${bare(code)}).to_string()`;
+            case "float":
+                return `fv::js_json_number(${bare(code)})`;
+            case "bool":
+                return `(if ${condition(code)} { "true" } else { "false" }).to_owned()`;
+            default:
+                return fail(s.comp, "`JSON.stringify()` of a string, a number, a boolean or a list of those, present", n);
+        }
+    };
+    if (v.ty.k === "list") {
+        const each = one("v", v.ty.of);
+        const f = /^([\w:]+)\(v\)$/.exec(each)?.[1];
+        return `format!("[{}]", ${items(v)}.map(${f ?? `|v| ${each}`}).collect::<Vec<_>>().join(","))`;
+    }
+    return one(v.code, v.ty);
+}
+export function helperCall(s, name, args, n) {
+    const h = ctx.helpers[name];
+    if (args.length !== h.params.length)
+        fail(s.comp, `\`${name}\` takes ${h.params.length} argument(s)`, n);
+    const code = args.map((a, i) => bare(coerce(s.comp, expr(s, a), h.params[i], a))).join(", ");
+    s.helperBytes.n += h.maxLen;
+    return { code: `${h.rust}(${code})`, ty: h.ret };
+}

package/dist/children.d.ts

@@ -0,0 +1,9 @@
+import { type Component, type N, type Scope, type Ty, type Val } from "./model.ts";
+import { Emitter } from "./emitter.ts";
+export declare function renderChild(s: Scope, e: Emitter, n: N): void;
+export declare function array(key: string): boolean;
+export declare function fieldInit(name: string, value: string): string;
+export declare function takesSlots(c: Component): boolean;
+export declare function extraParams(c: Component): string;
+export declare function callChild(s: Scope, e: Emitter, child: Component, propsCode: string, slots: N, attrs: string | null): void;
+export declare function ownInto(comp: Component, v: Val, want: Ty, node: N): string;

package/dist/children.js

@@ -0,0 +1,273 @@
+import { isSSRSafeAttrName, propsToAttrMap } from "@vue/shared";
+import { camelize, declares, fail, GenError, rustStr, sameTy, snake, takesAttrs } from "./model.js";
+import { ctx } from "./context.js";
+import { markHome } from "./typescript.js";
+import { expr, fieldVal } from "./expr.js";
+import { asF64 } from "./numbers.js";
+import { atom, bare } from "./parens.js";
+import { Emitter } from "./emitter.js";
+import { attrOf, dollarAttrs, IGNORED_PROPS, isAttrs, mergedParts } from "./attrs.js";
+import { passedKey } from "./fallthrough.js";
+import { claim, paramsOf, slotFieldsOf } from "./plugin.js";
+import { statements } from "./template.js";
+import { slotContent, slotFieldBorrows, staticallyFilled } from "./slots.js";
+export function renderChild(s, e, n) {
+    const [target, rawProps, slots, , slotScopeId] = n.arguments;
+    let local = null;
+    if (target.type === "MemberExpression" && target.object.name === "$setup") {
+        local = target.computed ? target.property.value : target.property.name;
+    }
+    const isSelf = target.type === "Identifier" && target.name === s.selfAlias.name;
+    const childName = isSelf ? s.comp.name : local ? s.children.get(local) : undefined;
+    const child = childName ? s.components.get(childName) : undefined;
+    if (!child)
+        fail(s.comp, "a child component must be an imported island", n);
+    for (const p of ctx.plugins)
+        p.child?.(s, child, n);
+    const parts = !rawProps || rawProps.type === "NullLiteral" ? [] : mergedParts(rawProps);
+    const merges = parts.length > 0 && parts[0] !== rawProps;
+    const passesAttrs = parts.some(isAttrs);
+    const passed = (p) => s.fallthrough !== null && ((isAttrs(p) && s.comp.inheritAttrs) || dollarAttrs(s, p));
+    const marker = (p) => p.type === "ObjectExpression" && p.properties.length > 0 && p.properties.every((q) => q.type === "ObjectProperty" && IGNORED_PROPS.has(q.key.name ?? q.key.value));
+    const objects = parts.filter((p) => !isAttrs(p) && !dollarAttrs(s, p) && !marker(p));
+    if (parts.some(passed)) {
+        for (const name of s.comp.attrNames) {
+            if (declares(child, name)) {
+                fail(s.comp, `\`${name}\`, an attribute ${s.comp.name} may be passed, would reach ${child.name} as its prop \`${camelize(name)}\`, which an attribute has no type for`, n);
+            }
+        }
+    }
+    const ids = claim((p) => p.childIds?.(s, child, passesAttrs, !!slotScopeId, n)) ?? null;
+    if (objects.length === 1 && objects[0].type !== "ObjectExpression") {
+        const v = expr(s, objects[0]);
+        const own = child.name === s.comp.name && v.ty.k === "struct" && v.ty.name === "Props";
+        if (own || (v.ty.k === "child" && v.ty.name === child.name)) {
+            callChild(s, e, child, v.code, slots, childAttrsArg(s, child, parts, merges, null, ids));
+            return;
+        }
+        fail(s.comp, `child props must be an object literal, or \`v-bind\` of ${child.name}'s own \`Props\``, n);
+    }
+    for (const p of objects) {
+        if (p.type !== "ObjectExpression")
+            fail(s.comp, `child props must be an object literal, or \`v-bind\` of ${child.name}'s own \`Props\``, p);
+    }
+    const given = new Map();
+    const fallthrough = new Set();
+    for (const obj of objects) {
+        for (const p of obj.properties) {
+            if (p.type !== "ObjectProperty" || p.computed)
+                fail(s.comp, "child props hold plain keys", p);
+            const key = p.key.type === "Identifier" ? p.key.name : String(p.key.value);
+            if (!passedKey(child, key))
+                continue;
+            const field = child.props.fields.find((f) => camelize(f.js) === camelize(key));
+            if (field) {
+                given.set(field.js, p.value);
+                continue;
+            }
+            if (array(key))
+                fail(s.comp, `an attribute named \`${key}\`, which JavaScript would put before the others`, p);
+            const name = propsToAttrMap[key] ?? key.toLowerCase();
+            if (key !== "class" && key !== "style" && !isSSRSafeAttrName(name))
+                fail(s.comp, `unsafe attribute name \`${name}\``, p);
+            fallthrough.add(p);
+        }
+    }
+    const inits = child.props.fields.map((f) => {
+        const node = given.get(f.js);
+        if (!node) {
+            if (f.ty.k !== "opt")
+                fail(s.comp, `${child.name} requires \`${f.js}\``, n);
+            return `${f.rust}: None`;
+        }
+        const v = expr(s, node);
+        return fieldInit(f.rust, ownInto(s.comp, { ...v, ty: markHome(v.ty, s.comp.name) }, markHome(f.ty, child.name), node));
+    });
+    callChild(s, e, child, `&super::${child.module}::Props { ${inits.join(", ")} }`, slots, childAttrsArg(s, child, parts, merges, fallthrough, ids));
+}
+export function array(key) {
+    return /^(0|[1-9]\d*)$/.test(key) && Number(key) < 2 ** 32 - 1;
+}
+function childAttrsArg(s, child, parts, merges, fallthrough, ids) {
+    const sources = [];
+    for (const p of parts) {
+        if (s.fallthrough !== null && ((isAttrs(p) && s.comp.inheritAttrs) || dollarAttrs(s, p))) {
+            sources.push(`${s.fallthrough}.list()`);
+        }
+        else if (p.type === "ObjectExpression" && fallthrough !== null) {
+            const entries = p.properties.filter((q) => fallthrough.has(q)).map((q) => {
+                const key = q.key.type === "Identifier" ? q.key.name : String(q.key.value);
+                return `(${rustStr(key)}, ${attrOf(s, key, q.value, "vnode")})`;
+            });
+            if (entries.length)
+                sources.push(`&[${entries.join(", ")}]`);
+        }
+    }
+    if (!takesAttrs(child)) {
+        if (sources.length)
+            throw new GenError(`${s.comp.file}: ${child.name} is passed attributes it does not take`);
+        return ids;
+    }
+    if (!sources.length)
+        return ids === null ? "&fv::Attrs::NONE" : `&fv::Attrs::scoped(${ids})`;
+    if (sources.length === 1 && !merges)
+        return `&fv::Attrs::new(${sources[0]}, ${ids ?? '""'})`;
+    return `&fv::Attrs::merged(&[${sources.join(", ")}], ${ids ?? '""'})`;
+}
+export function fieldInit(name, value) {
+    return value === name ? name : `${name}: ${bare(value)}`;
+}
+export function takesSlots(c) {
+    return c.slotNames.length > 0 || slotFieldsOf(c).length > 0;
+}
+export function extraParams(c) {
+    return (takesSlots(c) ? ", fv_slots: Slots<'_>" : "") + paramsOf(c).map((p) => `, ${p.name}: ${p.ty}`).join("");
+}
+export function callChild(s, e, child, propsCode, slots, attrs) {
+    const given = new Map();
+    if (slots && slots.type !== "NullLiteral") {
+        if (slots.type !== "ObjectExpression")
+            fail(s.comp, "slots must be an object literal", slots);
+        for (const p of slots.properties) {
+            const key = p.key?.type === "Identifier" ? p.key.name : p.key?.value;
+            if (key === "_")
+                continue;
+            if (p.type !== "ObjectProperty" || p.computed)
+                fail(s.comp, "slots hold plain keys", p);
+            if (!child.slotNames.includes(key))
+                fail(s.comp, `${child.name} has no slot \`${key}\``, p);
+            given.set(key, p.value);
+        }
+    }
+    const m = `super::${child.module}`;
+    const scoped = child.inherits || takesAttrs(child);
+    const trailing = paramsOf(child).map((p) => `, ${p.name}`).join("") + (scoped ? `, ${attrs ?? (takesAttrs(child) ? "&fv::Attrs::NONE" : '""')}` : "");
+    const render = scoped ? "render_scoped" : "render";
+    if (!takesSlots(child)) {
+        e.stmt(`${m}::${render}(out, ${propsCode}${trailing});`);
+        return;
+    }
+    e.open(`${m}::${render}(out, ${propsCode}, ${m}::Slots`);
+    for (const name of child.slotNames) {
+        const field = snake(name);
+        const value = given.get(name);
+        if (!value) {
+            e.stmt(`${field}: None,`);
+            continue;
+        }
+        const { body, param } = slotContent(s, value);
+        const shape = child.slotShapes.get(name);
+        const takesNone = param?.type === "Identifier" && param.name === "_";
+        const sid = child.passesSlotIds ? `fv_sid${++ctx.narrowCount}` : null;
+        const sidParam = sid === null ? "" : `, ${sid}: &str`;
+        const content = (inner) => {
+            if (staticallyFilled(body)) {
+                statements({ ...inner, fill: false }, e, body);
+                e.stmt("true");
+            }
+            else {
+                e.stmt("let mut filled = false;");
+                statements({ ...inner, fill: true }, e, body);
+                e.stmt("filled");
+            }
+        };
+        const unread = (opened, binding) => {
+            if (binding !== null && !e.reads(binding, opened + 1))
+                e.replace(opened, `${binding}:`, `_${binding}:`);
+        };
+        if (shape) {
+            const sp = `fv_sp${++ctx.narrowCount}`;
+            const ty = { k: "struct", name: shape.name, home: child.name };
+            const locals = new Map(s.locals);
+            if (param?.type === "ObjectPattern") {
+                for (const p of param.properties) {
+                    if (p.type !== "ObjectProperty" || p.computed || p.value.type !== "Identifier") {
+                        fail(s.comp, "slot props are destructured into plain names, without defaults", p);
+                    }
+                    locals.set(p.value.name, fieldVal(s.comp, sp, ty, p.key.name ?? p.key.value, p));
+                }
+            }
+            else if (param?.type === "Identifier" && !takesNone) {
+                locals.set(param.name, { code: sp, ty });
+            }
+            else if (!takesNone)
+                fail(s.comp, "slot props are a name or an object pattern", param);
+            const life = shape.fields.some((f) => slotFieldBorrows(f.ty)) ? "<'_>" : "";
+            e.open(`${field}: Some(&|out: &mut String, ${sp}: &${m}::${shape.name}${life}${sidParam}| -> bool`);
+            const opened = e.lines.length - 1;
+            content({ ...s, locals, sid });
+            unread(opened, sp);
+            unread(opened, sid);
+            e.close("),");
+            continue;
+        }
+        if (!takesNone)
+            fail(s.comp, `\`<slot${name === "default" ? "" : ` name="${name}"`}>\` in ${child.name} passes no props`, param);
+        const inner = { ...s, sid };
+        if (sid !== null) {
+            e.open(`${field}: Some(fv::Slot::slotted(&|out: &mut String${sidParam}| -> bool`);
+            const opened = e.lines.length - 1;
+            content(inner);
+            unread(opened, sid);
+            e.close(")),");
+        }
+        else if (staticallyFilled(body)) {
+            e.open(`${field}: Some(fv::Slot::new(&|out: &mut String|`);
+            statements({ ...inner, fill: false }, e, body);
+            e.close(")),");
+        }
+        else {
+            e.open(`${field}: Some(fv::Slot::markup(&|out: &mut String| -> bool`);
+            e.stmt("let mut filled = false;");
+            statements({ ...inner, fill: true }, e, body);
+            e.stmt("filled");
+            e.close(")),");
+        }
+    }
+    e.close(`${trailing});`);
+}
+export function ownInto(comp, v, want, node) {
+    if (want.k === "str") {
+        if (v.ty.k !== "str")
+            fail(comp, "a string prop needs a string", node);
+        return `std::borrow::Cow::Borrowed(${bare(v.code)})`;
+    }
+    if (want.k === "opt" && want.of.k === "str") {
+        if (v.ty.k === "undef")
+            return "None";
+        if (v.ty.k === "str")
+            return `Some(std::borrow::Cow::Borrowed(${bare(v.code)}))`;
+        if (v.ty.k === "opt" && v.ty.of.k === "str")
+            return `${atom(v.code)}.map(std::borrow::Cow::Borrowed)`;
+    }
+    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"))
+        return `Some(${bare(v.code)})`;
+    if (want.k === "float" && v.ty.k === "int")
+        return asF64(v);
+    if (want.k === "opt" && want.of.k === "float" && v.ty.k === "int")
+        return `Some(${asF64(v)})`;
+    if (v.iter !== undefined && v.ty.k === "list" && want.k === "list" && sameTy(v.ty.of, want.of)) {
+        return want.of.k === "struct" || want.of.k === "child" ? `${v.iter}.cloned().collect()` : `${v.iter}.collect()`;
+    }
+    const objecty = (t) => t.k === "struct" || t.k === "child" || t.k === "record" || ((t.k === "list" || t.k === "opt") && objecty(t.of));
+    if (objecty(want) && sameTy(v.ty, want))
+        return `${atom(v.code)}.${v.ty.k === "opt" ? "cloned" : "to_owned"}()`;
+    if (want.k === "opt" && objecty(want.of) && sameTy(v.ty, want.of))
+        return `Some(${atom(v.code)}.to_owned())`;
+    if (objecty(want) && v.ty.k === want.k && JSON.stringify(v.ty).includes('"struct"')) {
+        fail(comp, `a ${JSON.stringify(v.ty)} where the child takes a ${JSON.stringify(want)}: two components share a type only when both import it from one \`.ts\` file`, node);
+    }
+    if (want.k === "list" && v.ty.k === "list" && v.ty.of.k === "undef")
+        return "Vec::new()";
+    if (want.k === "opt" && want.of.k === "list" && v.ty.k === "list")
+        return `Some(${ownInto(comp, v, want.of, node)})`;
+    if (want.k === "list" && v.ty.k === "list" && sameTy(v.ty.of, want.of)) {
+        if (want.of.k === "str")
+            return `${atom(v.code)}.iter().map(|v| std::borrow::Cow::Borrowed(&**v)).collect()`;
+        if (want.of.k === "int" || want.of.k === "float" || want.of.k === "bool")
+            return `${atom(v.code)}.to_vec()`;
+    }
+    return fail(comp, `a ${JSON.stringify(v.ty)} into a ${JSON.stringify(want)} prop`, node);
+}

package/dist/classes.d.ts

@@ -0,0 +1,13 @@
+import { type N, type Scope } from "./model.ts";
+import { Emitter } from "./emitter.ts";
+export type ClassItem = {
+    lit: string;
+} | {
+    code: string;
+};
+export declare function classItems(s: Scope, n: N): ClassItem[];
+export declare function renderClass(s: Scope, e: Emitter, n: N, after?: boolean): void;
+export declare function classPresent(s: Scope, n: N): string;
+export declare function maybeEqual(s: Scope, n: N): boolean;
+export declare function literalClass(n: N): string | null;
+export declare function classAttr(s: Scope, n: N, side: "vnode" | "own"): string;