@loro-dev/flock 4.5.0 → 4.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loro-dev/flock",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "description": "TypeScript bindings for the Flock CRDT with mergeable export/import utilities.",
   "exports": {
     ".": {

package/src/index.ts

@@ -680,6 +680,104 @@ function normalizeRawEventPayload(
 }
 
 const JSON_SERIALIZATION_ERROR = "Value is not JSON serializable";
+const JSON_SERIALIZATION_WARNING_PREFIX = "[flock] JSON value normalized:";
+
+function warnJsonNormalization(message: string): void {
+  try {
+    console.warn(`${JSON_SERIALIZATION_WARNING_PREFIX} ${message}`);
+  } catch {
+    // Ignore console failures so value normalization never becomes a write error.
+  }
+}
+
+function normalizeInvalidJsonValue(message: string): null {
+  warnJsonNormalization(message);
+  return null;
+}
+
+function normalizeJsonValue(
+  value: unknown,
+  seen: WeakSet<object>,
+  inObjectEntry = false,
+): unknown {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return normalizeInvalidJsonValue("non-finite number stored as null");
+  }
+  if (value === undefined) {
+    return inObjectEntry ? undefined : null;
+  }
+  if (typeof value === "function" || typeof value === "symbol") {
+    warnJsonNormalization(`${typeof value} value omitted`);
+    return inObjectEntry ? undefined : null;
+  }
+  if (typeof value === "bigint") {
+    if (
+      value <= BigInt(Number.MAX_SAFE_INTEGER) &&
+      value >= BigInt(Number.MIN_SAFE_INTEGER)
+    ) {
+      return Number(value);
+    }
+    return normalizeInvalidJsonValue(
+      "bigint exceeds JavaScript safe integer range and was stored as null",
+    );
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+
+  const toJson = (value as { toJSON?: unknown }).toJSON;
+  if (typeof toJson === "function") {
+    try {
+      return normalizeJsonValue(toJson.call(value), seen, inObjectEntry);
+    } catch {
+      return normalizeInvalidJsonValue("toJSON threw and value was stored as null");
+    }
+  }
+
+  if (seen.has(value)) {
+    return normalizeInvalidJsonValue("circular reference stored as null");
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result = value.map((item) => {
+      const normalized = normalizeJsonValue(item, seen);
+      return normalized === undefined ? null : normalized;
+    });
+    seen.delete(value);
+    return result;
+  }
+
+  let keys: string[];
+  try {
+    keys = Object.keys(value);
+  } catch {
+    seen.delete(value);
+    return normalizeInvalidJsonValue("object keys could not be read and value was stored as null");
+  }
+
+  const result: Record<string, unknown> = {};
+  for (const key of keys) {
+    let rawValue: unknown;
+    try {
+      rawValue = (value as Record<string, unknown>)[key];
+    } catch {
+      result[key] = normalizeInvalidJsonValue(
+        "object property could not be read and was stored as null",
+      );
+      continue;
+    }
+    const normalized = normalizeJsonValue(
+      rawValue,
+      seen,
+      true,
+    );
+    if (normalized !== undefined) {
+      result[key] = normalized;
+    }
+  }
+  seen.delete(value);
+  return result;
+}
 
 function validateJsonPart(value: unknown): unknown {
   if (typeof value === "number" && !Number.isFinite(value)) {
@@ -697,6 +795,11 @@ function validateJsonPart(value: unknown): unknown {
 }
 
 function stringifyJson(value: unknown): string {
+  const normalized = normalizeJsonValue(value, new WeakSet<object>());
+  return JSON.stringify(normalized) ?? "null";
+}
+
+function stringifyStrictJson(value: unknown): string {
   const encoded = JSON.stringify(value, (_key, part) =>
     validateJsonPart(part),
   );
@@ -717,6 +820,13 @@ function cloneJson<T>(value: T): T {
   return JSON.parse(stringifyJson(value)) as T;
 }
 
+function cloneStrictJson<T>(value: T): T {
+  if (value === undefined) {
+    return value;
+  }
+  return JSON.parse(stringifyStrictJson(value)) as T;
+}
+
 function cloneStoredJson(value: Value | undefined): Value {
   return value === undefined ? null : cloneJson(value);
 }
@@ -725,7 +835,7 @@ function cloneKey(key: KeyPart[]): KeyPart[] {
   if (!Array.isArray(key)) {
     throw new TypeError("key must be an array");
   }
-  return cloneJson(key) as KeyPart[];
+  return cloneStrictJson(key) as KeyPart[];
 }
 
 function parseKeyString(key: string): KeyPart[] {