@hw-component/form 0.0.4 → 0.0.5-beta-v1

package/src/components/Form/config.ts

@@ -0,0 +1,43 @@
+import HSelect from "../Select";
+import HInput from "../Input";
+import HInputNumber from "../Input/InputNumber";
+import HSelectInput from "../Input/SelectInput";
+import HButtonInput from "../Input/ButtonInput";
+import HCheckboxGroup from "../CheckboxGroup";
+import HCheckBox from "../CheckboxGroup/CheckBox";
+import HRadioGroup from "../RadioGroup";
+import HSwitch from "../Switch";
+import HDatePicker from "../TDPicker";
+import HRangePicker from "../TDPicker/RangePicker";
+import HTimePicker from "../TDPicker/TimePicker";
+import HUpload from "../Upload";
+import HUrlUpload from "../Upload/UrlUpload";
+import HSubmit from "../Submit";
+import TextArea from "../TextArea";
+import ColorInput from "../Input/ColorInput";
+
+export const placeholderConfig = {
+  inputType: ["input", "inputNumber", "selectInput", "buttonInput"],
+  selectType: ["select", "datePicker", "timePicker", "colorInput"],
+};
+const componentConfig = {
+  select: HSelect,
+  inputNumber: HInputNumber,
+  selectInput: HSelectInput,
+  buttonInput: HButtonInput,
+  checkboxGroup: HCheckboxGroup,
+  checkBox: HCheckBox,
+  radioGroup: HRadioGroup,
+  switch: HSwitch,
+  datePicker: HDatePicker,
+  rangePicker: HRangePicker,
+  timePicker: HTimePicker,
+  input: HInput,
+  upload: HUpload,
+  urlUpload: HUrlUpload,
+  submit: HSubmit,
+  textArea: TextArea,
+  colorInput: ColorInput,
+};
+
+export default componentConfig;

package/src/components/Form/hooks/index.ts

@@ -0,0 +1,111 @@
+import { useRequest } from "ahooks";
+import type { HFormProps, HFormInstance } from "../modal";
+import useHForm from "./useHForm";
+import { useEffect, useMemo } from "react";
+import FormConfig from "../config";
+import { useFormConfigContext } from "../Context/FormConfigProvider";
+import type { DispatchModal } from "../modal";
+
+interface UseValuesChangeModal {
+  onValuesChange: HFormProps["onValuesChange"];
+  dispatch: DispatchModal;
+  form: HFormInstance;
+}
+
+export const useCurrentForm = (form?: HFormInstance) => {
+  const selfForm = useHForm();
+  return form || selfForm;
+};
+type ParamsModal = Omit<HFormProps, "configData">;
+
+export const useInfoReq = ({
+  initialValues,
+  infoRequest,
+  form,
+  params,
+  request,
+  onFinish,
+}: ParamsModal) => {
+  const reqData = useMemo(() => {
+    const saveParams = params || {};
+    return {
+      params: saveParams,
+    };
+  }, [params]);
+
+  const subControl = useRequest(
+    async (value) => {
+      const subVal = form?.outputValues(value);
+      if (request) {
+        await request(subVal, reqData.params);
+      }
+      onFinish?.(subVal, reqData.params);
+    },
+    { manual: true }
+  );
+  const infoControl = useRequest(async (reqParams = reqData.params) => {
+    let setValue = initialValues;
+    reqData.params = reqParams;
+    if (!initialValues && !infoRequest) {
+      return {};
+    }
+    if (infoRequest) {
+      setValue = await infoRequest(reqParams);
+    }
+    form?.setFieldsValue(setValue);
+    return setValue || {};
+  });
+  const { run, mutate } = infoControl;
+  useEffect(() => {
+    if (form) {
+      form.reload = (reloadParams) => {
+        mutate(undefined);
+        return run(reloadParams);
+      };
+    }
+  }, []);
+  return {
+    subControl,
+    infoControl,
+  };
+};
+
+export const useDefaultComponents = () => {
+  const defaultComponent = useFormConfigContext("defaultComponent");
+  return { ...FormConfig, ...defaultComponent };
+};
+
+const dispatchControl=(form:HFormInstance,params,dispatch?:Record<string, DispatchModal>)=>{
+   if (!dispatch){
+      return;
+   }
+  const dispatchKey = Object.keys(dispatch);
+  dispatchKey.forEach((name) => {
+    const { fnKey, reset } = dispatch[name];
+    if (reset) {
+      form.setFields([{ name, value: null, errors: [] }]);
+    }
+    if (!fnKey){
+      return;
+    }
+    form.dispatch(
+        {
+          key: fnKey,
+          name,
+        },
+        params
+    );
+  });
+};//触发
+export const useValuesChange = ({
+  onValuesChange,
+  dispatch,
+  form,
+}: UseValuesChangeModal) => {
+  return (changedValues: any, values: any) => {
+    const changeKey = Object.keys(changedValues)[0];
+    const dispatchItem = dispatch[changeKey];
+    dispatchControl(form,{ changedValues,oldValues: values},dispatchItem);
+    onValuesChange?.(changedValues, values);
+  };
+};

