@valbuild/core 0.43.1 → 0.44.0

package/dist/declarations/src/schema/validation/ValidationError.d.ts

@@ -3,6 +3,7 @@ import { ValidationFix } from "./ValidationFix.js";
 export type ValidationError = {
     message: string;
     value?: unknown;
+    fatal?: boolean;
     fixes?: ValidationFix[];
 };
 /**

package/dist/{ops-e02ab215.cjs.dev.js → ops-422169e5.cjs.dev.js}

@@ -163,6 +163,8 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
     value: function validate(path, src) {
       var _this2 = this;
       var error = false;
+
+      // TODO: src should never be undefined
       if (this.opt && (src === null || src === undefined)) {
         return false;
       }
@@ -328,6 +330,67 @@ var array = function array(schema) {
   return new ArraySchema(schema);
 };
 
+var LiteralSchema = /*#__PURE__*/function (_Schema) {
+  index._inherits(LiteralSchema, _Schema);
+  var _super = index._createSuper(LiteralSchema);
+  function LiteralSchema(value) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    index._classCallCheck(this, LiteralSchema);
+    _this = _super.call(this);
+    _this.value = value;
+    _this.opt = opt;
+    return _this;
+  }
+  index._createClass(LiteralSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (typeof src !== "string") {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'string', got '".concat(index._typeof(src), "'"),
+          value: src
+        }]);
+      }
+      if (src !== this.value) {
+        return index._defineProperty({}, path, [{
+          message: "Expected literal '".concat(this.value, "', got '").concat(src, "'"),
+          value: src
+        }]);
+      }
+      return false;
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      return typeof src === "string";
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new LiteralSchema(this.value, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "literal",
+        value: this.value,
+        opt: this.opt
+      };
+    }
+  }]);
+  return LiteralSchema;
+}(index.Schema);
+var literal = function literal(value) {
+  return new LiteralSchema(value);
+};
+
 var UnionSchema = /*#__PURE__*/function (_Schema) {
   index._inherits(UnionSchema, _Schema);
   var _super = index._createSuper(UnionSchema);
@@ -344,8 +407,143 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
   index._createClass(UnionSchema, [{
     key: "validate",
     value: function validate(path, src) {
-      // TODO:
-      return false;
+      var unknownSrc = src;
+      var errors = false;
+      if (this.opt && (unknownSrc === null || unknownSrc === undefined)) {
+        // TODO: src should never be undefined
+        return false;
+      }
+      if (!this.key) {
+        return index._defineProperty({}, path, [{
+          message: "Missing required first argument in union"
+        }]);
+      }
+      var key = this.key;
+      if (!Array.isArray(this.items)) {
+        return index._defineProperty({}, path, [{
+          message: "A union schema must take more than 1 schema arguments",
+          fatal: true
+        }]);
+      }
+      if (typeof key === "string") {
+        // tagged union
+        if (this.items.some(function (item) {
+          return !(item instanceof ObjectSchema);
+        })) {
+          return index._defineProperty({}, path, [{
+            message: "Key is a string, so all schema items must be objects",
+            fatal: true
+          }]);
+        }
+        var objectSchemas = this.items;
+        var serializedSchemas = objectSchemas.map(function (schema) {
+          return schema.serialize();
+        });
+        var illegalSchemas = serializedSchemas.filter(function (schema) {
+          return !(schema.type === "object") || !(schema.items[key].type === "literal");
+        });
+        if (illegalSchemas.length > 0) {
+          return index._defineProperty({}, path, [{
+            message: "All schema items must be objects with a key: ".concat(key, " that is a literal schema. Found: ").concat(JSON.stringify(illegalSchemas, null, 2)),
+            fatal: true
+          }]);
+        }
+        var serializedObjectSchemas = serializedSchemas;
+        var optionalLiterals = serializedObjectSchemas.filter(function (schema) {
+          return schema.items[key].opt;
+        });
+        if (optionalLiterals.length > 1) {
+          return index._defineProperty({}, path, [{
+            message: "Schema cannot have an optional keys: ".concat(key),
+            fatal: true
+          }]);
+        }
+        if (index._typeof(unknownSrc) !== "object") {
+          return index._defineProperty({}, path, [{
+            message: "Expected an object"
+          }]);
+        }
+        var objectSrc = unknownSrc;
+        if (objectSrc[key] === undefined) {
+          return index._defineProperty({}, path, [{
+            message: "Missing required key: ".concat(key)
+          }]);
+        }
+        var foundSchemaLiterals = [];
+        var _iterator = result._createForOfIteratorHelper(serializedObjectSchemas),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var schema = _step.value;
+            var schemaKey = schema.items[key];
+            if (schemaKey.type === "literal") {
+              if (!foundSchemaLiterals.includes(schemaKey.value)) {
+                foundSchemaLiterals.push(schemaKey.value);
+              } else {
+                return index._defineProperty({}, path, [{
+                  message: "Found duplicate key in schema: ".concat(schemaKey.value),
+                  fatal: true
+                }]);
+              }
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        var objectSchemaAtKey = objectSchemas.find(function (schema) {
+          return !schema.items[key].validate(path, objectSrc[key]);
+        });
+        if (!objectSchemaAtKey) {
+          var keyPath = createValPathOfItem(path, key);
+          if (!keyPath) {
+            throw new Error("Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at key ").concat(key));
+          }
+          return index._defineProperty({}, keyPath, [{
+            message: "Invalid key: \"".concat(key, "\". Value was: \"").concat(objectSrc[key], "\". Valid values: ").concat(serializedObjectSchemas.map(function (schema) {
+              var keySchema = schema.items[key];
+              if (keySchema.type === "literal" && keySchema.value) {
+                return "\"".concat(keySchema.value, "\"");
+              } else {
+                // should not happen here, we already checked this
+                throw new Error("Expected literal schema, got ".concat(JSON.stringify(keySchema, null, 2)));
+              }
+            }).join(", "))
+          }]);
+        }
+        var error = objectSchemaAtKey.validate(path, objectSrc);
+        if (error) {
+          return error;
+        }
+      } else if (key instanceof LiteralSchema) {
+        if (this.items.some(function (item) {
+          return !(item instanceof LiteralSchema);
+        })) {
+          return index._defineProperty({}, path, [{
+            message: "Key is a literal schema, so all schema items must be literals",
+            fatal: true
+          }]);
+        }
+        var literalItems = [key].concat(index._toConsumableArray(this.items));
+        if (typeof unknownSrc === "string") {
+          var isMatch = literalItems.some(function (item) {
+            return !item.validate(path, unknownSrc);
+          });
+          if (!isMatch) {
+            return index._defineProperty({}, path, [{
+              message: "Union must match one of the following: ".concat(literalItems.map(function (item) {
+                return "\"".concat(item.value, "\"");
+              }).join(", "))
+            }]);
+          }
+        }
+      } else {
+        return index._defineProperty({}, path, [{
+          message: "Expected a string or literal"
+        }]);
+      }
+      return errors;
     }
   }, {
     key: "assert",
@@ -776,6 +974,7 @@ exports.content = content;
 exports.createValPathOfItem = createValPathOfItem;
 exports.getSource = getSource;
 exports.isSelector = isSelector;
+exports.literal = literal;
 exports.newSelectorProxy = newSelectorProxy;
 exports.object = object;
 exports.record = record;

package/dist/{ops-d88e99cd.cjs.prod.js → ops-5bd1bd7a.cjs.prod.js}

@@ -163,6 +163,8 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
     value: function validate(path, src) {
       var _this2 = this;
       var error = false;
+
+      // TODO: src should never be undefined
       if (this.opt && (src === null || src === undefined)) {
         return false;
       }
@@ -328,6 +330,67 @@ var array = function array(schema) {
   return new ArraySchema(schema);
 };
 
+var LiteralSchema = /*#__PURE__*/function (_Schema) {
+  index._inherits(LiteralSchema, _Schema);
+  var _super = index._createSuper(LiteralSchema);
+  function LiteralSchema(value) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    index._classCallCheck(this, LiteralSchema);
+    _this = _super.call(this);
+    _this.value = value;
+    _this.opt = opt;
+    return _this;
+  }
+  index._createClass(LiteralSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (typeof src !== "string") {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'string', got '".concat(index._typeof(src), "'"),
+          value: src
+        }]);
+      }
+      if (src !== this.value) {
+        return index._defineProperty({}, path, [{
+          message: "Expected literal '".concat(this.value, "', got '").concat(src, "'"),
+          value: src
+        }]);
+      }
+      return false;
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      return typeof src === "string";
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new LiteralSchema(this.value, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "literal",
+        value: this.value,
+        opt: this.opt
+      };
+    }
+  }]);
+  return LiteralSchema;
+}(index.Schema);
+var literal = function literal(value) {
+  return new LiteralSchema(value);
+};
+
 var UnionSchema = /*#__PURE__*/function (_Schema) {
   index._inherits(UnionSchema, _Schema);
   var _super = index._createSuper(UnionSchema);
@@ -344,8 +407,143 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
   index._createClass(UnionSchema, [{
     key: "validate",
     value: function validate(path, src) {
-      // TODO:
-      return false;
+      var unknownSrc = src;
+      var errors = false;
+      if (this.opt && (unknownSrc === null || unknownSrc === undefined)) {
+        // TODO: src should never be undefined
+        return false;
+      }
+      if (!this.key) {
+        return index._defineProperty({}, path, [{
+          message: "Missing required first argument in union"
+        }]);
+      }
+      var key = this.key;
+      if (!Array.isArray(this.items)) {
+        return index._defineProperty({}, path, [{
+          message: "A union schema must take more than 1 schema arguments",
+          fatal: true
+        }]);
+      }
+      if (typeof key === "string") {
+        // tagged union
+        if (this.items.some(function (item) {
+          return !(item instanceof ObjectSchema);
+        })) {
+          return index._defineProperty({}, path, [{
+            message: "Key is a string, so all schema items must be objects",
+            fatal: true
+          }]);
+        }
+        var objectSchemas = this.items;
+        var serializedSchemas = objectSchemas.map(function (schema) {
+          return schema.serialize();
+        });
+        var illegalSchemas = serializedSchemas.filter(function (schema) {
+          return !(schema.type === "object") || !(schema.items[key].type === "literal");
+        });
+        if (illegalSchemas.length > 0) {
+          return index._defineProperty({}, path, [{
+            message: "All schema items must be objects with a key: ".concat(key, " that is a literal schema. Found: ").concat(JSON.stringify(illegalSchemas, null, 2)),
+            fatal: true
+          }]);
+        }
+        var serializedObjectSchemas = serializedSchemas;
+        var optionalLiterals = serializedObjectSchemas.filter(function (schema) {
+          return schema.items[key].opt;
+        });
+        if (optionalLiterals.length > 1) {
+          return index._defineProperty({}, path, [{
+            message: "Schema cannot have an optional keys: ".concat(key),
+            fatal: true
+          }]);
+        }
+        if (index._typeof(unknownSrc) !== "object") {
+          return index._defineProperty({}, path, [{
+            message: "Expected an object"
+          }]);
+        }
+        var objectSrc = unknownSrc;
+        if (objectSrc[key] === undefined) {
+          return index._defineProperty({}, path, [{
+            message: "Missing required key: ".concat(key)
+          }]);
+        }
+        var foundSchemaLiterals = [];
+        var _iterator = result._createForOfIteratorHelper(serializedObjectSchemas),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var schema = _step.value;
+            var schemaKey = schema.items[key];
+            if (schemaKey.type === "literal") {
+              if (!foundSchemaLiterals.includes(schemaKey.value)) {
+                foundSchemaLiterals.push(schemaKey.value);
+              } else {
+                return index._defineProperty({}, path, [{
+                  message: "Found duplicate key in schema: ".concat(schemaKey.value),
+                  fatal: true
+                }]);
+              }
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        var objectSchemaAtKey = objectSchemas.find(function (schema) {
+          return !schema.items[key].validate(path, objectSrc[key]);
+        });
+        if (!objectSchemaAtKey) {
+          var keyPath = createValPathOfItem(path, key);
+          if (!keyPath) {
+            throw new Error("Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at key ").concat(key));
+          }
+          return index._defineProperty({}, keyPath, [{
+            message: "Invalid key: \"".concat(key, "\". Value was: \"").concat(objectSrc[key], "\". Valid values: ").concat(serializedObjectSchemas.map(function (schema) {
+              var keySchema = schema.items[key];
+              if (keySchema.type === "literal" && keySchema.value) {
+                return "\"".concat(keySchema.value, "\"");
+              } else {
+                // should not happen here, we already checked this
+                throw new Error("Expected literal schema, got ".concat(JSON.stringify(keySchema, null, 2)));
+              }
+            }).join(", "))
+          }]);
+        }
+        var error = objectSchemaAtKey.validate(path, objectSrc);
+        if (error) {
+          return error;
+        }
+      } else if (key instanceof LiteralSchema) {
+        if (this.items.some(function (item) {
+          return !(item instanceof LiteralSchema);
+        })) {
+          return index._defineProperty({}, path, [{
+            message: "Key is a literal schema, so all schema items must be literals",
+            fatal: true
+          }]);
+        }
+        var literalItems = [key].concat(index._toConsumableArray(this.items));
+        if (typeof unknownSrc === "string") {
+          var isMatch = literalItems.some(function (item) {
+            return !item.validate(path, unknownSrc);
+          });
+          if (!isMatch) {
+            return index._defineProperty({}, path, [{
+              message: "Union must match one of the following: ".concat(literalItems.map(function (item) {
+                return "\"".concat(item.value, "\"");
+              }).join(", "))
+            }]);
+          }
+        }
+      } else {
+        return index._defineProperty({}, path, [{
+          message: "Expected a string or literal"
+        }]);
+      }
+      return errors;
     }
   }, {
     key: "assert",
@@ -776,6 +974,7 @@ exports.content = content;
 exports.createValPathOfItem = createValPathOfItem;
 exports.getSource = getSource;
 exports.isSelector = isSelector;
+exports.literal = literal;
 exports.newSelectorProxy = newSelectorProxy;
 exports.object = object;
 exports.record = record;

package/dist/{ops-266faf09.esm.js → ops-899d8bef.esm.js}

@@ -161,6 +161,8 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
     value: function validate(path, src) {
       var _this2 = this;
       var error = false;
+
+      // TODO: src should never be undefined
       if (this.opt && (src === null || src === undefined)) {
         return false;
       }
@@ -326,6 +328,67 @@ var array = function array(schema) {
   return new ArraySchema(schema);
 };
 
+var LiteralSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(LiteralSchema, _Schema);
+  var _super = _createSuper(LiteralSchema);
+  function LiteralSchema(value) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, LiteralSchema);
+    _this = _super.call(this);
+    _this.value = value;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(LiteralSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (typeof src !== "string") {
+        return _defineProperty({}, path, [{
+          message: "Expected 'string', got '".concat(_typeof(src), "'"),
+          value: src
+        }]);
+      }
+      if (src !== this.value) {
+        return _defineProperty({}, path, [{
+          message: "Expected literal '".concat(this.value, "', got '").concat(src, "'"),
+          value: src
+        }]);
+      }
+      return false;
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      return typeof src === "string";
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new LiteralSchema(this.value, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "literal",
+        value: this.value,
+        opt: this.opt
+      };
+    }
+  }]);
+  return LiteralSchema;
+}(Schema);
+var literal = function literal(value) {
+  return new LiteralSchema(value);
+};
+
 var UnionSchema = /*#__PURE__*/function (_Schema) {
   _inherits(UnionSchema, _Schema);
   var _super = _createSuper(UnionSchema);
@@ -342,8 +405,143 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
   _createClass(UnionSchema, [{
     key: "validate",
     value: function validate(path, src) {
-      // TODO:
-      return false;
+      var unknownSrc = src;
+      var errors = false;
+      if (this.opt && (unknownSrc === null || unknownSrc === undefined)) {
+        // TODO: src should never be undefined
+        return false;
+      }
+      if (!this.key) {
+        return _defineProperty({}, path, [{
+          message: "Missing required first argument in union"
+        }]);
+      }
+      var key = this.key;
+      if (!Array.isArray(this.items)) {
+        return _defineProperty({}, path, [{
+          message: "A union schema must take more than 1 schema arguments",
+          fatal: true
+        }]);
+      }
+      if (typeof key === "string") {
+        // tagged union
+        if (this.items.some(function (item) {
+          return !(item instanceof ObjectSchema);
+        })) {
+          return _defineProperty({}, path, [{
+            message: "Key is a string, so all schema items must be objects",
+            fatal: true
+          }]);
+        }
+        var objectSchemas = this.items;
+        var serializedSchemas = objectSchemas.map(function (schema) {
+          return schema.serialize();
+        });
+        var illegalSchemas = serializedSchemas.filter(function (schema) {
+          return !(schema.type === "object") || !(schema.items[key].type === "literal");
+        });
+        if (illegalSchemas.length > 0) {
+          return _defineProperty({}, path, [{
+            message: "All schema items must be objects with a key: ".concat(key, " that is a literal schema. Found: ").concat(JSON.stringify(illegalSchemas, null, 2)),
+            fatal: true
+          }]);
+        }
+        var serializedObjectSchemas = serializedSchemas;
+        var optionalLiterals = serializedObjectSchemas.filter(function (schema) {
+          return schema.items[key].opt;
+        });
+        if (optionalLiterals.length > 1) {
+          return _defineProperty({}, path, [{
+            message: "Schema cannot have an optional keys: ".concat(key),
+            fatal: true
+          }]);
+        }
+        if (_typeof(unknownSrc) !== "object") {
+          return _defineProperty({}, path, [{
+            message: "Expected an object"
+          }]);
+        }
+        var objectSrc = unknownSrc;
+        if (objectSrc[key] === undefined) {
+          return _defineProperty({}, path, [{
+            message: "Missing required key: ".concat(key)
+          }]);
+        }
+        var foundSchemaLiterals = [];
+        var _iterator = _createForOfIteratorHelper(serializedObjectSchemas),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var schema = _step.value;
+            var schemaKey = schema.items[key];
+            if (schemaKey.type === "literal") {
+              if (!foundSchemaLiterals.includes(schemaKey.value)) {
+                foundSchemaLiterals.push(schemaKey.value);
+              } else {
+                return _defineProperty({}, path, [{
+                  message: "Found duplicate key in schema: ".concat(schemaKey.value),
+                  fatal: true
+                }]);
+              }
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        var objectSchemaAtKey = objectSchemas.find(function (schema) {
+          return !schema.items[key].validate(path, objectSrc[key]);
+        });
+        if (!objectSchemaAtKey) {
+          var keyPath = createValPathOfItem(path, key);
+          if (!keyPath) {
+            throw new Error("Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at key ").concat(key));
+          }
+          return _defineProperty({}, keyPath, [{
+            message: "Invalid key: \"".concat(key, "\". Value was: \"").concat(objectSrc[key], "\". Valid values: ").concat(serializedObjectSchemas.map(function (schema) {
+              var keySchema = schema.items[key];
+              if (keySchema.type === "literal" && keySchema.value) {
+                return "\"".concat(keySchema.value, "\"");
+              } else {
+                // should not happen here, we already checked this
+                throw new Error("Expected literal schema, got ".concat(JSON.stringify(keySchema, null, 2)));
+              }
+            }).join(", "))
+          }]);
+        }
+        var error = objectSchemaAtKey.validate(path, objectSrc);
+        if (error) {
+          return error;
+        }
+      } else if (key instanceof LiteralSchema) {
+        if (this.items.some(function (item) {
+          return !(item instanceof LiteralSchema);
+        })) {
+          return _defineProperty({}, path, [{
+            message: "Key is a literal schema, so all schema items must be literals",
+            fatal: true
+          }]);
+        }
+        var literalItems = [key].concat(_toConsumableArray(this.items));
+        if (typeof unknownSrc === "string") {
+          var isMatch = literalItems.some(function (item) {
+            return !item.validate(path, unknownSrc);
+          });
+          if (!isMatch) {
+            return _defineProperty({}, path, [{
+              message: "Union must match one of the following: ".concat(literalItems.map(function (item) {
+                return "\"".concat(item.value, "\"");
+              }).join(", "))
+            }]);
+          }
+        }
+      } else {
+        return _defineProperty({}, path, [{
+          message: "Expected a string or literal"
+        }]);
+      }
+      return errors;
     }
   }, {
     key: "assert",
@@ -768,4 +966,4 @@ var PatchError = /*#__PURE__*/_createClass(function PatchError(message) {
  * NOTE: MAY mutate the input document.
  */
 
-export { PatchError as P, array as a, record as b, content as c, createValPathOfItem as d, resolvePath as e, getSource as g, isSelector as i, newSelectorProxy as n, object as o, richtext as r, splitModuleIdAndModulePath as s, union as u };
+export { PatchError as P, array as a, record as b, content as c, createValPathOfItem as d, resolvePath as e, getSource as g, isSelector as i, literal as l, newSelectorProxy as n, object as o, richtext as r, splitModuleIdAndModulePath as s, union as u };

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

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var ops = require('./ops-e02ab215.cjs.dev.js');
+var ops = require('./ops-422169e5.cjs.dev.js');
 var index = require('./index-a5295001.cjs.dev.js');
 var expr_dist_valbuildCoreExpr = require('./index-6deb169d.cjs.dev.js');
 var result = require('./result-48320acd.cjs.dev.js');
@@ -195,67 +195,6 @@ var _boolean = function _boolean() {
   return new BooleanSchema();
 };
 
-var LiteralSchema = /*#__PURE__*/function (_Schema) {
-  index._inherits(LiteralSchema, _Schema);
-  var _super = index._createSuper(LiteralSchema);
-  function LiteralSchema(value) {
-    var _this;
-    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    index._classCallCheck(this, LiteralSchema);
-    _this = _super.call(this);
-    _this.value = value;
-    _this.opt = opt;
-    return _this;
-  }
-  index._createClass(LiteralSchema, [{
-    key: "validate",
-    value: function validate(path, src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return false;
-      }
-      if (typeof src !== "string") {
-        return index._defineProperty({}, path, [{
-          message: "Expected 'string', got '".concat(index._typeof(src), "'"),
-          value: src
-        }]);
-      }
-      if (src !== this.value) {
-        return index._defineProperty({}, path, [{
-          message: "Expected literal '".concat(this.value, "', got '").concat(src, "'"),
-          value: src
-        }]);
-      }
-      return false;
-    }
-  }, {
-    key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
-      }
-      return typeof src === "string";
-    }
-  }, {
-    key: "optional",
-    value: function optional() {
-      return new LiteralSchema(this.value, true);
-    }
-  }, {
-    key: "serialize",
-    value: function serialize() {
-      return {
-        type: "literal",
-        value: this.value,
-        opt: this.opt
-      };
-    }
-  }]);
-  return LiteralSchema;
-}(index.Schema);
-var literal = function literal(value) {
-  return new LiteralSchema(value);
-};
-
 var KeyOfSchema = /*#__PURE__*/function (_Schema) {
   index._inherits(KeyOfSchema, _Schema);
   var _super = index._createSuper(KeyOfSchema);
@@ -403,7 +342,7 @@ function initSchema() {
     // oneOf,
     richtext: ops.richtext,
     image: index.image,
-    literal: literal,
+    literal: ops.literal,
     keyOf: keyOf,
     record: ops.record
     // i18n: i18n(locales),

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

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var ops = require('./ops-d88e99cd.cjs.prod.js');
+var ops = require('./ops-5bd1bd7a.cjs.prod.js');
 var index = require('./index-5bdaa229.cjs.prod.js');
 var expr_dist_valbuildCoreExpr = require('./index-216627d7.cjs.prod.js');
 var result = require('./result-26f67b40.cjs.prod.js');
@@ -195,67 +195,6 @@ var _boolean = function _boolean() {
   return new BooleanSchema();
 };
 
-var LiteralSchema = /*#__PURE__*/function (_Schema) {
-  index._inherits(LiteralSchema, _Schema);
-  var _super = index._createSuper(LiteralSchema);
-  function LiteralSchema(value) {
-    var _this;
-    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    index._classCallCheck(this, LiteralSchema);
-    _this = _super.call(this);
-    _this.value = value;
-    _this.opt = opt;
-    return _this;
-  }
-  index._createClass(LiteralSchema, [{
-    key: "validate",
-    value: function validate(path, src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return false;
-      }
-      if (typeof src !== "string") {
-        return index._defineProperty({}, path, [{
-          message: "Expected 'string', got '".concat(index._typeof(src), "'"),
-          value: src
-        }]);
-      }
-      if (src !== this.value) {
-        return index._defineProperty({}, path, [{
-          message: "Expected literal '".concat(this.value, "', got '").concat(src, "'"),
-          value: src
-        }]);
-      }
-      return false;
-    }
-  }, {
-    key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
-      }
-      return typeof src === "string";
-    }
-  }, {
-    key: "optional",
-    value: function optional() {
-      return new LiteralSchema(this.value, true);
-    }
-  }, {
-    key: "serialize",
-    value: function serialize() {
-      return {
-        type: "literal",
-        value: this.value,
-        opt: this.opt
-      };
-    }
-  }]);
-  return LiteralSchema;
-}(index.Schema);
-var literal = function literal(value) {
-  return new LiteralSchema(value);
-};
-
 var KeyOfSchema = /*#__PURE__*/function (_Schema) {
   index._inherits(KeyOfSchema, _Schema);
   var _super = index._createSuper(KeyOfSchema);
@@ -403,7 +342,7 @@ function initSchema() {
     // oneOf,
     richtext: ops.richtext,
     image: index.image,
-    literal: literal,
+    literal: ops.literal,
     keyOf: keyOf,
     record: ops.record
     // i18n: i18n(locales),

package/dist/valbuild-core.esm.js

@@ -1,4 +1,4 @@
-import { a as array, o as object, u as union, r as richtext$1, b as record, c as content, P as PatchError, n as newSelectorProxy, d as createValPathOfItem, i as isSelector, g as getSource, e as resolvePath, s as splitModuleIdAndModulePath } from './ops-266faf09.esm.js';
+import { a as array, o as object, u as union, r as richtext$1, l as literal, b as record, c as content, P as PatchError, n as newSelectorProxy, d as createValPathOfItem, i as isSelector, g as getSource, e as resolvePath, s as splitModuleIdAndModulePath } from './ops-899d8bef.esm.js';
 import { _ as _inherits, a as _createSuper, b as _classCallCheck, c as _createClass, d as _defineProperty, e as _typeof, S as Schema, G as GetSchema, g as getValPath, i as image, V as VAL_EXTENSION, f as file, h as _slicedToArray, j as isFile, F as FILE_REF_PROP, P as Path, k as GetSource, l as isSerializedVal, m as convertFileSource, n as getSchema, o as isVal } from './index-c83918b8.esm.js';
 export { F as FILE_REF_PROP, p as GenericSelector, S as Schema, V as VAL_EXTENSION } from './index-c83918b8.esm.js';
 export { i as expr } from './index-4f821892.esm.js';
@@ -192,67 +192,6 @@ var _boolean = function _boolean() {
   return new BooleanSchema();
 };
 
-var LiteralSchema = /*#__PURE__*/function (_Schema) {
-  _inherits(LiteralSchema, _Schema);
-  var _super = _createSuper(LiteralSchema);
-  function LiteralSchema(value) {
-    var _this;
-    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    _classCallCheck(this, LiteralSchema);
-    _this = _super.call(this);
-    _this.value = value;
-    _this.opt = opt;
-    return _this;
-  }
-  _createClass(LiteralSchema, [{
-    key: "validate",
-    value: function validate(path, src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return false;
-      }
-      if (typeof src !== "string") {
-        return _defineProperty({}, path, [{
-          message: "Expected 'string', got '".concat(_typeof(src), "'"),
-          value: src
-        }]);
-      }
-      if (src !== this.value) {
-        return _defineProperty({}, path, [{
-          message: "Expected literal '".concat(this.value, "', got '").concat(src, "'"),
-          value: src
-        }]);
-      }
-      return false;
-    }
-  }, {
-    key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
-      }
-      return typeof src === "string";
-    }
-  }, {
-    key: "optional",
-    value: function optional() {
-      return new LiteralSchema(this.value, true);
-    }
-  }, {
-    key: "serialize",
-    value: function serialize() {
-      return {
-        type: "literal",
-        value: this.value,
-        opt: this.opt
-      };
-    }
-  }]);
-  return LiteralSchema;
-}(Schema);
-var literal = function literal(value) {
-  return new LiteralSchema(value);
-};
-
 var KeyOfSchema = /*#__PURE__*/function (_Schema) {
   _inherits(KeyOfSchema, _Schema);
   var _super = _createSuper(KeyOfSchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/core",
-  "version": "0.43.1",
+  "version": "0.44.0",
   "private": false,
   "description": "Val - supercharged hard-coded content",
   "scripts": {

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

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var index = require('../../dist/index-a5295001.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-e02ab215.cjs.dev.js');
+var ops = require('../../dist/ops-422169e5.cjs.dev.js');
 
 function isNotRoot(path) {
   return result.isNonEmpty(path);

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

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var index = require('../../dist/index-5bdaa229.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-d88e99cd.cjs.prod.js');
+var ops = require('../../dist/ops-5bd1bd7a.cjs.prod.js');
 
 function isNotRoot(path) {
   return result.isNonEmpty(path);

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

@@ -1,8 +1,8 @@
 import { e as _typeof, h as _slicedToArray, c as _createClass, b as _classCallCheck, u as _toConsumableArray } from '../../dist/index-c83918b8.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 { p as pipe } from '../../dist/util-18613e99.esm.js';
-import { P as PatchError, s as splitModuleIdAndModulePath } from '../../dist/ops-266faf09.esm.js';
-export { P as PatchError } from '../../dist/ops-266faf09.esm.js';
+import { P as PatchError, s as splitModuleIdAndModulePath } from '../../dist/ops-899d8bef.esm.js';
+export { P as PatchError } from '../../dist/ops-899d8bef.esm.js';
 
 function isNotRoot(path) {
   return isNonEmpty(path);