@websolutespa/bom-mixer-forms 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1080 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/forms/event-emitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.events_ = {};
+  }
+  on(event, listener) {
+    if (typeof this.events_[event] !== "object") {
+      this.events_[event] = [];
+    }
+    this.events_[event].push(listener);
+  }
+  off(event, listener) {
+    if (typeof this.events_[event] === "object") {
+      const index = this.events_[event].indexOf(listener);
+      if (index > -1) {
+        this.events_[event].splice(index, 1);
+      }
+    } else {
+      throw new Error(`Can't remove a listener. Event "${event}" doesn't exits.`);
+    }
+  }
+  emit(event, ...args) {
+    if (typeof this.events_[event] === "object") {
+      this.events_[event].forEach((listener) => listener.apply(this, args));
+    }
+  }
+  once(event, listener) {
+    const onceListener = (...args) => {
+      this.off(event, onceListener);
+      listener.apply(this, args);
+    };
+    this.on(event, onceListener);
+  }
+};
+
+// src/forms/utils.ts
+function validValue(value) {
+  return value !== void 0 && value !== "" ? value : null;
+}
+function isThenable(result) {
+  return result && typeof result.then === "function";
+}
+function mapErrors_(errors) {
+  return Object.keys(errors).map((key) => ({ key, value: errors[key] }));
+}
+function deepCopy(source) {
+  if (Array.isArray(source)) {
+    return source.map((x) => deepCopy(x));
+  } else if (source && typeof source === "object") {
+    const copy = {};
+    Object.keys(source).forEach((key) => {
+      copy[key] = deepCopy(source[key]);
+    });
+    return copy;
+  } else {
+    return source;
+  }
+}
+function valueToString(value) {
+  function mapValue(value2) {
+    const stringValue = value2 != null ? typeof value2 === "object" ? value2.id.toString() : value2.toString() : void 0;
+    return stringValue;
+  }
+  function mapValues(values) {
+    const strings = values.map((x) => mapValue(x)).filter((x) => x !== void 0);
+    return strings.length ? strings : void 0;
+  }
+  return Array.isArray(value) ? mapValues(value) : mapValue(value);
+}
+function stringToValue(value, options, optionsExtra) {
+  function findValue(value2) {
+    const option = options == null ? void 0 : options.find((x) => x.id.toString() === value2);
+    return option ? (optionsExtra == null ? void 0 : optionsExtra.asEquatable) ? option.id : option : null;
+  }
+  function mapValue(value2) {
+    return value2 !== void 0 ? findValue(value2) : null;
+  }
+  function mapValues(values) {
+    const mappedValues = values.map((x) => mapValue(x)).filter((x) => x !== null);
+    return mappedValues.length ? mappedValues : null;
+  }
+  return Array.isArray(value) ? mapValues(value) : mapValue(value);
+}
+
+// src/forms/form-abstract.ts
+var FormAbstract = class extends EventEmitter {
+  constructor(value, validators) {
+    super();
+    // new
+    this.schema = "text";
+    this.markAsDirty_ = false;
+    this.errors_ = {};
+    this.value_ = validValue(value);
+    this.validators_ = validators ? Array.isArray(validators) ? validators : [validators] : [];
+    this.state_ = {
+      invalid: false,
+      disabled: false,
+      hidden: false,
+      readonly: false,
+      dirty: false,
+      touched: false,
+      submitted: false,
+      // derived
+      valid: true,
+      enabled: true,
+      visible: true,
+      writeable: true,
+      pristine: true,
+      untouched: true,
+      unsubmitted: true
+    };
+  }
+  setInitialOptions(options) {
+    this.initialOptions_ = options;
+    if (options) {
+      if (options.schema) {
+        this.schema = options.schema;
+      }
+      if (options.name) {
+        this.name = options.name;
+      }
+      if (options.label) {
+        this.label = options.label;
+      }
+      if (options.placeholder) {
+        this.placeholder = options.placeholder;
+      }
+      if (options.options) {
+        this.options = options.options;
+      }
+      if (options.optionsExtra) {
+        this.optionsExtra = options.optionsExtra;
+      }
+      if (options.disabled === true || typeof options.disabled === "function") {
+        this.state_.disabled = true;
+      }
+      if (options.readonly === true || typeof options.readonly === "function") {
+        this.state_.readonly = true;
+      }
+      if (options.hidden === true || typeof options.hidden === "function") {
+        this.state_.hidden = true;
+      }
+    }
+  }
+  checkAsyncState_(root) {
+    return __async(this, null, function* () {
+      const options = this.initialOptions_;
+      let dirty = false;
+      if (options) {
+        const disabledDirty = yield this.checkAsyncPropState_("disabled", options.disabled, root);
+        const hiddenDirty = yield this.checkAsyncPropState_("hidden", options.hidden, root);
+        const readonlyDirty = yield this.checkAsyncPropState_("readonly", options.readonly, root);
+        dirty = disabledDirty || hiddenDirty || readonlyDirty;
+      }
+      return dirty;
+    });
+  }
+  checkAsyncPropState_(key, option, root) {
+    return __async(this, null, function* () {
+      let dirty = false;
+      if (typeof option === "function") {
+        let result = option(this.value_, root == null ? void 0 : root.value, this, root);
+        result = isThenable(result) ? yield result : result;
+        if (this.state_[key] !== result) {
+          this.state_[key] = result;
+          dirty = true;
+        }
+      }
+      return dirty;
+    });
+  }
+  revalidate_() {
+    return __async(this, null, function* () {
+      if (this.parent) {
+        return yield this.parent.revalidate_();
+      }
+      yield this.validateAndChange_();
+    });
+  }
+  validate_(root) {
+    return __async(this, null, function* () {
+      let markAsDirty_ = yield this.checkAsyncState_(root);
+      let errors = {};
+      if (this.validators.length === 0 || this.disabled || this.submitted) {
+        this.state_.invalid = false;
+      } else {
+        const validations = this.validators_.map((x) => x(this.value_, root == null ? void 0 : root.value, this, root)).filter((x) => x);
+        const { results, promises } = validations.reduce((p, c) => {
+          isThenable(c) ? p.promises.push(c) : p.results.push(c);
+          return p;
+        }, { results: [], promises: [] });
+        promises.forEach((x) => x.then((result) => {
+          if (result) {
+            this.state_.invalid = true;
+            this.errors_ = Object.assign(this.errors_, result);
+            this.markAsDirty_ = true;
+            this.updateState_();
+            this.change_(true);
+          }
+        }).catch((error) => {
+          console.warn("Validation.async.error", error);
+        }));
+        this.state_.invalid = results.length > 0;
+        errors = Object.assign(errors, ...results);
+      }
+      markAsDirty_ = markAsDirty_ || Object.keys(this.errors_).join(",") !== Object.keys(errors).join(",");
+      this.errors_ = errors;
+      this.markAsDirty_ = markAsDirty_;
+      this.updateState_();
+    });
+  }
+  validateAndChange_(root) {
+    return __async(this, null, function* () {
+      yield this.validate_(root);
+      this.markAsDirty_ = true;
+      this.change_();
+    });
+  }
+  updateStateAndChange_() {
+    return __async(this, null, function* () {
+      this.updateState_();
+      this.markAsDirty_ = true;
+      this.change_();
+    });
+  }
+  change_(propagate = false) {
+    if (!this.markAsDirty_) {
+      return;
+    }
+    this.markAsDirty_ = false;
+    this.emit("change", this.value);
+    if (propagate && this.parent) {
+      this.parent.markAsDirty_ = true;
+      this.parent.change_.call(this.parent);
+    }
+  }
+  updateState_() {
+    const state = this.state_;
+    state.dirty = this.value_ != null;
+    state.valid = !state.invalid;
+    state.enabled = !state.disabled;
+    state.visible = !state.hidden;
+    state.writeable = !state.disabled && !state.readonly;
+    state.pristine = !state.dirty;
+    state.untouched = !state.touched;
+    state.unsubmitted = !state.submitted;
+  }
+  /*
+  set changes$(changes) {
+    this.changes$_ = changes;
+  }
+  */
+  /*
+   bind(callback) {
+     const index = this.callbacks_.indexOf(callback);
+     if (index === -1) {
+       this.callbacks_.push(callback);
+       this.revalidate_();
+     }
+   }
+   unbind(callback) {
+     const index = this.callbacks_.indexOf(callback);
+     if (index !== -1) {
+       this.callbacks_.splice(index, 1);
+     }
+   }
+   once(callback) {
+     const this_ = this;
+     function once() {
+       callback();
+       this_.unbind(once);
+     }
+     this.bind(once);
+   }
+   bindControl(control) {
+     const index = this.binds_.indexOf(control);
+     if (index === -1) {
+       this.binds_.push(control);
+     }
+   }
+   unbindControl(control) {
+     const index = this.binds_.indexOf(control);
+     if (index !== -1) {
+       this.binds_.splice(index, 1);
+     }
+   }
+   */
+  reset() {
+    this.value_ = null;
+    const state = this.state_;
+    state.dirty = false;
+    state.touched = false;
+    state.submitted = false;
+    this.revalidate_();
+  }
+  patch(value) {
+    this.value = value;
+  }
+  addValidators(...validators) {
+    this.validators.push(...validators);
+    this.revalidate_();
+  }
+  replaceValidators(...validators) {
+    this.validators = validators;
+  }
+  clearValidators() {
+    this.validators = [];
+  }
+  // getter & setter
+  get path() {
+    if (this.name != null) {
+      return this.parent ? [...this.parent.path, this.name] : [this.name];
+    } else {
+      return [];
+    }
+  }
+  get root() {
+    let parent = this;
+    while (parent.parent) {
+      parent = parent.parent;
+    }
+    return parent;
+  }
+  get label() {
+    var _a;
+    return this.label_ || ((_a = this.name) == null ? void 0 : _a.toString()) || "";
+  }
+  set label(label) {
+    this.label_ = label;
+  }
+  get placeholder() {
+    return this.placeholder_ || this.label || "";
+  }
+  set placeholder(placeholder) {
+    this.placeholder_ = placeholder;
+  }
+  get validators() {
+    return this.validators_;
+  }
+  set validators(validators) {
+    if (this.validators_ !== validators) {
+      this.validators_ = validators;
+      this.revalidate_();
+    }
+  }
+  get state() {
+    return this.state_;
+  }
+  get errors() {
+    return this.errors_;
+  }
+  get invalid() {
+    return this.state_.invalid;
+  }
+  get disabled() {
+    return this.state_.disabled;
+  }
+  // internal disabled type boolean | () => boolean | Promise<boolean>
+  set disabled(disabled) {
+    if (this.state_.disabled !== disabled) {
+      this.state_.disabled = disabled;
+      this.revalidate_();
+    }
+  }
+  get hidden() {
+    return this.state_.hidden;
+  }
+  set hidden(hidden) {
+    if (this.state_.hidden !== hidden) {
+      this.state_.hidden = hidden;
+      this.revalidate_();
+    }
+  }
+  get readonly() {
+    return this.state_.readonly;
+  }
+  set readonly(readonly) {
+    if (this.state_.readonly !== readonly) {
+      this.state_.readonly = readonly;
+      this.revalidate_();
+    }
+  }
+  get dirty() {
+    return this.state_.dirty;
+  }
+  set dirty(dirty) {
+    if (this.state_.dirty !== dirty) {
+      this.state_.dirty = dirty;
+      this.updateStateAndChange_();
+    }
+  }
+  get touched() {
+    return this.state_.touched;
+  }
+  set touched(touched) {
+    if (this.state_.touched !== touched) {
+      this.state_.touched = touched;
+      this.updateStateAndChange_();
+    }
+  }
+  get submitted() {
+    return this.state_.submitted;
+  }
+  set submitted(submitted) {
+    if (this.state_.submitted !== submitted) {
+      this.state_.submitted = submitted;
+      this.updateStateAndChange_();
+    }
+  }
+  get valid() {
+    return this.state_.valid;
+  }
+  get enabled() {
+    return this.state_.enabled;
+  }
+  get visible() {
+    return this.state_.visible;
+  }
+  get writeable() {
+    return this.state_.writeable;
+  }
+  get pristine() {
+    return this.state_.pristine;
+  }
+  get untouched() {
+    return this.state_.untouched;
+  }
+  get unsubmitted() {
+    return this.state_.unsubmitted;
+  }
+  get value() {
+    return this.value_;
+  }
+  set value(value) {
+    value = validValue(value);
+    if (this.value_ !== value) {
+      this.value_ = value;
+      this.state_.submitted = false;
+      this.revalidate_();
+    }
+  }
+  /*
+  set invalid(invalid) {
+    if (this.state_.invalid !== invalid) {
+      this.state_.invalid = invalid;
+      this.revalidate_();
+    }
+  }
+  */
+};
+
+// src/forms/form-control.ts
+var FormControl = class extends FormAbstract {
+  constructor(value = null, validators, initialOptions) {
+    super(value, validators);
+    this.setInitialOptions(initialOptions);
+  }
+};
+function formControl(value = null, validators) {
+  return new FormControl(value, validators);
+}
+
+// src/forms/form-abstract-collection.ts
+var FormAbstractCollection = class extends FormAbstract {
+  constructor(controls, validators) {
+    super(null, validators);
+    this.controls_ = controls;
+    this.forEach_((control, key) => {
+      this.controls_[key] = this.initControl_(control, key);
+    });
+  }
+  initControl_(controlOrValue, key) {
+    const control = controlOrValue instanceof FormAbstract ? controlOrValue : new FormControl(controlOrValue);
+    control.name = key;
+    control.parent = this;
+    control.validators.push(...this.validators);
+    return control;
+  }
+  setInitialOptions(options) {
+    this.initialOptions_ = options;
+    if (options) {
+      if (options.schema) {
+        this.schema = options.schema;
+      }
+      if (options.name) {
+        this.name = options.name;
+      }
+      if (options.label) {
+        this.label = options.label;
+      }
+      if (options.placeholder) {
+        this.placeholder = options.placeholder;
+      }
+      if (options.options) {
+        this.options = options.options;
+      }
+      if (options.optionsExtra) {
+        this.optionsExtra = options.optionsExtra;
+      }
+      if (options.disabled === true || typeof options.disabled === "function") {
+        this.forEach_((control) => {
+          control.state_.disabled = true;
+        });
+      }
+      if (options.readonly === true || typeof options.readonly === "function") {
+        this.forEach_((control) => {
+          control.state_.readonly = true;
+        });
+      }
+      if (options.hidden === true || typeof options.hidden === "function") {
+        this.forEach_((control) => {
+          control.state_.hidden = true;
+        });
+      }
+    }
+    this.updateState_();
+  }
+  checkAsyncPropState_(key, option, root) {
+    return __async(this, null, function* () {
+      let dirty = false;
+      if (typeof option === "function") {
+        let result = option(this.value_, root == null ? void 0 : root.value, this, root);
+        result = isThenable(result) ? yield result : result;
+        this.forEach_((control) => {
+          if (control.state_[key] !== result) {
+            control.state_[key] = result;
+            dirty = true;
+          }
+        });
+      }
+      return dirty;
+    });
+  }
+  updateState_() {
+    const state = this.state_;
+    let invalid = false;
+    let disabled = true;
+    let hidden = true;
+    let readonly = true;
+    let dirty = false;
+    let touched = true;
+    let submitted = true;
+    this.forEach_((control) => {
+      invalid = invalid || control.invalid;
+      disabled = disabled && control.disabled;
+      hidden = hidden && control.hidden;
+      readonly = readonly && control.readonly;
+      dirty = dirty || control.dirty;
+      touched = touched && control.touched;
+      submitted = submitted && control.submitted;
+    });
+    state.invalid = invalid;
+    state.disabled = disabled;
+    state.hidden = hidden;
+    state.readonly = readonly;
+    state.dirty = dirty;
+    state.touched = touched;
+    state.submitted = submitted;
+    state.valid = !invalid;
+    state.enabled = !disabled;
+    state.visible = !hidden;
+    state.writeable = !disabled && !readonly;
+    state.pristine = !dirty;
+    state.untouched = !touched;
+  }
+  revalidate_() {
+    return __async(this, null, function* () {
+      if (this.parent) {
+        return yield this.parent.revalidate_();
+      }
+      yield this.validateAndChange_(this);
+    });
+  }
+  validate_(root) {
+    return __async(this, null, function* () {
+      yield this.checkAsyncState_(root);
+      const validations = this.map_().map((x) => x.validateAndChange_(root));
+      yield Promise.all(validations);
+      this.updateState_();
+    });
+  }
+  reset() {
+    this.forEach_((control) => control.reset());
+  }
+  patch(value) {
+    if (value) {
+      this.forEach_((control, key) => {
+        if (value[key] != null) {
+          control.patch(value[key]);
+        }
+      });
+    }
+  }
+  get(key) {
+    const controls = this.controls;
+    return controls[key];
+  }
+  set(control, key) {
+    const controls = this.controls;
+    delete controls[key];
+    controls[key] = this.initControl_(control, key);
+  }
+  // !!! needed?
+  add(control, key) {
+    const controls = this.controls;
+    controls[key] = this.initControl_(control, key);
+  }
+  remove(control) {
+    this.forEach_((c, k) => {
+      if (c === control) {
+        this.removeKey(k);
+      }
+    });
+  }
+  /*
+  remove(control: FormAbstract): void {
+    const key = Object.keys(this.controls_).find((key: keyof T) => (this.controls_[key] === control ? key : null));
+    if (key) {
+      this.removeKey(key);
+    }
+  }
+  */
+  removeKey(key) {
+    const exhist = this.controls[key] !== void 0;
+    delete this.controls_[key];
+  }
+  addValidators(...validators) {
+    this.forEach_((control) => control.addValidators(...validators));
+  }
+  replaceValidators(...validators) {
+    this.forEach_((control) => control.replaceValidators(...validators));
+  }
+  clearValidators() {
+    this.forEach_((control) => control.clearValidators());
+  }
+  forEach_(callback) {
+    const controls = this.controls;
+    Object.keys(controls).forEach((key) => callback(controls[key], key));
+  }
+  reduce_(callback, result) {
+    this.forEach_((control, key) => {
+      result = callback(result, control, key);
+    });
+    return result;
+  }
+  all_(key, value) {
+    return this.reduce_((result, control) => {
+      return result && control[key] === value;
+    }, true);
+  }
+  any_(key, value) {
+    return this.reduce_((result, control) => {
+      return result || control[key] === value;
+    }, false);
+  }
+  map_() {
+    const controls = this.controls;
+    return Object.keys(controls).map((key) => controls[key]);
+  }
+  // getter & setter
+  get controls() {
+    return this.controls_;
+  }
+  set controls(controls) {
+    if (this.controls_ !== controls) {
+      this.controls_ = controls;
+      this.revalidate_();
+    }
+  }
+  set disabled(disabled) {
+    this.forEach_((control) => {
+      control.disabled = disabled;
+    });
+  }
+  set readonly(readonly) {
+    this.forEach_((control) => {
+      control.readonly = readonly;
+    });
+  }
+  set hidden(hidden) {
+    this.forEach_((control) => {
+      control.hidden = hidden;
+    });
+  }
+  set submitted(submitted) {
+    this.forEach_((control) => {
+      control.submitted = submitted;
+    });
+  }
+  set touched(touched) {
+    this.forEach_((control) => {
+      control.touched = touched;
+    });
+  }
+  get value() {
+    return this.reduce_((result, control, key) => {
+      if (control.enabled) {
+        result[key] = control.value;
+      }
+      return result;
+    }, {});
+  }
+  set value(value) {
+    this.forEach_((control, key) => {
+      control.value = value[key];
+    });
+  }
+  get errors() {
+    return this.reduce_((result, control) => {
+      return Object.assign(result, control.errors);
+    }, {});
+  }
+  set errors(errors) {
+  }
+};
+
+// src/forms/form-array.ts
+var FormArray = class extends FormAbstractCollection {
+  constructor(controls = [], validators, initialOptions) {
+    super(controls, validators);
+    this.setInitialOptions(initialOptions);
+  }
+  forEach_(callback) {
+    this.controls.forEach((control, key) => callback(control, key));
+  }
+  map_() {
+    return this.controls;
+  }
+  get value() {
+    return this.reduce_((result, control, key) => {
+      result[key] = control.value;
+      return result;
+    }, []);
+  }
+  get length() {
+    return this.controls.length;
+  }
+  init(control, key) {
+    this.controls.length = Math.max(this.controls.length, key);
+    this.controls[key] = this.initControl_(control, key);
+  }
+  set(control, key) {
+    this.controls.splice(key, 1, this.initControl_(control, key));
+  }
+  add(control, key) {
+    this.controls.length = Math.max(this.controls.length, key);
+    this.controls[key] = this.initControl_(control, key);
+  }
+  push(control) {
+    this.controls.push(this.initControl_(control, this.controls.length));
+  }
+  insert(control, key) {
+    this.controls.splice(key, 0, this.initControl_(control, key));
+  }
+  remove(control) {
+    const key = this.controls.indexOf(control);
+    if (key !== -1) {
+      this.removeKey(key);
+    }
+  }
+  removeKey(key) {
+    if (this.controls.length > key) {
+      this.controls.splice(key, 1);
+    }
+  }
+  at(key) {
+    return this.controls[key];
+  }
+};
+function formArray(controls = [], validators) {
+  return new FormArray(controls, validators);
+}
+
+// src/forms/form-group.ts
+var FormGroup = class extends FormAbstractCollection {
+  constructor(controls = {}, validators, initialOptions) {
+    super(controls, validators);
+    this.setInitialOptions(initialOptions);
+  }
+};
+function formGroup(controls = {}, validators) {
+  return new FormGroup(controls, validators);
+}
+
+// src/forms/validators/email.validator.ts
+function EmailValidator() {
+  const regex = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+  return function(value) {
+    if (!value) {
+      return null;
+    }
+    return regex.test(value) ? null : { email: true };
+  };
+}
+
+// src/forms/validators/match.validator.ts
+function MatchValidator(getOtherValue) {
+  return function(value, rootValue, control, root) {
+    let otherValue = getOtherValue(value, rootValue, control, root);
+    otherValue = validValue(otherValue);
+    return value !== otherValue ? { match: { value, match: otherValue } } : null;
+  };
+}
+
+// src/forms/validators/max-length.validator.ts
+function MaxLengthValidator(maxlength) {
+  return function(value) {
+    if (value == null || maxlength == null) {
+      return null;
+    }
+    const length = value ? value.length : 0;
+    return length > maxlength ? { minlength: { requiredLength: maxlength, actualLength: length } } : null;
+  };
+}
+
+// src/forms/validators/max.validator.ts
+function MaxValidator(max) {
+  return function(value) {
+    if (value == null || max == null) {
+      return null;
+    }
+    value = parseFloat(value);
+    return !isNaN(value) && value > max ? { max: { max, actual: value } } : null;
+  };
+}
+
+// src/forms/validators/min-length.validator.ts
+function MinLengthValidator(minlength) {
+  return function(value) {
+    if (value == null || minlength == null) {
+      return null;
+    }
+    const length = value ? value.length : 0;
+    return length < minlength ? { minlength: { requiredLength: minlength, actualLength: length } } : null;
+  };
+}
+
+// src/forms/validators/min.validator.ts
+function MinValidator(min) {
+  return function(value) {
+    if (value == null || min == null) {
+      return null;
+    }
+    value = parseFloat(value);
+    return !isNaN(value) && value < min ? { min: { min, actual: value } } : null;
+  };
+}
+
+// src/forms/validators/null.validator.ts
+function NullValidator() {
+  return function(value) {
+    return null;
+  };
+}
+
+// src/forms/validators/pattern.validator.ts
+function PatternValidator(pattern) {
+  return function(value) {
+    if (value == null || pattern == null) {
+      return null;
+    }
+    const regex = patternToRegEx(pattern);
+    return regex.test(value) ? null : { pattern: { requiredPattern: regex.toString(), actualValue: value } };
+  };
+}
+function patternToRegEx(pattern) {
+  let regex;
+  if (pattern instanceof RegExp) {
+    regex = pattern;
+  } else if (typeof pattern === "string") {
+    pattern = pattern.charAt(0) === "^" ? pattern : `^${pattern}`;
+    pattern = pattern.charAt(pattern.length - 1) === "$" ? pattern : `${pattern}$`;
+    regex = new RegExp(pattern);
+  }
+  return regex || new RegExp("");
+}
+
+// src/forms/validators/required-if.validator.ts
+function RequiredIfValidator(condition) {
+  return function(value, rootValue, control, root) {
+    if (Boolean(condition(value, rootValue, control, root)) === true) {
+      return value == null || value.length === 0 ? { required: true } : null;
+    } else {
+      return null;
+    }
+  };
+}
+
+// src/forms/validators/required-true.validator.ts
+function RequiredTrueValidator() {
+  return function(value) {
+    return value === true ? null : { required: true };
+  };
+}
+
+// src/forms/validators/required.validator.ts
+function RequiredValidator() {
+  return function(value) {
+    return value == null || value.length === 0 ? { required: true } : null;
+  };
+}
+
+// src/hooks/useControl/useControl.ts
+import { useCallback, useEffect, useState } from "react";
+function useControl(control) {
+  const [state, setState] = useState({
+    value: control.value,
+    flags: control.state,
+    errors: mapErrors_(control.errors)
+  });
+  const setValue = useCallback((value) => {
+    control.patch(value);
+  }, [control]);
+  const setTouched = useCallback(() => {
+    control.touched = true;
+  }, [control]);
+  const reset = useCallback(() => {
+    control.reset();
+  }, [control]);
+  useEffect(() => {
+    const onChange = (value) => {
+      const newState = { value, flags: control.state, errors: mapErrors_(control.errors) };
+      setState(newState);
+    };
+    control.on("change", onChange);
+    return () => control.off("change", onChange);
+  }, [control]);
+  return [state, setValue, setTouched, reset, control];
+}
+
+// src/hooks/useForm/useForm.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+function useForm(factory, deps = []) {
+  const collection = useMemo(factory, deps);
+  const setValue = useCallback2((value) => {
+    collection.patch(value);
+  }, deps);
+  const setTouched = useCallback2(() => {
+    collection.touched = true;
+  }, deps);
+  const reset = useCallback2(() => {
+    collection.reset();
+  }, deps);
+  const [state, setState] = useState2({ value: collection.value, flags: collection.state, errors: mapErrors_(collection.errors) });
+  useEffect2(() => {
+    const onChange = (value) => {
+      const newState = { value, flags: collection.state, errors: mapErrors_(collection.errors) };
+      setState(newState);
+    };
+    collection.on("change", onChange);
+    collection.validateAndChange_();
+    return () => collection.off("change", onChange);
+  }, deps);
+  return [state, setValue, setTouched, reset, collection];
+}
+
+// src/hooks/useFormBuilder/useFormBuilder.ts
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo2, useState as useState3 } from "react";
+function useFormBuilder(schema, deps = []) {
+  const collection = useMemo2(() => {
+    if (Array.isArray(schema)) {
+      return mapArray_(schema);
+    } else {
+      return mapGroup_(schema);
+    }
+  }, deps);
+  const setValue = useCallback3((value) => {
+    collection.patch(value);
+  }, deps);
+  const setTouched = useCallback3(() => {
+    collection.touched = true;
+  }, deps);
+  const reset = useCallback3(() => {
+    collection.reset();
+  }, deps);
+  const [state, setState] = useState3({ value: collection.value, flags: collection.state, errors: mapErrors_(collection.errors) });
+  useEffect3(() => {
+    const onChange = (value) => {
+      const newState = { value, flags: collection.state, errors: mapErrors_(collection.errors) };
+      setState(newState);
+    };
+    collection.on("change", onChange);
+    collection.validateAndChange_();
+    return () => collection.off("change", onChange);
+  }, deps);
+  return [state, setValue, setTouched, reset, collection];
+}
+function mapGroup_(children, schema) {
+  const controls = {};
+  Object.keys(children).forEach((key) => {
+    controls[key] = mapSchema_(__spreadValues({ name: key }, children[key]));
+  });
+  const group = new FormGroup(controls, schema == null ? void 0 : schema.validators, schema);
+  return group;
+}
+function mapArray_(children, schema) {
+  const controls = children.map((x) => mapSchema_(x));
+  const array = new FormArray(controls, schema == null ? void 0 : schema.validators, schema);
+  return array;
+}
+function mapControl_(schema) {
+  return new FormControl(schema.value, schema.validators, schema);
+}
+function mapSchema_(schema) {
+  switch (schema.schema) {
+    case "group":
+      return mapGroup_(schema.children || {}, schema);
+    case "array":
+      return mapArray_(schema.children || [], schema);
+    default:
+      return mapControl_(schema);
+  }
+}
+export {
+  EmailValidator,
+  FormAbstract,
+  FormAbstractCollection,
+  FormArray,
+  FormControl,
+  FormGroup,
+  MatchValidator,
+  MaxLengthValidator,
+  MaxValidator,
+  MinLengthValidator,
+  MinValidator,
+  NullValidator,
+  PatternValidator,
+  RequiredIfValidator,
+  RequiredTrueValidator,
+  RequiredValidator,
+  deepCopy,
+  formArray,
+  formControl,
+  formGroup,
+  isThenable,
+  mapErrors_,
+  stringToValue,
+  useControl,
+  useForm,
+  useFormBuilder,
+  validValue,
+  valueToString
+};