@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/core/optimization/core/strategy-factory.d.ts

@@ -1,84 +0,0 @@
-/**
- * Strategy Pattern Implementation
- * Validation strategy integration and factory pattern
- */
-import { ValidationEngine, ValidationField, ValidationResult, ParseResult } from "./validation-engine";
-export declare enum ValidationStrategy {
-    FAST_SEPARATED = "fast_separated",
-    DEFINITION_ORDER = "definition_order",
-    ARRAY_BATCH = "array_batch",
-    HOISTED_OPTIMIZED = "hoisted_optimized"
-}
-export interface StrategyValidationOptions {
-    abortEarly?: boolean;
-    abortEarlyOnEachField?: boolean;
-}
-export interface StrategyAnalysis {
-    strategy: ValidationStrategy;
-    reason: string;
-    canOptimize: boolean;
-    hasTransforms: boolean;
-    hasArrayFields: boolean;
-    fieldCount: number;
-}
-/**
- * Unified validation strategy interface
- */
-export interface IValidationStrategy {
-    readonly strategyType: ValidationStrategy;
-    validate(value: any, rootData: any, options?: StrategyValidationOptions): ValidationResult;
-    parse(value: any, rootData: any, options?: StrategyValidationOptions): ParseResult;
-    validateHoisted?(value: any, rootData: any, abortEarlyOnEachField?: boolean): {
-        valid: boolean;
-        errorIndices?: number[];
-    };
-    reconstructErrors?(errorIndices: number[], value: any, rootData: any, abortEarlyOnEachField?: boolean): Array<{
-        path: string;
-        code: string;
-        message: string;
-    }>;
-}
-/**
- * Fast Separated Strategy
- * Execute in order: Validators → Transforms (optimized)
- */
-export declare function createFastSeparatedStrategy(field: ValidationField, engine?: ValidationEngine): IValidationStrategy;
-/**
- * Definition Order Strategy
- * Execute in definition order (including transforms)
- */
-export declare function createDefinitionOrderStrategy(field: ValidationField, engine?: ValidationEngine): IValidationStrategy;
-/**
- * Array Batch Strategy
- * Batch processing of array elements (optimized)
- */
-export declare function createArrayBatchStrategy(arrayPath: string, elementFields: ValidationField[], engine?: ValidationEngine): IValidationStrategy;
-/**
- * Multi-Field Strategy
- * Integrated processing of multiple fields
- */
-export declare function createMultiFieldStrategy(fields: ValidationField[], engine?: ValidationEngine): IValidationStrategy;
-/**
- * Analyze field definitions to determine optimal strategy
- */
-export declare function analyzeFields(fieldDefinitions: Array<{
-    path: string;
-    builderFunction: Function;
-}>, plugins: Record<string, any>): StrategyAnalysis;
-/**
- * Create strategy instance
- */
-export declare function createStrategy(analysis: StrategyAnalysis, fieldDefinitions: Array<{
-    path: string;
-    builderFunction: Function;
-    validators?: any[];
-    transforms?: any[];
-}>, plugins: Record<string, any>): IValidationStrategy;
-export declare function createOptimalStrategy(fieldDefinitions: Array<{
-    path: string;
-    builderFunction: Function;
-}>, plugins: Record<string, any>): {
-    strategy: IValidationStrategy;
-    analysis: StrategyAnalysis;
-};
-export declare function createSingleFieldStrategy(path: string, validators: any[], transforms?: any[]): IValidationStrategy;

package/dist/core/optimization/core/validation-engine.d.ts

