ferrovue 0.4.0 → 0.6.0

package/dist/attrs.d.ts

@@ -1,10 +1,11 @@
 import { type N, type Scope, type Val } from "./model.ts";
 import { Emitter } from "./emitter.ts";
 export declare function display(e: Emitter, v: Val): boolean;
-export declare function interpolate(e: Emitter, v: Val): void;
+export declare function interpolate(s: Scope, e: Emitter, v: Val, n: N): void;
 export declare function attrValue(e: Emitter, v: Val): void;
 export declare function renderAttr(s: Scope, e: Emitter, key: string, v: Val, n: N): void;
-export declare function renderDynamicAttr(s: Scope, e: Emitter, key: string, v: Val, n: N): void;
+export declare function keepsAttrCase(tag: string): boolean;
+export declare function renderDynamicAttr(s: Scope, e: Emitter, key: string, v: Val, n: N, tag?: string | null): void;
 export declare const IGNORED_PROPS: Set<string>;
 export declare function directiveProps(s: Scope, n: N): boolean;
 export declare function isAttrs(n: N): boolean;

package/dist/attrs.js

@@ -1,5 +1,5 @@
-import { escapeHtml, hyphenate, isBooleanAttr, isSSRSafeAttrName, propsToAttrMap } from "@vue/shared";
-import { fail, GenError, rustStr } from "./model.js";
+import { escapeHtml, hyphenate, isBooleanAttr, isSSRSafeAttrName, isSVGTag, propsToAttrMap } from "@vue/shared";
+import { fail, nothing, GenError, rustStr } from "./model.js";
 import { CONFIG_FILE, ctx } from "./context.js";
 import { describeTy, expr } from "./expr.js";
 import { known, truthy } from "./narrowing.js";
@@ -30,39 +30,40 @@ export function display(e, v) {
         return false;
     return true;
 }
