justus 0.1.6 → 0.2.1

package/dist/validators/array.cjs

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/array.ts
+var array_exports = {};
+__export(array_exports, {
+  AnyArrayValidator: () => AnyArrayValidator,
+  ArrayValidator: () => ArrayValidator,
+  array: () => array,
+  arrayOf: () => arrayOf
+});
+module.exports = __toCommonJS(array_exports);
+var import_errors = require("../errors.cjs");
+var import_types = require("../types.cjs");
+var import_utilities = require("../utilities.cjs");
+var import_any = require("./any.cjs");
+var AnyArrayValidator = class extends import_types.AbstractValidator {
+  validate(value) {
+    (0, import_errors.assertValidation)(Array.isArray(value), 'Value is not an "array"');
+    return [...value];
+  }
+};
+var ArrayValidator = class extends import_types.AbstractValidator {
+  maxItems;
+  minItems;
+  uniqueItems;
+  items;
+  constructor(options = {}) {
+    super();
+    const {
+      items = import_any.any,
+      maxItems = Number.POSITIVE_INFINITY,
+      minItems = 0,
+      uniqueItems = false
+    } = options;
+    (0, import_errors.assertSchema)(minItems >= 0, `Constraint "minItems" (${minItems}) must be non-negative`);
+    (0, import_errors.assertSchema)(maxItems >= 0, `Constraint "maxItems" (${maxItems}) must be non-negative`);
+    (0, import_errors.assertSchema)(minItems <= maxItems, `Constraint "minItems" (${minItems}) is greater than "maxItems" (${maxItems})`);
+    this.items = items;
+    this.maxItems = maxItems;
+    this.minItems = minItems;
+    this.uniqueItems = uniqueItems;
+  }
+  validate(value, options) {
+    (0, import_errors.assertValidation)(Array.isArray(value), 'Value is not an "array"');
+    (0, import_errors.assertValidation)(
+      value.length >= this.minItems,
+      `Array must have a minimum length of ${this.minItems}`
+    );
+    (0, import_errors.assertValidation)(
+      value.length <= this.maxItems,
+      `Array must have a maximum length of ${this.maxItems}`
+    );
+    const builder = new import_errors.ValidationErrorBuilder();
+    const clone = new Array(value.length);
+    value.forEach((item, i) => {
+      try {
+        const position = value.indexOf(value[i]);
+        if (position === i) {
+          clone[i] = this.items.validate(item, options);
+        } else if (this.uniqueItems) {
+          builder.record(`Duplicate of item at index ${position}`, i);
+        } else {
+          clone[i] = clone[position];
+        }
+      } catch (error) {
+        builder.record(error, i);
+      }
+    });
+    return builder.assert(clone);
+  }
+};
+function _array(constraints) {
+  const items = constraints.items ? (0, import_utilities.getValidator)(constraints.items) : import_any.any;
+  return new ArrayValidator({ ...constraints, items });
+}
+var array = (0, import_types.makeValidatorFactory)(new AnyArrayValidator(), _array);
+function arrayOf(validation) {
+  return new ArrayValidator({ items: (0, import_utilities.getValidator)(validation) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnyArrayValidator,
+  ArrayValidator,
+  array,
+  arrayOf
+});
+//# sourceMappingURL=array.cjs.map

package/dist/validators/array.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/array.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuE;AACvE,mBAAwD;AACxD,uBAA6B;AAC7B,iBAAoB;AAqBb,IAAM,oBAAN,cAAyC,+BAAuB;AAAA,EACrE,SAAS,OAAqB;AAC5B,wCAAiB,MAAM,QAAQ,KAAK,GAAG,yBAAyB;AAChE,WAAO,CAAE,GAAG,KAAM;AAAA,EACpB;AACF;AAGO,IAAM,iBAAN,cAAgC,+BAAuB;AAAA,EACnD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,UAA0C,CAAC,GAAG;AACxD,UAAM;AAEN,UAAM;AAAA,MACJ,QAAQ;AAAA,MACR,WAAW,OAAO;AAAA,MAClB,WAAW;AAAA,MACX,cAAc;AAAA,IAChB,IAAI;AAEJ,oCAAa,YAAY,GAAG,0BAA0B,gCAAgC;AACtF,oCAAa,YAAY,GAAG,0BAA0B,gCAAgC;AACtF,oCAAa,YAAY,UAAU,0BAA0B,yCAAyC,WAAW;AAEjH,SAAK,QAAQ;AACb,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AAAA,EACrB;AAAA,EAEA,SAAS,OAAgB,SAAkC;AACzD,wCAAiB,MAAM,QAAQ,KAAK,GAAG,yBAAyB;AAEhE;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,uCAAuC,KAAK;AAAA,IAAU;AAE1D;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,uCAAuC,KAAK;AAAA,IAAU;AAE1D,UAAM,UAAU,IAAI,qCAAuB;AAC3C,UAAM,QAAe,IAAI,MAAM,MAAM,MAAM;AAE3C,UAAM,QAAQ,CAAC,MAAM,MAAM;AACzB,UAAI;AACF,cAAM,WAAW,MAAM,QAAQ,MAAM,CAAC,CAAC;AACvC,YAAI,aAAa,GAAG;AAClB,gBAAM,CAAC,IAAI,KAAK,MAAM,SAAS,MAAM,OAAO;AAAA,QAC9C,WAAW,KAAK,aAAa;AAC3B,kBAAQ,OAAO,8BAA8B,YAAY,CAAC;AAAA,QAC5D,OAAO;AACL,gBAAM,CAAC,IAAI,MAAM,QAAQ;AAAA,QAC3B;AAAA,MACF,SAAS,OAAP;AACA,gBAAQ,OAAO,OAAO,CAAC;AAAA,MACzB;AAAA,IACF,CAAC;AAED,WAAO,QAAQ,OAAO,KAAK;AAAA,EAC7B;AACF;AAIA,SAAS,OAA6B,aAAsE;AAC1G,QAAM,QAAQ,YAAY,YAAQ,+BAAa,YAAY,KAAK,IAAI;AACpE,SAAO,IAAI,eAAe,EAAE,GAAG,aAAa,MAAM,CAAC;AACrD;AAGO,IAAM,YAAQ,mCAAqB,IAAI,kBAAkB,GAAG,MAAM;AAGlE,SAAS,QAA8B,YAAgD;AAC5F,SAAO,IAAI,eAAe,EAAE,WAAO,+BAAa,UAAU,EAAE,CAAC;AAC/D;",
+  "names": []
+}

