cnhis-design-vue 3.1.40-beta.1 → 3.1.40-beta.11

package/es/components/table-filter/src/components/render-widget/helpers/presetValToTimestamp.d.ts

@@ -0,0 +1 @@
+export declare const presetValToTimestamp: (presetVal: string, format?: string) => any;

package/es/components/table-filter/src/components/render-widget/helpers/presetValToTimestamp.js

@@ -0,0 +1,70 @@
+import { DatePresetValEnums } from '../enums.js';
+import moment from 'moment';
+
+const Maps = /* @__PURE__ */ new Map([
+  [
+    DatePresetValEnums.NOW,
+    () => moment()
+  ],
+  [
+    DatePresetValEnums.TODAY,
+    () => moment().startOf("day")
+  ],
+  [
+    DatePresetValEnums.TODAY_START,
+    () => moment().startOf("day")
+  ],
+  [
+    DatePresetValEnums.TODAY_END,
+    () => moment().endOf("day")
+  ],
+  [
+    DatePresetValEnums.TOMORROW,
+    () => moment().add(1, "days").startOf("day")
+  ],
+  [
+    DatePresetValEnums.TOMORROW_START,
+    () => moment().add(1, "days").startOf("day")
+  ],
+  [
+    DatePresetValEnums.TOMORROW_END,
+    () => moment().add(1, "days").endOf("day")
+  ],
+  [
+    DatePresetValEnums.YESTERDAY,
+    () => moment().subtract(1, "days").startOf("day")
+  ],
+  [
+    DatePresetValEnums.YESTERDAY_START,
+    () => moment().subtract(1, "days").startOf("day")
+  ],
+  [
+    DatePresetValEnums.YESTERDAY_END,
+    () => moment().subtract(1, "days").endOf("day")
+  ],
+  [
+    DatePresetValEnums.WEEK_START,
+    () => moment().startOf("week")
+  ],
+  [
+    DatePresetValEnums.WEEK_END,
+    () => moment().endOf("week")
+  ],
+  [
+    DatePresetValEnums.MONTH_START,
+    () => moment().startOf("month")
+  ],
+  [
+    DatePresetValEnums.MONTH_END,
+    () => moment().endOf("month")
+  ]
+]);
+const presetValToTimestamp = (presetVal, format = "x") => {
+  if (!Maps.has(presetVal))
+    return;
+  const fun = Maps.get(presetVal);
+  const val = fun().format(format);
+  return format === "x" || format === "X" ? Number(val) : val;
+};
+
+export { presetValToTimestamp };

package/es/components/table-filter/src/components/render-widget/index.vue.d.ts

