@mandujs/core 0.54.18 → 0.54.19

package/src/client/__tests__/props-serialization.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "bun:test";
+import { deserializeProps, serializeProps } from "../props-serialization";
+
+describe("props serialization", () => {
+  it("roundtrips complex browser hydration props through the shared deserializer", () => {
+    const input = {
+      date: new Date("2026-05-23T00:00:00.000Z"),
+      map: new Map<unknown, unknown>([
+        ["count", 3],
+        ["nested", { ok: true }],
+      ]),
+      set: new Set<unknown>(["a", "b"]),
+      url: new URL("https://mandu.dev/docs?phase=4"),
+      missing: undefined,
+      nested: {
+        list: [1, undefined, { value: "x" }],
+      },
+    };
+
+    const output = deserializeProps(serializeProps(input));
+
+    expect(output.date).toBeInstanceOf(Date);
+    expect((output.date as Date).toISOString()).toBe("2026-05-23T00:00:00.000Z");
+    expect(output.map).toBeInstanceOf(Map);
+    expect((output.map as Map<unknown, unknown>).get("count")).toBe(3);
+    expect((output.map as Map<unknown, unknown>).get("nested")).toEqual({ ok: true });
+    expect(output.set).toBeInstanceOf(Set);
+    expect(Array.from(output.set as Set<unknown>)).toEqual(["a", "b"]);
+    expect(output.url).toBeInstanceOf(URL);
+    expect((output.url as URL).href).toBe("https://mandu.dev/docs?phase=4");
+    expect(Object.prototype.hasOwnProperty.call(output, "missing")).toBe(true);
+    expect(output.missing).toBeUndefined();
+    expect(output.nested).toEqual({
+      list: [1, undefined, { value: "x" }],
+    });
+  });
+});

package/src/client/hydrate.ts

@@ -16,8 +16,8 @@
  *   2. Unit tests can import it under happy-dom/JSDOM without triggering
  *      global mutation (no `document.querySelectorAll` on module eval).
  *
- * The bundler-generated runtime (`bundler/build.ts::generateRuntimeSource`)
- * delegates strategy selection to `scheduleHydration()` here — SSR emits the
+ * The bundled runtime entry (`client/runtime-entry.ts`)
+ * delegates strategy selection to `scheduleHydration()` here — SSR emits the
  * `data-hydrate` attribute, the runtime reads it and dispatches.
  *
  * Design contract:

package/src/client/index.ts

