@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/types/array-type-analysis.d.ts

@@ -1,115 +0,0 @@
-/**
- * Build-time TypeScript type analysis for multi-dimensional arrays
- * Enables Array<Array<Array>> pattern optimization through compile-time type inspection
- */
-/**
- * Extract array depth from a type at compile time
- * Array<string> → 1
- * Array<Array<string>> → 2
- * Array<Array<Array<string>>> → 3
- *
- * Note: TypeScript's type system has limitations with recursive arithmetic,
- * so we use a more practical approach with explicit depth levels
- */
-export type ArrayDepth<T> = T extends readonly (infer U)[] ? U extends readonly (infer V)[] ? V extends readonly (infer W)[] ? W extends readonly (infer X)[] ? X extends readonly (infer Y)[] ? 5 : 4 : 3 : 2 : 1 : 0;
-/**
- * Extract the final element type from nested arrays
- * Array<Array<{name: string}>> → {name: string}
- */
-export type ArrayElementType<T> = T extends readonly (infer U)[] ? ArrayElementType<U> : T;
-/**
- * Generate path pattern for nested array access
- * Depth 1 → "[i]"
- * Depth 2 → "[i][j]"
- * Depth 3 → "[i][j][k]"
- */
-export type ArrayIndexPattern<Depth extends number> = Depth extends 1 ? "[i]" : Depth extends 2 ? "[i][j]" : Depth extends 3 ? "[i][j][k]" : Depth extends 4 ? "[i][j][k][l]" : Depth extends 5 ? "[i][j][k][l][m]" : string;
-/**
- * Array structure information resolved at build time
- */
-export interface ArrayStructureInfo<T = any> {
-    readonly depth: number;
-    readonly elementType: T;
-    readonly indexPattern: string;
-    readonly loopVariables: readonly string[];
-}
-/**
- * Resolve array structure at compile time
- */
-export type ResolveArrayStructure<T> = {
-    readonly depth: ArrayDepth<T>;
-    readonly elementType: ArrayElementType<T>;
-    readonly indexPattern: ArrayIndexPattern<ArrayDepth<T>>;
-    readonly loopVariables: ArrayDepth<T> extends 1 ? readonly ["i"] : ArrayDepth<T> extends 2 ? readonly ["i", "j"] : ArrayDepth<T> extends 3 ? readonly ["i", "j", "k"] : ArrayDepth<T> extends 4 ? readonly ["i", "j", "k", "l"] : ArrayDepth<T> extends 5 ? readonly ["i", "j", "k", "l", "m"] : readonly string[];
-};
-/**
- * Build-time array structure analyzer
- * Creates optimized validation functions based on TypeScript type information
- */
-export declare class BuildTimeArrayAnalyzer {
-    /**
-     * Analyze array structure from TypeScript type at build time
-     * This is called during field builder analysis phase
-     */
-    static analyzeArrayStructure<T>(fieldPath: string, sampleValue?: T): ArrayStructureInfo<ArrayElementType<T>>;
-    /**
-     * Calculate array depth at runtime (fallback for type analysis)
-     */
-    private static calculateArrayDepth;
-    /**
-     * Extract element type (for validation purposes)
-     */
-    private static extractElementType;
-    /**
-     * Generate optimized validation function for multi-dimensional arrays
-     */
-    static generateOptimizedValidator<T>(structure: ArrayStructureInfo<T>, fieldPath: string, elementValidator: (element: T, path: string) => ValidationResult): (array: any) => ValidationResult;
-    /**
-     * Create nested loop validator with arbitrary depth
-     */
-    private static createNestedLoopValidator;
-    /**
-     * Generate nested loop code string
-     */
-    private static generateNestedLoopCode;
-}
-/**
- * Validation result interface
- */
-interface ValidationResult {
-    valid: boolean;
-    errors: Array<{
-        path: string;
-        code: string;
-        message: string;
-    }>;
-}
-/**
- * Type-safe array field validator generator
- * Uses TypeScript type information to create optimized validators
- */
-export declare function createTypedArrayValidator<T>(fieldPath: string, elementValidator: (element: ArrayElementType<T>, path: string) => ValidationResult): (value: T) => ValidationResult;
-/**
- * Compile-time type testing
- */
-export type Test_ArrayDepth = {
-    Simple: ArrayDepth<string[]>;
-    Double: ArrayDepth<string[][]>;
-    Triple: ArrayDepth<string[][][]>;
-    Complex: ArrayDepth<Array<Array<{
-        id: number;
-        name: string;
-    }[]>>>;
-};
-export type Test_ElementType = {
-    Simple: ArrayElementType<{
-        name: string;
-    }[]>;
-    Double: ArrayElementType<{
-        name: string;
-    }[][]>;
-    Triple: ArrayElementType<{
-        name: string;
-    }[][][]>;
-};
-export {};

