@hw-component/form 0.0.1 → 0.0.2-bate

package/src/components/Form/modal.ts

@@ -0,0 +1,142 @@
+import type { FormInstance, FormItemProps, FormProps } from "antd";
+import type { HCheckboxProps } from "@/components/CheckboxGroup/modal";
+import type React from "react";
+import type {
+  HButtonProps,
+  HInputProps,
+  HSelectInputProps,
+} from "@/components/Input/modal";
+import type { HRadioGroupProps } from "@/components/RadioGroup";
+import type { HSelectProps } from "@/components/Select/modal";
+import type { ButtonProps } from "antd/es";
+import type { HSwitchProps } from "@/components/Switch";
+import type {
+  HDatePickerProps,
+  HRangePickerProps,
+  HTimePickerProps,
+} from "@/components/TDPicker/modal";
+import type { TextAreaProps } from "antd/es/input";
+import type { IUpLoadProps } from "@/components/Upload/modal";
+import type { SelectProps } from "antd";
+import type { RangePickerProps } from "antd/es/date-picker";
+import type {
+  PromiseFnResult,
+  ValueCheckMapModal,
+  ValueSwitchMapModal,
+  DateRangePickerValueMapModal,
+} from "../modal";
+type RenderFun = (
+  props: HItemProps,
+  node: React.ReactNode,
+  form: FormInstance
+) => void;
+type ItemPropsType =
+  | HCheckboxProps
+  | HInputProps
+  | HSelectInputProps
+  | HButtonProps
+  | HRadioGroupProps
+  | HSelectProps
+  | ButtonProps
+  | HSwitchProps
+  | HDatePickerProps
+  | HRangePickerProps
+  | HTimePickerProps
+  | TextAreaProps
+  | IUpLoadProps;
+
+export interface HoverModal {
+  text?: string;
+  icon?: React.ReactNode;
+}
+type HelperModal = (form: HFormInstance) => React.ReactNode | string;
+
+export type HideModal = (form: HFormInstance) => boolean;
+
+export interface HItemProps extends Omit<FormItemProps, "name"> {
+  type?: string;
+  itemProps?: ItemPropsType;
+  render?: RenderFun;
+  helper?: HelperModal;
+  hover?: string | HoverModal;
+  // formItems?: HItemProps[]; 保留感觉没必要
+  labelWidth?: number;
+  hide?: boolean | HideModal;
+  placeholder?: string | string[];
+  formatKeys?: string[];
+  name: string;
+}
+
+export interface HFormProps<T = any, R = any> extends Omit<FormProps, "form"> {
+  configData: HItemProps[];
+  labelWidth?: number;
+  request?: PromiseFnResult<T, R>;
+  infoRequest?: () => Promise<T>;
+  valueType?: string;
+  form?: HFormInstance;
+}
+
+export interface HFormItemProps extends HItemProps {
+  required?: boolean;
+}
+export interface FormItemWithRender extends Omit<HFormItemProps, "render"> {
+  render: (form: HFormInstance) => React.ReactNode;
+}
+
+export interface FormContextProps {
+  loading?: boolean;
+  form: HFormInstance;
+  valueType?: string;
+}
+interface ConfigUploadProps {
+  exFiles?: string[];
+  maxSize?: number;
+  request?: PromiseFnResult;
+}
+
+export interface IFormConfigContextProps {
+  fieldNames?: SelectProps["fieldNames"];
+  valueCheckMap?: ValueCheckMapModal;
+  valueSwitchMap?: ValueSwitchMapModal;
+  valueRangePickerValueMap?: DateRangePickerValueMapModal;
+  dateRanges?: RangePickerProps["ranges"];
+  uploadProps?: ConfigUploadProps;
+}
+
+export interface HFormInstance extends FormInstance {
+  addFormat: (name: string, formats?: FormatItemModal) => void;
+  initValues: (values?: Record<string, any>) => void;
+  formatValues: (
+    values?: Record<string, any>,
+    formatKey?: string
+  ) => Record<string, any>;
+  dispatch: (key: string) => void;
+  outputValues: (values?: Record<string, any>) => Record<string, any>;
+  addDispatchListener: (key: string, fn: VoidFunction) => void;
+  removeDispatchListener: (key?: string) => void;
+}
+
+export interface ConnectConfigModal {
+  format?: Record<string, addFormatItemModal>;
+}
+
+type ValueFormat = (value: Record<string, any>) => Record<string, any>;
+
+export interface FormatItemModal {
+  inputValue: ValueFormat;
+  outputValue: ValueFormat;
+}
+
+type addValueFormat = (
+  item: HFormItemProps,
+  value: Record<string, any>
+) => Record<string, any>;
+
+export interface addFormatItemModal {
+  inputValue: addValueFormat;
+  outputValue: addValueFormat;
+}
+
+export interface ConnectResultProps {
+  addFormat?: (format: Record<string, addFormatItemModal>) => void;
+}