@@ -1,107 +0,0 @@
-/**
- * Core Validation Engine
- * Integrated validation execution engine - eliminates duplicate logic
- */
-export interface ValidationError {
-    path: string;
-    code: string;
-    message: string;
-}
-export interface ValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-}
-export interface ParseResult extends ValidationResult {
-    data?: any;
-}
-export interface ValidationContext {
-    originalValue: any;
-    currentValue: any;
-    allValues: any;
-    path: string;
-    arrayContext?: import("../../plugin/types").ArrayContext;
-}
-export interface ValidatorFunction {
-    check: (value: any, allValues?: any, arrayContext?: import("../../plugin/types").ArrayContext) => boolean;
-    code?: string;
-    pluginName?: string;
-    getErrorMessage?: (value: any, path: string, allValues?: any, arrayContext?: import("../../plugin/types").ArrayContext) => string;
-    messageFactory?: (context: any) => string;
-    params?: any[];
-    metadata?: {
-        type?: string;
-        category?: string;
-        [key: string]: any;
-    };
-}
-export interface TransformFunction {
-    apply?: (value: any, context?: any) => any;
-    transformFn?: (value: any) => any;
-    (value: any): any;
-}
-export interface ValidationField {
-    path: string;
-    validators: ValidatorFunction[];
-    transforms: TransformFunction[];
-}
-/**
- * Execute validation for single field
- */
-export declare function validateField(field: ValidationField, value: any, context: ValidationContext, options?: {
-    abortEarly?: boolean;
-}): ValidationResult;
-/**
- * Batch validation for multiple fields
- */
-export declare function validateBatch(fields: ValidationField[], values: any, options?: {
-    abortEarly?: boolean;
-    abortEarlyOnEachField?: boolean;
-}): ValidationResult;
-/**
- * Parse field (validation + transform)
- */
-export declare function parseField(field: ValidationField, value: any, context: ValidationContext, options?: {
-    abortEarly?: boolean;
-}): ParseResult;
-/**
- * Batch parse multiple fields
- */
-export declare function parseBatch(fields: ValidationField[], values: any, options?: {
-    abortEarly?: boolean;
-    abortEarlyOnEachField?: boolean;
-}): ParseResult;
-/**
- * Apply transform (logic duplicated across all files)
- */
-export declare function applyTransforms(transforms: TransformFunction[], value: any, context: ValidationContext): any;
-/**
- * Hoisted validation (for high-speed validation)
- */
-export declare function validateHoisted(field: ValidationField, value: any, allValues: any, abortEarlyOnEachField?: boolean, arrayContext?: import("../../plugin/types").ArrayContext): {
-    valid: boolean;
-    errorIndices?: number[];
-};
-/**
- * Rebuild errors (for hoisted validation)
- */
-export declare function reconstructErrors(field: ValidationField, errorIndices: number[], value: any, allValues: any, arrayContext?: import("../../plugin/types").ArrayContext): ValidationError[];
-/**
- * ValidationEngine interface for compatibility
- */
-export interface ValidationEngine {
-    validateField: typeof validateField;
-    validateBatch: typeof validateBatch;
-    parseField: typeof parseField;
-    parseBatch: typeof parseBatch;
-    applyTransforms: typeof applyTransforms;
-    validateHoisted: typeof validateHoisted;
-    reconstructErrors: typeof reconstructErrors;
-}
-/**
- * 共有エンジンインスタンス取得
- */
-export declare function getValidationEngine(): ValidationEngine;
-/**
- * Create new engine instance (for testing)
- */
-export declare function createValidationEngine(): ValidationEngine;

package/dist/core/optimization/execution-strategy-selector.d.ts

@@ -1,23 +0,0 @@
-/**
- * Execution Strategy Selector (Refactored)
- * Uses integrated StrategyFactory - eliminates duplicate logic
- *
- * Before: 84 lines with strategy analysis duplication
- * After: ~25 lines using unified core systems
- */
-import { StrategyAnalysis } from './core/strategy-factory';
-/**
- * Determine execution strategy for all fields (simplified)
- * Delegates duplicated strategy analysis logic to StrategyFactory
- */
-export declare function selectOptimalStrategies(fieldDefinitions: Array<{
-    path: string;
-    builderFunction: Function;
-}>, plugins: Record<string, any>): Map<string, StrategyAnalysis>;
-/**
- * Group fields by strategy (simplified)
- */
-export declare function groupByStrategy(strategies: Map<string, StrategyAnalysis>): {
-    fastFields: string[];
-    slowFields: string[];
-};

package/dist/core/optimization/unified-validator.d.ts

