@valbuild/core 0.12.0

package/expr/dist/valbuild-core-expr.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/expr/index";
+//# sourceMappingURL=valbuild-core-expr.cjs.d.ts.map

package/expr/dist/valbuild-core-expr.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valbuild-core-expr.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/expr/index.d.ts"],"names":[],"mappings":"AAAA"}

package/expr/dist/valbuild-core-expr.cjs.dev.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var expr_dist_valbuildCoreExpr = require('../../dist/index-b49a2c60.cjs.dev.js');
+require('../../dist/createClass-a436dbfe.cjs.dev.js');
+require('../../dist/result-48320acd.cjs.dev.js');
+
+
+
+exports.Call = expr_dist_valbuildCoreExpr.Call;
+exports.Expr = expr_dist_valbuildCoreExpr.Expr;
+exports.NilSym = expr_dist_valbuildCoreExpr.NilSym;
+exports.StringLiteral = expr_dist_valbuildCoreExpr.StringLiteral;
+exports.StringTemplate = expr_dist_valbuildCoreExpr.StringTemplate;
+exports.Sym = expr_dist_valbuildCoreExpr.Sym;
+exports.evaluate = expr_dist_valbuildCoreExpr.evaluate;
+exports.parse = expr_dist_valbuildCoreExpr.parse;

package/expr/dist/valbuild-core-expr.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./valbuild-core-expr.cjs.prod.js");
+} else {
+  module.exports = require("./valbuild-core-expr.cjs.dev.js");
+}

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

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var expr_dist_valbuildCoreExpr = require('../../dist/index-2f1631cf.cjs.prod.js');
+require('../../dist/createClass-de7426aa.cjs.prod.js');
+require('../../dist/result-26f67b40.cjs.prod.js');
+
+
+
+exports.Call = expr_dist_valbuildCoreExpr.Call;
+exports.Expr = expr_dist_valbuildCoreExpr.Expr;
+exports.NilSym = expr_dist_valbuildCoreExpr.NilSym;
+exports.StringLiteral = expr_dist_valbuildCoreExpr.StringLiteral;
+exports.StringTemplate = expr_dist_valbuildCoreExpr.StringTemplate;
+exports.Sym = expr_dist_valbuildCoreExpr.Sym;
+exports.evaluate = expr_dist_valbuildCoreExpr.evaluate;
+exports.parse = expr_dist_valbuildCoreExpr.parse;

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

@@ -0,0 +1,3 @@
+export { C as Call, E as Expr, N as NilSym, q as StringLiteral, r as StringTemplate, s as Sym, t as evaluate, p as parse } from '../../dist/index-55916dcd.esm.js';
+import '../../dist/createClass-012eebbf.esm.js';
+import '../../dist/result-b96df128.esm.js';

package/expr/package.json

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

package/fp/dist/valbuild-core-fp.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/fp/index";
+//# sourceMappingURL=valbuild-core-fp.cjs.d.ts.map

package/fp/dist/valbuild-core-fp.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valbuild-core-fp.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/fp/index.d.ts"],"names":[],"mappings":"AAAA"}

package/fp/dist/valbuild-core-fp.cjs.dev.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var result = require('../../dist/result-48320acd.cjs.dev.js');
+var util = require('../../dist/util-b213092b.cjs.dev.js');
+
+
+
+exports.array = result.array;
+exports.result = result.result;
+exports.pipe = util.pipe;
+exports.tap = util.tap;

package/fp/dist/valbuild-core-fp.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./valbuild-core-fp.cjs.prod.js");
+} else {
+  module.exports = require("./valbuild-core-fp.cjs.dev.js");
+}

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

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var result = require('../../dist/result-26f67b40.cjs.prod.js');
+var util = require('../../dist/util-030d8a1f.cjs.prod.js');
+
+
+
+exports.array = result.array;
+exports.result = result.result;
+exports.pipe = util.pipe;
+exports.tap = util.tap;

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

@@ -0,0 +1,2 @@
+export { d as array, r as result } from '../../dist/result-b96df128.esm.js';
+export { p as pipe, t as tap } from '../../dist/util-18613e99.esm.js';