package/src/components/Input/ButtonInput.tsx

@@ -0,0 +1,41 @@
+import { Input, Button } from "antd";
+import React from "react";
+import { useRequest } from "ahooks";
+import type { HButtonInputProps } from "./modal";
+
+const Index: React.FC<HButtonInputProps> = ({
+  buttonProps = {},
+  value,
+  onChange,
+  children,
+  request,
+  ...props
+}) => {
+  const { onClick, type = "primary", ...oProps } = buttonProps;
+  const { run, loading } = useRequest(
+    (val) => {
+      return request?.(val);
+    },
+    { manual: true }
+  );
+  const change = (e) => {
+    onChange?.(e.target.value);
+  };
+  const click = async (e) => {
+    let result = value;
+    if (request) {
+      result = await run(value);
+    }
+    onClick?.(result, e);
+  };
+
+  return (
+    <Input.Group compact style={{ display: "flex" }}>
+      <Input {...props} style={{ flex: 1 }} value={value} onChange={change} />
+      <Button {...oProps} type={type} onClick={click} loading={loading}>
+        {children}
+      </Button>
+    </Input.Group>
+  );
+};
+export default Index;

package/src/components/Input/InputNumber.tsx

@@ -0,0 +1,5 @@
+import type { InputNumberProps } from "antd";
+import { InputNumber } from "antd";
+export default ({ style = { width: "100%" }, ...props }: InputNumberProps) => {
+  return <InputNumber style={style} {...props} />;
+};

package/src/components/Input/SelectInput.tsx

@@ -0,0 +1,74 @@
+import { Input } from "antd";
+import type { HSelectInputProps } from "./modal";
+import HSelect from "../Select";
+import { defaultSelectStyle, defaultValueName } from "./defaultConfig";
+import HFormConnect from "../Form/HFormConnect";
+export enum SelectInputType {
+  input,
+  select,
+}
+export const Index = ({
+  selectProps = {},
+  value = {},
+  onChange,
+  valueName = defaultValueName,
+  addFormat,
+  ...props
+}: HSelectInputProps) => {
+  const { input = "", select = "" } = valueName;
+  const { [input]: inputVal, [select]: selectVal } = value;
+  const {
+    style = defaultSelectStyle,
+    placeholder = "请选择",
+    ...sProps
+  } = selectProps;
+  const change = (val, key) => {
+    const newVal = { ...value };
+    newVal[key] = val;
+    const type = key === input ? SelectInputType.input : SelectInputType.select;
+    onChange?.(newVal, type);
+  };
+  addFormat?.({
+    float: {
+      inputValue: (item, initValue) => {
+        const { name } = item;
+        const resultObj = {};
+        Object.values(valueName).forEach((key) => {
+          resultObj[key] = initValue[key];
+        });
+        return {
+          [name]: resultObj,
+        };
+      },
+      outputValue: (item, outputValue) => {
+        const { name } = item;
+        const { [name]: itemVal = {} } = outputValue;
+        const newItemVal = { [itemVal[select]]: itemVal[input] };
+        return {
+          ...newItemVal,
+        };
+      },
+    },
+  });
+  return (
+    <Input
+      value={inputVal}
+      onChange={(e) => {
+        change(e.target.value, input);
+      }}
+      addonBefore={
+        <HSelect
+          {...sProps}
+          style={style}
+          placeholder={placeholder}
+          value={selectVal}
+          onChange={(val) => {
+            change(val, select);
+          }}
+        />
+      }
+      {...props}
+    />
+  );
+};
+export default HFormConnect(Index);

