@dabble/patches 0.4.4 → 0.4.6

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

@@ -1,57 +1,57 @@
-import { Delta } from '@dabble/delta';
-import { replace } from '../ops/replace.js';
-import { get } from '../utils/get.js';
-import { log } from '../utils/log.js';
-import { updateRemovedOps } from '../utils/ops.js';
-export const text = {
-    like: 'replace',
-    apply(state, path, value) {
-        const delta = Array.isArray(value) ? new Delta(value) : value;
-        if (!delta || !Array.isArray(delta.ops)) {
-            return 'Invalid delta';
-        }
-        const existingData = get(state, path);
-        let doc;
-        if (Array.isArray(existingData)) {
-            if (existingData.length && existingData[0].insert) {
-                doc = new Delta(existingData);
-            }
-        }
-        else if (existingData && existingData.ops) {
-            doc = new Delta(existingData.ops);
-        }
-        if (!doc) {
-            doc = new Delta().insert('\n');
-        }
-        doc = doc.compose(delta);
-        if (hasInvalidOps(doc)) {
-            return 'Invalid text delta provided for this text document';
-        }
-        return replace.apply(state, path, doc);
-    },
-    transform(state, thisOp, otherOps) {
-        log('Transforming ', otherOps, ' against "@txt"', thisOp);
-        return updateRemovedOps(state, thisOp.path, otherOps, false, true, thisOp.op, op => {
-            if (op.path !== thisOp.path)
-                return null; // If a subpath, it is overwritten
-            if (!op.value || !Array.isArray(op.value))
-                return null; // If not a delta, it is overwritten
-            const thisDelta = new Delta(thisOp.value);
-            let otherDelta = new Delta(op.value);
-            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 === undefined ? { op: 'remove', path } : { op: '@txt', path, value: delta.invert(oldValue) };
-    },
-    compose(state, delta1, delta2) {
-        return new Delta(delta1).compose(new Delta(delta2));
-    },
+import "../../chunk-IZ2YBCUP.js";
+import { Delta } from "@dabble/delta";
+import { replace } from "../ops/replace.js";
+import { get } from "../utils/get.js";
+import { log } from "../utils/log.js";
+import { updateRemovedOps } from "../utils/ops.js";
+const text = {
+  like: "replace",
+  apply(state, path, value) {
+    const delta = Array.isArray(value) ? new Delta(value) : value;
+    if (!delta || !Array.isArray(delta.ops)) {
+      return "Invalid delta";
+    }
+    const existingData = get(state, path);
+    let doc;
+    if (Array.isArray(existingData)) {
+      if (existingData.length && existingData[0].insert) {
+        doc = new Delta(existingData);
+      }
+    } else if (existingData && existingData.ops) {
+      doc = new Delta(existingData.ops);
+    }
+    if (!doc) {
+      doc = new Delta().insert("\n");
+    }
+    doc = doc.compose(delta);
+    if (hasInvalidOps(doc)) {
+      return "Invalid text delta provided for this text document";
+    }
+    return replace.apply(state, path, doc);
+  },
+  transform(state, thisOp, otherOps) {
+    log("Transforming ", otherOps, ' against "@txt"', thisOp);
+    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);
+      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) };
+  },
+  compose(state, delta1, delta2) {
+    return new Delta(delta1).compose(new Delta(delta2));
+  }
 };
 function hasInvalidOps(doc) {
-    return doc.ops.some(op => typeof op.insert !== 'string' && (typeof op.insert !== 'object' || op.insert === null));
+  return doc.ops.some((op) => typeof op.insert !== "string" && (typeof op.insert !== "object" || op.insert === null));
 }
+export {
+  text
+};

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

@@ -1,4 +1,8 @@
-import type { PathProxy } from '../types.js';
+import { PathProxy } from '../types.js';
+import './JSONPatch.js';
+import '@dabble/delta';
+import './types.js';
+
 /**
  * Creates a path proxy for generating JSON Pointer paths in a type-safe way.
  * This proxy should ONLY be used for path creation with JSONPatch methods.
@@ -18,5 +22,7 @@ import type { PathProxy } from '../types.js';
  * @template T The type of the object to create paths for.
  * @returns A path proxy object.
  */
-export declare const createPathProxy: <T>() => PathProxy<T>;
-export declare function pathProxy<T>(path?: string): PathProxy<T>;
+declare const createPathProxy: <T = any>() => PathProxy<T>;
+declare function pathProxy<T>(path?: string): PathProxy<T>;
+
+export { createPathProxy, pathProxy };

