feature-form 0.0.34 → 0.0.35

package/dist/cjs/create-form.js

@@ -1 +1,230 @@
-"use strict";var M=require("@blgc/utils"),y=require("feature-state"),C=require("./form-field/create-form-field.js"),u=require("./types/form-field.js"),E=Object.defineProperty,j=Object.getOwnPropertySymbols,P=Object.prototype.hasOwnProperty,I=Object.prototype.propertyIsEnumerable,k=(s,l,i)=>l in s?E(s,l,{enumerable:!0,configurable:!0,writable:!0,value:i}):s[l]=i,w=(s,l)=>{for(var i in l||(l={}))P.call(l,i)&&k(s,i,l[i]);if(j)for(var i of j(l))I.call(l,i)&&k(s,i,l[i]);return s},g=(s,l,i)=>new Promise((V,S)=>{var F=o=>{try{c(i.next(o))}catch(d){S(d)}},p=o=>{try{c(i.throw(o))}catch(d){S(d)}},c=o=>o.done?V(o.value):Promise.resolve(o.value).then(F,p);c((i=i.apply(s,l)).next())});function D(s){const{fields:l,collectErrorMode:i="firstError",disabled:V=!1,validateMode:S=M.bitwiseFlag(u.FormFieldValidateMode.OnSubmit),reValidateMode:F=M.bitwiseFlag(u.FormFieldReValidateMode.OnBlur),onValidSubmit:p,onInvalidSubmit:c,notifyOnStatusChange:o=!0}=s,d={_features:[],_config:{collectErrorMode:i,disabled:V},_validSubmitCallbacks:p!=null?[p]:[],_invalidSubmitCallbacks:c!=null?[c]:[],fields:Object.fromEntries(Object.entries(l).map(([e,t])=>{var r,h,v,f;return[e,C.createFormField(t.defaultValue,{key:e,validator:t.validator,collectErrorMode:(r=t.collectErrorMode)!=null?r:i,validateMode:(h=t.validateMode)!=null?h:S,reValidateMode:(v=t.reValidateMode)!=null?v:F,editable:(f=t.editable)!=null?f:!0,notifyOnStatusChange:o})]})),isValid:y.createState(!1),isValidating:y.createState(!1),isSubmitted:y.createState(!1),isSubmitting:y.createState(!1),_revalidate(e=!1){return g(this,null,function*(){const t=Object.values(this.fields);return e||(this.isValidating.set(!0),yield Promise.all(t.map(r=>r.validate())),this.isValidating.set(!1)),this.isValid.set(t.every(r=>r.isValid())),this.isValid.get()})},submit(){return g(this,arguments,function*(e={}){const{additionalData:t,assignToInitial:r=!1,onInvalidSubmit:h,onValidSubmit:v,postSubmitCallback:f}=e;this.isSubmitting.set(!0);const _=[];for(const a of Object.values(this.fields))a.isSubmitting=!0,(a.isSubmitted&&a._config.reValidateMode.has(u.FormFieldReValidateMode.OnSubmit)||!a.isSubmitted&&a._config.validateMode.has(u.FormFieldValidateMode.OnSubmit))&&_.push(a.validate());yield Promise.all(_);const b=this.getValidData(),m=[];if(b!=null){for(const a of this._validSubmitCallbacks)m.push(a(b,t));typeof v=="function"&&m.push(v(b,t))}else{const a=this.getErrors();for(const n of this._invalidSubmitCallbacks)m.push(n(a,t));typeof h=="function"&&m.push(h(a,t))}let O=null;f!=null?O=(yield Promise.all(m)).reduce((a,n)=>n!=null&&typeof n=="object"?w(w({},a),n):a,{}):yield Promise.all(m);for(const[a,n]of Object.entries(this.fields))b!=null&&Object.prototype.hasOwnProperty.call(b,a)&&r&&(n._intialValue=M.deepCopy(b[a])),n.isSubmitted=!0,n.isSubmitting=!1;return this.isSubmitted.set(!0),this.isSubmitting.set(!1),f==null||f(this,O!=null?O:{}),this.isValid.get()})},validate(){return g(this,null,function*(){return this._revalidate(!1)})},getField(e){return this.fields[e]},getValidData(){if(!this.isValid.get())return null;const e={};for(const[t,r]of Object.entries(this.fields))e[t]=r.get();return e},getErrors(){const e={};for(const[t,r]of Object.entries(this.fields))switch(r.status._v.type){case"INVALID":e[t]=r.status._v.errors;break;case"UNVALIDATED":e[t]=[{code:"unvalidated",message:`${t.toString()} was not yet validated!`,path:t}];break}return e},reset(){for(const e of Object.values(this.fields))e.reset();this.isSubmitted.set(!1)}};for(const e of Object.values(d.fields))e.listen(t=>g(this,[t],function*({source:r}){r==="set"&&(e.isSubmitted&&e._config.reValidateMode.has(u.FormFieldReValidateMode.OnChange)||!e.isSubmitted&&e._config.validateMode.has(u.FormFieldValidateMode.OnChange)||e._config.validateMode.has(u.FormFieldValidateMode.OnTouched)&&e.isTouched)&&(yield e.validate())}),{key:"form"}),e.status.listen(()=>g(this,null,function*(){yield d._revalidate(!0)}),{key:"form"});return d}exports.createForm=D;
+'use strict';
+
+var utils = require('@blgc/utils');
+var featureState = require('feature-state');
+var createFormField = require('./form-field/create-form-field.js');
+var formField = require('./types/form-field.js');
+
+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());
+  });
+};
+function createForm(config) {
+  const {
+    fields,
+    collectErrorMode = "firstError",
+    disabled = false,
+    validateMode = utils.bitwiseFlag(formField.FormFieldValidateMode.OnSubmit),
+    reValidateMode = utils.bitwiseFlag(formField.FormFieldReValidateMode.OnBlur),
+    onValidSubmit,
+    onInvalidSubmit,
+    notifyOnStatusChange = true
+  } = config;
+  const form = {
+    _features: [],
+    _config: {
+      collectErrorMode,
+      disabled
+    },
+    _validSubmitCallbacks: onValidSubmit != null ? [onValidSubmit] : [],
+    _invalidSubmitCallbacks: onInvalidSubmit != null ? [onInvalidSubmit] : [],
+    fields: Object.fromEntries(
+      Object.entries(fields).map(
+        ([fieldKey, field]) => {
+          var _a2, _b, _c, _d;
+          return [
+            fieldKey,
+            createFormField.createFormField(field.defaultValue, {
+              key: fieldKey,
+              validator: field.validator,
+              collectErrorMode: (_a2 = field.collectErrorMode) != null ? _a2 : collectErrorMode,
+              validateMode: (_b = field.validateMode) != null ? _b : validateMode,
+              reValidateMode: (_c = field.reValidateMode) != null ? _c : reValidateMode,
+              editable: (_d = field.editable) != null ? _d : true,
+              notifyOnStatusChange
+            })
+          ];
+        }
+      )
+    ),
+    isValid: featureState.createState(false),
+    isValidating: featureState.createState(false),
+    isSubmitted: featureState.createState(false),
+    isSubmitting: featureState.createState(false),
+    _revalidate(cached = false) {
+      return __async(this, null, function* () {
+        const formFields = Object.values(this.fields);
+        if (!cached) {
+          this.isValidating.set(true);
+          yield Promise.all(formFields.map((formField) => formField.validate()));
+          this.isValidating.set(false);
+        }
+        this.isValid.set(formFields.every((formField) => formField.isValid()));
+        return this.isValid.get();
+      });
+    },
+    submit() {
+      return __async(this, arguments, function* (options = {}) {
+        const {
+          additionalData,
+          assignToInitial = false,
+          onInvalidSubmit: _onInvalidSubmit,
+          onValidSubmit: _onValidSubmit,
+          postSubmitCallback
+        } = options;
+        this.isSubmitting.set(true);
+        const validationPromises = [];
+        for (const formField$1 of Object.values(
+          this.fields
+        )) {
+          formField$1.isSubmitting = true;
+          if (formField$1.isSubmitted && formField$1._config.reValidateMode.has(formField.FormFieldReValidateMode.OnSubmit) || !formField$1.isSubmitted && formField$1._config.validateMode.has(formField.FormFieldValidateMode.OnSubmit)) {
+            validationPromises.push(formField$1.validate());
+          }
+        }
+        yield Promise.all(validationPromises);
+        const data = this.getValidData();
+        const submitCallbackPromises = [];
+        if (data != null) {
+          for (const callback of this._validSubmitCallbacks) {
+            submitCallbackPromises.push(callback(data, additionalData));
+          }
+          if (typeof _onValidSubmit === "function") {
+            submitCallbackPromises.push(_onValidSubmit(data, additionalData));
+          }
+        } else {
+          const errors = this.getErrors();
+          for (const callback of this._invalidSubmitCallbacks) {
+            submitCallbackPromises.push(callback(errors, additionalData));
+          }
+          if (typeof _onInvalidSubmit === "function") {
+            submitCallbackPromises.push(_onInvalidSubmit(errors, additionalData));
+          }
+        }
+        let submitCallbackData = null;
+        if (postSubmitCallback != null) {
+          submitCallbackData = (yield Promise.all(submitCallbackPromises)).reduce((acc, result) => {
+            if (result != null && typeof result === "object") {
+              return __spreadValues(__spreadValues({}, acc), result);
+            }
+            return acc;
+          }, {});
+        } else {
+          yield Promise.all(submitCallbackPromises);
+        }
+        for (const [fieldKey, formField] of Object.entries(this.fields)) {
+          if (data != null && Object.prototype.hasOwnProperty.call(data, fieldKey)) {
+            if (assignToInitial) {
+              formField._intialValue = utils.deepCopy(data[fieldKey]);
+            }
+          }
+          formField.isSubmitted = true;
+          formField.isSubmitting = false;
+        }
+        this.isSubmitted.set(true);
+        this.isSubmitting.set(false);
+        postSubmitCallback == null ? void 0 : postSubmitCallback(this, submitCallbackData != null ? submitCallbackData : {});
+        return this.isValid.get();
+      });
+    },
+    validate() {
+      return __async(this, null, function* () {
+        return this._revalidate(false);
+      });
+    },
+    getField(fieldKey) {
+      return this.fields[fieldKey];
+    },
+    getValidData() {
+      if (!this.isValid.get()) {
+        return null;
+      }
+      const preparedData = {};
+      for (const [fieldKey, formField] of Object.entries(this.fields)) {
+        preparedData[fieldKey] = formField.get();
+      }
+      return preparedData;
+    },
+    getErrors() {
+      const errors = {};
+      for (const [fieldKey, formField] of Object.entries(this.fields)) {
+        switch (formField.status._v.type) {
+          case "INVALID":
+            errors[fieldKey] = formField.status._v.errors;
+            break;
+          case "UNVALIDATED":
+            errors[fieldKey] = [
+              {
+                code: "unvalidated",
+                message: `${fieldKey.toString()} was not yet validated!`,
+                path: fieldKey
+              }
+            ];
+            break;
+        }
+      }
+      return errors;
+    },
+    reset() {
+      for (const formField of Object.values(
+        this.fields
+      )) {
+        formField.reset();
+      }
+      this.isSubmitted.set(false);
+    }
+  };
+  for (const field of Object.values(form.fields)) {
+    field.listen(
+      (_0) => __async(this, [_0], function* ({ source }) {
+        if (source === "set") {
+          if (field.isSubmitted && field._config.reValidateMode.has(formField.FormFieldReValidateMode.OnChange) || !field.isSubmitted && field._config.validateMode.has(formField.FormFieldValidateMode.OnChange) || field._config.validateMode.has(formField.FormFieldValidateMode.OnTouched) && field.isTouched) {
+            yield field.validate();
+          }
+        }
+      }),
+      { key: "form" }
+    );
+    field.status.listen(
+      () => __async(this, null, function* () {
+        yield form._revalidate(true);
+      }),
+      { key: "form" }
+    );
+  }
+  return form;
+}
+
+exports.createForm = createForm;

