@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/core/builder/types/types.d.ts

@@ -1,319 +0,0 @@
-/**
- * Consolidated Type Definitions for Builder Module
- *
- * This file contains type definitions from:
- * - nested-type-utils.ts
- * - types/validation-types.ts
- * - path-to-nested.ts
- */
-/**
- * Split a path string into segments
- */
-type Split<S extends string> = S extends `${infer Head}.${infer Tail}` ? [Head, ...Split<Tail>] : [S];
-/**
- * Build nested object from path segments
- * This is used for simple paths without array consideration
- */
-type BuildNested<Path extends string[], Value> = Path extends [
-    infer Head,
-    ...infer Tail
-] ? Head extends string ? Tail extends string[] ? Tail extends [] ? {
-    [K in Head]: Value;
-} : {
-    [K in Head]: BuildNested<Tail, Value>;
-} : never : never : {};
-/**
- * Convert a dotted path and value into a nested object type
- *
- * Examples:
- * PathToNested<"a.b.c", number> => { a: { b: { c: number } } }
- * PathToNested<"user.name", string> => { user: { name: string } }
- */
-export type PathToNested<Path extends string, Value> = BuildNested<Split<Path>, Value>;
-/**
- * Deep merge two types
- * Arrays are replaced, not merged
- * Objects are recursively merged
- */
-export type DeepMerge<T, U> = T extends any[] ? U extends any[] ? U : T : T extends object ? U extends object ? {
-    [K in keyof T | keyof U]: K extends keyof U ? K extends keyof T ? T[K] extends any[] ? U[K] extends any[] ? U[K] : T[K] : T[K] extends object ? U[K] extends object ? DeepMerge<T[K], U[K]> : U[K] : U[K] : U[K] : K extends keyof T ? T[K] : never;
-} : T : U;
-type FirstKey<Path extends string> = Path extends `${infer Key}.${string}` ? Key : Path;
-type RestPath<Path extends string> = Path extends `${string}.${infer Rest}` ? Rest : never;
-type BuildArrayTransform<ArrayKey extends string, RestPath extends string, Value> = {
-    [K in ArrayKey]: Array<PathToNested<RestPath, Value>>;
-};
-/**
- * Build nested transformation for paths that include array access
- * Example: "users.0.name" -> { users: Array<{ name: Value }> }
- */
-type ArrayPathToNested<Path extends string, Value, OriginalType = any> = FirstKey<Path> extends keyof OriginalType ? OriginalType[FirstKey<Path>] extends Array<any> ? BuildArrayTransform<FirstKey<Path>, RestPath<Path>, Value> : PathToNested<Path, Value> : PathToNested<Path, Value>;
-/**
- * Check if a path references an array element
- */
-type IsArrayPath<Path extends string, T = any> = FirstKey<Path> extends keyof T ? T[FirstKey<Path>] extends Array<any> ? RestPath<Path> extends never ? false : true : RestPath<Path> extends never ? false : IsArrayPath<RestPath<Path>, T[FirstKey<Path>]> : false;
-type CreateNestedFromPath<Path extends string, Value, OriginalType> = IsArrayPath<Path, OriginalType> extends true ? ArrayPathToNested<Path, Value, OriginalType> : PathToNested<Path, Value>;
-/**
- * Convert a flat map of path-value pairs to a nested object type
- */
-export type FlatMapToNested<TMap, OriginalType = any> = TMap extends Record<string, any> ? UnionToIntersection<{
-    [K in keyof TMap & string]: CreateNestedFromPath<K, TMap[K], OriginalType>;
-}[keyof TMap & string]> : {};
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-/**
- * Apply multiple nested transformations
- */
-export type ApplyNestedTransforms<T, TMap> = TMap extends Record<string, any> ? DeepMerge<T, FlatMapToNested<TMap>> : T;
-export type { ValidationResult, FieldValidationResult, TransformParseResult, FieldValidator, TransformAwareValidator, } from "../plugins/plugin-types";
-export type { PluginValidationResult as BasicValidationResult } from "../plugins/plugin-interfaces";
-export interface ValidationOperation {
-    validate(value: any, context?: any): {
-        valid: boolean;
-    };
-}
-export interface RecursiveContext {
-    currentDepth: number;
-    rootObject: any;
-    parent: any;
-    current: any;
-}
-export interface ValidationError {
-    path: string;
-    message: string;
-    code: string;
-}
-export interface ValidationFunction<TObject = any, TTypes = any> {
-    (value: any, context: ValidationContext<any, any>): {
-        valid: boolean;
-    };
-}
-export interface ValidationContext<TObject = any, TValue = any> {
-    path: string;
-    allValues: TObject;
-}
-export type { TypeName, ValidationOptions } from "../plugins/plugin-types";
-import type { StandardPluginImplementation, ConditionalPluginImplementation, FieldReferencePluginImplementation, MultiFieldReferencePluginImplementation, TransformPluginImplementation, ArrayElementPluginImplementation, ContextPluginImplementation, PreprocessorPluginImplementation, StandardValidationMethod, ConditionalValidationMethod, FieldReferenceValidationMethod, TransformValidationMethod, ArrayElementValidationMethod, ContextValidationMethod } from "../plugins/plugin-interfaces";
-import type { PluginCategory, TransformAwareValidator } from "../plugins/plugin-types";
-import { Result } from "../../../types/result";
-/**
- * Plugin implementation type based on category with Args
- */
-export type PluginImplementation<TCategory extends PluginCategory, TTypes extends readonly TypeName[], TArgs extends any[] = any[], TInput = any, TOutput = any> = TCategory extends "standard" ? StandardPluginImplementation<TArgs, TTypes> : TCategory extends "conditional" ? ConditionalPluginImplementation<TTypes> : TCategory extends "fieldReference" ? FieldReferencePluginImplementation<TTypes> : TCategory extends "multiFieldReference" ? MultiFieldReferencePluginImplementation<TTypes> : TCategory extends "transform" ? TransformPluginImplementation<TInput, TOutput> : TCategory extends "arrayElement" ? ArrayElementPluginImplementation : TCategory extends "context" ? ContextPluginImplementation<TTypes> : TCategory extends "preprocessor" ? PreprocessorPluginImplementation<TTypes> : never;
-/**
- * Plugin definition result
- */
-export interface PluginDefinition<TName extends string, TTypes extends readonly TypeName[], TCategory extends PluginCategory> {
-    name: TName;
-    allowedTypes: TTypes;
-    category: TCategory;
-    methods: Record<string, PluginImplementation<TCategory, TTypes, any[]>>;
-    impl: () => Record<string, Function>;
-}
-/**
- * Method signatures based on category with type placeholders
- */
-export type CategoryMethodSignature<TCategory extends PluginCategory, TObjectPlaceholder = unknown, TInputPlaceholder = unknown> = TCategory extends "standard" ? StandardValidationMethod<any[], any> : TCategory extends "conditional" ? ConditionalValidationMethod<any, TObjectPlaceholder, TInputPlaceholder> : TCategory extends "fieldReference" ? FieldReferenceValidationMethod<any, TObjectPlaceholder, TInputPlaceholder> : TCategory extends "transform" ? TransformValidationMethod<any> : TCategory extends "arrayElement" ? ArrayElementValidationMethod : TCategory extends "context" ? ContextValidationMethod<any> : never;
-import type { FieldBuilderContext } from "../plugins/plugin-types";
-/**
- * Field definition for deferred building
- */
-export interface FieldBuilderDefinition<TObject extends object = any, TPlugins = any, TFieldType = any> {
-    path: string;
-    builderFunction: (context: FieldBuilderContext<TObject, TPlugins, TFieldType>) => any;
-    inferredType?: string;
-    fieldOptions?: import("../types/field-options").FieldOptions<TFieldType>;
-    fieldType?: TFieldType;
-}
-import type { FieldBuilder } from "../plugins/plugin-types";
-import type { ComposablePlugin } from "../plugins/composable-plugin";
-import type { ComposableConditionalPlugin } from "../plugins/composable-conditional-plugin";
-import type { ComposableDirectlyPlugin } from "../plugins/composable-directly-plugin";
-/**
- * Base ChainableBuilder interface
- */
-export interface ChainableBuilder<TPlugins = {}> {
-    for<TInputType extends object>(): FieldBuilder<TInputType, unknown, TPlugins, never>;
-}
-/**
- * Map plugin array to plugin map type
- */
-export type PluginMapFromArray<T extends TypedPlugin<string, any, any, any, any>[]> = {
-    [K in T[number] as K extends TypedPlugin<infer TName, any, any, any, any> ? TName : never]: K;
-};
-/**
- * Extract extensions from a plugin
- */
-type ExtractPluginExtensions<T> = T extends BuilderExtensionPlugin<any, infer TMethodName, infer TMethodSignature> ? {
-    [K in TMethodName]: TMethodSignature;
-} : {};
-/**
- * Helper type to determine builder extensions based on plugins
- * Dynamically extracts extension methods from all builder-extension plugins
- */
-export type BuilderExtensions<TPlugins> = TPlugins extends Record<string, any> ? UnionToIntersection<{
-    [K in keyof TPlugins]: ExtractPluginExtensions<TPlugins[K]>;
-}[keyof TPlugins]> : {};
-/**
- * Type for any plugin
- */
-export type AnyPlugin = TypedPlugin<any, any, any, any, any, any> | ComposablePlugin<any, any, any> | ComposableConditionalPlugin<any, any, any> | ComposableDirectlyPlugin<any, any, any> | BuilderExtensionPlugin<any, any>;
-/**
- * Extract plugin name from any plugin type
- */
-type ExtractPluginName<T> = T extends {
-    name: infer N;
-} ? N : never;
-/**
- * Map multiple plugins to plugin map
- */
-type PluginsToMap<T extends readonly AnyPlugin[]> = {
-    [K in T[number] as ExtractPluginName<K>]: K;
-};
-/**
- * Extract extensions from a single plugin
- */
-type ExtractSinglePluginExtension<T> = T extends BuilderExtensionPlugin<any, infer TMethodName, infer TMethodSignature> ? {
-    [K in TMethodName]: TMethodSignature;
-} : {};
-/**
- * Extract all extensions from multiple plugins
- */
-type ExtractAllExtensions<T extends readonly AnyPlugin[]> = UnionToIntersection<{
-    [K in keyof T]: ExtractSinglePluginExtension<T[K]>;
-}[number]>;
-/**
- * Extract parameters from BuilderExtensionMethod and create new signature
- * This properly types the method that gets added to the builder
- */
-type CreateMethodWithBuilder<TMethodSignature extends BuilderExtensionMethod, TBuilder> = TMethodSignature extends <T extends FieldBuilder<infer O, infer M, infer P, infer D>>(...args: infer Args) => T ? TBuilder extends IChainableBuilder<infer TInput, infer TPlugins, any> ? TInput extends object ? (...args: Args) => FieldBuilder<TInput, M, TPlugins, D> : (...args: Args) => FieldBuilder<any, M, TPlugins, D> : never : TMethodSignature extends <T>(...args: infer Args) => T ? (...args: Args) => TBuilder : never;
-/**
- * Type that combines builder interface with accumulated extensions
- */
-export type ChainableBuilderWithExtensions<TInput, TPlugins = {}, TAccumulatedExtensions extends object = {}> = IChainableBuilder<TInput, TPlugins, TAccumulatedExtensions> & TAccumulatedExtensions;
-/**
- * Builder interface with dynamic method addition
- * Now tracks accumulated extensions separately
- */
-export interface IChainableBuilder<TInput, TPlugins = {}, TAccumulatedExtensions extends object = {}> extends ChainableBuilder<TPlugins> {
-    use<TName extends string, TMethodName extends string, TMethod extends Function, TAllowedTypes extends readonly TypeName[] | undefined, TPluginType extends PluginType = PluginType, TCategory extends PluginCategory = PluginCategory>(plugin: TypedPlugin<TName, TMethodName, TMethod, TAllowedTypes, TPluginType, TCategory>): IChainableBuilder<TInput, TPlugins & {
-        [K in TName]: TypedPlugin<TName, TMethodName, TMethod, TAllowedTypes, TPluginType, TCategory>;
-    }, TAccumulatedExtensions> & TAccumulatedExtensions & TPlugins & {
-        [K in TMethodName]: TMethod;
-    };
-    use<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[]>(plugin: ComposablePlugin<TName, TMethodName, TAllowedTypes>): IChainableBuilder<TInput, TPlugins & {
-        [K in TName]: ComposablePlugin<TName, TMethodName, TAllowedTypes>;
-    }, TAccumulatedExtensions> & TAccumulatedExtensions & TPlugins & {
-        [K in TMethodName]: any;
-    };
-    use<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[]>(plugin: ComposableConditionalPlugin<TName, TMethodName, TAllowedTypes>): IChainableBuilder<TInput, TPlugins & {
-        [K in TName]: ComposableConditionalPlugin<TName, TMethodName, TAllowedTypes>;
-    }, TAccumulatedExtensions> & TAccumulatedExtensions & TPlugins & {
-        [K in TMethodName]: any;
-    };
-    use<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[]>(plugin: ComposableDirectlyPlugin<TName, TMethodName, TAllowedTypes>): IChainableBuilder<TInput, TPlugins & {
-        [K in TName]: ComposableDirectlyPlugin<TName, TMethodName, TAllowedTypes>;
-    }, TAccumulatedExtensions> & TAccumulatedExtensions & TPlugins & {
-        [K in TMethodName]: any;
-    };
-    use<TName extends string, TMethodName extends string, TMethodSignature extends BuilderExtensionMethod>(plugin: BuilderExtensionPlugin<TName, TMethodName, TMethodSignature>): IChainableBuilder<TInput, TPlugins & {
-        [K in TName]: BuilderExtensionPlugin<TName, TMethodName, TMethodSignature>;
-    }, TAccumulatedExtensions & {
-        [K in TMethodName]: CreateMethodWithBuilder<TMethodSignature, IChainableBuilder<TInput, TPlugins & {
-            [K in TName]: BuilderExtensionPlugin<TName, TMethodName, TMethodSignature>;
-        }, TAccumulatedExtensions & {
-            [K in TMethodName]: TMethodSignature;
-        }>>;
-    }> & {
-        [K in TMethodName]: CreateMethodWithBuilder<TMethodSignature, IChainableBuilder<TInput, TPlugins & {
-            [K in TName]: BuilderExtensionPlugin<TName, TMethodName, TMethodSignature>;
-        }, TAccumulatedExtensions & {
-            [K in TMethodName]: TMethodSignature;
-        }>>;
-    };
-    use<P1 extends AnyPlugin, P2 extends AnyPlugin>(plugin1: P1, plugin2: P2): IChainableBuilder<TInput, TPlugins & PluginsToMap<[P1, P2]>, TAccumulatedExtensions & ExtractAllExtensions<[P1, P2]>> & (TAccumulatedExtensions & ExtractAllExtensions<[P1, P2]>);
-    use<P1 extends AnyPlugin, P2 extends AnyPlugin, P3 extends AnyPlugin>(plugin1: P1, plugin2: P2, plugin3: P3): IChainableBuilder<TInput, TPlugins & PluginsToMap<[P1, P2, P3]>, TAccumulatedExtensions & ExtractAllExtensions<[P1, P2, P3]>> & (TAccumulatedExtensions & ExtractAllExtensions<[P1, P2, P3]>);
-    use<P1 extends AnyPlugin, P2 extends AnyPlugin, P3 extends AnyPlugin, P4 extends AnyPlugin>(plugin1: P1, plugin2: P2, plugin3: P3, plugin4: P4): IChainableBuilder<TInput, TPlugins & PluginsToMap<[P1, P2, P3, P4]>, TAccumulatedExtensions & ExtractAllExtensions<[P1, P2, P3, P4]>> & (TAccumulatedExtensions & ExtractAllExtensions<[P1, P2, P3, P4]>);
-    use<P1 extends AnyPlugin, P2 extends AnyPlugin, P3 extends AnyPlugin, P4 extends AnyPlugin, P5 extends AnyPlugin>(plugin1: P1, plugin2: P2, plugin3: P3, plugin4: P4, plugin5: P5): IChainableBuilder<TInput, TPlugins & PluginsToMap<[P1, P2, P3, P4, P5]>, TAccumulatedExtensions & ExtractAllExtensions<[P1, P2, P3, P4, P5]>> & (TAccumulatedExtensions & ExtractAllExtensions<[P1, P2, P3, P4, P5]>);
-    use<T extends readonly AnyPlugin[]>(...plugins: T): IChainableBuilder<TInput, TPlugins & PluginsToMap<T>, TAccumulatedExtensions & ExtractAllExtensions<T>> & (TAccumulatedExtensions & ExtractAllExtensions<T>);
-}
-import type { TypedPlugin, PluginType, BuilderExtensionPlugin, BuilderExtensionMethod, TypeName, ValidationOptions } from "../plugins/plugin-types";
-/**
- * Async context behavior options
- */
-export interface AsyncContextOptions {
-    /** Whether to continue processing even with async errors */
-    continueOnError?: boolean;
-    /** Timeout duration (milliseconds) */
-    timeout?: number;
-    /** Default values when individual async operations fail */
-    defaultValues?: Record<string, any>;
-}
-/**
- * Async context type definition (simplified)
- */
-export interface AsyncContext<T = Record<string, any>> {
-    readonly data: T;
-    readonly isReady: boolean;
-    readonly hasErrors: boolean;
-    readonly errors: Array<{
-        key: string;
-        error: any;
-    }>;
-}
-/**
- * Async-aware validator
- */
-export interface AsyncAwareValidator<TObject> {
-    validate(value: Partial<TObject> | unknown, options?: ValidationOptions): Result<TObject>;
-    /**
-     * Validation with async context (type-safe version)
-     * Resolve async context before executing sync validation
-     */
-    withAsyncContext<TContext extends Record<string, any>>(asyncContext: AsyncContext<TContext>): {
-        validate(value: Partial<TObject> | unknown, options?: ValidationOptions): Promise<Result<TObject>>;
-        getContextType(): TContext;
-    };
-}
-/**
- * Type definition for usage examples
- */
-export interface ExampleAsyncContext {
-    hasEmail: boolean;
-    userExists: boolean;
-    domainValidation: {
-        valid: boolean;
-        message?: string;
-    };
-}
-/**
- * Async support integration in builder
- */
-export interface AsyncEnhancedBuilder<TObject extends object> {
-    /**
-     * Existing build functionality
-     */
-    build(): AsyncAwareValidator<TObject> & TransformAwareValidator<TObject, any>;
-    /**
-     * Build with async context
-     */
-    buildWithAsyncSupport(): AsyncAwareValidator<TObject> & TransformAwareValidator<TObject, any>;
-}
-/**
- * Async context-aware validation function type (type-safe version)
- */
-export type AsyncContextAwareValidation<T, TAsyncContext extends Record<string, any> = Record<string, any>> = (value: T, context: ValidationContext<any, any> & {
-    asyncContext?: TAsyncContext;
-}) => {
-    valid: boolean;
-    message?: string;
-};
-/**
- * Type-safe usage example of async plugins
- */
-export type AsyncPluginMethods = {
-    checkDuplication(): any;
-    validateMx(): any;
-    checkQuota(): any;
-    conditionalCheck(): any;
-    fullEmailValidation(): any;
-};