package/src/components/Form/hooks/useDefaultRender.tsx

@@ -0,0 +1,42 @@
+import type {
+  DefaultComponentModal,
+  HFormItemProps,
+  ConfigComponentModal,
+} from "../modal";
+import FormConfig from "../config";
+import type { FormInstance } from "antd";
+import React from "react";
+
+export const useDefaultRender = (
+  props: HFormItemProps,
+  defaultComponents: DefaultComponentModal
+) => {
+  const {
+    render,
+    labelWidth,
+    colon,
+    type = "input",
+    itemProps = {},
+    ...componentProps
+  } = props;
+  const mergeComponent = { ...FormConfig, ...defaultComponents };
+  const dom = mergeComponent[type];
+  return (form: FormInstance) => {
+    let Component = dom;
+    if ((dom as ConfigComponentModal)?.Component) {
+      Component = (dom as ConfigComponentModal).Component;
+    }
+    const node = Component && (
+      <Component {...componentProps} {...itemProps} form={form} />
+    );
+    if (render) {
+      const resultNode = render(props, node, form);
+      return React.cloneElement<any>(resultNode as any, {
+        ...componentProps,
+        ...itemProps,
+        form,
+      });
+    }
+    return node;
+  };
+};

package/src/components/Form/hooks/useHForm.ts