package/dist/validators/array.d.ts

@@ -0,0 +1,32 @@
+import { AbstractValidator } from '../types';
+import type { InferValidation, Validation, ValidationOptions, Validator } from '../types';
+/** Constraints to validate an `Array` with. */
+export interface ArrayConstraints<V extends Validation> {
+    /** The _maximum_ number of elements a valid `Array`: `value.length <= maxItems` */
+    maxItems?: number;
+    /** The _minimum_ number of elements a valid `Array`: `value.length >= minItems` */
+    minItems?: number;
+    /** A flag indicating whether an `Array`'s elements must be unique */
+    uniqueItems?: boolean;
+    /** A `Validator` validating each individual item in an `Array` */
+    items?: V;
+}
+/** Basic validator for `Array` instances. */
+export declare class AnyArrayValidator<T = any> extends AbstractValidator<T[]> {
+    validate(value: unknown): T[];
+}
+/** A validator for `Array` instances with constraints. */
+export declare class ArrayValidator<T> extends AbstractValidator<T[]> {
+    readonly maxItems: number;
+    readonly minItems: number;
+    readonly uniqueItems: boolean;
+    readonly items: Validator<T>;
+    constructor(options?: ArrayConstraints<Validator<T>>);
+    validate(value: unknown, options?: ValidationOptions): T[];
+}
+declare function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>>;
+/** Validate `Array`s. */
+export declare const array: typeof _array & AnyArrayValidator<any>;
+/** Validate `Array`s containing only the specified elements. */
+export declare function arrayOf<V extends Validation>(validation: V): Validator<InferValidation<V>[]>;
+export {};

package/dist/validators/array.mjs

