@modulify/validator 0.1.0 → 0.2.0

package/dist/combinators.cjs

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assert = require("./assert.cjs");
+const metadata = require("./metadata.cjs.js");
+const predicates = require("./predicates.cjs");
+const describeConstraintMap = (constraints) => {
+  const described = {};
+  Reflect.ownKeys(constraints).forEach((key) => {
+    described[key] = metadata.describeConstraints(constraints[key]);
+  });
+  return described;
+};
+const normalizeRuleDescriptor = (descriptor) => {
+  if (!descriptor.metadata) {
+    return descriptor;
+  }
+  return {
+    ...descriptor,
+    metadata: Object.freeze({ ...descriptor.metadata })
+  };
+};
+const passthrough = (kind, accepts, constraints) => metadata.attachConstraintDescriptor({
+  check(value) {
+    return accepts(value) || metadata.matchesConstraints(value, constraints);
+  },
+  run(validate, value, path) {
+    return accepts(value) ? [] : [validate(value, constraints, path)];
+  }
+}, () => ({
+  kind,
+  child: metadata.describeConstraints(constraints)
+}));
+const keysOf = (value) => Object.keys(value);
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const hasUnknownKeys = (value, descriptor) => Object.keys(value).some((key) => !hasOwn(descriptor, key));
+const collectUnknownKeyViolations = (value, path, descriptor) => Object.keys(value).filter((key) => !hasOwn(descriptor, key)).map((key) => [{
+  value: value[key],
+  path: [...path, key],
+  violates: { kind: "validator", name: "shape", code: "shape.unknown-key", args: [] }
+}]);
+const pickDescriptor = (descriptor, keys) => {
+  const picked = {};
+  keys.forEach((key) => {
+    if (hasOwn(descriptor, key)) {
+      picked[key] = descriptor[key];
+    }
+  });
+  return picked;
+};
+const omitDescriptor = (descriptor, keys) => {
+  const omitted = { ...descriptor };
+  keys.forEach((key) => {
+    delete omitted[key];
+  });
+  return omitted;
+};
+const extendDescriptor = (descriptor, extension) => ({
+  ...descriptor,
+  ...extension
+});
+const partialDescriptor = (descriptor) => {
+  const partial = {};
+  keysOf(descriptor).forEach((key) => {
+    partial[key] = optional(descriptor[key]);
+  });
+  return partial;
+};
+const getPathValue = (value, path) => path.reduce((current, key) => {
+  if (current === null || current === void 0) {
+    return void 0;
+  }
+  return Reflect.get(Object(current), key);
+}, value);
+const toPath = (selector) => Array.isArray(selector) ? [...selector] : [selector];
+const collectShapeRefinementViolations = (value, path, refinements) => refinements.flatMap((refinement) => {
+  const result = refinement(value);
+  if (result === null || result === void 0) {
+    return [];
+  }
+  return metadata.arrayify(result).filter((issue) => issue !== null && issue !== void 0).map((issue) => {
+    const issuePath = issue.path ? [...issue.path] : [];
+    return {
+      value: issue.value ?? getPathValue(value, issuePath),
+      path: [...path, ...issuePath],
+      violates: {
+        kind: "validator",
+        name: "shape",
+        code: issue.code,
+        args: issue.args ?? []
+      }
+    };
+  });
+});
+const createObjectShape = (descriptor, unknownKeys, refinements, rules) => {
+  const keys = keysOf(descriptor);
+  return metadata.attachConstraintDescriptor({
+    descriptor,
+    unknownKeys,
+    check(value) {
+      return predicates.isRecord(value) && keys.every((key) => metadata.matchesConstraints(value[key], descriptor[key])) && (unknownKeys === "passthrough" || !hasUnknownKeys(value, descriptor)) && collectShapeRefinementViolations(value, [], refinements).length === 0;
+    },
+    run(validate, value, path) {
+      if (!predicates.isRecord(value)) {
+        return [[{
+          value,
+          path,
+          violates: { kind: "validator", name: "shape", code: "type.record", args: [] }
+        }]];
+      }
+      const validations = keys.reduce((all, key) => [
+        ...all,
+        validate(value[key], descriptor[key], [...path, key])
+      ], []);
+      if (unknownKeys === "strict") {
+        validations.push(...collectUnknownKeyViolations(value, path, descriptor));
+      }
+      if (validations.some((validation) => validation instanceof Promise)) {
+        return [Promise.all(validations.map((validation) => Promise.resolve(validation))).then((results) => {
+          const structuralViolations2 = results.flat();
+          return structuralViolations2.length > 0 ? structuralViolations2 : collectShapeRefinementViolations(value, path, refinements);
+        })];
+      }
+      const structuralViolations = validations.flat();
+      return structuralViolations.length > 0 ? validations : [collectShapeRefinementViolations(value, path, refinements)];
+    },
+    refine(refinement, ruleDescriptor = { kind: "refine" }) {
+      return createObjectShape(
+        descriptor,
+        unknownKeys,
+        [...refinements, refinement],
+        [...rules, normalizeRuleDescriptor(ruleDescriptor)]
+      );
+    },
+    fieldsMatch(selectedKeys) {
+      const [left, right] = selectedKeys;
+      const leftPath = toPath(left);
+      const rightPath = toPath(right);
+      const ruleDescriptor = {
+        kind: "fieldsMatch",
+        selectors: [left, right]
+      };
+      return createObjectShape(
+        descriptor,
+        unknownKeys,
+        [...refinements, (value) => {
+          return getPathValue(value, leftPath) === getPathValue(value, rightPath) ? [] : [{
+            path: rightPath,
+            code: "shape.fields.mismatch",
+            args: [selectedKeys]
+          }];
+        }],
+        [...rules, ruleDescriptor]
+      );
+    },
+    strict() {
+      return createObjectShape(descriptor, "strict", refinements, rules);
+    },
+    passthrough() {
+      return createObjectShape(descriptor, "passthrough", refinements, rules);
+    },
+    pick(selectedKeys) {
+      return createObjectShape(pickDescriptor(descriptor, selectedKeys), unknownKeys, [], []);
+    },
+    omit(selectedKeys) {
+      return createObjectShape(omitDescriptor(descriptor, selectedKeys), unknownKeys, [], []);
+    },
+    partial() {
+      return createObjectShape(partialDescriptor(descriptor), unknownKeys, [], []);
+    },
+    extend(extension) {
+      return createObjectShape(extendDescriptor(descriptor, extension), unknownKeys, [], []);
+    },
+    merge(shape2) {
+      return createObjectShape(extendDescriptor(descriptor, shape2.descriptor), unknownKeys, [], []);
+    }
+  }, () => ({
+    kind: "shape",
+    unknownKeys,
+    fields: describeConstraintMap(descriptor),
+    rules
+  }));
+};
+const toUnionFailure = (branches, value, path, branchResults) => {
+  const matched = branchResults.find((result) => result.length === 0);
+  if (matched) {
+    return matched;
+  }
+  return [{
+    value,
+    path,
+    violates: { kind: "validator", name: "union", code: "union.no-match", args: [branches.length] }
+  }, ...branchResults.flat()];
+};
+const collectUnionViolations = (branches, validate, value, path) => {
+  const branchResults = branches.map((branch) => validate(value, branch, path));
+  if (branchResults.some((result) => result instanceof Promise)) {
+    return Promise.all(branchResults.map((result) => Promise.resolve(result))).then((results) => {
+      return toUnionFailure(branches, value, path, results);
+    });
+  }
+  return toUnionFailure(branches, value, path, branchResults);
+};
+const each = (constraints) => metadata.attachConstraintDescriptor({
+  check(value) {
+    return predicates.isArray(value) && value.every((item) => metadata.matchesConstraints(item, constraints));
+  },
+  run(validate, value, path) {
+    return predicates.isArray(value) ? value.map((item, index) => validate(item, constraints, [...path, index])) : [[{
+      value,
+      path,
+      violates: { kind: "validator", name: "each", code: "type.array", args: [] }
+    }]];
+  }
+}, () => ({
+  kind: "each",
+  item: metadata.describeConstraints(constraints)
+}));
+const tuple = (constraints) => metadata.attachConstraintDescriptor({
+  check(value) {
+    return predicates.isArray(value) && value.length === constraints.length && constraints.every((constraint, index) => metadata.matchesConstraints(value[index], constraint));
+  },
+  run(validate, value, path) {
+    if (!predicates.isArray(value)) {
+      return [[{
+        value,
+        path,
+        violates: { kind: "validator", name: "tuple", code: "type.array", args: [] }
+      }]];
+    }
+    if (value.length !== constraints.length) {
+      return [[{
+        value,
+        path,
+        violates: { kind: "validator", name: "tuple", code: "tuple.length", args: [constraints.length] }
+      }]];
+    }
+    return constraints.map((constraint, index) => validate(value[index], constraint, [...path, index]));
+  }
+}, () => ({
+  kind: "tuple",
+  items: constraints.map((constraint) => metadata.describeConstraints(constraint))
+}));
+const union = (constraints) => metadata.attachConstraintDescriptor({
+  check(value) {
+    return constraints.some((constraint) => metadata.matchesConstraints(value, constraint));
+  },
+  run(validate, value, path) {
+    return [collectUnionViolations(constraints, validate, value, path)];
+  }
+}, () => ({
+  kind: "union",
+  branches: constraints.map((constraint) => metadata.describeConstraints(constraint))
+}));
+const discriminatedUnion = (key, variants) => metadata.attachConstraintDescriptor({
+  check(value) {
+    if (!predicates.isRecord(value)) {
+      return false;
+    }
+    const discriminator = value[key];
+    return Object.prototype.hasOwnProperty.call(variants, discriminator) && metadata.matchesConstraints(value, variants[discriminator]);
+  },
+  run(validate, value, path) {
+    if (!predicates.isRecord(value)) {
+      return [[{
+        value,
+        path,
+        violates: { kind: "validator", name: "discriminatedUnion", code: "type.record", args: [] }
+      }]];
+    }
+    const discriminator = value[key];
+    if (!Object.prototype.hasOwnProperty.call(variants, discriminator)) {
+      return [[{
+        value: discriminator,
+        path: [...path, key],
+        violates: {
+          kind: "validator",
+          name: "discriminatedUnion",
+          code: "union.invalid-discriminator",
+          args: [Reflect.ownKeys(variants)]
+        }
+      }]];
+    }
+    return [validate(value, variants[discriminator], path)];
+  }
+}, () => ({
+  kind: "discriminatedUnion",
+  key,
+  variants: describeConstraintMap(variants)
+}));
+const record = (constraints) => metadata.attachConstraintDescriptor({
+  check(value) {
+    return predicates.isRecord(value) && Object.values(value).every((item) => metadata.matchesConstraints(item, constraints));
+  },
+  run(validate, value, path) {
+    if (!predicates.isRecord(value)) {
+      return [[{
+        value,
+        path,
+        violates: { kind: "validator", name: "record", code: "type.record", args: [] }
+      }]];
+    }
+    return Object.keys(value).map((key) => validate(value[key], constraints, [...path, key]));
+  }
+}, () => ({
+  kind: "record",
+  values: metadata.describeConstraints(constraints)
+}));
+const shape = (descriptor) => {
+  return createObjectShape(descriptor, "passthrough", [], []);
+};
+const exact = (value) => assert.assert(predicates.isExact(value), {
+  name: "exact",
+  bail: true,
+  code: "value.exact",
+  args: [value]
+});
+const optional = (constraints) => passthrough(
+  "optional",
+  predicates.isUndefined,
+  constraints
+);
+const nullable = (constraints) => passthrough(
+  "nullable",
+  predicates.isNull,
+  constraints
+);
+const nullish = (constraints) => passthrough(
+  "nullish",
+  (value) => predicates.isNull(value) || predicates.isUndefined(value),
+  constraints
+);
+exports.discriminatedUnion = discriminatedUnion;
+exports.each = each;
+exports.exact = exact;
+exports.nullable = nullable;
+exports.nullish = nullish;
+exports.optional = optional;
+exports.record = record;
+exports.shape = shape;
+exports.tuple = tuple;
+exports.union = union;

