@maroonedog/luq 0.1.2-alpha → 2.1.0

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

@@ -1,43 +0,0 @@
-import { ValidationOptions, MessageContext } from "./types";
-export interface StringMinContext extends MessageContext {
-    min: number;
-    actual: number;
-}
-/**
- * @luq-plugin
- * @name stringMin
- * @category standard
- * @description Validates that a string has at least the specified minimum length
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * // Basic usage - set minimum string length
- * const validator = Builder()
- *   .use(stringMinPlugin)
- *   .for<UserProfile>()
- *   .v("password", (b) => b.string.min(8))
- *   .v("username", (b) => b.string.min(3))
- *   .build();
- *
- * // Combined with other validators
- * builder.v("bio", b => b.string.required().min(10).max(500))
- * ```
- * @params
- * - min: number - Minimum character count
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if string length is at least the minimum
- * @customError
- * ```typescript
- * .min(8, {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must be at least ${params.min} characters (current: ${value.length})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringMinPlugin: import("../..").TypedPlugin<"stringMin", "min", (minLength: number, options?: ValidationOptions<StringMinContext>) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => any;
-    params: (number | ValidationOptions<StringMinContext>)[];
-}, readonly ["string"], "validator", "standard">;

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

@@ -1,40 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name stringPattern
- * @category standard
- * @description Validates that a string matches a regular expression pattern
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * // Basic usage - validate against regex pattern
- * const validator = Builder()
- *   .use(stringPatternPlugin)
- *   .for<UserData>()
- *   .v("phone", (b) => b.string.pattern(/^\d{3}-\d{3}-\d{4}$/))
- *   .v("zipCode", (b) => b.string.pattern(/^\d{5}(-\d{4})?$/))
- *   .build();
- *
- * // Common patterns
- * builder.v("hexColor", b => b.string.pattern(/^#[0-9A-Fa-f]{6}$/))
- * builder.v("slug", b => b.string.pattern(/^[a-z0-9-]+$/))
- * ```
- * @params
- * - pattern: RegExp - Regular expression to match against
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if string matches the pattern
- * @customError
- * ```typescript
- * .pattern(/^[A-Z]{2}\d{4}$/, {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must match pattern ${params.pattern} (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringPatternPlugin: import("../..").TypedPlugin<"stringPattern", "pattern", (regex: RegExp | string, options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (string | RegExp | ValidationOptions<{}>)[];
-}, readonly ["string"], "validator", "standard">;

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

@@ -1,42 +0,0 @@
-/**
- * @luq-plugin
- * @name stringRelativeJsonPointer
- * @category string
- * @description Validates Relative JSON Pointer format (draft-handrews-relative-json-pointer)
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * const validator = Builder()
- *   .use(stringRelativeJsonPointerPlugin)
- *   .for<{ pointer: string }>()
- *   .v("pointer", (b) => b.string.relativeJsonPointer())
- *   .build();
- *
- * // Valid: 0 (current location)
- * // Valid: 1/foo/bar (up 1 level, then to /foo/bar)
- * // Valid: 2/0 (up 2 levels, then to index 0)
- * // Valid: 0# (current location's key/index)
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
- * @returns Validation function that checks Relative JSON Pointer format
- * @customError
- * ```typescript
- * .relativeJsonPointer({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be valid Relative JSON Pointer format, received: ${value}`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "./types";
-export declare const stringRelativeJsonPointerPlugin: import("../..").TypedPlugin<"stringRelativeJsonPointer", "relativeJsonPointer", (options?: {
-    messageFactory?: (context: MessageContext) => string;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    params: {
-        messageFactory?: (context: MessageContext) => string;
-    }[];
-}, readonly ["string"], "validator", "standard">;

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

@@ -1,42 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name stringStartsWith
- * @category standard
- * @description Validates that a string begins with a specific prefix
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * // Basic usage - checks if string starts with prefix
- * const validator = Builder()
- *   .use(stringStartsWithPlugin)
- *   .for<ApiData>()
- *   .v("url", (b) => b.string.startsWith("https://"))
- *   .v("apiKey", (b) => b.string.required().startsWith("sk_"))
- *   .build();
- *
- * // For protocol validation
- * builder.v("secureUrl", b => b.string.startsWith("https://").url())
- *
- * // For ID prefixes
- * builder.v("orderId", b => b.string.startsWith("ORD-").pattern(/^ORD-\d{8}$/))
- * ```
- * @params
- * - prefix: string - The prefix that the string must start with
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if string starts with the prefix
- * @customError
- * ```typescript
- * .startsWith("REF-", {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must start with '${params.prefix}' (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringStartsWithPlugin: import("../..").TypedPlugin<"stringStartsWith", "startsWith", (prefix: string, options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (string | ValidationOptions<{}>)[];
-}, readonly ["string"], "validator", "standard">;

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

@@ -1,39 +0,0 @@
-/**
- * @luq-plugin
- * @name stringTime
- * @category string
- * @description Validates time format (HH:MM:SS or HH:MM:SS.mmm)
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * const validator = Builder()
- *   .use(stringTimePlugin)
- *   .for<{ startTime: string }>()
- *   .v("startTime", (b) => b.string.time())
- *   .build();
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string; allowMilliseconds?: boolean } - Optional configuration
- * @returns Validation function that checks time format
- * @customError
- * ```typescript
- * .time({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be a valid time format, received: ${value}`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "./types";
-export declare const stringTimePlugin: import("../..").TypedPlugin<"stringTime", "time", (options?: {
-    messageFactory?: (context: MessageContext) => string;
-    allowMilliseconds?: boolean;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    params: {
-        messageFactory?: (context: MessageContext) => string;
-        allowMilliseconds?: boolean;
-    }[];
-}, readonly ["string"], "validator", "standard">;

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

@@ -1,43 +0,0 @@
-/**
- * @luq-plugin
- * @name stringUriTemplate
- * @category string
- * @description Validates URI Template format (RFC 6570)
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * const validator = Builder()
- *   .use(stringUriTemplatePlugin)
- *   .for<{ template: string }>()
- *   .v("template", (b) => b.string.uriTemplate())
- *   .build();
- *
- * // Valid: https://api.example.com/users/{id}
- * // Valid: /search{?q,lang}
- * // Valid: /path{/segments*}
- * // Valid: {+path}/here
- * // Valid: {#section}
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
- * @returns Validation function that checks URI Template format
- * @customError
- * ```typescript
- * .uriTemplate({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be a valid URI Template, received: ${value}`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "./types";
-export declare const stringUriTemplatePlugin: import("../..").TypedPlugin<"stringUriTemplate", "uriTemplate", (options?: {
-    messageFactory?: (context: MessageContext) => string;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    params: {
-        messageFactory?: (context: MessageContext) => string;
-    }[];
-}, readonly ["string"], "validator", "standard">;

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

@@ -1,97 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name stringUrl
- * @category standard
- * @description Validates that a string is a valid URL format
- * @allowedTypes ["string"]
- * @see https://developer.mozilla.org/en-US/docs/Web/API/URL - MDN URL API Reference
- * @see https://tools.ietf.org/html/rfc3986 - RFC 3986: Uniform Resource Identifier (URI) Generic Syntax
- * @example
- * ```typescript
- * // Basic usage - validates all URL formats (RFC 3986 compliant)
- * const validator = Builder()
- *   .use(stringUrlPlugin)
- *   .for<UserProfile>()
- *   .v("website", (b) => b.string.url())
- *   .v("profileUrl", (b) => b.string.required().url())
- *   .build();
- *
- * // Custom protocols (e.g., allow ftp://)
- * builder.v("ftpServer", b => b.string.url({
- *   protocols: ['ftp:', 'ftps:']
- * }))
- *
- * // Allow URLs without protocol (assumes https://)
- * builder.v("domain", b => b.string.url({
- *   allowWithoutProtocol: true
- * }))
- *
- * // ✅ VALID URL formats (RFC 3986)
- * validator.parse({ website: "https://example.com" });                    // Standard HTTPS
- * validator.parse({ website: "http://www.test.co.uk/path?q=value#frag" }); // Full URL with query and fragment
- * validator.parse({ website: "ftp://files.domain.com/file.txt" });        // FTP protocol
- * validator.parse({ website: "ws://localhost:3000" });                    // WebSocket protocol
- * validator.parse({ website: "https://subdomain.example.com:8080/api" }); // With port and path
- * validator.parse({ website: "https://127.0.0.1:3000" });                // IP address
- * validator.parse({ website: "https://[::1]:8080" });                    // IPv6 address
- * validator.parse({ website: "mailto:user@example.com" });                // mailto protocol
- * validator.parse({ website: "tel:+1-555-123-4567" });                   // tel protocol
- * validator.parse({ website: "https://user:pass@example.com" });          // With credentials
- *
- * // With allowWithoutProtocol: true
- * const flexValidator = builder.v("site", b => b.string.url({ allowWithoutProtocol: true }));
- * flexValidator.parse({ site: "example.com" });                          // Assumes https://
- * flexValidator.parse({ site: "www.domain.co.uk/path" });                // Assumes https://
- *
- * // ❌ INVALID URL formats
- * validator.parse({ website: "not-a-url" });              // Plain text
- * validator.parse({ website: "http://" });                // Missing host
- * validator.parse({ website: "://missing-protocol" });    // Missing protocol
- * validator.parse({ website: "https://" });               // Missing host after protocol
- * validator.parse({ website: "http://.com" });            // Invalid host
- * validator.parse({ website: "https://example." });       // Incomplete domain
- * validator.parse({ website: "just text with spaces" });  // Contains spaces
- * validator.parse({ website: "ftp://[invalid-ipv6]" });   // Invalid IPv6
- * validator.parse({ website: "https://exam ple.com" });   // Space in domain
- * validator.parse({ website: "" });                       // Empty string
- * ```
- * @params
- * - options?: StringUrlOptions - URL validation configuration
- *   - protocols?: string[] - Allowed protocols (default: all protocols allowed)
- *   - allowWithoutProtocol?: boolean - Allow URLs without protocol (default: false)
- *   - messageFactory?: (context: MessageContext) => string - Custom error message factory
- * @returns Validation function that returns true if string is a valid URL
- * @customError
- * ```typescript
- * .url({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be a valid URL (received: ${value})`
- * })
- *
- * // Restrict to specific protocols
- * .url({
- *   protocols: ['https:'],
- *   messageFactory: ({ path }) => `${path} must be a secure HTTPS URL`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export interface StringUrlOptions extends ValidationOptions {
-    /**
-     * Array of allowed protocols. Default: null (allow all protocols)
-     * @example ['http:', 'https:', 'ftp:', 'ws:', 'wss:']
-     */
-    protocols?: string[];
-    /**
-     * Whether to allow URLs without protocol (will default to https://)
-     * @default false
-     */
-    allowWithoutProtocol?: boolean;
-}
-export declare const stringUrlPlugin: import("../..").TypedPlugin<"stringUrl", "url", (options?: StringUrlOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: StringUrlOptions[];
-}, readonly ["string"], "validator", "standard">;

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