@@ -1,45 +0,0 @@
-/**
- * Unified Validator - Integrates meaningless Fast/Slow separation
- *
- * User feedback: validateFast and validateSlow don't need separate function names
- * Since the caller uses the same interface, they should be unified
- *
- * Before: FastValidator + SlowValidator = 519 lines
- * After: UnifiedValidator = ~80 lines (85% reduction)
- */
-interface ValidationResult {
-    readonly valid: boolean;
-    readonly errors: Array<{
-        readonly path: string;
-        readonly code: string;
-        readonly message: string;
-    }>;
-}
-interface ParseResult {
-    readonly valid: boolean;
-    readonly data?: any;
-    readonly errors: Array<{
-        readonly path: string;
-        readonly code: string;
-        readonly message: string;
-    }>;
-}
-export interface UnifiedValidator {
-    validate(value: any, rootData: any, options?: {
-        abortEarlyOnEachField?: boolean;
-    }): ValidationResult;
-    parse(value: any, rootData: any, options?: {
-        abortEarlyOnEachField?: boolean;
-    }): ParseResult;
-    accessor?: (obj: any) => any;
-}
-type ExecutionStrategy = "definition_order" | "fast_separated";
-/**
- * Create unified validator
- * Fast/Slow differences are internal implementation only, external interface is unified
- */
-export declare function createUnifiedValidator(fieldDef: {
-    path: string;
-    builderFunction: Function;
-}, plugins: Record<string, any>, strategy?: ExecutionStrategy, accessor?: (obj: any) => any): UnifiedValidator;
-export {};

package/dist/core/plugin/__tests__/test-utils.d.ts

@@ -1 +0,0 @@
-export { createMockReporter, createMockContext } from '../testUtils';

package/dist/core/plugin/arrayContains.d.ts

@@ -1,37 +0,0 @@
-/**
- * @luq-plugin
- * @name arrayContains
- * @category array
- * @description Validates that an array contains at least one item matching the specified schema or value
- * @allowedTypes ["array"]
- * @example
- * ```typescript
- * // Contains specific value
- * const validator = Builder()
- *   .use(arrayContainsPlugin)
- *   .for<{ tags: string[] }>()
- *   .v("tags", (b) => b.array.contains("important"))
- *   .build();
- *
- * // Contains matching schema
- * builder.v("items", b => b.array.contains({
- *   validator: (value) => typeof value === 'number' && value > 10,
- *   message: "Array must contain at least one number greater than 10"
- * }))
- * ```
- * @params
- * - schema: any | { validator: (value: any) => boolean, message?: string } - Value or validation schema
- * @returns Validation function that checks if array contains matching item
- * @since 0.1.0-alpha
- */
-import type { JSONSchema7 } from "json-schema";
-export interface ContainsSchema {
-    validator: (value: any) => boolean;
-    message?: string;
-}
-export declare const arrayContainsPlugin: import("../..").TypedPlugin<"arrayContains", "contains", (schema: any | ContainsSchema | JSONSchema7) => {
-    check: (value: any[]) => boolean;
-    code: string;
-    getErrorMessage: (value: any[], path: string) => any;
-    params: any[];
-}, readonly ["array"], "validator", "standard">;

package/dist/core/plugin/arrayIncludes.d.ts

@@ -1,42 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name arrayIncludes
- * @category standard
- * @description Validates that an array contains a specific required element
- * @allowedTypes ["array"]
- * @example
- * ```typescript
- * // Basic usage - check if array contains specific item
- * const validator = Builder()
- *   .use(arrayIncludesPlugin)
- *   .for<UserData>()
- *   .v("roles", (b) => b.array.includes("admin"))
- *   .v("permissions", (b) => b.array.includes("read"))
- *   .build();
- *
- * // Multiple required items
- * builder.v("features", b => b.array
- *   .includes("core")
- *   .includes("api")
- * )
- * ```
- * @params
- * - expected: any - The element that must be present in the array
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if array contains the expected element
- * @customError
- * ```typescript
- * .includes("admin", {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must include "${params.expected}" (current: [${value.join(", ")}])`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const arrayIncludesPlugin: import("../..").TypedPlugin<"arrayIncludes", "includes", <TElement = any>(element: TElement, options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (ValidationOptions<{}> | TElement)[];
-}, readonly ["array"], "validator", "arrayElement">;

package/dist/core/plugin/arrayMaxLength.d.ts

