ferrovue 0.3.0 → 0.4.0

package/dist/styles.d.ts

@@ -0,0 +1,14 @@
+import { type N, type Scope } from "./model.ts";
+import { Emitter } from "./emitter.ts";
+export declare function mergedStyle(s: Scope, e: Emitter, n: N): void;
+export declare function styleAttr(s: Scope, n: N): string;
+export interface StyleItem {
+    cond: string | null;
+    entries: {
+        key: string;
+        css: string;
+        value: N;
+    }[];
+}
+export declare function styleItems(s: Scope, n: N, when: string | null): StyleItem[];
+export declare function renderStyle(s: Scope, e: Emitter, n: N): void;

package/dist/styles.js

@@ -0,0 +1,181 @@
+import { escapeHtml, hyphenate, parseStringStyle } from "@vue/shared";
+import { fail, rustStr } from "./model.js";
+import { expr } from "./expr.js";
+import { cond } from "./narrowing.js";
+import { condition, logical, not, strArg } from "./parens.js";
+import { Emitter } from "./emitter.js";
+import { display, valueAttr } from "./attrs.js";
+export function mergedStyle(s, e, n) {
+    if (n.type === "StringLiteral") {
+        renderStyle(s, e, { type: "ArrayExpression", elements: [n] });
+        return;
+    }
+    if (n.fvMerged || ["ObjectExpression", "ArrayExpression", "ConditionalExpression", "LogicalExpression", "NullLiteral"].includes(n.type)) {
+        renderStyle(s, e, n);
+        return;
+    }
+    const v = expr(s, n);
+    if (v.ty.k === "str")
+        e.stmt(`fv::style_text_into(out, ${strArg(v.code)});`);
+    else if (v.ty.k === "opt" && v.ty.of.k === "str") {
+        e.open(`if let Some(v) = ${v.code}`);
+        e.stmt("fv::style_text_into(out, v);");
+        e.close();
+    }
+    else if (v.ty.k !== "undef")
+        fail(s.comp, "a style binding is a string, an object or an array", n);
+}
+export function styleAttr(s, n) {
+    switch (n.type) {
+        case "StringLiteral":
+            return `fv::Attr::str(${rustStr(n.value)})`;
+        case "NullLiteral":
+            return "fv::Attr::Undefined";
+        case "ObjectExpression": {
+            const entries = n.properties.map((p) => {
+                if (p.type !== "ObjectProperty" || p.computed)
+                    fail(s.comp, "a style object holds plain `property: value` pairs", p);
+                const key = p.key.type === "Identifier" ? p.key.name : String(p.key.value);
+                if (/^\d+$/.test(key) || key.startsWith(":"))
+                    fail(s.comp, `style property \`${key}\``, p);
+                return `(${rustStr(key)}, ${valueAttr(s, expr(s, p.value), p.value)})`;
+            });
+            return `fv::Attr::style([${entries.join(", ")}])`;
+        }
+        case "ArrayExpression":
+            return `fv::Attr::styles([${n.elements.map((el) => (el ? styleAttr(s, el) : "fv::Attr::Undefined")).join(", ")}])`;
+        case "LogicalExpression":
+            if (n.operator === "&&")
+                return `if ${condition(cond(s, n.left))} { ${styleAttr(s, n.right)} } else { fv::Attr::Undefined }`;
+            break;
+        case "ConditionalExpression":
+            return `if ${condition(cond(s, n.test))} { ${styleAttr(s, n.consequent)} } else { ${styleAttr(s, n.alternate)} }`;
+    }
+    const v = expr(s, n);
+    if (v.ty.k === "str" || v.ty.k === "undef" || (v.ty.k === "opt" && v.ty.of.k === "str"))
+        return valueAttr(s, v, n);
+    return fail(s.comp, "a style binding is a string, an object or an array", n);
+}
+export function styleItems(s, n, when) {
+    if (when === "false")
+        return [];
+    if (when === "true")
+        when = null;
+    const both = (a, b) => (a === null ? b : logical(a, "&&", b));
+    switch (n.type) {
+        case "NullLiteral":
+            return [];
+        case "ArrayExpression":
+            return n.elements.flatMap((el) => (el ? styleItems(s, el, when) : []));
+        case "StringLiteral":
+            return [{ cond: when, entries: Object.entries(parseStringStyle(n.value)).map(([key, v]) => ({ key, css: key, value: { type: "StringLiteral", value: v } })) }];
+        case "ConditionalExpression": {
+            const t = cond(s, n.test);
+            return [...styleItems(s, n.consequent, both(when, t)), ...styleItems(s, n.alternate, both(when, not(t)))];
+        }
+        case "LogicalExpression":
+            if (n.operator === "&&")
+                return styleItems(s, n.right, both(when, cond(s, n.left)));
+            break;
+        case "ObjectExpression":
+            return [{
+                    cond: when,
+                    entries: n.properties.map((p) => {
+                        if (p.type !== "ObjectProperty" || p.computed)
+                            fail(s.comp, "a style object holds plain `property: value` pairs", p);
+                        const key = p.key.type === "Identifier" ? p.key.name : String(p.key.value);
+                        if (/^\d+$/.test(key) || key.startsWith(":"))
+                            fail(s.comp, `style property \`${key}\``, p);
+                        return { key, css: key.startsWith("--") ? key : hyphenate(key), value: p.value };
+                    }),
+                }];
+    }
+    return fail(s.comp, "a style binding is an object, an array of objects, or a string on its own", n);
+}
+export function renderStyle(s, e, n) {
+    if (n.type === "StringLiteral") {
+        e.lit(escapeHtml(n.value));
+        return;
+    }
+    if (n.type !== "ObjectExpression" && n.type !== "ArrayExpression" && n.type !== "ConditionalExpression" && n.type !== "LogicalExpression" && n.type !== "NullLiteral") {
+        const v = expr(s, n);
+        if (v.ty.k === "str")
+            e.stmt(`fv::escape_into(out, ${strArg(v.code)});`);
+        else if (v.ty.k === "opt" && v.ty.of.k === "str") {
+            e.open(`if let Some(v) = ${v.code}`);
+            e.stmt("fv::escape_into(out, v);");
+            e.close();
+        }
+        else if (v.ty.k !== "undef")
+            fail(s.comp, "a style binding is a string, an object or an array", n);
+        return;
+    }
+    const items = styleItems(s, n, null);
+    const order = [];
+    const sets = new Map();
+    for (const it of items) {
+        for (const en of it.entries) {
+            if (!sets.has(en.key)) {
+                order.push(en.key);
+                sets.set(en.key, []);
+            }
+            sets.get(en.key).push({ cond: it.cond, css: en.css, value: en.value });
+        }
+    }
+    const write = (css, value) => {
+        if (value.type === "StringLiteral" || value.type === "NumericLiteral") {
+            e.lit(escapeHtml(`${css}:${String(value.value)};`));
+            return;
+        }
+        const v = expr(s, value);
+        const one = (w) => {
+            if (w.ty.k === "str" || w.ty.k === "int" || w.ty.k === "float") {
+                e.lit(`${escapeHtml(css)}:`);
+                display(e, w);
+                e.lit(";");
+            }
+            else if (w.ty.k === "opt") {
+                e.open(`if let Some(v) = ${w.code}`);
+                one({ code: "v", ty: w.ty.of });
+                e.close();
+            }
+        };
+        one(v);
+    };
+    const flat = items.flatMap((it, i) => it.entries.map((en) => ({ key: en.key, item: i, cond: it.cond })));
+    for (const key of order) {
+        const at = flat.filter((f) => f.key === key);
+        if (at.length < 2 || at[0].cond === null)
+            continue;
+        const first = flat.indexOf(at[0]);
+        const again = flat.indexOf(at[at.length - 1]);
+        const between = flat.slice(first + 1, again).some((f) => order.indexOf(f.key) > order.indexOf(key));
+        if (between)
+            fail(s.comp, `the place of style property \`${key}\` would depend on a condition; set it unconditionally first`, n);
+    }
+    for (const key of order) {
+        const chain = [];
+        for (const set of sets.get(key).toReversed()) {
+            chain.push(set);
+            if (set.cond === null)
+                break;
+        }
+        if (chain.length === 1 && chain[0].cond === null) {
+            write(chain[0].css, chain[0].value);
+            continue;
+        }
+        chain.forEach((set, i) => {
+            if (set.cond === null) {
+                e.close(" else {");
+            }
+            else if (i === 0) {
+                e.open(`if ${condition(set.cond)}`);
+            }
+            else {
+                e.close(` else if ${condition(set.cond)} {`);
+            }
+            write(set.css, set.value);
+        });
+        e.close();
+    }
+}