@@ -168,7 +168,7 @@ import { Link, NavLink } from "./Link";
 
 /**
  * Mandu Client namespace
- * v0.8.0: Hydration is handled automatically (generateRuntimeSource)
+ * v0.8.0: Hydration is handled automatically (runtime-entry)
  * Note: Use `ManduClient` to avoid conflict with other Mandu exports
  */
 export const ManduClient = {

package/src/client/props-serialization.ts

@@ -0,0 +1,233 @@
+/**
+ * Browser-safe Mandu props serialization.
+ *
+ * This module intentionally has no DOM, Bun, or Node imports. Runtime entry
+ * code may read from the document, but serialization semantics live here.
+ */
+
+const TYPE_MARKERS = {
+  UNDEFINED: "\x00_",
+  DATE: "\x00D",
+  URL: "\x00U",
+  REGEXP: "\x00R",
+  MAP: "\x00M",
+  SET: "\x00S",
+  REF: "\x00$",
+  BIGINT: "\x00B",
+  SYMBOL: "\x00Y",
+  ERROR: "\x00E",
+} as const;
+
+interface SerializeContext {
+  seen: Map<object, number>;
+  refs: object[];
+}
+
+interface DeserializeContext {
+  refs: unknown[];
+}
+
+export function serializeProps(props: Record<string, unknown>): string {
+  const ctx: SerializeContext = { seen: new Map(), refs: [] };
+  return JSON.stringify(serialize(props, ctx));
+}
+
+function serialize(value: unknown, ctx: SerializeContext): unknown {
+  if (value === null) return null;
+  if (value === undefined) return TYPE_MARKERS.UNDEFINED;
+
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+
+  if (typeof value === "string") {
+    return value.startsWith("\x00") ? "\x00\x00" + value : value;
+  }
+
+  if (typeof value === "bigint") {
+    return TYPE_MARKERS.BIGINT + value.toString();
+  }
+
+  if (typeof value === "symbol") {
+    return TYPE_MARKERS.SYMBOL + (value.description ?? "");
+  }
+
+  if (typeof value === "function") {
+    console.warn("[Mandu Serialize] Functions cannot be serialized, skipping");
+    return undefined;
+  }
+
+  if (typeof value === "object") {
+    const existing = ctx.seen.get(value);
+    if (existing !== undefined) {
+      return TYPE_MARKERS.REF + existing;
+    }
+
+    const idx = ctx.refs.length;
+    ctx.seen.set(value, idx);
+    ctx.refs.push(value);
+  }
+
+  if (value instanceof Date) {
+    return TYPE_MARKERS.DATE + value.toISOString();
+  }
+
+  if (value instanceof URL) {
+    return TYPE_MARKERS.URL + value.href;
+  }
+
+  if (value instanceof RegExp) {
+    return TYPE_MARKERS.REGEXP + value.toString();
+  }
+
+  if (value instanceof Error) {
+    return [
+      TYPE_MARKERS.ERROR,
+      value.name,
+      value.message,
+      value.stack ?? "",
+    ];
+  }
+
+  if (value instanceof Map) {
+    const entries: [unknown, unknown][] = [];
+    for (const [key, nested] of value.entries()) {
+      entries.push([serialize(key, ctx), serialize(nested, ctx)]);
+    }
+    return [TYPE_MARKERS.MAP, ...entries];
+  }
+
+  if (value instanceof Set) {
+    const items: unknown[] = [];
+    for (const item of value) {
+      items.push(serialize(item, ctx));
+    }
+    return [TYPE_MARKERS.SET, ...items];
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => serialize(item, ctx));
+  }
+
+  const result: Record<string, unknown> = {};
+  for (const [key, nested] of Object.entries(value as object)) {
+    const serialized = serialize(nested, ctx);
+    if (serialized !== undefined) {
+      result[key] = serialized;
+    }
+  }
+  return result;
+}
+
+export function deserializeProps(json: string): Record<string, unknown> {
+  const ctx: DeserializeContext = { refs: [] };
+  const parsed = JSON.parse(json);
+  return deserialize(parsed, ctx) as Record<string, unknown>;
+}
+
+function deserialize(value: unknown, ctx: DeserializeContext): unknown {
+  if (value === null) return null;
+
+  if (typeof value === "string") {
+    if (value === TYPE_MARKERS.UNDEFINED) return undefined;
+    if (value.startsWith("\x00\x00")) return value.slice(2);
+    if (value.startsWith(TYPE_MARKERS.DATE)) return new Date(value.slice(2));
+    if (value.startsWith(TYPE_MARKERS.URL)) return new URL(value.slice(2));
+    if (value.startsWith(TYPE_MARKERS.REGEXP)) {
+      const str = value.slice(2);
+      const match = str.match(/^\/(.*)\/([gimsuy]*)$/);
+      return match ? new RegExp(match[1], match[2]) : str;
+    }
+    if (value.startsWith(TYPE_MARKERS.BIGINT)) return BigInt(value.slice(2));
+    if (value.startsWith(TYPE_MARKERS.SYMBOL)) return Symbol(value.slice(2));
+    if (value.startsWith(TYPE_MARKERS.REF)) {
+      return ctx.refs[parseInt(value.slice(2), 10)];
+    }
+    return value;
+  }
+
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    const marker = value[0];
+
+    if (marker === TYPE_MARKERS.ERROR) {
+      const [, name, message, stack] = value as [string, string, string, string];
+      const error = new Error(message);
+      error.name = name;
+      if (stack) error.stack = stack;
+      ctx.refs.push(error);
+      return error;
+    }
+
+    if (marker === TYPE_MARKERS.MAP) {
+      const map = new Map();
+      ctx.refs.push(map);
+      for (let i = 1; i < value.length; i++) {
+        const [key, nested] = value[i] as [unknown, unknown];
+        map.set(deserialize(key, ctx), deserialize(nested, ctx));
+      }
+      return map;
+    }
+
+    if (marker === TYPE_MARKERS.SET) {
+      const set = new Set();
+      ctx.refs.push(set);
+      for (let i = 1; i < value.length; i++) {
+        set.add(deserialize(value[i], ctx));
+      }
+      return set;
+    }
+
+    const arr: unknown[] = [];
+    ctx.refs.push(arr);
+    for (const item of value) {
+      arr.push(deserialize(item, ctx));
+    }
+    return arr;
+  }
+
+  if (typeof value === "object") {
+    const obj: Record<string, unknown> = {};
+    ctx.refs.push(obj);
+    for (const [key, nested] of Object.entries(value)) {
+      obj[key] = deserialize(nested, ctx);
+    }
+    return obj;
+  }
+
+  return value;
+}
+
+export function isSerializable(value: unknown): boolean {
+  if (value === null || value === undefined) return true;
+
+  const type = typeof value;
+  if (type === "boolean" || type === "number" || type === "string" || type === "bigint") {
+    return true;
+  }
+
+  if (type === "function" || type === "symbol") {
+    return false;
+  }
+
+  if (value instanceof Date || value instanceof URL || value instanceof RegExp) {
+    return true;
+  }
+
+  if (value instanceof Map || value instanceof Set) {
+    return true;
+  }
+
+  if (Array.isArray(value)) {
+    return value.every(isSerializable);
+  }
+
+  if (type === "object") {
+    return Object.values(value as object).every(isSerializable);
+  }
+
+  return false;
+}