@@ -1,43 +0,0 @@
-import { ValidationOptions, MessageContext } from "./types";
-export interface ArrayMaxLengthContext extends MessageContext {
-    max: number;
-    actual: number;
-}
-/**
- * @luq-plugin
- * @name arrayMaxLength
- * @category standard
- * @description Validates that an array does not exceed the specified maximum number of elements
- * @allowedTypes ["array"]
- * @example
- * ```typescript
- * // Basic usage - set maximum array length
- * const validator = Builder()
- *   .use(arrayMaxLengthPlugin)
- *   .for<FormData>()
- *   .v("tags", (b) => b.array.maxLength(10))
- *   .v("attachments", (b) => b.array.maxLength(5))
- *   .build();
- *
- * // Limit file uploads with min and max
- * builder.v("files", b => b.array.minLength(1).maxLength(3))
- * ```
- * @params
- * - maxLength: number - Maximum number of elements allowed
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if array length does not exceed maximum
- * @customError
- * ```typescript
- * .maxLength(5, {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} can have at most ${params.maxLength} items (current: ${value.length})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const arrayMaxLengthPlugin: import("../..").TypedPlugin<"arrayMaxLength", "maxLength", (maxLength: number, options?: ValidationOptions<ArrayMaxLengthContext>) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (number | ValidationOptions<ArrayMaxLengthContext>)[];
-}, readonly ["array"], "validator", "standard">;

package/dist/core/plugin/arrayMinLength.d.ts

@@ -1,43 +0,0 @@
-import { ValidationOptions, MessageContext } from "./types";
-export interface ArrayMinLengthContext extends MessageContext {
-    min: number;
-    actual: number;
-}
-/**
- * @luq-plugin
- * @name arrayMinLength
- * @category standard
- * @description Validates that an array has at least the specified minimum number of elements
- * @allowedTypes ["array"]
- * @example
- * ```typescript
- * // Basic usage - set minimum array length
- * const validator = Builder()
- *   .use(arrayMinLengthPlugin)
- *   .for<FormData>()
- *   .v("tags", (b) => b.array.minLength(1))
- *   .v("items", (b) => b.array.minLength(3))
- *   .build();
- *
- * // Ensure non-empty array
- * builder.v("selectedOptions", b => b.array.required().minLength(1))
- * ```
- * @params
- * - minLength: number - Minimum number of elements required
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if array length is at least the minimum
- * @customError
- * ```typescript
- * .minLength(3, {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must have at least ${params.minLength} items (current: ${value.length})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const arrayMinLengthPlugin: import("../..").TypedPlugin<"arrayMinLength", "minLength", (minLength: number, options?: ValidationOptions<ArrayMinLengthContext>) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (number | ValidationOptions<ArrayMinLengthContext>)[];
-}, readonly ["array"], "validator", "standard">;

package/dist/core/plugin/arrayUnique.d.ts

@@ -1,41 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name arrayUnique
- * @category standard
- * @description Validates that all elements in an array are unique (no duplicates)
- * @allowedTypes ["array"]
- * @example
- * ```typescript
- * // Basic usage - ensures all array elements are unique
- * const validator = Builder()
- *   .use(arrayUniquePlugin)
- *   .for<FormData>()
- *   .v("emails", (b) => b.array.unique())
- *   .v("userIds", (b) => b.array.required().unique())
- *   .build();
- *
- * // For tags or categories
- * builder.v("tags", b => b.array.unique().minLength(1).maxLength(10))
- *
- * // Combining with other array validations
- * builder.v("productCodes", b => b.array.unique().includes("PRIMARY"))
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if all array elements are unique
- * @customError
- * ```typescript
- * .unique({
- *   messageFactory: ({ path, value }) =>
- *     `${path} contains duplicate values`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const arrayUniquePlugin: import("../..").TypedPlugin<"arrayUnique", "unique", (options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: ValidationOptions<{}>[];
-}, readonly ["array"], "validator", "standard">;

package/dist/core/plugin/booleanFalsy.d.ts

@@ -1,41 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name booleanFalsy
- * @category standard
- * @description Validates that a boolean value is exactly false
- * @allowedTypes ["boolean"]
- * @example
- * ```typescript
- * // Basic usage - ensures value is exactly false
- * const validator = Builder()
- *   .use(booleanFalsyPlugin)
- *   .for<Settings>()
- *   .v("isActive", (b) => b.boolean.falsy())
- *   .v("debugMode", (b) => b.boolean.required().falsy())
- *   .build();
- *
- * // Privacy settings
- * builder.v("shareData", b => b.boolean.falsy())
- *
- * // Security flags
- * builder.v("allowExternalAccess", b => b.boolean.required().falsy())
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if value is exactly false
- * @customError
- * ```typescript
- * .falsy({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be set to false (current: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const booleanFalsyPlugin: import("../..").TypedPlugin<"booleanFalsy", "falsy", (options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: ValidationOptions<{}>[];
-}, readonly ["boolean"], "validator", "standard">;

package/dist/core/plugin/booleanTruthy.d.ts

@@ -1,38 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name booleanTruthy
- * @category standard
- * @description Validates that a boolean value is exactly true
- * @allowedTypes ["boolean"]
- * @example
- * ```typescript
- * // Basic usage - ensure value is exactly true
- * const validator = Builder()
- *   .use(booleanTruthyPlugin)
- *   .for<FormData>()
- *   .v("isActive", (b) => b.boolean.truthy())
- *   .v("termsAccepted", (b) => b.boolean.required().truthy())
- *   .build();
- *
- * // For consent checkboxes
- * builder.v("agreeToTerms", b => b.boolean.required().truthy())
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true only if value is exactly true
- * @customError
- * ```typescript
- * .truthy({
- *   messageFactory: ({ path }) =>
- *     `${path} must be checked/accepted`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const booleanTruthyPlugin: import("../..").TypedPlugin<"booleanTruthy", "truthy", (options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: ValidationOptions<{}>[];
-}, readonly ["boolean"], "validator", "standard">;

package/dist/core/plugin/compareField.d.ts

@@ -1,58 +0,0 @@
-import { ValidationOptions } from "./types";
-type CompareFn = (value: any, targetValue: any) => boolean;
-interface CompareFieldOptions extends ValidationOptions {
-    compareFn?: CompareFn;
-}
-/**
- * @luq-plugin
- * @name compareField
- * @category standard
- * @description Validates a field's value by comparing it with another field's value using a custom comparison function
- * @allowedTypes ["string", "number", "boolean", "date", "object", "array", "null", "undefined"]
- * @example
- * ```typescript
- * // Default usage - strict equality
- * const validator = Builder()
- *   .use(compareFieldPlugin)
- *   .for<SignupForm>()
- *   .v("password", (b) => b.string.required().min(8))
- *   .v("confirmPassword", (b) => b.string.required().compareField("password"))
- *   .build();
- *
- * // Custom comparison - date before
- * builder.v("endDate", (b) => b.string.datetime().compareField("startDate", {
- *   compareFn: (endDate, startDate) => new Date(endDate) > new Date(startDate),
- *   messageFactory: () => "End date must be after start date"
- * }))
- *
- * // Number comparison
- * builder.v("maxValue", (b) => b.number.compareField("minValue", {
- *   compareFn: (max, min) => max >= min,
- *   messageFactory: () => "Max value must be greater than or equal to min value"
- * }))
- * ```
- * @params
- * - fieldPath: string - Path to the field to compare against (supports dot notation)
- * - options?: { compareFn?: (value, targetValue) => boolean, messageFactory?: (context) => string } - Optional configuration
- * @returns Validation function that returns true if comparison passes
- * @customError
- * ```typescript
- * .compareField("startDate", {
- *   compareFn: (end, start) => new Date(end) > new Date(start),
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must be after ${params.fieldPath}`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const compareFieldPlugin: import("../..").TypedPlugin<"compareField", "compareField", (fieldPath: string, options?: CompareFieldOptions) => {
-    check: (value: any, allValues?: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string, allValues?: any) => string;
-    params: (string | CompareFieldOptions)[];
-    fieldReference: {
-        fieldPath: string;
-        compareFn: CompareFn;
-    };
-}, readonly ["string", "number", "boolean", "date", "object", "array", "tuple", "union"], "validator", "fieldReference">;
-export {};

package/dist/core/plugin/conditionalSchema.d.ts

@@ -1,24 +0,0 @@
-import { ValidationOptions } from "./types";
-import { JSONSchema7 } from "json-schema";
-export interface ConditionalSchemaOptions extends ValidationOptions {
-    ifSchema: JSONSchema7;
-    thenSchema?: JSONSchema7;
-    elseSchema?: JSONSchema7;
-    validator?: (value: any, schema: JSONSchema7) => boolean;
-}
-/**
- * Conditional Schema Plugin (if/then/else)
- *
- * Handles JSON Schema Draft-07 conditional validation
- * @luq-plugin
- * @name conditionalSchema
- * @category advanced
- * @description Validates based on if/then/else conditions
- * @allowedTypes ["object"]
- */
-export declare const conditionalSchemaPlugin: import("../..").TypedPlugin<"conditionalSchema", "conditionalSchema", (options: ConditionalSchemaOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: ConditionalSchemaOptions[];
-}, readonly ["object"], "validator", "standard">;