package/dist/types/indexed-result.d.ts

@@ -1,44 +0,0 @@
-/**
- * True index-based Result implementation
- * Stores only error index and generates error objects on demand
- */
-import { ValidationError } from "./index";
-import { Result } from "./result";
-/**
- * Error context for deferred error generation
- */
-export interface ErrorContext {
-    path: string;
-    value: any;
-    validators?: any[];
-    errorGenerator?: (index: number, context: ErrorContext) => ValidationError;
-}
-/**
- * Index-based validation state
- */
-export interface IndexedValidState<T> {
-    readonly errorIndex: number;
-    readonly data?: T;
-    readonly errorContext?: ErrorContext;
-}
-/**
- * Create index-based Result implementation
- */
-export declare function createIndexedResult<T>(state: IndexedValidState<T>): Result<T>;
-/**
- * Index-based Result factory
- */
-export declare const IndexedResult: {
-    /**
-     * Create a successful result
-     */
-    ok<T>(data: T): Result<T>;
-    /**
-     * Create a failed result with error index
-     */
-    errorIndex<T>(errorIndex: number, errorContext: ErrorContext): Result<T>;
-    /**
-     * Create a failed result with pre-generated errors (for compatibility)
-     */
-    error<T>(errors: ValidationError[]): Result<T>;
-};

package/dist/types/result.d.ts

