adaptform 2.0.4 → 2.0.5

package/dist/index.mjs

@@ -6,7 +6,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);
@@ -26,11 +26,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;
@@ -49,7 +49,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();
@@ -92,11 +92,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;
@@ -129,7 +129,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;
@@ -153,6 +152,7 @@ var ArrayField = class {
       ...options
     };
     this._items = initial.map((v) => this.factory(v));
+    this.checkValid();
   }
   // ===== value =====
   set itemsValue(items) {
@@ -220,7 +220,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"
@@ -238,7 +239,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] ?? "";
@@ -273,6 +275,7 @@ var ArrayFormField = class {
       form.fields = data;
       return form;
     });
+    this.checkValid();
   }
   // ===== value =====
   set forms(forms) {
@@ -364,7 +367,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;
@@ -381,10 +385,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 = {};
@@ -437,9 +686,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)) {
@@ -450,20 +707,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) {