package/dist/cjs/form-field/create-form-field-validation-context.js

@@ -1 +1,27 @@
-"use strict";function t(r){return{config:{collectErrorMode:r._config.collectErrorMode,name:r.key},value:r.get(),isValue:e=>!0,hasError:()=>{var e;return((e=r.status._nextValue)==null?void 0:e.type)==="INVALID"},registerError(e){r.status.registerNextError({code:e.code,message:e.message,path:e.path})}}}exports.createFormFieldValidationContext=t;
+'use strict';
+
+function createFormFieldValidationContext(formField) {
+  return {
+    config: {
+      collectErrorMode: formField._config.collectErrorMode,
+      name: formField.key
+    },
+    value: formField.get(),
+    isValue: (v) => {
+      return true;
+    },
+    hasError: () => {
+      var _a;
+      return ((_a = formField.status._nextValue) == null ? void 0 : _a.type) === "INVALID";
+    },
+    registerError(error) {
+      formField.status.registerNextError({
+        code: error.code,
+        message: error.message,
+        path: error.path
+      });
+    }
+  };
+}
+
+exports.createFormFieldValidationContext = createFormFieldValidationContext;

package/dist/cjs/form-field/create-form-field.js

@@ -1 +1,102 @@
-"use strict";var c=require("@blgc/utils"),F=require("feature-state"),f=require("validation-adapter"),s=require("../types/form-field.js"),g=require("./create-form-field-validation-context.js"),y=require("./create-status.js"),M=(d,l,i)=>new Promise((o,r)=>{var u=t=>{try{a(i.next(t))}catch(e){r(e)}},n=t=>{try{a(i.throw(t))}catch(e){r(e)}},a=t=>t.done?o(t.value):Promise.resolve(t.value).then(u,n);a((i=i.apply(d,l)).next())});function _(d,l){const{key:i,validator:o=f.createValidator([]),editable:r=!0,reValidateMode:u=c.bitwiseFlag(s.FormFieldReValidateMode.OnBlur),validateMode:n=c.bitwiseFlag(s.FormFieldValidateMode.OnSubmit),collectErrorMode:a="firstError",notifyOnStatusChange:t=!0}=l,e=F.createState(d,{deferred:!1}),v=y.createStatus({type:"UNVALIDATED"});t&&v.listen(h=>{e._notify({additionalData:{source:"status",status:h.value}})},{key:"form-field"});const m={_config:{editable:r,validateMode:n,reValidateMode:u,collectErrorMode:a},_intialValue:c.deepCopy(e._v),_validator:o,key:i,isTouched:!1,isSubmitted:!1,isSubmitting:!1,isValidating:!1,status:v,validate(){return M(this,null,function*(){const h=g.createFormFieldValidationContext(this);return this.isValidating=!0,yield this._validator.validate(h),this.isValidating=!1,this.status._nextValue==null?this.status.set({type:"VALID"}):this.status.set(this.status._nextValue),this.status._nextValue=void 0,this.status.get().type==="VALID"})},isValid(){return this.status.get().type==="VALID"},blur(){(this.isSubmitted&&this._config.reValidateMode.has(s.FormFieldReValidateMode.OnBlur)||!this.isSubmitted&&(this._config.validateMode.has(s.FormFieldValidateMode.OnBlur)||this._config.validateMode.has(s.FormFieldValidateMode.OnTouched)&&!this.isTouched))&&this.validate(),this.isTouched=!0},reset(){this.set(this._intialValue,{additionalData:{source:"reset"}}),this.isTouched=!1,this.isSubmitted=!1,this.isSubmitting=!1,this.status.set({type:"UNVALIDATED"})}},V=Object.assign(e,m);return V._features.push("form-field"),V}exports.createFormField=_;
+'use strict';
+
+var utils = require('@blgc/utils');
+var featureState = require('feature-state');
+var validationAdapter = require('validation-adapter');
+var formField = require('../types/form-field.js');
+var createFormFieldValidationContext = require('./create-form-field-validation-context.js');
+var createStatus = require('./create-status.js');
+
+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());
+  });
+};
+function createFormField(initialValue, config) {
+  const {
+    key,
+    validator = validationAdapter.createValidator([]),
+    editable = true,
+    reValidateMode = utils.bitwiseFlag(formField.FormFieldReValidateMode.OnBlur),
+    validateMode = utils.bitwiseFlag(formField.FormFieldValidateMode.OnSubmit),
+    collectErrorMode = "firstError",
+    notifyOnStatusChange = true
+  } = config;
+  const formFieldState = featureState.createState(initialValue, { deferred: false });
+  const status = createStatus.createStatus({ type: "UNVALIDATED" });
+  if (notifyOnStatusChange) {
+    status.listen(
+      (data) => {
+        formFieldState._notify({ additionalData: { source: "status", status: data.value } });
+      },
+      { key: "form-field" }
+    );
+  }
+  const formFieldFeature = {
+    _config: {
+      editable,
+      validateMode,
+      reValidateMode,
+      collectErrorMode
+    },
+    _intialValue: utils.deepCopy(formFieldState._v),
+    _validator: validator,
+    key,
+    isTouched: false,
+    isSubmitted: false,
+    isSubmitting: false,
+    isValidating: false,
+    status,
+    validate() {
+      return __async(this, null, function* () {
+        const validationContext = createFormFieldValidationContext.createFormFieldValidationContext(this);
+        this.isValidating = true;
+        yield this._validator.validate(validationContext);
+        this.isValidating = false;
+        if (this.status._nextValue == null) {
+          this.status.set({ type: "VALID" });
+        } else {
+          this.status.set(this.status._nextValue);
+        }
+        this.status._nextValue = void 0;
+        return this.status.get().type === "VALID";
+      });
+    },
+    isValid() {
+      return this.status.get().type === "VALID";
+    },
+    blur() {
+      if (this.isSubmitted && this._config.reValidateMode.has(formField.FormFieldReValidateMode.OnBlur) || !this.isSubmitted && (this._config.validateMode.has(formField.FormFieldValidateMode.OnBlur) || this._config.validateMode.has(formField.FormFieldValidateMode.OnTouched) && !this.isTouched)) {
+        void this.validate();
+      }
+      this.isTouched = true;
+    },
+    reset() {
+      this.set(this._intialValue, { additionalData: { source: "reset" } });
+      this.isTouched = false;
+      this.isSubmitted = false;
+      this.isSubmitting = false;
+      this.status.set({ type: "UNVALIDATED" });
+    }
+  };
+  const _formField = Object.assign(formFieldState, formFieldFeature);
+  _formField._features.push("form-field");
+  return _formField;
+}
+
+exports.createFormField = createFormField;

