@dabble/patches 0.4.5 → 0.4.6

package/dist/json-patch/JSONPatch.js

@@ -1,3 +1,4 @@
+import "../chunk-IZ2YBCUP.js";
 /*!
  * Based on work from
  * https://github.com/mohayonao/json-touch-patch
@@ -10,189 +11,180 @@
  * WARNING: using /array/- syntax to indicate the end of the array makes it impossible to transform arrays correctly in
  * all situaions. Please avoid using this syntax when using Operational Transformations.
  */
-import { Delta } from '@dabble/delta';
-import { applyPatch } from './applyPatch.js';
-import { composePatch } from './composePatch.js';
-import { invertPatch } from './invertPatch.js';
-import { bitmask } from './ops/bitmask.js';
-import { transformPatch } from './transformPatch.js';
-/**
- * A JSONPatch helps with creating and applying one or more "JSON patches". It can track one or more changes
- * together which may form a single operation or transaction.
- */
-export class JSONPatch {
-    ops;
-    custom;
-    /**
-     * Create a new JSONPatch, optionally with an existing array of operations.
-     */
-    constructor(ops = [], custom = {}) {
-        this.ops = ops;
-        this.custom = custom;
-    }
-    op(op, path, value, from, soft) {
-        path = checkPath(path);
-        if (from !== undefined) {
-            from = checkPath(from);
-        }
-        const patchOp = (from ? { op, from, path } : { op, path });
-        if (value !== undefined)
-            patchOp.value = value;
-        if (soft)
-            patchOp.soft = soft;
-        this.ops.push(patchOp);
-        return this;
-    }
-    /**
-     * Tests a value exists. If it doesn't, the patch is not applied.
-     */
-    test(path, value) {
-        return this.op('test', path, value);
-    }
-    /**
-     * Adds the value to an object or array, inserted before the given index.
-     */
-    add(path, value, options) {
-        if (value && value.toJSON)
-            value = value.toJSON();
-        return this.op('add', path, value, undefined, options?.soft);
-    }
-    /**
-     * Deletes the value at the given path or removes it from an array.
-     */
-    remove(path) {
-        return this.op('remove', path);
-    }
-    /**
-     * Replaces a value (same as remove+add).
-     */
-    replace(path, value, options) {
-        if (value && value.toJSON)
-            value = value.toJSON();
-        return this.op('replace', path, value, undefined, options?.soft);
-    }
-    /**
-     * Copies the value at `from` to `path`.
-     */
-    copy(from, to, options) {
-        return this.op('copy', to, undefined, from, options?.soft);
-    }
-    /**
-     * Moves the value at `from` to `path`.
-     */
-    move(from, to) {
-        if (from === to)
-            return this;
-        return this.op('move', to, undefined, from);
-    }
-    /**
-     * Increments a numeric value by 1 or the given amount.
-     */
-    increment(path, value = 1) {
-        return this.op('@inc', path, value);
-    }
-    /**
-     * Decrements a numeric value by 1 or the given amount.
-     */
-    decrement(path, value = 1) {
-        return this.op('@inc', path, -value);
-    }
-    /**
-     * Flips a bit at the given index in a bitmask to the given value.
-     */
-    bit(path, index, on) {
-        return this.op('@bit', path, bitmask(index, on));
-    }
-    /**
-     * Applies a delta to a text document.
-     */
-    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);
-    }
-    /**
-     * Creates a patch from an object partial, updating each field. Set a field to undefined to delete it.
-     */
-    addUpdates(updates, path = '/') {
-        path = checkPath(path);
-        if (path[path.length - 1] !== '/')
-            path += '/';
-        Object.keys(updates).forEach(key => {
-            const value = updates[key];
-            if (value == undefined) {
-                this.remove(path + key);
-            }
-            else {
-                this.replace(path + key, value);
-            }
-        });
-        return this;
-    }
-    /**
-     * Apply this patch to an object, returning a new object with the applied changes (or the same object if nothing
-     * changed in the patch). Optionally apply the page at the given path prefix.
-     */
-    apply(obj, options) {
-        return applyPatch(obj, this.ops, options, this.custom);
-    }
-    /**
-     * Transform the given patch against this one. This patch is considered to have happened first. Optionally provide
-     * the object these operations are being applied to if available to know for sure if a numerical path is an array
-     * index or object key. Otherwise, all numerical paths are treated as array indexes.
-     */
-    transform(patch, obj) {
-        const JSONPatch = this.constructor;
-        return new JSONPatch(transformPatch(obj, this.ops, Array.isArray(patch) ? patch : patch.ops, this.custom), this.custom);
-    }
-    /**
-     * Create a patch which can reverse what this patch does. Because JSON Patches do not store previous values, you
-     * must provide the previous object to create a reverse patch.
-     */
-    invert(obj) {
-        const JSONPatch = this.constructor;
-        return new JSONPatch(invertPatch(obj, this.ops, this.custom), this.custom);
-    }
-    /**
-     * Compose/collapse patches into fewer operations.
-     */
-    compose(patch) {
-        const JSONPatch = this.constructor;
-        let ops = this.ops;
-        if (patch)
-            ops = ops.concat(Array.isArray(patch) ? patch : patch.ops);
-        return new JSONPatch(composePatch(ops), this.custom);
-    }
-    /**
-     * Add two patches together.
-     */
-    concat(patch) {
-        const JSONPatch = this.constructor;
-        return new JSONPatch(this.ops.concat(Array.isArray(patch) ? patch : patch.ops), this.custom);
-    }
-    /**
-     * Returns an array of patch operations.
-     */
-    toJSON() {
-        return this.ops.slice();
-    }
-    /**
-     * Create a new JSONPatch with the provided JSON patch operations.
-     */
-    static fromJSON(ops, types) {
-        return new this(ops, types);
-    }
+import { Delta } from "@dabble/delta";
+import { applyPatch } from "./applyPatch.js";
+import { composePatch } from "./composePatch.js";
+import { invertPatch } from "./invertPatch.js";
+import { bitmask } from "./ops/bitmask.js";
+import { transformPatch } from "./transformPatch.js";
+class JSONPatch {
+  ops;
+  custom;
+  /**
+   * Create a new JSONPatch, optionally with an existing array of operations.
+   */
+  constructor(ops = [], custom = {}) {
+    this.ops = ops;
+    this.custom = custom;
+  }
+  op(op, path, value, from, soft) {
+    path = checkPath(path);
+    if (from !== void 0) {
+      from = checkPath(from);
+    }
+    const patchOp = from ? { op, from, path } : { op, path };
+    if (value !== void 0) patchOp.value = value;
+    if (soft) patchOp.soft = soft;
+    this.ops.push(patchOp);
+    return this;
+  }
+  /**
+   * Tests a value exists. If it doesn't, the patch is not applied.
+   */
+  test(path, value) {
+    return this.op("test", path, value);
+  }
+  /**
+   * Adds the value to an object or array, inserted before the given index.
+   */
+  add(path, value, options) {
+    if (value && value.toJSON) value = value.toJSON();
+    return this.op("add", path, value, void 0, options?.soft);
+  }
+  /**
+   * Deletes the value at the given path or removes it from an array.
+   */
+  remove(path) {
+    return this.op("remove", path);
+  }
+  /**
+   * Replaces a value (same as remove+add).
+   */
+  replace(path, value, options) {
+    if (value && value.toJSON) value = value.toJSON();
+    return this.op("replace", path, value, void 0, options?.soft);
+  }
+  /**
+   * Copies the value at `from` to `path`.
+   */
+  copy(from, to, options) {
+    return this.op("copy", to, void 0, from, options?.soft);
+  }
+  /**
+   * Moves the value at `from` to `path`.
+   */
+  move(from, to) {
+    if (from === to) return this;
+    return this.op("move", to, void 0, from);
+  }
+  /**
+   * Increments a numeric value by 1 or the given amount.
+   */
+  increment(path, value = 1) {
+    return this.op("@inc", path, value);
+  }
+  /**
+   * Decrements a numeric value by 1 or the given amount.
+   */
+  decrement(path, value = 1) {
+    return this.op("@inc", path, -value);
+  }
+  /**
+   * Flips a bit at the given index in a bitmask to the given value.
+   */
+  bit(path, index, on) {
+    return this.op("@bit", path, bitmask(index, on));
+  }
+  /**
+   * Applies a delta to a text document.
+   */
+  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);
+  }
+  /**
+   * Creates a patch from an object partial, updating each field. Set a field to undefined to delete it.
+   */
+  addUpdates(updates, path = "/") {
+    path = checkPath(path);
+    if (path[path.length - 1] !== "/") path += "/";
+    Object.keys(updates).forEach((key) => {
+      const value = updates[key];
+      if (value == void 0) {
+        this.remove(path + key);
+      } else {
+        this.replace(path + key, value);
+      }
+    });
+    return this;
+  }
+  /**
+   * Apply this patch to an object, returning a new object with the applied changes (or the same object if nothing
+   * changed in the patch). Optionally apply the page at the given path prefix.
+   */
+  apply(obj, options) {
+    return applyPatch(obj, this.ops, options, this.custom);
+  }
+  /**
+   * Transform the given patch against this one. This patch is considered to have happened first. Optionally provide
+   * the object these operations are being applied to if available to know for sure if a numerical path is an array
+   * index or object key. Otherwise, all numerical paths are treated as array indexes.
+   */
+  transform(patch, obj) {
+    const JSONPatch2 = this.constructor;
+    return new JSONPatch2(
+      transformPatch(obj, this.ops, Array.isArray(patch) ? patch : patch.ops, this.custom),
+      this.custom
+    );
+  }
+  /**
+   * Create a patch which can reverse what this patch does. Because JSON Patches do not store previous values, you
+   * must provide the previous object to create a reverse patch.
+   */
+  invert(obj) {
+    const JSONPatch2 = this.constructor;
+    return new JSONPatch2(invertPatch(obj, this.ops, this.custom), this.custom);
+  }
+  /**
+   * Compose/collapse patches into fewer operations.
+   */
+  compose(patch) {
+    const JSONPatch2 = this.constructor;
+    let ops = this.ops;
+    if (patch) ops = ops.concat(Array.isArray(patch) ? patch : patch.ops);
+    return new JSONPatch2(composePatch(ops), this.custom);
+  }
+  /**
+   * Add two patches together.
+   */
+  concat(patch) {
+    const JSONPatch2 = this.constructor;
+    return new JSONPatch2(this.ops.concat(Array.isArray(patch) ? patch : patch.ops), this.custom);
+  }
+  /**
+   * Returns an array of patch operations.
+   */
+  toJSON() {
+    return this.ops.slice();
+  }
+  /**
+   * Create a new JSONPatch with the provided JSON patch operations.
+   */
+  static fromJSON(ops, types) {
+    return new this(ops, types);
+  }
 }
 function checkPath(path) {
-    path = path.toString();
-    if (path.length && path[0] !== '/')
-        path = `/${path}`;
-    return path;
+  path = path.toString();
+  if (path.length && path[0] !== "/") path = `/${path}`;
+  return path;
 }