@@ -1,159 +0,0 @@
-/**
- * Result pattern implementation for Luq validation
- * Provides a type-safe, functional approach to handling validation results
- */
-import { ValidationError } from "./index";
-/**
- * Lightweight validation exception interface
- */
-export interface LuqValidationException {
-    readonly name: string;
-    readonly message: string;
-    readonly errors: ValidationError[];
-    toString(): string;
-}
-/**
- * Create a validation exception (does not extend Error for performance)
- */
-export declare function createLuqValidationException(message: string, errors: ValidationError[]): LuqValidationException;
-export declare const LuqValidationException: {
-    new (message: string, errors: ValidationError[]): LuqValidationException;
-};
-/**
- * Represents a successful validation result
- */
-export interface ValidResult<T> {
-    readonly isValid: true;
-    readonly data: T;
-    readonly errors: never;
-}
-/**
- * Represents a failed validation result
- */
-export interface InvalidResult {
-    readonly isValid: false;
-    readonly data: never;
-    readonly errors: ValidationError[];
-}
-/**
- * Union type for validation results
- */
-export type ValidationState<T> = ValidResult<T> | InvalidResult;
-/**
- * Result interface providing functional validation result handling
- * Pattern 3: Function-based interface approach
- *
- * @example
- * ```typescript
- * const result = validator.validate(data);
- *
- * // Check if valid
- * if (result.isValid()) {
- *   // unwrap data safely
- *   const data = result.unwrap();
- * }
- *
- * // Functional approach
- * const processed = result
- *   .map(data => ({ ...data, processed: true }))
- *   .unwrapOr(defaultValue);
- *
- * // Exception approach
- * const data = result.unwrap(); // throws if invalid
- * ```
- */
-export interface Result<T> {
-    /**
-     * Check if result is valid
-     */
-    isValid(): boolean;
-    /**
-     * Backward compatibility: Check if result is valid (property access)
-     */
-    readonly valid: boolean;
-    /**
-     * Check if result is invalid
-     */
-    isError(): boolean;
-    /**
-     * Get the data if valid, otherwise throw ValidationException
-     *
-     * @throws {LuqValidationException} If the result is invalid
-     */
-    unwrap(): T;
-    /**
-     * Get the data if valid, otherwise return the default value
-     */
-    unwrapOr(defaultValue: T): T;
-    /**
-     * Get the data if valid, otherwise compute default using lazy function
-     */
-    unwrapOrElse(fn: (errors: ValidationError[]) => T): T;
-    /**
-     * Transform the data if valid, leave errors unchanged
-     */
-    map<U>(fn: (data: T) => U): Result<U>;
-    /**
-     * Transform the data if valid, allowing for fallible transformation
-     */
-    flatMap<U>(fn: (data: T) => Result<U>): Result<U>;
-    /**
-     * Execute a side effect if the result is valid
-     */
-    tap(fn: (data: T) => void): Result<T>;
-    /**
-     * Execute a side effect if the result is invalid
-     */
-    tapError(fn: (errors: ValidationError[]) => void): Result<T>;
-    /**
-     * Get the data if valid, undefined otherwise
-     * Use with caution - prefer unwrapOr() or check isValid() first
-     */
-    data(): T | undefined;
-    /**
-     * Get the errors if invalid, empty array otherwise
-     */
-    readonly errors: ValidationError[];
-    /**
-     * Convert to plain object (for serialization/compatibility)
-     */
-    toPlainObject(): {
-        valid: boolean;
-        data?: T;
-        errors: ValidationError[];
-    };
-}
-/**
- * Result implementation factory
- */
-export declare const Result: {
-    /**
-     * Create a successful result - optimized for performance
-     */
-    ok<T>(data: T): Result<T>;
-    /**
-     * Create a failed result
-     */
-    error<T>(errors: ValidationError[]): Result<T>;
-};
-/**
- * Utility functions for working with Results
- */
-export declare namespace ResultUtils {
-    /**
-     * Combine multiple results into a single result containing an array
-     * If any result is invalid, returns the first error
-     */
-    function all<T>(results: Result<T>[]): Result<T[]>;
-    /**
-     * Return the first valid result, or all errors if none are valid
-     */
-    function any<T>(results: Result<T>[]): Result<T>;
-    /**
-     * Partition results into valid and invalid arrays
-     */
-    function partition<T>(results: Result<T>[]): {
-        valid: T[];
-        invalid: ValidationError[][];
-    };
-}

package/dist/types/stitch-types.d.ts

