@vnmfify/core/form/use-form.js

```shell npm i @vnmfify/core -S ```

import _isPlainObject from "lodash/isPlainObject";
import _toArray from "lodash/toArray";
import _cloneDeep from "lodash/cloneDeep";
import _includes from "lodash/includes";
import _set from "lodash/set";
import _isEqual from "lodash/isEqual";
import _forEach from "lodash/forEach";
import _get from "lodash/get";
import _reduce from "lodash/reduce";
import _isEmpty from "lodash/isEmpty";
import _isArray from "lodash/isArray";
import _isUndefined from "lodash/isUndefined";
import _unset from "lodash/unset";
import _filter from "lodash/filter";

function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }

function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }

function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }

function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }

function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }

function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }

function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }

import { Events } from "@vnxjs/vnmf";
import { useEffect, useMemo, useState } from "react";
import { getLogger } from "../utils/logger";
import { useToRef } from "../utils/state";
import { validateAll } from "./form.validate";
var {
  warn
} = getLogger("useForm");
var containerForms = new Map();
var containerFormRefs = new Map();

function toMapValueArray(map) {
  var array = [];
  map === null || map === void 0 ? void 0 : map.forEach(value => array.push(value));
  return array;
}

function getAttributiveForm(formName) {
  return containerForms.get(formName);
}

var _fields = /*#__PURE__*/new WeakMap();

var _defaultValues = /*#__PURE__*/new WeakMap();

var _values = /*#__PURE__*/new WeakMap();

var _errors = /*#__PURE__*/new WeakMap();

var _events = /*#__PURE__*/new WeakMap();

class FormAttributes {
  constructor() {
    _classPrivateFieldInitSpec(this, _fields, {
      writable: true,
      value: new Map()
    });

    _classPrivateFieldInitSpec(this, _defaultValues, {
      writable: true,
      value: {}
    });

    _classPrivateFieldInitSpec(this, _values, {
      writable: true,
      value: {}
    });

    _classPrivateFieldInitSpec(this, _errors, {
      writable: true,
      value: {}
    });

    _classPrivateFieldInitSpec(this, _events, {
      writable: true,
      value: new Events()
    });
  }

  get fields() {
    return _classPrivateFieldGet(this, _fields);
  }

  get defaultValues() {
    return _classPrivateFieldGet(this, _defaultValues);
  }

  set defaultValues(defaultValues) {
    _classPrivateFieldSet(this, _defaultValues, defaultValues);
  }

  get values() {
    return _classPrivateFieldGet(this, _values);
  }

  set values(value) {
    _classPrivateFieldSet(this, _values, value);
  }

  get errors() {
    return _classPrivateFieldGet(this, _errors);
  }

  set errors(errors) {
    _classPrivateFieldSet(this, _errors, errors);
  }

  addEventListener(event, listener) {
    var _classPrivateFieldGet2;

    (_classPrivateFieldGet2 = _classPrivateFieldGet(this, _events)) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.on(event, listener);
  }

  removeEventListener(event, listener) {
    var _classPrivateFieldGet3;

    (_classPrivateFieldGet3 = _classPrivateFieldGet(this, _events)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.off(event, listener);
  }

  emitEvent(event) {
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }

    _classPrivateFieldGet(this, _events).trigger(event, ...args);
  }

  findFields(predicate) {
    var fields = toMapValueArray(this.fields);
    return _filter(fields, predicate);
  }

  addField(name, field) {
    _classPrivateFieldGet(this, _fields).set(name, field);
  }

  removeField(name) {
    _classPrivateFieldGet(this, _fields).delete(name);

    _unset(_classPrivateFieldGet(this, _values), name);
  }

  hasField(name) {
    return _classPrivateFieldGet(this, _fields).has(name);
  }

  getErrors(nameNames) {
    var names = _isUndefined(nameNames) ? [] : _isArray(nameNames) ? nameNames : [nameNames];
    var {
      errors
    } = this;

    if (_isEmpty(names)) {
      return errors;
    }

    return _reduce(names, (nameErrors, name) => {
      var error = _get(errors, name);

      if (error) {
        nameErrors[name] = error;
      }

      return nameErrors;
    }, {});
  }

  setErrors(newErrors) {
    var emitChange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
    var {
      errors
    } = this;

    _forEach(newErrors, error => {
      var {
        name
      } = error;

      if (name) {
        var oldError = _get(errors, name);

        if (!_isEqual(oldError === null || oldError === void 0 ? void 0 : oldError.errors, error === null || error === void 0 ? void 0 : error.errors)) {
          _set(errors, name, error);

          if (emitChange) {
            this.emitEvent("fields.".concat(name, ".error.change"), errors);
          }
        }
      }
    });
  }

