@modulify/validator 0.2.1 → 0.3.0

package/dist/combinators.cjs

@@ -1,334 +1,333 @@
-"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 require_assert = require("./assert-BDOtHdLx.cjs");
+const require_predicates = require("./predicates.cjs");
+//#region src/combinators.ts
+var describeConstraintMap = (constraints) => {
+	const described = {};
+	Reflect.ownKeys(constraints).forEach((key) => {
+		described[key] = require_assert.describeConstraints(constraints[key]);
+	});
+	return described;
 };
-const normalizeRuleDescriptor = (descriptor) => {
-  if (!descriptor.metadata) {
-    return descriptor;
-  }
-  return {
-    ...descriptor,
-    metadata: Object.freeze({ ...descriptor.metadata })
-  };
+var 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)];
-  }
+var normalizeAsyncRuleDescriptor = (descriptor) => ({
+	...normalizeRuleDescriptor(descriptor),
+	async: true
+});
+var passthrough = (kind, accepts, constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+	check(value) {
+		return accepts(value) || require_assert.matchesConstraints(value, constraints);
+	},
+	run(validate, value, path) {
+		return accepts(value) ? [] : [validate(value, constraints, path)];
+	}
 }, () => ({
-  kind,
-  child: metadata.describeConstraints(constraints)
+	kind,
+	child: require_assert.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: [] }
+var keysOf = (value) => Object.keys(value);
+var hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var hasUnknownKeys = (value, descriptor) => Object.keys(value).some((key) => !hasOwn(descriptor, key));
+var 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;
+var 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;
+var omitDescriptor = (descriptor, keys) => {
+	const omitted = { ...descriptor };
+	keys.forEach((key) => {
+		delete omitted[key];
+	});
+	return omitted;
 };
-const extendDescriptor = (descriptor, extension) => ({
-  ...descriptor,
-  ...extension
+var extendDescriptor = (descriptor, extension) => ({
+	...descriptor,
+	...extension
 });
-const partialDescriptor = (descriptor) => {
-  const partial = {};
-  keysOf(descriptor).forEach((key) => {
-    partial[key] = optional(descriptor[key]);
-  });
-  return partial;
+var 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);
+var getPathValue = (value, path) => path.reduce((current, key) => {
+	if (current === null || current === void 0) return;
+	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 ?? []
-      }
-    };
-  });
+var toPath = (selector) => typeof selector === "object" ? [...selector] : [selector];
+var toShapeRefinementViolations = (value, path, result) => {
+	if (result === null || result === void 0) return [];
+	return require_assert.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 ?? []
+			}
+		};
+	});
+};
+var collectShapeRefinementViolations = (value, path, refinements) => refinements.flatMap((refinement) => {
+	const result = refinement(value);
+	if (result instanceof Promise) throw new Error("Found asynchronous object-level shape refinement");
+	return toShapeRefinementViolations(value, path, result);
 });
