@valbuild/core 0.61.0 → 0.62.1

package/patch/dist/valbuild-core-patch.cjs.prod.js

@@ -2,10 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('../../dist/index-f2552460.cjs.prod.js');
+var expr_dist_valbuildCoreExpr = require('../../dist/index-596f28bb.cjs.prod.js');
 var result = require('../../dist/result-26f67b40.cjs.prod.js');
 var util = require('../../dist/util-030d8a1f.cjs.prod.js');
-var ops = require('../../dist/ops-92570725.cjs.prod.js');
 
 function isNotRoot(path) {
   return result.isNonEmpty(path);
@@ -14,7 +13,7 @@ function deepEqual(a, b) {
   if (a === b) {
     return true;
   }
-  if (index._typeof(a) === "object" && index._typeof(b) === "object" && a !== null && b !== null) {
+  if (expr_dist_valbuildCoreExpr._typeof(a) === "object" && expr_dist_valbuildCoreExpr._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) {
@@ -26,7 +25,7 @@ function deepEqual(a, b) {
       // 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 = index._slicedToArray(_aEntries[_i], 2),
+        var _aEntries$_i = expr_dist_valbuildCoreExpr._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
@@ -43,9 +42,9 @@ function deepEqual(a, b) {
 function deepClone(value) {
   if (Array.isArray(value)) {
     return value.map(deepClone);
-  } else if (index._typeof(value) === "object" && value !== null) {
+  } else if (expr_dist_valbuildCoreExpr._typeof(value) === "object" && value !== null) {
     return Object.fromEntries(Object.entries(value).map(function (_ref) {
-      var _ref2 = index._slicedToArray(_ref, 2),
+      var _ref2 = expr_dist_valbuildCoreExpr._slicedToArray(_ref, 2),
         key = _ref2[0],
         value = _ref2[1];
       return [key, deepClone(value)];
@@ -56,14 +55,14 @@ function deepClone(value) {
 }
 function parseAndValidateArrayIndex(value) {
   if (!/^(0|[1-9][0-9]*)$/g.test(value)) {
-    return result.err(new ops.PatchError("Invalid array index \"".concat(value, "\"")));
+    return result.err(new expr_dist_valbuildCoreExpr.PatchError("Invalid array index \"".concat(value, "\"")));
   }
   return result.ok(Number(value));
 }
 function sourceToPatchPath(sourcePath) {
-  var _splitModuleIdAndModu = ops.splitModuleIdAndModulePath(sourcePath),
-    _splitModuleIdAndModu2 = index._slicedToArray(_splitModuleIdAndModu, 2),
-    modulePath = _splitModuleIdAndModu2[1];
+  var _splitModuleFilePathA = expr_dist_valbuildCoreExpr.splitModuleFilePathAndModulePath(sourcePath),
+    _splitModuleFilePathA2 = expr_dist_valbuildCoreExpr._slicedToArray(_splitModuleFilePathA, 2),
+    modulePath = _splitModuleFilePathA2[1];
   return modulePath.split(".").map(function (p) {
     return JSON.parse(p).toString();
   });
@@ -76,14 +75,14 @@ function parseAndValidateArrayInsertIndex(key, nodes) {
   return util.pipe(parseAndValidateArrayIndex(key), result.filterOrElse(function (index) {
     return index <= nodes.length;
   }, function () {
-    return new ops.PatchError("Array index out of bounds");
+    return new expr_dist_valbuildCoreExpr.PatchError("Array index out of bounds");
   }));
 }
 function parseAndValidateArrayInboundsIndex(key, nodes) {
   return util.pipe(parseAndValidateArrayIndex(key), result.filterOrElse(function (index) {
     return index < nodes.length;
   }, function () {
-    return new ops.PatchError("Array index out of bounds");
+    return new expr_dist_valbuildCoreExpr.PatchError("Array index out of bounds");
   }));
 }
 function replaceInNode(node, key, value) {
@@ -93,25 +92,22 @@ function replaceInNode(node, key, value) {
       node[index] = value;
       return replaced;
     }));
-  } else if (index._typeof(node) === "object" && node !== null) {
+  } else if (expr_dist_valbuildCoreExpr._typeof(node) === "object" && node !== null) {
     // Prototype pollution protection
     if (Object.prototype.hasOwnProperty.call(node, key)) {
       var _replaced = node[key];
       node[key] = value;
       return result.ok(_replaced);
     } else {
-      console.log({
-        node: node
-      });
-      return result.err(new ops.PatchError("Cannot replace object element which does not exist"));
+      return result.err(new expr_dist_valbuildCoreExpr.PatchError("Cannot replace object element which does not exist"));
     }
   }
-  return result.err(new ops.PatchError("Cannot replace in non-object/array"));
+  return result.err(new expr_dist_valbuildCoreExpr.PatchError("Cannot replace in non-object/array"));
 }
 function replaceAtPath(document, path, value) {
   if (isNotRoot(path)) {
     return util.pipe(getPointerFromPath(document, path), result.flatMap(function (_ref) {
-      var _ref2 = index._slicedToArray(_ref, 2),
+      var _ref2 = expr_dist_valbuildCoreExpr._slicedToArray(_ref, 2),
         node = _ref2[0],
         key = _ref2[1];
       return replaceInNode(node, key, value);
@@ -126,12 +122,12 @@ function getFromNode(node, key) {
   if (Array.isArray(node)) {
     return util.pipe(parseAndValidateArrayIndex(key), result.flatMap(function (index) {
       if (index >= node.length) {
-        return result.err(new ops.PatchError("Array index out of bounds"));
+        return result.err(new expr_dist_valbuildCoreExpr.PatchError("Array index out of bounds"));
       } else {
         return result.ok(node[index]);
       }
     }));
-  } else if (index._typeof(node) === "object" && node !== null) {
+  } else if (expr_dist_valbuildCoreExpr._typeof(node) === "object" && node !== null) {
     // Prototype pollution protection
     if (Object.prototype.hasOwnProperty.call(node, key)) {
       return result.ok(node[key]);
@@ -139,7 +135,7 @@ function getFromNode(node, key) {
       return result.ok(undefined);
     }
   }
-  return result.err(new ops.PatchError("Cannot access non-object/array"));
+  return result.err(new expr_dist_valbuildCoreExpr.PatchError("Cannot access non-object/array"));
 }
 function getPointerFromPath(node, path) {
   var targetNode = node;
@@ -150,7 +146,7 @@ function getPointerFromPath(node, path) {
       return childNode;
     }
     if (childNode.value === undefined) {
-      return result.err(new ops.PatchError("Path refers to non-existing object/array"));
+      return result.err(new expr_dist_valbuildCoreExpr.PatchError("Path refers to non-existing object/array"));
     }
     targetNode = childNode.value;
   }
@@ -161,19 +157,19 @@ function getAtPath(node, path) {
     return util.pipe(getFromNode(node, key), result.filterOrElse(function (childNode) {
       return childNode !== undefined;
     }, function () {
-      return new ops.PatchError("Path refers to non-existing object/array");
+      return new expr_dist_valbuildCoreExpr.PatchError("Path refers to non-existing object/array");
     }));
   }, node));
 }
 function removeFromNode(node, key) {
   if (Array.isArray(node)) {
-    return util.pipe(parseAndValidateArrayInboundsIndex(key, node), result.map(function (index$1) {
-      var _node$splice = node.splice(index$1, 1),
-        _node$splice2 = index._slicedToArray(_node$splice, 1),
+    return util.pipe(parseAndValidateArrayInboundsIndex(key, node), result.map(function (index) {
+      var _node$splice = node.splice(index, 1),
+        _node$splice2 = expr_dist_valbuildCoreExpr._slicedToArray(_node$splice, 1),
         removed = _node$splice2[0];
       return removed;
     }));
-  } else if (index._typeof(node) === "object" && node !== null) {
+  } else if (expr_dist_valbuildCoreExpr._typeof(node) === "object" && node !== null) {
     // Prototype pollution protection
     if (Object.prototype.hasOwnProperty.call(node, key)) {
       var removed = node[key];
@@ -181,11 +177,11 @@ function removeFromNode(node, key) {
       return result.ok(removed);
     }
   }
-  return result.err(new ops.PatchError("Cannot remove from non-object/array"));
+  return result.err(new expr_dist_valbuildCoreExpr.PatchError("Cannot remove from non-object/array"));
 }
 function removeAtPath(document, path) {
   return util.pipe(getPointerFromPath(document, path), result.flatMap(function (_ref3) {
-    var _ref4 = index._slicedToArray(_ref3, 2),
+    var _ref4 = expr_dist_valbuildCoreExpr._slicedToArray(_ref3, 2),
       node = _ref4[0],
       key = _ref4[1];
     return removeFromNode(node, key);
@@ -197,7 +193,7 @@ function addToNode(node, key, value) {
       node.splice(index, 0, value);
       return undefined;
     }));
-  } else if (index._typeof(node) === "object" && node !== null) {
+  } else if (expr_dist_valbuildCoreExpr._typeof(node) === "object" && node !== null) {
     var _replaced2;
     // Prototype pollution protection
     if (Object.prototype.hasOwnProperty.call(node, key)) {
@@ -206,12 +202,12 @@ function addToNode(node, key, value) {
     node[key] = value;
     return result.ok(_replaced2);
   }
-  return result.err(new ops.PatchError("Cannot add to non-object/array"));
+  return result.err(new expr_dist_valbuildCoreExpr.PatchError("Cannot add to non-object/array"));
 }
 function addAtPath(document, path, value) {
   if (isNotRoot(path)) {
     return util.pipe(getPointerFromPath(document, path), result.flatMap(function (_ref5) {
-      var _ref6 = index._slicedToArray(_ref5, 2),
+      var _ref6 = expr_dist_valbuildCoreExpr._slicedToArray(_ref5, 2),
         node = _ref6[0],
         key = _ref6[1];
       return addToNode(node, key, value);
@@ -223,15 +219,15 @@ function addAtPath(document, path, value) {
   }
 }
 function pickDocument(_ref7) {
-  var _ref8 = index._slicedToArray(_ref7, 1),
+  var _ref8 = expr_dist_valbuildCoreExpr._slicedToArray(_ref7, 1),
     document = _ref8[0];
   return document;
 }
 var JSONOps = /*#__PURE__*/function () {
   function JSONOps() {
-    index._classCallCheck(this, JSONOps);
+    expr_dist_valbuildCoreExpr._classCallCheck(this, JSONOps);
   }
-  index._createClass(JSONOps, [{
+  expr_dist_valbuildCoreExpr._createClass(JSONOps, [{
     key: "get",
     value: function get(document, path) {
       return getAtPath(document, path);
@@ -326,7 +322,7 @@ function prefixIssuePath(prefix, _ref) {
   var path = _ref.path,
     message = _ref.message;
   return {
-    path: [prefix].concat(index._toConsumableArray(path)),
+    path: [prefix].concat(expr_dist_valbuildCoreExpr._toConsumableArray(path)),
     message: message
   };
 }
@@ -391,14 +387,14 @@ function parseOperation(operation) {
       return util.pipe(result.allT([util.pipe(parseJSONPointer(operation.from), result.filterOrElse(result.isNonEmpty, function () {
         return "Cannot move root";
       }), result.mapErr(createIssueAtPath(["from"]))), util.pipe(path, result.mapErr(createIssueAtPath(["path"])))]), result.filterOrElse(function (_ref2) {
-        var _ref3 = index._slicedToArray(_ref2, 2),
+        var _ref3 = expr_dist_valbuildCoreExpr._slicedToArray(_ref2, 2),
           from = _ref3[0],
           path = _ref3[1];
         return !isProperPathPrefix(from, path);
       }, function () {
         return [createIssueAtPath(["from"])("Cannot be a proper prefix of path")];
       }), result.map(function (_ref4) {
-        var _ref5 = index._slicedToArray(_ref4, 2),
+        var _ref5 = expr_dist_valbuildCoreExpr._slicedToArray(_ref4, 2),
           from = _ref5[0],
           path = _ref5[1];
         return {
@@ -409,7 +405,7 @@ function parseOperation(operation) {
       }));
     case "copy":
       return util.pipe(result.allT([util.pipe(parseJSONPointer(operation.from), result.mapErr(createIssueAtPath(["from"]))), util.pipe(path, result.mapErr(createIssueAtPath(["path"])))]), result.map(function (_ref6) {
-        var _ref7 = index._slicedToArray(_ref6, 2),
+        var _ref7 = expr_dist_valbuildCoreExpr._slicedToArray(_ref6, 2),
           from = _ref7[0],
           path = _ref7[1];
         return {
@@ -426,28 +422,28 @@ function parsePatch(patch) {
   }))), result.all, result.mapErr(result.flatten));
 }
 
-function apply(document, ops$1, op) {
+function apply(document, ops, op) {
   switch (op.op) {
     case "add":
-      return ops$1.add(document, op.path, op.value);
+      return ops.add(document, op.path, op.value);
     case "remove":
-      return ops$1.remove(document, op.path);
+      return ops.remove(document, op.path);
     case "replace":
-      return ops$1.replace(document, op.path, op.value);
+      return ops.replace(document, op.path, op.value);
     case "move":
-      return ops$1.move(document, op.from, op.path);
+      return ops.move(document, op.from, op.path);
     case "copy":
-      return ops$1.copy(document, op.from, op.path);
+      return ops.copy(document, op.from, op.path);
     case "test":
       {
-        if (!ops$1.test(document, op.path, op.value)) {
-          return result.err(new ops.PatchError("Test failed"));
+        if (!ops.test(document, op.path, op.value)) {
+          return result.err(new expr_dist_valbuildCoreExpr.PatchError("Test failed"));
         }
         return result.ok(document);
       }
     case "file":
       {
-        return result.err(new ops.PatchError("Cannot apply a file patch here"));
+        return result.err(new expr_dist_valbuildCoreExpr.PatchError("Cannot apply a file patch here"));
       }
   }
 }
@@ -457,7 +453,7 @@ function applyPatch(document, ops, patch) {
   }, document));
 }
 
-exports.PatchError = ops.PatchError;
+exports.PatchError = expr_dist_valbuildCoreExpr.PatchError;
 exports.JSONOps = JSONOps;
 exports.applyPatch = applyPatch;
 exports.deepClone = deepClone;

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

@@ -1,8 +1,7 @@
-import { e as _typeof, k as _slicedToArray, c as _createClass, a as _classCallCheck, w as _toConsumableArray } from '../../dist/index-051c34f3.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 { _ as _typeof, a as _slicedToArray, P as PatchError, s as splitModuleFilePathAndModulePath, b as _createClass, c as _classCallCheck, d as _toConsumableArray } from '../../dist/index-316f5dd8.esm.js';
+export { P as PatchError } from '../../dist/index-316f5dd8.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-a8316efa.esm.js';
 import { p as pipe } from '../../dist/util-18613e99.esm.js';
-import { P as PatchError, s as splitModuleIdAndModulePath } from '../../dist/ops-9262cf01.esm.js';
-export { P as PatchError } from '../../dist/ops-9262cf01.esm.js';
 
 function isNotRoot(path) {
   return isNonEmpty(path);
@@ -58,9 +57,9 @@ function parseAndValidateArrayIndex(value) {
   return ok(Number(value));
 }
 function sourceToPatchPath(sourcePath) {
-  var _splitModuleIdAndModu = splitModuleIdAndModulePath(sourcePath),
-    _splitModuleIdAndModu2 = _slicedToArray(_splitModuleIdAndModu, 2),
-    modulePath = _splitModuleIdAndModu2[1];
+  var _splitModuleFilePathA = splitModuleFilePathAndModulePath(sourcePath),
+    _splitModuleFilePathA2 = _slicedToArray(_splitModuleFilePathA, 2),
+    modulePath = _splitModuleFilePathA2[1];
   return modulePath.split(".").map(function (p) {
     return JSON.parse(p).toString();
   });
@@ -97,9 +96,6 @@ function replaceInNode(node, key, value) {
       node[key] = value;
       return ok(_replaced);
     } else {
-      console.log({
-        node: node
-      });
       return err(new PatchError("Cannot replace object element which does not exist"));
     }
   }