  resetErrors() {
    var errors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    this.errors = errors;
  }

  getValues(nameNames) {
    var names = _isUndefined(nameNames) ? [] : _isArray(nameNames) ? nameNames : [nameNames];
    var values = {};

    if (_isEmpty(names)) {
      for (var field of this.fields.values()) {
        if (field.name) {
          values[field.name] = _get(this.values, field.name);
        }
      }

      return values;
    }

    for (var attr of names) {
      _set(values, attr, _get(this.values, attr));
    }

    return values;
  }

  setValues(newValues) {
    var emitChange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
    var changed = false;
    var {
      values
    } = this;

    _forEach(newValues, (value, name) => {
      var oldValue = _get(values, name);

      if (oldValue !== value) {
        _set(values, name, value);

        if (emitChange) {
          this.emitEvent("fields.".concat(name, ".value.change"), value);
          changed = true;
        }
      }
    });

    if (changed) {
      this.emitEvent("change", newValues, values);
    }
  }

  resetValues() {
    var newValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    this.values = newValues;
  }

  release() {
    var _classPrivateFieldGet4;

    (_classPrivateFieldGet4 = _classPrivateFieldGet(this, _events)) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.off();
  }

}

function validateForm(formName, name) {
  return new Promise((resolve, reject) => {
    var form = getAttributiveForm(formName);
    Promise.resolve(_isUndefined(name) ? [] : _isArray(name) ? name : [name]).then(names => form === null || form === void 0 ? void 0 : form.findFields(field => _isEmpty(names) || _includes(names, field.name))).then(items => items && validateAll(items)).then(() => form === null || form === void 0 ? void 0 : form.getValues(name)).then(resolve).catch(errors => {
      form === null || form === void 0 ? void 0 : form.resetErrors();
      form === null || form === void 0 ? void 0 : form.setErrors(errors);
      reject(errors);
    });
  });
}

function defineForm(formName) {
  return class DelegatingForm {
    get name() {
      return formName;
    }

    addEventListener(event, listener) {
      var _getAttributiveForm;

      (_getAttributiveForm = getAttributiveForm(formName)) === null || _getAttributiveForm === void 0 ? void 0 : _getAttributiveForm.addEventListener(event, listener);
    }

    removeEventListener(event, listener) {
      var _getAttributiveForm2;

      (_getAttributiveForm2 = getAttributiveForm(formName)) === null || _getAttributiveForm2 === void 0 ? void 0 : _getAttributiveForm2.removeEventListener(event, listener);
    }

    linkField(name, field) {
      if (name && field) {
        var _getAttributiveForm3;

        (_getAttributiveForm3 = getAttributiveForm(formName)) === null || _getAttributiveForm3 === void 0 ? void 0 : _getAttributiveForm3.addField(name, field);
      }
    }

    hasField(name) {
      var _getAttributiveForm4;

      return name && ((_getAttributiveForm4 = getAttributiveForm(formName)) === null || _getAttributiveForm4 === void 0 ? void 0 : _getAttributiveForm4.hasField(name));
    }

    unlinkField(name) {
      if (name) {
        var _getAttributiveForm5;

        (_getAttributiveForm5 = getAttributiveForm(formName)) === null || _getAttributiveForm5 === void 0 ? void 0 : _getAttributiveForm5.removeField(name);
      }
    }

    getFields() {
      var _getAttributiveForm6;

      return toMapValueArray((_getAttributiveForm6 = getAttributiveForm(formName)) === null || _getAttributiveForm6 === void 0 ? void 0 : _getAttributiveForm6.fields);
    }

    findFields(predicate) {
      var _getAttributiveForm7;

      return (_getAttributiveForm7 = getAttributiveForm(formName)) === null || _getAttributiveForm7 === void 0 ? void 0 : _getAttributiveForm7.findFields(predicate);
    }

    setErrors(errors) {
      var _getAttributiveForm8;

      (_getAttributiveForm8 = getAttributiveForm(formName)) === null || _getAttributiveForm8 === void 0 ? void 0 : _getAttributiveForm8.setErrors(errors);
    }

    resetErrors() {
      var _getAttributiveForm9;

      (_getAttributiveForm9 = getAttributiveForm(formName)) === null || _getAttributiveForm9 === void 0 ? void 0 : _getAttributiveForm9.resetErrors();
    }

    getErrors(name) {
      var form = getAttributiveForm(formName);
      return _reduce(form === null || form === void 0 ? void 0 : form.getErrors(name), (errors, error) => {
        errors.push(error);
        return errors;
      }, []);
    }

    setDefaultValues(defaultValues) {
      var form = getAttributiveForm(formName);

      if (form) {
        _forEach(defaultValues, (value, name) => {
          _set(form.defaultValues, name, value);
        });

        form === null || form === void 0 ? void 0 : form.setValues(_cloneDeep(defaultValues));
      }
    }

    setValues(newValues) {
      var _getAttributiveForm10;

      (_getAttributiveForm10 = getAttributiveForm(formName)) === null || _getAttributiveForm10 === void 0 ? void 0 : _getAttributiveForm10.setValues(newValues);
    }

    resetValues(values) {}

    getValues(name) {
      var _getAttributiveForm11;

      return (_getAttributiveForm11 = getAttributiveForm(formName)) === null || _getAttributiveForm11 === void 0 ? void 0 : _getAttributiveForm11.getValues(name);
    }

    validate(name) {
      return validateForm(formName, name);
    }

    reset() {
      var form = getAttributiveForm(formName);

      var newValues = _cloneDeep(form === null || form === void 0 ? void 0 : form.defaultValues);

      form === null || form === void 0 ? void 0 : form.resetValues(newValues);
      form === null || form === void 0 ? void 0 : form.resetErrors();
      form === null || form === void 0 ? void 0 : form.emitEvent("change", newValues, newValues);
      form === null || form === void 0 ? void 0 : form.emitEvent("reset");
    }

    setFieldsValue(newValues, emitChange) {
      var _getAttributiveForm12;

      warn("Please use setValues instead of setFieldsValue");
      (_getAttributiveForm12 = getAttributiveForm(formName)) === null || _getAttributiveForm12 === void 0 ? void 0 : _getAttributiveForm12.setValues(newValues);
    }

    getFieldsValue(name) {
      var _getAttributiveForm13;

      warn("Please use getValues instead of getFieldsValue");
      return (_getAttributiveForm13 = getAttributiveForm(formName)) === null || _getAttributiveForm13 === void 0 ? void 0 : _getAttributiveForm13.getValues(name);
    }

    validateFields(name) {
      warn("Please use validate instead of validateFields");
      return validateForm(formName, name);
    }

  };
}

