@dabble/patches 0.4.4 → 0.4.6

package/dist/json-patch/index.js

@@ -1,9 +1,20 @@
-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 { transformPatch } from './transformPatch.js';
-export * from './JSONPatch.js';
-export * from './ops/index.js';
+import "../chunk-IZ2YBCUP.js";
+import { applyPatch } from "./applyPatch.js";
+import { composePatch } from "./composePatch.js";
+import { invertPatch } from "./invertPatch.js";
+import { applyBitmask, bitmask, combineBitmasks } from "./ops/bitmask.js";
+import * as defaultOps from "./ops/index.js";
+export * from "./pathProxy.js";
+import { transformPatch } from "./transformPatch.js";
+export * from "./JSONPatch.js";
+export * from "./ops/index.js";
+export {
+  applyBitmask,
+  applyPatch,
+  bitmask,
+  combineBitmasks,
+  composePatch,
+  defaultOps,
+  invertPatch,
+  transformPatch
+};

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

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

package/dist/json-patch/invertPatch.js

@@ -1,31 +1,32 @@
-import { getTypes } from './ops/index.js';
-import { runWithObject } from './state.js';
-import { getType } from './utils/getType.js';
-export function invertPatch(object, ops, custom = {}) {
-    const types = getTypes(custom);
-    return runWithObject({}, types, false, state => {
-        return ops
-            .map((op) => {
-            const pathParts = op.path.split('/').slice(1);
-            let changedObj = object;
-            const prop = pathParts.pop();
-            let value, isIndex;
-            try {
-                for (let i = 0; i < pathParts.length; i++) {
-                    changedObj = changedObj[pathParts[i]];
-                }
-                value = changedObj[prop];
-                isIndex = prop >= 0;
-            }
-            catch (err) {
-                throw new Error(`Patch mismatch. This patch was not applied to the provided object and cannot be inverted. ${err.message || err}`);
-            }
-            const handler = getType(state, op)?.invert;
-            if (!handler)
-                throw new Error('Unknown patch operation, cannot invert');
-            return handler(state, op, value, changedObj, isIndex);
-        })
-            .filter(op => !!op)
-            .reverse();
-    });
+import "../chunk-IZ2YBCUP.js";
+import { getTypes } from "./ops/index.js";
+import { runWithObject } from "./state.js";
+import { getType } from "./utils/getType.js";
+function invertPatch(object, ops, custom = {}) {
+  const types = getTypes(custom);
+  return runWithObject({}, types, false, (state) => {
+    return ops.map((op) => {
+      const pathParts = op.path.split("/").slice(1);
+      let changedObj = object;
+      const prop = pathParts.pop();
+      let value, isIndex;
+      try {
+        for (let i = 0; i < pathParts.length; i++) {
+          changedObj = changedObj[pathParts[i]];
+        }
+        value = changedObj[prop];
+        isIndex = prop >= 0;
+      } catch (err) {
+        throw new Error(
+          `Patch mismatch. This patch was not applied to the provided object and cannot be inverted. ${err.message || err}`
+        );
+      }
+      const handler = getType(state, op)?.invert;
+      if (!handler) throw new Error("Unknown patch operation, cannot invert");
+      return handler(state, op, value, changedObj, isIndex);
+    }).filter((op) => !!op).reverse();
+  });
 }
+export {
+  invertPatch
+};

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

@@ -1,2 +1,5 @@
-import type { JSONPatchOpHandler } from '../types.js';
-export declare const add: JSONPatchOpHandler;
+import { JSONPatchOpHandler } from '../types.js';
+
+declare const add: JSONPatchOpHandler;
+
+export { add };

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

@@ -1,52 +1,54 @@
-import { deepEqual } from '../utils/deepEqual.js';
-import { getOpData } from '../utils/getOpData.js';
-import { isArrayPath, isEmptyObject, log, updateArrayIndexes, updateRemovedOps, updateSoftWrites, } from '../utils/index.js';
-import { pluckWithShallowCopy } from '../utils/pluck.js';
-import { toArrayIndex } from '../utils/toArrayIndex.js';
-export const add = {
-    like: 'add',
-    apply(state, path, value) {
-        if (typeof value === 'undefined') {
-            return '[op:add] require value, but got undefined';
-        }
-        const [keys, lastKey, target] = getOpData(state, path, true);
-        if (target === null) {
-            return `[op:add] path not found: ${path}`;
-        }
-        if (Array.isArray(target)) {
-            const index = toArrayIndex(target, lastKey);
-            if (index < 0 || target.length < index) {
-                return `[op:add] invalid array index: ${path}`;
-            }
-            pluckWithShallowCopy(state, keys, true).splice(index, 0, value);
-        }
-        else {
-            if (!deepEqual(target[lastKey], value)) {
-                pluckWithShallowCopy(state, keys, true)[lastKey] = value;
-            }
-        }
-    },
-    invert(_state, { path }, value, changedObj, isIndex) {
-        if (path.endsWith('/-'))
-            return { op: 'remove', path: path.replace('-', changedObj.length) };
-        else if (isIndex)
-            return { op: 'remove', path };
-        return value === undefined ? { op: 'remove', path } : { op: 'replace', path, value };
-    },
-    transform(state, thisOp, otherOps) {
-        log('Transforming', otherOps, 'against "add"', thisOp);
-        if (isArrayPath(thisOp.path, state)) {
-            // Adjust any operations on the same array by 1 to account for this new entry
-            return updateArrayIndexes(state, thisOp.path, otherOps, 1);
-        }
-        else if (isEmptyObject(thisOp.value)) {
-            // Treat empty objects special. If two empty objects are added to the same location, don't overwrite the existing
-            // one, allowing for the merging of maps together which did not exist before
-            return updateSoftWrites(thisOp.path, otherOps);
-        }
-        else {
-            // Remove anything that was done at this path since it is being overwritten by the add
-            return updateRemovedOps(state, thisOp.path, otherOps);
-        }
-    },
+import "../../chunk-IZ2YBCUP.js";
+import { deepEqual } from "../utils/deepEqual.js";
+import { getOpData } from "../utils/getOpData.js";
+import {
+  isArrayPath,
+  isEmptyObject,
+  log,
+  updateArrayIndexes,
+  updateRemovedOps,
+  updateSoftWrites
+} from "../utils/index.js";
+import { pluckWithShallowCopy } from "../utils/pluck.js";
+import { toArrayIndex } from "../utils/toArrayIndex.js";
+const add = {
+  like: "add",
+  apply(state, path, value) {
+    if (typeof value === "undefined") {
+      return "[op:add] require value, but got undefined";
+    }
+    const [keys, lastKey, target] = getOpData(state, path, true);
+    if (target === null) {
+      return `[op:add] path not found: ${path}`;
+    }
+    if (Array.isArray(target)) {
+      const index = toArrayIndex(target, lastKey);
+      if (index < 0 || target.length < index) {
+        return `[op:add] invalid array index: ${path}`;
+      }
+      pluckWithShallowCopy(state, keys, true).splice(index, 0, value);
+    } else {
+      if (!deepEqual(target[lastKey], value)) {
+        pluckWithShallowCopy(state, keys, true)[lastKey] = value;
+      }
+    }
+  },
+  invert(_state, { path }, value, changedObj, isIndex) {
+    if (path.endsWith("/-")) return { op: "remove", path: path.replace("-", changedObj.length) };
+    else if (isIndex) return { op: "remove", path };
+    return value === void 0 ? { op: "remove", path } : { op: "replace", path, value };
+  },
+  transform(state, thisOp, otherOps) {
+    log("Transforming", otherOps, 'against "add"', thisOp);
+    if (isArrayPath(thisOp.path, state)) {
+      return updateArrayIndexes(state, thisOp.path, otherOps, 1);
+    } else if (isEmptyObject(thisOp.value)) {
+      return updateSoftWrites(thisOp.path, otherOps);
+    } else {
+      return updateRemovedOps(state, thisOp.path, otherOps);
+    }
+  }
+};
+export {
+  add
 };

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

@@ -1,14 +1,17 @@
-import type { JSONPatchOpHandler } from '../types.js';
+import { JSONPatchOpHandler } from '../types.js';
+
 /**
  * Create and maintain up to 15 boolean values in a single positive number (a bitmask). This can reduce the size of your
  * JSON document. Limiting the bits to 15 allows us to keep the number smaller (max of 9 characters), positive, and
  * allows us to combine multiple operations into a single number.
  */
-export declare const bit: JSONPatchOpHandler;
+declare const bit: JSONPatchOpHandler;
 /**
  * A helper function to create a mask number for bitmask operations. The bottom 15 bits are used to turn bits on, and
  * the top 15 bits are used to turn bits off.
  */
-export declare function bitmask(index: number, value: boolean): number;
-export declare function applyBitmask(num: number, mask: number): number;
-export declare function combineBitmasks(a: number, b: number): number;
+declare function bitmask(index: number, value: boolean): number;
+declare function applyBitmask(num: number, mask: number): number;
+declare function combineBitmasks(a: number, b: number): number;
+
+export { applyBitmask, bit, bitmask, combineBitmasks };

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

@@ -1,48 +1,45 @@
-import { get } from '../utils/get.js';
-import { updateRemovedOps } from '../utils/ops.js';
-import { replace } from './replace.js';
-/**
- * Create and maintain up to 15 boolean values in a single positive number (a bitmask). This can reduce the size of your
- * JSON document. Limiting the bits to 15 allows us to keep the number smaller (max of 9 characters), positive, and
- * allows us to combine multiple operations into a single number.
- */
-export const bit = {
-    like: 'replace',
-    apply(state, path, value) {
-        return replace.apply(state, path, applyBitmask(get(state, path) || 0, value || 0));
-    },
-    transform(state, thisOp, otherOps) {
-        return updateRemovedOps(state, thisOp.path, otherOps, false, true);
-    },
-    invert(state, op, value, changedObj, isIndex) {
-        return replace.invert(state, op, value, changedObj, isIndex);
-    },
-    compose(_state, value1, value2) {
-        return combineBitmasks(value1, value2);
-    },
+import "../../chunk-IZ2YBCUP.js";
+import { get } from "../utils/get.js";
+import { updateRemovedOps } from "../utils/ops.js";
+import { replace } from "./replace.js";
+const bit = {
+  like: "replace",
+  apply(state, path, value) {
+    return replace.apply(state, path, applyBitmask(get(state, path) || 0, value || 0));
+  },
+  transform(state, thisOp, otherOps) {
+    return updateRemovedOps(state, thisOp.path, otherOps, false, true);
+  },
+  invert(state, op, value, changedObj, isIndex) {
+    return replace.invert(state, op, value, changedObj, isIndex);
+  },
+  compose(_state, value1, value2) {
+    return combineBitmasks(value1, value2);
+  }
 };
-/**
- * A helper function to create a mask number for bitmask operations. The bottom 15 bits are used to turn bits on, and
- * the top 15 bits are used to turn bits off.
- */
-export function bitmask(index, value) {
-    if (index < 0 || index > 14)
-        throw new Error('Index must be between 0 and 14');
-    return value ? 1 << index : 1 << (index + 15);
+function bitmask(index, value) {
+  if (index < 0 || index > 14) throw new Error("Index must be between 0 and 14");
+  return value ? 1 << index : 1 << index + 15;
 }
-export function applyBitmask(num, mask) {
-    const offMask = (mask >> 15) & 0x7fff;
-    const onMask = mask & 0x7fff;
-    num &= ~offMask;
-    num |= onMask;
-    return num;
+function applyBitmask(num, mask) {
+  const offMask = mask >> 15 & 32767;
+  const onMask = mask & 32767;
+  num &= ~offMask;
+  num |= onMask;
+  return num;
 }
-export function combineBitmasks(a, b) {
-    const aOff = (a >> 15) & 0x7fff;
-    const aOn = a & 0x7fff;
-    const bOff = (b >> 15) & 0x7fff;
-    const bOn = b & 0x7fff;
-    const combinedOn = (aOn & ~bOff) | bOn;
-    const combinedOff = (aOff & ~bOn) | bOff;
-    return (combinedOff << 15) | combinedOn;
+function combineBitmasks(a, b) {
+  const aOff = a >> 15 & 32767;
+  const aOn = a & 32767;
+  const bOff = b >> 15 & 32767;
+  const bOn = b & 32767;
+  const combinedOn = aOn & ~bOff | bOn;
+  const combinedOff = aOff & ~bOn | bOff;
+  return combinedOff << 15 | combinedOn;
 }
+export {
+  applyBitmask,
+  bit,
+  bitmask,
+  combineBitmasks
+};

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

@@ -1,2 +1,5 @@
-import type { JSONPatchOpHandler } from '../types.js';
-export declare const copy: JSONPatchOpHandler;
+import { JSONPatchOpHandler } from '../types.js';
+
+declare const copy: JSONPatchOpHandler;
+
+export { copy };

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

@@ -1,34 +1,33 @@
-import { getOpData } from '../utils/getOpData.js';
-import { log } from '../utils/log.js';
-import { updateRemovedOps } from '../utils/ops.js';
-import { isArrayPath } from '../utils/paths.js';
-import { updateArrayIndexes } from '../utils/updateArrayIndexes.js';
-import { add } from './add.js';
-export const copy = {
-    like: 'copy',
-    apply(state, path, from) {
-        const [, lastKey, target] = getOpData(state, from);
-        if (target === null) {
-            return `[op:copy] path not found: ${from}`;
-        }
-        return add.apply(state, path, target[lastKey]);
-    },
-    invert(_state, { path }, value, changedObj, isIndex) {
-        if (path.endsWith('/-'))
-            return { op: 'remove', path: path.replace('-', changedObj.length) };
-        else if (isIndex)
-            return { op: 'remove', path };
-        return value === undefined ? { op: 'remove', path } : { op: 'replace', path, value };
-    },
-    transform(state, thisOp, otherOps) {
-        log('Transforming', otherOps, 'against "add"', thisOp);
-        if (isArrayPath(thisOp.path, state)) {
-            // Adjust any operations on the same array by 1 to account for this new entry
-            return updateArrayIndexes(state, thisOp.path, otherOps, 1);
-        }
-        else {
-            // Remove anything that was done at this path since it is being overwritten
-            return updateRemovedOps(state, thisOp.path, otherOps);
-        }
-    },
+import "../../chunk-IZ2YBCUP.js";
+import { getOpData } from "../utils/getOpData.js";
+import { log } from "../utils/log.js";
+import { updateRemovedOps } from "../utils/ops.js";
+import { isArrayPath } from "../utils/paths.js";
+import { updateArrayIndexes } from "../utils/updateArrayIndexes.js";
+import { add } from "./add.js";
+const copy = {
+  like: "copy",
+  apply(state, path, from) {
+    const [, lastKey, target] = getOpData(state, from);
+    if (target === null) {
+      return `[op:copy] path not found: ${from}`;
+    }
+    return add.apply(state, path, target[lastKey]);
+  },
+  invert(_state, { path }, value, changedObj, isIndex) {
+    if (path.endsWith("/-")) return { op: "remove", path: path.replace("-", changedObj.length) };
+    else if (isIndex) return { op: "remove", path };
+    return value === void 0 ? { op: "remove", path } : { op: "replace", path, value };
+  },
+  transform(state, thisOp, otherOps) {
+    log("Transforming", otherOps, 'against "add"', thisOp);
+    if (isArrayPath(thisOp.path, state)) {
+      return updateArrayIndexes(state, thisOp.path, otherOps, 1);
+    } else {
+      return updateRemovedOps(state, thisOp.path, otherOps);
+    }
+  }
+};
+export {
+  copy
 };

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

@@ -1,5 +1,8 @@
-import type { JSONPatchOpHandler } from '../types.js';
+import { JSONPatchOpHandler } from '../types.js';
+
 /**
  * Increment or decrement a number (using `+` or `-`).
  */
-export declare const increment: JSONPatchOpHandler;
+declare const increment: JSONPatchOpHandler;
+
+export { increment };

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

@@ -1,21 +1,22 @@
-import { get } from '../utils/get.js';
-import { updateRemovedOps } from '../utils/ops.js';
-import { replace } from './replace.js';
-/**
- * Increment or decrement a number (using `+` or `-`).
- */
-export const increment = {
-    like: 'replace',
-    apply(state, path, value) {
-        return replace.apply(state, path, (get(state, path) || 0) + value);
-    },
-    transform(state, thisOp, otherOps) {
-        return updateRemovedOps(state, thisOp.path, otherOps, false, true);
-    },
-    invert(state, op, value, changedObj, isIndex) {
-        return replace.invert(state, op, value, changedObj, isIndex);
-    },
-    compose(_state, value1, value2) {
-        return value1 + value2;
-    },
+import "../../chunk-IZ2YBCUP.js";
+import { get } from "../utils/get.js";
+import { updateRemovedOps } from "../utils/ops.js";
+import { replace } from "./replace.js";
+const increment = {
+  like: "replace",
+  apply(state, path, value) {
+    return replace.apply(state, path, (get(state, path) || 0) + value);
+  },
+  transform(state, thisOp, otherOps) {
+    return updateRemovedOps(state, thisOp.path, otherOps, false, true);
+  },
+  invert(state, op, value, changedObj, isIndex) {
+    return replace.invert(state, op, value, changedObj, isIndex);
+  },
+  compose(_state, value1, value2) {
+    return value1 + value2;
+  }
+};
+export {
+  increment
 };

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

@@ -1,21 +1,10 @@
-import type { JSONPatchOpHandlerMap } from '../types.js';
-import { add } from './add.js';
-import { bit } from './bitmask.js';
-import { copy } from './copy.js';
-import { increment } from './increment.js';
-import { move } from './move.js';
-import { remove } from './remove.js';
-import { replace } from './replace.js';
-import { test } from './test.js';
-export { add, bit, copy, increment, move, remove, replace, test };
-export declare function getTypes(custom?: JSONPatchOpHandlerMap): {
-    test: import("../types.js").JSONPatchOpHandler;
-    add: import("../types.js").JSONPatchOpHandler;
-    remove: import("../types.js").JSONPatchOpHandler;
-    replace: import("../types.js").JSONPatchOpHandler;
-    copy: import("../types.js").JSONPatchOpHandler;
-    move: import("../types.js").JSONPatchOpHandler;
-    '@inc': import("../types.js").JSONPatchOpHandler;
-    '@bit': import("../types.js").JSONPatchOpHandler;
-    '@txt': import("../types.js").JSONPatchOpHandler;
-};
+import '../types.js';
+export { add } from './add.js';
+export { bit } from './bitmask.js';
+export { copy } from './copy.js';
+export { increment } from './increment.js';
+export { move } from './move.js';
+export { remove } from './remove.js';
+export { replace } from './replace.js';
+export { test } from './test.js';
+export { g as getTypes } from '../../index-CvQws3AB.js';

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

@@ -1,25 +1,35 @@
-import { add } from './add.js';
-import { bit } from './bitmask.js';
-import { copy } from './copy.js';
-import { increment } from './increment.js';
-import { move } from './move.js';
-import { remove } from './remove.js';
-import { replace } from './replace.js';
-import { test } from './test.js';
-import { text } from './text.js';
-// Export all patch operations
-export { add, bit, copy, increment, move, remove, replace, test };
-export function getTypes(custom) {
-    return {
-        test,
-        add,
-        remove,
-        replace,
-        copy,
-        move,
-        '@inc': increment,
-        '@bit': bit,
-        '@txt': text,
-        ...custom,
-    };
+import "../../chunk-IZ2YBCUP.js";
+import { add } from "./add.js";
+import { bit } from "./bitmask.js";
+import { copy } from "./copy.js";
+import { increment } from "./increment.js";
+import { move } from "./move.js";
+import { remove } from "./remove.js";
+import { replace } from "./replace.js";
+import { test } from "./test.js";
+import { text } from "./text.js";
+function getTypes(custom) {
+  return {
+    test,
+    add,
+    remove,
+    replace,
+    copy,
+    move,
+    "@inc": increment,
+    "@bit": bit,
+    "@txt": text,
+    ...custom
+  };
 }
+export {
+  add,
+  bit,
+  copy,
+  getTypes,
+  increment,
+  move,
+  remove,
+  replace,
+  test
+};

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

@@ -1,2 +1,5 @@
-import type { JSONPatchOpHandler } from '../types.js';
-export declare const move: JSONPatchOpHandler;
+import { JSONPatchOpHandler } from '../types.js';
+
+declare const move: JSONPatchOpHandler;
+
+export { move };