package/dist/core/builder/ultra-fast-validator.d.ts

@@ -1,30 +0,0 @@
-/**
- * Ultra-fast validator implementation for 1M+ ops/sec
- * Bypasses Result wrapper and all unnecessary abstractions
- */
-import { UnifiedValidator } from "../optimization/unified-validator";
-export interface UltraFastValidator<T> {
-    validate(value: T): {
-        valid: boolean;
-        value?: T;
-        error?: any;
-    };
-    parse(value: T): {
-        valid: boolean;
-        value?: T;
-        error?: any;
-    };
-}
-/**
- * Create ultra-fast validator for single field
- * Eliminates ALL unnecessary overhead
- */
-export declare function createUltraFastSingleFieldValidator<T extends Record<string, any>>(fieldPath: string, validator: UnifiedValidator): UltraFastValidator<T>;
-/**
- * Create ultra-fast validator for multiple fields
- * Specialized for 2-5 fields (most common cases)
- */
-export declare function createUltraFastMultiFieldValidator<T extends Record<string, any>>(fields: Array<{
-    path: string;
-    validator: UnifiedValidator;
-}>): UltraFastValidator<T>;

package/dist/core/builder/validator-factory.d.ts

@@ -1,29 +0,0 @@
-/**
- * Validator Factory - Separated validator construction responsibility
- * Responsible for generating performance-optimized validators
- */
-import type { FieldBuilderContext, ApplyFieldTransforms as ApplyNestedTransforms, TransformAwareValidator } from "./plugins/plugin-types";
-import { ArrayStructureInfo } from "../../types/array-type-analysis";
-/**
- * Field definition interface
- */
-export interface FieldDefinition {
-    path: string;
-    builderFunction?: (context: FieldBuilderContext<any, any, any>) => any;
-    rules?: any[];
-    metadata?: {
-        inferredType?: string;
-        hasTransforms?: boolean;
-        fieldOptions?: import("../builder/types/field-options").FieldOptions<any>;
-    };
-    fieldType?: string;
-    isArrayField?: boolean;
-    arrayStructure?: ArrayStructureInfo;
-    isOptional?: boolean;
-}
-/**
- * ValidatorFactory - Responsible for building high-performance validators
- */
-export declare function createValidatorFactory<TObject extends object, TMap = {}>(plugins: Record<string, any>): {
-    buildOptimizedValidator: (fieldDefinitions: Array<FieldDefinition>) => TransformAwareValidator<TObject, ApplyNestedTransforms<TObject, TMap>>;
-};

