@modulify/validator 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -1,231 +1,178 @@
-import { endsWith, hasLength, hasPattern, hasSize, hasValue, isBigInt, isBlob, isBoolean, isDate, isDefined, isEmail, isFile, isFunction, isMap, isNaN, isNull, isNumber, isSet, isString, isSymbol, multipleOf, oneOf, startsWith } from "./assertions.mjs";
+import { a as refine, c as custom, d as meta, f as arrayify, i as isRefinementAssertion, l as describe, o as runRefinementAssertion, p as isValidator, t as assert } from "./assert-CzMg5aO7.mjs";
+import { A as startsWith, C as isSafeInteger, D as isValidDate, E as isSymbol, O as multipleOf, S as isRegExp, T as isString, _ as isMap, a as hasValue, b as isNumber, c as isBoolean, d as isEmail, f as isError, g as isInteger, h as isFunction, i as hasSize, k as oneOf, l as isDate, m as isFiniteNumber, n as hasLength, o as isBigInt, p as isFile, r as hasPattern, s as isBlob, t as endsWith, u as isDefined, v as isNaN, w as isSet, x as isPromiseLike, y as isNull } from "./assertions-DPYCHREw.mjs";
 import { discriminatedUnion, each, exact, nullable, nullish, optional, record, shape, tuple, union } from "./combinators.mjs";