@@ -0,0 +1,76 @@
+// validators/array.ts
+import { assertSchema, assertValidation, ValidationErrorBuilder } from "../errors.mjs";
+import { AbstractValidator, makeValidatorFactory } from "../types.mjs";
+import { getValidator } from "../utilities.mjs";
+import { any } from "./any.mjs";
+var AnyArrayValidator = class extends AbstractValidator {
+  validate(value) {
+    assertValidation(Array.isArray(value), 'Value is not an "array"');
+    return [...value];
+  }
+};
+var ArrayValidator = class extends AbstractValidator {
+  maxItems;
+  minItems;
+  uniqueItems;
+  items;
+  constructor(options = {}) {
+    super();
+    const {
+      items = any,
+      maxItems = Number.POSITIVE_INFINITY,
+      minItems = 0,
+      uniqueItems = false
+    } = options;
+    assertSchema(minItems >= 0, `Constraint "minItems" (${minItems}) must be non-negative`);
+    assertSchema(maxItems >= 0, `Constraint "maxItems" (${maxItems}) must be non-negative`);
+    assertSchema(minItems <= maxItems, `Constraint "minItems" (${minItems}) is greater than "maxItems" (${maxItems})`);
+    this.items = items;
+    this.maxItems = maxItems;
+    this.minItems = minItems;
+    this.uniqueItems = uniqueItems;
+  }
+  validate(value, options) {
+    assertValidation(Array.isArray(value), 'Value is not an "array"');
+    assertValidation(
+      value.length >= this.minItems,
+      `Array must have a minimum length of ${this.minItems}`
+    );
+    assertValidation(
+      value.length <= this.maxItems,
+      `Array must have a maximum length of ${this.maxItems}`
+    );
+    const builder = new ValidationErrorBuilder();
+    const clone = new Array(value.length);
+    value.forEach((item, i) => {
+      try {
+        const position = value.indexOf(value[i]);
+        if (position === i) {
+          clone[i] = this.items.validate(item, options);
+        } else if (this.uniqueItems) {
+          builder.record(`Duplicate of item at index ${position}`, i);
+        } else {
+          clone[i] = clone[position];
+        }
+      } catch (error) {
+        builder.record(error, i);
+      }
+    });
+    return builder.assert(clone);
+  }
+};
+function _array(constraints) {
+  const items = constraints.items ? getValidator(constraints.items) : any;
+  return new ArrayValidator({ ...constraints, items });
+}
+var array = makeValidatorFactory(new AnyArrayValidator(), _array);
+function arrayOf(validation) {
+  return new ArrayValidator({ items: getValidator(validation) });
+}
+export {
+  AnyArrayValidator,
+  ArrayValidator,
+  array,
+  arrayOf
+};
+//# sourceMappingURL=array.mjs.map

package/dist/validators/array.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/array.ts"],
+  "mappings": ";AAAA,SAAS,cAAc,kBAAkB,8BAA8B;AACvE,SAAS,mBAAmB,4BAA4B;AACxD,SAAS,oBAAoB;AAC7B,SAAS,WAAW;AAqBb,IAAM,oBAAN,cAAyC,kBAAuB;AAAA,EACrE,SAAS,OAAqB;AAC5B,qBAAiB,MAAM,QAAQ,KAAK,GAAG,yBAAyB;AAChE,WAAO,CAAE,GAAG,KAAM;AAAA,EACpB;AACF;AAGO,IAAM,iBAAN,cAAgC,kBAAuB;AAAA,EACnD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,UAA0C,CAAC,GAAG;AACxD,UAAM;AAEN,UAAM;AAAA,MACJ,QAAQ;AAAA,MACR,WAAW,OAAO;AAAA,MAClB,WAAW;AAAA,MACX,cAAc;AAAA,IAChB,IAAI;AAEJ,iBAAa,YAAY,GAAG,0BAA0B,gCAAgC;AACtF,iBAAa,YAAY,GAAG,0BAA0B,gCAAgC;AACtF,iBAAa,YAAY,UAAU,0BAA0B,yCAAyC,WAAW;AAEjH,SAAK,QAAQ;AACb,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AAAA,EACrB;AAAA,EAEA,SAAS,OAAgB,SAAkC;AACzD,qBAAiB,MAAM,QAAQ,KAAK,GAAG,yBAAyB;AAEhE;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,uCAAuC,KAAK;AAAA,IAAU;AAE1D;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,uCAAuC,KAAK;AAAA,IAAU;AAE1D,UAAM,UAAU,IAAI,uBAAuB;AAC3C,UAAM,QAAe,IAAI,MAAM,MAAM,MAAM;AAE3C,UAAM,QAAQ,CAAC,MAAM,MAAM;AACzB,UAAI;AACF,cAAM,WAAW,MAAM,QAAQ,MAAM,CAAC,CAAC;AACvC,YAAI,aAAa,GAAG;AAClB,gBAAM,CAAC,IAAI,KAAK,MAAM,SAAS,MAAM,OAAO;AAAA,QAC9C,WAAW,KAAK,aAAa;AAC3B,kBAAQ,OAAO,8BAA8B,YAAY,CAAC;AAAA,QAC5D,OAAO;AACL,gBAAM,CAAC,IAAI,MAAM,QAAQ;AAAA,QAC3B;AAAA,MACF,SAAS,OAAP;AACA,gBAAQ,OAAO,OAAO,CAAC;AAAA,MACzB;AAAA,IACF,CAAC;AAED,WAAO,QAAQ,OAAO,KAAK;AAAA,EAC7B;AACF;AAIA,SAAS,OAA6B,aAAsE;AAC1G,QAAM,QAAQ,YAAY,QAAQ,aAAa,YAAY,KAAK,IAAI;AACpE,SAAO,IAAI,eAAe,EAAE,GAAG,aAAa,MAAM,CAAC;AACrD;AAGO,IAAM,QAAQ,qBAAqB,IAAI,kBAAkB,GAAG,MAAM;AAGlE,SAAS,QAA8B,YAAgD;AAC5F,SAAO,IAAI,eAAe,EAAE,OAAO,aAAa,UAAU,EAAE,CAAC;AAC/D;",
+  "names": []
+}

