react-form-manage 1.0.8-beta.7 → 1.0.8

package/src/stores/formStore.ts

@@ -3,11 +3,26 @@ import { cloneDeep, get, isNil, isNumber, last, set, unset } from "lodash";
 import { v4 } from "uuid";
 import { create } from "zustand";
 import { getAllNoneObjStringPath } from "../utils/obj.util";
+type ListenerFormItemType = "normal" | "array";
+
+export interface SubmitProps<T = any> {
+  externalFinishCallback?: (values: T, allValues?: any) => void | Promise<void>;
+  externalRejectCallback?: (errorFields: any[]) => void | Promise<void>;
+  externalFinallyCallback?: (result: {
+    errorsField: any[];
+    values: T;
+    withUnRegisteredValues: any;
+  }) => void | Promise<void>;
+  callBothFinish?: boolean;
+  callBothReject?: boolean;
+  callBothFinally?: boolean;
+  collectHiddenFields?: boolean;
+}
 
-export interface FormInstance {
+export interface FormInstance<T = any> {
   formName: string;
   resetFields: (values?: any) => void;
-  submit: (values?: any) => void;
+  submit: (props?: SubmitProps<T>) => void;
   submitAsync: (values?: any) => Promise<any>;
   setFieldValue: (name: string, value: any, options?: any) => void;
   setFieldValues: (values: Record<string, any>, options?: any) => void;
@@ -17,20 +32,25 @@ export interface FormInstance {
   setFieldFocus: (name: string) => void;
 }
 
-interface ListenerItem {
+export interface ListenerItem {
   name?: string;
   formName?: string;
   isTouched?: boolean;
   isDirty?: boolean;
   formItemId?: string;
   internalErrors?: any;
+  onArrayChange?: any;
   onChange?: any;
   onReset?: any;
   onFocus?: any;
   emitFocus?: any;
+  isInitied?: boolean;
+  type?: ListenerFormItemType;
+  hidden?: boolean;
+  collectOnHidden?: boolean;
 }
 
-interface CleanUpItem {
+export interface CleanUpItem {
   name?: string;
   type?: string;
   key: string;
@@ -45,109 +65,134 @@ interface FormStoreState {
   cacheData: Record<string, any>;
   formInstances: FormInstance[];
   submitHistory: Record<string, any[]>;
+  listeners: ListenerItem[];
+  cleanUpStack: CleanUpItem[];
   // methods (loose typed for incremental migration)
   [key: string]: any;
 }
-export const useFormStore = create<FormStoreState>(
-  (storeSet: any, storeGet: any) => ({
-    forms: {},
-    initialValues: {},
-    formStates: {},
-    cacheData: {},
-    formInstances: [],
-    submitHistory: {},
-    setData(formName, name, value) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.forms;
-          set(oldValues, `${formName}.${name}`, value);
-        }),
-      );
-    },
-
-    getCacheData(formName) {
-      return get(storeGet(), `cacheData.${formName}`);
-    },
-
-    setCacheData(formName, name, value) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.cacheData;
-          set(oldValues, `${formName}.${name}`, value);
-        }),
-      );
-    },
-
-    clearCacheData(formName) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.cacheData;
-
-          if (formName) {
-            set(oldValues, formName, {});
-          } else {
-            set(oldValues, "", {});
-          }
-        }),
-      );
-    },
+// Form Store Slice
+const createFormStoreSlice = (storeSet: any, storeGet: any, api: any) => ({
+  forms: {},
+  initialValues: {},
+  formStates: {},
+  cacheData: {},
+  formInstances: [],
+  submitHistory: {},
+  setData(formName, name, value) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.forms;
+        set(oldValues, `${formName}.${name}`, value);
+      }),
+    );
+  },
+
+  getCacheData(formName) {
+    return get(storeGet(), `cacheData.${formName}`);
+  },
+
+  setCacheData(formName, name, value) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.cacheData;
+        set(oldValues, `${formName}.${name}`, value);
+      }),
+    );
+  },
 
-    getFormItemValue(formName, name) {
-      return get(storeGet().forms?.[formName], name);
-    },
+  clearCacheData(formName) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.cacheData;
 
