@dabble/patches 0.4.5 → 0.4.6

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

@@ -1,14 +1,17 @@
-import type { JSONPatchOp, State } from '../types.js';
+import { State, JSONPatchOp } from '../types.js';
+
 /**
  * Check whether this operation is an add operation of some sort (add, copy, move).
  */
-export declare function isAdd(state: State, op: JSONPatchOp, pathName: 'from' | 'path'): boolean;
+declare function isAdd(state: State, op: JSONPatchOp, pathName: 'from' | 'path'): boolean;
 /**
  * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
  */
-export declare function mapAndFilterOps(ops: JSONPatchOp[], iterator: (op: JSONPatchOp, index: number, breakAfter: (keepRest?: boolean) => void) => JSONPatchOp | JSONPatchOp[] | null): JSONPatchOp[];
+declare function mapAndFilterOps(ops: JSONPatchOp[], iterator: (op: JSONPatchOp, index: number, breakAfter: (keepRest?: boolean) => void) => JSONPatchOp | JSONPatchOp[] | null): JSONPatchOp[];
 /**
  * Remove operations that apply to a value which was removed.
  */
-export declare function updateRemovedOps(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean, updatableObject?: boolean, opOp?: string, customHandler?: (op: JSONPatchOp) => any): JSONPatchOp[];
-export declare function transformRemove(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean): JSONPatchOp[];
+declare function updateRemovedOps(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean, updatableObject?: boolean, opOp?: string, customHandler?: (op: JSONPatchOp) => any): JSONPatchOp[];
+declare function transformRemove(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean): JSONPatchOp[];
+
+export { isAdd, mapAndFilterOps, transformRemove, updateRemovedOps };

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

