@modulify/validator 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+## 0.3.1
+
 ## 0.3.0
 
 ### ⚠ BREAKING CHANGE* **types:** Public type names were simplified

package/dist/assert.cjs

@@ -1,8 +1,102 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_assert = require("./assert-BDOtHdLx.cjs");
-exports.assert = require_assert.assert;
-exports.checkRefinementAssertion = require_assert.checkRefinementAssertion;
-exports.createRefinement = require_assert.createRefinement;
-exports.isRefinementAssertion = require_assert.isRefinementAssertion;
-exports.refine = require_assert.refine;
-exports.runRefinementAssertion = require_assert.runRefinementAssertion;
+const require_metadata = require("./metadata.cjs");
+//#region src/assert.ts
+var assertionStageSymbol = Symbol("modulify.validator.assertion.stage");
+var runRefinementSymbol = Symbol("modulify.validator.assertion.runRefinement");
+var checkRefinementSymbol = Symbol("modulify.validator.assertion.checkRefinement");
+var createAssertion = (stage, predicate, meta, constraints = []) => {
+	const assertionCode = meta.code ?? meta.name;
+	const assertionArgs = meta.args ?? [];
+	const violationSubject = {
+		kind: "assertion",
+		name: meta.name,
+		code: assertionCode,
+		args: assertionArgs
+	};
+	const runConstraints = (value) => {
+		for (const [extract, check, code, ...args] of constraints) if (!check(extract(value), ...args)) return {
+			value,
+			violates: {
+				kind: "assertion",
+				name: meta.name,
+				code,
+				args
+			}
+		};
+		return null;
+	};
+	const checkConstraints = (value) => !constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args));
+	const assertion = ((value) => {
+		if (!predicate(value)) return {
+			value,
+			violates: violationSubject
+		};
+		return runConstraints(value);
+	});
+	Object.defineProperties(assertion, {
+		name: {
+			configurable: true,
+			value: meta.name
+		},
+		bail: {
+			enumerable: true,
+			value: meta.bail
+		},
+		constraints: {
+			enumerable: true,
+			value: constraints
+		},
+		check: {
+			enumerable: true,
+			value: (value) => predicate(value) && checkConstraints(value)
+		},
+		[assertionStageSymbol]: {
+			enumerable: false,
+			value: stage
+		},
+		[runRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => runConstraints(value)
+		},
+		[checkRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => checkConstraints(value)
+		}
+	});
+	return /* @__PURE__ */ require_metadata.attachConstraintDescriptor(assertion, () => ({
+		kind: "assertion",
+		name: meta.name,
+		bail: meta.bail,
+		code: assertionCode,
+		args: assertionArgs,
+		constraints: constraints.map(([, , code, ...args]) => ({
+			code,
+			args
+		}))
+	}));
+};
+var assert = (predicate, meta, constraints = []) => {
+	return createAssertion("guard", predicate, meta, constraints);
+};
+var isRefinementAssertion = (constraint) => {
+	return typeof constraint === "function" && constraint[assertionStageSymbol] === "refinement";
+};
+var runRefinementAssertion = (constraint, value) => {
+	const runRefinement = constraint[runRefinementSymbol];
+	return runRefinement ? runRefinement(value) : constraint(value);
+};
+var checkRefinementAssertion = (constraint, value) => {
+	const checkRefinement = constraint[checkRefinementSymbol];
+	return checkRefinement ? checkRefinement(value) : constraint.check(value);
+};
+var createRefinement = (meta, constraints = []) => {
+	return createAssertion("refinement", ((value) => true), meta, constraints);
+};
+var refine = createRefinement;
+//#endregion
+exports.assert = assert;
+exports.checkRefinementAssertion = checkRefinementAssertion;
+exports.createRefinement = createRefinement;
+exports.isRefinementAssertion = isRefinementAssertion;
+exports.refine = refine;
+exports.runRefinementAssertion = runRefinementAssertion;

package/dist/assert.mjs