class FormContainer {
  static increaseFormRef(name) {
    var count = containerFormRefs.get(name);
    containerFormRefs.set(name, (count !== null && count !== void 0 ? count : 0) + 1);
  }

  static decreaseFormRef(name) {
    var count = containerFormRefs.get(name);
    containerFormRefs.set(name, (count !== null && count !== void 0 ? count : 0) - 1);
  }

  static hasFormRef(name) {
    var count = containerFormRefs.get(name);
    return !_isUndefined(count) && count > 0;
  }

  getForms() {
    return _toArray(containerForms.values());
  }

  getForm(name) {
    if (!containerForms.has(name)) {
      return undefined;
    }

    FormContainer.increaseFormRef(name);
    var DelegatingForm = defineForm(name);
    return new DelegatingForm();
  }

  hasForm(name) {
    return name && containerForms.has(name);
  }

  newForm(name) {
    if (_isEmpty(name)) {
      return;
    }

    containerForms.set(name, new FormAttributes());
  }

  releaseForm(name) {
    if (_isEmpty(name)) {
      return;
    }

    FormContainer.decreaseFormRef(name);

    if (!FormContainer.hasFormRef(name)) {
      var _containerForms$get;

      (_containerForms$get = containerForms.get(name)) === null || _containerForms$get === void 0 ? void 0 : _containerForms$get.release();
      containerForms.delete(name);
    }
  }

}

var formContainer = new FormContainer();

function useConstant(value) {
  var [constant] = useState(value);
  return constant;
}

export default function useForm() {
  var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var {
    defaultValues,
    values
  } = options;
  var hasForm = formContainer.hasForm(name);
  var immutableHasForm = useConstant(hasForm);
  var nameRef = useToRef(name);

  if (!hasForm && !_isEmpty(name)) {
    formContainer.newForm(name);
  }

  useEffect(() => {
    if (!immutableHasForm && _isPlainObject(defaultValues)) {
      var _formContainer$getFor;

      (_formContainer$getFor = formContainer.getForm(nameRef.current)) === null || _formContainer$getFor === void 0 ? void 0 : _formContainer$getFor.setDefaultValues(defaultValues);
    }
  }, []);
  useEffect(() => {
    if (!immutableHasForm && _isPlainObject(values)) {
      var _formContainer$getFor2;

      (_formContainer$getFor2 = formContainer.getForm(nameRef.current)) === null || _formContainer$getFor2 === void 0 ? void 0 : _formContainer$getFor2.setValues(values);
    }
  }, [nameRef, values]);
  useEffect(() => () => formContainer.releaseForm(name), [name]);
  return useMemo(() => formContainer.getForm(name), [name]);
}
//# sourceMappingURL=use-form.js.map