@dabble/patches 0.4.5 → 0.4.6

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

@@ -1,211 +1,145 @@
-import { getOpData } from '../utils/getOpData.js';
-import { getTypeLike } from '../utils/getType.js';
-import { log } from '../utils/log.js';
-import { isAdd, mapAndFilterOps, updateRemovedOps } from '../utils/ops.js';
-import { getArrayPrefixAndIndex, getIndexAndEnd, isArrayPath } from '../utils/paths.js';
-import { getValue, pluckWithShallowCopy } from '../utils/pluck.js';
-import { toArrayIndex } from '../utils/toArrayIndex.js';
-import { updateArrayIndexes } from '../utils/updateArrayIndexes.js';
-import { add } from './add.js';
-export const move = {
-    like: 'move',
-    apply(state, path, from) {
-        if (path === from)
-            return;
-        let value;
-        const [keys, lastKey, target] = getOpData(state, from);
-        if (target === null) {
-            return `[op:move] path not found: ${from}`;
-        }
-        if (Array.isArray(target)) {
-            const index = toArrayIndex(target, lastKey);
-            if (index < 0 || target.length <= index) {
-                return `[op:move] invalid array index: ${path}`;
-            }
-            value = target[index];
-            pluckWithShallowCopy(state, keys, true).splice(index, 1);
-        }
-        else {
-            value = target[lastKey];
-            delete pluckWithShallowCopy(state, keys, true)[lastKey];
-        }
-        return add.apply(state, path, value);
-    },
-    invert(_state, { path, from }) {
-        return { op: 'move', from: path, path: '' + from };
-    },
-    transform(state, thisOp, otherOps) {
-        log('Transforming', otherOps, 'against "move"', thisOp);
-        let removed = false;
-        const { from, path } = thisOp;
-        if (from === path)
-            return otherOps;
-        const [fromPrefix, fromIndex] = getArrayPrefixAndIndex(state, from);
-        const [pathPrefix, pathIndex] = getArrayPrefixAndIndex(state, path);
-        const isPathArray = pathPrefix !== undefined;
-        const isSameArray = isPathArray && pathPrefix === fromPrefix;
-        /*
-        A move needs to do a "remove" and an "add" at once with `from` and `path`. If it is being moved from one location in
-        an array to another in the same array, this needs to be handled special.
-    
-        1. Ops that were added to where the move lands when not an array should be removed just like with an add/copy
-        2. Ops that were added to where the move came from should be translated to the new path
-        3. Ops that are in an array with the moved item after need to be adjusted up or down
-          3a. But, ops that were translated to the new path shouldn't get adjusted up or down by these adjustments
-        */
-        // A move removes the value from one place then adds it to another, update the paths and add a marker to them so
-        // they won't be altered by `updateArrayIndexes`, then remove the markers afterwards
-        otherOps = mapAndFilterOps(otherOps, otherOp => {
-            if (removed) {
-                return otherOp;
-            }
-            const opLike = getTypeLike(state, otherOp);
-            if (opLike === 'remove' && from === otherOp.path) {
-                // Once an operation removes the moved value, the following ops should be working on the old location and not
-                // not the new one. Allow the following operations (which may include add/remove) to affect the old location
-                removed = true;
-            }
-            const original = otherOp;
-            otherOp = updateMovePath(state, otherOp, 'path', from, path, original);
-            otherOp = updateMovePath(state, otherOp, 'from', from, path, original);
-            return otherOp;
-        });
-        // Remove/adjust items that were affected by this item moving (those that actually moved because of it will not
-        // be affected because they have a temporary $ marker prefix that will keep them from doing so)
-        if (isSameArray) {
-            // need special logic when a move is within one array
-            otherOps = updateArrayIndexesForMove(state, fromPrefix, fromIndex, pathIndex, otherOps);
-        }
-        else {
-            // if a move is not within one array, treat it as a remove then add
-            if (isArrayPath(from, state)) {
-                otherOps = updateArrayIndexes(state, from, otherOps, -1);
-            }
-            else {
-                otherOps = updateRemovedOps(state, from, otherOps);
-            }
-            if (isArrayPath(path, state)) {
-                otherOps = updateArrayIndexes(state, path, otherOps, 1);
-            }
-            else {
-                otherOps = updateRemovedOps(state, path, otherOps);
-            }
-        }
-        // Remove the move markers added with `updateMovePath`
-        return mapAndFilterOps(otherOps, removeMoveMarkers);
-    },
-};
-/**
- * Update paths for a move operation, adding a marker so the path will not be altered by array updates.
- */
-function updateMovePath(state, op, pathName, from, to, original) {
-    const path = op[pathName];
-    if (!path)
-        return op; // No adjustment needed on a property that doesn't exist
-    // If a value is being added or copied to the old location it should not be adjusted
-    if (isAdd(state, op, pathName) && op.path === from) {
-        return op;
+import "../../chunk-IZ2YBCUP.js";
+import { getOpData } from "../utils/getOpData.js";
+import { getTypeLike } from "../utils/getType.js";
+import { log } from "../utils/log.js";
+import { isAdd, mapAndFilterOps, updateRemovedOps } from "../utils/ops.js";
+import { getArrayPrefixAndIndex, getIndexAndEnd, isArrayPath } from "../utils/paths.js";
+import { getValue, pluckWithShallowCopy } from "../utils/pluck.js";
+import { toArrayIndex } from "../utils/toArrayIndex.js";
+import { updateArrayIndexes } from "../utils/updateArrayIndexes.js";
+import { add } from "./add.js";
+const move = {
+  like: "move",
+  apply(state, path, from) {
+    if (path === from) return;
+    let value;
+    const [keys, lastKey, target] = getOpData(state, from);
+    if (target === null) {
+      return `[op:move] path not found: ${from}`;
     }
-    // If this path needs to be changed due to a move operation, change it, but prefix it with a $ temporarily so when we
-    // adjust the array indexes to account for this change, we aren't changing this path we JUST set. We will remove the
-    // $ prefix right after we adjust arrays affected by this move.
-    if (path === from || path.indexOf(from + '/') === 0) {
-        if (op === original)
-            op = Object.assign({}, op);
-        log('Moving', op, 'from', from, 'to', to);
-        // Add a marker "$" so this path will not be double-updated by array index updates
-        op[pathName] = '$' + path.replace(from, to);
+    if (Array.isArray(target)) {
+      const index = toArrayIndex(target, lastKey);
+      if (index < 0 || target.length <= index) {
+        return `[op:move] invalid array index: ${path}`;
+      }
+      value = target[index];
+      pluckWithShallowCopy(state, keys, true).splice(index, 1);
+    } else {
+      value = target[lastKey];
+      delete pluckWithShallowCopy(state, keys, true)[lastKey];
+    }
+    return add.apply(state, path, value);
+  },
+  invert(_state, { path, from }) {
+    return { op: "move", from: path, path: "" + from };
+  },
+  transform(state, thisOp, otherOps) {
+    log("Transforming", otherOps, 'against "move"', thisOp);
+    let removed = false;
+    const { from, path } = thisOp;
+    if (from === path) return otherOps;
+    const [fromPrefix, fromIndex] = getArrayPrefixAndIndex(state, from);
+    const [pathPrefix, pathIndex] = getArrayPrefixAndIndex(state, path);
+    const isPathArray = pathPrefix !== void 0;
+    const isSameArray = isPathArray && pathPrefix === fromPrefix;
+    otherOps = mapAndFilterOps(otherOps, (otherOp) => {
+      if (removed) {
+        return otherOp;
+      }
+      const opLike = getTypeLike(state, otherOp);
+      if (opLike === "remove" && from === otherOp.path) {
+        removed = true;
+      }
+      const original = otherOp;
+      otherOp = updateMovePath(state, otherOp, "path", from, path, original);
+      otherOp = updateMovePath(state, otherOp, "from", from, path, original);
+      return otherOp;
+    });
+    if (isSameArray) {
+      otherOps = updateArrayIndexesForMove(state, fromPrefix, fromIndex, pathIndex, otherOps);
+    } else {
+      if (isArrayPath(from, state)) {
+        otherOps = updateArrayIndexes(state, from, otherOps, -1);
+      } else {
+        otherOps = updateRemovedOps(state, from, otherOps);
+      }
+      if (isArrayPath(path, state)) {
+        otherOps = updateArrayIndexes(state, path, otherOps, 1);
+      } else {
+        otherOps = updateRemovedOps(state, path, otherOps);
+      }
     }
+    return mapAndFilterOps(otherOps, removeMoveMarkers);
+  }
+};
+function updateMovePath(state, op, pathName, from, to, original) {
+  const path = op[pathName];
+  if (!path) return op;
+  if (isAdd(state, op, pathName) && op.path === from) {
     return op;
+  }
+  if (path === from || path.indexOf(from + "/") === 0) {
+    if (op === original) op = Object.assign({}, op);
+    log("Moving", op, "from", from, "to", to);
+    op[pathName] = "$" + path.replace(from, to);
+  }
+  return op;
 }
-/**
- * Update array indexes to account for values being added or removed from an array. If the path is not an array index
- * or if nothing is changed then the original array is returned.
- */
 function updateArrayIndexesForMove(state, prefix, fromIndex, pathIndex, otherOps) {
-    // Check ops for any that need to be replaced
-    log(`Shifting array indexes for a move between ${prefix}/${fromIndex} and ${prefix}/${pathIndex}`);
-    return mapAndFilterOps(otherOps, otherOp => {
-        // check for items from the same array that will be affected
-        const fromUpdate = updateArrayPathForMove(state, otherOp, 'from', prefix, fromIndex, pathIndex);
-        const pathUpdate = updateArrayPathForMove(state, otherOp, 'path', prefix, fromIndex, pathIndex);
-        if (!fromUpdate || !pathUpdate)
-            return null;
-        if (fromUpdate !== otherOp || pathUpdate !== otherOp) {
-            otherOp = { ...otherOp, path: pathUpdate.path };
-            if (fromUpdate.from)
-                otherOp.from = fromUpdate.from;
-        }
-        return otherOp;
-    });
+  log(`Shifting array indexes for a move between ${prefix}/${fromIndex} and ${prefix}/${pathIndex}`);
+  return mapAndFilterOps(otherOps, (otherOp) => {
+    const fromUpdate = updateArrayPathForMove(state, otherOp, "from", prefix, fromIndex, pathIndex);
+    const pathUpdate = updateArrayPathForMove(state, otherOp, "path", prefix, fromIndex, pathIndex);
+    if (!fromUpdate || !pathUpdate) return null;
+    if (fromUpdate !== otherOp || pathUpdate !== otherOp) {
+      otherOp = { ...otherOp, path: pathUpdate.path };
+      if (fromUpdate.from) otherOp.from = fromUpdate.from;
+    }
+    return otherOp;
+  });
 }
-/**
- * Get the adjusted path if it is higher, or undefined if not.
- */
 function updateArrayPathForMove(state, otherOp, pathName, prefix, from, to) {
-    const path = otherOp[pathName];
-    if (!path || !path.startsWith(prefix))
+  const path = otherOp[pathName];
+  if (!path || !path.startsWith(prefix)) return otherOp;
+  const min = Math.min(from, to);
+  const max = Math.max(from, to);
+  const [otherIndex, end] = getIndexAndEnd(state, path, prefix.length);
+  if (otherIndex === void 0) return otherOp;
+  const isFinalProp = end === path.length;
+  const opLike = getTypeLike(state, otherOp);
+  if (otherIndex < min || otherIndex > max) {
+    return otherOp;
+  }
+  if (isFinalProp && isAdd(state, otherOp, pathName)) {
+    if (otherIndex === min) {
+      if (min === from) {
         return otherOp;
-    const min = Math.min(from, to);
-    const max = Math.max(from, to);
-    const [otherIndex, end] = getIndexAndEnd(state, path, prefix.length);
-    if (otherIndex === undefined)
-        return otherOp; // if a prop on an array is being set, for e.g.
-    const isFinalProp = end === path.length;
-    const opLike = getTypeLike(state, otherOp);
-    // If this index is not within the movement boundary, don't touch it
-    if (otherIndex < min || otherIndex > max) {
+      } else {
         return otherOp;
+      }
+    } else if (otherIndex === max) {
+      if (max === from) {
+        const fromIndex = getIndexAndEnd(state, otherOp.from, prefix.length)[0];
+        if (opLike === "move" && pathName === "path" && to <= fromIndex && fromIndex < from) return otherOp;
+      } else {
+        return otherOp;
+      }
     }
-    // If the index touches the boundary on an unaffected side, don't touch it
-    if (isFinalProp && isAdd(state, otherOp, pathName)) {
-        /*
-          if the move is from low to high (min is a remove, max is an add) then
-          use the remove logic with an add
-    
-          if the move is from high to low (min is an add, max is a remove) then
-          use the add logic at the bottom
-        */
-        if (otherIndex === min) {
-            if (min === from) {
-                // treat like a remove
-                return otherOp;
-            }
-            else {
-                // treat like an add
-                return otherOp;
-            }
-        }
-        else if (otherIndex === max) {
-            if (max === from) {
-                // treat like a remove
-                const fromIndex = getIndexAndEnd(state, otherOp.from, prefix.length)[0];
-                if (opLike === 'move' && pathName === 'path' && to <= fromIndex && fromIndex < from)
-                    return otherOp;
-                // continue
-            }
-            else {
-                // treat like an add
-                return otherOp;
-            }
-        }
-    }
-    const modifier = from === min ? -1 : 1;
-    const newPath = prefix + (otherIndex + modifier) + path.slice(end);
-    return getValue(state, otherOp, pathName, newPath);
+  }
+  const modifier = from === min ? -1 : 1;
+  const newPath = prefix + (otherIndex + modifier) + path.slice(end);
+  return getValue(state, otherOp, pathName, newPath);
 }
-/**
- * Remove any move markers placed during updateMovePath. This occurs in-place since these objects have already been
- * cloned.
- */
 function removeMoveMarkers(op) {
-    if (op.path[0] === '$') {
-        op.path = op.path.slice(1);
-    }
-    if (op.from && op.from[0] === '$') {
-        op.from = op.from.slice(1);
-    }
-    if (op.from === op.path)
-        return null;
-    return op;
+  if (op.path[0] === "$") {
+    op.path = op.path.slice(1);
+  }
+  if (op.from && op.from[0] === "$") {
+    op.from = op.from.slice(1);
+  }
+  if (op.from === op.path) return null;
+  return op;
 }
+export {
+  move
+};

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

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

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

@@ -1,31 +1,34 @@
-import { getOpData } from '../utils/getOpData.js';
-import { log } from '../utils/log.js';
-import { transformRemove } from '../utils/ops.js';
-import { pluckWithShallowCopy } from '../utils/pluck.js';
-import { toArrayIndex } from '../utils/toArrayIndex.js';
-export const remove = {
-    like: 'remove',
-    apply(state, path) {
-        const [keys, lastKey, target] = getOpData(state, path);
-        if (target === null) {
-            return;
-        }
-        if (Array.isArray(target)) {
-            const index = toArrayIndex(target, lastKey);
-            if (index < 0 || target.length <= index) {
-                return '[op:remove] invalid array index: ' + path;
-            }
-            pluckWithShallowCopy(state, keys).splice(index, 1);
-        }
-        else {
-            delete pluckWithShallowCopy(state, keys)[lastKey];
-        }
-    },
-    invert(_state, { path }, value) {
-        return { op: 'add', path, value };
-    },
-    transform(state, thisOp, otherOps) {
-        log('Transforming', otherOps, 'against "remove"', thisOp);
-        return transformRemove(state, thisOp.path, otherOps, true);
-    },
+import "../../chunk-IZ2YBCUP.js";
+import { getOpData } from "../utils/getOpData.js";
+import { log } from "../utils/log.js";
+import { transformRemove } from "../utils/ops.js";
+import { pluckWithShallowCopy } from "../utils/pluck.js";
+import { toArrayIndex } from "../utils/toArrayIndex.js";
+const remove = {
+  like: "remove",
+  apply(state, path) {
+    const [keys, lastKey, target] = getOpData(state, path);
+    if (target === null) {
+      return;
+    }
+    if (Array.isArray(target)) {
+      const index = toArrayIndex(target, lastKey);
+      if (index < 0 || target.length <= index) {
+        return "[op:remove] invalid array index: " + path;
+      }
+      pluckWithShallowCopy(state, keys).splice(index, 1);
+    } else {
+      delete pluckWithShallowCopy(state, keys)[lastKey];
+    }
+  },
+  invert(_state, { path }, value) {
+    return { op: "add", path, value };
+  },
+  transform(state, thisOp, otherOps) {
+    log("Transforming", otherOps, 'against "remove"', thisOp);
+    return transformRemove(state, thisOp.path, otherOps, true);
+  }
+};
+export {
+  remove
 };

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

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

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

@@ -1,44 +1,46 @@
-import { deepEqual } from '../utils/deepEqual.js';
-import { getOpData } from '../utils/getOpData.js';
-import { log } from '../utils/log.js';
-import { updateRemovedOps } from '../utils/ops.js';
-import { pluckWithShallowCopy } from '../utils/pluck.js';
-import { toArrayIndex } from '../utils/toArrayIndex.js';
-export const replace = {
-    like: 'replace',
-    apply(state, path, value) {
-        if (typeof value === 'undefined') {
-            return '[op:replace] require value, but got undefined';
-        }
-        const [keys, lastKey, target] = getOpData(state, path, true);
-        if (target === null) {
-            return `[op:replace] path not found: ${path}`;
-        }
-        if (Array.isArray(target)) {
-            const index = toArrayIndex(target, lastKey);
-            if (index < 0 || target.length <= index) {
-                return `[op:replace] invalid array index: ${path}`;
-            }
-            if (!deepEqual(target[index], value)) {
-                pluckWithShallowCopy(state, keys, true).splice(index, 1, value);
-            }
-        }
-        else {
-            if (!deepEqual(target[lastKey], value)) {
-                pluckWithShallowCopy(state, keys, true)[lastKey] = value;
-            }
-        }
-    },
-    invert(_state, { path }, value, changedObj) {
-        if (path.endsWith('/-'))
-            path = path.replace('-', changedObj.length);
-        return value === undefined ? { op: 'remove', path } : { op: 'replace', path, value };
-    },
-    transform(state, thisOp, otherOps) {
-        log('Transforming ', otherOps, ' against "replace"', thisOp);
-        return updateRemovedOps(state, thisOp.path, otherOps);
-    },
-    compose(_state, _value1, value2) {
-        return value2;
-    },
+import "../../chunk-IZ2YBCUP.js";
+import { deepEqual } from "../utils/deepEqual.js";
+import { getOpData } from "../utils/getOpData.js";
+import { log } from "../utils/log.js";
+import { updateRemovedOps } from "../utils/ops.js";
+import { pluckWithShallowCopy } from "../utils/pluck.js";
+import { toArrayIndex } from "../utils/toArrayIndex.js";
+const replace = {
+  like: "replace",
+  apply(state, path, value) {
+    if (typeof value === "undefined") {
+      return "[op:replace] require value, but got undefined";
+    }
+    const [keys, lastKey, target] = getOpData(state, path, true);
+    if (target === null) {
+      return `[op:replace] path not found: ${path}`;
+    }
+    if (Array.isArray(target)) {
+      const index = toArrayIndex(target, lastKey);
+      if (index < 0 || target.length <= index) {
+        return `[op:replace] invalid array index: ${path}`;
+      }
+      if (!deepEqual(target[index], value)) {
+        pluckWithShallowCopy(state, keys, true).splice(index, 1, value);
+      }
+    } else {
+      if (!deepEqual(target[lastKey], value)) {
+        pluckWithShallowCopy(state, keys, true)[lastKey] = value;
+      }
+    }
+  },
+  invert(_state, { path }, value, changedObj) {
+    if (path.endsWith("/-")) path = path.replace("-", changedObj.length);
+    return value === void 0 ? { op: "remove", path } : { op: "replace", path, value };
+  },
+  transform(state, thisOp, otherOps) {
+    log("Transforming ", otherOps, ' against "replace"', thisOp);
+    return updateRemovedOps(state, thisOp.path, otherOps);
+  },
+  compose(_state, _value1, value2) {
+    return value2;
+  }
+};
+export {
+  replace
 };

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

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

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

@@ -1,22 +1,26 @@
-import { deepEqual } from '../utils/deepEqual.js';
-import { getOpData } from '../utils/getOpData.js';
-export const test = {
-    like: 'test',
-    apply(state, path, expected) {
-        const [, lastKey, target] = getOpData(state, path);
-        if (target === null) {
-            return `[op:test] path not found: ${path}`;
-        }
-        if (!deepEqual(target[lastKey], expected)) {
-            const a = JSON.stringify(target[lastKey]);
-            const b = JSON.stringify(expected);
-            return `[op:test] not matched: ${a} ${b}`;
-        }
-    },
-    invert() {
-        return undefined;
-    },
-    transform(_state, _other, ops) {
-        return ops;
-    },
+import "../../chunk-IZ2YBCUP.js";
+import { deepEqual } from "../utils/deepEqual.js";
+import { getOpData } from "../utils/getOpData.js";
+const test = {
+  like: "test",
+  apply(state, path, expected) {
+    const [, lastKey, target] = getOpData(state, path);
+    if (target === null) {
+      return `[op:test] path not found: ${path}`;
+    }
+    if (!deepEqual(target[lastKey], expected)) {
+      const a = JSON.stringify(target[lastKey]);
+      const b = JSON.stringify(expected);
+      return `[op:test] not matched: ${a} ${b}`;
+    }
+  },
+  invert() {
+    return void 0;
+  },
+  transform(_state, _other, ops) {
+    return ops;
+  }
+};
+export {
+  test
 };

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

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