@@ -0,0 +1,32 @@
+declare const _default: import("vue").DefineComponent<{
+    cfg: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    modelValue: {
+        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+    };
+}, any, {
+    initialProps: {};
+}, {
+    valueCp(): any;
+}, {
+    search(): void;
+    getEleWidth(cfg: any): string | undefined;
+    initComponentProps(cfg: any): void;
+    generateWidget(cfg: any): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | null;
+    handleUpdate(val: any, widgetType: any, defValueUnit: any): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    cfg: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    modelValue: {
+        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {}>;
+export default _default;

package/es/components/table-filter/src/components/render-widget/index.vue.js

@@ -0,0 +1,107 @@
+import { defineComponent, h } from 'vue';
+import { WidgetTypeEnums } from './enums.js';
+import { WidgetCfgMaps, formatItemData } from './widgetCfgMaps.js';
+import moment from 'moment';
+import _export_sfc from '../../../../../_virtual/plugin-vue_export-helper.js';
+
+const UseSelfWidth = [WidgetTypeEnums.DATE, WidgetTypeEnums.DATE_TIME, WidgetTypeEnums.CHECKBOX_GROUP];
+const _sfc_main = defineComponent({
+  props: {
+    cfg: {
+      type: Object,
+      required: true
+    },
+    modelValue: {
+      type: [Array, String, Number]
+    }
+  },
+  emits: ["update:modelValue"],
+  computed: {
+    valueCp() {
+      const { widgetType } = this.cfg;
+      const GATHER = [WidgetTypeEnums.DATE, WidgetTypeEnums.DATE_TIME];
+      if (GATHER.includes(widgetType)) {
+        return moment(this.cfg.value).valueOf();
+      }
+      return this.cfg.value;
+    }
+  },
+  data() {
+    return {
+      initialProps: {}
+    };
+  },
+  methods: {
+    search() {
+      this.$emit("outFilterChange");
+    },
+    getEleWidth(cfg) {
+      const { widgetType } = cfg;
+      if (UseSelfWidth.includes(widgetType))
+        return;
+      return `${cfg.advanceColWidth || 200}px`;
+    },
+    initComponentProps(cfg) {
+      const { widgetType, alias, title, placeholder: customPlaceholder, widgetCfg } = cfg;
+      const { props, handlerProps } = WidgetCfgMaps.get(widgetType);
+      let Props = { ...props };
+      if (handlerProps) {
+        Props = handlerProps(Props, { ...widgetCfg, title: alias || title });
+      }
+      if (customPlaceholder) {
+        Props.placeholder = customPlaceholder;
+      }
+      this.initialProps = Props;
+      if (Props.value) {
+        this.valueCp = Props.value;
+      }
+    },
+    generateWidget(cfg) {
+      const { widgetType } = cfg;
+      const { defValueUnit } = cfg.widgetCfg || {};
+      if (!WidgetCfgMaps.has(widgetType)) {
+        return null;
+      }
+      const { value } = cfg;
+      const { component, style, eventsBySearch = [] } = WidgetCfgMaps.get(widgetType);
+      const props = { ...this.initialProps, value };
+      const EventsBySearch = eventsBySearch.reduce((evts, item) => {
+        const { name, handler } = item;
+        let eventHandler = this.search;
+        if (handler) {
+          eventHandler = (e) => {
+            handler(e, this.search, props);
+          };
+        }
+        return {
+          ...evts,
+          [`on${name}`]: eventHandler
+        };
+      }, {});
+      return h(
+        component,
+        {
+          ...style,
+          ...props,
+          style: { width: this.getEleWidth(cfg) },
+          value: this.valueCp,
+          "onUpdate:value": (val) => this.handleUpdate(val, widgetType, defValueUnit),
+          ...EventsBySearch
+        }
+      );
+    },
+    handleUpdate(val, widgetType, defValueUnit) {
+      const result = formatItemData(val, widgetType);
+      this.$emit("update:modelValue", result);
+    }
+  },
+  created() {
+    this.initComponentProps(this.cfg);
+  },
+  render() {
+    return this.generateWidget(this.cfg);
+  }
+});
+var RenderWidget = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "index.vue"]]);
+
+export { RenderWidget as default };

package/es/components/table-filter/src/components/render-widget/widgetCfgMaps.d.ts