package/src/components/Input/defaultConfig.ts

@@ -0,0 +1,8 @@
+export const defaultSelectStyle = {
+  width: 128,
+};
+
+export const defaultValueName = {
+  input: "input",
+  select: "select",
+};

package/src/components/Input/index.tsx

@@ -0,0 +1,6 @@
+import { Input } from "antd";
+import type { HInputProps } from "./modal";
+
+export default ({ ...props }: HInputProps) => {
+  return <Input {...props} />;
+};

package/src/components/Input/modal.ts

@@ -0,0 +1,31 @@
+import type { ButtonProps, InputProps } from "antd";
+import type { HSelectProps } from "../Select/modal";
+import type { SelectInputType } from "./SelectInput";
+import type { PromiseFnResult } from "../modal";
+import type { addFormatItemModal } from "../Form/modal";
+
+export type HInputProps = InputProps;
+
+interface ValueNameModal {
+  input?: string;
+  select?: string;
+}
+
+export interface HSelectInputProps
+  extends Omit<HInputProps, "value" | "onChange"> {
+  selectProps?: HSelectProps;
+  value?: Record<string, any>;
+  onChange?: (value: Record<string, any>, type: SelectInputType) => void;
+  valueName?: ValueNameModal;
+  addFormat?: (config: Record<string, addFormatItemModal>) => void;
+}
+export interface HButtonProps extends Omit<ButtonProps, "onClick"> {
+  onClick: (
+    value: string | readonly string[] | number | undefined,
+    e: HTMLElement
+  ) => void;
+}
+export interface HButtonInputProps extends HInputProps {
+  buttonProps?: HButtonProps;
+  request?: PromiseFnResult;
+}

package/src/components/PageHandler/ErrorComponent.tsx

@@ -0,0 +1,20 @@
+import { Button, Row, Space, Typography } from "antd";
+import { ExclamationCircleOutlined } from "@ant-design/icons";
+import type { IHPageHandler } from "./modal";
+
+const { Text } = Typography;
+export default ({ error, reload }: IHPageHandler) => {
+  return (
+    <Row justify={"center"} align={"middle"} style={{ height: 125 }}>
+      <Space align={"center"} direction={"vertical"}>
+        <Text type={"danger"}>
+          <ExclamationCircleOutlined size={24} />
+        </Text>
+        <Text type={"danger"}>{error?.message}</Text>
+        <Button type="primary" size={"small"} onClick={reload}>
+          重新加载
+        </Button>
+      </Space>
+    </Row>
+  );
+};

package/src/components/PageHandler/LoadingComponent.tsx

@@ -0,0 +1,9 @@
+import { Row, Spin } from "antd";
+
+export default () => {
+  return (
+    <Row justify={"center"} align={"middle"} style={{ height: 125 }}>
+      <Spin size="large" />
+    </Row>
+  );
+};

package/src/components/PageHandler/index.tsx

@@ -0,0 +1,14 @@
+import React from "react";
+import Loading from "./LoadingComponent";
+import ErrorComponent from "./ErrorComponent";
+import type { IHPageHandler } from "./modal";
+const Index: React.FC<IHPageHandler> = ({ error, data, reload, children }) => {
+  if (error) {
+    return <ErrorComponent error={error} reload={reload} />;
+  }
+  if (data) {
+    return <>{children}</>;
+  }
+  return <Loading />;
+};
+export default Index;

package/src/components/PageHandler/modal.ts

@@ -0,0 +1,6 @@
+export interface IHPageHandler<T = any> {
+  loading?: boolean;
+  error?: Error;
+  reload: VoidFunction;
+  data?: T;
+}

package/src/components/RadioGroup/index.tsx

