@valbuild/core 0.14.0 → 0.16.0

package/dist/ops-74661336.esm.js

@@ -0,0 +1,541 @@
+import { _ as _inherits, a as _createSuper, b as _classCallCheck, c as _createClass, f as _typeof, e as _defineProperty, j as _slicedToArray, l as createValPathOfItem, d as _objectSpread2, S as Schema, V as VAL_EXTENSION, n as newSelectorProxy, m as SourceOrExpr, E as Expr, w as _toConsumableArray, I as ImageSchema } from './SelectorProxy-63c2d0e2.esm.js';
+import { _ as _createForOfIteratorHelper } from './result-b96df128.esm.js';
+
+var ObjectSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(ObjectSchema, _Schema);
+  var _super = _createSuper(ObjectSchema);
+  function ObjectSchema(items) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, ObjectSchema);
+    _this = _super.call(this);
+    _this.items = items;
+    _this.opt = opt;
+    return _this;
+  }
+  _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 (_typeof(src) !== "object") {
+        return _defineProperty({}, path, [{
+          message: "Expected 'object', got '".concat(_typeof(src), "'")
+        }]);
+      } else if (Array.isArray(src)) {
+        return _defineProperty({}, path, [{
+          message: "Expected 'object', got 'array'"
+        }]);
+      }
+      Object.entries(this.items).forEach(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          schema = _ref4[1];
+        var subPath = 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 = _objectSpread2(_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 = _slicedToArray(_Object$entries[_i], 2),
+          _key = _Object$entries$_i[0],
+          schema = _Object$entries$_i[1];
+        if (!schema.assert(src[_key])) {
+          return false;
+        }
+      }
+      return _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 = _slicedToArray(_ref5, 2),
+            key = _ref6[0],
+            schema = _ref6[1];
+          return [key, schema.serialize()];
+        })),
+        opt: this.opt
+      };
+    }
+  }]);
+  return ObjectSchema;
+}(Schema);
+var object = function object(schema) {
+  return new ObjectSchema(schema);
+};
+
+var ArraySchema = /*#__PURE__*/function (_Schema) {
+  _inherits(ArraySchema, _Schema);
+  var _super = _createSuper(ArraySchema);
+  function ArraySchema(item) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, ArraySchema);
+    _this = _super.call(this);
+    _this.item = item;
+    _this.opt = opt;
+    return _this;
+  }
+  _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 (_typeof(src) !== "object" || !Array.isArray(src)) {
+        return _defineProperty({}, path, [{
+          message: "Expected 'array', got '".concat(_typeof(src), "'")
+        }]);
+      }
+      src.forEach(function (i, idx) {
+        var subPath = 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 = _objectSpread2(_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 = _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 _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;
+}(Schema);
+var array = function array(schema) {
+  return new ArraySchema(schema);
+};
+
+var I18nSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(I18nSchema, _Schema);
+  var _super = _createSuper(I18nSchema);
+  function I18nSchema(locales, item) {
+    var _this;
+    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    _classCallCheck(this, I18nSchema);
+    _this = _super.call(this);
+    _this.locales = locales;
+    _this.item = item;
+    _this.opt = opt;
+    return _this;
+  }
+  _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;
+}(Schema);
+var i18n = function i18n(locales) {
+  return function (schema) {
+    return new I18nSchema(locales, schema);
+  };
+};
+
+var UnionSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(UnionSchema, _Schema);
+  var _super = _createSuper(UnionSchema);
+  function UnionSchema(key, items) {
+    var _this;
+    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    _classCallCheck(this, UnionSchema);
+    _this = _super.call(this);
+    _this.key = key;
+    _this.items = items;
+    _this.opt = opt;
+    return _this;
+  }
+  _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;
+}(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) {
+  _inherits(RichTextSchema, _Schema);
+  var _super = _createSuper(RichTextSchema);
+  function RichTextSchema() {
+    var _this;
+    var opt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    _classCallCheck(this, RichTextSchema);
+    _this = _super.call(this);
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(RichTextSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (src === null || src === undefined) {
+        return _defineProperty({}, path, [{
+          message: "Expected non-nullable got '".concat(src, "'")
+        }]);
+      }
+      if (_typeof(src) !== "object" && !Array.isArray(src)) {
+        return _defineProperty({}, path, [{
+          message: "Expected 'object' (that is not of an array) or 'string', got '".concat(_typeof(src), "'"),
+          value: src
+        }]);
+      }
+      if (src[VAL_EXTENSION] !== "richtext") {
+        return _defineProperty({}, path, [{
+          message: "Expected _type key with value 'richtext' got '".concat(src[VAL_EXTENSION], "'"),
+          value: src
+        }]);
+      }
+      if (src.type !== "root") {
+        return _defineProperty({}, path, [{
+          message: "Expected type key with value 'root' got '".concat(src.type, "'"),
+          value: src
+        }]);
+      }
+      if (_typeof(src.children) !== "object" && !Array.isArray(src.children)) {
+        return _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;
+}(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 newSelectorProxy(source, id, schema);
+}
+function getRawSource(valModule) {
+  var sourceOrExpr = valModule[SourceOrExpr];
+  if (sourceOrExpr instanceof 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 || _typeof(schema) === "object" && "type" in schema && schema.type === "object";
+}
+function isArraySchema(schema) {
+  return schema instanceof ArraySchema || _typeof(schema) === "object" && "type" in schema && schema.type === "array";
+}
+function isI18nSchema(schema) {
+  return schema instanceof I18nSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "i18n";
+}
+function isUnionSchema(schema) {
+  return schema instanceof UnionSchema || _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 || _typeof(schema) === "object" && "type" in schema && schema.type === "richtext";
+}
+function isImageSchema(schema) {
+  return schema instanceof ImageSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "image";
+}
+function resolvePath(path, valModule, schema) {
+  var parts = parsePath(path);
+  var origParts = _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 (_typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+        throw Error("Schema type error: expected source to be type of array, but got ".concat(_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 (_typeof(resolvedSource) !== "object") {
+        throw Error("Schema type error: expected source to be type of object, but got ".concat(_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 (_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__*/_createClass(function PatchError(message) {
+  _classCallCheck(this, PatchError);
+  this.message = message;
+});
+
+/**
+ * NOTE: MAY mutate the input document.
+ */
+
+export { PatchError as P, array as a, resolvePath as b, content as c, getRawSource as g, i18n as i, object as o, richtext as r, splitModuleIdAndModulePath as s, union as u };