@valbuild/core 0.12.0

package/patch/dist/valbuild-core-patch.esm.js

@@ -0,0 +1,431 @@
+import { b as _typeof, c as _slicedToArray, a as _createClass, _ as _classCallCheck, d as _toConsumableArray } from '../../dist/createClass-012eebbf.esm.js';
+import { f as isNonEmpty, e as err, o as ok, m as map, g as flatMap, i as isErr, h as flatMapReduce, j as filterOrElse, k as mapErr, l as map$1, n as all, p as flatten, q as allT } from '../../dist/result-b96df128.esm.js';
+import { p as pipe } from '../../dist/util-18613e99.esm.js';
+import { P as PatchError } from '../../dist/ops-6fae92a1.esm.js';
+export { P as PatchError } from '../../dist/ops-6fae92a1.esm.js';
+
+function isNotRoot(path) {
+  return isNonEmpty(path);
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (_typeof(a) === "object" && _typeof(b) === "object" && a !== null && b !== null) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      for (var i = 0; i < a.length; ++i) {
+        if (!deepEqual(a[i], b[i])) return false;
+      }
+      return true;
+    } else if (!Array.isArray(a) && !Array.isArray(b)) {
+      var aEntries = Object.entries(a);
+      // If the objects have a different amount of keys, they cannot be equal
+      if (aEntries.length !== Object.keys(b).length) return false;
+      for (var _i = 0, _aEntries = aEntries; _i < _aEntries.length; _i++) {
+        var _aEntries$_i = _slicedToArray(_aEntries[_i], 2),
+          key = _aEntries$_i[0],
+          aValue = _aEntries$_i[1];
+        // b must be a JSON object, so the only way for the bValue to be
+        // undefined is if the key is unset
+        var bValue = b[key];
+        if (bValue === undefined) return false;
+        if (!deepEqual(aValue, bValue)) return false;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function deepClone(value) {
+  if (Array.isArray(value)) {
+    return value.map(deepClone);
+  } else if (_typeof(value) === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      return [key, deepClone(value)];
+    }));
+  } else {
+    return value;
+  }
+}
+function parseAndValidateArrayIndex(value) {
+  if (!/^(0|[1-9][0-9]*)$/g.test(value)) {
+    return err(new PatchError("Invalid array index \"".concat(value, "\"")));
+  }
+  return ok(Number(value));
+}
+
+function parseAndValidateArrayInsertIndex(key, nodes) {
+  if (key === "-") {
+    return ok(nodes.length);
+  }
+  return pipe(parseAndValidateArrayIndex(key), filterOrElse(function (index) {
+    return index <= nodes.length;
+  }, function () {
+    return new PatchError("Array index out of bounds");
+  }));
+}
+function parseAndValidateArrayInboundsIndex(key, nodes) {
+  return pipe(parseAndValidateArrayIndex(key), filterOrElse(function (index) {
+    return index < nodes.length;
+  }, function () {
+    return new PatchError("Array index out of bounds");
+  }));
+}
+function replaceInNode(node, key, value) {
+  if (Array.isArray(node)) {
+    return pipe(parseAndValidateArrayInboundsIndex(key, node), map(function (index) {
+      var replaced = node[index];
+      node[index] = value;
+      return replaced;
+    }));
+  } else if (_typeof(node) === "object" && node !== null) {
+    // Prototype pollution protection
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      var _replaced = node[key];
+      node[key] = value;
+      return ok(_replaced);
+    } else {
+      return err(new PatchError("Cannot replace object element which does not exist"));
+    }
+  }
+  return err(new PatchError("Cannot replace in non-object/array"));
+}
+function replaceAtPath(document, path, value) {
+  if (isNotRoot(path)) {
+    return pipe(getPointerFromPath(document, path), flatMap(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        node = _ref2[0],
+        key = _ref2[1];
+      return replaceInNode(node, key, value);
+    }), map(function (replaced) {
+      return [document, replaced];
+    }));
+  } else {
+    return ok([value, document]);
+  }
+}
+function getFromNode(node, key) {
+  if (Array.isArray(node)) {
+    return pipe(parseAndValidateArrayIndex(key), flatMap(function (index) {
+      if (index >= node.length) {
+        return err(new PatchError("Array index out of bounds"));
+      } else {
+        return ok(node[index]);
+      }
+    }));
+  } else if (_typeof(node) === "object" && node !== null) {
+    // Prototype pollution protection
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      return ok(node[key]);
+    } else {
+      return ok(undefined);
+    }
+  }
+  return err(new PatchError("Cannot access non-object/array"));
+}
+function getPointerFromPath(node, path) {
+  var targetNode = node;
+  var key = path[0];
+  for (var i = 0; i < path.length - 1; ++i, key = path[i]) {
+    var childNode = getFromNode(targetNode, key);
+    if (isErr(childNode)) {
+      return childNode;
+    }
+    if (childNode.value === undefined) {
+      return err(new PatchError("Path refers to non-existing object/array"));
+    }
+    targetNode = childNode.value;
+  }
+  return ok([targetNode, key]);
+}
+function getAtPath(node, path) {
+  return pipe(path, flatMapReduce(function (node, key) {
+    return pipe(getFromNode(node, key), filterOrElse(function (childNode) {
+      return childNode !== undefined;
+    }, function () {
+      return new PatchError("Path refers to non-existing object/array");
+    }));
+  }, node));
+}
+function removeFromNode(node, key) {
+  if (Array.isArray(node)) {
+    return pipe(parseAndValidateArrayInboundsIndex(key, node), map(function (index) {
+      var _node$splice = node.splice(index, 1),
+        _node$splice2 = _slicedToArray(_node$splice, 1),
+        removed = _node$splice2[0];
+      return removed;
+    }));
+  } else if (_typeof(node) === "object" && node !== null) {
+    // Prototype pollution protection
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      var removed = node[key];
+      delete node[key];
+      return ok(removed);
+    }
+  }
+  return err(new PatchError("Cannot remove from non-object/array"));
+}
+function removeAtPath(document, path) {
+  return pipe(getPointerFromPath(document, path), flatMap(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      node = _ref4[0],
+      key = _ref4[1];
+    return removeFromNode(node, key);
+  }));
+}
+function addToNode(node, key, value) {
+  if (Array.isArray(node)) {
+    return pipe(parseAndValidateArrayInsertIndex(key, node), map(function (index) {
+      node.splice(index, 0, value);
+      return undefined;
+    }));
+  } else if (_typeof(node) === "object" && node !== null) {
+    var _replaced2;
+    // Prototype pollution protection
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      _replaced2 = node[key];
+    }
+    node[key] = value;
+    return ok(_replaced2);
+  }
+  return err(new PatchError("Cannot add to non-object/array"));
+}
+function addAtPath(document, path, value) {
+  if (isNotRoot(path)) {
+    return pipe(getPointerFromPath(document, path), flatMap(function (_ref5) {
+      var _ref6 = _slicedToArray(_ref5, 2),
+        node = _ref6[0],
+        key = _ref6[1];
+      return addToNode(node, key, value);
+    }), map(function (replaced) {
+      return [document, replaced];
+    }));
+  } else {
+    return ok([value, document]);
+  }
+}
+function pickDocument(_ref7) {
+  var _ref8 = _slicedToArray(_ref7, 1),
+    document = _ref8[0];
+  return document;
+}
+var JSONOps = /*#__PURE__*/function () {
+  function JSONOps() {
+    _classCallCheck(this, JSONOps);
+  }
+  _createClass(JSONOps, [{
+    key: "get",
+    value: function get(document, path) {
+      return getAtPath(document, path);
+    }
+  }, {
+    key: "add",
+    value: function add(document, path, value) {
+      return pipe(addAtPath(document, path, value), map(pickDocument));
+    }
+  }, {
+    key: "remove",
+    value: function remove(document, path) {
+      return pipe(removeAtPath(document, path), map(function () {
+        return document;
+      }));
+    }
+  }, {
+    key: "replace",
+    value: function replace(document, path, value) {
+      return pipe(replaceAtPath(document, path, value), map(pickDocument));
+    }
+  }, {
+    key: "move",
+    value: function move(document, from, path) {
+      return pipe(removeAtPath(document, from), flatMap(function (removed) {
+        return addAtPath(document, path, removed);
+      }), map(pickDocument));
+    }
+  }, {
+    key: "copy",
+    value: function copy(document, from, path) {
+      return pipe(getAtPath(document, from), flatMap(function (value) {
+        return addAtPath(document, path, deepClone(value));
+      }), map(pickDocument));
+    }
+  }, {
+    key: "test",
+    value: function test(document, path, value) {
+      return pipe(getAtPath(document, path), map(function (documentValue) {
+        return deepEqual(value, documentValue);
+      }));
+    }
+  }]);
+  return JSONOps;
+}();
+
+function parseJSONPointerReferenceToken(value) {
+  if (value.endsWith("~")) {
+    return undefined;
+  }
+  try {
+    return value.replace(/~./, function (escaped) {
+      switch (escaped) {
+        case "~0":
+          return "~";
+        case "~1":
+          return "/";
+      }
+      throw new Error();
+    });
+  } catch (e) {
+    return undefined;
+  }
+}
+function parseJSONPointer(pointer) {
+  if (pointer === "/") return ok([]);
+  if (!pointer.startsWith("/")) return err("JSON pointer must start with /");
+  var tokens = pointer.substring(1).split("/").map(parseJSONPointerReferenceToken);
+  if (tokens.every(function (token) {
+    return token !== undefined;
+  })) {
+    return ok(tokens);
+  } else {
+    return err("Invalid JSON pointer escape sequence");
+  }
+}
+function formatJSONPointerReferenceToken(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function formatJSONPointer(path) {
+  return "/".concat(path.map(formatJSONPointerReferenceToken).join("/"));
+}
+
+/**
+ * A signifies an issue that makes a PatchJSON or an OperationJSON invalid.
+ * Unlike PatchError, a StaticPatchIssue indicates an issue with the patch
+ * document itself; it is independent of any document which the patch or
+ * might be applied to.
+ */
+
+function prefixIssuePath(prefix, _ref) {
+  var path = _ref.path,
+    message = _ref.message;
+  return {
+    path: [prefix].concat(_toConsumableArray(path)),
+    message: message
+  };
+}
+function createIssueAtPath(path) {
+  return function (message) {
+    return {
+      path: path,
+      message: message
+    };
+  };
+}
+function isProperPathPrefix(prefix, path) {
+  if (prefix.length >= path.length) {
+    // A proper prefix cannot be longer or have the same length as the path
+    return false;
+  }
+  for (var i = 0; i < prefix.length; ++i) {
+    if (prefix[i] !== path[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function parseOperation(operation) {
+  var path = parseJSONPointer(operation.path);
+  switch (operation.op) {
+    case "add":
+    case "replace":
+    case "test":
+      return pipe(path, mapErr(function (error) {
+        return [createIssueAtPath(["path"])(error)];
+      }), map(function (path) {
+        return {
+          op: operation.op,
+          path: path,
+          value: operation.value
+        };
+      }));
+    case "remove":
+      return pipe(path, filterOrElse(isNonEmpty, function () {
+        return "Cannot remove root";
+      }), mapErr(function (error) {
+        return [createIssueAtPath(["path"])(error)];
+      }), map(function (path) {
+        return {
+          op: operation.op,
+          path: path
+        };
+      }));
+    case "move":
+      return pipe(allT([pipe(parseJSONPointer(operation.from), filterOrElse(isNonEmpty, function () {
+        return "Cannot move root";
+      }), mapErr(createIssueAtPath(["from"]))), pipe(path, mapErr(createIssueAtPath(["path"])))]), filterOrElse(function (_ref2) {
+        var _ref3 = _slicedToArray(_ref2, 2),
+          from = _ref3[0],
+          path = _ref3[1];
+        return !isProperPathPrefix(from, path);
+      }, function () {
+        return [createIssueAtPath(["from"])("Cannot be a proper prefix of path")];
+      }), map(function (_ref4) {
+        var _ref5 = _slicedToArray(_ref4, 2),
+          from = _ref5[0],
+          path = _ref5[1];
+        return {
+          op: operation.op,
+          from: from,
+          path: path
+        };
+      }));
+    case "copy":
+      return pipe(allT([pipe(parseJSONPointer(operation.from), mapErr(createIssueAtPath(["from"]))), pipe(path, mapErr(createIssueAtPath(["path"])))]), map(function (_ref6) {
+        var _ref7 = _slicedToArray(_ref6, 2),
+          from = _ref7[0],
+          path = _ref7[1];
+        return {
+          op: operation.op,
+          from: from,
+          path: path
+        };
+      }));
+  }
+}
+function parsePatch(patch) {
+  return pipe(patch.map(parseOperation).map(mapErr(map$1(function (error, index) {
+    return prefixIssuePath(index.toString(), error);
+  }))), all, mapErr(flatten));
+}
+
+function apply(document, ops, op) {
+  switch (op.op) {
+    case "add":
+      return ops.add(document, op.path, op.value);
+    case "remove":
+      return ops.remove(document, op.path);
+    case "replace":
+      return ops.replace(document, op.path, op.value);
+    case "move":
+      return ops.move(document, op.from, op.path);
+    case "copy":
+      return ops.copy(document, op.from, op.path);
+    case "test":
+      {
+        if (!ops.test(document, op.path, op.value)) {
+          return err(new PatchError("Test failed"));
+        }
+        return ok(document);
+      }
+  }
+}
+function applyPatch(document, ops, patch) {
+  return pipe(patch, flatMapReduce(function (doc, op) {
+    return apply(doc, ops, op);
+  }, document));
+}
+
+export { JSONOps, applyPatch, deepClone, deepEqual, formatJSONPointer, isNotRoot, parseAndValidateArrayIndex, parseJSONPointer, parsePatch };

package/patch/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/valbuild-core-patch.cjs.js",
+  "module": "dist/valbuild-core-patch.esm.js"
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "isolatedModules": true,
+    "noEmit": true
+  }
+}