@valbuild/core 0.14.0 → 0.16.0

package/dist/ops-1b6e0e35.cjs.prod.js

@@ -0,0 +1,552 @@
+'use strict';
+
+var SelectorProxy = require('./SelectorProxy-2af1b2b8.cjs.prod.js');
+var result = require('./result-26f67b40.cjs.prod.js');
+
+var ObjectSchema = /*#__PURE__*/function (_Schema) {
+  SelectorProxy._inherits(ObjectSchema, _Schema);
+  var _super = SelectorProxy._createSuper(ObjectSchema);
+  function ObjectSchema(items) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    SelectorProxy._classCallCheck(this, ObjectSchema);
+    _this = _super.call(this);
+    _this.items = items;
+    _this.opt = opt;
+    return _this;
+  }
+  SelectorProxy._createClass(ObjectSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      var _this2 = this;
+      var error = false;
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (SelectorProxy._typeof(src) !== "object") {
+        return SelectorProxy._defineProperty({}, path, [{
+          message: "Expected 'object', got '".concat(SelectorProxy._typeof(src), "'")
+        }]);
+      } else if (Array.isArray(src)) {
+        return SelectorProxy._defineProperty({}, path, [{
+          message: "Expected 'object', got 'array'"
+        }]);
+      }
+      Object.entries(this.items).forEach(function (_ref3) {
+        var _ref4 = SelectorProxy._slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          schema = _ref4[1];
+        var subPath = SelectorProxy.createValPathOfItem(path, key);
+        if (!subPath) {
+          error = _this2.appendValidationError(error, path, "Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at key ").concat(key),
+          // Should! never happen
+          src);
+        } else {
+          var subError = schema.validate(subPath, src[key]);
+          if (subError && error) {
+            error = SelectorProxy._objectSpread2(SelectorProxy._objectSpread2({}, subError), error);
+          } else if (subError) {
+            error = subError;
+          }
+        }
+      });
+      return error;
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      if (!src) {
+        return false;
+      }
+      for (var _i = 0, _Object$entries = Object.entries(this.items); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = SelectorProxy._slicedToArray(_Object$entries[_i], 2),
+          _key = _Object$entries$_i[0],
+          schema = _Object$entries$_i[1];
+        if (!schema.assert(src[_key])) {
+          return false;
+        }
+      }
+      return SelectorProxy._typeof(src) === "object" && !Array.isArray(src);
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new ObjectSchema(this.items, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "object",
+        items: Object.fromEntries(Object.entries(this.items).map(function (_ref5) {
+          var _ref6 = SelectorProxy._slicedToArray(_ref5, 2),
+            key = _ref6[0],
+            schema = _ref6[1];
+          return [key, schema.serialize()];
+        })),
+        opt: this.opt
+      };
+    }
+  }]);
+  return ObjectSchema;
+}(SelectorProxy.Schema);
+var object = function object(schema) {
+  return new ObjectSchema(schema);
+};
+
+var ArraySchema = /*#__PURE__*/function (_Schema) {
+  SelectorProxy._inherits(ArraySchema, _Schema);
+  var _super = SelectorProxy._createSuper(ArraySchema);
+  function ArraySchema(item) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    SelectorProxy._classCallCheck(this, ArraySchema);
+    _this = _super.call(this);
+    _this.item = item;
+    _this.opt = opt;
+    return _this;
+  }
+  SelectorProxy._createClass(ArraySchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      var _this2 = this;
+      var error = false;
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (SelectorProxy._typeof(src) !== "object" || !Array.isArray(src)) {
+        return SelectorProxy._defineProperty({}, path, [{
+          message: "Expected 'array', got '".concat(SelectorProxy._typeof(src), "'")
+        }]);
+      }
+      src.forEach(function (i, idx) {
+        var subPath = SelectorProxy.createValPathOfItem(path, idx);
+        if (!subPath) {
+          error = _this2.appendValidationError(error, path, "Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at index ").concat(idx),
+          // Should! never happen
+          src);
+        } else {
+          var subError = _this2.item.validate(subPath, i);
+          if (subError && error) {
+            error = SelectorProxy._objectSpread2(SelectorProxy._objectSpread2({}, subError), error);
+          } else if (subError) {
+            error = subError;
+          }
+        }
+      });
+      return error;
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      if (!src) {
+        return false;
+      }
+      var _iterator = result._createForOfIteratorHelper(src),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _item = _step.value;
+          if (!this.item.assert(_item)) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return SelectorProxy._typeof(src) === "object" && Array.isArray(src);
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new ArraySchema(this.item, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "array",
+        item: this.item.serialize(),
+        opt: this.opt
+      };
+    }
+  }]);
+  return ArraySchema;
+}(SelectorProxy.Schema);
+var array = function array(schema) {
+  return new ArraySchema(schema);
+};
+
+var I18nSchema = /*#__PURE__*/function (_Schema) {
+  SelectorProxy._inherits(I18nSchema, _Schema);
+  var _super = SelectorProxy._createSuper(I18nSchema);
+  function I18nSchema(locales, item) {
+    var _this;
+    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    SelectorProxy._classCallCheck(this, I18nSchema);
+    _this = _super.call(this);
+    _this.locales = locales;
+    _this.item = item;
+    _this.opt = opt;
+    return _this;
+  }
+  SelectorProxy._createClass(I18nSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new I18nSchema(this.locales, this.item, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "i18n",
+        item: this.item.serialize(),
+        locales: this.locales,
+        opt: this.opt
+      };
+    }
+  }]);
+  return I18nSchema;
+}(SelectorProxy.Schema);
+var i18n = function i18n(locales) {
+  return function (schema) {
+    return new I18nSchema(locales, schema);
+  };
+};
+
+var UnionSchema = /*#__PURE__*/function (_Schema) {
+  SelectorProxy._inherits(UnionSchema, _Schema);
+  var _super = SelectorProxy._createSuper(UnionSchema);
+  function UnionSchema(key, items) {
+    var _this;
+    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    SelectorProxy._classCallCheck(this, UnionSchema);
+    _this = _super.call(this);
+    _this.key = key;
+    _this.items = items;
+    _this.opt = opt;
+    return _this;
+  }
+  SelectorProxy._createClass(UnionSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      throw new Error("Method not implemented.");
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "union",
+        key: this.key,
+        items: this.items.map(function (o) {
+          return o.serialize();
+        }),
+        opt: this.opt
+      };
+    }
+  }]);
+  return UnionSchema;
+}(SelectorProxy.Schema);
+var union = function union(key) {
+  for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    objects[_key - 1] = arguments[_key];
+  }
+  return new UnionSchema(key, objects);
+};
+
+var RichTextSchema = /*#__PURE__*/function (_Schema) {
+  SelectorProxy._inherits(RichTextSchema, _Schema);
+  var _super = SelectorProxy._createSuper(RichTextSchema);
+  function RichTextSchema() {
+    var _this;
+    var opt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    SelectorProxy._classCallCheck(this, RichTextSchema);
+    _this = _super.call(this);
+    _this.opt = opt;
+    return _this;
+  }
+  SelectorProxy._createClass(RichTextSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (src === null || src === undefined) {
+        return SelectorProxy._defineProperty({}, path, [{
+          message: "Expected non-nullable got '".concat(src, "'")
+        }]);
+      }
+      if (SelectorProxy._typeof(src) !== "object" && !Array.isArray(src)) {
+        return SelectorProxy._defineProperty({}, path, [{
+          message: "Expected 'object' (that is not of an array) or 'string', got '".concat(SelectorProxy._typeof(src), "'"),
+          value: src
+        }]);
+      }
+      if (src[SelectorProxy.VAL_EXTENSION] !== "richtext") {
+        return SelectorProxy._defineProperty({}, path, [{
+          message: "Expected _type key with value 'richtext' got '".concat(src[SelectorProxy.VAL_EXTENSION], "'"),
+          value: src
+        }]);
+      }
+      if (src.type !== "root") {
+        return SelectorProxy._defineProperty({}, path, [{
+          message: "Expected type key with value 'root' got '".concat(src.type, "'"),
+          value: src
+        }]);
+      }
+      if (SelectorProxy._typeof(src.children) !== "object" && !Array.isArray(src.children)) {
+        return SelectorProxy._defineProperty({}, path, [{
+          message: "Expected children to be an array, but got '".concat(src.type, "'"),
+          value: src
+        }]);
+      }
+      return false;
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      // TODO:
+      return true;
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new RichTextSchema(true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "richtext",
+        opt: this.opt
+      };
+    }
+  }]);
+  return RichTextSchema;
+}(SelectorProxy.Schema);
+var richtext = function richtext() {
+  return new RichTextSchema();
+};
+
+function content(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+id,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+schema,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+source) {
+  return SelectorProxy.newSelectorProxy(source, id, schema);
+}
+function getRawSource(valModule) {
+  var sourceOrExpr = valModule[SelectorProxy.SourceOrExpr];
+  if (sourceOrExpr instanceof SelectorProxy.Expr) {
+    throw Error("Cannot get raw source of an Expr");
+  }
+  var source = sourceOrExpr;
+  return source;
+}
+function splitModuleIdAndModulePath(path) {
+  return [path.slice(0, path.indexOf(".")), path.slice(path.indexOf(".") + 1)];
+}
+function isObjectSchema(schema) {
+  return schema instanceof ObjectSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "object";
+}
+function isArraySchema(schema) {
+  return schema instanceof ArraySchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "array";
+}
+function isI18nSchema(schema) {
+  return schema instanceof I18nSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "i18n";
+}
+function isUnionSchema(schema) {
+  return schema instanceof UnionSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "union";
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function isRichTextSchema(schema) {
+  return schema instanceof RichTextSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "richtext";
+}
+function isImageSchema(schema) {
+  return schema instanceof SelectorProxy.ImageSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "image";
+}
+function resolvePath(path, valModule, schema) {
+  var parts = parsePath(path);
+  var origParts = SelectorProxy._toConsumableArray(parts);
+  var resolvedSchema = schema;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  var resolvedSource = valModule;
+  var _loop = function _loop() {
+    var part = parts.shift();
+    if (part === undefined) {
+      throw Error("Unexpected undefined part");
+    }
+    if (isArraySchema(resolvedSchema)) {
+      if (Number.isNaN(Number(part))) {
+        throw Error("Invalid path: array schema ".concat(resolvedSchema, " must have ").concat(part, " a number as path"));
+      }
+      if (SelectorProxy._typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+        throw Error("Schema type error: expected source to be type of array, but got ".concat(SelectorProxy._typeof(resolvedSource)));
+      }
+      if (!resolvedSource[part]) {
+        var _resolvedSource;
+        throw Error("Invalid path: array source (length: ".concat((_resolvedSource = resolvedSource) === null || _resolvedSource === void 0 ? void 0 : _resolvedSource.length, ") did not have index ").concat(part, " from path: ").concat(path));
+      }
+      resolvedSource = resolvedSource[part];
+      resolvedSchema = resolvedSchema.item;
+    } else if (isObjectSchema(resolvedSchema)) {
+      if (SelectorProxy._typeof(resolvedSource) !== "object") {
+        throw Error("Schema type error: expected source to be type of object, but got ".concat(SelectorProxy._typeof(resolvedSource)));
+      }
+      if (!resolvedSource[part]) {
+        throw Error("Invalid path: object source did not have key ".concat(part, " from path: ").concat(path));
+      }
+      resolvedSource = resolvedSource[part];
+      resolvedSchema = resolvedSchema.items[part];
+    } else if (isI18nSchema(resolvedSchema)) {
+      if (!resolvedSchema.locales.includes(part)) {
+        throw Error("Invalid path: i18n schema ".concat(resolvedSchema, " supports locales ").concat(resolvedSchema.locales.join(", "), ", but found: ").concat(part));
+      }
+      if (!Object.keys(resolvedSource).includes(part)) {
+        throw Error("Schema type error: expected source to be type of i18n with locale ".concat(part, ", but got ").concat(JSON.stringify(Object.keys(resolvedSource))));
+      }
+      resolvedSource = resolvedSource[part];
+      resolvedSchema = resolvedSchema.item;
+    } else if (isImageSchema(resolvedSchema)) {
+      return {
+        v: {
+          path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+            return JSON.stringify(p);
+          }).join("."),
+          // TODO: create a function generate path from parts (not sure if this always works)
+          schema: resolvedSchema,
+          source: resolvedSource
+        }
+      };
+    } else if (isUnionSchema(resolvedSchema)) {
+      var _key = resolvedSchema.key;
+      var keyValue = resolvedSource[_key];
+      if (!keyValue) {
+        throw Error("Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key, " in path: ").concat(path));
+      }
+      var schemaOfUnionKey = resolvedSchema.items.find(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      function (child) {
+        var _child$items, _child$items$_key;
+        return (child === null || child === void 0 ? void 0 : (_child$items = child.items) === null || _child$items === void 0 ? void 0 : (_child$items$_key = _child$items[_key]) === null || _child$items$_key === void 0 ? void 0 : _child$items$_key.value) === keyValue;
+      });
+      if (!schemaOfUnionKey) {
+        throw Error("Invalid path: union schema ".concat(resolvedSchema, " did not have a child object with ").concat(_key, " of value ").concat(keyValue, " in path: ").concat(path));
+      }
+      resolvedSchema = schemaOfUnionKey.items[part];
+      resolvedSource = resolvedSource[part];
+    } else if (isRichTextSchema(resolvedSchema)) {
+      return {
+        v: {
+          path: origParts.slice(0, origParts.length - parts.length - 1).map(function (p) {
+            return JSON.stringify(p);
+          }).join("."),
+          // TODO: create a function generate path from parts (not sure if this always works)
+          schema: resolvedSchema,
+          source: resolvedSource
+        }
+      };
+    } else {
+      throw Error("Invalid path: ".concat(part, " resolved to an unexpected schema ").concat(JSON.stringify(resolvedSchema)));
+    }
+  };
+  while (parts.length > 0) {
+    var _ret = _loop();
+    if (SelectorProxy._typeof(_ret) === "object") return _ret.v;
+  }
+  if (parts.length > 0) {
+    throw Error("Invalid path: ".concat(parts.join("."), " is not a valid path"));
+  }
+  return {
+    path: path,
+    schema: resolvedSchema,
+    source: resolvedSource
+  };
+}
+function parsePath(input) {
+  var result = [];
+  var i = 0;
+  while (i < input.length) {
+    var part = "";
+    if (input[i] === '"') {
+      // Parse a quoted string
+      i++;
+      while (i < input.length && input[i] !== '"') {
+        if (input[i] === "\\" && input[i + 1] === '"') {
+          // Handle escaped double quotes
+          part += '"';
+          i++;
+        } else {
+          part += input[i];
+        }
+        i++;
+      }
+      if (input[i] !== '"') {
+        var _input$i;
+        throw new Error("Invalid input (".concat(JSON.stringify(input), "): Missing closing double quote: ").concat((_input$i = input[i]) !== null && _input$i !== void 0 ? _input$i : "at end of string", " (char: ").concat(i, "; length: ").concat(input.length, ")"));
+      }
+    } else {
+      // Parse a regular string
+      while (i < input.length && input[i] !== ".") {
+        part += input[i];
+        i++;
+      }
+    }
+    if (part !== "") {
+      result.push(part);
+    }
+    i++;
+  }
+  return result;
+}
+
+var PatchError = /*#__PURE__*/SelectorProxy._createClass(function PatchError(message) {
+  SelectorProxy._classCallCheck(this, PatchError);
+  this.message = message;
+});
+
+/**
+ * NOTE: MAY mutate the input document.
+ */
+
+exports.PatchError = PatchError;
+exports.array = array;
+exports.content = content;
+exports.getRawSource = getRawSource;
+exports.i18n = i18n;
+exports.object = object;
+exports.resolvePath = resolvePath;
+exports.richtext = richtext;
+exports.splitModuleIdAndModulePath = splitModuleIdAndModulePath;
+exports.union = union;