n4s 6.1.12 → 6.2.0

package/dist/{n4s-KWquSyTb.mjs → n4s-BxrvnvKp.mjs}

@@ -1,4 +1,4 @@
-import { StringObject, asArray, assign, bindNot, dynamicValue, greaterThan, greaterThan as greaterThan$1, hasOwnProperty, invariant, isBoolean, isEmpty, isEmpty as isEmpty$2, isFailure, isNotEmpty, isNotEmpty as isNotEmpty$2, isNotNull, isNotNullish, isNotUndefined, isNull, isNullish, isNumeric, isObject, isStringValue, isUndefined, isUnsafeKey, lengthEquals, mapFirst, numberEquals, numberEquals as numberEquals$1, numberNotEquals, toNumber } from "vest-utils";
+import { StringObject, asArray, assign, bindNot, dynamicValue, greaterThan, greaterThan as greaterThan$1, hasOwnProperty, invariant, isBoolean, isEmpty, isEmpty as isEmpty$2, isFailure, isFunction, isNotEmpty, isNotEmpty as isNotEmpty$2, isNotNull, isNotNullish, isNotUndefined, isNull, isNullish, isNumeric, isObject, isStringValue, isUndefined, isUnsafeKey, lengthEquals, longerThan, mapFirst, numberEquals, numberEquals as numberEquals$1, numberNotEquals, toNumber } from "vest-utils";
 import { createCascade } from "context";
 
 //#region rolldown:runtime