package/dist/combinators.d.ts

@@ -0,0 +1,17 @@
+import { Constraint, DiscriminatedUnionValidator, EachValidator, InferConstraints, MaybeMany, NullableValidator, NullishValidator, ObjectShape, OptionalValidator, RecordValidator, TupleValidator, UnionValidator, Assertion } from '../types';
+export type ShapeDescriptor = Record<PropertyKey, MaybeMany<Constraint>>;
+export type InferShape<D extends ShapeDescriptor> = {
+    [K in keyof D]: InferConstraints<D[K]>;
+};
+export type { ObjectShapeFieldSelector, ObjectShape, ObjectShapeRefinement, ObjectShapeRefinementIssue, UnknownKeysMode, } from '../types';
+type VariantMap = Record<PropertyKey, MaybeMany<Constraint>>;
+export declare const each: <const C extends MaybeMany<Constraint>>(constraints: C) => EachValidator<C>;
+export declare const tuple: <const T extends readonly MaybeMany<Constraint>[]>(constraints: T) => TupleValidator<T>;
+export declare const union: <const T extends readonly MaybeMany<Constraint>[]>(constraints: T) => UnionValidator<T>;
+export declare const discriminatedUnion: <const K extends PropertyKey, const T extends VariantMap>(key: K, variants: T) => DiscriminatedUnionValidator<K, T>;
+export declare const record: <const C extends MaybeMany<Constraint>>(constraints: C) => RecordValidator<C>;
+export declare const shape: <const D extends ShapeDescriptor>(descriptor: D) => ObjectShape<D, "passthrough", [], never>;
+export declare const exact: <const T>(value: T) => Assertion<T, [], "value.exact", readonly [T], "exact">;
+export declare const optional: <const C extends MaybeMany<Constraint>>(constraints: C) => OptionalValidator<C>;
+export declare const nullable: <const C extends MaybeMany<Constraint>>(constraints: C) => NullableValidator<C>;
+export declare const nullish: <const C extends MaybeMany<Constraint>>(constraints: C) => NullishValidator<C>;