package/dist/core/global-config.d.ts

@@ -1,27 +0,0 @@
-export interface GlobalConfig {
-    messageKeyPrefix?: string;
-    toBooleanTruthyValues?: string[];
-    numberFormat?: {
-        decimalSeparator?: string;
-        thousandSeparator?: string;
-    };
-    dateFormat?: string;
-    trimStrings?: boolean;
-    caseSensitive?: boolean;
-    customTransforms?: Record<string, (value: any) => any>;
-}
-export declare const globalConfig: {
-    setConfig(config: Partial<GlobalConfig>): void;
-    getConfig(): GlobalConfig;
-    readonly messageKeyPrefix: string;
-    readonly toBooleanTruthyValues: string[];
-    readonly numberFormat: NonNullable<GlobalConfig["numberFormat"]>;
-    readonly dateFormat: string;
-    readonly trimStrings: boolean;
-    readonly caseSensitive: boolean;
-    readonly customTransforms: Record<string, (value: any) => any>;
-    reset(): void;
-};
-export declare function setGlobalConfig(config: Partial<GlobalConfig>): void;
-export declare function getGlobalConfig(): GlobalConfig;
-export declare function resetGlobalConfig(): void;

package/dist/core/index.d.ts

@@ -1,36 +0,0 @@
-/**
- * Luq Core - Plugin-based validation library core
- *
- * This module provides only minimal core functionality.
- * Add specific validation features as plugins.
- */
-export { Builder } from "./builder/core/builder";
-export { createPluginRegistry, type PluginRegistry, type FieldRule, type ExtractFieldRuleType, type FieldRuleDefinition } from "./registry/plugin-registry";
-export { type FieldBuilder, type TransformAwareValidator, type ApplyFieldTransforms, type ExtractFieldType, } from "./builder/plugins/plugin-types";
-export { ValidationResult } from "./builder/plugins/plugin-types";
-export { type ValidationOptions, type MessageContext, type SEVERITY, } from "./plugin/types";
-export { requiredPlugin } from "./plugin/required";
-export { optionalPlugin } from "./plugin/optional";
-export { stringMinPlugin } from "./plugin/stringMin";
-export { stringMaxPlugin } from "./plugin/stringMax";
-export { stringEmailPlugin } from "./plugin/stringEmail";
-export { stringPatternPlugin } from "./plugin/stringPattern";
-export { numberMinPlugin } from "./plugin/numberMin";
-export { numberMaxPlugin } from "./plugin/numberMax";
-export { numberPositivePlugin } from "./plugin/numberPositive";
-export { numberIntegerPlugin } from "./plugin/numberInteger";
-export { booleanTruthyPlugin } from "./plugin/booleanTruthy";
-export { booleanFalsyPlugin } from "./plugin/booleanFalsy";
-export { arrayMinLengthPlugin } from "./plugin/arrayMinLength";
-export { arrayMaxLengthPlugin } from "./plugin/arrayMaxLength";
-export { arrayUniquePlugin } from "./plugin/arrayUnique";
-export { objectPlugin } from "./plugin/object";
-export { oneOfPlugin } from "./plugin/oneOf";
-export { literalPlugin } from "./plugin/literal";
-export { compareFieldPlugin } from "./plugin/compareField";
-export { transformPlugin } from "./plugin/transform";
-export { requiredIfPlugin } from "./plugin/requiredIf";
-export { validateIfPlugin } from "./plugin/validateIf";
-export { skipPlugin } from "./plugin/skip";
-export { GlobalConfig, globalConfig, setGlobalConfig, getGlobalConfig, resetGlobalConfig, } from "./global-config";
-export { jsonSchemaPlugin } from "./plugin/jsonSchema";