@@ -274,7 +274,7 @@ function notInside(value, container) {
 var commonLength_exports = /* @__PURE__ */ __export({
 	lengthEquals: () => lengthEquals$1,
 	lengthNotEquals: () => lengthNotEquals,
-	longerThan: () => longerThan,
+	longerThan: () => longerThan$1,
 	longerThanOrEquals: () => longerThanOrEquals,
 	max: () => max,
 	maxLength: () => maxLength,
@@ -297,7 +297,7 @@ function lengthEquals$1(value, n) {
 function lengthNotEquals(value, n) {
 	return value.length !== n;
 }
-function longerThan(value, n) {
+function longerThan$1(value, n) {
 	return value.length > n;
 }
 function longerThanOrEquals(value, n) {
@@ -342,7 +342,7 @@ var arrayRules_exports = /* @__PURE__ */ __export({
 	isNotEmpty: () => isNotEmpty$2,
 	lengthEquals: () => lengthEquals$1,
 	lengthNotEquals: () => lengthNotEquals,
-	longerThan: () => longerThan,
+	longerThan: () => longerThan$1,
 	longerThanOrEquals: () => longerThanOrEquals,
 	maxLength: () => maxLength,
 	minLength: () => minLength,
@@ -1575,16 +1575,177 @@ function shape(value, schema) {
 	return RuleRunReturn.Passing(baseRes.type);
 }
 
+//#endregion
+//#region src/rules/schemaRules/record.ts
+/**
+* Validates that an object's dynamic keys and/or values match provided rules.
+* Like TypeScript's Record<K, V>, it checks elements against shape rules.
+*
+* @param value - The object to validate
+* @param arg1 - Either the key rule (if arg2 is present) or the value rule
+* @param arg2 - The value rule (if arg1 is the key rule)
+* @returns RuleRunReturn indicating success or failure
+*/
+function record(value, arg1, arg2) {
+	if (!isObject(value) || Array.isArray(value)) return RuleRunReturn.Failing(value);
+	const rules = parseRules(arg1, arg2);
+	const dangerousKey = findDangerousOwnKey(value);
+	if (dangerousKey) return createRecordFailure(value, dangerousKey, RuleRunReturn.Failing(value));
+	const parsedValue = safeShallowCopy(value);
+	return mapFirst(ownKeys(value), (key, breakout) => {
+		const errorRes = evaluateRecordEntry(key, value, rules, parsedValue);
+		if (errorRes) breakout(true, errorRes);
+	}) || RuleRunReturn.Passing(parsedValue);
+}
+function parseRules(arg1, arg2) {
+	if (arg2 !== void 0) return {
+		keyRule: arg1,
+		valueRule: arg2
+	};
+	return {
+		keyRule: void 0,
+		valueRule: arg1
+	};
+}
+function validateKey(key, keyRule) {
+	return ctx.run({
+		value: key,
+		set: true
+	}, () => keyRule.run(key));
+}
+function evaluateRecordEntry(key, value, rules, parsedValue) {
+	if (rules.keyRule) {
+		const keyRes = validateKey(key, rules.keyRule);
+		if (!keyRes.pass) return createRecordFailure(value, key, keyRes);
+		if (keyRes.type !== key) {
+			delete parsedValue[key];
+			key = keyRes.type;
+		}
+	}
+	const valRes = ctx.run({
+		value: value[key],
+		set: true,
+		meta: { key }
+	}, () => rules.valueRule.run(value[key]));
+	if (!valRes.pass) return createRecordFailure(value, key, valRes);
+	parsedValue[key] = valRes.type;
+}
+function createRecordFailure(value, key, ruleRes) {
+	const currentPath = ruleRes.path || [];
+	const newRes = RuleRunReturn.Failing(value, ruleRes.message);
+	newRes.path = [key, ...currentPath];
+	return newRes;
+}
+
+//#endregion
+//#region src/rules/schemaRules/tuple.ts
+/**
+* Validates that a value is a fixed-length array (tuple) where each position
+* matches the corresponding rule. Enforces exact length unless trailing
+* elements use enforce.optional().
+*
+* Parsed values are propagated: if a rule transforms its input (e.g. toNumber),
+* the parsed tuple returned via `.parse()` carries the transformed values.
+*
+* @param value - The array to validate
+* @param rules - One RuleInstance per tuple position
+* @returns RuleRunReturn indicating success or failure, with `.type` holding
+*          the parsed tuple on success
+*
+* @example
+* ```typescript
+* // Eager API
+* enforce(['hello', 42]).tuple(enforce.isString(), enforce.isNumber());
+*
+* // Lazy API
+* const coordSchema = enforce.tuple(enforce.isNumber(), enforce.isNumber());
+* coordSchema.test([40.7, -74.0]); // true
+* coordSchema.test([40.7]);        // false — too few
+* coordSchema.test([40.7, -74, 0]);// false — too many
+* ```
+*/
+function tuple(value, ...rules) {
+	if (!Array.isArray(value)) return RuleRunReturn.Failing(value);
+	if (greaterThan(countRequired(rules), value.length) || longerThan(value, rules.length)) return RuleRunReturn.Failing(value);
+	return validateElements(value, rules);
+}
+/**
+* Counts the number of required (non-optional) leading positions by scanning
+* backwards from the end of the rules array. Stops at the first non-optional
+* rule, so only *trailing* optionals reduce the required count.
+*/
+function countRequired(rules) {
+	let count = rules.length;
+	for (let i = rules.length - 1; i >= 0; i--) if (isOptionalRule(rules[i])) count = i;
+	else break;
+	return count;
+}
+/**
+* Iterates over each rule position, validates the corresponding array element,
+* and collects parsed output values. Returns early on the first failing element
+* with an index-based error path.
+*/
+function validateElements(value, rules) {
+	const parsedTuple = [];
+	for (let i = 0; i < rules.length; i++) {
+		if (isBeyondArrayEnd(value, i, rules[i])) continue;
+		const res = runElementRule(value[i], rules[i], i);
+		if (!res.pass) return elementFailure(value, res, i);
+		parsedTuple.push(res.type ?? value[i]);
+	}
+	return RuleRunReturn.Passing(parsedTuple);
+}
+/**
+* Checks whether the given index is past the array's actual length
+* and the corresponding rule is optional, meaning it can be skipped.
+*/
+function isBeyondArrayEnd(value, index, rule) {
+	return index >= value.length && isOptionalRule(rule);
+}
+/**
+* Runs a single element's rule within an enforce context that carries
+* the element value and its positional index as metadata.
+*/
+function runElementRule(item, rule, index) {
+	return ctx.run({
+		value: item,
+		set: true,
+		meta: { index }
+	}, () => rule.run(item));
+}
+/**
+* Builds a failing RuleRunReturn with an error path that includes the
+* tuple index, prepended to any nested path from the inner rule failure.
+* For example, a shape failure at index 1 on key "id" yields path ["1", "id"].
+*/
+function elementFailure(value, res, index) {
+	const failure = RuleRunReturn.Failing(value, res.message);
+	failure.path = [index.toString(), ...res.path || []];
+	return failure;
+}
+/**
+* Determines whether a rule is optional by testing if it passes with undefined.
+* This mirrors how shape/loose detect optional fields — a rule wrapping
+* enforce.optional() will pass for undefined, while required rules will not.
+*/
+function isOptionalRule(rule) {
+	if (!rule || !isFunction(rule.test)) return false;
+	return rule.test(void 0);
+}
+
 //#endregion
 //#region src/rules/schemaRules/schemaRules.ts
 var schemaRules_exports = /* @__PURE__ */ __export({
 	isArrayOf: () => isArrayOf,
+	list: () => isArrayOf,
 	loose: () => loose,
 	omit: () => omit,
 	optional: () => optional,
 	partial: () => partial,
 	pick: () => pick,
-	shape: () => shape
+	record: () => record,
+	shape: () => shape,
+	tuple: () => tuple
 });
 
 //#endregion
@@ -1685,7 +1846,7 @@ var stringRules_exports = /* @__PURE__ */ __export({
 	isString: () => isString,
 	lengthEquals: () => lengthEquals$1,
 	lengthNotEquals: () => lengthNotEquals,
-	longerThan: () => longerThan,
+	longerThan: () => longerThan$1,
 	longerThanOrEquals: () => longerThanOrEquals,
 	matches: () => matches,
 	maxLength: () => maxLength,
@@ -2229,6 +2390,44 @@ const typeRules = {
 	isUndefined: () => addToChain({}, isUndefined$1)
 };
 
+//#endregion
+//#region src/rules/schemaRules/lazy.ts
+/**
+* Creates a lazy schema wrapper for recursive/self-referencing schemas.
+* The factory function is called on first validation and cached.
+*
+* @param factory - A function that returns the RuleInstance to delegate to
+* @returns A RuleInstance that defers schema resolution to validation time
+*
+* @example
+* ```typescript
+* type Category = { name: string; children: Category[] };
+*
+* const categorySchema = enforce.shape({
+*   name: enforce.isString(),
+*   children: enforce.isArrayOf(enforce.lazy(() => categorySchema)),
+* });
+*
+* categorySchema.test({
+*   name: 'Root',
+*   children: [
+*     { name: 'Child', children: [] },
+*   ],
+* }); // true
+* ```
+*/
+function lazy(factory) {
+	let cached = null;
+	const resolve = () => {
+		if (!cached) cached = factory();
+		return cached;
+	};
+	return addToChain({}, (value) => {
+		const result = ctx.run({ value }, () => resolve().run(value));
+		return RuleRunReturn.create(result, value);
+	});
+}
+
 //#endregion
 //#region src/lazy.ts
 const schemaModifiers = adaptDynamicRules({
@@ -2241,6 +2440,7 @@ const schemaEvaluators = adaptDynamicRules({
 	shape,
 	loose
 });
+const recordEvaluators = adaptDynamicRules({ record });
 /**
 * Wraps a lazy schema evaluator so the resulting RuleInstance carries
 * a `__schema` reference to the original schema definition.
@@ -2258,8 +2458,18 @@ const schemaRulesWithArrayChaining = {
 		const result = ctx.run({ value }, () => isArrayOf(value, ...rules));
 		return RuleRunReturn.create(result, value);
 	}),
+	lazy,
+	list: (...rules) => addToChain(arrayRules_exports, (value) => {
+		const result = ctx.run({ value }, () => isArrayOf(value, ...rules));
+		return RuleRunReturn.create(result, value);
+	}),
 	loose: schemaAttacher(schemaEvaluators.loose),
-	shape: schemaAttacher(schemaEvaluators.shape)
+	record: recordEvaluators.record,
+	shape: schemaAttacher(schemaEvaluators.shape),
+	tuple: (...rules) => addToChain(arrayRules_exports, (value) => {
+		const result = ctx.run({ value }, () => tuple(value, ...rules));
+		return RuleRunReturn.create(result, value);
+	})
 };
 const baseEnforceLazy = {
 	...adaptDynamicRules(compoundRules_exports),
@@ -2450,4 +2660,4 @@ enforce.extend = function extend(rules) {
 
 //#endregion
 export { compose as n, ctx as r, enforce as t };
-//# sourceMappingURL=n4s-KWquSyTb.mjs.map
+//# sourceMappingURL=n4s-BxrvnvKp.mjs.map