@@ -1,2 +1,96 @@
-import { a as refine, i as isRefinementAssertion, n as checkRefinementAssertion, o as runRefinementAssertion, r as createRefinement, t as assert } from "./assert-CzMg5aO7.mjs";
+import { attachConstraintDescriptor } from "./metadata.mjs";
+//#region src/assert.ts
+var assertionStageSymbol = Symbol("modulify.validator.assertion.stage");
+var runRefinementSymbol = Symbol("modulify.validator.assertion.runRefinement");
+var checkRefinementSymbol = Symbol("modulify.validator.assertion.checkRefinement");
+var createAssertion = (stage, predicate, meta, constraints = []) => {
+	const assertionCode = meta.code ?? meta.name;
+	const assertionArgs = meta.args ?? [];
+	const violationSubject = {
+		kind: "assertion",
+		name: meta.name,
+		code: assertionCode,
+		args: assertionArgs
+	};
+	const runConstraints = (value) => {
+		for (const [extract, check, code, ...args] of constraints) if (!check(extract(value), ...args)) return {
+			value,
+			violates: {
+				kind: "assertion",
+				name: meta.name,
+				code,
+				args
+			}
+		};
+		return null;
+	};
+	const checkConstraints = (value) => !constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args));
+	const assertion = ((value) => {
+		if (!predicate(value)) return {
+			value,
+			violates: violationSubject
+		};
+		return runConstraints(value);
+	});
+	Object.defineProperties(assertion, {
+		name: {
+			configurable: true,
+			value: meta.name
+		},
+		bail: {
+			enumerable: true,
+			value: meta.bail
+		},
+		constraints: {
+			enumerable: true,
+			value: constraints
+		},
+		check: {
+			enumerable: true,
+			value: (value) => predicate(value) && checkConstraints(value)
+		},
+		[assertionStageSymbol]: {
+			enumerable: false,
+			value: stage
+		},
+		[runRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => runConstraints(value)
+		},
+		[checkRefinementSymbol]: {
+			enumerable: false,
+			value: (value) => checkConstraints(value)
+		}
+	});
+	return /* @__PURE__ */ attachConstraintDescriptor(assertion, () => ({
+		kind: "assertion",
+		name: meta.name,
+		bail: meta.bail,
+		code: assertionCode,
+		args: assertionArgs,
+		constraints: constraints.map(([, , code, ...args]) => ({
+			code,
+			args
+		}))
+	}));
+};
+var assert = (predicate, meta, constraints = []) => {
+	return createAssertion("guard", predicate, meta, constraints);
+};
+var isRefinementAssertion = (constraint) => {
+	return typeof constraint === "function" && constraint[assertionStageSymbol] === "refinement";
+};
+var runRefinementAssertion = (constraint, value) => {
+	const runRefinement = constraint[runRefinementSymbol];
+	return runRefinement ? runRefinement(value) : constraint(value);
+};
+var checkRefinementAssertion = (constraint, value) => {
+	const checkRefinement = constraint[checkRefinementSymbol];
+	return checkRefinement ? checkRefinement(value) : constraint.check(value);
+};
+var createRefinement = (meta, constraints = []) => {
+	return createAssertion("refinement", ((value) => true), meta, constraints);
+};
+var refine = createRefinement;
+//#endregion
 export { assert, checkRefinementAssertion, createRefinement, isRefinementAssertion, refine, runRefinementAssertion };

package/dist/assertions.cjs

@@ -1,35 +1,312 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_assert = require("./assert-BDOtHdLx.cjs");
-const require_assertions = require("./assertions-nfOKqcjs.cjs");
+const require_assert = require("./assert.cjs");
+const require_checkers = require("./checkers.cjs");
+const require_extractors = require("./extractors.cjs");
+const require_predicates = require("./predicates.cjs");
+//#region src/assertions.ts
+var buildLengthConstraints = (options) => {
+	const { exact = null, max = null, min = null, range = null } = options;
+	const constraints = [];
+	if (exact !== null) constraints.push([
+		require_extractors.length,
+		require_checkers.isEqual,
+		"length.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		require_extractors.length,
+		require_checkers.isLte,
+		"length.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		require_extractors.length,
+		require_checkers.isGte,
+		"length.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		require_extractors.length,
+		require_checkers.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([
+		require_extractors.size,
+		require_checkers.isEqual,
+		"size.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		require_extractors.size,
+		require_checkers.isLte,
+		"size.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		require_extractors.size,
+		require_checkers.isGte,
+		"size.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		require_extractors.size,
+		require_checkers.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,
+		require_checkers.isEqual,
+		"number.exact",
+		exact
+	]);
+	if (max !== null) constraints.push([
+		(value) => value,
+		require_checkers.isLte,
+		"number.max",
+		max
+	]);
+	if (min !== null) constraints.push([
+		(value) => value,
+		require_checkers.isGte,
+		"number.min",
+		min
+	]);
+	if (range !== null) constraints.push([
+		(value) => value,
+		require_checkers.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,
+	require_checkers.matchesPattern,
+	"string.pattern",
+	pattern
+]]);
+var startsWith = (prefix, { bail = false } = {}) => /* @__PURE__ */ require_assert.createRefinement({
+	name: "startsWith",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	require_checkers.startsWith,
+	"string.starts-with",
+	prefix
+]]);
+var endsWith = (suffix, { bail = false } = {}) => /* @__PURE__ */ require_assert.createRefinement({
+	name: "endsWith",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	require_checkers.endsWith,
+	"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,
+	require_checkers.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
 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.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.isError = isError;
+exports.isFile = isFile;
+exports.isFiniteNumber = isFiniteNumber;
+exports.isFunction = isFunction;
+exports.isInteger = isInteger;
+exports.isMap = isMap;
+exports.isNaN = isNaN;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isPromiseLike = isPromiseLike;
+exports.isRegExp = isRegExp;
+exports.isSafeInteger = isSafeInteger;
+exports.isSet = isSet;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isValidDate = isValidDate;
+exports.multipleOf = multipleOf;
+exports.oneOf = oneOf;
 exports.refine = require_assert.refine;
-exports.startsWith = require_assertions.startsWith;
+exports.startsWith = startsWith;