package/dist/core/optimization/array-batch-validator.d.ts

@@ -1,68 +0,0 @@
-/**
- * Array Batch Validator (Refactored)
- * Uses integrated core system - eliminates duplicate logic
- *
- * Before: 343 lines with massive field processing duplication
- * After: ~80 lines using unified core systems
- */
-export interface ArrayFieldMapping {
-    arrayPath: string;
-    arrayAccessor: (obj: any) => any[];
-    elementFields: Array<{
-        fieldPath: string;
-        elementKey: string;
-        validator: any;
-        accessor: (obj: any) => any;
-        setter: (obj: any, value: any) => void;
-    }>;
-}
-/**
- * Analyze array fields (dramatically simplified)
- * Delegates duplicated path parsing logic to FieldUtils
- */
-export declare function analyzeArrayFields(fieldDefinitions: Array<{
-    path: string;
-    builderFunction: Function;
-}>, plugins: Record<string, any>): ArrayFieldMapping[];
-/**
- * Create array batch validator (dramatically simplified)
- * Delegates duplicated validation/parse logic to ArrayBatchStrategy
- */
-export declare function createArrayBatchValidator(arrayMappings: ArrayFieldMapping[]): {
-    validateArrays: (data: any, options?: {
-        abortEarly?: boolean;
-    }) => {
-        valid: boolean;
-        errors: Array<{
-            path: string;
-            code: string;
-            message: string;
-        }>;
-    };
-    parseArrays: (data: any, options?: {
-        abortEarly?: boolean;
-    }) => {
-        valid: boolean;
-        data?: any;
-        errors: Array<{
-            path: string;
-            code: string;
-            message: string;
-        }>;
-    };
-};
-/**
- * Legacy compatibility helper functions
- * Simplified version using integrated core system
- */
-export declare function createArrayAccessor(path: string): (obj: any) => any[];
-export declare function getNestedValue(obj: any, path: string): any;
-export declare function setNestedValue(obj: any, path: string, value: any): void;
-/**
- * Performance comparison helper
- */
-export declare function getArrayBatchValidatorStats(): {
-    codeReduction: string;
-    performanceImpact: string;
-    bundleSizeReduction: string;
-};

