@modulify/validator 0.3.0 → 0.3.1

package/dist/index.mjs

@@ -1,85 +1,9 @@
-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 { arrayify, isValidator } from "./constraints.mjs";
+import { custom, describe, meta } from "./metadata.mjs";
+import { assert, isRefinementAssertion, refine, runRefinementAssertion } from "./assert.mjs";
+import { endsWith, 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, multipleOf, oneOf, startsWith } from "./assertions.mjs";
 import { discriminatedUnion, each, exact, nullable, nullish, optional, record, shape, tuple, union } from "./combinators.mjs";
-//#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]));
-};
-var isPathPrefix = (path, prefix) => {
-	if (prefix.length > path.length) return false;
-	return prefix.every((part, index) => Object.is(part, path[index]));
-};
-var createTreeState = (path) => ({
-	path: Object.freeze([...path]),
-	self: [],
-	subtree: [],
-	children: /* @__PURE__ */ new Map()
-});
-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);
-	}
-};
-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);
-	}
-};
-var collection = (violations) => new ViolationCollection(violations);
-//#endregion
+import { ViolationCollection, collection } from "./violations.mjs";
 //#region src/index.ts
 var collectViolations = async (value, constraints, path = []) => {
 	const validations = [];

package/dist/json-schema.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_assert = require("./assert-BDOtHdLx.cjs");
+const require_metadata = require("./metadata.cjs");
 //#region src/json-schema.ts
 var jsonSchemaMetadataKeys = [
 	"title",
@@ -379,7 +379,7 @@ var exportDescriptor = (descriptor, context) => {
 	return applyMetadata(schema, descriptor.metadata);
 };
 var toJsonSchema = (constraints, options = {}) => {
-	return exportDescriptor(require_assert.describeConstraints(constraints), {
+	return exportDescriptor(require_metadata.describeConstraints(constraints), {
 		mode: options.mode ?? "bestEffort",
 		path: []
 	});

package/dist/json-schema.mjs

@@ -1,4 +1,4 @@
-import { u as describeConstraints } from "./assert-CzMg5aO7.mjs";
+import { describeConstraints } from "./metadata.mjs";
 //#region src/json-schema.ts
 var jsonSchemaMetadataKeys = [
 	"title",

package/dist/metadata.cjs

@@ -1,7 +1,99 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_assert = require("./assert-BDOtHdLx.cjs");
-exports.attachConstraintDescriptor = require_assert.attachConstraintDescriptor;
-exports.custom = require_assert.custom;
-exports.describe = require_assert.describe;
-exports.describeConstraints = require_assert.describeConstraints;
-exports.meta = require_assert.meta;
+const require_constraints = require("./constraints.cjs");
+//#region src/metadata.ts
+var constraintDescriptorSymbol = Symbol("modulify.validator.descriptor");
+var constraintMetadataSymbol = Symbol("modulify.validator.metadata");
+var cloneCallableConstraint = (constraint) => {
+	const source = constraint;
+	const cloned = ((value) => source(value));
+	const { length: _length, name: _name, prototype: _prototype, ...descriptors } = Object.getOwnPropertyDescriptors(source);
+	Object.defineProperties(cloned, descriptors);
+	try {
+		Object.defineProperty(cloned, "name", {
+			configurable: true,
+			value: source.name
+		});
+	} catch {}
+	Object.setPrototypeOf(cloned, Object.getPrototypeOf(source));
+	return cloned;
+};
+var cloneConstraint = (constraint) => {
+	if (typeof constraint === "function") return cloneCallableConstraint(constraint);
+	return Object.create(Object.getPrototypeOf(constraint), Object.getOwnPropertyDescriptors(constraint));
+};
+var freezeMetadata = (metadata) => Object.freeze({ ...metadata });
+var getConstraintMetadata = (constraint) => {
+	return constraint[constraintMetadataSymbol];
+};
+var getDescriptorFactory = (constraint) => {
+	return constraint[constraintDescriptorSymbol];
+};
+var getPublicDescriptor = (constraint) => {
+	if (!require_constraints.isValidator(constraint)) return;
+	const { describe } = constraint;
+	return typeof describe === "function" ? describe.call(constraint) : void 0;
+};
+var inferAssertionDescriptor = (assertion) => ({
+	kind: "assertion",
+	name: assertion.name,
+	bail: assertion.bail,
+	code: assertion.name,
+	args: [],
+	constraints: assertion.constraints.map(([, , code, ...args]) => ({
+		code,
+		args
+	}))
+});
+var withMetadata = (descriptor, metadata) => {
+	if (!metadata) return descriptor;
+	return {
+		...descriptor,
+		metadata
+	};
+};
+var attachConstraintDescriptor = (constraint, describe) => {
+	Object.defineProperty(constraint, constraintDescriptorSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: describe,
+		writable: false
+	});
+	return constraint;
+};
+var meta = (constraint, metadata) => {
+	const cloned = cloneConstraint(constraint);
+	const nextMetadata = freezeMetadata({
+		...getConstraintMetadata(constraint) ?? {},
+		...metadata
+	});
+	Object.defineProperty(cloned, constraintMetadataSymbol, {
+		configurable: true,
+		enumerable: false,
+		value: nextMetadata,
+		writable: false
+	});
+	return cloned;
+};
+var custom = (validator) => validator;
+var describeConstraints = (constraints) => {
+	const values = require_constraints.arrayify(constraints);
+	return values.length === 1 ? describe(values[0]) : {
+		kind: "allOf",
+		constraints: values.map((value) => describe(value))
+	};
+};
+var describe = (constraint) => {
+	const factory = getDescriptorFactory(constraint);
+	const metadata = getConstraintMetadata(constraint);
+	if (factory) return withMetadata(factory(), metadata);
+	const publicDescriptor = getPublicDescriptor(constraint);
+	if (publicDescriptor) return withMetadata(publicDescriptor, metadata);
+	if (require_constraints.isValidator(constraint)) return withMetadata({ kind: "validator" }, metadata);
+	return withMetadata(inferAssertionDescriptor(constraint), metadata);
+};
+//#endregion
+exports.attachConstraintDescriptor = attachConstraintDescriptor;
+exports.custom = custom;
+exports.describe = describe;
+exports.describeConstraints = describeConstraints;
+exports.meta = meta;

package/dist/metadata.mjs

@@ -1,2 +1,94 @@
-import { c as custom, d as meta, l as describe, s as attachConstraintDescriptor, u as describeConstraints } from "./assert-CzMg5aO7.mjs";
+import { arrayify, isValidator } from "./constraints.mjs";
+//#region src/metadata.ts
+var constraintDescriptorSymbol = Symbol("modulify.validator.descriptor");
+var constraintMetadataSymbol = Symbol("modulify.validator.metadata");
+var cloneCallableConstraint = (constraint) => {
+	const source = constraint;
+	const cloned = ((value) => source(value));
+	const { length: _length, name: _name, prototype: _prototype, ...descriptors } = Object.getOwnPropertyDescriptors(source);
+	Object.defineProperties(cloned, descriptors);
+	try {
+		Object.defineProperty(cloned, "name", {
+			configurable: true,
+			value: source.name
+		});
+	} catch {}
+	Object.setPrototypeOf(cloned, Object.getPrototypeOf(source));
+	return cloned;
+};
+var cloneConstraint = (constraint) => {
+	if (typeof constraint === "function") return cloneCallableConstraint(constraint);
+	return Object.create(Object.getPrototypeOf(constraint), Object.getOwnPropertyDescriptors(constraint));
+};
+var freezeMetadata = (metadata) => Object.freeze({ ...metadata });
+var getConstraintMetadata = (constraint) => {
+	return constraint[constraintMetadataSymbol];
+};
+var getDescriptorFactory = (constraint) => {
+	return constraint[constraintDescriptorSymbol];
+};
+var getPublicDescriptor = (constraint) => {
+	if (!isValidator(constraint)) return;
+	const { describe } = constraint;
+	return typeof describe === "function" ? describe.call(constraint) : void 0;
+};
+var inferAssertionDescriptor = (assertion) => ({
+	kind: "assertion",
+	name: assertion.name,
+	bail: assertion.bail,
+	code: assertion.name,
+	args: [],
+	constraints: assertion.constraints.map(([, , code, ...args]) => ({
+		code,
+		args
+	}))
+});
+var withMetadata = (descriptor, metadata) => {
+	if (!metadata) return descriptor;
+	return {
+		...descriptor,
+		metadata
+	};
+};
+var attachConstraintDescriptor = (constraint, describe) => {
+	Object.defineProperty(constraint, constraintDescriptorSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: describe,
+		writable: false
+	});
+	return constraint;
+};
+var meta = (constraint, metadata) => {
+	const cloned = cloneConstraint(constraint);
+	const nextMetadata = freezeMetadata({
+		...getConstraintMetadata(constraint) ?? {},
+		...metadata
+	});
+	Object.defineProperty(cloned, constraintMetadataSymbol, {
+		configurable: true,
+		enumerable: false,
+		value: nextMetadata,
+		writable: false
+	});
+	return cloned;
+};
+var custom = (validator) => validator;
+var describeConstraints = (constraints) => {
+	const values = arrayify(constraints);
+	return values.length === 1 ? describe(values[0]) : {
+		kind: "allOf",
+		constraints: values.map((value) => describe(value))
+	};
+};
+var describe = (constraint) => {
+	const factory = getDescriptorFactory(constraint);
+	const metadata = getConstraintMetadata(constraint);
+	if (factory) return withMetadata(factory(), metadata);
+	const publicDescriptor = getPublicDescriptor(constraint);
+	if (publicDescriptor) return withMetadata(publicDescriptor, metadata);
+	if (isValidator(constraint)) return withMetadata({ kind: "validator" }, metadata);
+	return withMetadata(inferAssertionDescriptor(constraint), metadata);
+};
+//#endregion
 export { attachConstraintDescriptor, custom, describe, describeConstraints, meta };

package/dist/violations.cjs

@@ -0,0 +1,81 @@
+//#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]));
+};
+var isPathPrefix = (path, prefix) => {
+	if (prefix.length > path.length) return false;
+	return prefix.every((part, index) => Object.is(part, path[index]));
+};
+var createTreeState = (path) => ({
+	path: Object.freeze([...path]),
+	self: [],
+	subtree: [],
+	children: /* @__PURE__ */ new Map()
+});
+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);
+	}
+};
+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);
+	}
+};
+var collection = (violations) => new ViolationCollection(violations);
+//#endregion
+exports.ViolationCollection = ViolationCollection;
+exports.collection = collection;

package/dist/violations.mjs

@@ -0,0 +1,80 @@
+//#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]));
+};
+var isPathPrefix = (path, prefix) => {
+	if (prefix.length > path.length) return false;
+	return prefix.every((part, index) => Object.is(part, path[index]));
+};
+var createTreeState = (path) => ({
+	path: Object.freeze([...path]),
+	self: [],
+	subtree: [],
+	children: /* @__PURE__ */ new Map()
+});
+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);
+	}
+};
+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);
+	}
+};
+var collection = (violations) => new ViolationCollection(violations);
+//#endregion
+export { ViolationCollection, collection };

package/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "description": "Declarative validation util for JavaScript",
   "license": "MIT",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "exports": {
     ".": {
       "import": {