@@ -0,0 +1,45 @@
+import { Radio } from "antd";
+import type { SelectProps, RadioGroupProps } from "antd/es";
+import { useMemo } from "react";
+import { useMatchConfigProps } from "../hooks";
+
+export interface HRadioGroupProps
+  extends Omit<RadioGroupProps, "onChange" | "options"> {
+  onChange?: (value: any) => void;
+  fieldNames?: SelectProps["fieldNames"];
+  options?: (Record<string, any> | string | number)[];
+}
+export default ({
+  value,
+  options,
+  onChange,
+  fieldNames: propsFieldNames,
+  ...props
+}: HRadioGroupProps) => {
+  const { fieldNames = {} } = useMatchConfigProps({
+    fieldNames: propsFieldNames,
+  });
+  const relOptions = useMemo(() => {
+    return options?.map((item) => {
+      const type = typeof item;
+      if (type === "string" || type === "number") {
+        return item;
+      }
+      const { label: labelKey = "", value: valueKey = "" } = fieldNames;
+      return {
+        label: item[labelKey],
+        value: item[valueKey],
+      };
+    });
+  }, [options, fieldNames]);
+  return (
+    <Radio.Group
+      options={relOptions as RadioGroupProps["options"]}
+      value={value}
+      onChange={(e) => {
+        onChange?.(e.target.value);
+      }}
+      {...props}
+    />
+  );
+};

package/src/components/Select/components/AllSelect.tsx

@@ -1,38 +1,54 @@
 import type { HSelectProps } from "@/components/Select/modal";
 import { Checkbox, Space } from "antd";
-import styles from "../index.less";
+import { itemOpProvider } from "../utils";
+import { useClassName } from "../../hooks";
+import React from "react";
+
 interface IProps extends HSelectProps {
   checked?: boolean;
 }