-    getFormValues(formName) {
-      return storeGet().forms?.[formName];
-    },
+        if (formName) {
+          set(oldValues, formName, {});
+        } else {
+          set(oldValues, "", {});
+        }
+      }),
+    );
+  },
 
-    clearFormValues(formName) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.forms;
+  getFormItemValue(formName, name) {
+    return get(storeGet().forms?.[formName], name);
+  },
 
-          // console.log("Clear form values", formName);
+  getFormValues(formName) {
+    return storeGet().forms?.[formName];
+  },
 
-          unset(oldValues, formName);
+  clearFormValues(formName) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.forms;
 
-          // console.log(JSON.parse(JSON.stringify(oldValues)));
-        }),
-      );
-    },
+        // console.log("Clear form values", formName);
 
-    clearFormInitialValues(formName) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.initialValues;
+        unset(oldValues, formName);
 
-          // console.log("Clear form initial values", formName);
+        // console.log(JSON.parse(JSON.stringify(oldValues)));
+      }),
+    );
+  },
 
-          unset(oldValues, formName);
+  clearFormInitialValues(formName) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.initialValues;
 
-          // console.log(JSON.parse(JSON.stringify(oldValues)));
-        }),
-      );
-    },
+        // console.log("Clear form initial values", formName);
 
-    clearObjKeyItem(formName, name) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.forms;
+        unset(oldValues, formName);
 
-          // console.log("Clear item value", formName, name);
+        // console.log(JSON.parse(JSON.stringify(oldValues)));
+      }),
+    );
+  },
 
-          unset(oldValues, `${formName}.${name}`);
+  clearObjKeyItem(formName, name) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.forms;
 
-          // console.log(JSON.parse(JSON.stringify(oldValues)));
-        }),
-      );
-    },
-    clearArrItem(formName, name) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.forms;
+        // console.log("Clear item value", formName, name);
 
-          console.log("Clear item array value", formName, name);
+        unset(oldValues, `${formName}.${name}`);
 
+        // console.log(JSON.parse(JSON.stringify(oldValues)));
+      }),
+    );
+  },
+  clearArrItem(formName, name) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.forms;
+
+        console.log("Clear item array value", formName, name);
+
+        const arrPath = name.split(".").slice(0, -1).join(".");
+
+        const elPath = Number(name.split(".").slice(-1).join(""));
+
+        const getArrItem = get(oldValues, `${formName}.${arrPath}`);
+
+        if (isNumber(elPath)) {
+          getArrItem.splice(elPath, 1);
+        }
+
+        // console.log(JSON.parse(JSON.stringify(oldValues)));
+      }),
+    );
+  },
+
+  clearArrItems(clearItems: { formName: string; name: string }[]) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.forms;
+
+        console.log("Clear item array values: ", clearItems);
+
+        clearItems.forEach(({ formName, name }) => {
           const arrPath = name.split(".").slice(0, -1).join(".");
 
           const elPath = Number(name.split(".").slice(-1).join(""));
@@ -157,207 +202,208 @@ export const useFormStore = create<FormStoreState>(
           if (isNumber(elPath)) {
             getArrItem.splice(elPath, 1);
           }
+        });
+
+        // console.log(JSON.parse(JSON.stringify(oldValues)));
+      }),
+    );
+  },
 