@@ -0,0 +1,164 @@
+import { useMemo } from "react";
+import { Form } from "antd";
+import type { FormatItemModal, HFormInstance } from "../modal";
+import type { argsFn } from "../modal";
+
+interface DispatchItemData {
+  keysFn: Record<string, argsFn>;
+  defaultFn: argsFn[];
+}
+
+export default () => {
+  const [form] = Form.useForm();
+  return useMemo<HFormInstance>(() => {
+    const formatSourceData: Record<string, FormatItemModal> = {};
+    let dispatchSourceData: Record<string, DispatchItemData> = {};
+    const initDispatch: Record<string, argsFn> = {};
+    let cacheValues: Record<string, any> = {};
+    let isLoading = false;
+
+    const norAddItemDispatch = (name, manual, fn) => {
+      if (manual === false && name) {
+        initDispatch[name] = fn;
+      }
+      if (!name) {
+        return {
+          keysFn: {},
+          defaultFn: [fn],
+        };
+      }
+      return {
+        keysFn: {
+          [name]: fn,
+        },
+        defaultFn: [],
+      };
+    };
+    return {
+      reload: (params) => {
+        return Promise.resolve(params);
+      },
+      initValues() {
+        let newValue = {};
+        if (cacheValues) {
+          newValue = this.formatValues(cacheValues);
+          form.setFieldsValue(newValue);
+        }
+        const initKeys = Object.keys(initDispatch);
+        initKeys.forEach((key) => {
+          initDispatch[key]({ changedValues: newValue, oldValues: newValue });
+        });
+        isLoading = true;
+      },
+      addFormat(name: string, format?: FormatItemModal) {
+        if (!format) {
+          return;
+        }
+        const { inputValue, outputValue } = format;
+        formatSourceData[name] = {
+          inputValue,
+          outputValue,
+        };
+      }, //注册转化方法
+      formatValues(value = {}, formatKey = "inputValue") {
+        const valKeys = Object.keys(value).length;
+        if (!valKeys) {
+          return {};
+        }
+        let newValue = { ...value };
+        const keys = Object.keys(formatSourceData);
+        keys.forEach((key) => {
+          const format = formatSourceData[key]?.[formatKey];
+          if (!format) {
+            return;
+          }
+          const resultValue = format(value);
+          Reflect.deleteProperty(newValue, key);
+          newValue = {
+            ...newValue,
+            ...resultValue,
+          };
+        });
+        return newValue;
+      }, //转化方法
+      dispatch(action, ...args) {
+        const { key, name } = action;
+        const items = dispatchSourceData[key];
+        if (!items) {
+          return;
+        }
+        const { keysFn, defaultFn } = items;
+        if (name) {
+          return keysFn[name]?.(...args);
+        }
+        const fnArrays = Object.keys(keysFn).map((itemKey) => {
+          return keysFn[itemKey];
+        }); //不存在name就合并
+        [...fnArrays, ...defaultFn].forEach((fn) => {
+          fn(...args);
+        });
+      },
+      addDispatchListener(action, fn) {
+        const { key, name, dispatch = {} } = action;
+        const { manual } = dispatch;
+        const items = dispatchSourceData[key];
+        if (!items) {
+          dispatchSourceData[key] = norAddItemDispatch(name, manual, fn);
+          return;
+        }
+        const { keysFn, defaultFn } = items;
+        if (name) {
+          keysFn[name] = fn;
+        } else {
+          defaultFn.push(fn);
+        }
+        if (manual === false && name) {
+          initDispatch[name] = fn;
+        }
+        dispatchSourceData[key] = {
+          keysFn,
+          defaultFn,
+        };
+      },
+      removeDispatchListener(action) {
+        if (!action) {
+          dispatchSourceData = {};
+          return;
+        }
+        const { key, name } = action;
+        const items = dispatchSourceData[key];
+        if (!items) {
+          return;
+        }
+        if (name) {
+          const { keysFn } = items;
+          Reflect.deleteProperty(keysFn, name);
+          items.keysFn = keysFn;
+          dispatchSourceData[key] = items;
+          return;
+        }
+        Reflect.deleteProperty(dispatchSourceData, key);
+      },
+      outputValues(value) {
+        return this.formatValues(value, "outputValue");
+      },
+      ...form,
+      setFieldsValue(values) {
+        if (!isLoading) {
+          cacheValues = values;
+          return;
+        }
+        const newValue = this.formatValues(values);
+        form.setFieldsValue(newValue);
+      },
+      validateFields(nameList) {
+        return new Promise((resolve) => {
+          form.validateFields(nameList).then((value) => {
+            const result = this.formatValues(value, "outputValue");
+            return resolve(result);
+          });
+        });
+      },
+    };
+  }, []);
+};

package/src/components/Form/hooks/useInitConfigData.tsx