-export default ({
+const useRootClassName = (checked: boolean) => {
+  const norClassNames = ["select-item", "select-item-option"];
+  return checked
+    ? [...norClassNames, "select-item-option-selected"]
+    : norClassNames;
+};
+const Index: React.FC<IProps> = ({
   allSelect,
   mode,
   onChange,
   value,
   serviceSearch,
   options,
-}: IProps) => {
-  if (!allSelect || mode !== "multiple" || serviceSearch) {
-    return null;
-  }
+  fieldNames = {},
+  children,
+}) => {
   const opLen = options?.length || 0;
   const checked = (value as any[])?.length >= opLen;
+  const classNames = useRootClassName(checked);
+  const optionsClassName = useClassName(classNames);
+  const allCheckBox = useClassName("hw-all-check-box");
   const change = () => {
     if (!checked) {
-      onChange?.(options);
+      const subItemOps = itemOpProvider(options, fieldNames);
+      onChange?.(options, subItemOps);
       return;
     }
-    onChange?.([]);
+    onChange?.([], []);
   };
+  if (!allSelect || mode !== "multiple" || serviceSearch) {
+    return <>{children}</>;
+  }
   return (
-    <div
-      className={`ant-select-item ant-select-item-option ${styles.option}`}
-      onClick={change}
-    >
-      <Space>
-        <Checkbox checked={checked} />
-        全部
-      </Space>
+    <div className={allCheckBox}>
+      <div className={optionsClassName} onClick={change}>
+        <Space>
+          <Checkbox checked={checked} />
+          全部
+        </Space>
+      </div>
+      {children}
     </div>
   );
 };
+export default Index;

package/src/components/Select/components/DropdownComponent.tsx

@@ -1,6 +1,7 @@
 import React from "react";
 import { Spin, Row, Space, Typography } from "antd";
 import NotFoundContent from "./NotFoundContent";
+
 interface IProps {
   loading?: boolean;
   options?: any[];

package/src/components/Select/components/NotFoundContent.tsx

@@ -11,7 +11,7 @@ export default ({ error, reload }: IProps) => {
       <Row justify={"center"} align={"middle"} style={{ height: 125 }}>
         <Space align={"center"} direction={"vertical"}>
           <Text type={"danger"}>
-            <ExclamationCircleOutlined style={{ fontSize: 24 }} />
+            <ExclamationCircleOutlined size={24} />
           </Text>
           <Text type={"danger"}>{error.message}</Text>
           <Button type="primary" size={"small"} onClick={reload}>

package/src/components/Select/defaultConfig.tsx

@@ -16,11 +16,6 @@ export const defaultModeConfig: HSelectProps["modeConfig"] = {
   },
 };
 
-export const defaultFieldNames: HSelectProps["fieldNames"] = {
-  label: "label",
-  value: "value",
-};
-
 export const defaultSelectConfig = {
   noMatchItemRender: () => {
     return <NoFindItem label={"选项被删除，请重新选择"} />;

package/src/components/Select/hooks/changeHooks.tsx

@@ -4,6 +4,7 @@ import type {
 } from "@/components/Select/modal";
 import { useEffect, useState } from "react";
 import type { FilterDataModal } from "@/components/Select/modal";
+import { itemOpProvider } from "../utils";
 
 const single = ({ options, value, noMatchItemRender }: PartialHSelectProps) => {
   const newOptions = options || [];
@@ -108,10 +109,18 @@ const matchNotFind = (
   return tag({ options, value }, oldVale);
 }; //不匹配
 export const useValueChange = (params: PartialHSelectProps) => {
-  const { labelInValue, onChange, value, options, mode, noMatchItemRender } =
-    params;
+  const {
+    labelInValue,
+    onChange,
+    value,
+    options,
+    mode,
+    noMatchItemRender,
+    fieldNames = {},
+  } = params;
   const [val, setVal] = useState<any>();
-  const change = (changeVal) => {
+
+  const change = (changeVal, itemOps) => {
     if (!onChange) {
       setVal(changeVal);
       return;
@@ -125,7 +134,8 @@ export const useValueChange = (params: PartialHSelectProps) => {
         return item.value;
       });
     }
-    onChange(newChangeVal);
+    const subItemOps = itemOpProvider(itemOps, fieldNames);
+    onChange(newChangeVal, subItemOps);
   };
   useEffect(() => {
     if (options && value) {

package/src/components/Select/hooks/norHooks.ts

@@ -1,29 +1,17 @@
 import { useState } from "react";
 import type {
-  HSelectProps,
   OptionType,
   PartialHSelectProps,
 } from "@/components/Select/modal";
 import { useRequest } from "ahooks";
 
-const resultProvider = (
-  data?: any[],
-  fieldNames?: HSelectProps["fieldNames"]
-) => {
-  return data?.map((item) => {
-    const { label = "label", value = "value" } = fieldNames || {};
-    return {
-      label: item[label],
-      value: item[value],
-    };
-  });
-};
 export const useOptionReq = ({
   manual,
-  fieldNames,
   request,
   options,
   serviceSearch,
+  showSearch,
+  onSearch: propsOnSearch,
 }: PartialHSelectProps) => {
   const [data, setData] = useState<OptionType[] | undefined>();
   const { run, loading, error } = useRequest(
@@ -32,11 +20,9 @@ export const useOptionReq = ({
         setData(undefined);
       }
       if (request) {
-        const result = await request(params);
-        return resultProvider(result, fieldNames);
+        return request(params);
       }
-      const resultOpt = resultProvider(options, fieldNames);
-      return Promise.resolve(resultOpt);
+      return Promise.resolve(options);
     },
     {
       manual,
@@ -48,16 +34,19 @@ export const useOptionReq = ({
   );
   const onSearch = (inputValue: string) => {
     if (!serviceSearch) {
+      propsOnSearch?.(inputValue);
       return;
     }
     run({ inputValue });
   };
+  const mathShowSearch = showSearch || serviceSearch;
   return {
     run,
     loading,
     error,
     data,
-    onSearch,
+    onSearch: mathShowSearch ? onSearch : propsOnSearch,
+    mathShowSearch: showSearch || serviceSearch,
   };
 };
 

package/src/components/Select/index.less

@@ -1,5 +1,22 @@
-.option {
-  &:hover {
-    background-color: #f5f5f5;
+@import "../styles/local.less";
+@all-check-box: ~"@{ant-prefix}-hw-all-check-box";
+
+.@{all-check-box} {
+  .@{ant-prefix}-select-item-option-active:not(
+      .@{ant-prefix}-select-item-option-disabled
+    ) {
+    background-color: transparent;
+  }
+  .@{ant-prefix}-select-item-option-selected:not(
+      .@{ant-prefix}-select-item-option-disabled
+    ) {
+    background-color: #e6f7ff;
+  }
+  .@{ant-prefix}-select-item-option:not(
+      .@{ant-prefix}-select-item-option-selected
+    ) {
+    &:hover {
+      background-color: #f5f5f5;
+    }
   }
 }