-import { a as arrayify, i as isValidator } from "./metadata.es.js";
-import { c, b, m } from "./metadata.es.js";
-import { assert } from "./assert.mjs";
-const ROOT_PATH = Object.freeze([]);
-const normalizePath = (path) => path ?? ROOT_PATH;
-const isSamePath = (left, right = ROOT_PATH) => {
-  const normalizedLeft = normalizePath(left);
-  if (normalizedLeft.length !== right.length) {
-    return false;
-  }
-  return normalizedLeft.every((part, index) => Object.is(part, right[index]));
+//#region src/violations.ts
+var ROOT_PATH = Object.freeze([]);
+var normalizePath = (path) => path ?? ROOT_PATH;
+var isSamePath = (left, right = ROOT_PATH) => {
+	const normalizedLeft = normalizePath(left);
+	if (normalizedLeft.length !== right.length) return false;
+	return normalizedLeft.every((part, index) => Object.is(part, right[index]));
 };
-const isPathPrefix = (path, prefix) => {
-  if (prefix.length > path.length) {
-    return false;
-  }
-  return prefix.every((part, index) => Object.is(part, path[index]));
+var isPathPrefix = (path, prefix) => {
+	if (prefix.length > path.length) return false;
+	return prefix.every((part, index) => Object.is(part, path[index]));
 };
-const createTreeState = (path) => ({
-  path: Object.freeze([...path]),
-  self: [],
-  subtree: [],
-  children: /* @__PURE__ */ new Map()
+var createTreeState = (path) => ({
+	path: Object.freeze([...path]),
+	self: [],
+	subtree: [],
+	children: /* @__PURE__ */ new Map()
 });
-class TreeNode {
-  constructor(state) {
-    this.path = state.path;
-    this.self = new ViolationCollection(state.self);
-    this.subtree = new ViolationCollection(state.subtree);
-    this.children = new Map(
-      [...state.children.entries()].map(([key, child]) => [key, new TreeNode(child)])
-    );
-  }
-  at(path) {
-    if (!isPathPrefix(path, this.path)) {
-      return void 0;
-    }
-    if (path.length === this.path.length) {
-      return this;
-    }
-    const child = this.children.get(path[this.path.length]);
-    return child?.at(path);
-  }
-}
-const buildTree = (violations) => {
-  const root = createTreeState(ROOT_PATH);
-  violations.forEach((violation) => {
-    const path = normalizePath(violation.path);
-    root.subtree.push(violation);
-    if (path.length === 0) {
-      root.self.push(violation);
-      return;
-    }
-    let current = root;
-    const currentPath = [];
-    path.forEach((segment, index) => {
-      currentPath.push(segment);
-      let child = current.children.get(segment);
-      if (!child) {
-        child = createTreeState(currentPath);
-        current.children.set(segment, child);
-      }
-      child.subtree.push(violation);
-      if (index === path.length - 1) {
-        child.self.push(violation);
-      }
-      current = child;
-    });
-  });
-  return new TreeNode(root);
+var TreeNode = class TreeNode {
+	constructor(state) {
+		this.path = state.path;
+		this.self = new ViolationCollection(state.self);
+		this.subtree = new ViolationCollection(state.subtree);
+		this.children = new Map([...state.children.entries()].map(([key, child]) => [key, new TreeNode(child)]));
+	}
+	at(path) {
+		if (!isPathPrefix(path, this.path)) return;
+		if (path.length === this.path.length) return this;
+		return this.children.get(path[this.path.length])?.at(path);
+	}
 };
-class ViolationCollection {
-  constructor(violations) {
-    this.violations = [...violations];
-    this.size = this.violations.length;
-  }
-  [Symbol.iterator]() {
-    return this.violations[Symbol.iterator]();
-  }
-  forEach(callback) {
-    this.violations.forEach((violation, index) => callback(violation, index, this));
-  }
-  map(callback) {
-    return this.violations.map((violation, index) => callback(violation, index, this));
-  }
-  at(path) {
-    return new ViolationCollection(this.violations.filter((violation) => isSamePath(violation.path, path)));
-  }
-  tree() {
-    return buildTree(this.violations);
-  }
-}
-const collection = (violations) => new ViolationCollection(violations);
-const collectViolations = async (value, constraints, path = []) => {
-  const validations = [];
-  for (const c2 of arrayify(constraints)) {
-    if (isValidator(c2)) {
-      validations.push(...c2.run(collectViolations, value, path).map((v2) => v2 instanceof Promise ? v2 : Promise.resolve(v2)));
-      continue;
-    }
-    const v = c2(value);
-    if (v instanceof Promise) {
-      if (c2.bail) {
-        const awaited = await v;
-        if (awaited) {
-          validations.push(Promise.resolve([Object.assign(awaited, { path: [...path] })]));
-          break;
-        }
-      } else {
-        validations.push(v.then((v2) => v2 ? [Object.assign(v2, { path: [...path] })] : []));
-      }
-    } else if (v) {
-      validations.push(Promise.resolve([Object.assign(v, { path: [...path] })]));
-      if (c2.bail) {
-        break;
-      }
-    }
-  }
-  return settle(value, path, validations);
+var buildTree = (violations) => {
+	const root = createTreeState(ROOT_PATH);
+	violations.forEach((violation) => {
+		const path = normalizePath(violation.path);
+		root.subtree.push(violation);
+		if (path.length === 0) {
+			root.self.push(violation);
+			return;
+		}
+		let current = root;
+		const currentPath = [];
+		path.forEach((segment, index) => {
+			currentPath.push(segment);
+			let child = current.children.get(segment);
+			if (!child) {
+				child = createTreeState(currentPath);
+				current.children.set(segment, child);
+			}
+			child.subtree.push(violation);
+			if (index === path.length - 1) child.self.push(violation);
+			current = child;
+		});
+	});
+	return new TreeNode(root);
+};
+var ViolationCollection = class ViolationCollection {
+	constructor(violations) {
+		this.violations = [...violations];
+		this.size = this.violations.length;
+	}
+	[Symbol.iterator]() {
+		return this.violations[Symbol.iterator]();
+	}
+	forEach(callback) {
+		this.violations.forEach((violation, index) => callback(violation, index, this));
+	}
+	map(callback) {
+		return this.violations.map((violation, index) => callback(violation, index, this));
+	}
+	at(path) {
+		return new ViolationCollection(this.violations.filter((violation) => isSamePath(violation.path, path)));
+	}
+	tree() {
+		return buildTree(this.violations);
+	}
 };
-const collectViolationsSync = (value, constraints, path = []) => {
-  const violations = [];
-  for (const c2 of arrayify(constraints)) {
-    if (isValidator(c2)) {
-      violations.push(...c2.run(collectViolationsSync, value, path));
-      continue;
-    }
-    const v = c2(value);
-    if (v instanceof Promise) {
-      throw new Error("Found asynchronous validator " + String(c2.name));
-    } else if (v) {
-      violations.push(Object.assign(v, { path: [...path] }));
-      if (c2.bail) break;
-    }
-  }
-  return flatten(violations);
+var collection = (violations) => new ViolationCollection(violations);
+//#endregion
+//#region src/index.ts
+var collectViolations = async (value, constraints, path = []) => {
+	const validations = [];
+	let establishedAssertionDomain = false;
+	for (const c of arrayify(constraints)) {
+		if (isValidator(c)) {
+			establishedAssertionDomain = false;
+			validations.push(...c.run(collectViolations, value, path).map((v) => v instanceof Promise ? v : Promise.resolve(v)));
+			continue;
+		}
+		if (!establishedAssertionDomain && isRefinementAssertion(c)) throw new Error(`Refinement ${String(c.name)} requires a compatible preceding guard`);
+		const v = establishedAssertionDomain && isRefinementAssertion(c) ? runRefinementAssertion(c, value) : c(value);
+		if (v instanceof Promise) {
+			establishedAssertionDomain = false;
+			if (c.bail) {
+				const awaited = await v;
+				if (awaited) {
+					validations.push(Promise.resolve([Object.assign(awaited, { path: [...path] })]));
+					break;
+				}
+			} else validations.push(v.then((v) => v ? [Object.assign(v, { path: [...path] })] : []));
+		} else if (v) {
+			establishedAssertionDomain = false;
+			validations.push(Promise.resolve([Object.assign(v, { path: [...path] })]));
+			if (c.bail) break;
+		} else establishedAssertionDomain = true;
+	}
+	return settle(value, path, validations);
 };
+collectViolations.sync = false;
+var collectViolationsSync = (value, constraints, path = []) => {
+	const violations = [];
+	let establishedAssertionDomain = false;
+	for (const c of arrayify(constraints)) {
+		if (isValidator(c)) {
+			establishedAssertionDomain = false;
+			violations.push(...c.run(collectViolationsSync, value, path));
+			continue;
+		}
+		if (!establishedAssertionDomain && isRefinementAssertion(c)) throw new Error(`Refinement ${String(c.name)} requires a compatible preceding guard`);
+		const v = establishedAssertionDomain && isRefinementAssertion(c) ? runRefinementAssertion(c, value) : c(value);
+		if (v instanceof Promise) throw new Error("Found asynchronous validator " + String(c.name));
+		else if (v) {
+			establishedAssertionDomain = false;
+			violations.push(Object.assign(v, { path: [...path] }));
+			if (c.bail) break;
+		} else establishedAssertionDomain = true;
+	}
+	return flatten(violations);
+};
+collectViolationsSync.sync = true;
 function toResult(value, violations) {
-  return violations.length === 0 ? [true, value, []] : [false, value, violations];
+	return violations.length === 0 ? [
+		true,
+		value,
+		[]
+	] : [
+		false,
+		value,
+		violations
+	];
 }
 function flatten(recursive) {
-  const flattened = [];
-  recursive.forEach((element) => {
-    flattened.push(...Array.isArray(element) ? flatten(element) : [element]);
-  });
-  return flattened;
+	const flattened = [];
+	recursive.forEach((element) => {
+		flattened.push(...Array.isArray(element) ? flatten(element) : [element]);
+	});
+	return flattened;
 }
 async function settle(value, path, validations) {
-  const violations = [];
-  const settled = await Promise.allSettled(validations);
-  settled.forEach((result) => {
-    if (result.status === "fulfilled") {
-      violations.push(...result.value);
-    } else {
-      violations.push({
-        value,
-        path,
-        violates: { kind: "runtime", name: "validate", code: "runtime.rejection", args: [result.reason] }
-      });
-    }
-  });
-  return violations;
+	const violations = [];
+	(await Promise.allSettled(validations)).forEach((result) => {
+		if (result.status === "fulfilled") violations.push(...result.value);
+		else violations.push({
+			value,
+			path,
+			violates: {
+				kind: "runtime",
+				name: "validate",
+				code: "runtime.rejection",
+				args: [result.reason]
+			}
+		});
+	});
+	return violations;
 }
-const matches = {
-  sync(value, constraints) {
-    return collectViolationsSync(value, constraints).length === 0;
-  }
-};
-const validate = Object.assign(
-  async (value, constraints) => {
-    const violations = await collectViolations(value, constraints);
-    return toResult(
-      value,
-      violations
-    );
-  },
-  {
-    sync(value, constraints) {
-      const violations = collectViolationsSync(value, constraints);
-      return toResult(
-        value,
-        violations
-      );
-    }
-  }
-);
-export {
-  ViolationCollection,
-  assert,
-  collection,
-  c as custom,
-  b as describe,
-  discriminatedUnion,
-  each,
-  endsWith,
-  exact,
-  hasLength,
-  hasPattern,
-  hasSize,
-  hasValue,
-  isBigInt,
-  isBlob,
-  isBoolean,
-  isDate,
-  isDefined,
-  isEmail,
-  isFile,
-  isFunction,
-  isMap,
-  isNaN,
-  isNull,
-  isNumber,
-  isSet,
-  isString,
-  isSymbol,
-  matches,
-  m as meta,
-  multipleOf,
-  nullable,
-  nullish,
-  oneOf,
-  optional,
-  record,
-  shape,
-  startsWith,
-  tuple,
-  union,
-  validate
-};
+var matches = { sync(value, constraints) {
+	return collectViolationsSync(value, constraints).length === 0;
+} };
+var validate = /* @__PURE__ */ Object.assign(async (value, constraints) => {
+	return toResult(value, await collectViolations(value, constraints));
+}, { sync(value, constraints) {
+	return toResult(value, collectViolationsSync(value, constraints));
+} });
+//#endregion
+export { ViolationCollection, assert, collection, custom, describe, discriminatedUnion, each, endsWith, exact, hasLength, hasPattern, hasSize, hasValue, isBigInt, isBlob, isBoolean, isDate, isDefined, isEmail, isError, isFile, isFiniteNumber, isFunction, isInteger, isMap, isNaN, isNull, isNumber, isPromiseLike, isRegExp, isSafeInteger, isSet, isString, isSymbol, isValidDate, matches, meta, multipleOf, nullable, nullish, oneOf, optional, record, refine, shape, startsWith, tuple, union, validate };