@@ -0,0 +1,199 @@
+import { funcVoid } from '../../../../../../es/components/table-filter/src/types';
+export declare const WidgetCfgMaps: Map<string, {
+    component: any;
+    props: {
+        clearable: boolean;
+        options?: undefined;
+        filterable?: undefined;
+        multiple?: undefined;
+        type?: undefined;
+        valueFormat?: undefined;
+    };
+    eventsBySearch: {
+        name: string;
+        handler(e: KeyboardEvent, search: funcVoid): void;
+    }[];
+    handlerProps(props: any, { title }?: any): any;
+    setDefaultValue: (defaultValue: any) => any;
+    style?: undefined;
+} | {
+    component: import("vue").DefineComponent<{
+        value: {
+            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+        };
+        componentCfg: {
+            type: ObjectConstructor;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+            };
+            componentCfg: {
+                type: ObjectConstructor;
+            };
+        }>> & {
+            "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+        }>>;
+        emit: (event: "update:value", ...args: any[]) => void;
+        valueCp: import("vue").WritableComputedRef<any>;
+        maxTagCount: import("vue").ComputedRef<0 | 1 | undefined>;
+        maxTagPlaceholder: () => string | undefined;
+        NSelect: any;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:value"[], "update:value", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+        };
+        componentCfg: {
+            type: ObjectConstructor;
+        };
+    }>> & {
+        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+    }, {}>;
+    props: {
+        clearable: boolean;
+        options: never[];
+        filterable: boolean;
+        multiple: boolean;
+        type?: undefined;
+        valueFormat?: undefined;
+    };
+    eventsBySearch: {
+        name: string;
+        handler(e: KeyboardEvent, search: funcVoid, props: any): void;
+    }[];
+    handlerProps(props: any, { valueList, multiple, title }?: any): any;
+    setDefaultValue: (defaultValue: any) => any;
+    style?: undefined;
+} | {
+    component: any;
+    props: {
+        type: string;
+        clearable: boolean;
+        valueFormat: string;
+        options?: undefined;
+        filterable?: undefined;
+        multiple?: undefined;
+    };
+    handlerProps(props: any, { title }?: any): any;
+    setDefaultValue(defaultValue: any, defValueUnit: any): any;
+    eventsBySearch?: undefined;
+    style?: undefined;
+} | {
+    component: import("vue").DefineComponent<{
+        options: {
+            type: import("vue").PropType<import("../../../../../../es/components/table-filter/src/types").ICheckboxType[]>;
+        };
+        value: {
+            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+            default: string[];
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            options: {
+                type: import("vue").PropType<import("../../../../../../es/components/table-filter/src/types").ICheckboxType[]>;
+            };
+            value: {
+                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+                default: string[];
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+        }>>;
+        emit: (event: "update:value", ...args: any[]) => void;
+        valueCp: import("vue").WritableComputedRef<any>;
+        filterNewVal: (val: any) => any;
+        onChange: (val: any) => void;
+        NCheckboxGroup: import("vue").DefineComponent<{
+            readonly min: NumberConstructor;
+            readonly max: NumberConstructor;
+            readonly size: import("vue").PropType<"small" | "medium" | "large">;
+            readonly value: import("vue").PropType<(string | number)[] | null>;
+            readonly defaultValue: {
+                readonly type: import("vue").PropType<(string | number)[] | null>;
+                readonly default: null;
+            };
+            readonly disabled: {
+                readonly type: import("vue").PropType<boolean | undefined>;
+                readonly default: undefined;
+            };
+            readonly 'onUpdate:value': import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: (string | number)[], meta: {
+                actionType: "check" | "uncheck";
+                value: string | number;
+            }) => void>>;
+            readonly onUpdateValue: import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: (string | number)[], meta: {
+                actionType: "check" | "uncheck";
+                value: string | number;
+            }) => void>>;
+            readonly onChange: import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: (string | number)[]) => void> | undefined>;
+        }, {
+            mergedClsPrefix: import("vue").ComputedRef<string>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly min: NumberConstructor;
+            readonly max: NumberConstructor;
+            readonly size: import("vue").PropType<"small" | "medium" | "large">;
+            readonly value: import("vue").PropType<(string | number)[] | null>;
+            readonly defaultValue: {
+                readonly type: import("vue").PropType<(string | number)[] | null>;
+                readonly default: null;
+            };
+            readonly disabled: {
+                readonly type: import("vue").PropType<boolean | undefined>;
+                readonly default: undefined;
+            };
+            readonly 'onUpdate:value': import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: (string | number)[], meta: {
+                actionType: "check" | "uncheck";
+                value: string | number;
+            }) => void>>;
+            readonly onUpdateValue: import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: (string | number)[], meta: {
+                actionType: "check" | "uncheck";
+                value: string | number;
+            }) => void>>;
+            readonly onChange: import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: (string | number)[]) => void> | undefined>;
+        }>>, {
+            readonly disabled: boolean | undefined;
+            readonly defaultValue: (string | number)[] | null;
+        }>;
+        NCheckbox: any;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:value"[], "update:value", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        options: {
+            type: import("vue").PropType<import("../../../../../../es/components/table-filter/src/types").ICheckboxType[]>;
+        };
+        value: {
+            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+            default: string[];
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {
+        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+    }, {
+        value: string | number | unknown[];
+        multiple: boolean;
+    }>;
+    props: {
+        clearable?: undefined;
+        options?: undefined;
+        filterable?: undefined;
+        multiple?: undefined;
+        type?: undefined;
+        valueFormat?: undefined;
+    };
+    style: {
+        "line-height": string;
+    };
+    handlerProps(props: any, { valueList, multiple }?: any): any;
+    setDefaultValue: (defaultValue: any) => any;
+    eventsBySearch?: undefined;
+}>;
+export declare const formatItemData: (val: any, widgetType: string) => any;

package/es/components/table-filter/src/components/render-widget/widgetCfgMaps.js

