adaptform 2.0.0 → 2.0.2

package/dist/index.cjs

@@ -1,5 +1,529 @@
 'use strict';
 
+// src/core/fields/Field.ts
+var Field = class {
+  constructor(TypeConstructor, defaultValue, options) {
+    this._rawValue = null;
+    this._valueClear = null;
+    this._errors = [];
+    this.isValid = null;
+    this.isTouched = false;
+    this.filed_type = new TypeConstructor(options ?? {});
+    this.defaultValue = defaultValue ?? null;
+    for (const plugin of this.options.plugins ?? []) {
+      plugin.init?.(this);
+    }
+    if (defaultValue !== void 0 && defaultValue !== null) {
+      this.rawValue = defaultValue;
+    } else {
+      this._rawValue = null;
+      this._valueClear = null;
+      this.isValid = null;
+    }
+  }
+  // ========== Геттеры/сеттеры ==========
+  get plugins() {
+    return [...this.options.plugins ?? []].sort((a, b) => {
+      return (a.pluginOptions?.priority ?? 0) - (b.pluginOptions?.priority ?? 0);
+    });
+  }
+  get options() {
+    return this.filed_type.options;
+  }
+  set options(options) {
+    let cur_options = this.filed_type.options;
+    this.filed_type.options = Object.assign(cur_options, options);
+  }
+  get rawValue() {
+    return this._rawValue;
+  }
+  set rawValue(input) {
+    let rawValue = input;
+    for (const plugin of this.plugins) {
+      if (plugin.toRawValue) {
+        rawValue = plugin.toRawValue(rawValue, this);
+      }
+    }
+    let valueClear = rawValue;
+    for (const plugin of this.plugins) {
+      if (plugin.toValueClear) {
+        valueClear = plugin.toValueClear(valueClear, this);
+      }
+    }
+    this._rawValue = rawValue;
+    this._valueClear = this.filed_type.cast(valueClear);
+    this._errors = [];
+    this.isTouched = true;
+    this.checkAndSetValid();
+  }
+  get errors() {
+    return this._errors;
+  }
+  get error() {
+    return this._errors[0] ?? "";
+  }
+  set error(message) {
+    if (message) {
+      this._errors = [message];
+    } else {
+      this._errors = [];
+    }
+    this.isValid = message ? false : null;
+  }
+  get valueClear() {
+    return this._valueClear;
+  }
+  // ========== Валидация ==========
+  isRequired(form) {
+    let isRequired;
+    if (typeof this.options.isRequired === "function") {
+      isRequired = this.options.isRequired(form ?? null);
+    } else {
+      isRequired = this.options.isRequired ?? false;
+    }
+    return isRequired;
+  }
+  checkValid(form) {
+    this._errors = [];
+    if (this.isEmpty) {
+      if (this.isRequired(form)) {
+        this._errors.push(this.options.messages?.isRequired ?? "\u041F\u043E\u043B\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u0434\u043B\u044F \u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044F");
+        return false;
+      }
+      return true;
+    }
+    if (this._valueClear === null) {
+      this._errors.push(
+        this.options.messages?.type ?? `\u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F ${this.filed_type.getTypeName()}`
+      );
+      return false;
+    }
+    const typeErrors = this.filed_type.validate(this._valueClear, form);
+    if (typeErrors.length > 0) {
+      this._errors.push(...typeErrors);
+      return false;
+    }
+    if (this.options.validate) {
+      const result = this.options.validate(this._valueClear, form);
+      if (result === false) {
+        this._errors.push(this.options.messages?.validate ?? "\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u043D\u0435 \u043F\u0440\u043E\u0448\u043B\u043E \u0432\u0430\u043B\u0438\u0434\u0430\u0446\u0438\u044E");
+        return false;
+      }
+      if (typeof result === "string") {
+        this._errors.push(result);
+        return false;
+      }
+    }
+    return true;
+  }
+  checkAndSetValid(form) {
+    this.isValid = this.checkValid(form);
+    return this.isValid;
+  }
+  get isEmpty() {
+    let isEmpty = false;
+    if (this._rawValue === null || this._rawValue === void 0) isEmpty = true;
+    else if (this._rawValue === "") isEmpty = true;
+    else if (Array.isArray(this._rawValue) && this._rawValue.length === 0) isEmpty = true;
+    return isEmpty;
+  }
+  // ========== Вспомогательные методы ==========
+  reset() {
+    if (this.defaultValue !== null && this.defaultValue !== void 0) {
+      this.rawValue = this.defaultValue;
+      this.isValid = true;
+    } else {
+      this._rawValue = null;
+      this._valueClear = null;
+      this.isValid = null;
+    }
+    this._errors = [];
+    this.isTouched = false;
+  }
+};
+
+// src/core/fields/ArrayField.ts
+var ArrayField = class {
+  constructor(factory, options = {}, initial = []) {
+    this.factory = factory;
+    this._items = [];
+    this._errors = [];
+    this.isTouched = false;
+    this.options = {
+      isRequired: true,
+      messages: {},
+      ...options
+    };
+    this._items = initial.map((v) => this.factory(v));
+  }
+  // ===== value =====
+  set itemsValue(items) {
+    this.clear();
+    for (const i of items) {
+      this.add(i, false);
+    }
+    this.checkValid();
+  }
+  get itemsValue() {
+    return this._items.map((i) => i.valueClear);
+  }
+  get items() {
+    return this._items;
+  }
+  // ===== actions =====
+  add(value, force_check) {
+    const field = this.factory(value);
+    this.isTouched = true;
+    this._items.push(field);
+    if (force_check) this.checkValid();
+    return field;
+  }
+  remove(index) {
+    this._items.splice(index, 1);
+    this.checkValid();
+  }
+  clear() {
+    this._items = [];
+    this.checkValid();
+  }
+  // ===== validation =====
+  isRequired(form) {
+    let isRequired;
+    if (typeof this.options.isRequired === "function") {
+      isRequired = this.options.isRequired(form ?? null);
+    } else {
+      isRequired = this.options.isRequired ?? false;
+    }
+    return isRequired;
+  }
+  checkValid(form) {
+    this._errors = [];
+    if (this.isRequired(form) && this._items.length === 0) {
+      this._errors.push(
+        this.options.messages?.isRequired ?? "\u0414\u043E\u0431\u0430\u0432\u044C\u0442\u0435 \u0445\u043E\u0442\u044F \u0431\u044B \u043E\u0434\u0438\u043D \u044D\u043B\u0435\u043C\u0435\u043D\u0442"
+      );
+      return false;
+    }
+    if (this.options.minItems != null && this._items.length < this.options.minItems) {
+      this._errors.push(
+        this.options.messages?.minItems ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 ${this.options.minItems}`
+      );
+      return false;
+    }
+    if (this.options.maxItems != null && this._items.length > this.options.maxItems) {
+      this._errors.push(
+        this.options.messages?.maxItems ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${this.options.maxItems}`
+      );
+      return false;
+    }
+    let valid = true;
+    for (const field of this._items) {
+      const ok = field.checkAndSetValid(form);
+      if (!ok) valid = false;
+    }
+    if (this.options.validate) {
+      const result = this.options.validate(this._items, 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"
+        );
+        return false;
+      }
+      if (typeof result === "string") {
+        this._errors.push(result);
+        return false;
+      }
+    }
+    return valid && this._errors.length === 0;
+  }
+  checkAndSetValid(form) {
+    return this.checkValid(form);
+  }
+  get isValid() {
+    return this._errors.length === 0 && this._items.every((i) => i.isValid === true);
+  }
+  get error() {
+    return this._errors[0] ?? "";
+  }
+  set error(message) {
+    if (message) {
+      this._errors = [message];
+    } else {
+      this._errors = [];
+    }
+  }
+  get errors() {
+    return this._errors;
+  }
+  reset() {
+    this._items.forEach((i) => i.reset());
+    this._errors = [];
+    this.isTouched = false;
+  }
+};
+
+// src/core/fields/ArrayFormField.ts
+var ArrayFormField = class {
+  constructor(FormConstructor, options = {}, initial = []) {
+    this.FormConstructor = FormConstructor;
+    this.options = options;
+    this._forms = [];
+    this._errors = [];
+    this.isTouched = false;
+    this._forms = initial.map((data) => {
+      const form = new this.FormConstructor();
+      form.fields = data;
+      return form;
+    });
+  }
+  // ===== value =====
+  set forms(forms) {
+    this.clear();
+    for (const f of forms) {
+      this.add(f, false);
+    }
+    this.checkValid();
+  }
+  get forms() {
+    return this._forms;
+  }
+  get formsFieldsValue() {
+    return this._forms.map((i) => i.fieldsValue);
+  }
+  // ===== actions =====
+  add(data, force_check) {
+    const form = new this.FormConstructor();
+    if (data) form.fields = data;
+    this.isTouched = true;
+    this._forms.push(form);
+    if (force_check) this.checkValid();
+    return form;
+  }
+  remove(index) {
+    this._forms.splice(index, 1);
+    this.checkValid();
+  }
+  clear() {
+    this._forms = [];
+    this.checkValid();
+  }
+  reset() {
+    this._forms.forEach((f) => f.reset());
+    this._errors = [];
+    this.isTouched = false;
+  }
+  // ===== validation =====
+  isRequired(form) {
+    let isRequired;
+    if (typeof this.options.isRequired === "function") {
+      isRequired = this.options.isRequired(form ?? null);
+    } else {
+      isRequired = this.options.isRequired ?? false;
+    }
+    return isRequired;
+  }
+  checkValid(form) {
+    this._errors = [];
+    if (this.isRequired(form) && this.forms.length === 0) {
+      this._errors.push(
+        this.options.messages?.isRequired ?? "\u0414\u043E\u0431\u0430\u0432\u044C\u0442\u0435 \u0445\u043E\u0442\u044F \u0431\u044B \u043E\u0434\u0438\u043D \u044D\u043B\u0435\u043C\u0435\u043D\u0442"
+      );
+      return false;
+    }
+    if (this.options.minForms != null && this._forms.length < this.options.minForms) {
+      this._errors.push(
+        this.options.messages?.minForms ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 ${this.options.minForms}`
+      );
+      return false;
+    }
+    if (this.options.maxForms != null && this._forms.length > this.options.maxForms) {
+      this._errors.push(
+        this.options.messages?.maxForms ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${this.options.maxForms}`
+      );
+      return false;
+    }
+    let valid = true;
+    for (const form2 of this.forms) {
+      const ok = form2.checkValid(form2);
+      if (!ok) valid = false;
+    }
+    if (this.options.validate) {
+      const result = this.options.validate(this.forms, 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"
+        );
+        return false;
+      }
+      if (typeof result === "string") {
+        this._errors.push(result);
+        return false;
+      }
+    }
+    return valid && this._errors.length === 0;
+  }
+  checkAndSetValid(form) {
+    return this.checkValid(form);
+  }
+  get isValid() {
+    return this._errors.length === 0 && this._forms.every((i) => i.checkValid() === true);
+  }
+  get errors() {
+    return this._errors;
+  }
+  get error() {
+    return this._errors[0] ?? "";
+  }
+  set error(message) {
+    if (message) {
+      this._errors = [message];
+    } else {
+      this._errors = [];
+    }
+  }
+};
+
+// src/core/Form.ts
+var Form = class {
+  constructor() {
+    this._globalErrors = {};
+  }
+  get _fields() {
+    const fields = {};
+    for (const key of Object.keys(this)) {
+      const property = this[key];
+      if (property instanceof Field || property instanceof ArrayField || property instanceof ArrayFormField) {
+        fields[key] = property;
+      }
+    }
+    return fields;
+  }
+  checkValid(form) {
+    let isFormValid = true;
+    const fields = this._fields;
+    for (const key of Object.keys(fields)) {
+      const field = fields[key];
+      if (!field.checkAndSetValid(form ?? this)) {
+        isFormValid = false;
+      }
+    }
+    return isFormValid;
+  }
+  get fieldsValue() {
+    const data = {};
+    const fields = this._fields;
+    for (const key of Object.keys(fields)) {
+      let valueClear = null;
+      const field = fields[key];
+      if (field instanceof Field) valueClear = field.valueClear;
+      else if (field instanceof ArrayField) valueClear = field.itemsValue;
+      else if (field instanceof ArrayFormField) valueClear = field.formsFieldsValue;
+      else console.error(`Invalid field "${key}" type`);
+      data[key] = valueClear;
+    }
+    return data;
+  }
+  set fields(data) {
+    const fields = this._fields;
+    for (const key of Object.keys(data)) {
+      const field = fields[key];
+      if (field) {
+        if (field instanceof Field) field.rawValue = data[key];
+        else if (field instanceof ArrayField) field.itemsValue = data[key];
+        else if (field instanceof ArrayFormField) field.forms = data[key];
+        else console.error(`Invalid field "${key}" type`);
+      }
+    }
+  }
+  get allErrors() {
+    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;
+      }
+    }
+    for (const key of Object.keys(this._globalErrors)) {
+      if (!errors[key]) {
+        errors[key] = [];
+      }
+      errors[key].push(this._globalErrors[key]);
+    }
+    return errors;
+  }
+  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];
+      } else {
+        this._globalErrors[key] = errors[key];
+      }
+    }
+  }
+  setGlobalError(key, message) {
+    this._globalErrors[key] = message;
+  }
+  clearGlobalErrors() {
+    this._globalErrors = {};
+  }
+  reset() {
+    const fields = this._fields;
+    for (const key of Object.keys(fields)) {
+      fields[key].reset();
+    }
+    this._globalErrors = {};
+  }
+  get isTouched() {
+    const fields = this._fields;
+    for (const key of Object.keys(fields)) {
+      if (fields[key].isTouched) return true;
+    }
+    return false;
+  }
+  // Проверить, валидна ли форма
+  get isValid() {
+    const fields = this._fields;
+    for (const key of Object.keys(fields)) {
+      if (fields[key].isValid !== true) return false;
+    }
+    return Object.keys(this._globalErrors).length === 0;
+  }
+  // Получить все значения в виде FormData (для отправки на сервер)
+  toFormData() {
+    const formData = new FormData();
+    const data = this.fieldsValue;
+    for (const [key, value] of Object.entries(data)) {
+      if (value instanceof Date) {
+        formData.append(key, value.toISOString());
+      } else if (value !== null && value !== void 0) {
+        formData.append(key, String(value));
+      }
+    }
+    return formData;
+  }
+  // Получить все значения в виде JSON
+  toJSON() {
+    const data = this.fieldsValue;
+    const json = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (value instanceof Date) {
+        json[key] = value.toISOString();
+      } else {
+        json[key] = value;
+      }
+    }
+    return json;
+  }
+};
+
 // src/core/plugins/FieldPlugin.ts
 var BasePlugin = class {
   constructor(pluginOptions = {}) {
@@ -10,6 +534,188 @@ var BasePlugin = class {
   }
 };
 
+// src/core/plugins/MaskPlugin.ts
+var MaskPlugin = class extends BasePlugin {
+  constructor(config, pluginOptions) {
+    super(pluginOptions);
+    this.maskParts = [];
+    this.config = config;
+  }
+  init(field) {
+    this.parseMask();
+  }
+  toRawValue(value, field) {
+    return this.applyMask(value);
+  }
+  toValueClear(value, field) {
+    return this.removeMask(value);
+  }
+  parseMask() {
+    this.maskParts = [];
+    let i = 0;
+    let escaped = false;
+    while (i < this.config.maskFormat.length) {
+      const char = this.config.maskFormat[i];
+      if (char === "/" && !escaped) {
+        escaped = true;
+        i++;
+        continue;
+      }
+      if (char === this.config.maskPlaceholder && i + 1 < this.config.maskFormat.length && this.config.maskFormat[i + 1] === "{" && !escaped) {
+        const openBracket = i + 1;
+        const closeBracket = this.config.maskFormat.indexOf("}", openBracket);
+        if (closeBracket !== -1 && closeBracket > openBracket + 1) {
+          const configString = this.config.maskFormat.substring(openBracket + 1, closeBracket).trim();
+          if (configString.includes(">")) {
+            const parts = configString.split(">");
+            const allowedChars = parts[0].trim();
+            const replacementOnMatch = parts[1]?.trim() || "";
+            let replacementOnMismatch = parts[2]?.trim() || "";
+            let pushToNext = false;
+            if (parts.length > 2 && parts[2] === "" && parts[3] !== void 0) {
+              pushToNext = true;
+              replacementOnMismatch = parts[3]?.trim() || "";
+            } else if (replacementOnMismatch === "" && parts.length > 3) {
+              pushToNext = true;
+              replacementOnMismatch = parts[3]?.trim() || "";
+            }
+            this.maskParts.push({
+              char: replacementOnMatch || this.config.maskPlaceholder,
+              isPlaceholder: true,
+              isEscaped: escaped,
+              allowedChars,
+              transformOnMatch: replacementOnMatch,
+              transformOnMismatch: replacementOnMismatch,
+              defaultValue: replacementOnMatch,
+              pushToNext
+            });
+          } else {
+            this.maskParts.push({
+              char: configString,
+              isPlaceholder: true,
+              isEscaped: escaped,
+              replacementValue: configString,
+              defaultValue: configString
+            });
+          }
+          escaped = false;
+          i = closeBracket + 1;
+          continue;
+        }
+      }
+      const isPlaceholder = char === this.config.maskPlaceholder;
+      this.maskParts.push({
+        char,
+        isPlaceholder,
+        isEscaped: escaped
+      });
+      escaped = false;
+      i++;
+    }
+  }
+  applyMask(value) {
+    if (typeof value !== "string" || !value) return "";
+    let result = "";
+    let inputIndex = 0;
+    for (let maskIndex = 0; maskIndex < this.maskParts.length; maskIndex++) {
+      const part = this.maskParts[maskIndex];
+      if (inputIndex >= value.length) {
+        if (part.replacementValue) {
+          result += part.replacementValue;
+          continue;
+        }
+        if (part.transformOnMatch) {
+          result += part.transformOnMatch;
+          continue;
+        }
+        break;
+      }
+      const inputChar = value[inputIndex];
+      if (part.isPlaceholder) {
+        if (part.replacementValue) {
+          result += part.replacementValue;
+          inputIndex++;
+        } else if (part.allowedChars) {
+          if (part.allowedChars.includes(inputChar)) {
+            result += part.transformOnMatch || inputChar;
+            inputIndex++;
+          } else if (part.pushToNext) {
+            result += part.transformOnMismatch || this.config.maskPlaceholder;
+          } else if (part.transformOnMismatch !== void 0) {
+            result += part.transformOnMismatch || this.config.maskPlaceholder;
+            inputIndex++;
+          } else {
+            result += this.config.maskPlaceholder;
+          }
+        } else {
+          if (this.config.digitPattern.test(inputChar)) {
+            result += inputChar;
+            inputIndex++;
+          } else if (inputChar === this.config.maskPlaceholder) {
+            result += this.config.maskPlaceholder;
+            inputIndex++;
+          } else {
+            inputIndex++;
+            maskIndex--;
+          }
+        }
+      } else {
+        if (inputChar === part.char) {
+          result += part.char;
+          inputIndex++;
+        } else if (this.config.digitPattern.test(inputChar)) {
+          result += part.char;
+        } else {
+          result += part.char;
+        }
+      }
+    }
+    return result;
+  }
+  removeMask(value) {
+    if (typeof value !== "string" || !value) return "";
+    let result = "";
+    let inputIndex = 0;
+    for (let maskIndex = 0; maskIndex < this.maskParts.length; maskIndex++) {
+      const part = this.maskParts[maskIndex];
+      if (inputIndex >= value.length) {
+        if (part.replacementValue) {
+          result += part.replacementValue;
+        } else if (part.transformOnMatch) {
+          result += part.transformOnMatch;
+        }
+        continue;
+      }
+      const inputChar = value[inputIndex];
+      if (part.isPlaceholder) {
+        if (part.replacementValue) {
+          result += part.replacementValue;
+        } else if (part.allowedChars) {
+          if (part.allowedChars.includes(inputChar)) {
+            result += part.transformOnMatch || inputChar;
+          } else if (part.pushToNext) {
+            result += part.transformOnMismatch || "";
+            continue;
+          } else {
+            result += part.transformOnMatch || "";
+          }
+        } else {
+          if (inputChar !== this.config.maskPlaceholder && this.config.digitPattern.test(inputChar)) {
+            result += inputChar;
+          }
+        }
+        inputIndex++;
+      } else if (part.isEscaped) {
+        result += part.char;
+        if (inputChar === part.char) inputIndex++;
+      } else {
+        if (inputChar === part.char) inputIndex++;
+      }
+    }
+    return result;
+  }
+};
+
 // src/core/types/FieldType.ts
 var FieldType = class {
   constructor(options) {
@@ -21,6 +727,197 @@ var FieldType = class {
   }
 };
 
+// src/core/types/StringType.ts
+var StringType = class extends FieldType {
+  cast(rawValue) {
+    if (rawValue === null || rawValue === void 0) return null;
+    if (typeof rawValue === "string") return rawValue;
+    return String(rawValue);
+  }
+  validate(value) {
+    const errors = [];
+    if (this.options.minLength != null && value.length < this.options.minLength) {
+      errors.push(
+        this.options.messages?.minLength ?? `\u041C\u0438\u043D\u0438\u043C\u0430\u043B\u044C\u043D\u0430\u044F \u0434\u043B\u0438\u043D\u0430 ${this.options.minLength} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432`
+      );
+    }
+    if (this.options.maxLength != null && value.length > this.options.maxLength) {
+      errors.push(
+        this.options.messages?.maxLength ?? `\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u0430\u044F \u0434\u043B\u0438\u043D\u0430 ${this.options.maxLength} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432`
+      );
+    }
+    if (this.options.pattern != null && !this.options.pattern.test(value)) {
+      errors.push(this.options.messages?.pattern ?? "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442");
+    }
+    return errors;
+  }
+  getTypeName() {
+    return "\u0441\u0442\u0440\u043E\u043A\u0430";
+  }
+};
+
+// src/core/types/NumberType.ts
+var NumberType = class extends FieldType {
+  cast(rawValue) {
+    if (rawValue === null || rawValue === void 0) return null;
+    if (typeof rawValue === "number" && !isNaN(rawValue)) return rawValue;
+    if (typeof rawValue === "string") {
+      const num = Number(rawValue);
+      return isNaN(num) ? null : num;
+    }
+    return null;
+  }
+  validate(value) {
+    const errors = [];
+    if (!Number.isInteger(value)) {
+      errors.push(this.options.messages?.invalid ?? "\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u0446\u0435\u043B\u044B\u043C \u0447\u0438\u0441\u043B\u043E\u043C");
+    }
+    if (this.options.gt != null && value <= this.options.gt) {
+      errors.push(
+        this.options.messages?.gt ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u0431\u043E\u043B\u044C\u0448\u0435 ${this.options.gt}`
+      );
+    }
+    if (this.options.ge != null && value < this.options.ge) {
+      errors.push(
+        this.options.messages?.ge ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u0435\u0435 ${this.options.ge}`
+      );
+    }
+    if (this.options.lt != null && value >= this.options.lt) {
+      errors.push(
+        this.options.messages?.lt ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043C\u0435\u043D\u044C\u0448\u0435 ${this.options.lt}`
+      );
+    }
+    if (this.options.le != null && value > this.options.le) {
+      errors.push(
+        this.options.messages?.le ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u0431\u043E\u043B\u0435\u0435 ${this.options.le}`
+      );
+    }
+    return errors;
+  }
+  getTypeName() {
+    return "\u0447\u0438\u0441\u043B\u043E";
+  }
+};
+
+// src/core/types/DecimalType.ts
+var DecimalType = class extends FieldType {
+  constructor(options = {}) {
+    super({
+      decimalPlaces: 2,
+      maxDigits: 8,
+      ...options
+    });
+  }
+  cast(rawValue) {
+    if (rawValue === null || rawValue === void 0) return null;
+    if (typeof rawValue === "string") {
+      return this.castString(rawValue);
+    }
+    if (typeof rawValue === "number" && !isNaN(rawValue)) {
+      return rawValue;
+    }
+    return null;
+  }
+  castString(value) {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    const normalized = trimmed.replace(",", ".");
+    if (!this.isValidNumberString(normalized)) {
+      return null;
+    }
+    return normalized;
+  }
+  validate(value) {
+    const errors = [];
+    value = typeof value === "number" ? this.numberToString(value) : value;
+    if (!this.isValidNumberString(value)) {
+      errors.push(this.options.messages?.invalid ?? "\u041F\u0440\u0438\u043C\u0435\u0440: 1.00");
+      return errors;
+    }
+    const maxDigits = this.options.maxDigits || 8;
+    const decimalPlaces = this.options.decimalPlaces || 2;
+    const maxIntDigits = maxDigits - decimalPlaces;
+    const isNegative = value.startsWith("-");
+    const normalizedValue = isNegative ? value.substring(1) : value;
+    const parts = normalizedValue.split(".");
+    const intPart = parts[0];
+    const decPart = parts.length > 1 ? parts[1] : "";
+    if (normalizedValue.endsWith(".")) {
+      if (intPart.length > maxIntDigits) {
+        errors.push(
+          this.options.messages?.maxDigits ?? `\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u043E\u0435 \u043A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0437\u043D\u0430\u043A\u043E\u0432 \u043F\u0435\u0440\u0435\u0434 \u0437\u0430\u043F\u044F\u0442\u043E\u0439 ${maxIntDigits}`
+        );
+      }
+      return errors;
+    }
+    if (intPart.length === 0) {
+      errors.push(this.options.messages?.invalid ?? "\u041F\u0440\u0438\u043C\u0435\u0440: 1.00");
+      return errors;
+    }
+    if (intPart.length > maxIntDigits) {
+      errors.push(
+        this.options.messages?.maxDigits ?? `\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u043E\u0435 \u043A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0437\u043D\u0430\u043A\u043E\u0432 \u043F\u0435\u0440\u0435\u0434 \u0437\u0430\u043F\u044F\u0442\u043E\u0439 ${maxIntDigits}`
+      );
+    }
+    if (parts.length === 2) {
+      if (intPart.length + decPart.length > maxDigits) {
+        errors.push(
+          this.options.messages?.maxDigits ?? `\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u043E\u0435 \u043A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0437\u043D\u0430\u043A\u043E\u0432 ${maxDigits}`
+        );
+      }
+      if (decPart.length === 0) {
+        errors.push(
+          this.options.messages?.invalid ?? "\u041F\u043E\u0441\u043B\u0435 \u0442\u043E\u0447\u043A\u0438 \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043C\u0438\u043D\u0438\u043C\u0443\u043C 1 \u0437\u043D\u0430\u043A"
+        );
+      } else if (decPart.length > decimalPlaces) {
+        errors.push(
+          this.options.messages?.decimalPlaces ?? `\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u043E\u0435 \u043A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0437\u043D\u0430\u043A\u043E\u0432 \u043F\u043E\u0441\u043B\u0435 \u0437\u0430\u043F\u044F\u0442\u043E\u0439 ${decimalPlaces}`
+        );
+      }
+    }
+    if (errors.length > 0) return errors;
+    if (!value.endsWith(".")) {
+      const numValue = parseFloat(value);
+      if (!isNaN(numValue)) {
+        if (this.options.gt != null && numValue <= this.options.gt) {
+          errors.push(
+            this.options.messages?.gt ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u0431\u043E\u043B\u044C\u0448\u0435 ${this.options.gt}`
+          );
+        }
+        if (this.options.ge != null && numValue < this.options.ge) {
+          errors.push(
+            this.options.messages?.ge ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u0435\u0435 ${this.options.ge}`
+          );
+        }
+        if (this.options.lt != null && numValue >= this.options.lt) {
+          errors.push(
+            this.options.messages?.lt ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043C\u0435\u043D\u044C\u0448\u0435 ${this.options.lt}`
+          );
+        }
+        if (this.options.le != null && numValue > this.options.le) {
+          errors.push(
+            this.options.messages?.le ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u0431\u043E\u043B\u0435\u0435 ${this.options.le}`
+          );
+        }
+      }
+    }
+    return errors;
+  }
+  isValidNumberString(value) {
+    const pattern = /^-?\d+\.?\d*$/;
+    const dotCount = (value.match(/\./g) || []).length;
+    if (dotCount > 1) return false;
+    return pattern.test(value);
+  }
+  numberToString(value) {
+    const decimalPlaces = this.options.decimalPlaces;
+    return value.toFixed(decimalPlaces);
+  }
+  getTypeName() {
+    return "\u0434\u0435\u0441\u044F\u0442\u0438\u0447\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E";
+  }
+};
+
 // src/core/types/BooleanType.ts
 var BooleanType = class extends FieldType {
   cast(rawValue) {
@@ -51,14 +948,78 @@ var BooleanType = class extends FieldType {
   }
 };
 
+// src/core/types/DateType.ts
+var DateType = class extends FieldType {
+  constructor(options = {}) {
+    super(options);
+  }
+  cast(rawValue) {
+    if (rawValue === null || rawValue === void 0) return null;
+    if (rawValue instanceof Date) {
+      return isNaN(rawValue.getTime()) ? null : rawValue;
+    }
+    if (typeof rawValue === "string") {
+      const date = new Date(rawValue);
+      return isNaN(date.getTime()) ? null : date;
+    }
+    return null;
+  }
+  validate(value) {
+    const errors = [];
+    if (isNaN(value.getTime())) {
+      errors.push(this.options.messages?.invalid ?? "\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0434\u0430\u0442\u0430");
+      return errors;
+    }
+    if (this.options.minDate) {
+      if (!this.compareDates(value, this.options.minDate, "min")) {
+        errors.push(
+          this.options.messages?.minDate ?? `\u0414\u0430\u0442\u0430 \u0434\u043E\u043B\u0436\u043D\u0430 \u0431\u044B\u0442\u044C \u043D\u0435 \u0440\u0430\u043D\u0435\u0435 ${this.options.minDate.toLocaleDateString()}`
+        );
+      }
+    }
+    if (this.options.maxDate) {
+      if (!this.compareDates(value, this.options.maxDate, "max")) {
+        errors.push(
+          this.options.messages?.maxDate ?? `\u0414\u0430\u0442\u0430 \u0434\u043E\u043B\u0436\u043D\u0430 \u0431\u044B\u0442\u044C \u043D\u0435 \u043F\u043E\u0437\u0434\u043D\u0435\u0435 ${this.options.maxDate.toLocaleDateString()}`
+        );
+      }
+    }
+    return errors;
+  }
+  getTypeName() {
+    return this.options.isDatetime ? "\u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F" : "\u0434\u0430\u0442\u0430";
+  }
+  // Сравнение дат с учётом времени
+  compareDates(value, boundary, type) {
+    if (this.options.isDatetime) {
+      if (type === "min") {
+        return value >= boundary;
+      } else {
+        return value <= boundary;
+      }
+    } else {
+      const valueDate = this.toDateOnly(value);
+      const boundaryDate = this.toDateOnly(boundary);
+      if (type === "min") {
+        return valueDate >= boundaryDate;
+      } else {
+        return valueDate <= boundaryDate;
+      }
+    }
+  }
+  toDateOnly(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  }
+};
+
 // src/core/utils/luxon-loader.ts
-var DateTime = null;
+var DateTimeConstructor = null;
 var isLoading = false;
 var loadError = null;
 var loadPromise = null;
-function getDateTime() {
-  if (DateTime) {
-    return DateTime;
+function getDateTimeConstructor() {
+  if (DateTimeConstructor) {
+    return DateTimeConstructor;
   }
   if (loadError) {
     throw loadError;
@@ -69,12 +1030,12 @@ function getDateTime() {
     );
   }
   throw new Error(
-    "Luxon is not initialized. Call initLuxon() first or install: npm install luxon"
+    "Luxon is not initialized. Install: npm install luxon"
   );
 }
 function initLuxon() {
-  if (DateTime) {
-    return Promise.resolve(DateTime);
+  if (DateTimeConstructor) {
+    return Promise.resolve(DateTimeConstructor);
   }
   if (loadPromise) {
     return loadPromise;
@@ -83,11 +1044,11 @@ function initLuxon() {
   loadPromise = (async () => {
     try {
       const luxon = await import('luxon');
-      DateTime = luxon.DateTime;
-      return DateTime;
+      DateTimeConstructor = luxon.DateTime;
+      return DateTimeConstructor;
     } catch (error) {
       loadError = new Error(
-        'DateLuxonType requires the "luxon" package to be installed.\nPlease install it by running:\n\n  npm install luxon\n  # or\n  yarn add luxon\n  # or\n  pnpm add luxon\n'
+        'DateLuxonType requires the "luxon" package to be installed.\nInstall: npm install luxon'
       );
       throw loadError;
     } finally {
@@ -97,10 +1058,10 @@ function initLuxon() {
   return loadPromise;
 }
 function isLuxonAvailable() {
-  return DateTime !== null;
+  return DateTimeConstructor !== null;
 }
 function resetLuxon() {
-  DateTime = null;
+  DateTimeConstructor = null;
   isLoading = false;
   loadError = null;
   loadPromise = null;
@@ -108,9 +1069,19 @@ function resetLuxon() {
 initLuxon().catch(() => {
 });
 
+exports.ArrayField = ArrayField;
+exports.ArrayFormField = ArrayFormField;
 exports.BasePlugin = BasePlugin;
 exports.BooleanType = BooleanType;
-exports.getDateTime = getDateTime;
+exports.DateType = DateType;
+exports.DecimalType = DecimalType;
+exports.Field = Field;
+exports.FieldType = FieldType;
+exports.Form = Form;
+exports.MaskPlugin = MaskPlugin;
+exports.NumberType = NumberType;
+exports.StringType = StringType;
+exports.getDateTimeConstructor = getDateTimeConstructor;
 exports.initLuxon = initLuxon;
 exports.isLuxonAvailable = isLuxonAvailable;
 exports.resetLuxon = resetLuxon;