@@ -1,15 +0,0 @@
-/**
- * Test utilities for plugin testing
- */
-export declare const createMockReporter: () => {
-    report: jest.Mock<any, any, any>;
-    getReports: jest.Mock<any[], [], any>;
-};
-export declare const createMockContext: (path?: string) => {
-    path: string;
-    reporter: {
-        report: jest.Mock<any, any, any>;
-        getReports: jest.Mock<any[], [], any>;
-    };
-    allValues: {};
-};

package/dist/core/plugin/transform-type-restrictions.d.ts

@@ -1,61 +0,0 @@
-/**
- * Transform type restriction utilities
- * Due to nested array support implementation, transform of Array<object> and Array<union>
- * is no longer supported, so we restrict it at the type level.
- */
-/**
- * Type helper to determine if it's a Union type
- * Uses the properties of distributive conditional types for detection
- */
-type IsUnionType<T, U = T> = T extends any ? [U] extends [T] ? false : true : false;
-/**
- * Use distributive conditional types to check if Union elements are plain objects
- * Result becomes boolean union (e.g., false | true)
- */
-type UnionMemberCheck<T> = T extends any ? T extends Record<string, any> ? T extends (...args: any[]) => any ? false : T extends readonly any[] ? false : T extends Date ? false : T extends RegExp ? false : T extends string | number | boolean | null | undefined ? false : true : false : false;
-/**
- * Accurately determine if a Union type contains plain objects
- * If true is included in the result, it's a Union containing plain objects
- */
-type UnionHasPlainObject<T> = true extends UnionMemberCheck<T> ? true : false;
-/**
- * More accurate approach: Detect Union type first then process
- */
-type ArrayElementIsObjectOrUnion<T> = T extends readonly (infer U)[] ? IsUnionType<U> extends true ? UnionHasPlainObject<U> extends true ? true : false : U extends Record<string, any> ? U extends (...args: any[]) => any ? false : U extends readonly any[] ? false : U extends Date ? false : U extends RegExp ? false : U extends string | number | boolean | null | undefined ? false : true : false : false;
-/**
- * Determine if the type is forbidden as a Transform return value
- */
-export type IsForbiddenTransformOutput<T> = T extends readonly any[] ? ArrayElementIsObjectOrUnion<T> extends true ? true : false : false;
-/**
- * Concise and clear English instruction message for forbidden Transform return types
- * Includes specific instructions displayed in TypeScript errors
- */
-export type ForbiddenTransformError<T> = T extends readonly (infer U)[] ? U extends Record<string, any> ? U extends (...args: any[]) => any | readonly any[] | Date | RegExp ? never : `🚫 FORBIDDEN: Cannot transform to Array<object>. Use Array<primitive> instead. Example: .transform(arr => arr.map(s => s.toUpperCase())) returns string[]` : `🚫 FORBIDDEN: Cannot transform to Array<union with object>. Use Array<primitive> instead. Example: .transform(arr => arr.map(s => s.length)) returns number[]` : never;
-/**
- * Conditional type to validate Transform function return type
- */
-export type ValidateTransformOutput<T> = IsForbiddenTransformOutput<T> extends true ? ForbiddenTransformError<T> : T;
-/**
- * Safe Transform function type definition
- * Returns error type for forbidden return types, otherwise returns normal function type
- */
-export type SafeTransformFunction<TInput, TOutput> = IsForbiddenTransformOutput<TOutput> extends true ? ForbiddenTransformError<TOutput> : (value: TInput) => TOutput;
-/**
- * More direct type checking used in actual plugin implementations
- */
-export type RestrictedTransformFunction<TInput = any, TOutput = any> = TOutput extends readonly any[] ? ArrayElementIsObjectOrUnion<TOutput> extends true ? ForbiddenTransformError<TOutput> : (value: TInput) => TOutput : (value: TInput) => TOutput;
-/**
- * Utility type for displaying Transform function type check results
- */
-export type CheckTransformFunction<F> = F extends (value: any) => infer R ? IsForbiddenTransformOutput<R> extends true ? {
-    _status: "❌ FORBIDDEN";
-    _type: R;
-    _error: ForbiddenTransformError<R>;
-} : {
-    _status: "✅ ALLOWED";
-    _type: R;
-} : {
-    _status: "❓ UNKNOWN";
-    _error: "Not a valid transform function";
-};
-export {};

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

@@ -1,35 +0,0 @@
-/**
- * @luq-plugin
- * @name transform
- * @category transform
- * @description Transforms values after successful validation (type conversion, normalization, computed values)
- * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
- * @example
- * ```typescript
- * // String transformation (lowercase)
- * const validator = Builder()
- *   .use(transformPlugin)
- *   .for<UserData>()
- *   .v("email", (b) =>
- *     b.string.required().email().transform(v => v.toLowerCase())
- *   )
- *   .build();
- *
- * // Number to string conversion
- * builder.v("age", b =>
- *   b.number.required().min(0).transform(v => String(v))
- * )
- *
- * // Array element transformation
- * builder.v("tags", b =>
- *   b.array.transform(tags => tags.map(t => t.trim().toLowerCase()))
- * )
- * ```
- * @params
- * - transformFn: (value: T) => U - Transform function that takes input value and returns transformed value
- * @returns Validation function with transformation
- * @customError
- * Transform plugin does not generate errors. Errors in transform function are treated as exceptions.
- * @since 0.1.0-alpha
- */
-export declare const transformPlugin: import("../..").TypedPlugin<"transform", "transform", import("../builder/plugins/plugin-interfaces").TransformPluginImplementation<any, any>, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "transform">;

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

@@ -1,66 +0,0 @@
-/**
- * @luq-plugin
- * @name tupleBuilder
- * @category composable-directly
- * @description Validates tuple types (fixed-length arrays with different types for each element)
- * @allowedTypes ["tuple"]
- * @example
- * ```typescript
- * // Fixed-length tuple - no options needed
- * type Coordinates = [number, number];
- *
- * const validator = Builder()
- *   .use(tupleBuilderPlugin)
- *   .for<{ location: Coordinates }>()
- *   .v("location", (b) => b.tuple
- *     .required()
- *     .builder(
- *       (a) => a.number.required().min(0),
- *       (b) => b.number.required().min(0)
- *     )
- *   )
- *   .build();
- *
- * // Variable-length tuple with rest elements
- * type UserData = [string, number, boolean, ...string[]];
- *
- * const userValidator = Builder()
- *   .use(tupleBuilderPlugin)
- *   .for<{ data: UserData }>()
- *   .v("data", (b) => b.tuple
- *     .required()
- *     .builder(
- *       (a) => a.string.required().min(3),     // name
- *       (b) => b.number.required().min(0),     // age
- *       (c) => c.boolean.required(),           // isActive
- *       { rest: (r) => r.string.optional() }   // rest elements
- *     )
- *   )
- *   .build();
- * ```
- * @params
- * - ...builderFns: Array<(context: FieldBuilderContext) => any> - Builder functions for each tuple element
- * - options?: { rest?: (context: FieldBuilderContext) => any } - Optional configuration (automatically defaults to {} when omitted)
- * @returns Composable validation function
- * @customError
- * - Returns false if value is not an array
- * - Returns false if array length doesn't match tuple definition (without rest)
- * - Returns false if any element validation fails
- * @since 0.1.0-alpha
- */
-import type { FieldBuilderContext } from "../builder/plugins/plugin-types";
-export interface TupleBuilderFunction<TObject extends object, TPlugins> {
-    (context: FieldBuilderContext<TObject, TPlugins, any>): any;
-}
-export interface RestBuilderFunction<TObject extends object, TPlugins> {
-    (context: FieldBuilderContext<TObject, TPlugins, any>): any;
-}
-export interface TupleBuilderOptions<TObject extends object, TPlugins> {
-    rest?: RestBuilderFunction<TObject, TPlugins>;
-    messageFactory?: {
-        notArray?: (value: unknown) => string;
-        lengthMismatch?: (expected: number, actual: number) => string;
-        tooShort?: (minimum: number, actual: number) => string;
-    };
-}
-export declare const tupleBuilderPlugin: import("../builder/plugins/composable-directly-plugin").ComposableDirectlyPlugin<"tupleBuilder", "builder", readonly ["tuple"]>;