@@ -1,106 +1,89 @@
-import { getTypeLike } from './getType.js';
-import { log } from './log.js';
-import { isArrayPath } from './paths.js';
-import { updateArrayIndexes } from './updateArrayIndexes.js';
-/**
- * Check whether this operation is an add operation of some sort (add, copy, move).
- */
-export function isAdd(state, op, pathName) {
-    const like = getTypeLike(state, op);
-    return (like === 'add' || like === 'copy' || like === 'move') && pathName === 'path';
+import "../../chunk-IZ2YBCUP.js";
+import { getTypeLike } from "./getType.js";
+import { log } from "./log.js";
+import { isArrayPath } from "./paths.js";
+import { updateArrayIndexes } from "./updateArrayIndexes.js";
+function isAdd(state, op, pathName) {
+  const like = getTypeLike(state, op);
+  return (like === "add" || like === "copy" || like === "move") && pathName === "path";
 }
-/**
- * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
- */
-export function mapAndFilterOps(ops, iterator) {
-    let changed = false;
-    const mapped = [];
-    let shouldBreak = false;
-    let keepRest;
-    const breakAfter = (keep) => {
-        shouldBreak = true;
-        keepRest = keep;
-    };
-    for (let i = 0; i < ops.length; i++) {
-        const original = ops[i];
-        // If an op was copied or moved to the same path, it is a no-op and should be removed
-        if (original.from === original.path) {
-            if (!changed)
-                changed = true;
-            continue;
-        }
-        let value = iterator(original, i, breakAfter);
-        if (value && !Array.isArray(value) && value.from === value.path)
-            value = null;
-        if (!changed && value !== original)
-            changed = true;
-        if (Array.isArray(value))
-            mapped.push(...value);
-        else if (value)
-            mapped.push(value);
-        if (shouldBreak) {
-            if (keepRest)
-                mapped.push(...ops.slice(i + 1));
-            break;
-        }
+function mapAndFilterOps(ops, iterator) {
+  let changed = false;
+  const mapped = [];
+  let shouldBreak = false;
+  let keepRest;
+  const breakAfter = (keep) => {
+    shouldBreak = true;
+    keepRest = keep;
+  };
+  for (let i = 0; i < ops.length; i++) {
+    const original = ops[i];
+    if (original.from === original.path) {
+      if (!changed) changed = true;
+      continue;
     }
-    return changed ? mapped : ops;
-}
-/**
- * Remove operations that apply to a value which was removed.
- */
-export function updateRemovedOps(state, thisPath, otherOps, isRemove = false, updatableObject = false, opOp, customHandler) {
-    const softPrefixes = new Set();
-    return mapAndFilterOps(otherOps, (op, index, breakAfter) => {
-        const opLike = getTypeLike(state, op);
-        const canMergeCustom = customHandler && opOp === op.op;
-        if (thisPath === op.path && opLike !== 'remove' && !canMergeCustom && !op.soft) {
-            // Once an operation sets this value again, we can assume the following ops were working on that and not the
-            // old value so they can be kept
-            if (op.op !== 'test') {
-                breakAfter(true); // stop and keep the remaining ops as-is
-            }
-            return op;
-        }
-        const { path, from } = op;
-        if (path === thisPath && canMergeCustom) {
-            const customOp = customHandler(op);
-            if (customOp)
-                return customOp;
-        }
-        if (isRemove && !updatableObject && from === thisPath) {
-            // Because of the check above, moves and copies will only hit here when the "from" field matches
-            if (opLike === 'move') {
-                // We need the rest of the otherOps to be adjusted against this "move"
-                breakAfter();
-                return transformRemove(state, op.path, otherOps.slice(index + 1));
-            }
-            else if (opLike === 'copy') {
-                // We need future ops on the copied object to be removed
-                breakAfter();
-                let rest = transformRemove(state, thisPath, otherOps.slice(index + 1));
-                rest = transformRemove(state, op.path, rest);
-                return rest;
-            }
-        }
-        if (op.soft && path === thisPath) {
-            softPrefixes.add(path);
-            return null;
-        }
-        const samePath = (!updatableObject && path === thisPath) || (!softPrefixes.has(thisPath) && path.startsWith(`${thisPath}/`));
-        const sameFrom = (!updatableObject && from === thisPath) || (!softPrefixes.has(thisPath) && from?.startsWith(`${thisPath}/`));
-        if (samePath || sameFrom) {
-            log('Removing', op);
-            return null;
-        }
-        return op;
-    });
+    let value = iterator(original, i, breakAfter);
+    if (value && !Array.isArray(value) && value.from === value.path) value = null;
+    if (!changed && value !== original) changed = true;
+    if (Array.isArray(value)) mapped.push(...value);
+    else if (value) mapped.push(value);
+    if (shouldBreak) {
+      if (keepRest) mapped.push(...ops.slice(i + 1));
+      break;
+    }
+  }
+  return changed ? mapped : ops;
 }
-export function transformRemove(state, thisPath, otherOps, isRemove) {
-    if (isArrayPath(thisPath, state)) {
-        return updateArrayIndexes(state, thisPath, otherOps, -1, isRemove);
+function updateRemovedOps(state, thisPath, otherOps, isRemove = false, updatableObject = false, opOp, customHandler) {
+  const softPrefixes = /* @__PURE__ */ new Set();
+  return mapAndFilterOps(otherOps, (op, index, breakAfter) => {
+    const opLike = getTypeLike(state, op);
+    const canMergeCustom = customHandler && opOp === op.op;
+    if (thisPath === op.path && opLike !== "remove" && !canMergeCustom && !op.soft) {
+      if (op.op !== "test") {
+        breakAfter(true);
+      }
+      return op;
+    }
+    const { path, from } = op;
+    if (path === thisPath && canMergeCustom) {
+      const customOp = customHandler(op);
+      if (customOp) return customOp;
     }
-    else {
-        return updateRemovedOps(state, thisPath, otherOps, isRemove);
+    if (isRemove && !updatableObject && from === thisPath) {
+      if (opLike === "move") {
+        breakAfter();
+        return transformRemove(state, op.path, otherOps.slice(index + 1));
+      } else if (opLike === "copy") {
+        breakAfter();
+        let rest = transformRemove(state, thisPath, otherOps.slice(index + 1));
+        rest = transformRemove(state, op.path, rest);
+        return rest;
+      }
     }
+    if (op.soft && path === thisPath) {
+      softPrefixes.add(path);
+      return null;
+    }
+    const samePath = !updatableObject && path === thisPath || !softPrefixes.has(thisPath) && path.startsWith(`${thisPath}/`);
+    const sameFrom = !updatableObject && from === thisPath || !softPrefixes.has(thisPath) && from?.startsWith(`${thisPath}/`);
+    if (samePath || sameFrom) {
+      log("Removing", op);
+      return null;
+    }
+    return op;
+  });
+}
+function transformRemove(state, thisPath, otherOps, isRemove) {
+  if (isArrayPath(thisPath, state)) {
+    return updateArrayIndexes(state, thisPath, otherOps, -1, isRemove);
+  } else {
+    return updateRemovedOps(state, thisPath, otherOps, isRemove);
+  }
 }
+export {
+  isAdd,
+  mapAndFilterOps,
+  transformRemove,
+  updateRemovedOps
+};

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

@@ -1,9 +1,12 @@
-import type { State } from '../types.js';
-export declare function getPrefix(path: string): string;
-export declare function getProp(path: string): string;
-export declare function getPrefixAndProp(path: string): [string, string];
-export declare function getPropAfter(path: string, index: number): string;
-export declare function isArrayPath(path: string, state?: State): boolean;
-export declare function getArrayPrefixAndIndex(state: State, path: string, pathLength?: number): [string, number];
-export declare function getArrayIndex(state: State, path: string, pathLength?: number): number;
-export declare function getIndexAndEnd(state: State, path: string | undefined, maxLength: number): number[];
+import { State } from '../types.js';
+
+declare function getPrefix(path: string): string;
+declare function getProp(path: string): string;
+declare function getPrefixAndProp(path: string): [string, string];
+declare function getPropAfter(path: string, index: number): string;
+declare function isArrayPath(path: string, state?: State): boolean;
+declare function getArrayPrefixAndIndex(state: State, path: string, pathLength?: number): [string, number];
+declare function getArrayIndex(state: State, path: string, pathLength?: number): number;
+declare function getIndexAndEnd(state: State, path: string | undefined, maxLength: number): number[];
+
+export { getArrayIndex, getArrayPrefixAndIndex, getIndexAndEnd, getPrefix, getPrefixAndProp, getProp, getPropAfter, isArrayPath };

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

@@ -1,53 +1,56 @@
-import { getOpData } from './getOpData.js';
+import "../../chunk-IZ2YBCUP.js";
+import { getOpData } from "./getOpData.js";
 const arrayPathExp = /\/(0|[1-9]\d*)$/;
 const EMPTY = [];
-export function getPrefix(path) {
-    const lastSlash = path.lastIndexOf('/');
-    return path.slice(0, lastSlash + 1);
-}
-export function getProp(path) {
-    const lastSlash = path.lastIndexOf('/');
-    return path.slice(lastSlash + 1);
-}
-export function getPrefixAndProp(path) {
-    const prefix = getPrefix(path);
-    return [prefix, path.slice(prefix.length)];
-}
-export function getPropAfter(path, index) {
-    const lastSlash = path.indexOf('/', index);
-    return path.slice(index, lastSlash === -1 ? undefined : lastSlash);
-}
-export function isArrayPath(path, state) {
-    if (!arrayPathExp.test(path))
-        return false;
-    if (!state || !state.root || !state.root[''])
-        return true;
-    // Double-check if this is an array or not
-    const [, , target] = getOpData(state, path);
-    return Array.isArray(target) || target == null;
-}
-export function getArrayPrefixAndIndex(state, path, pathLength) {
-    if (pathLength)
-        path = path.slice(0, path.indexOf('/', pathLength));
-    if (!arrayPathExp.test(path))
-        return EMPTY;
-    const [, , target] = getOpData(state, path);
-    if (!Array.isArray(target))
-        return EMPTY;
-    const [prefix, indexStr] = getPrefixAndProp(path);
-    const index = parseInt(indexStr);
-    return [prefix, index];
-}
-export function getArrayIndex(state, path, pathLength) {
-    return getArrayPrefixAndIndex(state, path, pathLength)[1];
-}
-export function getIndexAndEnd(state, path, maxLength) {
-    if (!path)
-        return [];
-    const prop = getPropAfter(path, maxLength);
-    const end = maxLength + prop.length;
-    if (!isArrayPath(path.slice(0, end), state))
-        return [];
-    const index = parseInt(prop);
-    return [index, end];
-}
+function getPrefix(path) {
+  const lastSlash = path.lastIndexOf("/");
+  return path.slice(0, lastSlash + 1);
+}
+function getProp(path) {
+  const lastSlash = path.lastIndexOf("/");
+  return path.slice(lastSlash + 1);
+}
+function getPrefixAndProp(path) {
+  const prefix = getPrefix(path);
+  return [prefix, path.slice(prefix.length)];
+}
+function getPropAfter(path, index) {
+  const lastSlash = path.indexOf("/", index);
+  return path.slice(index, lastSlash === -1 ? void 0 : lastSlash);
+}
+function isArrayPath(path, state) {
+  if (!arrayPathExp.test(path)) return false;
+  if (!state || !state.root || !state.root[""]) return true;
+  const [, , target] = getOpData(state, path);
+  return Array.isArray(target) || target == null;
+}
+function getArrayPrefixAndIndex(state, path, pathLength) {
+  if (pathLength) path = path.slice(0, path.indexOf("/", pathLength));
+  if (!arrayPathExp.test(path)) return EMPTY;
+  const [, , target] = getOpData(state, path);
+  if (!Array.isArray(target)) return EMPTY;
+  const [prefix, indexStr] = getPrefixAndProp(path);
+  const index = parseInt(indexStr);
+  return [prefix, index];
+}
+function getArrayIndex(state, path, pathLength) {
+  return getArrayPrefixAndIndex(state, path, pathLength)[1];
+}
+function getIndexAndEnd(state, path, maxLength) {
+  if (!path) return [];
+  const prop = getPropAfter(path, maxLength);
+  const end = maxLength + prop.length;
+  if (!isArrayPath(path.slice(0, end), state)) return [];
+  const index = parseInt(prop);
+  return [index, end];
+}
+export {
+  getArrayIndex,
+  getArrayPrefixAndIndex,
+  getIndexAndEnd,
+  getPrefix,
+  getPrefixAndProp,
+  getProp,
+  getPropAfter,
+  isArrayPath
+};

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

@@ -1,5 +1,8 @@
-import type { State } from '../types.js';
-export declare const EMPTY: {};
-export declare function pluck(state: State, keys: string[]): any;
-export declare function pluckWithShallowCopy(state: State, keys: string[], createMissingObjects?: boolean): any;
-export declare function getValue(state: State, value: any, addKey?: string, addValue?: any): any;
+import { State } from '../types.js';
+
+declare const EMPTY: {};
+declare function pluck(state: State, keys: string[]): any;
+declare function pluckWithShallowCopy(state: State, keys: string[], createMissingObjects?: boolean): any;
+declare function getValue(state: State, value: any, addKey?: string, addValue?: any): any;
+
+export { EMPTY, getValue, pluck, pluckWithShallowCopy };

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

@@ -1,30 +1,36 @@
-import { shallowCopy } from './shallowCopy.js';
-export const EMPTY = {};
-export function pluck(state, keys) {
-    let object = state.root;
-    for (let i = 0, imax = keys.length - 1; i < imax; i++) {
-        const key = keys[i];
-        if (!object[key]) {
-            return null;
-        }
-        object = object[key];
+import "../../chunk-IZ2YBCUP.js";
+import { shallowCopy } from "./shallowCopy.js";
+const EMPTY = {};
+function pluck(state, keys) {
+  let object = state.root;
+  for (let i = 0, imax = keys.length - 1; i < imax; i++) {
+    const key = keys[i];
+    if (!object[key]) {
+      return null;
     }
-    return object;
+    object = object[key];
+  }
+  return object;
 }
-export function pluckWithShallowCopy(state, keys, createMissingObjects) {
-    let object = state.root;
-    for (let i = 0, imax = keys.length - 1; i < imax; i++) {
-        const key = keys[i];
-        object = object[key] = createMissingObjects && !object[key] ? getValue(state, EMPTY) : getValue(state, object[key]);
-    }
-    return object;
+function pluckWithShallowCopy(state, keys, createMissingObjects) {
+  let object = state.root;
+  for (let i = 0, imax = keys.length - 1; i < imax; i++) {
+    const key = keys[i];
+    object = object[key] = createMissingObjects && !object[key] ? getValue(state, EMPTY) : getValue(state, object[key]);
+  }
+  return object;
 }
-export function getValue(state, value, addKey, addValue) {
-    if (!state.cache?.has(value)) {
-        value = shallowCopy(value);
-        state.cache?.add(value);
-    }
-    if (addKey)
-        value[addKey] = addValue;
-    return value;
+function getValue(state, value, addKey, addValue) {
+  if (!state.cache?.has(value)) {
+    value = shallowCopy(value);
+    state.cache?.add(value);
+  }
+  if (addKey) value[addKey] = addValue;
+  return value;
 }
+export {
+  EMPTY,
+  getValue,
+  pluck,
+  pluckWithShallowCopy
+};

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

@@ -1 +1,3 @@
-export declare function shallowCopy(obj: any): any;
+declare function shallowCopy(obj: any): any;
+
+export { shallowCopy };

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

@@ -1,20 +1,24 @@
-export function shallowCopy(obj) {
-    if (!obj || typeof obj !== 'object') {
-        return obj;
+import "../../chunk-IZ2YBCUP.js";
+function shallowCopy(obj) {
+  if (!obj || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    const len = obj.length;
+    const ary = new Array(len);
+    for (let i = 0; i < len; i++) {
+      ary[i] = obj[i];
     }
-    if (Array.isArray(obj)) {
-        const len = obj.length;
-        const ary = new Array(len);
-        for (let i = 0; i < len; i++) {
-            ary[i] = obj[i];
-        }
-        return ary;
-    }
-    const keys = Object.keys(obj);
-    const copy = {};
-    for (let j = 0, jmax = keys.length; j < jmax; j++) {
-        const key = keys[j];
-        copy[key] = obj[key];
-    }
-    return copy;
+    return ary;
+  }
+  const keys = Object.keys(obj);
+  const copy = {};
+  for (let j = 0, jmax = keys.length; j < jmax; j++) {
+    const key = keys[j];
+    copy[key] = obj[key];
+  }
+  return copy;
 }
+export {
+  shallowCopy
+};

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

@@ -1,7 +1,10 @@
-import type { JSONPatchOp } from '../types.js';
-export declare function isEmptyObject(value: any): boolean;
+import { JSONPatchOp } from '../types.js';
+
+declare function isEmptyObject(value: any): boolean;
 /**
  * If other objects were added to this same path, assume they are maps/hashes/lookups and don't overwrite, allow
  * subsequent ops to merge onto the first map created. `soft` will also do this for any value that already exists.
  */
-export declare function updateSoftWrites(overPath: string, ops: JSONPatchOp[]): JSONPatchOp[];
+declare function updateSoftWrites(overPath: string, ops: JSONPatchOp[]): JSONPatchOp[];
+
+export { isEmptyObject, updateSoftWrites };

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

@@ -1,18 +1,19 @@
-import { log } from './log.js';
-import { mapAndFilterOps } from './ops.js';
-export function isEmptyObject(value) {
-    return Boolean(value && typeof value === 'object' && Object.keys(value).length === 0);
+import "../../chunk-IZ2YBCUP.js";
+import { log } from "./log.js";
+import { mapAndFilterOps } from "./ops.js";
+function isEmptyObject(value) {
+  return Boolean(value && typeof value === "object" && Object.keys(value).length === 0);
 }
-/**
- * If other objects were added to this same path, assume they are maps/hashes/lookups and don't overwrite, allow
- * subsequent ops to merge onto the first map created. `soft` will also do this for any value that already exists.
- */
-export function updateSoftWrites(overPath, ops) {
-    return mapAndFilterOps(ops, op => {
-        if (op.op === 'add' && op.path === overPath && isEmptyObject(op.value)) {
-            log('Removing empty object', op);
-            return null;
-        }
-        return op;
-    });
+function updateSoftWrites(overPath, ops) {
+  return mapAndFilterOps(ops, (op) => {
+    if (op.op === "add" && op.path === overPath && isEmptyObject(op.value)) {
+      log("Removing empty object", op);
+      return null;
+    }
+    return op;
+  });
 }
+export {
+  isEmptyObject,
+  updateSoftWrites
+};

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

@@ -1 +1,3 @@
-export declare function toArrayIndex(array: any[], str: string): number;
+declare function toArrayIndex(array: any[], str: string): number;
+
+export { toArrayIndex };

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

@@ -1,12 +1,16 @@
-export function toArrayIndex(array, str) {
-    if (str === '-') {
-        return array.length;
+import "../../chunk-IZ2YBCUP.js";
+function toArrayIndex(array, str) {
+  if (str === "-") {
+    return array.length;
+  }
+  for (let i = 0, imax = str.length; i < imax; i++) {
+    const ch = str.charCodeAt(i);
+    if (57 < ch || ch < 48) {
+      return -1;
     }
-    for (let i = 0, imax = str.length; i < imax; i++) {
-        const ch = str.charCodeAt(i);
-        if (57 < ch || ch < 48) {
-            return -1;
-        }
-    }
-    return +str;
+  }
+  return +str;
 }
+export {
+  toArrayIndex
+};

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

@@ -1 +1,3 @@
-export declare function toKeys(path: string): string[];
+declare function toKeys(path: string): string[];
+
+export { toKeys };

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

@@ -1,15 +1,19 @@
+import "../../chunk-IZ2YBCUP.js";
 function esc(m) {
-    return m === '~0' ? '~' : '/';
+  return m === "~0" ? "~" : "/";
 }
-export function toKeys(path) {
-    const keys = path.split('/');
-    if (!path.includes('~')) {
-        return keys;
-    }
-    for (let i = 0, imax = keys.length; i < imax; i++) {
-        if (keys[i].includes('~')) {
-            keys[i] = keys[i].replace(/~[01]/g, esc);
-        }
-    }
+function toKeys(path) {
+  const keys = path.split("/");
+  if (!path.includes("~")) {
     return keys;
+  }
+  for (let i = 0, imax = keys.length; i < imax; i++) {
+    if (keys[i].includes("~")) {
+      keys[i] = keys[i].replace(/~[01]/g, esc);
+    }
+  }
+  return keys;
 }
+export {
+  toKeys
+};

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

@@ -1,5 +1,8 @@
-import type { JSONPatchOp, State } from '../types.js';
+import { State, JSONPatchOp } from '../types.js';
+
 /**
  * Update array indexes to account for values being added or removed from an array.
  */
-export declare function updateArrayIndexes(state: State, thisPath: string, otherOps: JSONPatchOp[], modifier: 1 | -1, isRemove?: boolean): JSONPatchOp[];
+declare function updateArrayIndexes(state: State, thisPath: string, otherOps: JSONPatchOp[], modifier: 1 | -1, isRemove?: boolean): JSONPatchOp[];
+
+export { updateArrayIndexes };