package/dist/combinators.mjs

@@ -0,0 +1,341 @@
+import { assert } from "./assert.mjs";
+import { e as attachConstraintDescriptor, f as matchesConstraints, d as describeConstraints, a as arrayify } from "./metadata.es.js";
+import { isRecord, isArray, isExact, isUndefined, isNull } from "./predicates.mjs";
+const describeConstraintMap = (constraints) => {
+  const described = {};
+  Reflect.ownKeys(constraints).forEach((key) => {
+    described[key] = describeConstraints(constraints[key]);
+  });
+  return described;
+};
+const normalizeRuleDescriptor = (descriptor) => {
+  if (!descriptor.metadata) {
+    return descriptor;
+  }
+  return {
+    ...descriptor,
+    metadata: Object.freeze({ ...descriptor.metadata })
+  };
+};
+const passthrough = (kind, accepts, constraints) => attachConstraintDescriptor({
+  check(value) {
+    return accepts(value) || matchesConstraints(value, constraints);
+  },
+  run(validate, value, path) {
+    return accepts(value) ? [] : [validate(value, constraints, path)];
+  }
+}, () => ({
+  kind,
+  child: describeConstraints(constraints)
+}));
+const keysOf = (value) => Object.keys(value);
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const hasUnknownKeys = (value, descriptor) => Object.keys(value).some((key) => !hasOwn(descriptor, key));
+const collectUnknownKeyViolations = (value, path, descriptor) => Object.keys(value).filter((key) => !hasOwn(descriptor, key)).map((key) => [{
+  value: value[key],
+  path: [...path, key],
+  violates: { kind: "validator", name: "shape", code: "shape.unknown-key", args: [] }
+}]);
+const pickDescriptor = (descriptor, keys) => {
+  const picked = {};
+  keys.forEach((key) => {
+    if (hasOwn(descriptor, key)) {
+      picked[key] = descriptor[key];
+    }
+  });
+  return picked;
+};
+const omitDescriptor = (descriptor, keys) => {
+  const omitted = { ...descriptor };
+  keys.forEach((key) => {
+    delete omitted[key];
+  });
+  return omitted;
+};
+const extendDescriptor = (descriptor, extension) => ({
+  ...descriptor,
+  ...extension
+});
+const partialDescriptor = (descriptor) => {
+  const partial = {};
+  keysOf(descriptor).forEach((key) => {
+    partial[key] = optional(descriptor[key]);
+  });
+  return partial;
+};
+const getPathValue = (value, path) => path.reduce((current, key) => {
+  if (current === null || current === void 0) {
+    return void 0;
+  }
+  return Reflect.get(Object(current), key);
+}, value);
+const toPath = (selector) => Array.isArray(selector) ? [...selector] : [selector];
+const collectShapeRefinementViolations = (value, path, refinements) => refinements.flatMap((refinement) => {
+  const result = refinement(value);
+  if (result === null || result === void 0) {
+    return [];
+  }
+  return arrayify(result).filter((issue) => issue !== null && issue !== void 0).map((issue) => {
+    const issuePath = issue.path ? [...issue.path] : [];
+    return {
+      value: issue.value ?? getPathValue(value, issuePath),
+      path: [...path, ...issuePath],
+      violates: {
+        kind: "validator",
+        name: "shape",
+        code: issue.code,
+        args: issue.args ?? []
+      }
+    };
+  });
+});
+const createObjectShape = (descriptor, unknownKeys, refinements, rules) => {
+  const keys = keysOf(descriptor);
+  return attachConstraintDescriptor({
+    descriptor,
+    unknownKeys,
+    check(value) {
+      return isRecord(value) && keys.every((key) => matchesConstraints(value[key], descriptor[key])) && (unknownKeys === "passthrough" || !hasUnknownKeys(value, descriptor)) && collectShapeRefinementViolations(value, [], refinements).length === 0;
+    },
+    run(validate, value, path) {
+      if (!isRecord(value)) {
+        return [[{
+          value,
+          path,
+          violates: { kind: "validator", name: "shape", code: "type.record", args: [] }
+        }]];
+      }
+      const validations = keys.reduce((all, key) => [
+        ...all,
+        validate(value[key], descriptor[key], [...path, key])
+      ], []);
+      if (unknownKeys === "strict") {
+        validations.push(...collectUnknownKeyViolations(value, path, descriptor));
+      }
+      if (validations.some((validation) => validation instanceof Promise)) {
+        return [Promise.all(validations.map((validation) => Promise.resolve(validation))).then((results) => {
+          const structuralViolations2 = results.flat();
+          return structuralViolations2.length > 0 ? structuralViolations2 : collectShapeRefinementViolations(value, path, refinements);
+        })];
+      }
+      const structuralViolations = validations.flat();
+      return structuralViolations.length > 0 ? validations : [collectShapeRefinementViolations(value, path, refinements)];
+    },
+    refine(refinement, ruleDescriptor = { kind: "refine" }) {
+      return createObjectShape(
+        descriptor,
+        unknownKeys,
+        [...refinements, refinement],
+        [...rules, normalizeRuleDescriptor(ruleDescriptor)]
+      );
+    },
+    fieldsMatch(selectedKeys) {
+      const [left, right] = selectedKeys;
+      const leftPath = toPath(left);
+      const rightPath = toPath(right);
+      const ruleDescriptor = {
+        kind: "fieldsMatch",
+        selectors: [left, right]
+      };
+      return createObjectShape(
+        descriptor,
+        unknownKeys,
+        [...refinements, (value) => {
+          return getPathValue(value, leftPath) === getPathValue(value, rightPath) ? [] : [{
+            path: rightPath,
+            code: "shape.fields.mismatch",
+            args: [selectedKeys]
+          }];
+        }],
+        [...rules, ruleDescriptor]
+      );
+    },
+    strict() {
+      return createObjectShape(descriptor, "strict", refinements, rules);
+    },
+    passthrough() {
+      return createObjectShape(descriptor, "passthrough", refinements, rules);
+    },
+    pick(selectedKeys) {
+      return createObjectShape(pickDescriptor(descriptor, selectedKeys), unknownKeys, [], []);
+    },
+    omit(selectedKeys) {
+      return createObjectShape(omitDescriptor(descriptor, selectedKeys), unknownKeys, [], []);
+    },
+    partial() {
+      return createObjectShape(partialDescriptor(descriptor), unknownKeys, [], []);
+    },
+    extend(extension) {
+      return createObjectShape(extendDescriptor(descriptor, extension), unknownKeys, [], []);
+    },
+    merge(shape2) {
+      return createObjectShape(extendDescriptor(descriptor, shape2.descriptor), unknownKeys, [], []);
+    }
+  }, () => ({
+    kind: "shape",
+    unknownKeys,
+    fields: describeConstraintMap(descriptor),
+    rules
+  }));
+};
+const toUnionFailure = (branches, value, path, branchResults) => {
+  const matched = branchResults.find((result) => result.length === 0);
+  if (matched) {
+    return matched;
+  }
+  return [{
+    value,
+    path,
+    violates: { kind: "validator", name: "union", code: "union.no-match", args: [branches.length] }
+  }, ...branchResults.flat()];
+};
+const collectUnionViolations = (branches, validate, value, path) => {
+  const branchResults = branches.map((branch) => validate(value, branch, path));
+  if (branchResults.some((result) => result instanceof Promise)) {
+    return Promise.all(branchResults.map((result) => Promise.resolve(result))).then((results) => {
+      return toUnionFailure(branches, value, path, results);
+    });
+  }
+  return toUnionFailure(branches, value, path, branchResults);
+};
+const each = (constraints) => attachConstraintDescriptor({
+  check(value) {
+    return isArray(value) && value.every((item) => matchesConstraints(item, constraints));
+  },
+  run(validate, value, path) {
+    return isArray(value) ? value.map((item, index) => validate(item, constraints, [...path, index])) : [[{
+      value,
+      path,
+      violates: { kind: "validator", name: "each", code: "type.array", args: [] }
+    }]];
+  }
+}, () => ({
+  kind: "each",
+  item: describeConstraints(constraints)
+}));
+const tuple = (constraints) => attachConstraintDescriptor({
+  check(value) {
+    return isArray(value) && value.length === constraints.length && constraints.every((constraint, index) => matchesConstraints(value[index], constraint));
+  },
+  run(validate, value, path) {
+    if (!isArray(value)) {
+      return [[{
+        value,
+        path,
+        violates: { kind: "validator", name: "tuple", code: "type.array", args: [] }
+      }]];
+    }
+    if (value.length !== constraints.length) {
+      return [[{
+        value,
+        path,
+        violates: { kind: "validator", name: "tuple", code: "tuple.length", args: [constraints.length] }
+      }]];
+    }
+    return constraints.map((constraint, index) => validate(value[index], constraint, [...path, index]));
+  }
+}, () => ({
+  kind: "tuple",
+  items: constraints.map((constraint) => describeConstraints(constraint))
+}));
+const union = (constraints) => attachConstraintDescriptor({
+  check(value) {
+    return constraints.some((constraint) => matchesConstraints(value, constraint));
+  },
+  run(validate, value, path) {
+    return [collectUnionViolations(constraints, validate, value, path)];
+  }
+}, () => ({
+  kind: "union",
+  branches: constraints.map((constraint) => describeConstraints(constraint))
+}));
+const discriminatedUnion = (key, variants) => attachConstraintDescriptor({
+  check(value) {
+    if (!isRecord(value)) {
+      return false;
+    }
+    const discriminator = value[key];
+    return Object.prototype.hasOwnProperty.call(variants, discriminator) && matchesConstraints(value, variants[discriminator]);
+  },
+  run(validate, value, path) {
+    if (!isRecord(value)) {
+      return [[{
+        value,
+        path,
+        violates: { kind: "validator", name: "discriminatedUnion", code: "type.record", args: [] }
+      }]];
+    }
+    const discriminator = value[key];
+    if (!Object.prototype.hasOwnProperty.call(variants, discriminator)) {
+      return [[{
+        value: discriminator,
+        path: [...path, key],
+        violates: {
+          kind: "validator",
+          name: "discriminatedUnion",
+          code: "union.invalid-discriminator",
+          args: [Reflect.ownKeys(variants)]
+        }
+      }]];
+    }
+    return [validate(value, variants[discriminator], path)];
+  }
+}, () => ({
+  kind: "discriminatedUnion",
+  key,
+  variants: describeConstraintMap(variants)
+}));
+const record = (constraints) => attachConstraintDescriptor({
+  check(value) {
+    return isRecord(value) && Object.values(value).every((item) => matchesConstraints(item, constraints));
+  },
+  run(validate, value, path) {
+    if (!isRecord(value)) {
+      return [[{
+        value,
+        path,
+        violates: { kind: "validator", name: "record", code: "type.record", args: [] }
+      }]];
+    }
+    return Object.keys(value).map((key) => validate(value[key], constraints, [...path, key]));
+  }
+}, () => ({
+  kind: "record",
+  values: describeConstraints(constraints)
+}));
+const shape = (descriptor) => {
+  return createObjectShape(descriptor, "passthrough", [], []);
+};
+const exact = (value) => assert(isExact(value), {
+  name: "exact",
+  bail: true,
+  code: "value.exact",
+  args: [value]
+});
+const optional = (constraints) => passthrough(
+  "optional",
+  isUndefined,
+  constraints
+);
+const nullable = (constraints) => passthrough(
+  "nullable",
+  isNull,
+  constraints
+);
+const nullish = (constraints) => passthrough(
+  "nullish",
+  (value) => isNull(value) || isUndefined(value),
+  constraints
+);
+export {
+  discriminatedUnion,
+  each,
+  exact,
+  nullable,
+  nullish,
+  optional,
+  record,
+  shape,
+  tuple,
+  union
+};

package/dist/constraints.d.ts

@@ -0,0 +1,4 @@
+import { Constraint, InferConstraints, MaybeMany, Validator } from '../types';
+export declare const isValidator: <T = unknown>(constraint: Constraint<T>) => constraint is Validator<T>;
+export declare function arrayify<T>(value: MaybeMany<T>): T[];
+export declare function matchesConstraints<C extends MaybeMany<Constraint>>(value: unknown, constraints: C): value is InferConstraints<C>;