package/dist/validators/boolean.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/boolean.ts
+var boolean_exports = {};
+__export(boolean_exports, {
+  BooleanValidator: () => BooleanValidator,
+  boolean: () => boolean
+});
+module.exports = __toCommonJS(boolean_exports);
+var import_errors = require("../errors.cjs");
+var import_types = require("../types.cjs");
+var BooleanValidator = class extends import_types.AbstractValidator {
+  fromString;
+  constructor(constraints = {}) {
+    super();
+    const { fromString = false } = constraints;
+    this.fromString = fromString;
+  }
+  validate(value) {
+    if (typeof value == "string" && this.fromString) {
+      const string = value.toLowerCase();
+      const parsed = string === "true" ? true : string === "false" ? false : void 0;
+      (0, import_errors.assertValidation)(parsed !== void 0, "Boolean can not be parsed from string");
+      value = parsed;
+    }
+    (0, import_errors.assertValidation)(typeof value === "boolean", 'Value is not a "boolean"');
+    return value;
+  }
+};
+function _boolean(constraints) {
+  return new BooleanValidator(constraints);
+}
+var boolean = (0, import_types.makeValidatorFactory)(new BooleanValidator(), _boolean);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BooleanValidator,
+  boolean
+});
+//# sourceMappingURL=boolean.cjs.map

package/dist/validators/boolean.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/boolean.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AACjC,mBAAwD;AAejD,IAAM,mBAAN,cAA+B,+BAA2B;AAAA,EACtD;AAAA,EAET,YAAY,cAAkC,CAAC,GAAG;AAChD,UAAM;AACN,UAAM,EAAE,aAAa,MAAM,IAAI;AAC/B,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,SAAS,OAAyB;AAEhC,QAAK,OAAO,SAAS,YAAc,KAAK,YAAa;AACnD,YAAM,SAAS,MAAM,YAAY;AACjC,YAAM,SAAS,WAAW,SAAS,OAAO,WAAW,UAAU,QAAQ;AACvE,0CAAiB,WAAW,QAAW,uCAAuC;AAC9E,cAAQ;AAAA,IACV;AAEA,wCAAiB,OAAO,UAAU,WAAW,0BAA0B;AACvE,WAAO;AAAA,EACT;AACF;AAEA,SAAS,SAAS,aAAmD;AACnE,SAAO,IAAI,iBAAiB,WAAW;AACzC;AAGO,IAAM,cAAU,mCAAqB,IAAI,iBAAiB,GAAG,QAAQ;",
+  "names": []
+}

package/dist/validators/boolean.d.ts

