state-sync-log 0.9.0 → 0.10.0

package/src/operations.ts

@@ -1,14 +1,14 @@
 import { failure } from "./error"
 import { JSONObject, JSONValue, Path } from "./json"
-import { deepClone, deepEqual, isObject } from "./utils"
+import { deepClone, deepEqual, isObject, parseArrayIndex } from "./utils"
 
 /**
  * Supported operations.
  * Applied sequentially within a tx.
  */
 export type Op =
-  | { kind: "set"; path: Path; key: string; value: JSONValue }
-  | { kind: "delete"; path: Path; key: string }
+  | { kind: "set"; path: Path; key: string | number; value: JSONValue }
+  | { kind: "delete"; path: Path; key: string | number }
   | { kind: "splice"; path: Path; index: number; deleteCount: number; inserts: JSONValue[] }
   | { kind: "addToSet"; path: Path; value: JSONValue }
   | { kind: "deleteFromSet"; path: Path; value: JSONValue }
@@ -72,21 +72,43 @@ function applyOp(state: JSONObject, op: Op, cloneValues: boolean): void {
   const container = resolvePath(state, op.path)
 
   switch (op.kind) {
-    case "set":
-      if (!isObject(container) || Array.isArray(container)) {
-        failure("set requires object container")
+    case "set": {
+      // Allow object or array container
+      if (!isObject(container)) {
+        failure("set requires object or array container")
+      }
+      let key: string | number = op.key
+      // For arrays, convert string keys to numbers (except "length")
+      if (Array.isArray(container) && typeof key === "string" && key !== "length") {
+        const numKey = parseArrayIndex(key)
+        if (numKey === null) {
+          failure(`Cannot set non-numeric property "${key}" on array`)
+        }
+        key = numKey
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ;(container as any)[op.key] = cloneValues ? deepClone(op.value) : op.value
+      ;(container as any)[key] = cloneValues ? deepClone(op.value) : op.value
       break
+    }
 
-    case "delete":
-      if (!isObject(container) || Array.isArray(container)) {
-        failure("delete requires object container")
+    case "delete": {
+      // Allow object or array (sparse delete?)
+      if (!isObject(container)) {
+        failure("delete requires object or array container")
+      }
+      let key: string | number = op.key
+      // For arrays, convert string keys to numbers
+      if (Array.isArray(container) && typeof key === "string") {
+        const numKey = parseArrayIndex(key)
+        if (numKey === null) {
+          failure(`Cannot delete non-numeric property "${key}" from array`)
+        }
+        key = numKey
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      delete (container as any)[op.key]
+      delete (container as any)[key]
       break
+    }
 
     case "splice": {
       if (!Array.isArray(container)) {

package/src/utils.ts

@@ -1,55 +1,67 @@
-import equal from "fast-deep-equal"
-import { nanoid } from "nanoid"
-import rfdc from "rfdc"
-import type { JSONValue } from "./json"
-
-const clone = rfdc({ proto: true })
-
-/**
- * Deep equality check for JSONValues.
- * Used for addToSet / deleteFromSet operations.
- */
-export function deepEqual(a: JSONValue, b: JSONValue): boolean {
-  return equal(a, b)
-}
-
-/**
- * Generates a unique ID using nanoid.
- */
-export function generateID(): string {
-  return nanoid()
-}
-
-/**
- * Checks if a value is an object (typeof === "object" && !== null).
- */
-export function isObject(value: unknown): value is object {
-  return value !== null && typeof value === "object"
-}
-
-/**
- * Deep clones a JSON-serializable value.
- * Optimized: primitives are returned as-is.
- */
-export function deepClone<T>(value: T): T {
-  // Primitives don't need cloning
-  if (value === null || typeof value !== "object") {
-    return value
-  }
-  return clone(value)
-}
-
-/**
- * Creates a lazy memoized getter.
- */
-export function lazy<T>(fn: () => T): () => T {
-  let computed = false
-  let value: T
-  return () => {
-    if (!computed) {
-      value = fn()
-      computed = true
-    }
-    return value
-  }
-}
+import equal from "fast-deep-equal"
+import { nanoid } from "nanoid"
+import rfdc from "rfdc"
+import type { JSONValue } from "./json"
+
+const clone = rfdc({ proto: true })
+
+/**
+ * Deep equality check for JSONValues.
+ * Used for addToSet / deleteFromSet operations.
+ */
+export function deepEqual(a: JSONValue, b: JSONValue): boolean {
+  return equal(a, b)
+}
+
+/**
+ * Generates a unique ID using nanoid.
+ */
+export function generateID(): string {
+  return nanoid()
+}
+
+/**
+ * Checks if a value is an object (typeof === "object" && !== null).
+ */
+export function isObject(value: unknown): value is object {
+  return value !== null && typeof value === "object"
+}
+
+/**
+ * Deep clones a JSON-serializable value.
+ * Optimized: primitives are returned as-is.
+ */
+export function deepClone<T>(value: T): T {
+  // Primitives don't need cloning
+  if (value === null || typeof value !== "object") {
+    return value
+  }
+  return clone(value)
+}
+
+/**
+ * Creates a lazy memoized getter.
+ */
+export function lazy<T>(fn: () => T): () => T {
+  let computed = false
+  let value: T
+  return () => {
+    if (!computed) {
+      value = fn()
+      computed = true
+    }
+    return value
+  }
+}
+
+/**
+ * Checks if a string is a valid non-negative integer array index.
+ * Returns the numeric value if valid, or null if invalid.
+ */
+export function parseArrayIndex(key: string): number | null {
+  const n = Number(key)
+  if (!Number.isInteger(n) || n < 0) {
+    return null
+  }
+  return n
+}