adaptform 2.0.3 → 2.0.5

package/dist/{Form-DOdrOtbT.d.ts → Form-Be3I6LX0.d.ts}

@@ -170,7 +170,7 @@ type FieldTypeConstructor<T, O extends FieldOptions = FieldOptions> = new (optio
 declare class Field<T = any, O extends FieldOptions = FieldOptions> {
     protected _rawValue: any;
     protected _valueClear: T | null;
-    protected filed_type: FieldType<T, O>;
+    protected fieldType: FieldType<T, O>;
     protected defaultValue: T | null;
     protected _errors: string[];
     isValid: boolean | null;
@@ -192,15 +192,95 @@ declare class Field<T = any, O extends FieldOptions = FieldOptions> {
     reset(): void;
 }
 
+interface ParsedError {
+    fieldName: string;
+    message: string;
+    sourceKey: string;
+    matchedBy: 'static' | 'dynamic' | 'fallback';
+}
+declare class ErrorsSchema {
+    private _staticRules;
+    private _dynamicRules;
+    private _fallbackHandler?;
+    private _valueTransformers;
+    /**
+     * Добавляет статическое правило - точное соответствие ключа ошибки
+     * @param errorKey - точный ключ ошибки из ответа сервера
+     * @param fieldName - имя поля в форме или функция для динамического определения
+     */
+    staticKey(errorKey: string, fieldName: string | ((errorValue: any) => string)): this;
+    /**
+     * Добавляет динамическое правило с регулярным выражением
+     * @param pattern - регулярное выражение для сопоставления ключа ошибки
+     * @param mapping - имя поля или функция для извлечения имени поля из совпадения
+     * @param options - дополнительные опции (приоритет и т.д.)
+     */
+    dynamicKey(pattern: RegExp, mapping: string | ((match: RegExpMatchArray) => string), options?: {
+        priority?: number;
+    }): this;
+    /**
+     * Устанавливает обработчик для ошибок, которые не подошли ни под одно правило
+     */
+    fallback(handler: (key: string, value: any) => string | null): this;
+    /**
+     * Добавляет трансформер для значений ошибок
+     * Полезно для нормализации сообщений (например, если сервер возвращает массив ошибок)
+     */
+    transformValue(transformer: (value: any) => any): this;
+    /**
+     * Быстрый метод для создания схемы из простого объекта маппинга
+     */
+    static fromObject(mapping: Record<string, string>): ErrorsSchema;
+    /**
+     * Создает схему для массива однотипных форм
+     */
+    static forArray(itemSchema: ErrorsSchema, arrayFieldName: string, indexExtractor?: (key: string) => number): ErrorsSchema;
+    /**
+     * Основной метод парсинга ошибок с поддержкой трансформеров
+     * Поддерживает вложенные структуры через точечную нотацию
+     */
+    parseErrors(errors: Record<string, any>, prefix?: string): Record<string, string>;
+    /**
+     * Парсит ошибки сервера и возвращает расширенную информацию
+     */
+    parseErrorsDetailed(errors: Record<string, any>, prefix?: string): Record<string, ParsedError>;
+    /**
+     * Создает схему для вложенной формы
+     */
+    nest(prefix: string): ErrorsSchema;
+    /**
+     * Клонирует текущую схему
+     */
+    clone(): ErrorsSchema;
+    /**
+     * Объединяет текущую схему с другой
+     */
+    merge(other: ErrorsSchema): ErrorsSchema;
+    private isNestedObject;
+    private findMappingDetailed;
+    private findMapping;
+}
+
 declare abstract class Form {
     private _globalErrors;
+    errorsShema: ErrorsSchema;
     protected get _fields(): Record<string, Field<any> | ArrayField<any> | ArrayFormField<any>>;
     checkValid(form?: this): boolean;
     get fieldsValue(): Record<string, any>;
     set fields(data: Record<string, any>);
     get allErrors(): Record<string, string[]>;
+    /**
+     * Рекурсивно собирает все ошибки из ArrayFormField
+     */
+    private collectArrayFormErrors;
     get globalErrors(): Record<string, string>;
-    set errors(errors: Record<string, string>);
+    set errors(errors: Record<string, any>);
+    /**
+     * Применяет ошибку к соответствующему полю
+     * Поддерживает вложенные поля через точечную нотацию
+     */
+    private applyErrorToField;
+    private applyNestedError;
     setGlobalError(key: string, message: string): void;
     clearGlobalErrors(): void;
     reset(): void;
@@ -210,4 +290,4 @@ declare abstract class Form {
     toJSON(): Record<string, any>;
 }
 
-export { type ArrayFieldOptions as A, BasePlugin as B, type DecimalOptions as D, Field as F, 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, Form as d, type messagesStringOptions as e, type messagesNumberOptions as f, type messagesBooleanOptions as g, type messagesDateOptions as h, type messagesDecimalOptions as i, type messagesArrayFieldOptions as j, type messagesArrayFormFieldOptions as k, type FieldOptions as l, type messagesOptions as m, type ArrayFormFieldOptions as n, ArrayField as o, ArrayFormField as p, type FieldPlugin as q };
+export { ArrayField as A, BasePlugin as B, type DecimalOptions as D, Field as F, 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, ArrayFormField as e, type ArrayFormFieldOptions as f, type FieldOptions as g, type FieldPlugin as h, Form as i, type messagesArrayFormFieldOptions as j, type messagesBooleanOptions as k, type messagesDateOptions as l, type messagesArrayFieldOptions as m, type messagesDecimalOptions as n, type messagesNumberOptions as o, type messagesOptions as p, type messagesStringOptions as q };

package/dist/index.cjs

@@ -8,7 +8,7 @@ var Field = class {
     this._errors = [];
     this.isValid = null;
     this.isTouched = false;
-    this.filed_type = new TypeConstructor(options ?? {});
+    this.fieldType = new TypeConstructor(options ?? {});
     this.defaultValue = defaultValue ?? null;
     for (const plugin of this.options.plugins ?? []) {
       plugin.init?.(this);
@@ -28,11 +28,11 @@ var Field = class {
     });
   }
   get options() {
-    return this.filed_type.options;
+    return this.fieldType.options;
   }
   set options(options) {
-    let cur_options = this.filed_type.options;
-    this.filed_type.options = Object.assign(cur_options, options);
+    let cur_options = this.fieldType.options;
+    this.fieldType.options = Object.assign(cur_options, options);
   }
   get rawValue() {
     return this._rawValue;
@@ -51,7 +51,7 @@ var Field = class {
       }
     }
     this._rawValue = rawValue;
-    this._valueClear = this.filed_type.cast(valueClear);
+    this._valueClear = this.fieldType.cast(valueClear);
     this._errors = [];
     this.isTouched = true;
     this.checkAndSetValid();
@@ -94,11 +94,11 @@ var Field = class {
     }
     if (this._valueClear === null) {
       this._errors.push(
-        this.options.messages?.type ?? `\u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F ${this.filed_type.getTypeName()}`
+        this.options.messages?.type ?? `\u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F ${this.fieldType.getTypeName()}`
       );
       return false;
     }
-    const typeErrors = this.filed_type.validate(this._valueClear, form);
+    const typeErrors = this.fieldType.validate(this._valueClear, form);
     if (typeErrors.length > 0) {
       this._errors.push(...typeErrors);
       return false;
@@ -131,7 +131,6 @@ var Field = class {
   reset() {
     if (this.defaultValue !== null && this.defaultValue !== void 0) {
       this.rawValue = this.defaultValue;
-      this.isValid = true;
     } else {
       this._rawValue = null;
       this._valueClear = null;
@@ -155,6 +154,7 @@ var ArrayField = class {
       ...options
     };
     this._items = initial.map((v) => this.factory(v));
+    this.checkValid();
   }
   // ===== value =====
   set itemsValue(items) {
@@ -222,7 +222,8 @@ var ArrayField = class {
       if (!ok) valid = false;
     }
     if (this.options.validate) {
-      const result = this.options.validate(this._items, form);
+      const values = this._items.map((i) => i.valueClear);
+      const result = this.options.validate(values, form);
       if (result === false) {
         this._errors.push(
           this.options.messages?.validate ?? "\u041E\u0448\u0438\u0431\u043A\u0430 \u0432\u0430\u043B\u0438\u0434\u0430\u0446\u0438\u0438"
@@ -240,7 +241,8 @@ var ArrayField = class {
     return this.checkValid(form);
   }
   get isValid() {
-    return this._errors.length === 0 && this._items.every((i) => i.isValid === true);
+    if (this._errors.length > 0) return false;
+    return this._items.every((i) => i.isValid === true);
   }
   get error() {
     return this._errors[0] ?? "";
@@ -275,6 +277,7 @@ var ArrayFormField = class {
       form.fields = data;
       return form;
     });
+    this.checkValid();
   }
   // ===== value =====
   set forms(forms) {
@@ -366,7 +369,8 @@ var ArrayFormField = class {
     return this.checkValid(form);
   }
   get isValid() {
-    return this._errors.length === 0 && this._forms.every((i) => i.checkValid() === true);
+    if (this._errors.length > 0) return false;
+    return this._forms.every((i) => i.checkValid() === true);
   }
   get errors() {
     return this._errors;
@@ -383,10 +387,255 @@ var ArrayFormField = class {
   }
 };
 
+// src/core/ErrorsShema.ts
+var ErrorsSchema = class _ErrorsSchema {
+  constructor() {
+    this._staticRules = /* @__PURE__ */ new Map();
+    this._dynamicRules = [];
+    this._valueTransformers = [];
+  }
+  /**
+   * Добавляет статическое правило - точное соответствие ключа ошибки
+   * @param errorKey - точный ключ ошибки из ответа сервера
+   * @param fieldName - имя поля в форме или функция для динамического определения
+   */
+  staticKey(errorKey, fieldName) {
+    this._staticRules.set(errorKey, fieldName);
+    return this;
+  }
+  /**
+   * Добавляет динамическое правило с регулярным выражением
+   * @param pattern - регулярное выражение для сопоставления ключа ошибки
+   * @param mapping - имя поля или функция для извлечения имени поля из совпадения
+   * @param options - дополнительные опции (приоритет и т.д.)
+   */
+  dynamicKey(pattern, mapping, options) {
+    this._dynamicRules.push({
+      pattern,
+      mapping,
+      priority: options?.priority ?? 0
+    });
+    this._dynamicRules.sort((a, b) => b.priority - a.priority);
+    return this;
+  }
+  /**
+   * Устанавливает обработчик для ошибок, которые не подошли ни под одно правило
+   */
+  fallback(handler) {
+    this._fallbackHandler = handler;
+    return this;
+  }
+  /**
+   * Добавляет трансформер для значений ошибок
+   * Полезно для нормализации сообщений (например, если сервер возвращает массив ошибок)
+   */
+  transformValue(transformer) {
+    this._valueTransformers.push(transformer);
+    return this;
+  }
+  /**
+   * Быстрый метод для создания схемы из простого объекта маппинга
+   */
+  static fromObject(mapping) {
+    const schema = new _ErrorsSchema();
+    for (const [errorKey, fieldName] of Object.entries(mapping)) {
+      schema.staticKey(errorKey, fieldName);
+    }
+    return schema;
+  }
+  /**
+   * Создает схему для массива однотипных форм
+   */
+  static forArray(itemSchema, arrayFieldName, indexExtractor) {
+    const schema = new _ErrorsSchema();
+    schema.dynamicKey(
+      new RegExp(`^${arrayFieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\[(\\d+)\\]\\.(.+)$`),
+      (match) => {
+        const index = match[1];
+        const fieldName = match[2];
+        return `${arrayFieldName}.${index}.${fieldName}`;
+      },
+      { priority: 100 }
+    );
+    return schema;
+  }
+  /**
+   * Основной метод парсинга ошибок с поддержкой трансформеров
+   * Поддерживает вложенные структуры через точечную нотацию
+   */
+  parseErrors(errors, prefix = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(errors)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (this.isNestedObject(value)) {
+        const nestedErrors = this.parseErrors(value, fullKey);
+        Object.assign(result, nestedErrors);
+        continue;
+      }
+      if (value === null || value === void 0) {
+        continue;
+      }
+      let transformedValue = value;
+      for (const transformer of this._valueTransformers) {
+        transformedValue = transformer(transformedValue);
+      }
+      const mapping = this.findMapping(fullKey, transformedValue);
+      if (mapping) {
+        if (typeof mapping === "function") {
+          const fieldName = mapping(transformedValue);
+          if (fieldName) {
+            result[fieldName] = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
+          }
+        } else {
+          result[mapping] = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
+        }
+      } else if (this._fallbackHandler) {
+        const fieldName = this._fallbackHandler(fullKey, transformedValue);
+        if (fieldName) {
+          result[fieldName] = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Парсит ошибки сервера и возвращает расширенную информацию
+   */
+  parseErrorsDetailed(errors, prefix = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(errors)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (this.isNestedObject(value)) {
+        const nestedErrors = this.parseErrorsDetailed(value, fullKey);
+        Object.assign(result, nestedErrors);
+        continue;
+      }
+      if (value === null || value === void 0) {
+        continue;
+      }
+      let transformedValue = value;
+      for (const transformer of this._valueTransformers) {
+        transformedValue = transformer(transformedValue);
+      }
+      const matchResult = this.findMappingDetailed(fullKey, transformedValue);
+      if (matchResult) {
+        const message = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
+        result[matchResult.fieldName] = {
+          fieldName: matchResult.fieldName,
+          message,
+          sourceKey: fullKey,
+          matchedBy: matchResult.matchedBy
+        };
+      }
+    }
+    return result;
+  }
+  /**
+   * Создает схему для вложенной формы
+   */
+  nest(prefix) {
+    const nestedSchema = new _ErrorsSchema();
+    for (const [key, mapping] of this._staticRules.entries()) {
+      nestedSchema.staticKey(`${prefix}.${key}`, mapping);
+    }
+    for (const rule of this._dynamicRules) {
+      const newPattern = new RegExp(`^${prefix}\\.${rule.pattern.source.replace(/^\^/, "")}`);
+      nestedSchema.dynamicKey(newPattern, rule.mapping, { priority: rule.priority });
+    }
+    for (const transformer of this._valueTransformers) {
+      nestedSchema.transformValue(transformer);
+    }
+    if (this._fallbackHandler) {
+      nestedSchema.fallback((key, value) => {
+        if (key.startsWith(`${prefix}.`)) {
+          return this._fallbackHandler(key.slice(prefix.length + 1), value);
+        }
+        return null;
+      });
+    }
+    return nestedSchema;
+  }
+  /**
+   * Клонирует текущую схему
+   */
+  clone() {
+    const cloned = new _ErrorsSchema();
+    for (const [key, mapping] of this._staticRules.entries()) {
+      cloned._staticRules.set(key, mapping);
+    }
+    for (const rule of this._dynamicRules) {
+      cloned._dynamicRules.push({ ...rule });
+    }
+    cloned._fallbackHandler = this._fallbackHandler;
+    cloned._valueTransformers = [...this._valueTransformers];
+    return cloned;
+  }
+  /**
+   * Объединяет текущую схему с другой
+   */
+  merge(other) {
+    const merged = this.clone();
+    for (const [key, mapping] of other._staticRules.entries()) {
+      merged._staticRules.set(key, mapping);
+    }
+    merged._dynamicRules.push(...other._dynamicRules);
+    merged._dynamicRules.sort((a, b) => b.priority - a.priority);
+    merged._valueTransformers.push(...other._valueTransformers);
+    if (other._fallbackHandler) {
+      merged._fallbackHandler = other._fallbackHandler;
+    }
+    return merged;
+  }
+  isNestedObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+  }
+  findMappingDetailed(key, value) {
+    if (this._staticRules.has(key)) {
+      const mapping = this._staticRules.get(key);
+      const fieldName = typeof mapping === "function" ? mapping(value) : mapping;
+      return fieldName ? { fieldName, matchedBy: "static" } : null;
+    }
+    for (const rule of this._dynamicRules) {
+      const match = key.match(rule.pattern);
+      if (match) {
+        const fieldName = typeof rule.mapping === "function" ? rule.mapping(match) : rule.mapping;
+        return fieldName ? { fieldName, matchedBy: "dynamic" } : null;
+      }
+    }
+    if (this._fallbackHandler) {
+      const fieldName = this._fallbackHandler(key, value);
+      return fieldName ? { fieldName, matchedBy: "fallback" } : null;
+    }
+    return null;
+  }
+  findMapping(key, value) {
+    if (this._staticRules.has(key)) {
+      return this._staticRules.get(key);
+    }
+    for (const rule of this._dynamicRules) {
+      const match = key.match(rule.pattern);
+      if (match) {
+        if (typeof rule.mapping === "function") {
+          const fieldName = rule.mapping(match);
+          return fieldName;
+        }
+        return rule.mapping;
+      }
+    }
+    if (this._fallbackHandler) {
+      const fieldName = this._fallbackHandler(key, value);
+      return fieldName;
+    }
+    return null;
+  }
+};
+var DefaultErrorsSchema = new ErrorsSchema().fallback((key) => key);
+
 // src/core/Form.ts
 var Form = class {
   constructor() {
     this._globalErrors = {};
+    this.errorsShema = DefaultErrorsSchema;
   }
   get _fields() {
     const fields = {};
@@ -439,9 +688,17 @@ var Form = class {
     const errors = {};
     const fields = this._fields;
     for (const key of Object.keys(fields)) {
-      const fieldErrors = fields[key].errors;
-      if (fieldErrors.length > 0) {
-        errors[key] = fieldErrors;
+      const field = fields[key];
+      if (field instanceof ArrayFormField) {
+        const formErrors = this.collectArrayFormErrors(field);
+        if (formErrors.length > 0) {
+          errors[key] = formErrors;
+        }
+      } else {
+        const fieldErrors = field.errors;
+        if (fieldErrors.length > 0) {
+          errors[key] = fieldErrors;
+        }
       }
     }
     for (const key of Object.keys(this._globalErrors)) {
@@ -452,20 +709,84 @@ var Form = class {
     }
     return errors;
   }
+  /**
+   * Рекурсивно собирает все ошибки из ArrayFormField
+   */
+  collectArrayFormErrors(arrayField) {
+    const allErrors = [];
+    allErrors.push(...arrayField.errors);
+    for (let i = 0; i < arrayField.forms.length; i++) {
+      const form = arrayField.forms[i];
+      const formAllErrors = form.allErrors;
+      for (const [fieldName, fieldErrors] of Object.entries(formAllErrors)) {
+        for (const error of fieldErrors) {
+          allErrors.push(`\u0424\u043E\u0440\u043C\u0430 ${i + 1}, ${fieldName}: ${error}`);
+        }
+      }
+    }
+    return allErrors;
+  }
   get globalErrors() {
     return { ...this._globalErrors };
   }
   set errors(errors) {
     const fields = this._fields;
     this._globalErrors = {};
-    for (const key of Object.keys(errors)) {
-      const keys = key.split(".");
-      const cleanKey = keys.length > 1 ? keys[1] : key;
-      if (cleanKey in fields && fields[cleanKey]) {
-        fields[cleanKey].error = errors[key];
+    for (const key of Object.keys(fields)) {
+      fields[key].error = null;
+    }
+    const parsedErrors = this.errorsShema.parseErrors(errors);
+    for (const [fieldName, errorMessage] of Object.entries(parsedErrors)) {
+      this.applyErrorToField(fieldName, errorMessage, fields, this);
+    }
+  }
+  /**
+   * Применяет ошибку к соответствующему полю
+   * Поддерживает вложенные поля через точечную нотацию
+   */
+  applyErrorToField(fieldPath, errorMessage, fields, targetForm) {
+    if (!targetForm) {
+      console.error("applyErrorToField: targetForm is undefined");
+      return;
+    }
+    if (fieldPath in fields && fields[fieldPath]) {
+      fields[fieldPath].error = errorMessage;
+      return;
+    }
+    const parts = fieldPath.split(".");
+    const rootField = parts[0];
+    if (rootField in fields && fields[rootField]) {
+      const field = fields[rootField];
+      if (parts.length === 1) {
+        field.error = errorMessage;
+      } else if (parts.length > 1) {
+        this.applyNestedError(field, parts.slice(1), errorMessage, fieldPath, targetForm);
+      }
+    } else {
+      targetForm.setGlobalError(fieldPath, errorMessage);
+    }
+  }
+  applyNestedError(field, pathParts, errorMessage, fullPath, targetForm) {
+    if (!targetForm) {
+      console.error("applyNestedError: targetForm is undefined");
+      return;
+    }
+    const [currentPart, ...remainingParts] = pathParts;
+    if (field instanceof ArrayFormField) {
+      const index = parseInt(currentPart);
+      if (!isNaN(index) && index >= 0 && index < field.forms.length) {
+        const form = field.forms[index];
+        if (remainingParts.length > 0) {
+          const formFields = form["_fields"];
+          this.applyErrorToField(remainingParts.join("."), errorMessage, formFields, form);
+        } else {
+          form.setGlobalError(`index_${index}`, errorMessage);
+        }
       } else {
-        this._globalErrors[key] = errors[key];
+        targetForm.setGlobalError(fullPath, errorMessage);
       }
+    } else {
+      targetForm.setGlobalError(fullPath, errorMessage);
     }
   }
   setGlobalError(key, message) {