@modulify/validator 0.2.1 → 0.3.0

package/dist/assertions-nfOKqcjs.cjs

@@ -0,0 +1,476 @@
+const require_assert = require("./assert-BDOtHdLx.cjs");
+const require_predicates = require("./predicates.cjs");
+//#region src/checkers.ts
+var isEqual = (value, exact) => value === exact;
+var isGte = (value, min) => value >= min;
+var isLte = (value, max) => value <= max;
+var inRange = (value, [min, max]) => value >= min && value <= max;
+var startsWith$1 = (value, prefix) => value.startsWith(prefix);
+var endsWith$1 = (value, suffix) => value.endsWith(suffix);
+var matchesPattern = (value, pattern) => new RegExp(pattern.source, pattern.flags).test(value);
+var isMultipleOf = (value, step) => {
+	if (step === 0) return false;
+	const quotient = value / step;
+	const delta = Math.abs(quotient - Math.round(quotient));
+	return Number.isFinite(quotient) && delta <= Number.EPSILON * Math.max(1, Math.abs(quotient)) * 16;
+};
+//#endregion
+//#region src/extractors.ts
+var length = (value) => value.length;
+var size = (value) => value.size;
+//#endregion
+//#region src/assertions.ts
+var buildLengthConstraints = (options) => {
+	const { exact = null, max = null, min = null, range = null } = options;
+	const constraints = [];
+	if (exact !== null) constraints.push([
+		length,
+		isEqual,
+		"length.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		length,
+		isLte,
+		"length.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		length,
+		isGte,
+		"length.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		length,
+		inRange,
+		"length.range",
+		range
+	]);
+	return constraints;
+};
+var buildSizeConstraints = (options) => {
+	const { exact = null, max = null, min = null, range = null } = options;
+	const constraints = [];
+	if (exact !== null) constraints.push([
+		size,
+		isEqual,
+		"size.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		size,
+		isLte,
+		"size.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		size,
+		isGte,
+		"size.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		size,
+		inRange,
+		"size.range",
+		range
+	]);
+	return constraints;
+};
+var buildValueConstraints = (options) => {
+	const { exact = null, max = null, min = null, range = null } = options;
+	const constraints = [];
+	if (exact !== null) constraints.push([
+		(value) => value,
+		isEqual,
+		"number.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		(value) => value,
+		isLte,
+		"number.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		(value) => value,
+		isGte,
+		"number.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		(value) => value,
+		inRange,
+		"number.range",
+		range
+	]);
+	return constraints;
+};
+var isBoolean = /* @__PURE__ */ require_assert.assert(require_predicates.isBoolean, {
+	name: "isBoolean",
+	bail: true,
+	code: "type.boolean"
+});
+var isBigInt = /* @__PURE__ */ require_assert.assert(require_predicates.isBigInt, {
+	name: "isBigInt",
+	bail: true,
+	code: "type.bigint"
+});
+var isBlob = /* @__PURE__ */ require_assert.assert(require_predicates.isBlob, {
+	name: "isBlob",
+	bail: true,
+	code: "type.blob"
+});
+var isDate = /* @__PURE__ */ require_assert.assert(require_predicates.isDate, {
+	name: "isDate",
+	bail: true,
+	code: "type.date"
+});
+var isDefined = /* @__PURE__ */ require_assert.assert((value) => value !== void 0, {
+	name: "isDefined",
+	bail: true,
+	code: "value.defined"
+});
+var isEmail = /* @__PURE__ */ require_assert.assert(require_predicates.isEmail, {
+	name: "isEmail",
+	bail: true,
+	code: "string.email"
+});
+var isError = /* @__PURE__ */ require_assert.assert(require_predicates.isError, {
+	name: "isError",
+	bail: true,
+	code: "type.error"
+});
+var isFiniteNumber = /* @__PURE__ */ require_assert.assert(require_predicates.isFiniteNumber, {
+	name: "isFiniteNumber",
+	bail: true,
+	code: "number.finite"
+});
+var isFile = /* @__PURE__ */ require_assert.assert(require_predicates.isFile, {
+	name: "isFile",
+	bail: true,
+	code: "type.file"
+});
+var isFunction = /* @__PURE__ */ require_assert.assert(require_predicates.isFunction, {
+	name: "isFunction",
+	bail: true,
+	code: "type.function"
+});
+var isInteger = /* @__PURE__ */ require_assert.assert(require_predicates.isInteger, {
+	name: "isInteger",
+	bail: true,
+	code: "number.integer"
+});
+var isMap = /* @__PURE__ */ require_assert.assert(require_predicates.isMap, {
+	name: "isMap",
+	bail: true,
+	code: "type.map"
+});
+var isNaN = /* @__PURE__ */ require_assert.assert(require_predicates.isNaN, {
+	name: "isNaN",
+	bail: true,
+	code: "number.nan"
+});
+var isNull = /* @__PURE__ */ require_assert.assert(require_predicates.isNull, {
+	name: "isNull",
+	bail: true,
+	code: "type.null"
+});
+var isNumber = /* @__PURE__ */ require_assert.assert(require_predicates.isNumber, {
+	name: "isNumber",
+	bail: true,
+	code: "type.number"
+});
+var isPromiseLike = /* @__PURE__ */ require_assert.assert(require_predicates.isPromiseLike, {
+	name: "isPromiseLike",
+	bail: true,
+	code: "type.promise-like"
+});
+var isRegExp = /* @__PURE__ */ require_assert.assert(require_predicates.isRegExp, {
+	name: "isRegExp",
+	bail: true,
+	code: "type.regexp"
+});
+var isSafeInteger = /* @__PURE__ */ require_assert.assert(require_predicates.isSafeInteger, {
+	name: "isSafeInteger",
+	bail: true,
+	code: "number.safe-integer"
+});
+var isSet = /* @__PURE__ */ require_assert.assert(require_predicates.isSet, {
+	name: "isSet",
+	bail: true,
+	code: "type.set"
+});
+var isString = /* @__PURE__ */ require_assert.assert(require_predicates.isString, {
+	name: "isString",
+	bail: true,
+	code: "type.string"
+});
+var isSymbol = /* @__PURE__ */ require_assert.assert(require_predicates.isSymbol, {
+	name: "isSymbol",
+	bail: true,
+	code: "type.symbol"
+});
+var isValidDate = /* @__PURE__ */ require_assert.assert(require_predicates.isValidDate, {
+	name: "isValidDate",
+	bail: true,
+	code: "date.valid"
+});
+var hasLength = (options = {}) => {
+	const { bail = false } = options;
+	const constraints = buildLengthConstraints(options);
+	return /* @__PURE__ */ require_assert.createRefinement({
+		name: "hasLength",
+		bail,
+		code: "length.unsupported-type"
+	}, constraints);
+};
+var hasSize = (options = {}) => {
+	const { bail = false } = options;
+	const constraints = buildSizeConstraints(options);
+	return /* @__PURE__ */ require_assert.createRefinement({
+		name: "hasSize",
+		bail,
+		code: "size.unsupported-type"
+	}, constraints);
+};
+var hasPattern = (pattern, { bail = false } = {}) => /* @__PURE__ */ require_assert.createRefinement({
+	name: "hasPattern",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	matchesPattern,
+	"string.pattern",
+	pattern
+]]);
+var startsWith = (prefix, { bail = false } = {}) => /* @__PURE__ */ require_assert.createRefinement({
+	name: "startsWith",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	startsWith$1,
+	"string.starts-with",
+	prefix
+]]);
+var endsWith = (suffix, { bail = false } = {}) => /* @__PURE__ */ require_assert.createRefinement({
+	name: "endsWith",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	endsWith$1,
+	"string.ends-with",
+	suffix
+]]);
+var hasValue = (options = {}) => {
+	const { bail = false } = options;
+	const constraints = buildValueConstraints(options);
+	return /* @__PURE__ */ require_assert.createRefinement({
+		name: "hasValue",
+		bail,
+		code: "number.unsupported-type"
+	}, constraints);
+};
+var multipleOf = (step, { bail = false } = {}) => /* @__PURE__ */ require_assert.createRefinement({
+	name: "multipleOf",
+	bail,
+	code: "number.unsupported-type"
+}, [[
+	(value) => value,
+	isMultipleOf,
+	"number.multiple-of",
+	step
+]]);
+var oneOf = (values, { equalTo = (a, b) => a === b, bail = false } = {}) => {
+	const haystack = require_predicates.isArray(values) ? values : Object.values(values);
+	return /* @__PURE__ */ require_assert.assert((value) => haystack.some((item) => equalTo(item, value)), {
+		name: "oneOf",
+		bail,
+		code: "value.one-of",
+		args: [haystack]
+	});
+};
+//#endregion
+Object.defineProperty(exports, "endsWith", {
+	enumerable: true,
+	get: function() {
+		return endsWith;
+	}
+});
+Object.defineProperty(exports, "hasLength", {
+	enumerable: true,
+	get: function() {
+		return hasLength;
+	}
+});
+Object.defineProperty(exports, "hasPattern", {
+	enumerable: true,
+	get: function() {
+		return hasPattern;
+	}
+});
+Object.defineProperty(exports, "hasSize", {
+	enumerable: true,
+	get: function() {
+		return hasSize;
+	}
+});
+Object.defineProperty(exports, "hasValue", {
+	enumerable: true,
+	get: function() {
+		return hasValue;
+	}
+});
+Object.defineProperty(exports, "isBigInt", {
+	enumerable: true,
+	get: function() {
+		return isBigInt;
+	}
+});
+Object.defineProperty(exports, "isBlob", {
+	enumerable: true,
+	get: function() {
+		return isBlob;
+	}
+});
+Object.defineProperty(exports, "isBoolean", {
+	enumerable: true,
+	get: function() {
+		return isBoolean;
+	}
+});
+Object.defineProperty(exports, "isDate", {
+	enumerable: true,
+	get: function() {
+		return isDate;
+	}
+});
+Object.defineProperty(exports, "isDefined", {
+	enumerable: true,
+	get: function() {
+		return isDefined;
+	}
+});
+Object.defineProperty(exports, "isEmail", {
+	enumerable: true,
+	get: function() {
+		return isEmail;
+	}
+});
+Object.defineProperty(exports, "isError", {
+	enumerable: true,
+	get: function() {
+		return isError;
+	}
+});
+Object.defineProperty(exports, "isFile", {
+	enumerable: true,
+	get: function() {
+		return isFile;
+	}
+});
+Object.defineProperty(exports, "isFiniteNumber", {
+	enumerable: true,
+	get: function() {
+		return isFiniteNumber;
+	}
+});
+Object.defineProperty(exports, "isFunction", {
+	enumerable: true,
+	get: function() {
+		return isFunction;
+	}
+});
+Object.defineProperty(exports, "isInteger", {
+	enumerable: true,
+	get: function() {
+		return isInteger;
+	}
+});
+Object.defineProperty(exports, "isMap", {
+	enumerable: true,
+	get: function() {
+		return isMap;
+	}
+});
+Object.defineProperty(exports, "isNaN", {
+	enumerable: true,
+	get: function() {
+		return isNaN;
+	}
+});
+Object.defineProperty(exports, "isNull", {
+	enumerable: true,
+	get: function() {
+		return isNull;
+	}
+});
+Object.defineProperty(exports, "isNumber", {
+	enumerable: true,
+	get: function() {
+		return isNumber;
+	}
+});
+Object.defineProperty(exports, "isPromiseLike", {
+	enumerable: true,
+	get: function() {
+		return isPromiseLike;
+	}
+});
+Object.defineProperty(exports, "isRegExp", {
+	enumerable: true,
+	get: function() {
+		return isRegExp;
+	}
+});
+Object.defineProperty(exports, "isSafeInteger", {
+	enumerable: true,
+	get: function() {
+		return isSafeInteger;
+	}
+});
+Object.defineProperty(exports, "isSet", {
+	enumerable: true,
+	get: function() {
+		return isSet;
+	}
+});
+Object.defineProperty(exports, "isString", {
+	enumerable: true,
+	get: function() {
+		return isString;
+	}
+});
+Object.defineProperty(exports, "isSymbol", {
+	enumerable: true,
+	get: function() {
+		return isSymbol;
+	}
+});
+Object.defineProperty(exports, "isValidDate", {
+	enumerable: true,
+	get: function() {
+		return isValidDate;
+	}
+});
+Object.defineProperty(exports, "multipleOf", {
+	enumerable: true,
+	get: function() {
+		return multipleOf;
+	}
+});
+Object.defineProperty(exports, "oneOf", {
+	enumerable: true,
+	get: function() {
+		return oneOf;
+	}
+});
+Object.defineProperty(exports, "startsWith", {
+	enumerable: true,
+	get: function() {
+		return startsWith;
+	}
+});