@@ -0,0 +1,152 @@
+import { WidgetTypeEnums, DatePresetValEnums } from './enums.js';
+import { NInputNumber, NInput, NDatePicker } from 'naive-ui';
+import CheckboxGroup from './components/CheckboxGroup.vue.js';
+import Select from './components/Select.vue.js';
+import moment from 'moment';
+import { presetValToTimestamp } from './helpers/presetValToTimestamp.js';
+
+const SetDefVal = (defaultValue) => defaultValue;
+const WidgetCfgMaps = /* @__PURE__ */ new Map([
+  [
+    WidgetTypeEnums.INPUT_NUMBER,
+    {
+      component: NInputNumber,
+      props: {
+        clearable: true
+      },
+      eventsBySearch: [{
+        name: "keydown",
+        handler(e, search) {
+          if (e.key === "Enter") {
+            console.log("\u70B9\u51FBkeyup>>>>>", search);
+            search();
+          }
+        }
+      }],
+      handlerProps(props, { title } = {}) {
+        const Props = { ...props, placeholder: `\u8F93\u5165${title}` };
+        return Props;
+      },
+      setDefaultValue: SetDefVal
+    }
+  ],
+  [
+    WidgetTypeEnums.INPUT,
+    {
+      component: NInput,
+      props: {
+        clearable: true
+      },
+      eventsBySearch: [{
+        name: "keydown",
+        handler(e, search) {
+          if (e.key === "Enter") {
+            search();
+          }
+        }
+      }],
+      handlerProps(props, { title } = {}) {
+        const Props = { ...props, placeholder: `\u641C\u7D22${title}` };
+        return Props;
+      },
+      setDefaultValue: SetDefVal
+    }
+  ],
+  [
+    WidgetTypeEnums.SELECT,
+    {
+      component: Select,
+      props: {
+        clearable: true,
+        options: [],
+        filterable: true,
+        multiple: false
+      },
+      eventsBySearch: [{
+        name: "change",
+        handler(e, search, props) {
+          const { multiple } = props;
+          if (multiple) {
+            search();
+          }
+        }
+      }],
+      handlerProps(props, { valueList, multiple, title } = {}) {
+        const Props = { ...props, placeholder: `\u8BF7\u9009\u62E9${title}` };
+        if (Array.isArray(valueList))
+          Props.options = valueList.map(({ value, label }) => ({ value, label }));
+        if (multiple)
+          Props.multiple = true;
+        return Props;
+      },
+      setDefaultValue: SetDefVal
+    }
+  ],
+  [
+    WidgetTypeEnums.DATE,
+    {
+      component: NDatePicker,
+      props: {
+        type: "date",
+        clearable: true,
+        valueFormat: "yyyy-MM-dd"
+      },
+      handlerProps(props, { title } = {}) {
+        const Props = { ...props, placeholder: `\u8BF7\u9009\u62E9${title}` };
+        return Props;
+      },
+      setDefaultValue(defaultValue, defValueUnit) {
+        if (defValueUnit && defValueUnit !== DatePresetValEnums.CUSTOM) {
+          return presetValToTimestamp(defValueUnit, "YYYY-MM-DD HH:mm:ss");
+        }
+        return defaultValue;
+      }
+    }
+  ],
+  [
+    WidgetTypeEnums.DATE_TIME,
+    {
+      component: NDatePicker,
+      props: {
+        type: "datetime",
+        clearable: true,
+        valueFormat: "yyyy-MM-dd HH:mm:ss"
+      },
+      handlerProps(props, { title } = {}) {
+        const Props = { ...props, placeholder: `\u8BF7\u9009\u62E9${title}` };
+        return Props;
+      },
+      setDefaultValue(defaultValue, defValueUnit) {
+        if (defValueUnit && defValueUnit !== DatePresetValEnums.CUSTOM) {
+          return presetValToTimestamp(defValueUnit, "YYYY-MM-DD HH:mm:ss");
+        }
+        return moment(defaultValue).format("YYYY-MM-DD HH:mm:ss");
+      }
+    }
+  ],
+  [
+    WidgetTypeEnums.CHECKBOX_GROUP,
+    {
+      component: CheckboxGroup,
+      props: {},
+      style: {
+        "line-height": "32px"
+      },
+      handlerProps(props, { valueList, multiple } = {}) {
+        const Props = { ...props, multiple };
+        if (Array.isArray(valueList))
+          Props.options = valueList.map(({ value, label }) => ({ value, label }));
+        return Props;
+      },
+      setDefaultValue: SetDefVal
+    }
+  ]
+]);
+const formatItemData = (val, widgetType) => {
+  if (widgetType === WidgetTypeEnums.DATE || widgetType === WidgetTypeEnums.DATE_TIME) {
+    return moment(val).format("YYYY-MM-DD HH:mm:ss");
+  }
+  return val;
+};
+
+export { WidgetCfgMaps, formatItemData };