@@ -0,0 +1,21 @@
+import { AbstractValidator } from '../types';
+/** Constraints to validate a `boolean` with. */
+export interface BooleanConstraints {
+    /**
+     * Allow booleans to be parsed from strings (default: `false`).
+     *
+     * The string in question _MUST_ be either `true` or `false`, and will be
+     * compared regardless of case.
+     */
+    fromString?: boolean;
+}
+/** A `Validator` validating `boolean`s. */
+export declare class BooleanValidator extends AbstractValidator<boolean> {
+    readonly fromString: boolean;
+    constructor(constraints?: BooleanConstraints);
+    validate(value: unknown): boolean;
+}
+declare function _boolean(constraints: BooleanConstraints): BooleanValidator;
+/** The `Validator` for `boolean`s. */
+export declare const boolean: typeof _boolean & BooleanValidator;
+export {};

package/dist/validators/boolean.mjs

@@ -0,0 +1,30 @@
+// validators/boolean.ts
+import { assertValidation } from "../errors.mjs";
+import { AbstractValidator, makeValidatorFactory } from "../types.mjs";
+var BooleanValidator = class extends AbstractValidator {
+  fromString;
+  constructor(constraints = {}) {
+    super();
+    const { fromString = false } = constraints;
+    this.fromString = fromString;
+  }
+  validate(value) {
+    if (typeof value == "string" && this.fromString) {
+      const string = value.toLowerCase();
+      const parsed = string === "true" ? true : string === "false" ? false : void 0;
+      assertValidation(parsed !== void 0, "Boolean can not be parsed from string");
+      value = parsed;
+    }
+    assertValidation(typeof value === "boolean", 'Value is not a "boolean"');
+    return value;
+  }
+};
+function _boolean(constraints) {
+  return new BooleanValidator(constraints);
+}
+var boolean = makeValidatorFactory(new BooleanValidator(), _boolean);
+export {
+  BooleanValidator,
+  boolean
+};
+//# sourceMappingURL=boolean.mjs.map

package/dist/validators/boolean.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/boolean.ts"],
+  "mappings": ";AAAA,SAAS,wBAAwB;AACjC,SAAS,mBAAmB,4BAA4B;AAejD,IAAM,mBAAN,cAA+B,kBAA2B;AAAA,EACtD;AAAA,EAET,YAAY,cAAkC,CAAC,GAAG;AAChD,UAAM;AACN,UAAM,EAAE,aAAa,MAAM,IAAI;AAC/B,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,SAAS,OAAyB;AAEhC,QAAK,OAAO,SAAS,YAAc,KAAK,YAAa;AACnD,YAAM,SAAS,MAAM,YAAY;AACjC,YAAM,SAAS,WAAW,SAAS,OAAO,WAAW,UAAU,QAAQ;AACvE,uBAAiB,WAAW,QAAW,uCAAuC;AAC9E,cAAQ;AAAA,IACV;AAEA,qBAAiB,OAAO,UAAU,WAAW,0BAA0B;AACvE,WAAO;AAAA,EACT;AACF;AAEA,SAAS,SAAS,aAAmD;AACnE,SAAO,IAAI,iBAAiB,WAAW;AACzC;AAGO,IAAM,UAAU,qBAAqB,IAAI,iBAAiB,GAAG,QAAQ;",
+  "names": []
+}

package/dist/validators/constant.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/constant.ts
+var constant_exports = {};
+__export(constant_exports, {
+  ConstantValidator: () => ConstantValidator,
+  constant: () => constant,
+  nullValidator: () => nullValidator
+});
+module.exports = __toCommonJS(constant_exports);
+var import_errors = require("../errors.cjs");
+var import_types = require("../types.cjs");
+var ConstantValidator = class extends import_types.AbstractValidator {
+  constant;
+  constructor(constant2) {
+    super();
+    this.constant = constant2;
+  }
+  validate(value) {
+    (0, import_errors.assertValidation)(value === this.constant, `Value does not match constant "${this.constant}"`);
+    return value;
+  }
+};
+function constant(constant2) {
+  return new ConstantValidator(constant2);
+}
+var nullValidator = new ConstantValidator(null);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConstantValidator,
+  constant,
+  nullValidator
+});
+//# sourceMappingURL=constant.cjs.map

package/dist/validators/constant.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/constant.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;AACjC,mBAAkC;AAK3B,IAAM,oBAAN,cAA4E,+BAAqB;AAAA,EAC7F;AAAA,EAET,YAAYA,WAAa;AACvB,UAAM;AACN,SAAK,WAAWA;AAAA,EAClB;AAAA,EAEA,SAAS,OAAmB;AAC1B,wCAAiB,UAAU,KAAK,UAAU,kCAAkC,KAAK,WAAW;AAC5F,WAAO;AAAA,EACT;AACF;AAGO,SAAS,SAAqDA,WAA2B;AAC9F,SAAO,IAAI,kBAAkBA,SAAQ;AACvC;AAGO,IAAM,gBAAgB,IAAI,kBAAkB,IAAI;",
+  "names": ["constant"]
+}