@@ -0,0 +1,194 @@
+import React, { useMemo } from "react";
+import type {
+  HFormItemProps,
+  HFormProps,
+  HItemProps,
+  DefaultComponentModal,
+} from "../modal";
+import { placeholderConfig } from "../config";
+import type { Rule } from "rc-field-form/lib/interface";
+import type { FormInstance } from "antd";
+import { useDefaultComponents } from "../hooks";
+import type { ConfigComponentModal } from "../modal";
+import type { DispatchSourceDataModal } from "../modal";
+import type { DispatchModal } from "../modal";
+
+const mathRequired = (
+  configItem: HFormItemProps,
+  form: FormInstance,
+  defaultComponents: DefaultComponentModal
+) => {
+  const { required, placeholder, rules, type = "input" } = configItem;
+  let resultRequired = false;
+  const dom = defaultComponents[type];
+  const resultRules = rules?.map((item) => {
+    let eachItem = item;
+    if (typeof item === "function") {
+      eachItem = item(form);
+    }
+
+    const { required: itemRequired, message } = eachItem as any;
+    if (itemRequired) {
+      resultRequired = itemRequired;
+    }
+    if (itemRequired && !message) {
+      let msg = placeholder;
+      const itemDom = dom as ConfigComponentModal;
+      if (itemDom?.requiredErrMsg) {
+        msg = itemDom.requiredErrMsg(configItem);
+      }
+      return {
+        ...eachItem,
+        required: itemRequired,
+        message: msg,
+      };
+    }
+    return eachItem;
+  });
+  return {
+    required: typeof required === "boolean" ? required : resultRequired,
+    rules: resultRules as Rule[],
+  };
+}; //是否必填
+const matchDefaultPlaceholder = (
+  props: HFormItemProps,
+  defaultComponents: DefaultComponentModal
+) => {
+  const { label, placeholder, type = "input" } = props;
+  const dom = defaultComponents[type];
+  if (placeholder) {
+    return placeholder;
+  }
+  const itemDom = dom as ConfigComponentModal;
+  if (itemDom?.placeholder) {
+    return itemDom.placeholder(props);
+  }
+  if (placeholderConfig.inputType.indexOf(type) !== -1) {
+    return `请输入${label}`;
+  }
+  return `请选择${label}`;
+}; //自动构建
+
+const defaultPlaceholderPropsMaker = (
+  props: HFormItemProps,
+  defaultComponents: DefaultComponentModal
+) => {
+  const placeholder = matchDefaultPlaceholder(props, defaultComponents);
+  return {
+    ...props,
+    placeholder,
+  };
+}; //组装参数
+const itemControl = (
+  item: HItemProps,
+  form: FormInstance,
+  defaultComponents: DefaultComponentModal
+): HFormItemProps => {
+  const { render, ...defaultProps } = defaultPlaceholderPropsMaker(
+    item,
+    defaultComponents
+  );
+  const { rules, required } = mathRequired(
+    defaultProps,
+    form,
+    defaultComponents
+  );
+  return {
+    ...defaultProps,
+    required,
+    rules,
+    render,
+  };
+};
+const itemDispatchProvider = (
+  name: string,
+  config: Required<DispatchModal<string>>,
+  dispatchSourceData: DispatchSourceDataModal
+) => {
+  const { dependencies, fnKey, reset } = config;
+  const itemDispatch = dispatchSourceData[dependencies as string];
+  if (!itemDispatch) {
+    return {
+      [dependencies]: {
+        [name]: {
+          fnKey,
+          reset,
+        },
+      },
+    };
+  }
+  const itemNameDispatch = {
+    [name]: {
+      fnKey,
+      reset,
+    },
+  };
+  return {
+    [dependencies]: {
+      ...itemDispatch,
+      ...itemNameDispatch,
+    },
+  };
+};
+const dispatchProvider = (
+  item: HItemProps,
+  dispatchSourceData: DispatchSourceDataModal
+) => {
+  const { name = "", dispatch = {}, dependencies = "allDependencies" } = item;
+  const {
+    fnKey,
+    dependencies: dispatchDependencies = dependencies as string | string[],
+    manual = true,
+    reset = true,
+  } = dispatch;
+  if (!fnKey) {
+    return {};
+  }
+  if (Array.isArray(dispatchDependencies)) {
+    let allDispatch: DispatchSourceDataModal = {
+      ...dispatchSourceData,
+    };
+    dispatchDependencies.forEach((key) => {
+      const itemDispatch = itemDispatchProvider(
+        name,
+        { dependencies: key, fnKey, manual, reset },
+        dispatchSourceData
+      );
+      allDispatch = {
+        ...allDispatch,
+        ...itemDispatch,
+      };
+    });
+    return allDispatch;
+  }
+  const itemDispatch = itemDispatchProvider(
+    name,
+    { dependencies: dispatchDependencies, fnKey, manual, reset },
+    dispatchSourceData
+  );
+  return {
+    ...dispatchSourceData,
+    ...itemDispatch,
+  };
+};
+type InitConfigModal = Required<Pick<HFormProps, "configData" | "form">>;
+
+export default ({ configData, form }: InitConfigModal) => {
+  const defaultComponents = useDefaultComponents();
+  return useMemo(() => {
+    const newConfigData: HItemProps[] = [];
+    let dispatchSourceData: DispatchSourceDataModal = {};
+    configData.forEach((item) => {
+      const itemDispatch = dispatchProvider(item, dispatchSourceData);
+      dispatchSourceData = {
+        ...dispatchSourceData,
+        ...itemDispatch,
+      };
+      newConfigData.push(itemControl(item, form, defaultComponents));
+    });
+    return {
+      newConfigData,
+      dispatchSourceData,
+    };
+  }, [configData]);
+};

