@zudojs/validation 0.1.0 → 1.0.1

package/dist/validationNormalizer/validationNormalizer.helpers.js

@@ -21,17 +21,52 @@ export function normalizeUppercase(value) {
 export function normalizeUnicode(value) {
     return value.normalize("NFC");
 }
-/** Normalizes an email address. */
+/**
+ * Normalizes Unicode text using NFKC, folding compatibility forms.
+ *
+ * Use this wherever the result identifies something. NFC is canonical only:
+ * it leaves ligatures and fullwidth forms distinct from their ASCII
+ * spellings, so two visually identical identifiers survive as two values.
+ */
+export function normalizeUnicodeCompatibility(value) {
+    return value.normalize("NFKC");
+}
+/**
+ * Case-folds a string for identifier comparison.
+ *
+ * `toLowerCase` is a locale-sensitive display transform. Folding through
+ * upper- then lower-case is the closest stable approximation available
+ * without ICU, and is what identifier comparison needs.
+ */
+export function foldCase(value) {
+    return value.toUpperCase().toLowerCase();
+}
+/**
+ * Normalizes an email address.
+ *
+ * Only the domain is lowercased. The local part is case-sensitive per RFC
+ * 5321, and folding it can merge two distinct mailboxes.
+ */
 export function normalizeEmail(value) {
-    return normalizeUnicode(normalizeWhitespace(value)).toLowerCase();
+    const trimmed = normalizeUnicodeCompatibility(normalizeWhitespace(value));
+    const at = trimmed.lastIndexOf("@");
+    if (at === -1)
+        return trimmed;
+    return `${trimmed.slice(0, at)}@${foldCase(trimmed.slice(at + 1))}`;
 }
 /** Normalizes a URL by removing surrounding whitespace. */
 export function normalizeUrl(value) {
     return normalizeWhitespace(normalizeUnicode(value));
 }
-/** Normalizes an identifier by trimming and lowercasing it. */
+/**
+ * Normalizes an identifier by trimming, compatibility-folding and case-folding.
+ *
+ * The output identifies an account or a resource, so it uses NFKC and a case
+ * fold rather than NFC and `toLowerCase`: otherwise two spellings that render
+ * identically normalize to two different identifiers.
+ */
 export function normalizeIdentifier(value) {
-    return normalizeLowercase(normalizeWhitespace(normalizeUnicode(value)));
+    return foldCase(normalizeWhitespace(normalizeUnicodeCompatibility(value)));
 }
 /** Removes surrounding quotes from a string. */
 export function normalizeQuotes(value) {
@@ -47,13 +82,19 @@ export function normalizeQuotes(value) {
 export function removeBom(value) {
     return value.replace(/^\uFEFF/u, "");
 }
-/** Normalizes an array by applying a normalizer to every item. */
+/**
+ * Normalizes an array by applying a normalizer to every item.
+ *
+ * The normalizer is invoked with the value only. Passing it straight to `map`
+ * would also hand it the index and the array, which silently overrides the
+ * optional second parameter of functions like `parseInt`.
+ */
 export function normalizeArray(values, normalizer) {
-    return values.map(normalizer);
+    return values.map((value) => normalizer(value));
 }
 /** Normalizes an array asynchronously. */
 export async function normalizeArrayAsync(values, normalizer) {
-    return Promise.all(values.map(normalizer));
+    return Promise.all(values.map((value) => normalizer(value)));
 }
 /** Composes multiple normalizers into one. */
 export function composeNormalizers(...normalizers) {

package/dist/validationParser/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * @zudojs/validation/validationParser
  *
- * Schema parsing and type inference.
+ * Reusable parsers built from validation schemas.
  */
 export * from "./validationParser.core.js";
+export * from "./validationParser.collection.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/validationParser/index.js

@@ -1,7 +1,8 @@
 /**
  * @zudojs/validation/validationParser
  *
- * Schema parsing and type inference.
+ * Reusable parsers built from validation schemas.
  */
 export * from "./validationParser.core.js";
+export * from "./validationParser.collection.js";
 //# sourceMappingURL=index.js.map

package/dist/validationParser/validationParser.collection.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @zudojs/validation — Parsing collections of values.
+ *
+ * @module validationParser/validationParser.collection
+ */
+import type { ParseOptions, ValidationSchema } from "../validationSchema/validationSchema.core.js";
+import type { ValidationResult } from "../validationResult/validationResult.type.js";
+/** Parses multiple values using the same schema. Succeeds only when every value is valid. */
+export declare function parseMany<T>(schema: ValidationSchema<T>, values: readonly unknown[]): ValidationResult<readonly T[]>;
+/** Parses multiple values asynchronously. */
+export declare function parseManyAsync<T>(schema: ValidationSchema<T>, values: readonly unknown[]): Promise<ValidationResult<readonly T[]>>;
+/**
+ * Parses a record of values using a schema.
+ *
+ * Results accumulate into a null-prototype object and are installed with
+ * `defineProperty`. A plain literal would route a `__proto__` key — which
+ * `JSON.parse` produces as a real own property — through the prototype setter,
+ * so the returned "validated" object would silently inherit attacker-supplied
+ * fields that `Object.keys` does not show.
+ */
+export declare function parseRecord<T>(schema: ValidationSchema<T>, values: Readonly<Record<string, unknown>>): ValidationResult<Readonly<Record<string, T>>>;
+/** Parses an optional value. Undefined is accepted and returned as undefined. */
+export declare function parseOptional<T>(schema: ValidationSchema<T>, value: unknown, options?: ParseOptions): ValidationResult<T | undefined>;
+/** Parses a nullable value. Null is accepted and returned as null. */
+export declare function parseNullable<T>(schema: ValidationSchema<T>, value: unknown, options?: ParseOptions): ValidationResult<T | null>;
+/** Parses an optional nullable value. */
+export declare function parseOptionalNullable<T>(schema: ValidationSchema<T>, value: unknown, options?: ParseOptions): ValidationResult<T | null | undefined>;
+//# sourceMappingURL=validationParser.collection.d.ts.map

package/dist/validationParser/validationParser.collection.js

@@ -0,0 +1,98 @@
+/**
+ * @zudojs/validation — Parsing collections of values.
+ *
+ * @module validationParser/validationParser.collection
+ */
+import { validate, validateAsync, } from "../validationSchema/validationSchema.core.js";
+import { failure, success } from "../validationResult/validationResult.type.js";
+/** Property names that would mutate a prototype instead of adding a key. */
+const FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+/** Parses multiple values using the same schema. Succeeds only when every value is valid. */
+export function parseMany(schema, values) {
+    const parsed = [];
+    const issues = [];
+    for (let index = 0; index < values.length; index++) {
+        const result = validate(schema, values[index], { pathPrefix: [index] });
+        if (result.success) {
+            parsed.push(result.data);
+        }
+        else {
+            issues.push(...result.issues);
+        }
+    }
+    return issues.length > 0 ? failure(issues) : success(parsed);
+}
+/** Parses multiple values asynchronously. */
+export async function parseManyAsync(schema, values) {
+    const parsed = [];
+    const issues = [];
+    for (let index = 0; index < values.length; index++) {
+        const result = await validateAsync(schema, values[index], {
+            pathPrefix: [index],
+        });
+        if (result.success) {
+            parsed.push(result.data);
+        }
+        else {
+            issues.push(...result.issues);
+        }
+    }
+    return issues.length > 0 ? failure(issues) : success(parsed);
+}
+/**
+ * Parses a record of values using a schema.
+ *
+ * Results accumulate into a null-prototype object and are installed with
+ * `defineProperty`. A plain literal would route a `__proto__` key — which
+ * `JSON.parse` produces as a real own property — through the prototype setter,
+ * so the returned "validated" object would silently inherit attacker-supplied
+ * fields that `Object.keys` does not show.
+ */
+export function parseRecord(schema, values) {
+    const parsed = Object.create(null);
+    const issues = [];
+    for (const [key, value] of Object.entries(values)) {
+        if (FORBIDDEN_KEYS.has(key)) {
+            issues.push({
+                path: [key],
+                code: "forbidden_key",
+                message: `Key "${key}" is not allowed.`,
+            });
+            continue;
+        }
+        const result = validate(schema, value, { pathPrefix: [key] });
+        if (result.success) {
+            Object.defineProperty(parsed, key, {
+                value: result.data,
+                enumerable: true,
+                writable: false,
+                configurable: false,
+            });
+        }
+        else {
+            issues.push(...result.issues);
+        }
+    }
+    return issues.length > 0
+        ? failure(issues)
+        : { success: true, data: Object.freeze(parsed), issues: [] };
+}
+/** Parses an optional value. Undefined is accepted and returned as undefined. */
+export function parseOptional(schema, value, options = {}) {
+    if (value === undefined)
+        return success(undefined);
+    return validate(schema, value, options);
+}
+/** Parses a nullable value. Null is accepted and returned as null. */
+export function parseNullable(schema, value, options = {}) {
+    if (value === null)
+        return success(null);
+    return validate(schema, value, options);
+}
+/** Parses an optional nullable value. */
+export function parseOptionalNullable(schema, value, options = {}) {
+    if (value === undefined || value === null)
+        return success(value);
+    return validate(schema, value, options);
+}
+//# sourceMappingURL=validationParser.collection.js.map

package/dist/validationParser/validationParser.core.d.ts

@@ -27,16 +27,4 @@ export declare function createAsyncValidationParser<T>(schema: ValidationSchema<
 export declare function parseOr<T>(schema: ValidationSchema<T>, value: unknown, fallback: T): T;
 /** Parses a value and returns a fallback produced by a function when validation fails. */
 export declare function parseOrElse<T>(schema: ValidationSchema<T>, value: unknown, fallback: (error: SchemaValidationError) => T): T;
-/** Parses multiple values using the same schema. Succeeds only when every value is valid. */
-export declare function parseMany<T>(schema: ValidationSchema<T>, values: readonly unknown[]): ValidationResult<readonly T[]>;
-/** Parses multiple values asynchronously. */
-export declare function parseManyAsync<T>(schema: ValidationSchema<T>, values: readonly unknown[]): Promise<ValidationResult<readonly T[]>>;
-/** Parses a record of values using a schema. */
-export declare function parseRecord<T>(schema: ValidationSchema<T>, values: Readonly<Record<string, unknown>>): ValidationResult<Readonly<Record<string, T>>>;
-/** Parses an optional value. Undefined is accepted and returned as undefined. */
-export declare function parseOptional<T>(schema: ValidationSchema<T>, value: unknown): ValidationResult<T | undefined>;
-/** Parses a nullable value. Null is accepted and returned as null. */
-export declare function parseNullable<T>(schema: ValidationSchema<T>, value: unknown): ValidationResult<T | null>;
-/** Parses an optional nullable value. */
-export declare function parseOptionalNullable<T>(schema: ValidationSchema<T>, value: unknown): ValidationResult<T | null | undefined>;
 //# sourceMappingURL=validationParser.core.d.ts.map

package/dist/validationParser/validationParser.core.js

@@ -44,75 +44,4 @@ export function parseOrElse(schema, value, fallback) {
         return result.data;
     return fallback(new SchemaValidationError("Schema validation failed.", result.issues));
 }
-/** Parses multiple values using the same schema. Succeeds only when every value is valid. */
-export function parseMany(schema, values) {
-    const parsed = [];
-    const issues = [];
-    for (let index = 0; index < values.length; index++) {
-        const result = validate(schema, values[index], { pathPrefix: [index] });
-        if (result.success) {
-            parsed.push(result.data);
-        }
-        else {
-            issues.push(...result.issues);
-        }
-    }
-    return issues.length > 0
-        ? { success: false, data: undefined, issues }
-        : { success: true, data: parsed, issues: [] };
-}
-/** Parses multiple values asynchronously. */
-export async function parseManyAsync(schema, values) {
-    const parsed = [];
-    const issues = [];
-    for (let index = 0; index < values.length; index++) {
-        const result = await validateAsync(schema, values[index], {
-            pathPrefix: [index],
-        });
-        if (result.success) {
-            parsed.push(result.data);
-        }
-        else {
-            issues.push(...result.issues);
-        }
-    }
-    return issues.length > 0
-        ? { success: false, data: undefined, issues }
-        : { success: true, data: parsed, issues: [] };
-}
-/** Parses a record of values using a schema. */
-export function parseRecord(schema, values) {
-    const parsed = {};
-    const issues = [];
-    for (const [key, value] of Object.entries(values)) {
-        const result = validate(schema, value, { pathPrefix: [key] });
-        if (result.success) {
-            parsed[key] = result.data;
-        }
-        else {
-            issues.push(...result.issues);
-        }
-    }
-    return issues.length > 0
-        ? { success: false, data: undefined, issues }
-        : { success: true, data: Object.freeze(parsed), issues: [] };
-}
-/** Parses an optional value. Undefined is accepted and returned as undefined. */
-export function parseOptional(schema, value) {
-    if (value === undefined)
-        return { success: true, data: undefined, issues: [] };
-    return validate(schema, value);
-}
-/** Parses a nullable value. Null is accepted and returned as null. */
-export function parseNullable(schema, value) {
-    if (value === null)
-        return { success: true, data: null, issues: [] };
-    return validate(schema, value);
-}
-/** Parses an optional nullable value. */
-export function parseOptionalNullable(schema, value) {
-    if (value === undefined || value === null)
-        return { success: true, data: value, issues: [] };
-    return validate(schema, value);
-}
 //# sourceMappingURL=validationParser.core.js.map

package/dist/validationRegistry/validationRegistry.core.d.ts

@@ -33,6 +33,14 @@ export declare class ValidationRegistry {
     entries(): readonly ValidationRule[];
     get size(): number;
     clear(): void;
+    /**
+     * Validate a value against a registered rule.
+     *
+     * Constraints receive whatever the caller passed, which at a trust boundary
+     * is arbitrary JSON. `checkConstraints` guards and catches internally, so a
+     * wrong-typed value reports as a validation failure rather than escaping as
+     * a `TypeError` and turning a 400 into a 500.
+     */
     validate<T>(name: string, value: unknown): ValidationResult<T>;
     clone(): ValidationRegistry;
     extend(source: ValidationRegistry, options?: ValidationRuleOptions): this;

package/dist/validationRegistry/validationRegistry.core.js

@@ -18,7 +18,13 @@ export class ValidationRegistry {
         if (!rule.schema && (!rule.constraints || rule.constraints.length === 0)) {
             throw new TypeError(`Validation rule "${name}" must define a schema or at least one constraint.`);
         }
-        this.rules.set(name, Object.freeze({ ...rule, name }));
+        this.rules.set(name, Object.freeze({
+            ...rule,
+            name,
+            ...(rule.constraints
+                ? { constraints: Object.freeze([...rule.constraints]) }
+                : {}),
+        }));
         return this;
     }
     registerSchema(name, schema, options = {}) {
@@ -54,6 +60,14 @@ export class ValidationRegistry {
     clear() {
         this.rules.clear();
     }
+    /**
+     * Validate a value against a registered rule.
+     *
+     * Constraints receive whatever the caller passed, which at a trust boundary
+     * is arbitrary JSON. `checkConstraints` guards and catches internally, so a
+     * wrong-typed value reports as a validation failure rather than escaping as
+     * a `TypeError` and turning a 400 into a 500.
+     */
     validate(name, value) {
         const rule = this.require(name);
         if (rule.schema)

package/dist/validationResult/validationResult.type.d.ts

@@ -12,7 +12,14 @@ export interface ValidationIssue {
 }
 /** Formats validation issues into a human-readable string. */
 export declare function formatIssues(issues: readonly ValidationIssue[]): string;
-/** Groups validation issues by their first path segment. */
+/**
+ * Groups validation issues by their first path segment.
+ *
+ * Built on a null-prototype object and probed with `Object.hasOwn`. Using `in`
+ * against a plain literal reported `constructor`, `toString` and `valueOf` as
+ * already present, so a field with one of those names produced no entry and
+ * the user saw a rejected form with nothing marked.
+ */
 export declare function toFieldErrors(issues: readonly ValidationIssue[]): Readonly<Record<string, string>>;
 /** A successful validation result. */
 export interface ValidationSuccess<T> {

package/dist/validationResult/validationResult.type.js

@@ -8,15 +8,30 @@ export function formatIssues(issues) {
         return "";
     return issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
 }
-/** Groups validation issues by their first path segment. */
+/**
+ * Groups validation issues by their first path segment.
+ *
+ * Built on a null-prototype object and probed with `Object.hasOwn`. Using `in`
+ * against a plain literal reported `constructor`, `toString` and `valueOf` as
+ * already present, so a field with one of those names produced no entry and
+ * the user saw a rejected form with nothing marked.
+ */
 export function toFieldErrors(issues) {
-    const result = {};
+    const result = Object.create(null);
     for (const issue of issues) {
         const field = issue.path[0];
-        if (typeof field === "string" && !(field in result))
-            result[field] = issue.message;
+        if (typeof field !== "string")
+            continue;
+        if (Object.hasOwn(result, field))
+            continue;
+        Object.defineProperty(result, field, {
+            value: issue.message,
+            enumerable: true,
+            writable: false,
+            configurable: false,
+        });
     }
-    return result;
+    return Object.freeze(result);
 }
 /** Creates a successful validation result. */
 export function success(data) {

package/dist/validationTransformer/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * @zudojs/validation/validationTransformer
  *
- * Data transformation after validation.
+ * Transformation of validated values.
  */
 export * from "./validationTransformer.core.js";
+export * from "./validationTransformer.helpers.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/validationTransformer/index.js

@@ -1,7 +1,8 @@
 /**
  * @zudojs/validation/validationTransformer
  *
- * Data transformation after validation.
+ * Transformation of validated values.
  */
 export * from "./validationTransformer.core.js";
+export * from "./validationTransformer.helpers.js";
 //# sourceMappingURL=index.js.map

package/dist/validationTransformer/validationTransformer.core.d.ts

@@ -1,4 +1,3 @@
-import type { ValidationSchema } from "../validationSchema/validationSchema.core.js";
 import type { ValidationResult } from "../validationResult/validationResult.type.js";
 /** A synchronous transformation function. */
 export type ValidationTransform<T, U> = (value: T) => U;
@@ -27,18 +26,4 @@ export interface AsyncValidationTransformer<T, U> {
 export declare function createValidationTransformer<T, U>(transform: ValidationTransform<T, U>, options?: TransformerOptions): ValidationTransformer<T, U>;
 /** Creates an asynchronous transformer. */
 export declare function createAsyncValidationTransformer<T, U>(transform: AsyncValidationTransform<T, U>, options?: TransformerOptions): AsyncValidationTransformer<T, U>;
-/** Validates input and then transforms it. */
-export declare function validateAndTransform<T, U>(schema: ValidationSchema<T>, value: unknown, transform: ValidationTransform<T, U>, options?: TransformerOptions): ValidationResult<U>;
-/** Validates input and then transforms it asynchronously. */
-export declare function validateAndTransformAsync<T, U>(schema: ValidationSchema<T>, value: unknown, transform: AsyncValidationTransform<T, U>, options?: TransformerOptions): Promise<ValidationResult<U>>;
-/** Creates a transformation pipeline. */
-export declare function composeTransforms<T, U, V>(first: ValidationTransform<T, U>, second: ValidationTransform<U, V>): ValidationTransform<T, V>;
-/** Creates a transformation pipeline from multiple functions. */
-export declare function composeManyTransforms<T>(...transforms: readonly ValidationTransform<T, T>[]): ValidationTransform<T, T>;
-/** Applies a transformation to every item in an array. */
-export declare function transformArray<T, U>(values: readonly T[], transform: ValidationTransform<T, U>): U[];
-/** Applies an asynchronous transformation to every item in an array. */
-export declare function transformArrayAsync<T, U>(values: readonly T[], transform: AsyncValidationTransform<T, U>): Promise<U[]>;
-/** Creates a schema that transforms the validated value. */
-export declare function withTransformer<T, U>(schema: ValidationSchema<T>, transform: ValidationTransform<T, U>): ValidationSchema<U>;
 //# sourceMappingURL=validationTransformer.core.d.ts.map

package/dist/validationTransformer/validationTransformer.core.js

@@ -1,13 +1,11 @@
-import { validate, validateAsync, } from "../validationSchema/validationSchema.core.js";
 import { failure, success } from "../validationResult/validationResult.type.js";
 import { ConstraintValidationError } from "../validationErrors/validationError.types.js";
-function transformFailure(options, error) {
+function transformFailure(options) {
     return failure([
         {
             path: [],
             code: "transform_failed",
             message: options.transformErrorMessage ?? "Validation transformation failed.",
-            received: error instanceof Error ? error.message : error,
         },
     ]);
 }
@@ -28,8 +26,8 @@ export function createValidationTransformer(transform, options = {}) {
             try {
                 return success(transform(value));
             }
-            catch (error) {
-                return transformFailure(options, error);
+            catch {
+                return transformFailure(options);
             }
         },
         validateAndTransform(value) {
@@ -54,8 +52,8 @@ export function createAsyncValidationTransformer(transform, options = {}) {
             try {
                 return success(await transform(value));
             }
-            catch (error) {
-                return transformFailure(options, error);
+            catch {
+                return transformFailure(options);
             }
         },
         async validateAndTransform(value) {
@@ -63,53 +61,4 @@ export function createAsyncValidationTransformer(transform, options = {}) {
         },
     });
 }
-/** Validates input and then transforms it. */
-export function validateAndTransform(schema, value, transform, options = {}) {
-    const validation = validate(schema, value);
-    if (!validation.success)
-        return validation;
-    try {
-        return success(transform(validation.data));
-    }
-    catch (error) {
-        return transformFailure(options, error);
-    }
-}
-/** Validates input and then transforms it asynchronously. */
-export async function validateAndTransformAsync(schema, value, transform, options = {}) {
-    const validation = await validateAsync(schema, value);
-    if (!validation.success)
-        return validation;
-    try {
-        return success(await transform(validation.data));
-    }
-    catch (error) {
-        return transformFailure(options, error);
-    }
-}
-/** Creates a transformation pipeline. */
-export function composeTransforms(first, second) {
-    return (value) => second(first(value));
-}
-/** Creates a transformation pipeline from multiple functions. */
-export function composeManyTransforms(...transforms) {
-    return (value) => {
-        let current = value;
-        for (const transform of transforms)
-            current = transform(current);
-        return current;
-    };
-}
-/** Applies a transformation to every item in an array. */
-export function transformArray(values, transform) {
-    return values.map(transform);
-}
-/** Applies an asynchronous transformation to every item in an array. */
-export async function transformArrayAsync(values, transform) {
-    return Promise.all(values.map(transform));
-}
-/** Creates a schema that transforms the validated value. */
-export function withTransformer(schema, transform) {
-    return schema.transform(transform);
-}
 //# sourceMappingURL=validationTransformer.core.js.map

package/dist/validationTransformer/validationTransformer.helpers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @zudojs/validation — Transformation helpers and pipelines.
+ *
+ * @module validationTransformer/validationTransformer.helpers
+ */
+import type { ValidationSchema } from "../validationSchema/validationSchema.core.js";
+import type { ValidationResult } from "../validationResult/validationResult.type.js";
+import type { AsyncValidationTransform, TransformerOptions, ValidationTransform } from "./validationTransformer.core.js";
+/** Validates input and then transforms it. */
+export declare function validateAndTransform<T, U>(schema: ValidationSchema<T>, value: unknown, transform: ValidationTransform<T, U>, options?: TransformerOptions): ValidationResult<U>;
+/** Validates input and then transforms it asynchronously. */
+export declare function validateAndTransformAsync<T, U>(schema: ValidationSchema<T>, value: unknown, transform: AsyncValidationTransform<T, U>, options?: TransformerOptions): Promise<ValidationResult<U>>;
+/** Creates a transformation pipeline. */
+export declare function composeTransforms<T, U, V>(first: ValidationTransform<T, U>, second: ValidationTransform<U, V>): ValidationTransform<T, V>;
+/** Creates a transformation pipeline from multiple functions. */
+export declare function composeManyTransforms<T>(...transforms: readonly ValidationTransform<T, T>[]): ValidationTransform<T, T>;
+/** Applies a transformation to every item in an array. */
+export declare function transformArray<T, U>(values: readonly T[], transform: ValidationTransform<T, U>): U[];
+/** Applies an asynchronous transformation to every item in an array. */
+export declare function transformArrayAsync<T, U>(values: readonly T[], transform: AsyncValidationTransform<T, U>): Promise<U[]>;
+/** Creates a schema that transforms the validated value. */
+export declare function withTransformer<T, U>(schema: ValidationSchema<T>, transform: ValidationTransform<T, U>): ValidationSchema<U>;
+//# sourceMappingURL=validationTransformer.helpers.d.ts.map

package/dist/validationTransformer/validationTransformer.helpers.js

@@ -0,0 +1,67 @@
+/**
+ * @zudojs/validation — Transformation helpers and pipelines.
+ *
+ * @module validationTransformer/validationTransformer.helpers
+ */
+import { validate, validateAsync, } from "../validationSchema/validationSchema.core.js";
+import { failure, success } from "../validationResult/validationResult.type.js";
+/** Builds the failure reported when a transformation throws. */
+function transformFailure(options) {
+    return failure([
+        {
+            path: [],
+            code: "transform_failed",
+            message: options.transformErrorMessage ?? "Validation transformation failed.",
+        },
+    ]);
+}
+/** Validates input and then transforms it. */
+export function validateAndTransform(schema, value, transform, options = {}) {
+    const validation = validate(schema, value);
+    if (!validation.success)
+        return validation;
+    try {
+        return success(transform(validation.data));
+    }
+    catch (error) {
+        return transformFailure(options);
+    }
+}
+/** Validates input and then transforms it asynchronously. */
+export async function validateAndTransformAsync(schema, value, transform, options = {}) {
+    const validation = await validateAsync(schema, value);
+    if (!validation.success)
+        return validation;
+    try {
+        return success(await transform(validation.data));
+    }
+    catch (error) {
+        return transformFailure(options);
+    }
+}
+/** Creates a transformation pipeline. */
+export function composeTransforms(first, second) {
+    return (value) => second(first(value));
+}
+/** Creates a transformation pipeline from multiple functions. */
+export function composeManyTransforms(...transforms) {
+    return (value) => {
+        let current = value;
+        for (const transform of transforms)
+            current = transform(current);
+        return current;
+    };
+}
+/** Applies a transformation to every item in an array. */
+export function transformArray(values, transform) {
+    return values.map((value) => transform(value));
+}
+/** Applies an asynchronous transformation to every item in an array. */
+export async function transformArrayAsync(values, transform) {
+    return Promise.all(values.map((value) => transform(value)));
+}
+/** Creates a schema that transforms the validated value. */
+export function withTransformer(schema, transform) {
+    return schema.transform(transform);
+}
+//# sourceMappingURL=validationTransformer.helpers.js.map