@capture.dev/fast-json-patch 3.2.0

package/dist/index.js

@@ -0,0 +1,726 @@
+// src/helpers.ts
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwnProperty(obj, key) {
+  return _hasOwnProperty.call(obj, key);
+}
+function _objectKeys(obj) {
+  if (Array.isArray(obj)) {
+    const keys2 = new Array(obj.length);
+    for (let k = 0; k < keys2.length; k++) {
+      keys2[k] = "" + k;
+    }
+    return keys2;
+  }
+  if (Object.keys) {
+    return Object.keys(obj);
+  }
+  let keys = [];
+  for (let i in obj) {
+    if (hasOwnProperty(obj, i)) {
+      keys.push(i);
+    }
+  }
+  return keys;
+}
+function _deepClone(obj) {
+  switch (typeof obj) {
+    case "object":
+      return JSON.parse(JSON.stringify(obj));
+    //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5
+    case "undefined":
+      return null;
+    //this is how JSON.stringify behaves for array items
+    default:
+      return obj;
+  }
+}
+function isInteger(str) {
+  let i = 0;
+  const len = str.length;
+  let charCode;
+  while (i < len) {
+    charCode = str.charCodeAt(i);
+    if (charCode >= 48 && charCode <= 57) {
+      i++;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function escapePathComponent(path) {
+  if (path.indexOf("/") === -1 && path.indexOf("~") === -1) return path;
+  return path.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapePathComponent(path) {
+  return path.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function hasUndefined(obj) {
+  if (obj === void 0) {
+    return true;
+  }
+  if (obj) {
+    if (Array.isArray(obj)) {
+      for (let i2 = 0, len = obj.length; i2 < len; i2++) {
+        if (hasUndefined(obj[i2])) {
+          return true;
+        }
+      }
+    } else if (typeof obj === "object") {
+      const objKeys = _objectKeys(obj);
+      const objKeysLength = objKeys.length;
+      for (var i = 0; i < objKeysLength; i++) {
+        if (hasUndefined(obj[objKeys[i]])) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function patchErrorMessageFormatter(message, args) {
+  const messageParts = [message];
+  for (const key in args) {
+    const value = typeof args[key] === "object" ? JSON.stringify(args[key], null, 2) : args[key];
+    if (typeof value !== "undefined") {
+      messageParts.push(`${key}: ${value}`);
+    }
+  }
+  return messageParts.join("\n");
+}
+var PatchError = class extends Error {
+  constructor(message, name, index, operation, tree) {
+    super(
+      patchErrorMessageFormatter(message, { name, index, operation, tree })
+    );
+    this.name = name;
+    this.index = index;
+    this.operation = operation;
+    this.tree = tree;
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.message = patchErrorMessageFormatter(message, {
+      name,
+      index,
+      operation,
+      tree
+    });
+  }
+};
+
+// src/core.ts
+var JsonPatchError = PatchError;
+var objOps = {
+  add: function(obj, key, document) {
+    obj[key] = this.value;
+    return { newDocument: document };
+  },
+  remove: function(obj, key, document) {
+    var removed = obj[key];
+    delete obj[key];
+    return { newDocument: document, removed };
+  },
+  replace: function(obj, key, document) {
+    var removed = obj[key];
+    obj[key] = this.value;
+    return { newDocument: document, removed };
+  },
+  move: function(obj, key, document) {
+    let removed = getValueByPointer(document, this.path);
+    if (removed) {
+      removed = _deepClone(removed);
+    }
+    const originalValue = applyOperation(document, {
+      op: "remove",
+      path: this.from
+    }).removed;
+    applyOperation(document, {
+      op: "add",
+      path: this.path,
+      value: originalValue
+    });
+    return { newDocument: document, removed };
+  },
+  copy: function(obj, key, document) {
+    const valueToCopy = getValueByPointer(document, this.from);
+    applyOperation(document, {
+      op: "add",
+      path: this.path,
+      value: _deepClone(valueToCopy)
+    });
+    return { newDocument: document };
+  },
+  test: function(obj, key, document) {
+    return { newDocument: document, test: _areEquals(obj[key], this.value) };
+  },
+  _get: function(obj, key, document) {
+    this.value = obj[key];
+    return { newDocument: document };
+  }
+};
+var arrOps = {
+  add: function(arr, i, document) {
+    if (isInteger(i)) {
+      arr.splice(i, 0, this.value);
+    } else {
+      arr[i] = this.value;
+    }
+    return { newDocument: document, index: i };
+  },
+  remove: function(arr, i, document) {
+    var removedList = arr.splice(i, 1);
+    return { newDocument: document, removed: removedList[0] };
+  },
+  replace: function(arr, i, document) {
+    var removed = arr[i];
+    arr[i] = this.value;
+    return { newDocument: document, removed };
+  },
+  move: objOps.move,
+  copy: objOps.copy,
+  test: objOps.test,
+  _get: objOps._get
+};
+function getValueByPointer(document, pointer) {
+  if (pointer == "") {
+    return document;
+  }
+  var getOriginalDestination = { op: "_get", path: pointer };
+  applyOperation(document, getOriginalDestination);
+  return getOriginalDestination.value;
+}
+function applyOperation(document, operation, validateOperation = false, mutateDocument = true, banPrototypeModifications = true, index = 0) {
+  if (validateOperation) {
+    if (typeof validateOperation == "function") {
+      validateOperation(operation, 0, document, operation.path);
+    } else {
+      validator(operation, 0);
+    }
+  }
+  if (operation.path === "") {
+    let returnValue = { newDocument: document };
+    if (operation.op === "add") {
+      returnValue.newDocument = operation.value;
+      return returnValue;
+    } else if (operation.op === "replace") {
+      returnValue.newDocument = operation.value;
+      returnValue.removed = document;
+      return returnValue;
+    } else if (operation.op === "move" || operation.op === "copy") {
+      returnValue.newDocument = getValueByPointer(document, operation.from);
+      if (operation.op === "move") {
+        returnValue.removed = document;
+      }
+      return returnValue;
+    } else if (operation.op === "test") {
+      returnValue.test = _areEquals(document, operation.value);
+      if (returnValue.test === false) {
+        throw new JsonPatchError(
+          "Test operation failed",
+          "TEST_OPERATION_FAILED",
+          index,
+          operation,
+          document
+        );
+      }
+      returnValue.newDocument = document;
+      return returnValue;
+    } else if (operation.op === "remove") {
+      returnValue.removed = document;
+      returnValue.newDocument = null;
+      return returnValue;
+    } else if (operation.op === "_get") {
+      operation.value = document;
+      return returnValue;
+    } else {
+      if (validateOperation) {
+        throw new JsonPatchError(
+          "Operation `op` property is not one of operations defined in RFC-6902",
+          "OPERATION_OP_INVALID",
+          index,
+          operation,
+          document
+        );
+      } else {
+        return returnValue;
+      }
+    }
+  } else {
+    if (!mutateDocument) {
+      document = _deepClone(document);
+    }
+    const path = operation.path || "";
+    const keys = path.split("/");
+    let obj = document;
+    let t = 1;
+    let len = keys.length;
+    let existingPathFragment = void 0;
+    let key;
+    let validateFunction;
+    if (typeof validateOperation == "function") {
+      validateFunction = validateOperation;
+    } else {
+      validateFunction = validator;
+    }
+    while (true) {
+      key = keys[t];
+      if (key && key.indexOf("~") != -1) {
+        key = unescapePathComponent(key);
+      }
+      if (banPrototypeModifications && (key == "__proto__" || key == "prototype" && t > 0 && keys[t - 1] == "constructor")) {
+        throw new TypeError(
+          "JSON-Patch: modifying `__proto__` or `constructor/prototype` prop is banned for security reasons, if this was on purpose, please set `banPrototypeModifications` flag false and pass it to this function. More info in fast-json-patch README"
+        );
+      }
+      if (validateOperation) {
+        if (existingPathFragment === void 0) {
+          if (obj[key] === void 0) {
+            existingPathFragment = keys.slice(0, t).join("/");
+          } else if (t == len - 1) {
+            existingPathFragment = operation.path;
+          }
+          if (existingPathFragment !== void 0) {
+            validateFunction(operation, 0, document, existingPathFragment);
+          }
+        }
+      }
+      t++;
+      if (Array.isArray(obj)) {
+        if (key === "-") {
+          key = obj.length;
+        } else {
+          if (validateOperation && !isInteger(key)) {
+            throw new JsonPatchError(
+              "Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index",
+              "OPERATION_PATH_ILLEGAL_ARRAY_INDEX",
+              index,
+              operation,
+              document
+            );
+          } else if (isInteger(key)) {
+            key = ~~key;
+          }
+        }
+        if (t >= len) {
+          if (validateOperation && operation.op === "add" && typeof key === "number" && key > obj.length) {
+            throw new JsonPatchError(
+              "The specified index MUST NOT be greater than the number of elements in the array",
+              "OPERATION_VALUE_OUT_OF_BOUNDS",
+              index,
+              operation,
+              document
+            );
+          }
+          const returnValue = arrOps[operation.op].call(
+            operation,
+            obj,
+            key,
+            document
+          );
+          if (returnValue.test === false) {
+            throw new JsonPatchError(
+              "Test operation failed",
+              "TEST_OPERATION_FAILED",
+              index,
+              operation,
+              document
+            );
+          }
+          return returnValue;
+        }
+      } else {
+        if (t >= len) {
+          const returnValue = objOps[operation.op].call(
+            operation,
+            obj,
+            key,
+            document
+          );
+          if (returnValue.test === false) {
+            throw new JsonPatchError(
+              "Test operation failed",
+              "TEST_OPERATION_FAILED",
+              index,
+              operation,
+              document
+            );
+          }
+          return returnValue;
+        }
+      }
+      obj = obj[key];
+      if (validateOperation && t < len && (!obj || typeof obj !== "object")) {
+        throw new JsonPatchError(
+          "Cannot perform operation at the desired path",
+          "OPERATION_PATH_UNRESOLVABLE",
+          index,
+          operation,
+          document
+        );
+      }
+    }
+  }
+}
+function applyPatch(document, patch, validateOperation, mutateDocument = true, banPrototypeModifications = true) {
+  if (validateOperation) {
+    if (!Array.isArray(patch)) {
+      throw new JsonPatchError(
+        "Patch sequence must be an array",
+        "SEQUENCE_NOT_AN_ARRAY"
+      );
+    }
+  }
+  if (!mutateDocument) {
+    document = _deepClone(document);
+  }
+  const results = new Array(patch.length);
+  for (let i = 0, length = patch.length; i < length; i++) {
+    results[i] = applyOperation(
+      document,
+      patch[i],
+      validateOperation,
+      true,
+      banPrototypeModifications,
+      i
+    );
+    document = results[i].newDocument;
+  }
+  results.newDocument = document;
+  return results;
+}
+function applyReducer(document, operation, index) {
+  const operationResult = applyOperation(
+    document,
+    operation
+  );
+  if (operationResult.test === false) {
+    throw new JsonPatchError(
+      "Test operation failed",
+      "TEST_OPERATION_FAILED",
+      index,
+      operation,
+      document
+    );
+  }
+  return operationResult.newDocument;
+}
+function validator(operation, index, document, existingPathFragment) {
+  if (typeof operation !== "object" || operation === null || Array.isArray(operation)) {
+    throw new JsonPatchError(
+      "Operation is not an object",
+      "OPERATION_NOT_AN_OBJECT",
+      index,
+      operation,
+      document
+    );
+  } else if (!objOps[operation.op]) {
+    throw new JsonPatchError(
+      "Operation `op` property is not one of operations defined in RFC-6902",
+      "OPERATION_OP_INVALID",
+      index,
+      operation,
+      document
+    );
+  } else if (typeof operation.path !== "string") {
+    throw new JsonPatchError(
+      "Operation `path` property is not a string",
+      "OPERATION_PATH_INVALID",
+      index,
+      operation,
+      document
+    );
+  } else if (operation.path.indexOf("/") !== 0 && operation.path.length > 0) {
+    throw new JsonPatchError(
+      'Operation `path` property must start with "/"',
+      "OPERATION_PATH_INVALID",
+      index,
+      operation,
+      document
+    );
+  } else if ((operation.op === "move" || operation.op === "copy") && typeof operation.from !== "string") {
+    throw new JsonPatchError(
+      "Operation `from` property is not present (applicable in `move` and `copy` operations)",
+      "OPERATION_FROM_REQUIRED",
+      index,
+      operation,
+      document
+    );
+  } else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && operation.value === void 0) {
+    throw new JsonPatchError(
+      "Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)",
+      "OPERATION_VALUE_REQUIRED",
+      index,
+      operation,
+      document
+    );
+  } else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && hasUndefined(operation.value)) {
+    throw new JsonPatchError(
+      "Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)",
+      "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED",
+      index,
+      operation,
+      document
+    );
+  } else if (document) {
+    if (operation.op == "add") {
+      var pathLen = operation.path.split("/").length;
+      var existingPathLen = existingPathFragment.split("/").length;
+      if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) {
+        throw new JsonPatchError(
+          "Cannot perform an `add` operation at the desired path",
+          "OPERATION_PATH_CANNOT_ADD",
+          index,
+          operation,
+          document
+        );
+      }
+    } else if (operation.op === "replace" || operation.op === "remove" || operation.op === "_get") {
+      if (operation.path !== existingPathFragment) {
+        throw new JsonPatchError(
+          "Cannot perform the operation at a path that does not exist",
+          "OPERATION_PATH_UNRESOLVABLE",
+          index,
+          operation,
+          document
+        );
+      }
+    } else if (operation.op === "move" || operation.op === "copy") {
+      var existingValue = {
+        op: "_get",
+        path: operation.from,
+        value: void 0
+      };
+      var error = validate([existingValue], document);
+      if (error && error.name === "OPERATION_PATH_UNRESOLVABLE") {
+        throw new JsonPatchError(
+          "Cannot perform the operation from a path that does not exist",
+          "OPERATION_FROM_UNRESOLVABLE",
+          index,
+          operation,
+          document
+        );
+      }
+    }
+  }
+}
+function validate(sequence, document, externalValidator) {
+  try {
+    if (!Array.isArray(sequence)) {
+      throw new JsonPatchError(
+        "Patch sequence must be an array",
+        "SEQUENCE_NOT_AN_ARRAY"
+      );
+    }
+    if (document) {
+      applyPatch(
+        _deepClone(document),
+        _deepClone(sequence),
+        externalValidator || true
+      );
+    } else {
+      externalValidator = externalValidator || validator;
+      for (var i = 0; i < sequence.length; i++) {
+        externalValidator(sequence[i], i, document, void 0);
+      }
+    }
+  } catch (e) {
+    if (e instanceof JsonPatchError) {
+      return e;
+    } else {
+      throw e;
+    }
+  }
+}
+function _areEquals(a, b) {
+  if (a === b) return true;
+  if (a && b && typeof a == "object" && typeof b == "object") {
+    var arrA = Array.isArray(a), arrB = Array.isArray(b), i, length, key;
+    if (arrA && arrB) {
+      length = a.length;
+      if (length != b.length) return false;
+      for (i = length; i-- !== 0; ) if (!_areEquals(a[i], b[i])) return false;
+      return true;
+    }
+    if (arrA != arrB) return false;
+    var keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) return false;
+    for (i = length; i-- !== 0; ) if (!b.hasOwnProperty(keys[i])) return false;
+    for (i = length; i-- !== 0; ) {
+      key = keys[i];
+      if (!_areEquals(a[key], b[key])) return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+
+// src/duplex.ts
+var beforeDict = /* @__PURE__ */ new WeakMap();
+var Mirror = class {
+  constructor(obj) {
+    this.observers = /* @__PURE__ */ new Map();
+    this.obj = obj;
+  }
+};
+var ObserverInfo = class {
+  constructor(callback, observer) {
+    this.callback = callback;
+    this.observer = observer;
+  }
+};
+function getMirror(obj) {
+  return beforeDict.get(obj);
+}
+function getObserverFromMirror(mirror, callback) {
+  return mirror.observers.get(callback);
+}
+function removeObserverFromMirror(mirror, observer) {
+  mirror.observers.delete(observer.callback);
+}
+function unobserve(root, observer) {
+  observer.unobserve();
+}
+function observe(obj, callback) {
+  var patches = [];
+  var observer;
+  var mirror = getMirror(obj);
+  if (!mirror) {
+    mirror = new Mirror(obj);
+    beforeDict.set(obj, mirror);
+  } else {
+    const observerInfo = getObserverFromMirror(mirror, callback);
+    observer = observerInfo && observerInfo.observer;
+  }
+  if (observer) {
+    return observer;
+  }
+  observer = {};
+  mirror.value = _deepClone(obj);
+  if (callback) {
+    observer.callback = callback;
+    observer.next = null;
+    var dirtyCheck = () => {
+      generate(observer);
+    };
+    var fastCheck = () => {
+      clearTimeout(observer.next);
+      observer.next = setTimeout(dirtyCheck);
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("mouseup", fastCheck);
+      window.addEventListener("keyup", fastCheck);
+      window.addEventListener("mousedown", fastCheck);
+      window.addEventListener("keydown", fastCheck);
+      window.addEventListener("change", fastCheck);
+    }
+  }
+  observer.patches = patches;
+  observer.object = obj;
+  observer.unobserve = () => {
+    generate(observer);
+    clearTimeout(observer.next);
+    removeObserverFromMirror(mirror, observer);
+    if (typeof window !== "undefined") {
+      window.removeEventListener("mouseup", fastCheck);
+      window.removeEventListener("keyup", fastCheck);
+      window.removeEventListener("mousedown", fastCheck);
+      window.removeEventListener("keydown", fastCheck);
+      window.removeEventListener("change", fastCheck);
+    }
+  };
+  mirror.observers.set(callback, new ObserverInfo(callback, observer));
+  return observer;
+}
+function generate(observer, invertible = false) {
+  var mirror = beforeDict.get(observer.object);
+  _generate(mirror.value, observer.object, observer.patches, "", invertible);
+  if (observer.patches.length) {
+    applyPatch(mirror.value, observer.patches);
+  }
+  var temp = observer.patches;
+  if (temp.length > 0) {
+    observer.patches = [];
+    if (observer.callback) {
+      observer.callback(temp);
+    }
+  }
+  return temp;
+}
+function _generate(mirror, obj, patches, path, invertible) {
+  if (obj === mirror) {
+    return;
+  }
+  if (typeof obj.toJSON === "function") {
+    obj = obj.toJSON();
+  }
+  var newKeys = _objectKeys(obj);
+  var oldKeys = _objectKeys(mirror);
+  var changed = false;
+  var deleted = false;
+  for (var t = oldKeys.length - 1; t >= 0; t--) {
+    var key = oldKeys[t];
+    var oldVal = mirror[key];
+    if (hasOwnProperty(obj, key) && !(obj[key] === void 0 && oldVal !== void 0 && Array.isArray(obj) === false)) {
+      var newVal = obj[key];
+      if (typeof oldVal == "object" && oldVal != null && typeof newVal == "object" && newVal != null && Array.isArray(oldVal) === Array.isArray(newVal)) {
+        _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key), invertible);
+      } else {
+        if (oldVal !== newVal) {
+          changed = true;
+          if (invertible) {
+            patches.push({ op: "test", path: path + "/" + escapePathComponent(key), value: _deepClone(oldVal) });
+          }
+          patches.push({ op: "replace", path: path + "/" + escapePathComponent(key), value: _deepClone(newVal) });
+        }
+      }
+    } else if (Array.isArray(mirror) === Array.isArray(obj)) {
+      if (invertible) {
+        patches.push({ op: "test", path: path + "/" + escapePathComponent(key), value: _deepClone(oldVal) });
+      }
+      patches.push({ op: "remove", path: path + "/" + escapePathComponent(key) });
+      deleted = true;
+    } else {
+      if (invertible) {
+        patches.push({ op: "test", path, value: mirror });
+      }
+      patches.push({ op: "replace", path, value: obj });
+      changed = true;
+    }
+  }
+  if (!deleted && newKeys.length == oldKeys.length) {
+    return;
+  }
+  for (var t = 0; t < newKeys.length; t++) {
+    var key = newKeys[t];
+    if (!hasOwnProperty(mirror, key) && obj[key] !== void 0) {
+      patches.push({ op: "add", path: path + "/" + escapePathComponent(key), value: _deepClone(obj[key]) });
+    }
+  }
+}
+function compare(tree1, tree2, invertible = false) {
+  var patches = [];
+  _generate(tree1, tree2, patches, "", invertible);
+  return patches;
+}
+export {
+  PatchError as JsonPatchError,
+  _areEquals,
+  applyOperation,
+  applyPatch,
+  applyReducer,
+  compare,
+  _deepClone as deepClone,
+  escapePathComponent,
+  generate,
+  getValueByPointer,
+  observe,
+  unescapePathComponent,
+  unobserve,
+  validate,
+  validator
+};
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2021 Joachim Wester
+ * MIT license
+ */