@modulify/validator 0.1.0 → 0.2.0

package/dist/assertions.cjs

@@ -1,109 +1,207 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assert = require("./assert.cjs");
 const predicates = require("./predicates.cjs");
-const delegate = (p) => {
-  return (value) => p(value);
+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 Assert = (predicate, options) => {
-  const extender = (asserts = []) => {
-    return {
-      That(...asserts2) {
-        return Object.assign(delegate(predicate), options, extender(asserts2));
-      },
-      get also() {
-        return asserts;
-      }
-    };
-  };
-  return Object.assign(delegate(predicate), options, extender());
-};
-const isGTE = (min) => (x) => predicates.isNumber(x) && x >= min;
-const isLTE = (max) => (x) => predicates.isNumber(x) && x <= max;
-const IsEqual = (exact) => Assert((x) => predicates.isExact(exact)(x.length), {
-  fqn: "@modulify/validator/HasLength[exact]",
-  bail: false,
-  reason: "exact",
-  meta: exact
-});
-const IsGTE = (min) => Assert((x) => isGTE(min)(x.length), {
-  fqn: "@modulify/validator/HasLength[min]",
-  bail: false,
-  reason: "min",
-  meta: min
-});
-const IsLTE = (max) => Assert((x) => isLTE(max)(x.length), {
-  fqn: "@modulify/validator/HasLength[max]",
-  bail: false,
-  reason: "max",
-  meta: max
+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 HasLength = ({
+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
-}) => Assert(predicates.Or(predicates.isString, predicates.isArray), {
-  fqn: "@modulify/validator/HasLength",
-  bail,
-  reason: "unsupported"
-}).That(
-  ...exact !== null ? [IsEqual(exact)] : [],
-  ...max !== null ? [IsLTE(max)] : [],
-  ...min !== null ? [IsGTE(min)] : []
+} = {}) => {
+  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 IsBoolean = Assert(predicates.isBoolean, {
-  fqn: "@modulify/validator/IsBoolean",
-  bail: true
-});
-const IsDate = Assert(predicates.isDate, {
-  fqn: "@modulify/validator/IsDate",
-  bail: true
-});
-const IsDefined = Assert(predicates.Not(predicates.isUndefined), {
-  fqn: "@modulify/validator/IsDefined",
-  bail: true,
-  reason: "undefined"
-});
-const IsEmail = Assert(predicates.isEmail, {
-  fqn: "@modulify/validator/IsEmail",
-  bail: true
-});
-const IsNull = Assert(predicates.isNull, {
-  fqn: "@modulify/validator/IsNull",
-  bail: true
-});
-const IsNumber = Assert(predicates.isNumber, {
-  fqn: "@modulify/validator/IsNumber",
-  bail: true
-});
-const IsString = Assert(predicates.isString, {
-  fqn: "@modulify/validator/IsString",
-  bail: true
-});
-const IsSymbol = Assert(predicates.isSymbol, {
-  fqn: "@modulify/validator/IsSymbol",
-  bail: true
-});
-const OneOf = (values, {
+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);
-  const oneOf = (value) => haystack.some((allowed) => equalTo(allowed, value));
-  return Assert(oneOf, {
-    fqn: "@modulify/validator/OneOf",
+  return assert.assert((value) => haystack.some((item) => equalTo(item, value)), {
+    name: "oneOf",
     bail,
-    meta: haystack
+    code: "value.one-of",
+    args: [haystack]
   });
 };
-exports.Assert = Assert;
-exports.HasLength = HasLength;
-exports.IsBoolean = IsBoolean;
-exports.IsDate = IsDate;
-exports.IsDefined = IsDefined;
-exports.IsEmail = IsEmail;
-exports.IsNull = IsNull;
-exports.IsNumber = IsNumber;
-exports.IsString = IsString;
-exports.IsSymbol = IsSymbol;
-exports.OneOf = OneOf;
+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;

package/dist/assertions.d.ts

@@ -1,2 +1,58 @@
-export * from './assertions/index'
-export {}
+import { AssertionConstraint, Assertion } from '../types';
+import { assert } from './assert';
+export { assert };
+type LengthAssertionConstraint = AssertionConstraint<string | unknown[], number, [exact: number], 'length.exact'> | AssertionConstraint<string | unknown[], number, [max: number], 'length.max'> | AssertionConstraint<string | unknown[], number, [min: number], 'length.min'> | AssertionConstraint<string | unknown[], number, [range: [number, number]], 'length.range'>;
+type SizeAssertionConstraint = AssertionConstraint<Map<unknown, unknown> | Set<unknown>, number, [exact: number], 'size.exact'> | AssertionConstraint<Map<unknown, unknown> | Set<unknown>, number, [max: number], 'size.max'> | AssertionConstraint<Map<unknown, unknown> | Set<unknown>, number, [min: number], 'size.min'> | AssertionConstraint<Map<unknown, unknown> | Set<unknown>, number, [range: [number, number]], 'size.range'>;
+type ValueAssertionConstraint = AssertionConstraint<number, number, [exact: number], 'number.exact'> | AssertionConstraint<number, number, [max: number], 'number.max'> | AssertionConstraint<number, number, [min: number], 'number.min'> | AssertionConstraint<number, number, [range: [number, number]], 'number.range'>;
+export declare const isBoolean: Assertion<boolean, [], "type.boolean", undefined, "isBoolean">;
+export declare const isBigInt: Assertion<bigint, [], "type.bigint", undefined, "isBigInt">;
+export declare const isBlob: Assertion<Blob, [], "type.blob", undefined, "isBlob">;
+export declare const isDate: Assertion<Date, [], "type.date", undefined, "isDate">;
+export declare const isDefined: Assertion<{}, [], "value.defined", undefined, "isDefined">;
+export declare const isEmail: Assertion<string, [], "string.email", undefined, "isEmail">;
+export declare const isFile: Assertion<File, [], "type.file", undefined, "isFile">;
+export declare const isFunction: Assertion<(...args: never[]) => unknown, [], "type.function", undefined, "isFunction">;
+export declare const isMap: Assertion<Map<unknown, unknown>, [], "type.map", undefined, "isMap">;
+export declare const isNaN: Assertion<number, [], "number.nan", undefined, "isNaN">;
+export declare const isNull: Assertion<null, [], "type.null", undefined, "isNull">;
+export declare const isNumber: Assertion<number, [], "type.number", undefined, "isNumber">;
+export declare const isSet: Assertion<Set<unknown>, [], "type.set", undefined, "isSet">;
+export declare const isString: Assertion<string, [], "type.string", undefined, "isString">;
+export declare const isSymbol: Assertion<symbol, [], "type.symbol", undefined, "isSymbol">;
+export declare const hasLength: ({ exact, max, min, range, bail, }?: {
+    exact?: number | null;
+    max?: number | null;
+    min?: number | null;
+    range?: [number, number] | null;
+    bail?: boolean;
+}) => Assertion<string | unknown[], LengthAssertionConstraint[], "length.unsupported-type", undefined, "hasLength">;
+export declare const hasSize: ({ exact, max, min, range, bail, }?: {
+    exact?: number | null;
+    max?: number | null;
+    min?: number | null;
+    range?: [number, number] | null;
+    bail?: boolean;
+}) => Assertion<Map<unknown, unknown> | Set<unknown>, SizeAssertionConstraint[], "size.unsupported-type", undefined, "hasSize">;
+export declare const hasPattern: (pattern: RegExp, { bail, }?: {
+    bail?: boolean;
+}) => Assertion<string, readonly [readonly [(value: string) => string, (value: string, pattern: RegExp) => boolean, "string.pattern", RegExp]], "string.unsupported-type", undefined, "hasPattern">;
+export declare const startsWith: (prefix: string, { bail, }?: {
+    bail?: boolean;
+}) => Assertion<string, readonly [readonly [(value: string) => string, (value: string, prefix: string) => boolean, "string.starts-with", string]], "string.unsupported-type", undefined, "startsWith">;
+export declare const endsWith: (suffix: string, { bail, }?: {
+    bail?: boolean;
+}) => Assertion<string, readonly [readonly [(value: string) => string, (value: string, suffix: string) => boolean, "string.ends-with", string]], "string.unsupported-type", undefined, "endsWith">;
+export declare const hasValue: ({ exact, max, min, range, bail, }?: {
+    exact?: number | null;
+    max?: number | null;
+    min?: number | null;
+    range?: [number, number] | null;
+    bail?: boolean;
+}) => Assertion<number, ValueAssertionConstraint[], "number.unsupported-type", undefined, "hasValue">;
+export declare const multipleOf: (step: number, { bail, }?: {
+    bail?: boolean;
+}) => Assertion<number, readonly [readonly [(value: number) => number, (value: number, step: number) => boolean, "number.multiple-of", number]], "number.unsupported-type", undefined, "multipleOf">;
+export declare const oneOf: <Actual = unknown>(values: Actual[] | Record<string, Actual>, { equalTo, bail, }?: {
+    equalTo?: (a: Actual, b: unknown) => boolean;
+    bail?: boolean;
+}) => Assertion<Actual, [], "value.one-of", readonly [Actual[]], "oneOf">;

package/dist/assertions.mjs

@@ -1,109 +1,207 @@
-import { Or, isArray, isString, isExact, isNumber, isBoolean, isDate, Not, isUndefined, isEmail, isNull, isSymbol } from "./predicates.mjs";
-const delegate = (p) => {
-  return (value) => p(value);
+import { assert } from "./assert.mjs";
+import { isString as isString$1, isArray, isMap as isMap$1, isSet as isSet$1, isNumber as isNumber$1, isBigInt as isBigInt$1, isBlob as isBlob$1, isBoolean as isBoolean$1, isDate as isDate$1, isEmail as isEmail$1, isFile as isFile$1, isFunction as isFunction$1, isNaN as isNaN$1, isNull as isNull$1, isSymbol as isSymbol$1 } from "./predicates.mjs";
+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 Assert = (predicate, options) => {
-  const extender = (asserts = []) => {
-    return {
-      That(...asserts2) {
-        return Object.assign(delegate(predicate), options, extender(asserts2));
-      },
-      get also() {
-        return asserts;
-      }
-    };
-  };
-  return Object.assign(delegate(predicate), options, extender());
-};
-const isGTE = (min) => (x) => isNumber(x) && x >= min;
-const isLTE = (max) => (x) => isNumber(x) && x <= max;
-const IsEqual = (exact) => Assert((x) => isExact(exact)(x.length), {
-  fqn: "@modulify/validator/HasLength[exact]",
-  bail: false,
-  reason: "exact",
-  meta: exact
-});
-const IsGTE = (min) => Assert((x) => isGTE(min)(x.length), {
-  fqn: "@modulify/validator/HasLength[min]",
-  bail: false,
-  reason: "min",
-  meta: min
-});
-const IsLTE = (max) => Assert((x) => isLTE(max)(x.length), {
-  fqn: "@modulify/validator/HasLength[max]",
-  bail: false,
-  reason: "max",
-  meta: max
+const length = (value) => value.length;
+const size = (value) => value.size;
+const isBoolean = assert(isBoolean$1, { name: "isBoolean", bail: true, code: "type.boolean" });
+const isBigInt = assert(isBigInt$1, { name: "isBigInt", bail: true, code: "type.bigint" });
+const isBlob = assert(isBlob$1, { name: "isBlob", bail: true, code: "type.blob" });
+const isDate = assert(isDate$1, { name: "isDate", bail: true, code: "type.date" });
+const isDefined = assert((value) => value !== void 0, {
+  name: "isDefined",
+  bail: true,
+  code: "value.defined"
 });
-const HasLength = ({
+const isEmail = assert(isEmail$1, { name: "isEmail", bail: true, code: "string.email" });
+const isFile = assert(isFile$1, { name: "isFile", bail: true, code: "type.file" });
+const isFunction = assert(isFunction$1, { name: "isFunction", bail: true, code: "type.function" });
+const isMap = assert(isMap$1, { name: "isMap", bail: true, code: "type.map" });
+const isNaN = assert(isNaN$1, { name: "isNaN", bail: true, code: "number.nan" });
+const isNull = assert(isNull$1, { name: "isNull", bail: true, code: "type.null" });
+const isNumber = assert(isNumber$1, { name: "isNumber", bail: true, code: "type.number" });
+const isSet = assert(isSet$1, { name: "isSet", bail: true, code: "type.set" });
+const isString = assert(isString$1, { name: "isString", bail: true, code: "type.string" });
+const isSymbol = assert(isSymbol$1, { 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(
+    (value) => isArray(value) || isString$1(value),
+    {
+      name: "hasLength",
+      bail,
+      code: "length.unsupported-type"
+    },
+    constraints
+  );
+};
+const hasSize = ({
   exact = null,
   max = null,
   min = null,
+  range = null,
   bail = false
-}) => Assert(Or(isString, isArray), {
-  fqn: "@modulify/validator/HasLength",
-  bail,
-  reason: "unsupported"
-}).That(
-  ...exact !== null ? [IsEqual(exact)] : [],
-  ...max !== null ? [IsLTE(max)] : [],
-  ...min !== null ? [IsGTE(min)] : []
+} = {}) => {
+  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(
+    (value) => isMap$1(value) || isSet$1(value),
+    {
+      name: "hasSize",
+      bail,
+      code: "size.unsupported-type"
+    },
+    constraints
+  );
+};
+const hasPattern = (pattern, {
+  bail = false
+} = {}) => assert(
+  isString$1,
+  {
+    name: "hasPattern",
+    bail,
+    code: "string.unsupported-type"
+  },
+  [[
+    (value) => value,
+    matchesPattern,
+    "string.pattern",
+    pattern
+  ]]
 );
-const IsBoolean = Assert(isBoolean, {
-  fqn: "@modulify/validator/IsBoolean",
-  bail: true
-});
-const IsDate = Assert(isDate, {
-  fqn: "@modulify/validator/IsDate",
-  bail: true
-});
-const IsDefined = Assert(Not(isUndefined), {
-  fqn: "@modulify/validator/IsDefined",
-  bail: true,
-  reason: "undefined"
-});
-const IsEmail = Assert(isEmail, {
-  fqn: "@modulify/validator/IsEmail",
-  bail: true
-});
-const IsNull = Assert(isNull, {
-  fqn: "@modulify/validator/IsNull",
-  bail: true
-});
-const IsNumber = Assert(isNumber, {
-  fqn: "@modulify/validator/IsNumber",
-  bail: true
-});
-const IsString = Assert(isString, {
-  fqn: "@modulify/validator/IsString",
-  bail: true
-});
-const IsSymbol = Assert(isSymbol, {
-  fqn: "@modulify/validator/IsSymbol",
-  bail: true
-});
-const OneOf = (values, {
+const startsWith = (prefix, {
+  bail = false
+} = {}) => assert(
+  isString$1,
+  {
+    name: "startsWith",
+    bail,
+    code: "string.unsupported-type"
+  },
+  [[
+    (value) => value,
+    startsWith$1,
+    "string.starts-with",
+    prefix
+  ]]
+);
+const endsWith = (suffix, {
+  bail = false
+} = {}) => assert(
+  isString$1,
+  {
+    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(
+    isNumber$1,
+    {
+      name: "hasValue",
+      bail,
+      code: "number.unsupported-type"
+    },
+    constraints
+  );
+};
+const multipleOf = (step, {
+  bail = false
+} = {}) => assert(
+  isNumber$1,
+  {
+    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 = isArray(values) ? values : Object.values(values);
-  const oneOf = (value) => haystack.some((allowed) => equalTo(allowed, value));
-  return Assert(oneOf, {
-    fqn: "@modulify/validator/OneOf",
+  return assert((value) => haystack.some((item) => equalTo(item, value)), {
+    name: "oneOf",
     bail,
-    meta: haystack
+    code: "value.one-of",
+    args: [haystack]
   });
 };
 export {
-  Assert,
-  HasLength,
-  IsBoolean,
-  IsDate,
-  IsDefined,
-  IsEmail,
-  IsNull,
-  IsNumber,
-  IsString,
-  IsSymbol,
-  OneOf
+  assert,
+  endsWith,
+  hasLength,
+  hasPattern,
+  hasSize,
+  hasValue,
+  isBigInt,
+  isBlob,
+  isBoolean,
+  isDate,
+  isDefined,
+  isEmail,
+  isFile,
+  isFunction,
+  isMap,
+  isNaN,
+  isNull,
+  isNumber,
+  isSet,
+  isString,
+  isSymbol,
+  multipleOf,
+  oneOf,
+  startsWith
 };

package/dist/checkers.d.ts

@@ -0,0 +1,8 @@
+export declare const isEqual: (value: number, exact: number) => boolean;
+export declare const isGte: (value: number, min: number) => boolean;
+export declare const isLte: (value: number, max: number) => boolean;
+export declare const inRange: (value: number, [min, max]: [number, number]) => boolean;
+export declare const startsWith: (value: string, prefix: string) => boolean;
+export declare const endsWith: (value: string, suffix: string) => boolean;
+export declare const matchesPattern: (value: string, pattern: RegExp) => boolean;
+export declare const isMultipleOf: (value: number, step: number) => boolean;