@dabble/patches 0.9.5 → 0.9.6

package/dist/json-patch/JSONPatch.d.ts

@@ -86,6 +86,9 @@ declare class JSONPatch {
     bit(path: PathLike, index: number, on: boolean): this;
     /**
      * Applies a delta to a text document.
+     *
+     * `value` is stored as a bare `Op[]` array (the canonical `@txt` shape).
+     * Accepts a `Delta` instance, a serialized `{ ops }` form, or the array directly.
      */
     text(path: PathLike, value: Delta | Delta['ops']): this;
     /**

package/dist/json-patch/JSONPatch.js

@@ -22,6 +22,7 @@ import { applyPatch } from "./applyPatch.js";
 import { composePatch } from "./composePatch.js";
 import { invertPatch } from "./invertPatch.js";
 import { bitmask } from "./ops/bitmask.js";
+import { toOps } from "./ops/text.js";
 import { transformPatch } from "./transformPatch.js";
 class JSONPatch {
   ops;
@@ -120,16 +121,14 @@ class JSONPatch {
   }
   /**
    * Applies a delta to a text document.
+   *
+   * `value` is stored as a bare `Op[]` array (the canonical `@txt` shape).
+   * Accepts a `Delta` instance, a serialized `{ ops }` form, or the array directly.
    */
   text(path, value) {
-    if (Array.isArray(value)) {
-      value = new Delta(value);
-    } else if (!(value instanceof Delta) && Array.isArray(value?.ops)) {
-      value = new Delta(value.ops);
-    } else if (!(value instanceof Delta)) {
-      throw new Error("Invalid Delta");
-    }
-    return this.op("@txt", path, value);
+    const ops = toOps(value);
+    if (!ops) throw new Error("Invalid Delta");
+    return this.op("@txt", path, ops);
   }
   /**
    * Creates a patch from an object partial, updating each field. Set a field to undefined to delete it.

package/dist/json-patch/ops/text.d.ts

@@ -1,5 +1,15 @@
+import { Op } from '@dabble/delta';
 import { JSONPatchOpHandler } from '../types.js';
 
+/**
+ * Normalize a `@txt` op's `value` to a bare `Op[]` array.
+ *
+ * The canonical form is an array of Delta ops, but historically `JSONPatch.text()`,
+ * `text.compose()`, and `text.invert()` produced `Delta` instances. Those serialize
+ * via `JSON.stringify` to `{ ops: [...] }`, so any rehydrated op may land in either
+ * shape. Accept all three; return `null` if the input isn't a recognizable Delta.
+ */
+declare function toOps(value: unknown): Op[] | null;
 declare const text: JSONPatchOpHandler;
 
-export { text };
+export { text, toOps };

package/dist/json-patch/ops/text.js

@@ -4,13 +4,21 @@ import { replace } from "../ops/replace.js";
 import { get } from "../utils/get.js";
 import { log } from "../utils/log.js";
 import { updateRemovedOps } from "../utils/ops.js";
+function toOps(value) {
+  if (Array.isArray(value)) return value;
+  if (value && typeof value === "object" && Array.isArray(value.ops)) {
+    return value.ops;
+  }
+  return null;
+}
 const text = {
   like: "replace",
   apply(state, path, value) {
-    const delta = Array.isArray(value) ? new Delta(value) : value;
-    if (!delta || !Array.isArray(delta.ops)) {
+    const ops = toOps(value);
+    if (!ops) {
       return "Invalid delta";
     }
+    const delta = new Delta(ops);
     const existingData = get(state, path);
     let doc;
     if (Array.isArray(existingData)) {
@@ -29,22 +37,24 @@ const text = {
   },
   transform(state, thisOp, otherOps) {
     log("Transforming ", otherOps, ' against "@txt"', thisOp);
+    const thisOps = toOps(thisOp.value);
     return updateRemovedOps(state, thisOp.path, otherOps, false, true, thisOp.op, (op) => {
       if (op.path !== thisOp.path) return null;
-      if (!op.value || !Array.isArray(op.value)) return null;
-      const thisDelta = new Delta(thisOp.value);
-      let otherDelta = new Delta(op.value);
+      const otherOpsArr = toOps(op.value);
+      if (!thisOps || !otherOpsArr) return null;
+      const thisDelta = new Delta(thisOps);
+      let otherDelta = new Delta(otherOpsArr);
       otherDelta = thisDelta.transform(otherDelta, true);
       return { ...op, value: otherDelta.ops };
     });
   },
   invert(state, { path, value }, oldValue, changedObj) {
     if (path.endsWith("/-")) path = path.replace("-", changedObj.length);
-    const delta = new Delta(value);
-    return oldValue === void 0 ? { op: "remove", path } : { op: "@txt", path, value: delta.invert(oldValue) };
+    const delta = new Delta(toOps(value) ?? []);
+    return oldValue === void 0 ? { op: "remove", path } : { op: "@txt", path, value: delta.invert(oldValue).ops };
   },
   compose(state, delta1, delta2) {
-    return new Delta(delta1).compose(new Delta(delta2));
+    return new Delta(toOps(delta1) ?? []).compose(new Delta(toOps(delta2) ?? [])).ops;
   }
 };
 function fixBadDeltaDoc(delta) {
@@ -72,5 +82,6 @@ function fixBadDeltaDoc(delta) {
   return newDelta;
 }
 export {
-  text
+  text,
+  toOps
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {