adaptform 2.0.5 → 2.2.0

package/dist/Form-uHUaTUZS.d.cts

@@ -0,0 +1,387 @@
+/** Shared mutation boundary; subclasses only describe state and their mutations. */
+declare abstract class ObservableNode<TSnapshot> {
+    private readonly _stateStore;
+    protected abstract captureState(): TSnapshot;
+    protected stateChildren(): readonly ObservableNode<unknown>[];
+    private contains;
+    protected validateAfterMutation(callback: () => unknown): void;
+    protected batchUpdate<TResult>(callback: () => TResult, validate: () => unknown): TResult;
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): TSnapshot;
+    protected update<TResult>(callback: () => TResult): TResult;
+}
+
+/** Snapshots contain data only: mutable built-ins and opaque instances are described. */
+type SnapshotValue = null | undefined | string | number | boolean | bigint | readonly SnapshotValue[] | {
+    readonly [key: string]: SnapshotValue;
+};
+interface NodeSnapshot {
+    readonly isValid: boolean | null;
+    readonly isTouched: boolean;
+    readonly isDirty: boolean;
+}
+interface FieldSnapshot extends NodeSnapshot {
+    readonly rawValue: SnapshotValue;
+    readonly valueClear: SnapshotValue;
+    readonly errors: readonly string[];
+}
+interface FormSnapshot extends NodeSnapshot {
+    readonly fieldsValue: Readonly<Record<string, SnapshotValue>>;
+    readonly allErrors: Readonly<Record<string, readonly string[]>>;
+    readonly globalErrors: Readonly<Record<string, string>>;
+    readonly fields: Readonly<Record<string, FieldSnapshot | ArrayFieldSnapshot | ArrayFormSnapshot>>;
+}
+interface ArrayFieldSnapshot extends NodeSnapshot {
+    readonly itemsValue: readonly SnapshotValue[];
+    readonly errors: readonly string[];
+    readonly items: readonly FieldSnapshot[];
+}
+interface ArrayFormSnapshot extends NodeSnapshot {
+    readonly formsFieldsValue: readonly Readonly<Record<string, SnapshotValue>>[];
+    readonly errors: readonly string[];
+    readonly forms: readonly FormSnapshot[];
+}
+
+interface FieldPlugin<T = any> {
+    pluginOptions?: PluginOptions;
+    init?(field: Field<T>): void;
+    toRawValue?(value: any, field: Field<T>): any;
+    toValueClear?(value: any, field: Field<T>): any;
+}
+declare abstract class BasePlugin<T = any> implements FieldPlugin<T> {
+    pluginOptions: PluginOptions;
+    constructor(pluginOptions?: PluginOptions);
+}
+
+declare class ArrayField<T = any> extends ObservableNode<ArrayFieldSnapshot> {
+    protected factory: (value?: T) => Field<T>;
+    protected captureState(): ArrayFieldSnapshot;
+    protected options: ArrayFieldOptions;
+    protected _items: Field<T>[];
+    protected _errors: string[];
+    protected stateChildren(): readonly ObservableNode<unknown>[];
+    private _baseline;
+    private _hasValidationResult;
+    private _isTouched;
+    get isTouched(): boolean;
+    set isTouched(value: boolean);
+    constructor(factory: (value?: T) => Field<T>, options?: ArrayFieldOptions, initial?: (T | null)[]);
+    get isDirty(): boolean;
+    commitBaseline(): void;
+    set itemsValue(items: (T | null)[]);
+    setItemsValue(items: (T | null)[], validate?: boolean): void;
+    get itemsValue(): (T | null)[];
+    get items(): Field<T>[];
+    add(value?: T, force_check?: boolean): Field<T>;
+    remove(index: number): void;
+    clear(): void;
+    private isRequired;
+    checkValid(form?: Form): boolean;
+    checkAndSetValid(form?: Form): boolean;
+    get isValid(): boolean;
+    get error(): string;
+    set error(message: string | null);
+    get errors(): string[];
+    reset(): void;
+}
+
+declare class ArrayFormField<T extends Form = Form> extends ObservableNode<ArrayFormSnapshot> {
+    private FormConstructor;
+    private options;
+    protected captureState(): ArrayFormSnapshot;
+    private _forms;
+    private _errors;
+    protected stateChildren(): readonly ObservableNode<unknown>[];
+    private _baseline;
+    private _hasValidationResult;
+    private _isTouched;
+    get isTouched(): boolean;
+    set isTouched(value: boolean);
+    constructor(FormConstructor: new () => T, options?: ArrayFormFieldOptions, initial?: unknown[]);
+    get isDirty(): boolean;
+    commitBaseline(): void;
+    set forms(forms: unknown[]);
+    setForms(forms: unknown[], validate?: boolean): void;
+    get forms(): T[];
+    get formsFieldsValue(): FormFieldsValue<T>[];
+    add(data?: unknown, force_check?: boolean): T;
+    remove(index: number): void;
+    clear(): void;
+    reset(): void;
+    private isRequired;
+    checkValid(form?: Form): boolean;
+    checkAndSetValid(form?: Form): boolean;
+    get isValid(): boolean;
+    get errors(): string[];
+    get error(): string;
+    set error(message: string | null);
+}
+
+interface messagesOptions {
+    isRequired?: string;
+    validate?: string;
+    type?: string;
+    invalid?: string;
+}
+interface messagesStringOptions extends messagesOptions {
+    minLength?: string;
+    maxLength?: string;
+    pattern?: string;
+}
+interface messagesNumberOptions extends messagesOptions {
+    gt?: string;
+    ge?: string;
+    lt?: string;
+    le?: string;
+}
+interface messagesBooleanOptions extends messagesOptions {
+    mustBeTrue?: string;
+    mustBeFalse?: string;
+}
+interface messagesDateOptions extends messagesOptions {
+    minDate?: string;
+    maxDate?: string;
+}
+interface messagesDecimalOptions extends messagesOptions {
+    gt?: string;
+    ge?: string;
+    lt?: string;
+    le?: string;
+    decimalPlaces?: string;
+    maxDigits?: string;
+}
+interface messagesArrayFieldOptions extends messagesOptions {
+    minItems?: string;
+    maxItems?: string;
+}
+interface messagesArrayFormFieldOptions extends messagesOptions {
+    minForms?: string;
+    maxForms?: string;
+}
+interface FieldOptions {
+    isRequired?: boolean | ((form?: any) => boolean);
+    messages?: messagesOptions;
+    validate?: (value: any, form?: any) => boolean | string;
+    plugins?: FieldPlugin[];
+}
+interface StringOptions extends FieldOptions {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    messages?: messagesStringOptions;
+}
+interface NumberOptions extends FieldOptions {
+    gt?: number;
+    ge?: number;
+    lt?: number;
+    le?: number;
+    messages?: messagesNumberOptions;
+}
+interface BooleanOptions extends FieldOptions {
+    mustBeTrue?: boolean;
+    mustBeFalse?: boolean;
+    messages?: messagesBooleanOptions;
+}
+interface DateOptions extends FieldOptions {
+    minDate?: Date;
+    maxDate?: Date;
+    isDatetime?: boolean;
+    messages?: messagesDateOptions;
+}
+interface DecimalOptions extends FieldOptions {
+    gt?: number;
+    ge?: number;
+    lt?: number;
+    le?: number;
+    decimalPlaces?: number;
+    maxDigits?: number;
+    messages?: messagesDecimalOptions;
+}
+interface ArrayFieldOptions {
+    isRequired?: boolean | ((form?: any) => boolean);
+    messages?: messagesArrayFieldOptions;
+    validate?: (value: any[], form?: any) => boolean | string;
+    minItems?: number;
+    maxItems?: number;
+}
+interface ArrayFormFieldOptions {
+    isRequired?: boolean | ((form?: any) => boolean);
+    messages?: messagesArrayFormFieldOptions;
+    validate?: (value: any[], form?: any) => boolean | string;
+    minForms?: number;
+    maxForms?: number;
+}
+interface PluginOptions {
+    priority?: number;
+}
+interface MaskPluginOptions {
+    maskFormat: string;
+    maskPlaceholder: string;
+    digitPattern: RegExp;
+}
+
+declare abstract class FieldType<T, O extends FieldOptions = FieldOptions> {
+    options: O;
+    constructor(options: O);
+    abstract cast(rawValue: any): T | null;
+    abstract validate(value: T, form?: Form): string[];
+    abstract getTypeName(): string;
+}
+
+type FieldTypeConstructor<T, O extends FieldOptions = FieldOptions> = new (options: O) => FieldType<T, O>;
+declare class Field<T = any, O extends FieldOptions = FieldOptions> extends ObservableNode<FieldSnapshot> {
+    protected _rawValue: any;
+    protected _valueClear: T | null;
+    protected fieldType: FieldType<T, O>;
+    protected defaultValue: T | null;
+    private _baseline;
+    protected _errors: string[];
+    private _isValid;
+    get isValid(): boolean | null;
+    set isValid(value: boolean | null);
+    private _isTouched;
+    get isTouched(): boolean;
+    set isTouched(value: boolean);
+    constructor(TypeConstructor: FieldTypeConstructor<T, O>, defaultValue?: T | null, options?: O | null);
+    protected captureState(): FieldSnapshot;
+    protected get plugins(): FieldPlugin<any>[];
+    get options(): O;
+    set options(options: O);
+    get rawValue(): T | null;
+    set rawValue(input: any);
+    setRawValue(input: any, validate?: boolean): void;
+    private assignRawValue;
+    get errors(): string[];
+    get error(): string;
+    set error(message: string | null);
+    get valueClear(): T | null;
+    get isDirty(): boolean;
+    commitBaseline(): void;
+    private isRequired;
+    checkValid(form?: Form): boolean;
+    checkAndSetValid(form?: Form): boolean;
+    get isEmpty(): boolean;
+    reset(): void;
+}
+
+type ErrorFieldMapping = string | ((errorValue: any) => string);
+interface ParsedError {
+    fieldName: string;
+    message: string;
+    sourceKey: string;
+    matchedBy: 'static' | 'dynamic' | 'fallback';
+}
+interface DynamicRule {
+    pattern: RegExp;
+    mapping: ErrorFieldMapping | ((match: RegExpMatchArray, value?: any) => string);
+    priority: number;
+}
+declare class ErrorsSchema {
+    private _staticRules;
+    private _dynamicRules;
+    private _fallbackHandler?;
+    private _valueTransformers;
+    /**
+     * Add a static rule that matches an exact error key.
+     * @param errorKey - Exact error key returned by the server.
+     * @param fieldName - Form field name or a function that resolves it dynamically.
+     */
+    staticKey(errorKey: string, fieldName: string | ((errorValue: any) => string)): this;
+    /**
+     * Add a dynamic rule using a regular expression.
+     * @param pattern - Regular expression used to match an error key.
+     * @param mapping - Field name or function that derives it from the match.
+     * @param options - Additional options, such as rule priority.
+     */
+    dynamicKey(pattern: RegExp, mapping: string | ((match: RegExpMatchArray, value?: any) => string), options?: {
+        priority?: number;
+    }): this;
+    /**
+     * Set a handler for errors that do not match any rule.
+     */
+    fallback(handler: (key: string, value: any) => string | null): this;
+    /**
+     * Add a transformer for error values.
+     * Useful for normalizing messages, such as server responses containing arrays.
+     */
+    transformValue(transformer: (value: any) => any): this;
+    /**
+     * Create a schema from a simple mapping object.
+     */
+    static fromObject(mapping: Record<string, string>): ErrorsSchema;
+    /**
+     * Create a schema for an array of similarly structured forms.
+     */
+    static forArray(itemSchema: ErrorsSchema, arrayFieldName: string, indexExtractor?: (key: string) => number): ErrorsSchema;
+    /**
+     * Parse errors while applying configured value transformers.
+     * Supports nested structures using dot notation.
+     */
+    parseErrors(errors: Record<string, any>, prefix?: string): Record<string, string>;
+    /**
+     * Parse server errors and return detailed metadata.
+     */
+    parseErrorsDetailed(errors: Record<string, any>, prefix?: string): Record<string, ParsedError>;
+    /**
+     * Create a schema for a nested form.
+     */
+    nest(prefix: string): ErrorsSchema;
+    /**
+     * Clone the current schema.
+     */
+    clone(): ErrorsSchema;
+    /**
+     * Merge the current schema with another schema.
+     */
+    merge(other: ErrorsSchema): ErrorsSchema;
+    private isNestedObject;
+    private findMappingDetailed;
+    private findMapping;
+}
+/**
+ * Default base schema.
+ */
+declare const DefaultErrorsSchema: ErrorsSchema;
+
+type FormFieldValue<TField> = TField extends Field<infer TValue, infer _Options> ? TValue | null : TField extends ArrayField<infer TValue> ? (TValue | null)[] : TField extends ArrayFormField<infer TForm> ? TForm extends Form ? FormFieldsValue<TForm>[] : unknown[] : never;
+type FormFieldsValue<TForm extends Form> = {
+    [K in keyof TForm as TForm[K] extends Field<infer _Value, infer _Options> | ArrayField<infer _ArrayValue> | ArrayFormField<infer _NestedForm> ? K : never]: FormFieldValue<TForm[K]>;
+};
+declare abstract class Form extends ObservableNode<FormSnapshot> {
+    protected captureState(): FormSnapshot;
+    protected stateChildren(): readonly ObservableNode<unknown>[];
+    batch<TResult>(callback: () => TResult & (TResult extends PromiseLike<unknown> ? never : unknown)): TResult;
+    private _globalErrors;
+    errorsShema: ErrorsSchema;
+    protected get _fields(): Record<string, Field<any> | ArrayField<any> | ArrayFormField<any>>;
+    checkValid(form?: this): boolean;
+    get fieldsValue(): FormFieldsValue<this>;
+    set fields(data: Record<string, unknown>);
+    setFields(data: Record<string, unknown>, validate?: boolean): void;
+    get allErrors(): Record<string, string[]>;
+    /**
+     * Recursively collect all errors from an ArrayFormField.
+     */
+    private collectArrayFormErrors;
+    get globalErrors(): Record<string, string>;
+    set errors(errors: Record<string, unknown>);
+    private clearErrorsRecursively;
+    /**
+     * Apply an error to the corresponding field.
+     * Supports nested fields using dot notation.
+     */
+    private applyErrorToField;
+    private applyNestedError;
+    setGlobalError(key: string, message: string): void;
+    clearGlobalErrors(): void;
+    reset(): void;
+    get isDirty(): boolean;
+    commitBaseline(): void;
+    get isTouched(): boolean;
+    get isValid(): boolean;
+    toFormData(): FormData;
+    toJSON(): Record<string, unknown>;
+    private serializeJsonValue;
+}
+
+export { ArrayField as A, BasePlugin as B, type messagesOptions as C, type DecimalOptions as D, ErrorsSchema as E, Field as F, type messagesStringOptions as G, type MaskPluginOptions as M, type NumberOptions as N, type PluginOptions as P, type StringOptions as S, FieldType as a, type BooleanOptions as b, type DateOptions as c, type ArrayFieldOptions as d, type ArrayFieldSnapshot as e, ArrayFormField as f, type ArrayFormFieldOptions as g, type ArrayFormSnapshot as h, DefaultErrorsSchema as i, type DynamicRule as j, type FieldOptions as k, type FieldPlugin as l, type FieldSnapshot as m, Form as n, type FormFieldValue as o, type FormFieldsValue as p, type FormSnapshot as q, type NodeSnapshot as r, type ParsedError as s, type SnapshotValue as t, type messagesArrayFieldOptions as u, type messagesArrayFormFieldOptions as v, type messagesBooleanOptions as w, type messagesDateOptions as x, type messagesDecimalOptions as y, type messagesNumberOptions as z };