@@ -1,118 +0,0 @@
-/**
- * Advanced type utilities for Stitch plugin - Multi-field reference type safety
- */
-import { NestedKeyOf, TypeOfPath } from "./util";
-/**
- * Extract field types from an array of field paths into a typed object
- *
- * @example
- * ```typescript
- * type UserForm = { name: string; age: number; email: string; }
- * type Fields = ["name", "age"]
- * type Result = FieldsToObject<UserForm, Fields>
- * // Result: { name: string; age: number; }
- * ```
- */
-export type FieldsToObject<T, K extends readonly (NestedKeyOf<T> & string)[]> = {
-    [P in K[number]]: TypeOfPath<T, P>;
-};
-/**
- * More precise tuple-based field extraction for better type inference
- * Preserves the exact relationship between field positions and types
- */
-export type TupleFieldsToObject<T, K extends readonly [...(NestedKeyOf<T> & string)[]]> = {
-    [Index in keyof K as K[Index] extends string ? K[Index] : never]: K[Index] extends NestedKeyOf<T> & string ? TypeOfPath<T, K[Index]> : never;
-};
-/**
- * Type-safe Stitch validation function
- * - First argument: Object containing only the specified field values with correct types
- * - Second argument: Current field value with its inferred type
- * - Third argument: Complete form object with full type safety
- */
-export type StitchValidationFn<TObject, TCurrentField, TFields extends readonly (NestedKeyOf<TObject> & string)[]> = (fieldValues: FieldsToObject<TObject, TFields>, currentValue: TCurrentField, allValues: TObject) => {
-    valid: boolean;
-    message?: string;
-};
-/**
- * Type-safe Stitch plugin options with complete type inference
- */
-export type TypeSafeStitchOptions<TObject, TCurrentField, TFields extends readonly (NestedKeyOf<TObject> & string)[]> = {
-    /**
-     * Array of field paths - constrained to valid nested keys of TObject
-     * Must be readonly tuple for precise type inference
-     */
-    fields: TFields;
-    /**
-     * Validation function with full type safety:
-     * - fieldValues: Extracted field types as typed object
-     * - currentValue: Current field's value with correct type
-     * - allValues: Complete form object
-     */
-    validate: StitchValidationFn<TObject, TCurrentField, TFields>;
-    /** Optional custom error code */
-    code?: string;
-    /**
-     * Optional custom error message factory with field context
-     */
-    messageFactory?: (context: {
-        path: string;
-        value: TCurrentField;
-        code: string;
-        fields: TFields;
-        fieldValues: FieldsToObject<TObject, TFields>;
-        allValues: TObject;
-    }) => string;
-};
-/**
- * Helper type to validate that all fields exist in the object type
- * Provides compile-time validation of field paths
- */
-export type ValidateFieldPaths<T, K extends readonly string[]> = K extends readonly [...infer Fields] ? Fields extends readonly (NestedKeyOf<T> & string)[] ? K : never : never;
-/**
- * Utility type for creating strongly typed field references
- * Ensures all field paths are valid at compile time
- */
-export type CreateStitchOptions<T, TCurrentField> = <const TFields extends readonly (NestedKeyOf<T> & string)[]>(options: TypeSafeStitchOptions<T, TCurrentField, TFields>) => TypeSafeStitchOptions<T, TCurrentField, TFields>;
-export declare const createStitchOptions: <T, TCurrentField>() => CreateStitchOptions<T, TCurrentField>;
-/**
- * Example usage and type validation:
- *
- * ```typescript
- * type EventForm = {
- *   startDate: string;
- *   endDate: string;
- *   eventDate: string;
- *   price: number;
- *   quantity: number;
- *   taxRate?: number;
- * }
- *
- * // Type-safe usage
- * const eventDateValidator = Builder()
- *   .use(stitchPlugin)
- *   .for<EventForm>()
- *   .v("eventDate", (b) => b.string.required().stitch({
- *     fields: ["startDate", "endDate"] as const, // ← readonly tuple for exact inference
- *     validate: (fieldValues, eventDate, allValues) => {
- *       // fieldValues: { startDate: string; endDate: string; }
- *       // eventDate: string
- *       // allValues: EventForm
- *
- *       const event = new Date(eventDate);
- *       const start = new Date(fieldValues.startDate); // ← Type-safe access
- *       const end = new Date(fieldValues.endDate);     // ← Type-safe access
- *
- *       // Can access any field from allValues with full type safety
- *       const taxRate = allValues.taxRate ?? 0; // ← Optional field handling
- *
- *       return {
- *         valid: event >= start && event <= end,
- *         message: event < start
- *           ? "Event date cannot be before start date"
- *           : "Event date cannot be after end date"
- *       };
- *     }
- *   }))
- *   .build();
- * ```
- */ 

package/dist/types/util.d.ts

