@warlock.js/seal 4.9.1 → 4.9.2

package/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to `@warlock.js/seal` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 4.9.2
+
+### Fixed
+
+- `v.literal("")` could never pass. Every validator is required by default and `required` rejects anything the empty-value check calls empty — which includes `""` — so a schema demanding an exact empty string reported "is required" for a field that was present. A literal set containing an empty value now uses `present` (the key must exist) instead of `required`, leaving the literal set to judge the value. Only the empty string was affected; `v.literal(0)` and `v.literal(false)` always worked
+- `v.literal("").optional()` silently disabled the literal check rather than fixing it, accepting `""`, `null` **and** a missing key alike. The literal rule now runs on empty values (`requiresValue: false`) while treating absence as the required/present rule's question, so `.optional()` means optional again and a present value must still match
+- a **failed** validation no longer returns the input it rejected. `object` returned the raw input — including the unknown keys it had just complained about — while `discriminatedUnion` returned `undefined`; the same call shape had two contracts. Validating an outbound DTO to keep internal fields out of a response, then reading `data` without branching on `isValid`, shipped every field the schema existed to exclude. `data` is now `undefined` whenever `isValid` is `false`
+- `v.number().toFixed(n)` could never produce a valid result — the mutator returned `Number(value).toFixed(n)`, a *string*, which the validator's own `number` type rule then rejected. It now yields a number (`3.14159` → `3.14`), so the method works where it lives. No working code can have depended on the old output, since every such validation failed; for a fixed-point *string*, format at the presentation edge rather than asking a number schema to emit one
+
 ## 4.2.11
 
 ### Changed

package/cjs/index.cjs

@@ -170,7 +170,12 @@ const validate = async (schema, data, { context: extendedContext, ...configurati
 		},
 		configurations
 	};
-	return await schema.validate(data, context);
+	const result = await schema.validate(data, context);
+	if (!result.isValid) return {
+		...result,
+		data: void 0
+	};
+	return result;
 };
 
 //#endregion
@@ -1267,10 +1272,18 @@ const roundMutator = async (value, context) => {
 	if (decimals === 0) return Math.round(Number(value));
 	return (0, _mongez_reinforcements.round)(Number(value), decimals);
 };
-/** To fixed mutator */
+/**
+* To fixed mutator — rounds to a fixed number of decimal places, as a number.
+*
+* `Number.prototype.toFixed` returns a *string*, which the number validator's
+* own type rule then rejected: `v.number().toFixed(2)` could never produce a
+* valid result. Coercing back to a number keeps the method usable where it
+* lives. For the fixed-point string form, format at the edge instead of asking
+* a number schema to output a string.
+*/
 const toFixedMutator = async (value, context) => {
 	const decimals = context?.options?.decimals ?? 2;
-	return Number(value).toFixed(decimals);
+	return Number(Number(value).toFixed(decimals));
 };
 
 //#endregion
@@ -4205,8 +4218,10 @@ const instanceofRule = {
 */
 const literalRule = {
 	name: "literal",
+	requiresValue: false,
 	defaultErrorMessage: "The :input must be one of the following values: :values",
 	async validate(value, context) {
+		if (value === void 0) return VALID_RULE;
 		if (this.context.options.values.includes(value)) return VALID_RULE;
 		this.context.translationParams.values = this.context.options.values.map((v) => resolveTranslation({
 			key: String(v),
@@ -6509,6 +6524,7 @@ var LiteralValidator = class extends BaseValidator {
 		super();
 		this.values = values;
 		this.addMutableRule(literalRule, errorMessage, { values });
+		if (values.some((value) => isEmptyValue(value))) this.requiredRule = this.createRule(presentRule);
 	}
 	/**
 	* Check if value is one of the configured literals
@@ -6901,7 +6917,14 @@ var NumberValidator = class extends PrimitiveValidator {
 		return this.addMutator(roundMutator, { decimals });
 	}
 	/**
-	* Format number using fixed-point notation
+	* Round to a fixed number of decimal places, keeping the value a **number**.
+	*
+	* `v.number().toFixed(2)` on `3.14159` yields `3.14`, not `"3.14"` — a number
+	* schema has to output a number, or its own type rule rejects the result.
+	* Format to a fixed-point *string* at the presentation edge instead.
+	*
+	* @example
+	* v.number().toFixed(2)   // 3.14159 → 3.14
 	*/
 	toFixed(decimals = 2) {
 		return this.addMutator(toFixedMutator, { decimals });