+export {
+  JSONPatch
+};

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

@@ -1,4 +1,5 @@
-import type { ApplyJSONPatchOptions, JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+import { JSONPatchOp, ApplyJSONPatchOptions, JSONPatchOpHandlerMap } from './types.js';
+
 /**
  * Applies a sequence of JSON patch operations to an object.
  *
@@ -8,4 +9,6 @@ import type { ApplyJSONPatchOptions, JSONPatchOp, JSONPatchOpHandlerMap } from '
  * @param custom - Custom patch operation handlers
  * @returns The object after applying the patches
  */
-export declare function applyPatch(object: any, patches: JSONPatchOp[], opts?: ApplyJSONPatchOptions, custom?: JSONPatchOpHandlerMap): any;
+declare function applyPatch(object: any, patches: JSONPatchOp[], opts?: ApplyJSONPatchOptions, custom?: JSONPatchOpHandlerMap): any;
+
+export { applyPatch };

package/dist/json-patch/applyPatch.js

@@ -1,37 +1,29 @@
-import { getTypes } from './ops/index.js';
-import { runWithObject } from './state.js';
-import { exit } from './utils/exit.js';
-import { getType } from './utils/getType.js';
-/**
- * Applies a sequence of JSON patch operations to an object.
- *
- * @param object - The object to apply the patches to
- * @param patches - The JSON patch operations to apply
- * @param opts - Options for applying the patch
- * @param custom - Custom patch operation handlers
- * @returns The object after applying the patches
- */
-export function applyPatch(object, patches, opts = {}, custom) {
-    if (patches.length === 0) {
-        return object;
+import "../chunk-IZ2YBCUP.js";
+import { getTypes } from "./ops/index.js";
+import { runWithObject } from "./state.js";
+import { exit } from "./utils/exit.js";
+import { getType } from "./utils/getType.js";
+function applyPatch(object, patches, opts = {}, custom) {
+  if (patches.length === 0) {
+    return object;
+  }
+  if (opts.atPath) {
+    patches = patches.map((op) => ({ ...op, path: opts.atPath + op.path }));
+  }
+  const types = getTypes(custom);
+  return runWithObject(object, types, patches.length > 1, (state) => {
+    for (let i = 0, imax = patches.length; i < imax; i++) {
+      const patch = patches[i];
+      const handler = getType(state, patch)?.apply;
+      const error = handler ? handler(state, "" + patch.path, patch.from || patch.value) : `[op:${patch.op}] unknown`;
+      if (error) {
+        if (!opts.silent && !opts.strict || opts.silent === false) console.error(error, patch);
+        if (opts.strict) throw new TypeError(error);
+        if (opts.rigid) return exit(state, object, patch, opts);
+      }
     }
-    if (opts.atPath) {
-        patches = patches.map(op => ({ ...op, path: opts.atPath + op.path }));
-    }
-    const types = getTypes(custom);
-    return runWithObject(object, types, patches.length > 1, state => {
-        for (let i = 0, imax = patches.length; i < imax; i++) {
-            const patch = patches[i];
-            const handler = getType(state, patch)?.apply;
-            const error = handler ? handler(state, '' + patch.path, patch.from || patch.value) : `[op:${patch.op}] unknown`;
-            if (error) {
-                if ((!opts.silent && !opts.strict) || opts.silent === false)
-                    console.error(error, patch);
-                if (opts.strict)
-                    throw new TypeError(error);
-                if (opts.rigid)
-                    return exit(state, object, patch, opts);
-            }
-        }
-    });
+  });
 }
+export {
+  applyPatch
+};

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

@@ -1,2 +1,5 @@
-import type { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
-export declare function composePatch(patches: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];
+import { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+
+declare function composePatch(patches: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];
+
+export { composePatch };

package/dist/json-patch/composePatch.js

@@ -1,38 +1,38 @@
-import { getTypes } from './ops/index.js';
-import { runWithObject } from './state.js';
-import { getType } from './utils/getType.js';
-import { mapAndFilterOps } from './utils/ops.js';
-import { getValue } from './utils/pluck.js';
-export function composePatch(patches, custom = {}) {
-    const types = getTypes(custom);
-    const opsByPath = new Map();
-    // Only composing ops next to each other on the same path. It becomes too complex to do more because of moves and arrays
-    return runWithObject(null, types, patches.length > 1, state => {
-        return mapAndFilterOps(patches, op => {
-            const type = getType(state, op);
-            const handler = type?.compose;
-            if (handler) {
-                const lastOp = opsByPath.get(op.path);
-                if (lastOp && match(lastOp, op)) {
-                    lastOp.value = handler(state, lastOp.value, op.value);
-                    return null;
-                }
-                else {
-                    const prefix = `${op.path}/`;
-                    for (const path of opsByPath.keys()) {
-                        if (path.startsWith(prefix))
-                            opsByPath.delete(path);
-                    }
-                    opsByPath.set(op.path, (op = getValue(state, op)));
-                }
-            }
-            else {
-                opsByPath.clear();
-            }
-            return op;
-        });
+import "../chunk-IZ2YBCUP.js";
+import { getTypes } from "./ops/index.js";
+import { runWithObject } from "./state.js";
+import { getType } from "./utils/getType.js";
+import { mapAndFilterOps } from "./utils/ops.js";
+import { getValue } from "./utils/pluck.js";
+function composePatch(patches, custom = {}) {
+  const types = getTypes(custom);
+  const opsByPath = /* @__PURE__ */ new Map();
+  return runWithObject(null, types, patches.length > 1, (state) => {
+    return mapAndFilterOps(patches, (op) => {
+      const type = getType(state, op);
+      const handler = type?.compose;
+      if (handler) {
+        const lastOp = opsByPath.get(op.path);
+        if (lastOp && match(lastOp, op)) {
+          lastOp.value = handler(state, lastOp.value, op.value);
+          return null;
+        } else {
+          const prefix = `${op.path}/`;
+          for (const path of opsByPath.keys()) {
+            if (path.startsWith(prefix)) opsByPath.delete(path);
+          }
+          opsByPath.set(op.path, op = getValue(state, op));
+        }
+      } else {
+        opsByPath.clear();
+      }
+      return op;
     });
+  });
 }
 function match(op1, op2) {
-    return op1 && op2 && op1.op === op2.op && op1.path === op2.path;
+  return op1 && op2 && op1.op === op2.op && op1.path === op2.path;
 }
+export {
+  composePatch
+};

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

@@ -1,5 +1,8 @@
-import type { ChangeMutator } from '../types.js';
+import { ChangeMutator } from '../types.js';
 import { JSONPatch } from './JSONPatch.js';
+import './types.js';
+import '@dabble/delta';
+
 /**
  * Creates a `JSONPatch` instance using a path-only proxy for type-safe operation generation.
  *
@@ -30,4 +33,6 @@ import { JSONPatch } from './JSONPatch.js';
  * // ]
  * ```
  */
-export declare function createJSONPatch<T>(mutator: ChangeMutator<T>): JSONPatch;
+declare function createJSONPatch<T>(mutator: ChangeMutator<T>): JSONPatch;
+
+export { createJSONPatch };

package/dist/json-patch/createJSONPatch.js

@@ -1,39 +1,12 @@
-import { JSONPatch } from './JSONPatch.js';
-import { createPathProxy } from './pathProxy.js';
-/**
- * Creates a `JSONPatch` instance using a path-only proxy for type-safe operation generation.
- *
- * The mutator function receives a JSONPatch instance and a PathProxy for creating
- * type-safe JSON Pointer paths. All modifications must be done through explicit
- * JSONPatch methods - the path proxy will throw errors if mutation is attempted.
- *
- * @template T The type of the target object.
- * @param target The initial state of the object (used for type inference only).
- * @param mutator A function that receives a JSONPatch instance and a PathProxy.
- * @returns A `JSONPatch` instance containing the operations generated within the mutator.
- *
- * @example
- * ```ts
- * const myObj = { name: { first: 'Alice' }, age: 30, tags: ['a'] };
- *
- * const patch = createJSONPatch(myObj, (patch, path) => {
- *   patch.replace(path.name.first, 'Bob');  // Type-safe path creation
- *   patch.increment(path.age, 1);           // Explicit operations only
- *   patch.add(path.tags[1], 'b');           // Array path handling
- * });
- *
- * console.log(patch.ops);
- * // [
- * //   { op: 'replace', path: '/name/first', value: 'Bob' },
- * //   { op: 'increment', path: '/age', value: 1 },
- * //   { op: 'add', path: '/tags/1', value: 'b' }
- * // ]
- * ```
- */
-export function createJSONPatch(mutator) {
-    const patch = new JSONPatch();
-    // Create path-only proxy for type-safe path generation
-    const pathProxy = createPathProxy();
-    mutator(patch, pathProxy);
-    return patch;
+import "../chunk-IZ2YBCUP.js";
+import { JSONPatch } from "./JSONPatch.js";
+import { createPathProxy } from "./pathProxy.js";
+function createJSONPatch(mutator) {
+  const patch = new JSONPatch();
+  const pathProxy = createPathProxy();
+  mutator(patch, pathProxy);
+  return patch;
 }
+export {
+  createJSONPatch
+};

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

@@ -1,10 +1,18 @@
 export { applyPatch } from './applyPatch.js';
 export { composePatch } from './composePatch.js';
 export { invertPatch } from './invertPatch.js';
-export { applyBitmask, bitmask, combineBitmasks } from './ops/bitmask.js';
-export * as defaultOps from './ops/index.js';
-export * from './pathProxy.js';
+export { applyBitmask, bit, bitmask, combineBitmasks } from './ops/bitmask.js';
+export { i as defaultOps, g as getTypes } from '../index-CvQws3AB.js';
+export { createPathProxy, pathProxy } from './pathProxy.js';
 export { transformPatch } from './transformPatch.js';
-export * from './JSONPatch.js';
-export * from './ops/index.js';
-export type { ApplyJSONPatchOptions, JSONPatchOpHandlerMap as JSONPatchCustomTypes, JSONPatchOp } from './types.js';
+export { JSONPatch, PathLike, WriteOptions } from './JSONPatch.js';
+export { ApplyJSONPatchOptions, JSONPatchOpHandlerMap as JSONPatchCustomTypes, JSONPatchOp } from './types.js';
+export { add } from './ops/add.js';
+export { copy } from './ops/copy.js';
+export { increment } from './ops/increment.js';
+export { move } from './ops/move.js';
+export { remove } from './ops/remove.js';
+export { replace } from './ops/replace.js';
+export { test } from './ops/test.js';
+import '../types.js';
+import '@dabble/delta';