-          // console.log(JSON.parse(JSON.stringify(oldValues)));
-        }),
-      );
-    },
-
-    setFormState({ formName, isInitied, submitState }) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.formStates;
-          const getFormState = get(storeGet().formStates, formName);
-
-          if (isNil(getFormState)) {
-            set(oldValues, formName, { isInitied, submitState });
-          } else {
-            if (!isNil(isInitied)) {
-              set(oldValues, `${formName}.isInitied`, isInitied);
-            }
-
-            if (!isNil(submitState)) {
-              set(oldValues, `${formName}.submitState`, submitState);
-            }
+  setFormState({ formName, isInitied, submitState }) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.formStates;
+        const getFormState = get(storeGet().formStates, formName);
+
+        if (isNil(getFormState)) {
+          set(oldValues, formName, { isInitied, submitState });
+        } else {
+          if (!isNil(isInitied)) {
+            set(oldValues, `${formName}.isInitied`, isInitied);
           }
-        }),
-      );
-    },
-
-    clearFormState(formName) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.formStates;
-
-          // console.log("Clear form state", formName);
-
-          unset(oldValues, formName);
-
-          // console.log(JSON.parse(JSON.stringify(oldValues)));
-        }),
-      );
-    },
-
-    getFormState(formName) {
-      return get(storeGet(), `formStates.${formName}`);
-    },
-
-    setFormInitData(formName, initValues) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.initialValues;
-          const listInitPath = getAllNoneObjStringPath(initValues);
-
-          // console.log({ listInitPath, initValues });
-
-          listInitPath.forEach((k) => {
-            if (get(initValues, k)) {
-              // console.log("init form data values: ", k, get(initValues, k));
-              set(oldValues, `${formName}.${k}`, get(initValues, k));
-            }
-          });
-        }),
-      );
-    },
-
-    getInitData(formName, name) {
-      return get(storeGet().initialValues, `${formName}.${name}`);
-    },
-
-    setInitData(formName, name, value) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = state.initialValues;
-          console.log("Inner init: ", `${formName}.${name}`, value);
-          set(oldValues, `${formName}.${name}`, value);
-        }),
-      );
-    },
-
-    setFormInstance({
-      formName,
-      resetFields,
-      submit,
-      submitAsync,
-      setFieldValue,
-      setFieldValues,
-      getFieldValue,
-      getFieldValues,
-      getFieldErrors,
-      setFieldFocus,
-    }) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const storeListeners = state.formInstances;
-          const findListenerIndex = storeListeners.findIndex(
-            (l) => l.formName === formName,
-          );
-          if (findListenerIndex > -1) {
-            if (!isNil(resetFields)) {
-              storeListeners[findListenerIndex].resetFields = resetFields;
-            }
-            if (!isNil(submit)) {
-              storeListeners[findListenerIndex].submit = submit;
-            }
-            if (!isNil(setFieldFocus)) {
-              storeListeners[findListenerIndex].setFieldFocus = setFieldFocus;
-            }
-            if (!isNil(submitAsync)) {
-              storeListeners[findListenerIndex].submitAsync = submitAsync;
-            }
-
-            if (!isNil(setFieldValue)) {
-              storeListeners[findListenerIndex].setFieldValue = setFieldValue;
-            }
-
-            if (!isNil(setFieldValues)) {
-              storeListeners[findListenerIndex].setFieldValues = setFieldValues;
-            }
-
-            if (!isNil(getFieldValue)) {
-              storeListeners[findListenerIndex].getFieldValue = getFieldValue;
-            }
-
-            if (!isNil(getFieldValues)) {
-              storeListeners[findListenerIndex].getFieldValues = getFieldValues;
-            }
-
-            if (!isNil(getFieldErrors)) {
-              storeListeners[findListenerIndex].getFieldErrors = getFieldErrors;
-            }
-
-            return;
+
+          if (!isNil(submitState)) {
+            set(oldValues, `${formName}.submitState`, submitState);
+          }
+        }
+      }),
+    );
+  },
+
+  clearFormState(formName) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.formStates;
+
+        // console.log("Clear form state", formName);
+
+        unset(oldValues, formName);
+
+        // console.log(JSON.parse(JSON.stringify(oldValues)));
+      }),
+    );
+  },
+
+  getFormState(formName) {
+    return get(storeGet(), `formStates.${formName}`);
+  },
+
+  setFormInitData(formName, initValues) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.initialValues;
+        const listInitPath = getAllNoneObjStringPath(initValues);
+
+        // console.log({ listInitPath, initValues });
+
+        listInitPath.forEach((k) => {
+          if (get(initValues, k)) {
+            // console.log("init form data values: ", k, get(initValues, k));
+            set(oldValues, `${formName}.${k}`, get(initValues, k));
+          }
+        });
+      }),
+    );
+  },
+
+  getInitData(formName, name) {
+    return get(storeGet().initialValues, `${formName}.${name}`);
+  },
+
+  setInitData(formName, name, value) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = state.initialValues;
+        console.log("Inner init: ", `${formName}.${name}`, value);
+        set(oldValues, `${formName}.${name}`, value);
+      }),
+    );
+  },
+
+  setFormInstance({
+    formName,
+    resetFields,
+    submit,
+    submitAsync,
+    setFieldValue,
+    setFieldValues,
+    getFieldValue,
+    getFieldValues,
+    getFieldErrors,
+    setFieldFocus,
+  }) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const storeListeners = state.formInstances;
+        const findListenerIndex = storeListeners.findIndex(
+          (l) => l.formName === formName,
+        );
+        if (findListenerIndex > -1) {
+          if (!isNil(resetFields)) {
+            storeListeners[findListenerIndex].resetFields = resetFields;
+          }
+          if (!isNil(submit)) {
+            storeListeners[findListenerIndex].submit = submit;
+          }
+          if (!isNil(setFieldFocus)) {
+            storeListeners[findListenerIndex].setFieldFocus = setFieldFocus;
+          }
+          if (!isNil(submitAsync)) {
+            storeListeners[findListenerIndex].submitAsync = submitAsync;
           }
-          storeListeners.push({
-            formName,
-            resetFields,
-            submit,
-            submitAsync,
-            setFieldValue,
-            setFieldValues,
-            getFieldValue,
-            getFieldValues,
-            getFieldErrors,
-            setFieldFocus,
-          });
-        }),
-      );
-    },
-    revokeFormInstance({ formName }) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const instances = state.formInstances;
-
-          const findInstanceIndex = instances.findIndex(
-            (l) => l.formName == formName,
-          );
 