package/dist/validators/constant.d.ts

@@ -0,0 +1,12 @@
+import { AbstractValidator } from '../types';
+import type { Validator } from '../types';
+/** A `Validator` for _constants_. */
+export declare class ConstantValidator<T extends string | number | boolean | null> extends AbstractValidator<T> {
+    readonly constant: T;
+    constructor(constant: T);
+    validate(value: unknown): T;
+}
+/** Validate _constants_. */
+export declare function constant<T extends string | number | boolean | null>(constant: T): Validator<T>;
+/** The `Validator` for the `null` constant. */
+export declare const nullValidator: ConstantValidator<null>;

package/dist/validators/constant.mjs

@@ -0,0 +1,24 @@
+// validators/constant.ts
+import { assertValidation } from "../errors.mjs";
+import { AbstractValidator } from "../types.mjs";
+var ConstantValidator = class extends AbstractValidator {
+  constant;
+  constructor(constant2) {
+    super();
+    this.constant = constant2;
+  }
+  validate(value) {
+    assertValidation(value === this.constant, `Value does not match constant "${this.constant}"`);
+    return value;
+  }
+};
+function constant(constant2) {
+  return new ConstantValidator(constant2);
+}
+var nullValidator = new ConstantValidator(null);
+export {
+  ConstantValidator,
+  constant,
+  nullValidator
+};
+//# sourceMappingURL=constant.mjs.map

package/dist/validators/constant.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/constant.ts"],
+  "mappings": ";AAAA,SAAS,wBAAwB;AACjC,SAAS,yBAAyB;AAK3B,IAAM,oBAAN,cAA4E,kBAAqB;AAAA,EAC7F;AAAA,EAET,YAAYA,WAAa;AACvB,UAAM;AACN,SAAK,WAAWA;AAAA,EAClB;AAAA,EAEA,SAAS,OAAmB;AAC1B,qBAAiB,UAAU,KAAK,UAAU,kCAAkC,KAAK,WAAW;AAC5F,WAAO;AAAA,EACT;AACF;AAGO,SAAS,SAAqDA,WAA2B;AAC9F,SAAO,IAAI,kBAAkBA,SAAQ;AACvC;AAGO,IAAM,gBAAgB,IAAI,kBAAkB,IAAI;",
+  "names": ["constant"]
+}

package/dist/validators/date.cjs

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/date.ts
+var date_exports = {};
+__export(date_exports, {
+  DateValidator: () => DateValidator,
+  date: () => date
+});
+module.exports = __toCommonJS(date_exports);
+var import_errors = require("../errors.cjs");
+var import_types = require("../types.cjs");
+var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+var DateValidator = class extends import_types.AbstractValidator {
+  format;
+  from;
+  until;
+  constructor(constraints = {}) {
+    super();
+    const { format, from, until } = constraints;
+    if (from != void 0 && until !== void 0) {
+      (0, import_errors.assertSchema)(
+        until.getTime() >= from.getTime(),
+        `Constraint "until" (${until.toISOString()}) must not be before "from" (${from.toISOString()})`
+      );
+    }
+    this.format = format;
+    this.from = from;
+    this.until = until;
+  }
+  validate(value) {
+    let date2;
+    try {
+      date2 = new Date(value);
+    } catch (error) {
+      throw new import_errors.ValidationError('Value could not be converted to a "Date"');
+    }
+    if (isNaN(date2.getTime()))
+      throw new import_errors.ValidationError("Invalid date");
+    if (this.format === "iso") {
+      (0, import_errors.assertValidation)(typeof value === "string", 'ISO Date is not a "string"');
+      (0, import_errors.assertValidation)(ISO_8601_REGEX.test(value), "Invalid format for ISO Date");
+    } else if (this.format === "timestamp") {
+      (0, import_errors.assertValidation)(typeof value === "number", 'Timestamp is not a "number"');
+    }
+    if (this.from) {
+      (0, import_errors.assertValidation)(this.from.getTime() <= date2.getTime(), `Date is before ${this.from.toISOString()}`);
+    }
+    if (this.until) {
+      (0, import_errors.assertValidation)(this.until.getTime() >= date2.getTime(), `Date is after ${this.until.toISOString()}`);
+    }
+    return date2;
+  }
+};
+function _date(constraints) {
+  return new DateValidator(constraints);
+}
+var date = (0, import_types.makeValidatorFactory)(new DateValidator(), _date);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DateValidator,
+  date
+});
+//# sourceMappingURL=date.cjs.map

