@modulify/validator 0.2.1 → 0.3.0

package/dist/assert.d.mts

@@ -0,0 +1,37 @@
+import { Assertion, Constraint, AssertionConstraint, Guard, Predicate, Refinement } from './types/index.mjs';
+type AssertMeta = {
+    name: string;
+    bail: boolean;
+    code?: string;
+    args?: readonly unknown[];
+};
+type ResolveAssertionCode<Name extends string, Code extends string | undefined> = Code extends string ? Code : Name;
+type ResolveAssertionArgs<Args extends readonly unknown[] | undefined> = Args extends readonly unknown[] ? Args : [];
+type ConstraintInputFunction<C extends AssertionConstraint> = C extends unknown ? (value: Parameters<C[0]>[0]) => void : never;
+type ConstraintInput<C extends readonly AssertionConstraint[]> = C extends readonly [] ? unknown : ConstraintInputFunction<C[number]> extends (value: infer Input) => void ? Input : never;
+type ConstraintArgs<C extends AssertionConstraint> = C extends readonly [unknown, unknown, string, ...infer Args] ? Args : never;
+type CompatibleAssertionConstraints<Input, C extends readonly AssertionConstraint[]> = {
+    [K in keyof C]: AssertionConstraint<Input, ReturnType<C[K][0]>, ConstraintArgs<C[K]>, C[K][2]>;
+};
+export declare const assert: <T, const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint<T, any, any[], string>[] = []>(predicate: Predicate<T>, meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<T, C>) => Guard<T, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const isRefinementAssertion: (constraint: Constraint) => constraint is Assertion;
+export declare const runRefinementAssertion: (constraint: Assertion, value: unknown) => ReturnType<Assertion>;
+export declare const checkRefinementAssertion: (constraint: Assertion, value: unknown) => boolean;
+export declare const createRefinement: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const refine: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<ConstraintInput<C>, C>) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export {};

package/dist/assert.d.ts

@@ -1,4 +1,4 @@
-import { Assertion, AssertionConstraint, Predicate } from '../types';
+import { Assertion, Constraint, AssertionConstraint, Guard, Predicate, Refinement } from './types/index.js';
 type AssertMeta = {
     name: string;
     bail: boolean;
@@ -7,10 +7,31 @@ type AssertMeta = {
 };
 type ResolveAssertionCode<Name extends string, Code extends string | undefined> = Code extends string ? Code : Name;
 type ResolveAssertionArgs<Args extends readonly unknown[] | undefined> = Args extends readonly unknown[] ? Args : [];
-export declare const assert: <T, const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(predicate: Predicate<T>, meta: AssertMeta & {
+type ConstraintInputFunction<C extends AssertionConstraint> = C extends unknown ? (value: Parameters<C[0]>[0]) => void : never;
+type ConstraintInput<C extends readonly AssertionConstraint[]> = C extends readonly [] ? unknown : ConstraintInputFunction<C[number]> extends (value: infer Input) => void ? Input : never;
+type ConstraintArgs<C extends AssertionConstraint> = C extends readonly [unknown, unknown, string, ...infer Args] ? Args : never;
+type CompatibleAssertionConstraints<Input, C extends readonly AssertionConstraint[]> = {
+    [K in keyof C]: AssertionConstraint<Input, ReturnType<C[K][0]>, ConstraintArgs<C[K]>, C[K][2]>;
+};
+export declare const assert: <T, const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint<T, any, any[], string>[] = []>(predicate: Predicate<T>, meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C & CompatibleAssertionConstraints<T, C>) => Guard<T, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const isRefinementAssertion: (constraint: Constraint) => constraint is Assertion;
+export declare const runRefinementAssertion: (constraint: Assertion, value: unknown) => ReturnType<Assertion>;
+export declare const checkRefinementAssertion: (constraint: Assertion, value: unknown) => boolean;
+export declare const createRefinement: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
+    name: Name;
+    bail: Bail;
+    code?: Code;
+    args?: Args;
+}, constraints?: C) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+export declare const refine: <const Name extends string, const Bail extends boolean, const Code extends string | undefined = undefined, const Args extends readonly unknown[] | undefined = undefined, const C extends readonly AssertionConstraint[] = []>(meta: AssertMeta & {
     name: Name;
     bail: Bail;
     code?: Code;
     args?: Args;
-}, constraints?: C) => Assertion<T, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
+}, constraints?: C & CompatibleAssertionConstraints<ConstraintInput<C>, C>) => Refinement<ConstraintInput<C>, C, ResolveAssertionCode<Name, Code>, ResolveAssertionArgs<Args>, Name>;
 export {};