-          // console.log("Find item for revoke: ", findListenerIndex, formItemId);
+          if (!isNil(setFieldValue)) {
+            storeListeners[findListenerIndex].setFieldValue = setFieldValue;
+          }
 
-          if (findInstanceIndex > -1) {
-            // const listenersInfo = cloneDeep(instances[findInstanceIndex]);
+          if (!isNil(setFieldValues)) {
+            storeListeners[findListenerIndex].setFieldValues = setFieldValues;
+          }
 
-            instances.splice(findInstanceIndex, 1);
+          if (!isNil(getFieldValue)) {
+            storeListeners[findListenerIndex].getFieldValue = getFieldValue;
+          }
 
-            // onAfterRevoke(
-            //   listenersInfo,
-            //   instances.filter(
-            //     (l) =>
-            //       l.name === listenersInfo.name &&
-            //       l.formName === listenersInfo.formName &&
-            //       l.formItemId !== listenersInfo.formItemId
-            //   )
-            // );
+          if (!isNil(getFieldValues)) {
+            storeListeners[findListenerIndex].getFieldValues = getFieldValues;
           }
-        }),
-      );
-    },
-
-    getCurrentSubmit(formName) {
-      return last(get(storeGet().submitHistory, formName)) || null;
-    },
-    getSubmitHistory(formName) {
-      return get(storeGet().submitHistory, formName);
-    },
-    setSubmitHistory(formName, submitData) {
-      return storeSet(
-        produce<any>((state: any) => {
-          const oldValues = get(state.submitHistory, formName);
-          if (oldValues) {
-            oldValues.push(submitData);
-            oldValues.splice(0, oldValues.length - 3);
-          } else {
-            set(state.submitHistory, formName, [submitData]);
+
+          if (!isNil(getFieldErrors)) {
+            storeListeners[findListenerIndex].getFieldErrors = getFieldErrors;
           }
-          console.log("Submit history: ", formName);
-        }),
-      );
-    },
-  }),
-);
-
-export const useFormListeners = create<any>((storeSet: any, storeGet: any) => ({
-  listeners: [],
+
+          return;
+        }
+        storeListeners.push({
+          formName,
+          resetFields,
+          submit,
+          submitAsync,
+          setFieldValue,
+          setFieldValues,
+          getFieldValue,
+          getFieldValues,
+          getFieldErrors,
+          setFieldFocus,
+        });
+      }),
+    );
+  },
+  revokeFormInstance({ formName }) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const instances = state.formInstances;
+
+        const findInstanceIndex = instances.findIndex(
+          (l) => l.formName == formName,
+        );
+
+        // console.log("Find item for revoke: ", findListenerIndex, formItemId);
+
+        if (findInstanceIndex > -1) {
+          // const listenersInfo = cloneDeep(instances[findInstanceIndex]);
+
+          instances.splice(findInstanceIndex, 1);
+
+          // onAfterRevoke(
+          //   listenersInfo,
+          //   instances.filter(
+          //     (l) =>
+          //       l.name === listenersInfo.name &&
+          //       l.formName === listenersInfo.formName &&
+          //       l.formItemId !== listenersInfo.formItemId
+          //   )
+          // );
+        }
+      }),
+    );
+  },
+
+  getCurrentSubmit(formName) {
+    return last(get(storeGet().submitHistory, formName)) || null;
+  },
+  getSubmitHistory(formName) {
+    return get(storeGet().submitHistory, formName);
+  },
+  setSubmitHistory(formName, submitData) {
+    return storeSet(
+      produce<any>((state: any) => {
+        const oldValues = get(state.submitHistory, formName);
+        if (oldValues) {
+          oldValues.push(submitData);
+          oldValues.splice(0, oldValues.length - 3);
+        } else {
+          set(state.submitHistory, formName, [submitData]);
+        }
+        console.log("Submit history: ", formName);
+      }),
+    );
+  },
+});
+
+// Listeners Slice
+const createListenersSlice = (storeSet: any, storeGet: any, api: any) => ({
+  listeners: [] as ListenerItem[],
   getListener(formItemId) {
     return storeGet().listeners.find((l) => l.formItemId === formItemId);
   },
@@ -376,7 +422,11 @@ export const useFormListeners = create<any>((storeSet: any, storeGet: any) => ({
     onFocus,
     emitFocus,
     isInitied,
-  }) {
+    type,
+    onArrayChange,
+    hidden,
+    collectOnHidden,
+  }: Partial<ListenerItem> & { formItemId: string }) {
     return storeSet(
       produce<any>((state: any) => {
         const storeListeners = state.listeners;
@@ -417,6 +467,18 @@ export const useFormListeners = create<any>((storeSet: any, storeGet: any) => ({
             storeListeners[findListenerIndex].isInitied = isInitied;
           }
 
+          if (!isNil(onArrayChange)) {
+            storeListeners[findListenerIndex].onArrayChange = onArrayChange;
+          }
+
+          if (!isNil(hidden)) {
+            storeListeners[findListenerIndex].hidden = hidden;
+          }
+
+          if (!isNil(collectOnHidden)) {
+            storeListeners[findListenerIndex].collectOnHidden = collectOnHidden;
+          }
+
           return;
         }
         storeListeners.push({
@@ -429,6 +491,12 @@ export const useFormListeners = create<any>((storeSet: any, storeGet: any) => ({
           onChange,
           onReset,
           isInitied: Boolean(isInitied),
+          type: type || "normal",
+          onArrayChange,
+          onFocus,
+          emitFocus,
+          hidden: Boolean(hidden),
+          collectOnHidden,
         });
       }),
     );
@@ -462,9 +530,10 @@ export const useFormListeners = create<any>((storeSet: any, storeGet: any) => ({
       }),
     );
   },
-}));
+});
 
-export const useFormCleanUp = create<any>((storeSet: any) => ({
+// CleanUp Slice
+const createCleanUpSlice = (storeSet: any, storeGet: any, api: any) => ({
   cleanUpStack: [],
   setCleanUpStack({ name, type, itemKey, formName }) {
     return storeSet(
@@ -482,4 +551,15 @@ export const useFormCleanUp = create<any>((storeSet: any) => ({
       }),
     );
   },
+});
+
+// Combined Store
+export const useFormStore = create<FormStoreState>((...a) => ({
+  ...createFormStoreSlice(...a),
+  ...createListenersSlice(...a),
+  ...createCleanUpSlice(...a),
 }));
+
+// Deprecated exports - use useFormStore instead
+export const useFormListeners = useFormStore;
+export const useFormCleanUp = useFormStore;