package/dist/cjs/form-field/create-status.js

@@ -1 +1,26 @@
-"use strict";var u=require("feature-state");function i(s){const a=u.createState(s,{deferred:!1}),e=Object.assign(a,{_nextValue:void 0,registerNextError(t){var r;((r=this._nextValue)==null?void 0:r.type)==="INVALID"?this._nextValue.errors.push(t):this._nextValue={type:"INVALID",errors:[t]}}});return e._features.push("form-field-status"),e}exports.createStatus=i;
+'use strict';
+
+var featureState = require('feature-state');
+
+function createStatus(initialValue) {
+  const formFieldStatusState = featureState.createState(initialValue, { deferred: false });
+  const formFieldStatusFeature = {
+    _nextValue: void 0,
+    registerNextError(error) {
+      var _a;
+      if (((_a = this._nextValue) == null ? void 0 : _a.type) === "INVALID") {
+        this._nextValue.errors.push(error);
+      } else {
+        this._nextValue = { type: "INVALID", errors: [error] };
+      }
+    }
+  };
+  const _formFieldStatus = Object.assign(
+    formFieldStatusState,
+    formFieldStatusFeature
+  );
+  _formFieldStatus._features.push("form-field-status");
+  return _formFieldStatus;
+}
+
+exports.createStatus = createStatus;