package/dist/assert.mjs

@@ -1,66 +1,2 @@
-import { e as attachConstraintDescriptor } from "./metadata.es.js";
-const assert = (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 assertion = ((value) => {
-    if (!predicate(value)) {
-      return {
-        value,
-        violates: violationSubject
-      };
-    }
-    for (const [extract, check, code, ...args] of constraints) {
-      if (!check(extract(value), ...args)) {
-        const constraintSubject = {
-          kind: "assertion",
-          name: meta.name,
-          code,
-          args
-        };
-        return {
-          value,
-          violates: constraintSubject
-        };
-      }
-    }
-    return null;
-  });
-  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) && (!constraints.length || constraints.every(([extract, check, , ...args]) => check(extract(value), ...args)))
-    }
-  });
-  return attachConstraintDescriptor(assertion, () => ({
-    kind: "assertion",
-    name: meta.name,
-    bail: meta.bail,
-    code: assertionCode,
-    args: assertionArgs,
-    constraints: constraints.map(([, , code, ...args]) => ({
-      code,
-      args
-    }))
-  }));
-};
-export {
-  assert
-};
+import { a as refine, i as isRefinementAssertion, n as checkRefinementAssertion, o as runRefinementAssertion, r as createRefinement, t as assert } from "./assert-CzMg5aO7.mjs";
+export { assert, checkRefinementAssertion, createRefinement, isRefinementAssertion, refine, runRefinementAssertion };

package/dist/assertions-DPYCHREw.mjs