package/dist/validators/date.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/date.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgE;AAChE,mBAAwD;AAGxD,IAAM,iBAAiB;AAahB,IAAM,gBAAN,cAA4B,+BAAwB;AAAA,EAChD;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,cAA+B,CAAC,GAAG;AAC7C,UAAM;AAEN,UAAM,EAAE,QAAQ,MAAM,MAAM,IAAI;AAEhC,QAAK,QAAQ,UAAe,UAAU,QAAY;AAChD;AAAA,QAAa,MAAM,QAAQ,KAAK,KAAK,QAAQ;AAAA,QACzC,uBAAuB,MAAM,YAAY,iCAAiC,KAAK,YAAY;AAAA,MAAI;AAAA,IACrG;AAEA,SAAK,SAAS;AACd,SAAK,OAAO;AACZ,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,SAAS,OAAsB;AAC7B,QAAIA;AACJ,QAAI;AACF,MAAAA,QAAO,IAAI,KAAK,KAAY;AAAA,IAC9B,SAAS,OAAP;AACA,YAAM,IAAI,8BAAgB,0CAA0C;AAAA,IACtE;AAEA,QAAI,MAAMA,MAAK,QAAQ,CAAC;AAAG,YAAM,IAAI,8BAAgB,cAAc;AAEnE,QAAI,KAAK,WAAW,OAAO;AACzB,0CAAiB,OAAO,UAAU,UAAU,4BAA4B;AACxE,0CAAiB,eAAe,KAAK,KAAK,GAAG,6BAA6B;AAAA,IAC5E,WAAW,KAAK,WAAW,aAAa;AACtC,0CAAiB,OAAO,UAAU,UAAU,6BAA6B;AAAA,IAC3E;AAEA,QAAI,KAAK,MAAM;AACb,0CAAiB,KAAK,KAAK,QAAQ,KAAKA,MAAK,QAAQ,GAAG,kBAAkB,KAAK,KAAK,YAAY,GAAG;AAAA,IACrG;AAEA,QAAI,KAAK,OAAO;AACd,0CAAiB,KAAK,MAAM,QAAQ,KAAKA,MAAK,QAAQ,GAAG,iBAAiB,KAAK,MAAM,YAAY,GAAG;AAAA,IACtG;AAEA,WAAOA;AAAA,EACT;AACF;AAEA,SAAS,MAAM,aAA6C;AAC1D,SAAO,IAAI,cAAc,WAAW;AACtC;AAGO,IAAM,WAAO,mCAAqB,IAAI,cAAc,GAAG,KAAK;",
+  "names": ["date"]
+}

package/dist/validators/date.d.ts

@@ -0,0 +1,22 @@
+import { AbstractValidator } from '../types';
+/** Constraints to validate a `Date` with. */
+export interface DateConstraints {
+    /** The format for dates, an _ISO date_ (RFC 3339) or a numeric timestamp */
+    format?: 'iso' | 'timestamp';
+    /** The earliest value a date can have */
+    from?: Date;
+    /** The latest value a date can have */
+    until?: Date;
+}
+/** A `Validator` validating dates and converting them to `Date` instances. */
+export declare class DateValidator extends AbstractValidator<Date> {
+    readonly format?: 'iso' | 'timestamp';
+    readonly from?: Date;
+    readonly until?: Date;
+    constructor(constraints?: DateConstraints);
+    validate(value: unknown): Date;
+}
+declare function _date(constraints: DateConstraints): DateValidator;
+/** Validate dates and convert them to `Date` instances. */
+export declare const date: typeof _date & DateValidator;
+export {};

package/dist/validators/date.mjs