-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
-  }));
+var collectAsyncShapeRefinementViolations = (value, path, refinements) => {
+	const results = refinements.map((refinement) => refinement(value));
+	if (results.some((result) => result instanceof Promise)) return Promise.all(results.map((result) => Promise.resolve(result))).then((resolved) => {
+		return resolved.flatMap((result) => toShapeRefinementViolations(value, path, result));
+	});
+	return results.flatMap((result) => toShapeRefinementViolations(value, path, result));
+};
+var createObjectShape = (descriptor, unknownKeys, refinements, rules) => {
+	const keys = keysOf(descriptor);
+	const addAsyncRefinement = (refinement, ruleDescriptor = { kind: "refine" }) => createObjectShape(descriptor, unknownKeys, [...refinements, refinement], [...rules, normalizeAsyncRuleDescriptor(ruleDescriptor)]);
+	const addSyncRefinement = (refinement, ruleDescriptor = { kind: "refine" }) => createObjectShape(descriptor, unknownKeys, [...refinements, refinement], [...rules, normalizeRuleDescriptor(ruleDescriptor)]);
+	return /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+		descriptor,
+		unknownKeys,
+		check(value) {
+			return require_predicates.isRecord(value) && keys.every((key) => require_assert.matchesConstraints(value[key], descriptor[key])) && (unknownKeys === "passthrough" || !hasUnknownKeys(value, descriptor)) && collectShapeRefinementViolations(value, [], refinements).length === 0;
+		},
+		run(validate, value, path) {
+			if (!require_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 structuralViolations = results.flat();
+				return structuralViolations.length > 0 ? structuralViolations : Promise.resolve(collectAsyncShapeRefinementViolations(value, path, refinements));
+			})];
+			return validations.flat().length > 0 ? validations : [validate.sync ? collectShapeRefinementViolations(value, path, refinements) : collectAsyncShapeRefinementViolations(value, path, refinements)];
+		},
+		refine: /* @__PURE__ */ Object.assign(addAsyncRefinement, { sync: addSyncRefinement }),
+		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(shape) {
+			return createObjectShape(extendDescriptor(descriptor, shape.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()];
+var 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);
+var 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: [] }
-    }]];
-  }
+var each = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+	check(value) {
+		return require_predicates.isArray(value) && value.every((item) => require_assert.matchesConstraints(item, constraints));
+	},
+	run(validate, value, path) {
+		return require_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)
+	kind: "each",
+	item: require_assert.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]));
-  }
+var tuple = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+	check(value) {
+		return require_predicates.isArray(value) && value.length === constraints.length && constraints.every((constraint, index) => require_assert.matchesConstraints(value[index], constraint));
+	},
+	run(validate, value, path) {
+		if (!require_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))
+	kind: "tuple",
+	items: constraints.map((constraint) => require_assert.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)];
-  }
+var union = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+	check(value) {
+		return constraints.some((constraint) => require_assert.matchesConstraints(value, constraint));
+	},
+	run(validate, value, path) {
+		return [collectUnionViolations(constraints, validate, value, path)];
+	}
 }, () => ({
-  kind: "union",
-  branches: constraints.map((constraint) => metadata.describeConstraints(constraint))
+	kind: "union",
+	branches: constraints.map((constraint) => require_assert.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)];
-  }
+var discriminatedUnion = (key, variants) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+	check(value) {
+		if (!require_predicates.isRecord(value)) return false;
+		const discriminator = value[key];
+		return Object.prototype.hasOwnProperty.call(variants, discriminator) && require_assert.matchesConstraints(value, variants[discriminator]);
+	},
+	run(validate, value, path) {
+		if (!require_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)
+	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]));
-  }
+var record = (constraints) => /* @__PURE__ */ require_assert.attachConstraintDescriptor({
+	check(value) {
+		return require_predicates.isRecord(value) && Object.values(value).every((item) => require_assert.matchesConstraints(item, constraints));
+	},
+	run(validate, value, path) {
+		if (!require_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)
+	kind: "record",
+	values: require_assert.describeConstraints(constraints)
 }));
-const shape = (descriptor) => {
-  return createObjectShape(descriptor, "passthrough", [], []);
+var shape = (descriptor) => {
+	return /* @__PURE__ */ createObjectShape(descriptor, "passthrough", [], []);
 };
-const exact = (value) => assert.assert(predicates.isExact(value), {
-  name: "exact",
-  bail: true,
-  code: "value.exact",
-  args: [value]
+var exact = (value) => /* @__PURE__ */ require_assert.assert(require_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
-);
+var optional = (constraints) => /* @__PURE__ */ passthrough("optional", require_predicates.isUndefined, constraints);
+var nullable = (constraints) => /* @__PURE__ */ passthrough("nullable", require_predicates.isNull, constraints);
+var nullish = (constraints) => /* @__PURE__ */ passthrough("nullish", (value) => require_predicates.isNull(value) || require_predicates.isUndefined(value), constraints);
+//#endregion
 exports.discriminatedUnion = discriminatedUnion;
 exports.each = each;
 exports.exact = exact;