ferrovue 0.4.0 → 0.5.0

package/dist/lists.js

@@ -4,14 +4,14 @@ import { expr, fieldVal } from "./expr.js";
 import { cond } from "./narrowing.js";
 import { asF64, isNumber } from "./numbers.js";
 import { asCow, isTemporary, lonely, meet, yieldsCow } from "./strings.js";
-import { atom, operand, strArg, UNARY } from "./parens.js";
+import { atom, binary, operand, strArg, UNARY } from "./parens.js";
 const COW = "std::borrow::Cow::<str>";
 function itemsTy(s, v, n) {
     if (v.ty.k !== "list")
-        return fail(s.comp, "not a list", n);
+        return fail(s.comp, "FV0803", "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);
+        fail(s.comp, "FV0804", "this method takes a list of strings, numbers, booleans or objects", n);
     }
     return of;
 }
@@ -44,13 +44,13 @@ function itemVal(of, param, byRef, lone) {
 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);
+        fail(comp, "FV0805", `\`.${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);
+        fail(comp, "FV0806", `\`.${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);
+        fail(comp, "FV0807", "an arrow function's index is a plain name", index);
     const n = ++ctx.narrowCount;
     const p = of.k === "str" ? `fv_s${n}` : `fv_a${n}`;
     const i = `fv_i${n}`;
@@ -64,14 +64,14 @@ function arrow(s, fn, list, of, byRef, method, body) {
     else if (item?.type === "ObjectPattern" && (of.k === "struct" || of.k === "child")) {
         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);
+                fail(comp, "FV0808", "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);
+        fail(comp, "FV0809", "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);
@@ -110,7 +110,7 @@ function mapped(s, v, n) {
         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);
+            return fail(s.comp, "FV0810", `\`.map()\` makes a list of strings, numbers, booleans or objects, not ${v.ty.k === "opt" ? "optional values" : "these"}`, n);
     }
 }
 export function listMethod(s, target, method, args, n) {
@@ -121,13 +121,13 @@ export function listMethod(s, target, method, args, 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);
+            fail(comp, "FV0811", "`.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);
+                fail(comp, "FV0812", "`.slice()` takes numbers", n);
             return asF64(v);
         };
         const from = index(start) ?? "0.0";
@@ -135,7 +135,7 @@ export function listMethod(s, target, method, args, n) {
         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);
+        fail(comp, "FV0813", `\`.${method}()\` takes one arrow function`, n);
     const fn = args[0];
     switch (method) {
         case "filter": {
@@ -175,19 +175,19 @@ 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);
+        return fail(comp, "FV0814", `\`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);
+            fail(comp, "FV0815", "`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);
+        return fail(comp, "FV0816", "`Object.entries()` is supported as the source of a `v-for`: `([key, value], i) in Object.entries(r)`", n);
+    return fail(comp, "FV0817", `\`Object.${method}()\` is not supported: \`keys\`, \`values\` and \`entries\` of a record are`, n);
 }
 export function computedListMethod(s, target, method, args, n) {
     if (target.ty.k !== "list")
@@ -195,11 +195,20 @@ export function computedListMethod(s, target, method, args, n) {
     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]);
+        const numbers = isNumber(x.ty) && isNumber(of);
+        if ((!sameTy(x.ty, of) && !numbers) || !["str", "int", "float", "bool"].includes(of.k))
+            fail(s.comp, "FV0801", "`.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");
-        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}`;
+        const test = of.k === "str"
+            ? `*v == ${x.code.startsWith("&*") ? `*${x.code.slice(2)}` : `*${operand(x.code, UNARY)}`}`
+            : of.k === "float" && x.ty.k === "int"
+                ? binary("v", "==", asF64(x))
+                : of.k === "float"
+                    ? `v == ${x.code} || (v.is_nan() && ${atom(x.code)}.is_nan())`
+                    : of.k === "int" && x.ty.k === "float"
+                        ? binary("v as f64", "==", x.code)
+                        : `v == ${x.code}`;
         return { code: `${items(target)}.any(|v| ${test})`, ty: BOOL };
     }
     if (method === "join" && args.length <= 1) {
@@ -207,10 +216,10 @@ export function computedListMethod(s, target, method, args, n) {
             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]);
+            fail(s.comp, "FV0802", "`.join()` takes a string", args[0]);
         const parted = /^"[^"]/.test(sep.code);
         if (of.k === "str" && target.lone && (!parted || sep.lone))
-            fail(s.comp, lonely("`.join()` with no literal separator"), n);
+            fail(s.comp, "FV0706", 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 } : {}) };
     }

package/dist/loops.js

@@ -8,15 +8,15 @@ import { statements } from "./template.js";
 export function list(s, e, c) {
     const fn = c.arguments[1];
     if (fn.type !== "ArrowFunctionExpression" || fn.body.type !== "BlockStatement") {
-        fail(s.comp, "unexpected `ssrRenderList` callback", c);
+        fail(s.comp, "FV0006", "unexpected `ssrRenderList` callback", c);
     }
     if (isObjectCall(c.arguments[0], "entries")) {
         const [pair, index] = fn.params;
         const r = c.arguments[0].arguments.length === 1 ? expr(s, c.arguments[0].arguments[0]) : null;
         if (r?.ty.k !== "record")
-            return fail(s.comp, "`Object.entries()` takes a `Record<string, T>`", c.arguments[0]);
+            return fail(s.comp, "FV0814", "`Object.entries()` takes a `Record<string, T>`", c.arguments[0]);
         if (pair?.type !== "ArrayPattern" || pair.elements.length > 2 || pair.elements.some((x) => x?.type !== "Identifier")) {
-            return fail(s.comp, "a `v-for` over `Object.entries()` names its items `[key, value]`", pair ?? c);
+            return fail(s.comp, "FV0818", "a `v-for` over `Object.entries()` names its items `[key, value]`", pair ?? c);
         }
         recordLoop(s, e, r, fn, pair.elements[1], pair.elements[0], index);
         return;
@@ -55,7 +55,7 @@ export function list(s, e, c) {
     else if (src.ty.k === "list") {
         of = src.ty.of;
         if (of.k === "undef")
-            fail(s.comp, "`v-for` over an empty array literal", c);
+            fail(s.comp, "FV0819", "`v-for` over an empty array literal", c);
         const itemCode = `${itemName}_ref`;
         walk = `${atom(src.code)}.iter()`;
         bound = itemCode;
@@ -64,12 +64,16 @@ export function list(s, e, c) {
             e.stmt(`let ${itemName}: &str = ${itemCode};`);
         else if (of.k === "struct" || of.k === "child")
             e.stmt(`let ${itemName} = ${itemCode};`);
+        else if (of.k === "opt" && of.of.k === "str")
+            e.stmt(`let ${itemName} = ${itemCode}.as_deref();`);
+        else if (of.k === "opt" && !["int", "float", "bool"].includes(of.of.k))
+            e.stmt(`let ${itemName} = ${itemCode}.as_ref();`);
         else
             e.stmt(`let ${itemName} = *${itemName}_ref;`);
         itemLet = e.lines.length - 1;
     }
     else {
-        return fail(s.comp, "`v-for` walks an array, or counts to a number", c);
+        return fail(s.comp, "FV0820", "`v-for` walks an array, or counts to a number", c);
     }
     let idxLet = -1;
     if (idx) {
@@ -82,13 +86,13 @@ export function list(s, e, c) {
     else if (item.type === "ObjectPattern") {
         for (const p of item.properties) {
             if (p.type !== "ObjectProperty" || p.computed || p.value.type !== "Identifier") {
-                fail(s.comp, "a destructured `v-for` item binds plain names, without defaults", p);
+                fail(s.comp, "FV0821", "a destructured `v-for` item binds plain names, without defaults", p);
             }
             inner.set(p.value.name, fieldVal(s.comp, itemName, of, p.key.name ?? p.key.value, p));
         }
     }
     else
-        fail(s.comp, "a `v-for` item is a name or an object pattern", item);
+        fail(s.comp, "FV0822", "a `v-for` item is a name or an object pattern", item);
     if (index)
         inner.set(index.name, { code: idx, ty: INT });
     const before = e.literalBytes;
@@ -118,7 +122,7 @@ function recordLoop(s, e, r, fn, value, key, index) {
     const of = r.ty.of;
     for (const p of [key, index])
         if (p && p.type !== "Identifier")
-            fail(s.comp, "a record's key and index in `v-for` are plain names", p);
+            fail(s.comp, "FV0823", "a record's key and index in `v-for` are plain names", p);
     const n = ++ctx.narrowCount;
     const v = value?.type === "Identifier" ? snake(value.name) : `fv_value${n}`;
     const k = key ? snake(key.name) : `fv_key${n}`;
@@ -135,13 +139,13 @@ function recordLoop(s, e, r, fn, value, key, index) {
     else if (value?.type === "ObjectPattern" && (of.k === "struct" || of.k === "child")) {
         for (const p of value.properties) {
             if (p.type !== "ObjectProperty" || p.computed || p.value.type !== "Identifier") {
-                fail(s.comp, "a destructured `v-for` item binds plain names, without defaults", p);
+                fail(s.comp, "FV0821", "a destructured `v-for` item binds plain names, without defaults", p);
             }
             inner.set(p.value.name, fieldVal(s.comp, v, of, p.key.name ?? p.key.value, p));
         }
     }
     else if (value)
-        fail(s.comp, "a `v-for` item is a name, or an object pattern of an object", value);
+        fail(s.comp, "FV0822", "a `v-for` item is a name, or an object pattern of an object", value);
     if (key)
         inner.set(key.name, { code: k, ty: STR });
     if (index)

package/dist/model.d.ts

@@ -1,5 +1,7 @@
 import type { SourceMapConsumer } from "source-map-js";
 import type { Plugin } from "./plugin.ts";
+import type { Const } from "./constants.ts";
+import type { Code } from "./errors.ts";
 export type N = any;
 export type Ty = {
     k: "str";
@@ -11,9 +13,12 @@ export type Ty = {
     k: "bool";
 } | {
     k: "undef";
+} | {
+    k: "null";
 } | {
     k: "opt";
     of: Ty;
+    none?: "null" | "either";
 } | {
     k: "list";
     of: Ty;
@@ -63,7 +68,13 @@ export declare const INT: Ty;
 export declare const FLOAT: Ty;
 export declare const BOOL: Ty;
 export declare const UNDEF: Ty;
+export declare const NULL: Ty;
+export type Absence = "undefined" | "null" | "either";
 export declare const opt: (of: Ty) => Ty;
+export declare function absence(ty: Ty): Absence | null;
+export declare function joinAbsence(a: Absence | null, b: Absence | null): Absence | null;
+export declare function withAbsence(of: Ty, none: Absence | null): Ty;
+export declare function nothing(ty: Ty): boolean;
 export declare const RUST_KEYWORDS: Set<string>;
 export declare const RUST_PRELUDE: Set<string>;
 export declare function snake(js: string): string;
@@ -72,8 +83,24 @@ export declare function declares(comp: Component, key: string): boolean;
 export declare function takesAttrs(comp: Component): boolean;
 export declare function rustStr(s: string): string;
 export declare function rustChar(ch: string): string;
+/** Where in a file an error is: lines and columns count from 1, and the end is exclusive. */
+export interface Location {
+    file: string;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+}
+/** A construct the compiler refuses: its stable code, the message as shown, where it is, and what
+ * is refused without the location and the quoted line. */
 export declare class GenError extends Error {
+    readonly code: Code;
+    readonly at: Location | null;
+    readonly what: string;
+    constructor(code: Code, message: string, at?: Location | null, what?: string);
 }
+/** Refuse something in a file that has no source to quote, as a locale or routes file. */
+export declare function failIn(file: string, code: Code, what: string): never;
 export interface Component {
     name: string;
     module: string;
@@ -84,6 +111,7 @@ export interface Component {
         line: number;
         column: number;
     };
+    templateAst?: N;
     attrsDropped?: N;
     props: Struct;
     structs: Map<string, Struct>;
@@ -127,6 +155,8 @@ export interface Scope {
     attrs: string | null;
     fallthrough: string | null;
     attrsBindings: Set<string>;
+    slotsBindings: Set<string>;
+    consts: Map<string, Const>;
     sid: string | null;
     loop?: {
         item: string;
@@ -136,5 +166,6 @@ export interface Scope {
 }
 export type Origin = "source" | "template";
 export declare function tagAst(node: N, origin: Origin, seen?: WeakSet<object>): void;
-export declare function fail(comp: Component, what: string, node?: N): never;
+export declare function sourceAt(source: string, offset: number): N;
+export declare function fail(comp: Component, code: Code, what: string, node?: N): never;
 export declare function sameTy(a: Ty, b: Ty): boolean;

package/dist/model.js

@@ -3,7 +3,32 @@ export const INT = { k: "int" };
 export const FLOAT = { k: "float" };
 export const BOOL = { k: "bool" };
 export const UNDEF = { k: "undef" };
-export const opt = (of) => (of.k === "opt" ? of : { k: "opt", of });
+export const NULL = { k: "null" };
+export const opt = (of) => (of.k !== "opt" ? { k: "opt", of } : of.none === undefined ? of : { k: "opt", of: of.of, none: "either" });
+export function absence(ty) {
+    if (ty.k === "undef")
+        return "undefined";
+    if (ty.k === "null")
+        return "null";
+    if (ty.k === "opt")
+        return ty.none ?? "undefined";
+    return null;
+}
+export function joinAbsence(a, b) {
+    if (a === null || a === b)
+        return b;
+    if (b === null)
+        return a;
+    return "either";
+}
+export function withAbsence(of, none) {
+    if (none === null)
+        return of;
+    return none === "undefined" ? { k: "opt", of } : { k: "opt", of, none };
+}
+export function nothing(ty) {
+    return ty.k === "undef" || ty.k === "null";
+}
 export const RUST_KEYWORDS = new Set("as break const continue crate else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type unsafe use where while async await dyn abstract become box do final macro override priv typeof unsized virtual yield try".split(" "));
 const NOT_RAW = new Set(["self", "Self", "super", "crate"]);
 export const RUST_PRELUDE = new Set(["Option", "Some", "None", "Vec", "String", "Box", "Result", "Ok", "Err", "Cow", "Slots", "Default"]);
@@ -51,7 +76,22 @@ export function rustChar(ch) {
         return `'"'`;
     return `'${rustStr(ch).slice(1, -1)}'`;
 }
+/** A construct the compiler refuses: its stable code, the message as shown, where it is, and what
+ * is refused without the location and the quoted line. */
 export class GenError extends Error {
+    code;
+    at;
+    what;
+    constructor(code, message, at = null, what = message) {
+        super(message);
+        this.code = code;
+        this.at = at;
+        this.what = what;
+    }
+}
+/** Refuse something in a file that has no source to quote, as a locale or routes file. */
+export function failIn(file, code, what) {
+    throw new GenError(code, `${file}: ${what}`, { file }, what);
 }
 export function blankComponent(name, module, file, structs = new Map()) {
     return {
@@ -105,12 +145,79 @@ function locate(comp, node) {
     if (node.__fv === "template" && comp.templateMap && comp.templateStart) {
         const o = comp.templateMap.originalPositionFor({ line: start.line, column: start.column });
         if (o.line == null || o.column == null)
-            return null;
+            return locateWithin(comp, node) ?? locate(comp, written(comp, node));
         const t = comp.templateStart;
         return o.line === 1 ? { line: t.line, column: t.column - 1 + o.column } : { line: t.line + o.line - 1, column: o.column };
     }
     return null;
 }
+function locateWithin(comp, node) {
+    const start = node.loc.start;
+    const inner = Object.entries(node)
+        .filter(([k, v]) => k !== "loc" && v && typeof v === "object")
+        .flatMap(([, v]) => (Array.isArray(v) ? v : [v]))
+        .filter((c) => c?.loc?.start)
+        .toSorted((a, b) => a.start - b.start);
+    for (const child of inner) {
+        const at = locate(comp, child);
+        if (!at)
+            continue;
+        const c = child.loc.start;
+        const back = c.line === start.line ? c.column - start.column : 0;
+        return { line: at.line, column: Math.max(0, at.column - back) };
+    }
+    return null;
+}
+export function sourceAt(source, offset) {
+    const before = source.slice(0, offset);
+    const line = before.split("\n").length;
+    return { type: "VueSource", loc: { start: { line, column: offset - before.lastIndexOf("\n") - 1 } }, __fv: "source" };
+}
+const plain = (name) => name.replace(/[-_]/g, "").toLowerCase();
+function assetName(n, prefix) {
+    if (n?.type === "Identifier")
+        return n.name.replace(prefix, "");
+    if (n?.type === "MemberExpression")
+        return n.computed ? n.property.value : n.property.name;
+    return null;
+}
+function written(comp, node) {
+    const call = node.type === "VariableDeclaration" ? node.declarations[0]?.init : node.type === "ExpressionStatement" ? node.expression : node;
+    const callee = call?.type === "CallExpression" && call.callee.type === "Identifier" ? call.callee.name : null;
+    const tagged = (name) => name && templateNode(comp, (el) => (plain(el.tag) === plain(name) ? el : null));
+    const directive = (name) => name && templateNode(comp, (el) => el.props.find((p) => p.type === 7 && plain(p.name) === plain(name)));
+    switch (callee) {
+        case "_ssrRenderComponent":
+            return tagged(assetName(call.arguments[0], /^_component_/));
+        case "_resolveComponent":
+            return tagged(call.arguments[0]?.value ?? null);
+        case "_resolveDirective":
+            return directive(call.arguments[0]?.value ?? null);
+        case "_ssrGetDirectiveProps":
+            return directive(assetName(call.arguments[1], /^_directive_/)?.replace(/^v(?=[A-Z])/, "") ?? null);
+        case "_ssrRenderSlot": {
+            const name = call.arguments[1]?.value;
+            return templateNode(comp, (el) => (el.tag === "slot" && (el.props.find((p) => p.type === 6 && p.name === "name")?.value?.content ?? "default") === name ? el : null));
+        }
+        default:
+            return null;
+    }
+}
+function templateNode(comp, test) {
+    const visit = (n) => {
+        const found = n.type === 1 ? test(n) : null;
+        if (found)
+            return found;
+        for (const c of n.children ?? []) {
+            const inner = visit(c);
+            if (inner)
+                return inner;
+        }
+        return null;
+    };
+    const found = comp.templateAst ? visit(comp.templateAst) : null;
+    return found && { type: "VueTemplate", loc: { start: { line: found.loc.start.line, column: found.loc.start.column - 1 } }, __fv: "source" };
+}
 function snippet(comp, at) {
     const text = comp.source?.split("\n")[at.line - 1];
     if (text === undefined)
@@ -119,12 +226,22 @@ function snippet(comp, at) {
     const lead = text.slice(0, at.column).replace(/[^\t]/g, " ");
     return `\n ${n} | ${text}\n ${" ".repeat(n.length)} | ${lead}^`;
 }
-export function fail(comp, what, node) {
+function locateEnd(node) {
+    const end = node?.__fv === "source" ? node.loc?.end : null;
+    return end ? { endLine: end.line, endColumn: end.column + 1 } : null;
+}
+export function fail(comp, code, what, node) {
     const at = locate(comp, node);
     if (!at)
-        throw new GenError(`${comp.file}: ${what}`);
-    throw new GenError(`${comp.file}:${at.line}:${at.column + 1}: ${what}${snippet(comp, at)}`);
+        throw new GenError(code, `${comp.file}: ${what}`, { file: comp.file }, what);
+    const where = { file: comp.file, line: at.line, column: at.column + 1, ...locateEnd(node) };
+    throw new GenError(code, `${comp.file}:${at.line}:${at.column + 1}: ${what}${snippet(comp, at)}`, where, what);
+}
+function canonical(_key, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
 }
 export function sameTy(a, b) {
-    return JSON.stringify(a) === JSON.stringify(b);
+    return JSON.stringify(a, canonical) === JSON.stringify(b, canonical);
 }

package/dist/narrowing.d.ts

@@ -2,6 +2,14 @@ import { type N, type Scope, type Ty, type Val } from "./model.ts";
 export declare function known(v: Val): boolean | undefined;
 export declare function truthy(v: Val): string;
 export declare function pathOf(n: N): string | null;
+export interface NullTest {
+    target: N;
+    literal: "null" | "undefined";
+    strict: boolean;
+    is: boolean;
+}
+export declare function nullTest(n: N): NullTest | null;
+export declare function checkNullTest(s: Scope, t: NullTest, v: Val): void;
 export interface Presence {
     path: string;
     pattern: (name: string) => string;

package/dist/narrowing.js

@@ -1,4 +1,4 @@
-import { BOOL } from "./model.js";
+import { absence, BOOL, fail, nothing } from "./model.js";
 import { ctx } from "./context.js";
 import { claim } from "./plugin.js";
 import { atom, bare, binary, condition, ifElse, logical, not, occurrences, receiver } from "./parens.js";
@@ -7,6 +7,8 @@ import { expr } from "./expr.js";
 export function known(v) {
     if (v.konst !== undefined)
         return v.konst;
+    if (nothing(v.ty))
+        return false;
     if (v.ty.k === "str" && /^"(?:[^"\\]|\\.)*"$/.test(v.code))
         return v.code !== '""';
     if (v.num !== undefined)
@@ -30,6 +32,7 @@ export function truthy(v) {
         case "bool":
             return v.code;
         case "undef":
+        case "null":
             return "false";
         case "opt":
             return `${atom(v.code)}.is_some_and(|v| ${truthy({ code: "v", ty: v.ty.of })})`;
@@ -51,6 +54,35 @@ export function pathOf(n) {
         return `${base}.${n.property.value}`;
     return null;
 }
+function nothingLiteral(n) {
+    if (n.type === "NullLiteral")
+        return "null";
+    if (n.type === "Identifier" && n.name === "undefined")
+        return "undefined";
+    return null;
+}
+export function nullTest(n) {
+    if (n.type !== "BinaryExpression" || !["===", "!==", "==", "!="].includes(n.operator))
+        return null;
+    const right = nothingLiteral(n.right);
+    const left = nothingLiteral(n.left);
+    const literal = right ?? left;
+    if (literal === null)
+        return null;
+    return { target: right !== null ? n.left : n.right, literal, strict: n.operator.length === 3, is: n.operator.startsWith("=") };
+}
+export function checkNullTest(s, t, v) {
+    const none = absence(v.ty);
+    if (none === null || !t.strict || none === t.literal)
+        return;
+    const op = t.is ? "==" : "!=";
+    if (none === "either") {
+        fail(s.comp, "FV0626", `\`${op}= ${t.literal}\` of a value that may be \`null\` or \`undefined\`, which its Rust \`Option\` cannot tell apart: test both with \`${op} null\``, t.target);
+    }
+    const other = t.literal === "null" ? "undefined" : "null";
+    const what = none === "null" ? "is `T | null`, never `undefined`" : "is optional, which is `undefined` when absent, never `null`";
+    fail(s.comp, "FV0627", `\`${op}= ${t.literal}\` of a value that ${what}: compare with \`${other}\``, t.target);
+}
 export function presence(s, n) {
     for (const p of ctx.plugins) {
         const own = p.presence?.(s, n);
@@ -64,15 +96,12 @@ export function presence(s, n) {
         target = n.argument;
         negated = true;
     }
-    else if (n.type === "BinaryExpression" && (n.operator === "===" || n.operator === "!==")) {
-        const isUndef = (m) => m.type === "Identifier" && m.name === "undefined";
-        if (isUndef(n.right))
-            target = n.left;
-        else if (isUndef(n.left))
-            target = n.right;
-        else
+    else if (n.type === "BinaryExpression") {
+        const test = nullTest(n);
+        if (!test)
             return null;
-        negated = n.operator === "===";
+        target = test.target;
+        negated = test.is;
         byTruth = false;
     }
     const path = pathOf(target);
@@ -81,6 +110,8 @@ export function presence(s, n) {
     const v = expr(s, target);
     if (v.ty.k !== "opt")
         return null;
+    if (n.type === "BinaryExpression")
+        checkNullTest(s, nullTest(n), v);
     const of = v.ty.of;
     const scalar = of.k === "str" || of.k === "int" || of.k === "float" || of.k === "bool";
     const filtered = byTruth && scalar;

package/dist/plugins/client-only.d.ts

@@ -0,0 +1,8 @@
+import { type Component } from "../model.ts";
+import { type Plugin } from "../plugin.ts";
+interface ClientOnlyRun {
+    locals: Map<Component, Set<string>>;
+    outside: Map<Component, Set<string>>;
+}
+export declare const clientOnly: Plugin<ClientOnlyRun>;
+export {};