@@ -0,0 +1,297 @@
+import { r as createRefinement, t as assert } from "./assert-CzMg5aO7.mjs";
+import { isArray, isBigInt as isBigInt$1, isBlob as isBlob$1, isBoolean as isBoolean$1, isDate as isDate$1, isEmail as isEmail$1, isError as isError$1, isFile as isFile$1, isFiniteNumber as isFiniteNumber$1, isFunction as isFunction$1, isInteger as isInteger$1, isMap as isMap$1, isNaN as isNaN$1, isNull as isNull$1, isNumber as isNumber$1, isPromiseLike as isPromiseLike$1, isRegExp as isRegExp$1, isSafeInteger as isSafeInteger$1, isSet as isSet$1, isString as isString$1, isSymbol as isSymbol$1, isValidDate as isValidDate$1 } from "./predicates.mjs";
+//#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__ */ assert(isBoolean$1, {
+	name: "isBoolean",
+	bail: true,
+	code: "type.boolean"
+});
+var isBigInt = /* @__PURE__ */ assert(isBigInt$1, {
+	name: "isBigInt",
+	bail: true,
+	code: "type.bigint"
+});
+var isBlob = /* @__PURE__ */ assert(isBlob$1, {
+	name: "isBlob",
+	bail: true,
+	code: "type.blob"
+});
+var isDate = /* @__PURE__ */ assert(isDate$1, {
+	name: "isDate",
+	bail: true,
+	code: "type.date"
+});
+var isDefined = /* @__PURE__ */ assert((value) => value !== void 0, {
+	name: "isDefined",
+	bail: true,
+	code: "value.defined"
+});
+var isEmail = /* @__PURE__ */ assert(isEmail$1, {
+	name: "isEmail",
+	bail: true,
+	code: "string.email"
+});
+var isError = /* @__PURE__ */ assert(isError$1, {
+	name: "isError",
+	bail: true,
+	code: "type.error"
+});
+var isFiniteNumber = /* @__PURE__ */ assert(isFiniteNumber$1, {
+	name: "isFiniteNumber",
+	bail: true,
+	code: "number.finite"
+});
+var isFile = /* @__PURE__ */ assert(isFile$1, {
+	name: "isFile",
+	bail: true,
+	code: "type.file"
+});
+var isFunction = /* @__PURE__ */ assert(isFunction$1, {
+	name: "isFunction",
+	bail: true,
+	code: "type.function"
+});
+var isInteger = /* @__PURE__ */ assert(isInteger$1, {
+	name: "isInteger",
+	bail: true,
+	code: "number.integer"
+});
+var isMap = /* @__PURE__ */ assert(isMap$1, {
+	name: "isMap",
+	bail: true,
+	code: "type.map"
+});
+var isNaN = /* @__PURE__ */ assert(isNaN$1, {
+	name: "isNaN",
+	bail: true,
+	code: "number.nan"
+});
+var isNull = /* @__PURE__ */ assert(isNull$1, {
+	name: "isNull",
+	bail: true,
+	code: "type.null"
+});
+var isNumber = /* @__PURE__ */ assert(isNumber$1, {
+	name: "isNumber",
+	bail: true,
+	code: "type.number"
+});
+var isPromiseLike = /* @__PURE__ */ assert(isPromiseLike$1, {
+	name: "isPromiseLike",
+	bail: true,
+	code: "type.promise-like"
+});
+var isRegExp = /* @__PURE__ */ assert(isRegExp$1, {
+	name: "isRegExp",
+	bail: true,
+	code: "type.regexp"
+});
+var isSafeInteger = /* @__PURE__ */ assert(isSafeInteger$1, {
+	name: "isSafeInteger",
+	bail: true,
+	code: "number.safe-integer"
+});
+var isSet = /* @__PURE__ */ assert(isSet$1, {
+	name: "isSet",
+	bail: true,
+	code: "type.set"
+});
+var isString = /* @__PURE__ */ assert(isString$1, {
+	name: "isString",
+	bail: true,
+	code: "type.string"
+});
+var isSymbol = /* @__PURE__ */ assert(isSymbol$1, {
+	name: "isSymbol",
+	bail: true,
+	code: "type.symbol"
+});
+var isValidDate = /* @__PURE__ */ assert(isValidDate$1, {
+	name: "isValidDate",
+	bail: true,
+	code: "date.valid"
+});
+var hasLength = (options = {}) => {
+	const { bail = false } = options;
+	const constraints = buildLengthConstraints(options);
+	return /* @__PURE__ */ createRefinement({
+		name: "hasLength",
+		bail,
+		code: "length.unsupported-type"
+	}, constraints);
+};
+var hasSize = (options = {}) => {
+	const { bail = false } = options;
+	const constraints = buildSizeConstraints(options);
+	return /* @__PURE__ */ createRefinement({
+		name: "hasSize",
+		bail,
+		code: "size.unsupported-type"
+	}, constraints);
+};
+var hasPattern = (pattern, { bail = false } = {}) => /* @__PURE__ */ createRefinement({
+	name: "hasPattern",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	matchesPattern,
+	"string.pattern",
+	pattern
+]]);
+var startsWith = (prefix, { bail = false } = {}) => /* @__PURE__ */ createRefinement({
+	name: "startsWith",
+	bail,
+	code: "string.unsupported-type"
+}, [[
+	(value) => value,
+	startsWith$1,
+	"string.starts-with",
+	prefix
+]]);
+var endsWith = (suffix, { bail = false } = {}) => /* @__PURE__ */ 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__ */ createRefinement({
+		name: "hasValue",
+		bail,
+		code: "number.unsupported-type"
+	}, constraints);
+};
+var multipleOf = (step, { bail = false } = {}) => /* @__PURE__ */ 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 = isArray(values) ? values : Object.values(values);
+	return /* @__PURE__ */ assert((value) => haystack.some((item) => equalTo(item, value)), {
+		name: "oneOf",
+		bail,
+		code: "value.one-of",
+		args: [haystack]
+	});
+};
+//#endregion
+export { startsWith as A, isSafeInteger as C, isValidDate as D, isSymbol as E, multipleOf as O, isRegExp as S, isString as T, isMap as _, hasValue as a, isNumber as b, isBoolean as c, isEmail as d, isError as f, isInteger as g, isFunction as h, hasSize as i, oneOf as k, isDate as l, isFiniteNumber as m, hasLength as n, isBigInt as o, isFile as p, hasPattern as r, isBlob as s, endsWith as t, isDefined as u, isNaN as v, isSet as w, isPromiseLike as x, isNull as y };