package/dist/cjs/form-field/is-form-field-status.js

@@ -1 +1,7 @@
-"use strict";function r(e){return typeof e=="object"&&e!=null&&"_features"in e&&Array.isArray(e._features)&&e._features.includes("form-field-status")}exports.isFormFieldStatus=r;
+'use strict';
+
+function isFormFieldStatus(value) {
+  return typeof value === "object" && value != null && "_features" in value && Array.isArray(value._features) && value._features.includes("form-field-status");
+}
+
+exports.isFormFieldStatus = isFormFieldStatus;

package/dist/cjs/form-field/is-form-field.js

@@ -1 +1,7 @@
-"use strict";function i(e){return typeof e=="object"&&e!=null&&"_features"in e&&Array.isArray(e._features)&&e._features.includes("form-field")}exports.isFormField=i;
+'use strict';
+
+function isFormField(value) {
+  return typeof value === "object" && value != null && "_features" in value && Array.isArray(value._features) && value._features.includes("form-field");
+}
+
+exports.isFormField = isFormField;

package/dist/cjs/helper/from-validator.js

@@ -1 +1,23 @@
-"use strict";var l=Object.defineProperty,e=Object.getOwnPropertySymbols,i=Object.prototype.hasOwnProperty,n=Object.prototype.propertyIsEnumerable,o=(a,r,t)=>r in a?l(a,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):a[r]=t,b=(a,r)=>{for(var t in r||(r={}))i.call(r,t)&&o(a,t,r[t]);if(e)for(var t of e(r))n.call(r,t)&&o(a,t,r[t]);return a};function c(a,r){return b({validator:a},r)}exports.fromValidator=c;
+'use strict';
+
+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;
+};
+function fromValidator(validator, config) {
+  return __spreadValues({ validator }, config);
+}
+
+exports.fromValidator = fromValidator;

