@doki-land/dejavu-engine 0.0.12 → 0.0.13

package/dist/runtime/expr.d.ts

@@ -1,23 +1,23 @@
 /**
  * Dejavu 1.0 支持的二元运算符。
- * 与 Rust `dejavu-ir::IrExprBinaryOp` 枚举一一对应。
+ * 与 Rust `dejavu-ir` 的 `eval_binary` 一一对应，**不借用 JS 隐式转换**：
  *
- * 行为：
- * - `+` 特殊：任何一侧为字符串时做字符串拼接，否则数值加法。
- * - `&&` / `||` 返回原值（短路），不是布尔。
- * - `in`：R 是 object / array 时检查 key 存在。
- * - 比较与相等用 JS 原生语义。
+ * - `+`：两侧都是 number 时相加，否则按 `valueToString` 做字符串拼接。
+ * - `-` `*` `/` `%`：只接受 number，非 number 或结果非有限数 → null。
+ * - `==` / `!=`：结构相等（见 `valuesEqual`），不做类型转换。
+ * - `<` `<=` `>` `>=`：两侧都是 number 才比较，否则 false。
+ * - `&&` / `||`：返回 **boolean**（Dejavu truthiness），不是原值。
+ * - `in`：数组按成员、字符串按子串、对象按 key 判断。
  */
 export declare function binary(op: string, l: unknown, r: unknown): unknown;
 /**
- * 一元运算符。
+ * 一元运算符 —— 与 Rust `eval_unary` 对齐。
  *
- * `!` 使用 **Dejavu truthiness**（不是 JS falsy）。
+ * `!` 使用 Dejavu truthiness；`-` 只接受 number；`+` 是恒等。
  */
 export declare function unary(op: string, a: unknown): unknown;
 /**
- * 成员访问 —— `obj?.[property] ?? null`。
- * 对不存在的键返回 null（不是 undefined）。
+ * 成员访问 —— 对不存在的键返回 null（不是 undefined）。
  */
 export declare function exprMember(obj: unknown, property: string): unknown;
 /**

package/dist/runtime/expr.js

@@ -1,81 +1,100 @@
-import { isTruthy } from "./value.js";
+import { isTruthy, valueToString, valuesEqual } from "./value.js";
 /**
  * Dejavu 1.0 支持的二元运算符。
- * 与 Rust `dejavu-ir::IrExprBinaryOp` 枚举一一对应。
+ * 与 Rust `dejavu-ir` 的 `eval_binary` 一一对应，**不借用 JS 隐式转换**：
  *
- * 行为：
- * - `+` 特殊：任何一侧为字符串时做字符串拼接，否则数值加法。
- * - `&&` / `||` 返回原值（短路），不是布尔。
- * - `in`：R 是 object / array 时检查 key 存在。
- * - 比较与相等用 JS 原生语义。
+ * - `+`：两侧都是 number 时相加，否则按 `valueToString` 做字符串拼接。
+ * - `-` `*` `/` `%`：只接受 number，非 number 或结果非有限数 → null。
+ * - `==` / `!=`：结构相等（见 `valuesEqual`），不做类型转换。
+ * - `<` `<=` `>` `>=`：两侧都是 number 才比较，否则 false。
+ * - `&&` / `||`：返回 **boolean**（Dejavu truthiness），不是原值。
+ * - `in`：数组按成员、字符串按子串、对象按 key 判断。
  */
 export function binary(op, l, r) {
     switch (op) {
         case "+": {
-            if (typeof l === "string" || typeof r === "string") {
-                return String(l) + String(r);
+            if (typeof l === "number" && typeof r === "number") {
+                return finite(l + r);
             }
-            return l + r;
+            return valueToString(l) + valueToString(r);
         }
         case "-":
-            return l - r;
         case "*":
-            return l * r;
         case "/":
-            return l / r;
-        case "%":
-            return l % r;
+        case "%": {
+            if (typeof l !== "number" || typeof r !== "number")
+                return null;
+            const value = op === "-"
+                ? l - r
+                : op === "*"
+                    ? l * r
+                    : op === "/"
+                        ? l / r
+                        : l % r;
+            return finite(value);
+        }
         case "==":
-            // Dejavu 1.0 只用 ==/!= —— JS 宽松相等
-            // eslint-disable-next-line eqeqeq
-            return l == r;
+            return valuesEqual(l, r);
         case "!=":
-            // eslint-disable-next-line eqeqeq
-            return l != r;
-        case "===":
-            return l === r;
-        case "!==":
-            return l !== r;
+            return !valuesEqual(l, r);
         case "<":
-            return l < r;
         case "<=":
-            return l <= r;
         case ">":
-            return l > r;
-        case ">=":
-            return l >= r;
+        case ">=": {
+            if (typeof l !== "number" || typeof r !== "number")
+                return false;
+            if (!Number.isFinite(l) || !Number.isFinite(r))
+                return false;
+            switch (op) {
+                case "<":
+                    return l < r;
+                case "<=":
+                    return l <= r;
+                case ">":
+                    return l > r;
+                default:
+                    return l >= r;
+            }
+        }
         case "&&":
-            return l && r;
+            return isTruthy(l) && isTruthy(r);
         case "||":
-            return l || r;
+            return isTruthy(l) || isTruthy(r);
         case "in":
-            if (r === null || r === undefined)
-                return false;
-            return String(l) in r;
+            if (Array.isArray(r))
+                return r.some((item) => valuesEqual(item, l));
+            if (typeof r === "string")
+                return r.includes(valueToString(l));
+            if (r !== null && typeof r === "object") {
+                return Object.prototype.hasOwnProperty.call(r, valueToString(l));
+            }
+            return false;
         default:
             return null;
     }
 }
+function finite(value) {
+    return Number.isFinite(value) ? value : null;
+}
 /**
- * 一元运算符。
+ * 一元运算符 —— 与 Rust `eval_unary` 对齐。
  *
- * `!` 使用 **Dejavu truthiness**（不是 JS falsy）。
+ * `!` 使用 Dejavu truthiness；`-` 只接受 number；`+` 是恒等。
  */
 export function unary(op, a) {
     switch (op) {
         case "!":
             return !isTruthy(a);
         case "-":
-            return -(Number(a) || 0);
+            return typeof a === "number" ? finite(-a) : null;
         case "+":
-            return +(Number(a) || 0);
+            return a;
         default:
             return null;
     }
 }
 /**
- * 成员访问 —— `obj?.[property] ?? null`。
- * 对不存在的键返回 null（不是 undefined）。
+ * 成员访问 —— 对不存在的键返回 null（不是 undefined）。
  */
 export function exprMember(obj, property) {
     if (obj === null || obj === undefined)

package/dist/runtime/filter.d.ts

@@ -1,8 +1,8 @@
 /**
  * Dejavu 1.0 合同过滤器集。
  *
- * 与 Rust `dejavu-types` 过滤器系统（见 `projects/crates/dejavu-types/src/values/filter.rs`）
- * 以及 `dejavu-codegen` Node stub 对齐。
+ * 与 Rust `dejavu-ir` 的 `apply_filter` 逐项对齐，所有字符串强制转换都走
+ * `valueToString`（null → ""），不使用 JS 的 `String()`。
  *
  * 未识别的过滤器 **宽松返回原值**（与 Rust 渲染器一致，不抛错）。
  */

package/dist/runtime/filter.js

@@ -1,10 +1,10 @@
 import { htmlEscape } from "./escape.js";
-import { isTruthy, valueToString } from "./value.js";
+import { valueToString } from "./value.js";
 /**
  * Dejavu 1.0 合同过滤器集。
  *
- * 与 Rust `dejavu-types` 过滤器系统（见 `projects/crates/dejavu-types/src/values/filter.rs`）
- * 以及 `dejavu-codegen` Node stub 对齐。
+ * 与 Rust `dejavu-ir` 的 `apply_filter` 逐项对齐，所有字符串强制转换都走
+ * `valueToString`（null → ""），不使用 JS 的 `String()`。
  *
  * 未识别的过滤器 **宽松返回原值**（与 Rust 渲染器一致，不抛错）。
  */
@@ -16,57 +16,87 @@ export function applyFilter(name, value, args) {
         case "raw":
         case "safe":
         case "s":
-            return valueToString(value);
+            return value;
         case "uppercase":
         case "upper":
-            return String(value).toUpperCase();
+            return valueToString(value).toUpperCase();
         case "lowercase":
         case "lower":
-            return String(value).toLowerCase();
+            return valueToString(value).toLowerCase();
         case "trim":
-            return String(value).trim();
-        case "default":
-            return isTruthy(value) ? value : args[0] ?? "";
+            return valueToString(value).trim();
+        case "default": {
+            // 只有 null 与空串算缺失 —— 0 / false / [] 保留原值。
+            if (value === null || value === undefined || value === "") {
+                return args[0] ?? null;
+            }
+            return value;
+        }
         case "length": {
-            if (value === null || value === undefined)
-                return 0;
-            if (Array.isArray(value))
-                return value.length;
             if (typeof value === "string")
+                return [...value].length;
+            if (Array.isArray(value))
                 return value.length;
-            const maybe = value.length;
-            return typeof maybe === "number" ? maybe : String(value).length;
+            if (value !== null && typeof value === "object") {
+                return Object.keys(value).length;
+            }
+            return 0;
         }
-        case "join":
+        case "join": {
+            const sep = valueToString(args[0] ?? ",");
             return Array.isArray(value)
-                ? value.join(String(args[0] ?? ","))
-                : String(value);
-        case "replace":
-            return String(value).replace(args[0] ?? "", String(args[1] ?? ""));
+                ? value.map(valueToString).join(sep)
+                : valueToString(value);
+        }
+        case "replace": {
+            const from = valueToString(args[0] ?? "");
+            const to = valueToString(args[1] ?? "");
+            return valueToString(value).split(from).join(to);
+        }
         case "date": {
-            let d = null;
-            if (value instanceof Date) {
-                d = value;
-            }
-            else if (typeof value === "number") {
-                d = new Date(value);
-            }
-            else if (typeof value === "string") {
-                const parsed = new Date(value);
-                if (!Number.isNaN(parsed.getTime()))
-                    d = parsed;
-            }
-            if (!d)
-                return "";
-            // 第一期只支持 ISO 8601（args[0] 不使用 —— Rust 过滤器默认也是 ISO）。
-            return d.toISOString();
+            const pattern = valueToString(args[0] ?? "%Y-%m-%d");
+            return formatDate(valueToString(value), pattern);
         }
         case "slug":
-            return slugify(String(value));
+            return slugify(valueToString(value));
         default:
             return value;
     }
 }
+/**
+ * 与 Rust `format_date` 对齐的最小 strftime：`%Y %m %d %H %M %S %%`。
+ *
+ * 输入：空串 → ""；`now` → 当前时间；纯数字 → epoch 毫秒；其他 → ISO 解析。
+ */
+function formatDate(input, pattern) {
+    if (input === "")
+        return "";
+    let ms;
+    if (input === "now") {
+        ms = Date.now();
+    }
+    else if (/^[0-9]+$/.test(input)) {
+        ms = Number(input);
+    }
+    else {
+        ms = Date.parse(input);
+        if (Number.isNaN(ms))
+            return "";
+    }
+    if (Number.isNaN(ms))
+        return "";
+    const d = new Date(ms);
+    const pad = (n) => String(n).padStart(2, "0");
+    return pattern
+        .replaceAll("%%", "\u0000")
+        .replaceAll("%Y", String(d.getUTCFullYear()))
+        .replaceAll("%m", pad(d.getUTCMonth() + 1))
+        .replaceAll("%d", pad(d.getUTCDate()))
+        .replaceAll("%H", pad(d.getUTCHours()))
+        .replaceAll("%M", pad(d.getUTCMinutes()))
+        .replaceAll("%S", pad(d.getUTCSeconds()))
+        .replaceAll("\u0000", "%");
+}
 /**
  * 与 Rust `slug_filter` 对齐：
  *

package/dist/runtime/index.d.ts

@@ -5,6 +5,6 @@
  * 与 Rust `dejavu-codegen` Node stub 以及 `dejavu-types` 的 filter 系统语义一致。
  */
 export { htmlEscape } from "./escape.js";
-export { valueToString, isTruthy } from "./value.js";
+export { valueToString, isTruthy, valuesEqual } from "./value.js";
 export { applyFilter } from "./filter.js";
 export { binary, unary, exprMember, exprIndex } from "./expr.js";

package/dist/runtime/index.js

@@ -5,6 +5,6 @@
  * 与 Rust `dejavu-codegen` Node stub 以及 `dejavu-types` 的 filter 系统语义一致。
  */
 export { htmlEscape } from "./escape.js";
-export { valueToString, isTruthy } from "./value.js";
+export { valueToString, isTruthy, valuesEqual } from "./value.js";
 export { applyFilter } from "./filter.js";
 export { binary, unary, exprMember, exprIndex } from "./expr.js";

package/dist/runtime/value.d.ts

@@ -11,14 +11,17 @@
  */
 export declare function isTruthy(v: unknown): boolean;
 /**
- * 将任意 JS 值渲染为字符串。与 Rust 渲染器的 debug-print 语义对齐：
+ * 将任意 JS 值渲染为字符串。与 Rust `value_to_string` 对齐：
  *
  * - null / undefined → ""
  * - boolean → "true" / "false"
  * - number → String()（NaN / Infinity 保持原样）
  * - Date → toISOString()
- * - Array → 递归 valueToString 后 "," join
- * - object → JSON.stringify（fallback 到 String()）
+ * - Array / object → 紧凑 JSON（与 serde_json 输出一致）
  * - string / 其他 → String()
  */
 export declare function valueToString(v: unknown): string;
+/**
+ * 结构相等 —— 与 Rust `serde_json::Value` 的 `==` 对齐，不做类型转换。
+ */
+export declare function valuesEqual(a: unknown, b: unknown): boolean;

package/dist/runtime/value.js

@@ -26,14 +26,13 @@ export function isTruthy(v) {
     return true;
 }
 /**
- * 将任意 JS 值渲染为字符串。与 Rust 渲染器的 debug-print 语义对齐：
+ * 将任意 JS 值渲染为字符串。与 Rust `value_to_string` 对齐：
  *
  * - null / undefined → ""
  * - boolean → "true" / "false"
  * - number → String()（NaN / Infinity 保持原样）
  * - Date → toISOString()
- * - Array → 递归 valueToString 后 "," join
- * - object → JSON.stringify（fallback 到 String()）
+ * - Array / object → 紧凑 JSON（与 serde_json 输出一致）
  * - string / 其他 → String()
  */
 export function valueToString(v) {
@@ -46,9 +45,7 @@ export function valueToString(v) {
     }
     if (v instanceof Date)
         return v.toISOString();
-    if (Array.isArray(v))
-        return v.map(valueToString).join(",");
-    if (typeof v === "object") {
+    if (Array.isArray(v) || typeof v === "object") {
         try {
             return JSON.stringify(v);
         }
@@ -58,3 +55,27 @@ export function valueToString(v) {
     }
     return String(v);
 }
+/**
+ * 结构相等 —— 与 Rust `serde_json::Value` 的 `==` 对齐，不做类型转换。
+ */
+export function valuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null || a === undefined || b === undefined)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => valuesEqual(v, b[i]));
+    }
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (typeof a === "object" && typeof b === "object") {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        if (ka.some((k) => !Object.prototype.hasOwnProperty.call(b, k)))
+            return false;
+        return ka.every((k) => valuesEqual(a[k], b[k]));
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doki-land/dejavu-engine",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "Dejavu pure TypeScript AOT runtime — generated template modules depend on this package",
   "type": "module",
   "license": "MPL-2.0",