@valbuild/core 0.15.0 → 0.17.0

package/dist/ops-f3015423.cjs.dev.js

@@ -0,0 +1,684 @@
+'use strict';
+
+var index = require('./index-a6e642dd.cjs.dev.js');
+var result = require('./result-48320acd.cjs.dev.js');
+
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function _andThen(f, source, path) {
+  if (source) {
+    return newSelectorProxy(f(newSelectorProxy(source, path)));
+  }
+  return newSelectorProxy(source, path);
+}
+function isSelector(source) {
+  return index._typeof(source) === "object" && source !== null && (index.GetSource in source || index.Path in source);
+}
+function newSelectorProxy(source, path, moduleSchema) {
+  var _ref;
+  if (index._typeof(source) === "object") {
+    if (isSelector(source)) {
+      return source;
+    } else if (index.isSerializedVal(source)) {
+      return newSelectorProxy(source.val, source.valPath);
+    }
+  }
+  if (source && source[index.FILE_REF_PROP] && source[index.VAL_EXTENSION] === "file") {
+    var fileRef = source[index.FILE_REF_PROP];
+    if (typeof fileRef !== "string") {
+      throw Error("Invalid file ref: " + fileRef);
+    }
+    return newSelectorProxy(index.convertFileSource(source), path, moduleSchema);
+  }
+  switch (index._typeof(source)) {
+    case "function":
+    case "symbol":
+      throw Error("Invalid selector type: ".concat(index._typeof(source), ": ").concat(source));
+    case "object":
+      // Handles both objects and arrays!
+      if (source !== null) {
+        return new Proxy(source, {
+          // TODO: see proxy docs if we want more traps
+          has: function has(target, prop) {
+            if (prop === index.GetSource) {
+              return true;
+            }
+            if (prop === index.Path) {
+              return true;
+            }
+            if (prop === "andThen") {
+              return true;
+            }
+            if (prop === index.GetSchema) {
+              return true;
+            }
+            return prop in target;
+          },
+          get: function get(target, prop) {
+            if (prop === index.GetSource) {
+              return source;
+            }
+            if (prop === index.Path) {
+              return path;
+            }
+            if (prop === index.GetSchema) {
+              return moduleSchema;
+            }
+            if (prop === "andThen") {
+              return function (f) {
+                return _andThen(f, source, path);
+              };
+            }
+            if (Array.isArray(target)) {
+              if (prop === "filter") {
+                return function (f) {
+                  var filtered = target.map(function (a, i) {
+                    return newSelectorProxy(a, createValPathOfItem(path, i), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item);
+                  }).filter(function (a) {
+                    if (f && f instanceof index.Schema) {
+                      return f.assert(unValify(a));
+                    } else {
+                      return unValify(f(a));
+                    }
+                  });
+                  return newSelectorProxy(filtered, path, moduleSchema);
+                };
+              } else if (prop === "map") {
+                return function (f) {
+                  var filtered = target.map(function (a, i) {
+                    var valueOrSelector = f(newSelectorProxy(a, createValPathOfItem(path, i), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item), newSelectorProxy(i));
+                    if (isSelector(valueOrSelector)) {
+                      return valueOrSelector;
+                    }
+                    return newSelectorProxy(valueOrSelector);
+                  });
+                  return newSelectorProxy(filtered, path, moduleSchema);
+                };
+              }
+            }
+            if (Array.isArray(target) && prop === "length") {
+              return newSelectorProxy(target.length);
+            }
+            var reflectedValue = Reflect.get(target, prop);
+            if (hasOwn(source, prop)) {
+              if (!Number.isNaN(Number(prop))) {
+                return newSelectorProxy(reflectedValue, createValPathOfItem(path, Number(prop)), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item);
+              }
+              return newSelectorProxy(reflectedValue, createValPathOfItem(path, prop), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.items[prop]);
+            }
+            return reflectedValue;
+          }
+        });
+      }
+    // intentional fallthrough
+    // eslint-disable-next-line no-fallthrough
+    default:
+      return _ref = {
+        eq: function eq(other) {
+          var otherValue = other;
+          if (isSelector(other)) {
+            otherValue = other[index.GetSource];
+            if (otherValue instanceof index.Expr) {
+              throw Error("TODO: Cannot evaluate equality with an Expr");
+            }
+          }
+          return newSelectorProxy(source === otherValue, undefined);
+        },
+        andThen: function andThen(f) {
+          return _andThen(f, source === undefined ? null : source, path);
+        }
+      }, index._defineProperty(_ref, index.GetSource, source === undefined ? null : source), index._defineProperty(_ref, index.Path, path), index._defineProperty(_ref, index.GetSchema, moduleSchema), _ref;
+  }
+}
+function createValPathOfItem(arrayPath, prop) {
+  if (index._typeof(prop) === "symbol") {
+    throw Error("Cannot create val path of array item with symbol prop: ".concat(prop.toString()));
+  }
+  return arrayPath && "".concat(arrayPath, ".").concat(JSON.stringify(prop));
+}
+
+// TODO: could we do .val on the objects instead?
+function unValify(valueOrSelector) {
+  if (index._typeof(valueOrSelector) === "object" && (index.GetSource in valueOrSelector || index.Path in valueOrSelector)) {
+    var selectorValue = valueOrSelector[index.GetSource];
+    return selectorValue;
+  }
+  return valueOrSelector;
+}
+
+var ObjectSchema = /*#__PURE__*/function (_Schema) {
+  index._inherits(ObjectSchema, _Schema);
+  var _super = index._createSuper(ObjectSchema);
+  function ObjectSchema(items) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    index._classCallCheck(this, ObjectSchema);
+    _this = _super.call(this);
+    _this.items = items;
+    _this.opt = opt;
+    return _this;
+  }
+  index._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 (index._typeof(src) !== "object") {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'object', got '".concat(index._typeof(src), "'")
+        }]);
+      } else if (Array.isArray(src)) {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'object', got 'array'"
+        }]);
+      }
+      Object.entries(this.items).forEach(function (_ref3) {
+        var _ref4 = index._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 = index._objectSpread2(index._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 = index._slicedToArray(_Object$entries[_i], 2),
+          _key = _Object$entries$_i[0],
+          schema = _Object$entries$_i[1];
+        if (!schema.assert(src[_key])) {
+          return false;
+        }
+      }
+      return index._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 = index._slicedToArray(_ref5, 2),
+            key = _ref6[0],
+            schema = _ref6[1];
+          return [key, schema.serialize()];
+        })),
+        opt: this.opt
+      };
+    }
+  }]);
+  return ObjectSchema;
+}(index.Schema);
+var object = function object(schema) {
+  return new ObjectSchema(schema);
+};
+
+var ArraySchema = /*#__PURE__*/function (_Schema) {
+  index._inherits(ArraySchema, _Schema);
+  var _super = index._createSuper(ArraySchema);
+  function ArraySchema(item) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    index._classCallCheck(this, ArraySchema);
+    _this = _super.call(this);
+    _this.item = item;
+    _this.opt = opt;
+    return _this;
+  }
+  index._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 (index._typeof(src) !== "object" || !Array.isArray(src)) {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'array', got '".concat(index._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 = index._objectSpread2(index._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 index._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;
+}(index.Schema);
+var array = function array(schema) {
+  return new ArraySchema(schema);
+};
+
+var UnionSchema = /*#__PURE__*/function (_Schema) {
+  index._inherits(UnionSchema, _Schema);
+  var _super = index._createSuper(UnionSchema);
+  function UnionSchema(key, items) {
+    var _this;
+    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    index._classCallCheck(this, UnionSchema);
+    _this = _super.call(this);
+    _this.key = key;
+    _this.items = items;
+    _this.opt = opt;
+    return _this;
+  }
+  index._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;
+}(index.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) {
+  index._inherits(RichTextSchema, _Schema);
+  var _super = index._createSuper(RichTextSchema);
+  function RichTextSchema() {
+    var _this;
+    var opt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    index._classCallCheck(this, RichTextSchema);
+    _this = _super.call(this);
+    _this.opt = opt;
+    return _this;
+  }
+  index._createClass(RichTextSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (src === null || src === undefined) {
+        return index._defineProperty({}, path, [{
+          message: "Expected non-nullable got '".concat(src, "'")
+        }]);
+      }
+      if (index._typeof(src) !== "object" && !Array.isArray(src)) {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'object' (that is not of an array) or 'string', got '".concat(index._typeof(src), "'"),
+          value: src
+        }]);
+      }
+      if (src[index.VAL_EXTENSION] !== "richtext") {
+        return index._defineProperty({}, path, [{
+          message: "Expected _type key with value 'richtext' got '".concat(src[index.VAL_EXTENSION], "'"),
+          value: src
+        }]);
+      }
+      if (src.type !== "root") {
+        return index._defineProperty({}, path, [{
+          message: "Expected type key with value 'root' got '".concat(src.type, "'"),
+          value: src
+        }]);
+      }
+      if (index._typeof(src.children) !== "object" && !Array.isArray(src.children)) {
+        return index._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;
+}(index.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) {
+  var _ref;
+  return _ref = {}, index._defineProperty(_ref, index.GetSource, source), index._defineProperty(_ref, index.GetSchema, schema), index._defineProperty(_ref, index.Path, id), _ref;
+}
+function getSource(valModule) {
+  var sourceOrExpr = valModule[index.GetSource];
+  if (sourceOrExpr instanceof index.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 || index._typeof(schema) === "object" && "type" in schema && schema.type === "object";
+}
+function isArraySchema(schema) {
+  return schema instanceof ArraySchema || index._typeof(schema) === "object" && "type" in schema && schema.type === "array";
+}
+
+// function isI18nSchema(
+//   schema: Schema<SelectorSource> | SerializedSchema
+// ): schema is I18nSchema<readonly string[]> | SerializedI18nSchema {
+//   return (
+//     schema instanceof I18nSchema ||
+//     (typeof schema === "object" && "type" in schema && schema.type === "i18n")
+//   );
+// }
+
+function isUnionSchema(schema) {
+  return schema instanceof UnionSchema || index._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 || index._typeof(schema) === "object" && "type" in schema && schema.type === "richtext";
+}
+function isImageSchema(schema) {
+  return schema instanceof index.ImageSchema || index._typeof(schema) === "object" && "type" in schema && schema.type === "image";
+}
+
+// function isOneOfSchema(
+//   schema: Schema<SelectorSource> | SerializedSchema
+// ): schema is OneOfSchema<GenericSelector<SourceArray>> | SerializedOneOfSchema {
+//   return (
+//     schema instanceof OneOfSchema ||
+//     (typeof schema === "object" && "type" in schema && schema.type === "oneOf")
+//   );
+// }
+
+function resolvePath(path, valModule, schema) {
+  var parts = parsePath(path);
+  var origParts = index._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 (index._typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+        throw Error("Schema type error: expected source to be type of array, but got ".concat(index._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 (index._typeof(resolvedSource) !== "object") {
+        throw Error("Schema type error: expected source to be type of object, but got ".concat(index._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 ${resolvedSchema} supports locales ${resolvedSchema.locales.join(
+      //         ", "
+      //       )}, but found: ${part}`
+      //     );
+      //   }
+      //   if (!Object.keys(resolvedSource).includes(part)) {
+      //     throw Error(
+      //       `Schema type error: expected source to be type of i18n with locale ${part}, but got ${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 (index._typeof(_ret) === "object") return _ret.v;
+  }
+  if (parts.length > 0) {
+    throw Error("Invalid path: ".concat(parts.join("."), " is not a valid path"));
+  }
+  return {
+    path: origParts.map(function (p) {
+      if (!Number.isNaN(Number(p))) {
+        return p;
+      } else {
+        return JSON.stringify(p);
+      }
+    }).join("."),
+    // TODO: create a function generate path from parts (not sure if this always works)
+    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__*/index._createClass(function PatchError(message) {
+  index._classCallCheck(this, PatchError);
+  this.message = message;
+});
+
+/**
+ * NOTE: MAY mutate the input document.
+ */
+
+exports.PatchError = PatchError;
+exports.array = array;
+exports.content = content;
+exports.createValPathOfItem = createValPathOfItem;
+exports.getSource = getSource;
+exports.isSelector = isSelector;
+exports.newSelectorProxy = newSelectorProxy;
+exports.object = object;
+exports.resolvePath = resolvePath;
+exports.richtext = richtext;
+exports.splitModuleIdAndModulePath = splitModuleIdAndModulePath;
+exports.union = union;