@@ -0,0 +1,54 @@
+// validators/date.ts
+import { assertSchema, assertValidation, ValidationError } from "../errors.mjs";
+import { AbstractValidator, makeValidatorFactory } from "../types.mjs";
+var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+var DateValidator = class extends AbstractValidator {
+  format;
+  from;
+  until;
+  constructor(constraints = {}) {
+    super();
+    const { format, from, until } = constraints;
+    if (from != void 0 && until !== void 0) {
+      assertSchema(
+        until.getTime() >= from.getTime(),
+        `Constraint "until" (${until.toISOString()}) must not be before "from" (${from.toISOString()})`
+      );
+    }
+    this.format = format;
+    this.from = from;
+    this.until = until;
+  }
+  validate(value) {
+    let date2;
+    try {
+      date2 = new Date(value);
+    } catch (error) {
+      throw new ValidationError('Value could not be converted to a "Date"');
+    }
+    if (isNaN(date2.getTime()))
+      throw new ValidationError("Invalid date");
+    if (this.format === "iso") {
+      assertValidation(typeof value === "string", 'ISO Date is not a "string"');
+      assertValidation(ISO_8601_REGEX.test(value), "Invalid format for ISO Date");
+    } else if (this.format === "timestamp") {
+      assertValidation(typeof value === "number", 'Timestamp is not a "number"');
+    }
+    if (this.from) {
+      assertValidation(this.from.getTime() <= date2.getTime(), `Date is before ${this.from.toISOString()}`);
+    }
+    if (this.until) {
+      assertValidation(this.until.getTime() >= date2.getTime(), `Date is after ${this.until.toISOString()}`);
+    }
+    return date2;
+  }
+};
+function _date(constraints) {
+  return new DateValidator(constraints);
+}
+var date = makeValidatorFactory(new DateValidator(), _date);
+export {
+  DateValidator,
+  date
+};
+//# sourceMappingURL=date.mjs.map

package/dist/validators/date.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/date.ts"],
+  "mappings": ";AAAA,SAAS,cAAc,kBAAkB,uBAAuB;AAChE,SAAS,mBAAmB,4BAA4B;AAGxD,IAAM,iBAAiB;AAahB,IAAM,gBAAN,cAA4B,kBAAwB;AAAA,EAChD;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,cAA+B,CAAC,GAAG;AAC7C,UAAM;AAEN,UAAM,EAAE,QAAQ,MAAM,MAAM,IAAI;AAEhC,QAAK,QAAQ,UAAe,UAAU,QAAY;AAChD;AAAA,QAAa,MAAM,QAAQ,KAAK,KAAK,QAAQ;AAAA,QACzC,uBAAuB,MAAM,YAAY,iCAAiC,KAAK,YAAY;AAAA,MAAI;AAAA,IACrG;AAEA,SAAK,SAAS;AACd,SAAK,OAAO;AACZ,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,SAAS,OAAsB;AAC7B,QAAIA;AACJ,QAAI;AACF,MAAAA,QAAO,IAAI,KAAK,KAAY;AAAA,IAC9B,SAAS,OAAP;AACA,YAAM,IAAI,gBAAgB,0CAA0C;AAAA,IACtE;AAEA,QAAI,MAAMA,MAAK,QAAQ,CAAC;AAAG,YAAM,IAAI,gBAAgB,cAAc;AAEnE,QAAI,KAAK,WAAW,OAAO;AACzB,uBAAiB,OAAO,UAAU,UAAU,4BAA4B;AACxE,uBAAiB,eAAe,KAAK,KAAK,GAAG,6BAA6B;AAAA,IAC5E,WAAW,KAAK,WAAW,aAAa;AACtC,uBAAiB,OAAO,UAAU,UAAU,6BAA6B;AAAA,IAC3E;AAEA,QAAI,KAAK,MAAM;AACb,uBAAiB,KAAK,KAAK,QAAQ,KAAKA,MAAK,QAAQ,GAAG,kBAAkB,KAAK,KAAK,YAAY,GAAG;AAAA,IACrG;AAEA,QAAI,KAAK,OAAO;AACd,uBAAiB,KAAK,MAAM,QAAQ,KAAKA,MAAK,QAAQ,GAAG,iBAAiB,KAAK,MAAM,YAAY,GAAG;AAAA,IACtG;AAEA,WAAOA;AAAA,EACT;AACF;AAEA,SAAS,MAAM,aAA6C;AAC1D,SAAO,IAAI,cAAc,WAAW;AACtC;AAGO,IAAM,OAAO,qBAAqB,IAAI,cAAc,GAAG,KAAK;",
+  "names": ["date"]
+}