package/src/components/Form/index.less

@@ -0,0 +1,22 @@
+@import "../styles/local.less";
+.@{ant-prefix}-hw-form-item-colon:after {
+  position: relative;
+  top: -0.5px;
+  margin: 0 0 0 2px;
+  content: ":";
+}
+.@{ant-prefix}-hw-form-item-required:before {
+  display: inline-block;
+  margin-right: 4px;
+  color: #ff4d4f;
+  font-size: 14px;
+  font-family: SimSun, sans-serif;
+  line-height: 1;
+  content: "*";
+}
+
+.@{ant-prefix}-hw-form-base-item {
+  display: flex;
+  align-items: center;
+  min-height: 32px;
+}

package/src/components/Form/index.tsx

@@ -0,0 +1,85 @@
+import { Form } from "antd";
+import type { HFormProps, HItemProps } from "./modal";
+import Item from "./FormItem";
+import { useCurrentForm, useInfoReq, useValuesChange } from "./hooks";
+import { FormContext } from "./Context";
+import PageHandler from "../PageHandler";
+import useInitConfigData from "./hooks/useInitConfigData";
+import { useEffect } from "react";
+import InitSet from "./InitSet";
+
+export default ({
+  configData,
+  labelWidth,
+  form,
+  request,
+  onFinish,
+  infoRequest,
+  valueType = "float",
+  initialValues,
+  params = {},
+  onValuesChange,
+  ...props
+}: HFormProps) => {
+  const hForm = useCurrentForm(form);
+  const { newConfigData, dispatchSourceData } = useInitConfigData({
+    configData,
+    form: hForm,
+  });
+  const { subControl, infoControl } = useInfoReq({
+    initialValues,
+    request,
+    onFinish,
+    valueType,
+    form: hForm,
+    infoRequest,
+    params,
+  });
+  const valuesChange = useValuesChange({
+    onValuesChange,
+    dispatch: dispatchSourceData,
+    form: hForm,
+  });
+  const { run, loading } = subControl;
+  const {
+    run: infoRun,
+    loading: infoLoading,
+    error: infoErr,
+    data: infoData,
+  } = infoControl;
+
+  useEffect(() => {
+    return () => {
+      hForm.removeDispatchListener();
+    };
+  }, []);
+  return (
+    <PageHandler
+      loading={infoLoading}
+      error={infoErr}
+      data={infoData}
+      reload={infoRun}
+    >
+      <FormContext.Provider value={{ loading, form: hForm, valueType }}>
+        <Form
+          form={hForm}
+          onFinish={run}
+          onValuesChange={valuesChange}
+          {...props}
+        >
+          {newConfigData.map((itemData: HItemProps, index) => {
+            const { labelWidth: itemLabelWidth } = itemData;
+            return (
+              <Item
+                {...itemData}
+                key={index}
+                labelWidth={itemLabelWidth || labelWidth}
+              />
+            );
+          })}
+          <InitSet />
+        </Form>
+      </FormContext.Provider>
+    </PageHandler>
+  );
+};