package/dist/assertions.cjs

@@ -1,207 +1,35 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const assert = require("./assert.cjs");
-const predicates = require("./predicates.cjs");
-const isEqual = (value, exact) => value === exact;
-const isGte = (value, min) => value >= min;
-const isLte = (value, max) => value <= max;
-const inRange = (value, [min, max]) => value >= min && value <= max;
-const startsWith$1 = (value, prefix) => value.startsWith(prefix);
-const endsWith$1 = (value, suffix) => value.endsWith(suffix);
-const matchesPattern = (value, pattern) => new RegExp(pattern.source, pattern.flags).test(value);
-const isMultipleOf = (value, step) => {
-  if (step === 0) {
-    return false;
-  }
-  const quotient = value / step;
-  const nearestInteger = Math.round(quotient);
-  const delta = Math.abs(quotient - nearestInteger);
-  return Number.isFinite(quotient) && delta <= Number.EPSILON * Math.max(1, Math.abs(quotient)) * 16;
-};
-const length = (value) => value.length;
-const size = (value) => value.size;
-const isBoolean = assert.assert(predicates.isBoolean, { name: "isBoolean", bail: true, code: "type.boolean" });
-const isBigInt = assert.assert(predicates.isBigInt, { name: "isBigInt", bail: true, code: "type.bigint" });
-const isBlob = assert.assert(predicates.isBlob, { name: "isBlob", bail: true, code: "type.blob" });
-const isDate = assert.assert(predicates.isDate, { name: "isDate", bail: true, code: "type.date" });
-const isDefined = assert.assert((value) => value !== void 0, {
-  name: "isDefined",
-  bail: true,
-  code: "value.defined"
-});
-const isEmail = assert.assert(predicates.isEmail, { name: "isEmail", bail: true, code: "string.email" });
-const isFile = assert.assert(predicates.isFile, { name: "isFile", bail: true, code: "type.file" });
-const isFunction = assert.assert(predicates.isFunction, { name: "isFunction", bail: true, code: "type.function" });
-const isMap = assert.assert(predicates.isMap, { name: "isMap", bail: true, code: "type.map" });
-const isNaN = assert.assert(predicates.isNaN, { name: "isNaN", bail: true, code: "number.nan" });
-const isNull = assert.assert(predicates.isNull, { name: "isNull", bail: true, code: "type.null" });
-const isNumber = assert.assert(predicates.isNumber, { name: "isNumber", bail: true, code: "type.number" });
-const isSet = assert.assert(predicates.isSet, { name: "isSet", bail: true, code: "type.set" });
-const isString = assert.assert(predicates.isString, { name: "isString", bail: true, code: "type.string" });
-const isSymbol = assert.assert(predicates.isSymbol, { name: "isSymbol", bail: true, code: "type.symbol" });
-const hasLength = ({
-  exact = null,
-  max = null,
-  min = null,
-  range = null,
-  bail = false
-} = {}) => {
-  const constraints = [];
-  if (exact !== null) constraints.push([length, isEqual, "length.exact", exact]);
-  if (max !== null) constraints.push([length, isLte, "length.max", max]);
-  if (min !== null) constraints.push([length, isGte, "length.min", min]);
-  if (range !== null) constraints.push([length, inRange, "length.range", range]);
-  return assert.assert(
-    (value) => predicates.isArray(value) || predicates.isString(value),
-    {
-      name: "hasLength",
-      bail,
-      code: "length.unsupported-type"
-    },
-    constraints
-  );
-};
-const hasSize = ({
-  exact = null,
-  max = null,
-  min = null,
-  range = null,
-  bail = false
-} = {}) => {
-  const constraints = [];
-  if (exact !== null) constraints.push([size, isEqual, "size.exact", exact]);
-  if (max !== null) constraints.push([size, isLte, "size.max", max]);
-  if (min !== null) constraints.push([size, isGte, "size.min", min]);
-  if (range !== null) constraints.push([size, inRange, "size.range", range]);
-  return assert.assert(
-    (value) => predicates.isMap(value) || predicates.isSet(value),
-    {
-      name: "hasSize",
-      bail,
-      code: "size.unsupported-type"
-    },
-    constraints
-  );
-};
-const hasPattern = (pattern, {
-  bail = false
-} = {}) => assert.assert(
-  predicates.isString,
-  {
-    name: "hasPattern",
-    bail,
-    code: "string.unsupported-type"
-  },
-  [[
-    (value) => value,
-    matchesPattern,
-    "string.pattern",
-    pattern
-  ]]
-);
-const startsWith = (prefix, {
-  bail = false
-} = {}) => assert.assert(
-  predicates.isString,
-  {
-    name: "startsWith",
-    bail,
-    code: "string.unsupported-type"
-  },
-  [[
-    (value) => value,
-    startsWith$1,
-    "string.starts-with",
-    prefix
-  ]]
-);
-const endsWith = (suffix, {
-  bail = false
-} = {}) => assert.assert(
-  predicates.isString,
-  {
-    name: "endsWith",
-    bail,
-    code: "string.unsupported-type"
-  },
-  [[
-    (value) => value,
-    endsWith$1,
-    "string.ends-with",
-    suffix
-  ]]
-);
-const hasValue = ({
-  exact = null,
-  max = null,
-  min = null,
-  range = null,
-  bail = false
-} = {}) => {
-  const constraints = [];
-  if (exact !== null) constraints.push([(value) => value, isEqual, "number.exact", exact]);
-  if (max !== null) constraints.push([(value) => value, isLte, "number.max", max]);
-  if (min !== null) constraints.push([(value) => value, isGte, "number.min", min]);
-  if (range !== null) constraints.push([(value) => value, inRange, "number.range", range]);
-  return assert.assert(
-    predicates.isNumber,
-    {
-      name: "hasValue",
-      bail,
-      code: "number.unsupported-type"
-    },
-    constraints
-  );
-};
-const multipleOf = (step, {
-  bail = false
-} = {}) => assert.assert(
-  predicates.isNumber,
-  {
-    name: "multipleOf",
-    bail,
-    code: "number.unsupported-type"
-  },
-  [[
-    (value) => value,
-    isMultipleOf,
-    "number.multiple-of",
-    step
-  ]]
-);
-const oneOf = (values, {
-  equalTo = (a, b) => a === b,
-  bail = false
-} = {}) => {
-  const haystack = predicates.isArray(values) ? values : Object.values(values);
-  return assert.assert((value) => haystack.some((item) => equalTo(item, value)), {
-    name: "oneOf",
-    bail,
-    code: "value.one-of",
-    args: [haystack]
-  });
-};
-exports.assert = assert.assert;
-exports.endsWith = endsWith;
-exports.hasLength = hasLength;
-exports.hasPattern = hasPattern;
-exports.hasSize = hasSize;
-exports.hasValue = hasValue;
-exports.isBigInt = isBigInt;
-exports.isBlob = isBlob;
-exports.isBoolean = isBoolean;
-exports.isDate = isDate;
-exports.isDefined = isDefined;
-exports.isEmail = isEmail;
-exports.isFile = isFile;
-exports.isFunction = isFunction;
-exports.isMap = isMap;
-exports.isNaN = isNaN;
-exports.isNull = isNull;
-exports.isNumber = isNumber;
-exports.isSet = isSet;
-exports.isString = isString;
-exports.isSymbol = isSymbol;
-exports.multipleOf = multipleOf;
-exports.oneOf = oneOf;
-exports.startsWith = startsWith;
+const require_assert = require("./assert-BDOtHdLx.cjs");
+const require_assertions = require("./assertions-nfOKqcjs.cjs");
+exports.assert = require_assert.assert;
+exports.endsWith = require_assertions.endsWith;
+exports.hasLength = require_assertions.hasLength;
+exports.hasPattern = require_assertions.hasPattern;
+exports.hasSize = require_assertions.hasSize;
+exports.hasValue = require_assertions.hasValue;
+exports.isBigInt = require_assertions.isBigInt;
+exports.isBlob = require_assertions.isBlob;
+exports.isBoolean = require_assertions.isBoolean;
+exports.isDate = require_assertions.isDate;
+exports.isDefined = require_assertions.isDefined;
+exports.isEmail = require_assertions.isEmail;
+exports.isError = require_assertions.isError;
+exports.isFile = require_assertions.isFile;
+exports.isFiniteNumber = require_assertions.isFiniteNumber;
+exports.isFunction = require_assertions.isFunction;
+exports.isInteger = require_assertions.isInteger;
+exports.isMap = require_assertions.isMap;
+exports.isNaN = require_assertions.isNaN;
+exports.isNull = require_assertions.isNull;
+exports.isNumber = require_assertions.isNumber;
+exports.isPromiseLike = require_assertions.isPromiseLike;
+exports.isRegExp = require_assertions.isRegExp;
+exports.isSafeInteger = require_assertions.isSafeInteger;
+exports.isSet = require_assertions.isSet;
+exports.isString = require_assertions.isString;
+exports.isSymbol = require_assertions.isSymbol;
+exports.isValidDate = require_assertions.isValidDate;
+exports.multipleOf = require_assertions.multipleOf;
+exports.oneOf = require_assertions.oneOf;
+exports.refine = require_assert.refine;
+exports.startsWith = require_assertions.startsWith;