@@ -1,19 +0,0 @@
-import { Validator } from "./valitator";
-export type InferType<T extends Validator<any, any>> = T extends Validator<infer U, infer U> ? U : never;
-type IsPlainObject<T> = T extends object ? T extends Function ? false : T extends any[] ? false : T extends Date ? false : true : false;
-type ArrayMethodNames = keyof any[] | keyof ReadonlyArray<any>;
-type ExcludeArrayMethods<T> = T extends string ? T extends ArrayMethodNames ? never : T : T;
-type ArrayElementPaths<U, Prefix extends string, D extends number> = U extends object ? {
-    [P in Extract<keyof U, string>]: U[P] extends Array<any> ? `${Prefix}.${P}` : NonNullable<U[P]> extends Array<any> ? `${Prefix}.${P}` : never;
-}[Extract<keyof U, string>] : never;
-type NestedKeyOfWithDepth<T, D extends number = 5> = D extends 0 ? never : T extends object ? {
-    [K in Extract<keyof T, string>]: T[K] extends Array<infer U> ? U extends Array<infer V> ? // 2D array case
-    K | `${K}[*]` | `${K}[*][*]` | (V extends object ? `${K}[*][*].${ExcludeArrayMethods<NestedKeyOfWithDepth<V, [-1, 0, 1, 2, 3, 4, 5][D]>>}` : never) : // 1D array case
-    K | `${K}[*]` | (U extends object ? `${K}[*].${ExcludeArrayMethods<NestedKeyOfWithDepth<U, [-1, 0, 1, 2, 3, 4, 5][D]>>}` : never) | ArrayElementPaths<U, `${K}[*]`, D> : NonNullable<T[K]> extends Array<infer U> ? U extends Array<infer V> ? // Optional 2D array case
-    K | `${K}[*]` | `${K}[*][*]` | (V extends object ? `${K}[*][*].${ExcludeArrayMethods<NestedKeyOfWithDepth<V, [-1, 0, 1, 2, 3, 4, 5][D]>>}` : never) : // Optional 1D array case
-    K | `${K}[*]` | (U extends object ? `${K}[*].${ExcludeArrayMethods<NestedKeyOfWithDepth<U, [-1, 0, 1, 2, 3, 4, 5][D]>>}` : never) | ArrayElementPaths<U, `${K}[*]`, D> : NonNullable<T[K]> extends object ? IsPlainObject<NonNullable<T[K]>> extends true ? K | `${K}.${NestedKeyOfWithDepth<NonNullable<T[K]>, [-1, 0, 1, 2, 3, 4, 5][D]>}` : K : K;
-}[Extract<keyof T, string>] : never;
-export type NestedKeyOf<T> = NestedKeyOfWithDepth<T>;
-export type TypeOfPath<T, Path extends string> = Path extends `${infer K}[*][*][*]` ? K extends keyof T ? T[K] extends Array<Array<Array<infer U>>> ? U : never : never : Path extends `${infer K}[*][*]` ? K extends keyof T ? T[K] extends Array<Array<infer U>> ? U : never : never : Path extends `${infer K}[*]` ? K extends keyof T ? T[K] extends Array<infer U> ? U : never : never : Path extends `${infer K}.*` ? K extends keyof T ? T[K] extends Array<infer U> ? U : never : never : Path extends `${infer K}[*][*][*].${infer Rest}` ? K extends keyof T ? T[K] extends Array<Array<Array<infer U>>> ? TypeOfPath<U, Rest> : never : never : Path extends `${infer K}[*][*].${infer Rest}` ? K extends keyof T ? T[K] extends Array<Array<infer U>> ? TypeOfPath<U, Rest> : never : never : Path extends `${infer K}[*].${infer Rest}` ? K extends keyof T ? T[K] extends Array<infer U> ? TypeOfPath<U, Rest> : never : never : Path extends `${infer K}.*.${infer Rest}` ? K extends keyof T ? T[K] extends Array<infer U> ? TypeOfPath<U, Rest> : never : never : Path extends `${infer K}.${infer Rest}` ? K extends keyof T ? T[K] extends Array<infer U> ? TypeOfPath<U, Rest> : T[K] extends any ? TypeOfPath<T[K], Rest> : never : never : Path extends keyof T ? T[Path] : never;
-export type ElementType<T> = T extends Array<infer U> ? U : never;
-export {};

package/dist/types/valitator.d.ts

@@ -1,10 +0,0 @@
-import { ValidationOptions, ValidationResult } from ".";
-export interface Validator<TObject, TValue> {
-    validate(value: TValue, options?: ValidationOptions): ValidationResult<TValue>;
-}
-export interface FieldValidator<TObject, TValue, TRequiredKeys extends keyof TObject = never> {
-    validate(value: unknown, allValues: TRequiredKeys extends never ? TObject | undefined : TObject, options?: ValidationOptions): ValidationResult<TValue>;
-}
-export interface ValidatorStrategy<TObject, TValue> {
-    validate(value: unknown, options?: ValidationOptions): ValidationResult<TValue>;
-}