package/dist/core/optimization/core/field-utils.d.ts

@@ -1,103 +0,0 @@
-/**
- * Field Processing Utilities
- * Integrated field processing utilities - eliminates duplicate logic
- */
-export type FieldAccessor<T = any> = (obj: any) => T;
-export type FieldSetter<T = any> = (obj: any, value: T) => void;
-export interface ParsedFieldPath {
-    segments: string[];
-    isArrayElement: boolean;
-    arrayPath?: string;
-    elementKey?: string;
-    depth: number;
-}
-export interface ArrayFieldInfo {
-    arrayPath: string;
-    elementPath: string;
-    indexPattern: RegExp;
-}
-/**
- * Parse field path (consolidates logic duplicated across 4 files)
- */
-export declare function parseFieldPath(path: string): ParsedFieldPath;
-/**
- * Create field accessor (consolidates and optimizes duplicated logic)
- */
-export declare function createFieldAccessor<T = any>(path: string): FieldAccessor<T>;
-/**
- * Create field setter (consolidates and optimizes duplicated logic)
- */
-export declare function createFieldSetter<T = any>(path: string): FieldSetter<T>;
-/**
- * Get nested value (unified helper)
- */
-export declare function getNestedValue(obj: any, path: string): any;
-/**
- * Set nested value (unified helper)
- */
-export declare function setNestedValue(obj: any, path: string, value: any): void;
-/**
- * Analyze array field information
- */
-export declare function analyzeArrayField(path: string): ArrayFieldInfo | null;
-/**
- * Create array accessor (optimized)
- */
-export declare function createArrayAccessor(arrayPath: string): FieldAccessor<any[]>;
-/**
- * Group array fields from field definitions
- */
-export declare function groupArrayFields(fieldPaths: string[]): Map<string, {
-    arrayPath: string;
-    elementFields: string[];
-}>;
-/**
- * Create batch accessors (for accessing multiple fields at once)
- */
-export declare function createBatchAccessors(paths: string[]): Array<{
-    fieldName: string;
-    path: string;
-    accessor: FieldAccessor;
-}>;
-/**
- * Validate field path
- */
-export declare function isValidFieldPath(path: string): boolean;
-/**
- * Normalize field path
- */
-export declare function normalizeFieldPath(path: string): string;
-/**
- * Compare field paths
- */
-export declare function compareFieldPaths(path1: string, path2: string): number;
-/**
- * Clear cache (for memory management)
- * @deprecated Caches have been removed to prevent memory leaks
- */
-export declare function clearCache(): void;
-/**
- * Get cache statistics (for debugging)
- * @deprecated Caches have been removed to prevent memory leaks
- */
-export declare function getCacheStats(): {
-    pathCacheSize: number;
-    accessorCacheSize: number;
-    setterCacheSize: number;
-};
-export declare const FieldUtils: {
-    parseFieldPath: typeof parseFieldPath;
-    createFieldAccessor: typeof createFieldAccessor;
-    createFieldSetter: typeof createFieldSetter;
-    getNestedValue: typeof getNestedValue;
-    setNestedValue: typeof setNestedValue;
-    analyzeArrayField: typeof analyzeArrayField;
-    createArrayAccessor: typeof createArrayAccessor;
-    groupArrayFields: typeof groupArrayFields;
-    createBatchAccessors: typeof createBatchAccessors;
-    isValidFieldPath: typeof isValidFieldPath;
-    normalizeFieldPath: typeof normalizeFieldPath;
-    compareFieldPaths: typeof compareFieldPaths;
-    clearCache: typeof clearCache;
-    getCacheStats: typeof getCacheStats;
-};