package/fp/package.json

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

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@valbuild/core",
+  "version": "0.12.0",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "analyze-trace": "npx tsc -p tsconfig.json --skipLibCheck --generateTrace trace; npx -p @typescript/analyze-trace analyze-trace trace;  npx speedscope trace/trace.json"
+  },
+  "main": "dist/valbuild-core.cjs.js",
+  "module": "dist/valbuild-core.esm.js",
+  "exports": {
+    ".": {
+      "module": "./dist/valbuild-core.esm.js",
+      "default": "./dist/valbuild-core.cjs.js"
+    },
+    "./fp": {
+      "module": "./fp/dist/valbuild-core-fp.esm.js",
+      "default": "./fp/dist/valbuild-core-fp.cjs.js"
+    },
+    "./expr": {
+      "module": "./expr/dist/valbuild-core-expr.esm.js",
+      "default": "./expr/dist/valbuild-core-expr.cjs.js"
+    },
+    "./patch": {
+      "module": "./patch/dist/valbuild-core-patch.esm.js",
+      "default": "./patch/dist/valbuild-core-patch.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "dist/valbuild-core.cjs.d.ts",
+  "preconstruct": {
+    "entrypoints": [
+      "./index.ts",
+      "./fp/index.ts",
+      "./patch/index.ts",
+      "./expr/index.ts"
+    ],
+    "exports": true
+  },
+  "dependencies": {
+    "ts-toolbelt": "^9.6.0"
+  }
+}

package/patch/dist/valbuild-core-patch.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/patch/index";
+//# sourceMappingURL=valbuild-core-patch.cjs.d.ts.map

package/patch/dist/valbuild-core-patch.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valbuild-core-patch.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/patch/index.d.ts"],"names":[],"mappings":"AAAA"}

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

@@ -0,0 +1,443 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createClass = require('../../dist/createClass-a436dbfe.cjs.dev.js');
+var result = require('../../dist/result-48320acd.cjs.dev.js');
+var util = require('../../dist/util-b213092b.cjs.dev.js');
+var ops = require('../../dist/ops-87cdbafc.cjs.dev.js');
+
+function isNotRoot(path) {
+  return result.isNonEmpty(path);
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (createClass._typeof(a) === "object" && createClass._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 = createClass._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 (createClass._typeof(value) === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(function (_ref) {
+      var _ref2 = createClass._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 result.err(new ops.PatchError("Invalid array index \"".concat(value, "\"")));
+  }
+  return result.ok(Number(value));
+}
+
+function parseAndValidateArrayInsertIndex(key, nodes) {
+  if (key === "-") {
+    return result.ok(nodes.length);
+  }
+  return util.pipe(parseAndValidateArrayIndex(key), result.filterOrElse(function (index) {
+    return index <= nodes.length;
+  }, function () {
+    return new ops.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");
+  }));
+}
+function replaceInNode(node, key, value) {
+  if (Array.isArray(node)) {
+    return util.pipe(parseAndValidateArrayInboundsIndex(key, node), result.map(function (index) {
+      var replaced = node[index];
+      node[index] = value;
+      return replaced;
+    }));
+  } else if (createClass._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 {
+      return result.err(new ops.PatchError("Cannot replace object element which does not exist"));
+    }
+  }
+  return result.err(new ops.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 = createClass._slicedToArray(_ref, 2),
+        node = _ref2[0],
+        key = _ref2[1];
+      return replaceInNode(node, key, value);
+    }), result.map(function (replaced) {
+      return [document, replaced];
+    }));
+  } else {
+    return result.ok([value, document]);
+  }
+}
+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"));
+      } else {
+        return result.ok(node[index]);
+      }
+    }));
+  } else if (createClass._typeof(node) === "object" && node !== null) {
+    // Prototype pollution protection
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      return result.ok(node[key]);
+    } else {
+      return result.ok(undefined);
+    }
+  }
+  return result.err(new ops.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 (result.isErr(childNode)) {
+      return childNode;
+    }
+    if (childNode.value === undefined) {
+      return result.err(new ops.PatchError("Path refers to non-existing object/array"));
+    }
+    targetNode = childNode.value;
+  }
+  return result.ok([targetNode, key]);
+}
+function getAtPath(node, path) {
+  return util.pipe(path, result.flatMapReduce(function (node, key) {
+    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");
+    }));
+  }, node));
+}
+function removeFromNode(node, key) {
+  if (Array.isArray(node)) {
+    return util.pipe(parseAndValidateArrayInboundsIndex(key, node), result.map(function (index) {
+      var _node$splice = node.splice(index, 1),
+        _node$splice2 = createClass._slicedToArray(_node$splice, 1),
+        removed = _node$splice2[0];
+      return removed;
+    }));
+  } else if (createClass._typeof(node) === "object" && node !== null) {
+    // Prototype pollution protection
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      var removed = node[key];
+      delete node[key];
+      return result.ok(removed);
+    }
+  }
+  return result.err(new ops.PatchError("Cannot remove from non-object/array"));
+}
+function removeAtPath(document, path) {
+  return util.pipe(getPointerFromPath(document, path), result.flatMap(function (_ref3) {
+    var _ref4 = createClass._slicedToArray(_ref3, 2),
+      node = _ref4[0],
+      key = _ref4[1];
+    return removeFromNode(node, key);
+  }));
+}
+function addToNode(node, key, value) {
+  if (Array.isArray(node)) {
+    return util.pipe(parseAndValidateArrayInsertIndex(key, node), result.map(function (index) {
+      node.splice(index, 0, value);
+      return undefined;
+    }));
+  } else if (createClass._typeof(node) === "object" && node !== null) {
+    var _replaced2;
+    // Prototype pollution protection
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      _replaced2 = node[key];
+    }
+    node[key] = value;
+    return result.ok(_replaced2);
+  }
+  return result.err(new ops.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 = createClass._slicedToArray(_ref5, 2),
+        node = _ref6[0],
+        key = _ref6[1];
+      return addToNode(node, key, value);
+    }), result.map(function (replaced) {
+      return [document, replaced];
+    }));
+  } else {
+    return result.ok([value, document]);
+  }
+}
+function pickDocument(_ref7) {
+  var _ref8 = createClass._slicedToArray(_ref7, 1),
+    document = _ref8[0];
+  return document;
+}
+var JSONOps = /*#__PURE__*/function () {
+  function JSONOps() {
+    createClass._classCallCheck(this, JSONOps);
+  }
+  createClass._createClass(JSONOps, [{
+    key: "get",
+    value: function get(document, path) {
+      return getAtPath(document, path);
+    }
+  }, {
+    key: "add",
+    value: function add(document, path, value) {
+      return util.pipe(addAtPath(document, path, value), result.map(pickDocument));
+    }
+  }, {
+    key: "remove",
+    value: function remove(document, path) {
+      return util.pipe(removeAtPath(document, path), result.map(function () {
+        return document;
+      }));
+    }
+  }, {
+    key: "replace",
+    value: function replace(document, path, value) {
+      return util.pipe(replaceAtPath(document, path, value), result.map(pickDocument));
+    }
+  }, {
+    key: "move",
+    value: function move(document, from, path) {
+      return util.pipe(removeAtPath(document, from), result.flatMap(function (removed) {
+        return addAtPath(document, path, removed);
+      }), result.map(pickDocument));
+    }
+  }, {
+    key: "copy",
+    value: function copy(document, from, path) {
+      return util.pipe(getAtPath(document, from), result.flatMap(function (value) {
+        return addAtPath(document, path, deepClone(value));
+      }), result.map(pickDocument));
+    }
+  }, {
+    key: "test",
+    value: function test(document, path, value) {
+      return util.pipe(getAtPath(document, path), result.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 result.ok([]);
+  if (!pointer.startsWith("/")) return result.err("JSON pointer must start with /");
+  var tokens = pointer.substring(1).split("/").map(parseJSONPointerReferenceToken);
+  if (tokens.every(function (token) {
+    return token !== undefined;
+  })) {
+    return result.ok(tokens);
+  } else {
+    return result.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(createClass._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 util.pipe(path, result.mapErr(function (error) {
+        return [createIssueAtPath(["path"])(error)];
+      }), result.map(function (path) {
+        return {
+          op: operation.op,
+          path: path,
+          value: operation.value
+        };
+      }));
+    case "remove":
+      return util.pipe(path, result.filterOrElse(result.isNonEmpty, function () {
+        return "Cannot remove root";
+      }), result.mapErr(function (error) {
+        return [createIssueAtPath(["path"])(error)];
+      }), result.map(function (path) {
+        return {
+          op: operation.op,
+          path: path
+        };
+      }));
+    case "move":
+      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 = createClass._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 = createClass._slicedToArray(_ref4, 2),
+          from = _ref5[0],
+          path = _ref5[1];
+        return {
+          op: operation.op,
+          from: from,
+          path: path
+        };
+      }));
+    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 = createClass._slicedToArray(_ref6, 2),
+          from = _ref7[0],
+          path = _ref7[1];
+        return {
+          op: operation.op,
+          from: from,
+          path: path
+        };
+      }));
+  }
+}
+function parsePatch(patch) {
+  return util.pipe(patch.map(parseOperation).map(result.mapErr(result.map$1(function (error, index) {
+    return prefixIssuePath(index.toString(), error);
+  }))), result.all, result.mapErr(result.flatten));
+}
+
+function apply(document, ops$1, op) {
+  switch (op.op) {
+    case "add":
+      return ops$1.add(document, op.path, op.value);
+    case "remove":
+      return ops$1.remove(document, op.path);
+    case "replace":
+      return ops$1.replace(document, op.path, op.value);
+    case "move":
+      return ops$1.move(document, op.from, op.path);
+    case "copy":
+      return ops$1.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"));
+        }
+        return result.ok(document);
+      }
+  }
+}
+function applyPatch(document, ops, patch) {
+  return util.pipe(patch, result.flatMapReduce(function (doc, op) {
+    return apply(doc, ops, op);
+  }, document));
+}
+
+exports.PatchError = ops.PatchError;
+exports.JSONOps = JSONOps;
+exports.applyPatch = applyPatch;
+exports.deepClone = deepClone;
+exports.deepEqual = deepEqual;
+exports.formatJSONPointer = formatJSONPointer;
+exports.isNotRoot = isNotRoot;
+exports.parseAndValidateArrayIndex = parseAndValidateArrayIndex;
+exports.parseJSONPointer = parseJSONPointer;
+exports.parsePatch = parsePatch;

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

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./valbuild-core-patch.cjs.prod.js");
+} else {
+  module.exports = require("./valbuild-core-patch.cjs.dev.js");
+}