package/dist/json-patch/pathProxy.js

@@ -1,50 +1,29 @@
-// We use a function as the target so that `push` and other array methods can be called without error.
+import "../chunk-IZ2YBCUP.js";
 const proxyFodder = {};
-/**
- * Creates a path proxy for generating JSON Pointer paths in a type-safe way.
- * This proxy should ONLY be used for path creation with JSONPatch methods.
- *
- * Usage:
- * ```ts
- * const patch = new JSONPatch();
- * const path = createPathProxy<MyType>();
- * patch.replace(path.content, 'new text');      // Path is '/content'
- * patch.increment(path.counter, 5);             // Path is '/counter'
- * patch.add(path.items[0], newItem);            // Path is '/items/0'
- * ```
- *
- * The proxy will throw errors if you attempt to set properties or delete properties.
- * This prevents accidental mutation and ensures explicit patch operations are used.
- *
- * @template T The type of the object to create paths for.
- * @returns A path proxy object.
- */
-export const createPathProxy = pathProxy;
-// Internal implementation with the path parameter
-export function pathProxy(path = '') {
-    // Always use an empty function as the proxy target
-    // This allows us to proxy any type of value, including primitives and undefined,
-    // and enables calling array methods like push/splice directly on array proxies.
-    return new Proxy(proxyFodder, {
-        get(_, prop) {
-            // Handle toString specially to make properties work as PathLike
-            if (prop === 'toString') {
-                return function () {
-                    return path;
-                };
-            }
-            // Create a proxy for the property to continue path building
-            return pathProxy(`${path}/${prop}`);
-        },
-        set(_, prop) {
-            throw new Error(`Cannot set property '${prop}' on path proxy. ` +
-                `Path proxies are for generating JSON Pointer paths only. ` +
-                `Use JSONPatch methods instead: patch.replace(path.${prop}, value)`);
-        },
-        deleteProperty(_, prop) {
-            throw new Error(`Cannot delete property '${prop}' on path proxy. ` +
-                `Path proxies are for generating JSON Pointer paths only. ` +
-                `Use JSONPatch methods instead: patch.remove(path.${prop})`);
-        },
-    });
+const createPathProxy = pathProxy;
+function pathProxy(path = "") {
+  return new Proxy(proxyFodder, {
+    get(_, prop) {
+      if (prop === "toString") {
+        return function() {
+          return path;
+        };
+      }
+      return pathProxy(`${path}/${prop}`);
+    },
+    set(_, prop) {
+      throw new Error(
+        `Cannot set property '${prop}' on path proxy. Path proxies are for generating JSON Pointer paths only. Use JSONPatch methods instead: patch.replace(path.${prop}, value)`
+      );
+    },
+    deleteProperty(_, prop) {
+      throw new Error(
+        `Cannot delete property '${prop}' on path proxy. Path proxies are for generating JSON Pointer paths only. Use JSONPatch methods instead: patch.remove(path.${prop})`
+      );
+    }
+  });
 }
+export {
+  createPathProxy,
+  pathProxy
+};

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

@@ -1,2 +1,5 @@
-import type { JSONPatchOpHandlerMap, Runner } from './types.js';
-export declare function runWithObject(object: any, allTypes: JSONPatchOpHandlerMap, shouldCache: boolean, callback: Runner): any;
+import { JSONPatchOpHandlerMap, Runner } from './types.js';
+
+declare function runWithObject(object: any, allTypes: JSONPatchOpHandlerMap, shouldCache: boolean, callback: Runner): any;
+
+export { runWithObject };

package/dist/json-patch/state.js

@@ -1,8 +1,12 @@
-export function runWithObject(object, allTypes, shouldCache, callback) {
-    const state = {
-        root: { '': object },
-        types: allTypes,
-        cache: shouldCache ? new Set() : null,
-    };
-    return callback(state) || state.root[''];
+import "../chunk-IZ2YBCUP.js";
+function runWithObject(object, allTypes, shouldCache, callback) {
+  const state = {
+    root: { "": object },
+    types: allTypes,
+    cache: shouldCache ? /* @__PURE__ */ new Set() : null
+  };
+  return callback(state) || state.root[""];
 }
+export {
+  runWithObject
+};

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

@@ -1,3 +1,5 @@
+import { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+
 /*!
  * Based on work from
  * https://github.com/Palindrom/JSONPatchOT
@@ -10,10 +12,12 @@
  * 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 type { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+
 /**
  * Transform an array of JSON Patch operations against another array of JSON Patch operations. Returns a new array with
  * transformed operations. Operations that change are cloned, making the results of this function immutable.
  * `otherOps` are transformed over `thisOps` with thisOps considered to have happened first.
  */
-export declare function transformPatch(obj: any, thisOps: JSONPatchOp[], otherOps: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];
+declare function transformPatch(obj: any, thisOps: JSONPatchOp[], otherOps: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];
+
+export { transformPatch };

package/dist/json-patch/transformPatch.js

@@ -1,3 +1,4 @@
+import "../chunk-IZ2YBCUP.js";
 /*!
  * Based on work from
  * https://github.com/Palindrom/JSONPatchOT
@@ -10,28 +11,24 @@
  * 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 { getTypes } from './ops/index.js';
-import { runWithObject } from './state.js';
-import { getType } from './utils/getType.js';
-import { log } from './utils/log.js';
-/**
- * Transform an array of JSON Patch operations against another array of JSON Patch operations. Returns a new array with
- * transformed operations. Operations that change are cloned, making the results of this function immutable.
- * `otherOps` are transformed over `thisOps` with thisOps considered to have happened first.
- */
-export function transformPatch(obj, thisOps, otherOps, custom) {
-    const types = getTypes(custom);
-    return runWithObject(obj, types, false, state => {
-        return thisOps.reduce((otherOps, thisOp) => {
-            // transform ops with patch operation
-            const handler = getType(state, thisOp)?.transform;
-            if (typeof handler === 'function') {
-                otherOps = handler(state, thisOp, otherOps);
-            }
-            else {
-                log('No function to transform against for', thisOp.op);
-            }
-            return otherOps;
-        }, otherOps);
-    });
+import { getTypes } from "./ops/index.js";
+import { runWithObject } from "./state.js";
+import { getType } from "./utils/getType.js";
+import { log } from "./utils/log.js";
+function transformPatch(obj, thisOps, otherOps, custom) {
+  const types = getTypes(custom);
+  return runWithObject(obj, types, false, (state) => {
+    return thisOps.reduce((otherOps2, thisOp) => {
+      const handler = getType(state, thisOp)?.transform;
+      if (typeof handler === "function") {
+        otherOps2 = handler(state, thisOp, otherOps2);
+      } else {
+        log("No function to transform against for", thisOp.op);
+      }
+      return otherOps2;
+    }, otherOps);
+  });
 }
+export {
+  transformPatch
+};

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

@@ -1,14 +1,14 @@
-export interface JSONPatchOpHandler {
+interface JSONPatchOpHandler {
     like: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
     apply(state: State, path: string, valueOrFrom: any): string | void;
     transform(state: State, other: JSONPatchOp, ops: JSONPatchOp[]): JSONPatchOp[];
     invert(state: State, op: JSONPatchOp, value: any, changedObj: any, isIndex: boolean): JSONPatchOp;
     compose?(state: State, value1: any, value2: any): any;
 }
-export interface JSONPatchOpHandlerMap {
+interface JSONPatchOpHandlerMap {
     [key: string]: JSONPatchOpHandler;
 }
-export interface ApplyJSONPatchOptions {
+interface ApplyJSONPatchOptions {
     /**
      * Do not reject patches if error occurs (partial patching)
      */
@@ -34,19 +34,21 @@ export interface ApplyJSONPatchOptions {
      */
     atPath?: string;
 }
-export interface JSONPatchOp {
+interface JSONPatchOp {
     op: string;
     path: string;
     from?: string;
     value?: any;
     soft?: boolean;
 }
-export interface Root {
+interface Root {
     '': any;
 }
-export type State = {
+type State = {
     root: Root;
     types: JSONPatchOpHandlerMap;
     cache: Set<any> | null;
 };
-export type Runner = (state: State) => any;
+type Runner = (state: State) => any;
+
+export type { ApplyJSONPatchOptions, JSONPatchOp, JSONPatchOpHandler, JSONPatchOpHandlerMap, Root, Runner, State };

package/dist/json-patch/types.js

@@ -1 +0,0 @@
-export {};

package/dist/json-patch/utils/deepEqual.d.ts

@@ -1 +1,3 @@
-export declare function deepEqual(a: any, b: any): boolean;
+declare function deepEqual(a: any, b: any): boolean;
+
+export { deepEqual };

package/dist/json-patch/utils/deepEqual.js

@@ -1,33 +1,37 @@
-export function deepEqual(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (!(a && b) || typeof a !== 'object' || typeof b !== 'object') {
-        return false;
-    }
-    if (a.length !== b.length) {
-        return false;
-    }
-    if (Array.isArray(a)) {
-        if (!Array.isArray(b)) {
-            return false;
-        }
-        for (let i = 0, imax = a.length; i < imax; i++) {
-            if (!deepEqual(a[i], b[i])) {
-                return false;
-            }
-        }
-        return true;
+import "../../chunk-IZ2YBCUP.js";
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!(a && b) || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return false;
     }
-    const aKeys = Object.keys(a);
-    if (aKeys.length !== Object.keys(b).length) {
+    for (let i = 0, imax = a.length; i < imax; i++) {
+      if (!deepEqual(a[i], b[i])) {
         return false;
-    }
-    for (let j = 0, jmax = aKeys.length; j < jmax; j++) {
-        const key = aKeys[j];
-        if (!deepEqual(a[key], b[key])) {
-            return false;
-        }
+      }
     }
     return true;
+  }
+  const aKeys = Object.keys(a);
+  if (aKeys.length !== Object.keys(b).length) {
+    return false;
+  }
+  for (let j = 0, jmax = aKeys.length; j < jmax; j++) {
+    const key = aKeys[j];
+    if (!deepEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
 }
+export {
+  deepEqual
+};

package/dist/json-patch/utils/exit.d.ts

@@ -1,2 +1,5 @@
-import type { ApplyJSONPatchOptions, JSONPatchOp, State } from '../types.js';
-export declare function exit(state: State, object: any, patch: JSONPatchOp, opts: ApplyJSONPatchOptions): any;
+import { State, JSONPatchOp, ApplyJSONPatchOptions } from '../types.js';
+
+declare function exit(state: State, object: any, patch: JSONPatchOp, opts: ApplyJSONPatchOptions): any;
+
+export { exit };

package/dist/json-patch/utils/exit.js

@@ -1,4 +1,8 @@
-export function exit(state, object, patch, opts) {
-    opts.error = patch;
-    return opts.partial && state.root ? state.root[''] : object;
+import "../../chunk-IZ2YBCUP.js";
+function exit(state, object, patch, opts) {
+  opts.error = patch;
+  return opts.partial && state.root ? state.root[""] : object;
 }
+export {
+  exit
+};

package/dist/json-patch/utils/get.d.ts

@@ -1,2 +1,5 @@
-import type { State } from '../types.js';
-export declare function get(state: State, path: string): any;
+import { State } from '../types.js';
+
+declare function get(state: State, path: string): any;
+
+export { get };

package/dist/json-patch/utils/get.js

@@ -1,5 +1,9 @@
-import { getOpData } from './getOpData.js';
-export function get(state, path) {
-    const [, lastKey, target] = getOpData(state, path);
-    return target ? target[lastKey] : undefined;
+import "../../chunk-IZ2YBCUP.js";
+import { getOpData } from "./getOpData.js";
+function get(state, path) {
+  const [, lastKey, target] = getOpData(state, path);
+  return target ? target[lastKey] : void 0;
 }
+export {
+  get
+};

package/dist/json-patch/utils/getOpData.d.ts

@@ -1,2 +1,5 @@
-import type { State } from '../types.js';
-export declare function getOpData(state: State, path: string, createMissingObjects?: boolean): any[];
+import { State } from '../types.js';
+
+declare function getOpData(state: State, path: string, createMissingObjects?: boolean): any[];
+
+export { getOpData };

package/dist/json-patch/utils/getOpData.js

@@ -1,10 +1,13 @@
-import { EMPTY, pluck } from './pluck.js';
-import { toKeys } from './toKeys.js';
-export function getOpData(state, path, createMissingObjects) {
-    const keys = toKeys(path);
-    const lastKey = keys[keys.length - 1];
-    let target = pluck(state, keys);
-    if (createMissingObjects)
-        target = target || EMPTY;
-    return [keys, lastKey, target];
+import "../../chunk-IZ2YBCUP.js";
+import { EMPTY, pluck } from "./pluck.js";
+import { toKeys } from "./toKeys.js";
+function getOpData(state, path, createMissingObjects) {
+  const keys = toKeys(path);
+  const lastKey = keys[keys.length - 1];
+  let target = pluck(state, keys);
+  if (createMissingObjects) target = target || EMPTY;
+  return [keys, lastKey, target];
 }
+export {
+  getOpData
+};

package/dist/json-patch/utils/getType.d.ts

@@ -1,3 +1,6 @@
-import type { JSONPatchOp, State } from '../types.js';
-export declare function getType(state: State, patch: JSONPatchOp): import("../types.js").JSONPatchOpHandler;
-export declare function getTypeLike(state: State, patch: JSONPatchOp): "add" | "remove" | "replace" | "move" | "copy" | "test";
+import { State, JSONPatchOp, JSONPatchOpHandler } from '../types.js';
+
+declare function getType(state: State, patch: JSONPatchOp): JSONPatchOpHandler;
+declare function getTypeLike(state: State, patch: JSONPatchOp): "add" | "remove" | "replace" | "move" | "copy" | "test";
+
+export { getType, getTypeLike };

package/dist/json-patch/utils/getType.js

@@ -1,6 +1,11 @@
-export function getType(state, patch) {
-    return state.types?.[patch.op];
+import "../../chunk-IZ2YBCUP.js";
+function getType(state, patch) {
+  return state.types?.[patch.op];
 }
-export function getTypeLike(state, patch) {
-    return state.types?.[patch.op]?.like;
+function getTypeLike(state, patch) {
+  return state.types?.[patch.op]?.like;
 }
+export {
+  getType,
+  getTypeLike
+};

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

@@ -1,14 +1,15 @@
-export * from './deepEqual.js';
-export * from './get.js';
-export * from './getOpData.js';
-export * from './getType.js';
-export * from './log.js';
-export * from './ops.js';
-export * from './paths.js';
-export * from './pluck.js';
-export * from './shallowCopy.js';
-export * from './softWrites.js';
-export * from './toArrayIndex.js';
-export * from './toKeys.js';
-export * from './updateArrayIndexes.js';
-export * from './updateArrayPath.js';
+export { deepEqual } from './deepEqual.js';
+export { get } from './get.js';
+export { getOpData } from './getOpData.js';
+export { getType, getTypeLike } from './getType.js';
+export { log, verbose } from './log.js';
+export { isAdd, mapAndFilterOps, transformRemove, updateRemovedOps } from './ops.js';
+export { getArrayIndex, getArrayPrefixAndIndex, getIndexAndEnd, getPrefix, getPrefixAndProp, getProp, getPropAfter, isArrayPath } from './paths.js';
+export { EMPTY, getValue, pluck, pluckWithShallowCopy } from './pluck.js';
+export { shallowCopy } from './shallowCopy.js';
+export { isEmptyObject, updateSoftWrites } from './softWrites.js';
+export { toArrayIndex } from './toArrayIndex.js';
+export { toKeys } from './toKeys.js';
+export { updateArrayIndexes } from './updateArrayIndexes.js';
+export { updateArrayPath } from './updateArrayPath.js';
+import '../types.js';

package/dist/json-patch/utils/index.js

@@ -1,14 +1,14 @@
-export * from './deepEqual.js';
-export * from './get.js';
-export * from './getOpData.js';
-export * from './getType.js';
-export * from './log.js';
-export * from './ops.js';
-export * from './paths.js';
-export * from './pluck.js';
-export * from './shallowCopy.js';
-export * from './softWrites.js';
-export * from './toArrayIndex.js';
-export * from './toKeys.js';
-export * from './updateArrayIndexes.js';
-export * from './updateArrayPath.js';
+export * from "./deepEqual.js";
+export * from "./get.js";
+export * from "./getOpData.js";
+export * from "./getType.js";
+export * from "./log.js";
+export * from "./ops.js";
+export * from "./paths.js";
+export * from "./pluck.js";
+export * from "./shallowCopy.js";
+export * from "./softWrites.js";
+export * from "./toArrayIndex.js";
+export * from "./toKeys.js";
+export * from "./updateArrayIndexes.js";
+export * from "./updateArrayPath.js";

package/dist/json-patch/utils/log.d.ts

@@ -1,5 +1,7 @@
-export declare let log: {
+declare let log: {
     (...data: any[]): void;
     (message?: any, ...optionalParams: any[]): void;
 };
-export declare function verbose(value: boolean): void;
+declare function verbose(value: boolean): void;
+
+export { log, verbose };

package/dist/json-patch/utils/log.js

@@ -1,4 +1,9 @@
-export let log = console.log;
-export function verbose(value) {
-    log = value ? console.log : () => undefined;
+import "../../chunk-IZ2YBCUP.js";
+let log = console.log;
+function verbose(value) {
+  log = value ? console.log : () => void 0;
 }
+export {
+  log,
+  verbose
+};