-export function interpolate(e, v) {
+export function interpolate(s, e, v, n) {
     if (display(e, v))
         return;
     switch (v.ty.k) {
         case "undef":
+        case "null":
             return;
         case "opt":
             e.open(`if let Some(v) = ${v.code}`);
-            interpolate(e, { code: "v", ty: v.ty.of });
+            interpolate(s, e, { code: "v", ty: v.ty.of }, n);
             e.close();
             return;
         default:
             if (ctx.plugins.some((p) => p.values?.interpolate?.(e, v)))
                 return;
-            throw new GenError("only strings, numbers and booleans can be interpolated");
+            fail(s.comp, "FV0401", `\`{{ }}\` of ${describeTy(v.ty)}: only strings, numbers and booleans can be interpolated`, n);
     }
 }
 export function attrValue(e, v) {
     if (!display(e, v))
-        throw new GenError("an attribute value must be a string, a number or a boolean");
+        throw new GenError("FV0402", "an attribute value must be a string, a number or a boolean");
 }
 function renderable(s, key, v, n) {
     const ty = v.ty.k === "opt" ? v.ty.of : v.ty;
-    if (ty.k === "str" || ty.k === "int" || ty.k === "float" || ty.k === "bool" || ty.k === "undef")
+    if (ty.k === "str" || ty.k === "int" || ty.k === "float" || ty.k === "bool" || nothing(ty))
         return;
     const own = claim((p) => p.values?.unbindable?.(ty));
     const what = own?.what ?? describeTy(ty);
     const fix = own?.fix ?? (ty.k === "list" ? 'join it into one string, as `.join(",")`' : "bind a string, a number or a boolean");
-    fail(s.comp, `\`${key}\` is bound to ${what}: Vue's server renderer leaves the attribute out, and hydration then sets it, changing the page; ${fix}`, n);
+    fail(s.comp, "FV0403", `\`${key}\` is bound to ${what}: Vue's server renderer leaves the attribute out, and hydration then sets it, changing the page; ${fix}`, n);
 }
 export function renderAttr(s, e, key, v, n) {
     renderable(s, key, v, n);
-    if (v.ty.k === "undef")
+    if (nothing(v.ty))
         return;
     if (v.ty.k === "opt") {
         e.open(`if let Some(v) = ${v.code}`);
@@ -74,12 +75,15 @@ export function renderAttr(s, e, key, v, n) {
     attrValue(e, v);
     e.lit(`"`);
 }
-export function renderDynamicAttr(s, e, key, v, n) {
-    const name = propsToAttrMap[key] ?? key.toLowerCase();
+export function keepsAttrCase(tag) {
+    return tag.indexOf("-") > 0 || isSVGTag(tag);
+}
+export function renderDynamicAttr(s, e, key, v, n, tag = null) {
+    const name = tag !== null && keepsAttrCase(tag) ? key : (propsToAttrMap[key] ?? key.toLowerCase());
     if (!isSSRSafeAttrName(name))
-        fail(s.comp, `unsafe attribute name \`${name}\``, n);
+        fail(s.comp, "FV0404", `unsafe attribute name \`${name}\``, n);
     renderable(s, key, v, n);
-    if (v.ty.k === "undef")
+    if (nothing(v.ty))
         return;
     const boolean = (t) => isBooleanAttr(name) || (name === "hidden" && (t.k === "bool" || t.k === "int" || t.k === "float"));
     if (v.ty.k === "opt" && boolean(v.ty.of)) {
@@ -90,7 +94,7 @@ export function renderDynamicAttr(s, e, key, v, n) {
     }
     if (v.ty.k === "opt") {
         e.open(`if let Some(v) = ${v.code}`);
-        renderDynamicAttr(s, e, key, { code: "v", ty: v.ty.of }, n);
+        renderDynamicAttr(s, e, key, { code: "v", ty: v.ty.of }, n, tag);
         e.close();
         return;
     }
@@ -140,7 +144,7 @@ export function directiveProps(s, n) {
     else if (dir?.type === "Identifier")
         name = s.directives.get(dir.name) ?? null;
     if (name === null || !ctx.clientDirectives.has(name)) {
-        fail(s.comp, `custom directive \`v-${name ?? "?"}\` may add attributes on the server; if it has no \`getSSRProps\`, list \`${name ?? "?"}\` in \`clientDirectives\` in ${CONFIG_FILE}`, n);
+        fail(s.comp, "FV0405", `custom directive \`v-${name ?? "?"}\` may add attributes on the server; if it has no \`getSSRProps\`, list \`${name ?? "?"}\` in \`clientDirectives\` in ${CONFIG_FILE}`, n);
     }
     return true;
 }
@@ -151,7 +155,7 @@ export function dollarAttrs(s, n) {
     if (!isDollarAttrs(n, s.attrsBindings))
         return false;
     if (s.comp.idsInAttrs) {
-        fail(s.comp, `\`$attrs\` in ${s.comp.name}, the root of a component that may be handed scope ids: it would hold them as attributes too`, n);
+        fail(s.comp, "FV0406", `\`$attrs\` in ${s.comp.name}, the root of a component that may be handed scope ids: it would hold them as attributes too`, n);
     }
     return true;
 }
@@ -192,7 +196,7 @@ export function renderAttrs(s, e, n) {
         else if (p.type === "ObjectExpression")
             sources.push(`&[${attrEntries(s, p, "own").join(", ")}]`);
         else
-            fail(s.comp, "attributes must be an object literal", p);
+            fail(s.comp, "FV0407", "attributes must be an object literal", p);
     }
     const ids = idsAt >= 0 && s.attrs !== null ? s.attrs : '""';
     e.stmt(`fv::attrs_into(out, &[${sources.join(", ")}], ${idsAt >= 0 ? idsAt : sources.length}, ${ids});`);
@@ -223,16 +227,16 @@ function staticAttrs(s, e, n) {
 }
 function objectAttrs(s, e, n, merged) {
     if (n.type !== "ObjectExpression")
-        fail(s.comp, "attributes must be an object literal", n);
+        fail(s.comp, "FV0407", "attributes must be an object literal", n);
     for (const p of n.properties) {
         if (p.type !== "ObjectProperty" || p.computed)
-            fail(s.comp, "attribute objects hold plain keys", p);
+            fail(s.comp, "FV0408", "attribute objects hold plain keys", p);
         const raw = p.key.type === "Identifier" ? p.key.name : p.key.value;
         if (IGNORED_PROPS.has(raw) || /^on[^a-z]/.test(raw) || raw.startsWith("."))
             continue;
         const key = raw.startsWith("^") ? raw.slice(1) : raw;
         if (key === "className") {
-            fail(s.comp, "`className` renders by its own rule in Vue; bind `class`", p);
+            fail(s.comp, "FV0409", "`className` renders by its own rule in Vue; bind `class`", p);
         }
         else if (key === "class") {
             const present = merged ? classPresent(s, p.value) : "true";
@@ -267,16 +271,16 @@ export function mergeProps(s, n) {
         if (directiveProps(s, a))
             continue;
         if (a.type !== "ObjectExpression")
-            fail(s.comp, "`_mergeProps` of object literals is supported", a);
+            fail(s.comp, "FV0410", "`_mergeProps` of object literals is supported", a);
         for (const p of a.properties) {
             if (p.type !== "ObjectProperty" || p.computed)
-                fail(s.comp, "attribute objects hold plain keys", p);
+                fail(s.comp, "FV0408", "attribute objects hold plain keys", p);
             const key = p.key.type === "Identifier" ? p.key.name : p.key.value;
             const had = merged.get(key);
             if (had && key === "class" && maybeEqual(s, p.value)) {
                 const before = literalClass(had.value);
                 if (before === null || p.value.type !== "StringLiteral") {
-                    fail(s.comp, "a class merged with a string that may equal the class before it, which Vue then writes once: bind an array", p);
+                    fail(s.comp, "FV0411", "a class merged with a string that may equal the class before it, which Vue then writes once: bind an array", p);
                 }
                 if (before !== p.value.value)
                     merged.set(key, { ...p, value: { type: "ArrayExpression", elements: [had.value, p.value], fvMerged: true } });
@@ -297,7 +301,7 @@ export function attrEntries(s, obj, side) {
     const out = [];
     for (const p of obj.properties) {
         if (p.type !== "ObjectProperty" || p.computed)
-            fail(s.comp, "attribute objects hold plain keys", p);
+            fail(s.comp, "FV0408", "attribute objects hold plain keys", p);
         const key = p.key.type === "Identifier" ? p.key.name : String(p.key.value);
         if (IGNORED_PROPS.has(key) || /^on[^a-z]/.test(key) || key.startsWith("."))
             continue;
@@ -307,7 +311,7 @@ export function attrEntries(s, obj, side) {
 }
 export function attrOf(s, key, n, side) {
     if (key === "className")
-        fail(s.comp, "`className` renders by its own rule in Vue; bind `class`", n);
+        fail(s.comp, "FV0409", "`className` renders by its own rule in Vue; bind `class`", n);
     if (key === "class")
         return classAttr(s, n, side);
     if (key === "style")
@@ -327,6 +331,7 @@ export function valueAttr(s, v, n) {
         case "bool":
             return `fv::Attr::Bool(${bare(v.code)})`;
         case "undef":
+        case "null":
             return "fv::Attr::Undefined";
         case "opt": {
             const of = v.ty.of.k;
@@ -335,5 +340,5 @@ export function valueAttr(s, v, n) {
                 return `${atom(v.code)}.map_or(fv::Attr::Undefined, ${make})`;
         }
     }
-    return fail(s.comp, "an attribute that may fall through is a string, a number or a boolean", n);
+    return fail(s.comp, "FV0412", "an attribute that may fall through is a string, a number or a boolean", n);
 }

package/dist/calls.js

@@ -20,7 +20,7 @@ export function call(s, n) {
                     meet(comp, a, b, "`v-model`", n, "equal");
                     return boolOf(stringsEqual(a, b));
                 }
-                return fail(comp, "`v-model` comparison between these types", n);
+                return fail(comp, "FV0413", "`v-model` comparison between these types", n);
             }
             case "_ssrIncludeBooleanAttr": {
                 const a = expr(s, args[0]);
@@ -33,7 +33,7 @@ export function call(s, n) {
                 return boolOf(truthy(a));
             }
             case "_ssrLooseContain":
-                return fail(comp, "`v-model` over an array", n);
+                return fail(comp, "FV0414", "`v-model` over an array", n);
         }
         const own = claim((p) => p.call?.(s, n));
         if (own)
@@ -58,21 +58,21 @@ export function call(s, n) {
                 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);
+            return fail(comp, "FV0701", "`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]);
+                fail(comp, "FV0702", `\`${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);
+                fail(comp, "FV0703", "`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);
+        return fail(comp, "FV0601", `\`${callee.name}()\` is not available when rendering on the server`, n);
     }
     if (callee.type === "MemberExpression" && !callee.computed) {
         const method = callee.property.name;
@@ -119,7 +119,7 @@ export function call(s, n) {
                         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);
+            return fail(comp, "FV0704", `\`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") {
@@ -145,7 +145,7 @@ export function call(s, n) {
         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);
+                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 };
         }
@@ -162,8 +162,10 @@ export function call(s, n) {
             const of = target.ty.of;
             if (method === "includes" && args.length === 1) {
                 const v = expr(s, args[0]);
+                if (of.k === "int" && v.ty.k === "float")
+                    return { code: `${atom(target.code)}.iter().any(|v| ${binary("*v as f64", "==", v.code)})`, ty: BOOL };
                 if (!sameTy(v.ty, of))
-                    fail(comp, "`.includes()` looks for a value of the list's own type", args[0]);
+                    fail(comp, "FV0801", "`.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);
@@ -172,14 +174,14 @@ export function call(s, n) {
             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]);
+                    fail(comp, "FV0802", "`.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, "FV0602", `\`.${method}()\` is not supported`, n);
     }
-    return fail(comp, "this call is not supported", n);
+    return fail(comp, "FV0603", "this call is not supported", n);
 }
 export function isObjectCall(n, method) {
     return (n?.type === "CallExpression" && n.callee.type === "MemberExpression" && !n.callee.computed &&
@@ -187,7 +189,7 @@ export function isObjectCall(n, method) {
 }
 function json(s, v, n) {
     if (v.lone)
-        fail(s.comp, lonely("`JSON.stringify()`"), n);
+        fail(s.comp, "FV0706", lonely("`JSON.stringify()`"), n);
     const one = (code, ty) => {
         switch (ty.k) {
             case "str":
@@ -199,7 +201,7 @@ function json(s, v, n) {
             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);
+                return fail(s.comp, "FV0707", "`JSON.stringify()` of a string, a number, a boolean or a list of those, present", n);
         }
     };
     if (v.ty.k === "list") {
@@ -212,7 +214,7 @@ function json(s, v, n) {
 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);
+        fail(s.comp, "FV1101", `\`${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

@@ -1,9 +1,16 @@
-import { type Component, type N, type Scope, type Ty, type Val } from "./model.ts";
+import { type Component, type Field, 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;
+/** A component the project renders with a Rust function of its own, in place of a compiled one. */
+export interface TwinCall {
+    comp: Component;
+    init(s: Scope, f: Field, node: N | undefined, n: N): string;
+    call(s: Scope, e: Emitter, inits: string[], slots: N, attrs: string): void;
+}
+export declare function renderChild(s: Scope, e: Emitter, n: N, twin?: TwinCall): 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 extraParams(c: Component, unread?: (name: string) => boolean): string;
+export declare function callChild(s: Scope, e: Emitter, child: Component, propsCode: string, slots: N, attrs: string | null, later?: boolean): void;
+export declare function callWith(s: Scope, e: Emitter, child: Component, m: string, head: string, slotsTy: string, trailing: string, slots: N, vnode?: boolean): void;
 export declare function ownInto(comp: Component, v: Val, want: Ty, node: N): string;