package/dist/template.d.ts

@@ -1,48 +1,7 @@
-import { type Component, type N, type Scope, type Ty, type Val } from "./model.ts";
+import { type N, type Scope } from "./model.ts";
 import { Emitter } from "./emitter.ts";
-/** One `${...}` inside a pushed template literal. */
 export declare function slot(s: Scope, e: Emitter, n: N): void;
-/** `isComment` in `@vue/server-renderer`: a chunk that is only comments and whitespace. */
 export declare function isComment(text: string): boolean;
-/** Whether a `_push` argument is content to `ssrRenderSlot` rather than only comments — `"run"`
- * when that depends on the values it interpolates (`${of1}<!--[-->` is a comment when `of1` writes
- * nothing). Vue asks it of each pushed string, so the generated code asks `fv::is_comment` of what
- * that push wrote. */
 export declare function pushesContent(n: N): boolean | "run";
 export declare function push(s: Scope, e: Emitter, n: N): void;
-export declare function renderChild(s: Scope, e: Emitter, n: N): void;
-/** `name: value` in a struct literal, or the name alone when the value is a variable of that name. */
-export declare function fieldInit(name: string, value: string): string;
-/** Whether a component takes a `Slots` argument. */
-export declare function takesSlots(c: Component): boolean;
-/** The arguments after `props` that a component's `render` takes. */
-export declare function extraParams(c: Component): string;
-/** `render(out, props[, slots][, route])` for a child, with the slot content this template gives
- * it as closures; `render_scoped`, with the scope ids its root is handed last — and the attributes
- * it is passed, as `fv::Attrs` — for a child that may be handed some. */
-export declare function callChild(s: Scope, e: Emitter, child: Component, propsCode: string, slots: N, attrs: string | null): void;
-/** The statements a parent's slot content pushes: the `if (_push)` half of its `_withCtx`. */
-export declare function slotBody(s: Scope, value: N): N[];
-/** A parent's slot content: what it pushes, and the parameter its scoped slot props are bound to
- * (`_` when it takes none). */
-export declare function slotContent(s: Scope, value: N): {
-    body: N[];
-    param: N;
-};
-/** Whether slot content always pushes something that is not a comment: a push of content outside
- * any `if` or loop. Then nothing has to be decided at run time. */
-export declare function staticallyFilled(body: N[]): boolean;
-/** `RowSlotProps`, `RowSlot`: the names of a scoped slot's props struct and content type. */
-export declare function slotTypeName(slotName: string, suffix: string): string;
-/** Whether a scoped slot prop's Rust type borrows, and so needs the props' lifetime `'v`. */
-export declare function slotFieldBorrows(ty: Ty): boolean;
-/** A scoped slot prop's Rust type: a scalar copied, anything else borrowed from the render for `'v`. */
-export declare function slotFieldTy(ty: Ty, comp: Component): string;
-/** A value an outlet passes, as the scoped slot prop field holds it. */
-export declare function slotFieldValue(s: Scope, v: Val, n: N): string;
-/** `<slot name="x" :prop="…">fallback</slot>`: `ssrRenderSlot`, with the props a scoped slot passes. */
-export declare function slotOutlet(s: Scope, e: Emitter, c: N): void;
-/** A value into a child's props field, whose strings are `Cow`s. */
-export declare function ownInto(comp: Component, v: Val, want: Ty, node: N): string;
 export declare function statements(s: Scope, e: Emitter, body: N[]): void;
-export declare function list(s: Scope, e: Emitter, c: N): void;