package/dist/cjs/helper/has-form-changed.js

@@ -1 +1,13 @@
-"use strict";function t(n){var i,r;for(const l in n.fields)if(((i=n.fields[l])==null?void 0:i.get())!==((r=n.fields[l])==null?void 0:r._intialValue))return!0;return!1}exports.hasFormChanged=t;
+'use strict';
+
+function hasFormChanged(form) {
+  var _a, _b;
+  for (const key in form.fields) {
+    if (((_a = form.fields[key]) == null ? void 0 : _a.get()) !== ((_b = form.fields[key]) == null ? void 0 : _b._intialValue)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+exports.hasFormChanged = hasFormChanged;

package/dist/cjs/helper/reset-form-submitted.js

@@ -1 +1,12 @@
-"use strict";function i(t){t.isSubmitted.set(!1),t.isSubmitting.set(!1);for(const e of Object.values(t.fields))e.isSubmitted=!1,e.isSubmitting=!1}exports.resetFormSubmitted=i;
+'use strict';
+
+function resetFormSubmitted(form) {
+  form.isSubmitted.set(false);
+  form.isSubmitting.set(false);
+  for (const formField of Object.values(form.fields)) {
+    formField.isSubmitted = false;
+    formField.isSubmitting = false;
+  }
+}
+
+exports.resetFormSubmitted = resetFormSubmitted;

package/dist/cjs/index.js

@@ -1 +1,35 @@
-"use strict";var e=require("@blgc/utils"),t=require("./create-form.js"),i=require("./form-field/create-form-field.js"),a=require("./form-field/create-status.js"),F=require("./form-field/is-form-field.js"),o=require("./form-field/is-form-field-status.js"),m=require("./helper/from-validator.js"),d=require("./helper/has-form-changed.js"),u=require("./helper/reset-form-submitted.js"),s=require("./is-form-with-features.js"),r=require("./types/form-field.js");Object.defineProperty(exports,"BitwiseFlag",{enumerable:!0,get:function(){return e.BitwiseFlag}}),Object.defineProperty(exports,"bitwiseFlag",{enumerable:!0,get:function(){return e.bitwiseFlag}}),exports.createForm=t.createForm,exports.createFormField=i.createFormField,exports.createStatus=a.createStatus,exports.isFormField=F.isFormField,exports.isFormFieldStatus=o.isFormFieldStatus,exports.fromValidator=m.fromValidator,exports.hasFormChanged=d.hasFormChanged,exports.resetFormSubmitted=u.resetFormSubmitted,exports.isFormWithFeatures=s.isFormWithFeatures,exports.FormFieldReValidateMode=r.FormFieldReValidateMode,exports.FormFieldValidateMode=r.FormFieldValidateMode;
+'use strict';
+
+var utils = require('@blgc/utils');
+var createForm = require('./create-form.js');
+var createFormField = require('./form-field/create-form-field.js');
+var createStatus = require('./form-field/create-status.js');
+var isFormField = require('./form-field/is-form-field.js');
+var isFormFieldStatus = require('./form-field/is-form-field-status.js');
+var fromValidator = require('./helper/from-validator.js');
+var hasFormChanged = require('./helper/has-form-changed.js');
+var resetFormSubmitted = require('./helper/reset-form-submitted.js');
+var isFormWithFeatures = require('./is-form-with-features.js');
+var formField = require('./types/form-field.js');
+
+
+
+Object.defineProperty(exports, "BitwiseFlag", {
+	enumerable: true,
+	get: function () { return utils.BitwiseFlag; }
+});
+Object.defineProperty(exports, "bitwiseFlag", {
+	enumerable: true,
+	get: function () { return utils.bitwiseFlag; }
+});
+exports.createForm = createForm.createForm;
+exports.createFormField = createFormField.createFormField;
+exports.createStatus = createStatus.createStatus;
+exports.isFormField = isFormField.isFormField;
+exports.isFormFieldStatus = isFormFieldStatus.isFormFieldStatus;
+exports.fromValidator = fromValidator.fromValidator;
+exports.hasFormChanged = hasFormChanged.hasFormChanged;
+exports.resetFormSubmitted = resetFormSubmitted.resetFormSubmitted;
+exports.isFormWithFeatures = isFormWithFeatures.isFormWithFeatures;
+exports.FormFieldReValidateMode = formField.FormFieldReValidateMode;
+exports.FormFieldValidateMode = formField.FormFieldValidateMode;

package/dist/cjs/is-form-with-features.js

@@ -1 +1,7 @@
-"use strict";function s(r,e){return typeof r=="object"&&r!=null&&"_features"in r&&Array.isArray(r._features)&&e.every(t=>r._features.includes(t))}exports.isFormWithFeatures=s;
+'use strict';
+
+function isFormWithFeatures(value, features) {
+  return typeof value === "object" && value != null && "_features" in value && Array.isArray(value._features) && features.every((feature) => value._features.includes(feature));
+}
+
+exports.isFormWithFeatures = isFormWithFeatures;

package/dist/cjs/types/form-field.js

@@ -1 +1,18 @@
-"use strict";var e=(n=>(n[n.OnBlur=1]="OnBlur",n[n.OnChange=2]="OnChange",n[n.OnSubmit=4]="OnSubmit",n[n.OnTouched=8]="OnTouched",n))(e||{}),d=(n=>(n[n.OnBlur=1]="OnBlur",n[n.OnChange=2]="OnChange",n[n.OnSubmit=4]="OnSubmit",n))(d||{});exports.FormFieldReValidateMode=d,exports.FormFieldValidateMode=e;
+'use strict';
+
+var FormFieldValidateMode = /* @__PURE__ */ ((FormFieldValidateMode2) => {
+  FormFieldValidateMode2[FormFieldValidateMode2["OnBlur"] = 1] = "OnBlur";
+  FormFieldValidateMode2[FormFieldValidateMode2["OnChange"] = 2] = "OnChange";
+  FormFieldValidateMode2[FormFieldValidateMode2["OnSubmit"] = 4] = "OnSubmit";
+  FormFieldValidateMode2[FormFieldValidateMode2["OnTouched"] = 8] = "OnTouched";
+  return FormFieldValidateMode2;
+})(FormFieldValidateMode || {});
+var FormFieldReValidateMode = /* @__PURE__ */ ((FormFieldReValidateMode2) => {
+  FormFieldReValidateMode2[FormFieldReValidateMode2["OnBlur"] = 1] = "OnBlur";
+  FormFieldReValidateMode2[FormFieldReValidateMode2["OnChange"] = 2] = "OnChange";
+  FormFieldReValidateMode2[FormFieldReValidateMode2["OnSubmit"] = 4] = "OnSubmit";
+  return FormFieldReValidateMode2;
+})(FormFieldReValidateMode || {});
+
+exports.FormFieldReValidateMode = FormFieldReValidateMode;
+exports.FormFieldValidateMode = FormFieldValidateMode;