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

package/es/components/table-filter/src/components/c-tree-select/tree-select.vue.d.ts

@@ -0,0 +1,90 @@
+import { PropType } from 'vue';
+import { ISearchType } from '../../../../../../es/components/table-filter/src/types';
+declare const _default: import("vue").DefineComponent<{
+    item: {
+        type: PropType<ISearchType>;
+        default: () => {
+            value: never[];
+        };
+    };
+    handleGetConfigApi: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    filterApiConfig: {
+        type: ObjectConstructor;
+    };
+    outFilterChange: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        item: {
+            type: PropType<ISearchType>;
+            default: () => {
+                value: never[];
+            };
+        };
+        handleGetConfigApi: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        filterApiConfig: {
+            type: ObjectConstructor;
+        };
+        outFilterChange: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+    }>> & {}>>;
+    quickInputSelect: any;
+    treeData: import("vue").Ref<{
+        label: string;
+        key: string;
+        selectable: boolean;
+        scopedSlots: {
+            title: string;
+        };
+    }[]>;
+    handleMaxTagCount: import("vue").ComputedRef<(item: ISearchType) => 0 | 1>;
+    showRemoveIcon: import("vue").ComputedRef<boolean>;
+    init: () => Promise<void>;
+    handleMaxTag: () => string;
+    handleRequestedOptions: (item: ISearchType) => Promise<any>;
+    getSearchDefParams: (item: ISearchType) => any;
+    formatField: (value: any) => any;
+    hanldeGetCascadelabel: (v?: never[], k?: {}) => any;
+    handleInitTreeData: (list: any, config: ISearchType) => void;
+    hanldeSetTreeDef: () => void;
+    maxTagPlaceholder: (item: ISearchType) => number;
+    treeSelect: (key: string, vnode: any) => void;
+    change: () => void;
+    handleDisabledTreeData: (list?: any, config?: any) => void;
+    createSuffixIcon: () => void;
+    NTreeSelect: any;
+    NSpin: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    item: {
+        type: PropType<ISearchType>;
+        default: () => {
+            value: never[];
+        };
+    };
+    handleGetConfigApi: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    filterApiConfig: {
+        type: ObjectConstructor;
+    };
+    outFilterChange: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>>, {
+    item: ISearchType;
+    handleGetConfigApi: Function;
+    outFilterChange: Function;
+}>;
+export default _default;

package/es/components/table-filter/src/components/c-tree-select/tree-select.vue.js

@@ -0,0 +1,253 @@
+import { defineComponent, ref, computed, onMounted, watch, getCurrentInstance, openBlock, createBlock, unref, normalizeStyle, normalizeClass, withCtx, createElementBlock, createVNode, createCommentVNode } from 'vue';
+import { NTreeSelect, NSpin } from 'naive-ui';
+import XEUtils from 'xe-utils';
+import 'moment';
+import _export_sfc from '../../../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = {
+  key: 0,
+  class: "init-key-loading",
+  slot: "title",
+  style: { "color": "#08c" }
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "tree-select",
+  props: {
+    item: {
+      type: Object,
+      default: () => ({ value: [] })
+    },
+    handleGetConfigApi: {
+      type: Function,
+      default: () => {
+      }
+    },
+    filterApiConfig: { type: Object },
+    outFilterChange: {
+      type: Function,
+      default: () => {
+      }
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const quickInputSelect = ref(null);
+    const treeData = ref([
+      {
+        label: "_init_key_",
+        key: "_init_key_",
+        selectable: false,
+        scopedSlots: {
+          title: "title"
+        }
+      }
+    ]);
+    let handleMaxTagCount = computed(() => {
+      return function(item) {
+        let len = maxTagPlaceholder(item);
+        if (len <= 1)
+          return 1;
+        return 0;
+      };
+    });
+    let showRemoveIcon = computed(() => {
+      var _a;
+      let v = props.item.value;
+      let f = 1 == ((_a = props == null ? void 0 : props.item) == null ? void 0 : _a.filterExplicit);
+      if (Array.isArray(v) && f) {
+        let l = v.length;
+        if (props.item.explicitRequired == 1) {
+          return l > 1;
+        }
+      }
+      return true;
+    });
+    onMounted(() => {
+      init();
+      createSuffixIcon();
+    });
+    async function init() {
+      try {
+        let res = await handleRequestedOptions(props.item);
+        let { result, map } = res.data;
+        if (result !== "SUCCESS") {
+          treeData.value = [];
+          return;
+        }
+        let rows = map.rows || [];
+        if (rows) {
+          handleInitTreeData(rows, props.item);
+          treeData.value = rows.map((item) => {
+            return {
+              ...item,
+              label: item.value
+            };
+          });
+        }
+      } catch (error) {
+        console.log(error);
+        treeData.value = [];
+      } finally {
+        hanldeSetTreeDef();
+      }
+    }
+    async function handleRequestedOptions(item) {
+      let params = getSearchDefParams(item);
+      let res = await props.handleGetConfigApi(params, "requestGetWordbookData", { fields: item }, props.filterApiConfig);
+      return res;
+    }
+    function getSearchDefParams(item) {
+      var _a;
+      let obj = {};
+      let { params = [], autograph, filterKeys, id, wordbookType } = ((_a = item == null ? void 0 : item.settingObj) == null ? void 0 : _a.wordbook) || {};
+      if (params) {
+        params.forEach((item2) => {
+          obj[item2.p_name] = item2.p_value;
+        });
+      }
+      if (autograph) {
+        obj.autograph = autograph;
+      }
+      let resFieldKeys = Array.isArray(filterKeys) ? JSON.stringify(filterKeys) : filterKeys;
+      let res = {
+        wordbookId: id,
+        fieldKeys: resFieldKeys,
+        wordbookType: wordbookType || "WORDBOOK",
+        isLevelLazyLoad: false,
+        ...obj
+      };
+      return res;
+    }
+    function formatField(value) {
+      let res = value;
+      try {
+        if (res && typeof res == "string" && res.startsWith("###")) {
+          res = res.slice(3);
+          res = JSON.parse(res);
+          res = res.change_text;
+        }
+        return res || "";
+      } catch (error) {
+        return "";
+      }
+    }
+    function hanldeGetCascadelabel(v = [], k = {}) {
+      if (Array.isArray(v) && v.length) {
+        const l = [];
+        v.forEach((i) => {
+          let res = formatField(k[i]);
+          l.push(res);
+        });
+        if (l.length == 0) {
+          return "";
+        }
+        return l.join(" ");
+      }
+      return "";
+    }
+    function handleInitTreeData(list = [], config) {
+      var _a;
+      let { showKeys = [], field_key = "" } = ((_a = config == null ? void 0 : config.setting) == null ? void 0 : _a.wordbook) || {};
+      list.forEach((item, i) => {
+        let val = XEUtils.stringToValue(item[field_key], "value");
+        item.myLabel = hanldeGetCascadelabel(showKeys, item) || val;
+        item.key = item.theUniqueKey;
+        item.title = item.myLabel;
+        item.value = `${val}<&=&>${i}<&=&>${item.key}`;
+        if (item.children && item.children.length) {
+          handleInitTreeData(item.children, config);
+        }
+      });
+    }
+    function hanldeSetTreeDef() {
+      var _a, _b;
+      let f = 1 == ((_a = props == null ? void 0 : props.item) == null ? void 0 : _a.filterExplicit);
+      let df = ((_b = props == null ? void 0 : props.item) == null ? void 0 : _b.explicitDefaultVal) || "";
+      if (df === "firstOption" && f) {
+        let v = treeData.value[0];
+        props.item.value = (v == null ? void 0 : v.value) ? [v == null ? void 0 : v.value] : [];
+        if (typeof props.outFilterChange === "function") {
+          props.outFilterChange({ type: "outSearchInit" });
+        }
+      }
+    }
+    function maxTagPlaceholder(item) {
+      if (Array.isArray(item.value)) {
+        return item.value.length;
+      } else {
+        return 1;
+      }
+    }
+    function treeSelect(key, vnode) {
+    }
+    function change() {
+    }
+    function handleDisabledTreeData(list = [], config = {}) {
+      list.forEach((item, i) => {
+        let k = config.showRemoveIcon ? false : props.item.value.includes(item.value);
+        item.disabled = k;
+        if (item.children && item.children.length) {
+          handleDisabledTreeData(item.children, config);
+        }
+      });
+    }
+    function createSuffixIcon() {
+      let refDom = quickInputSelect.value;
+      if (!refDom)
+        return;
+      let selectDom = refDom.$el;
+      if (!selectDom)
+        return;
+      let pDom = selectDom.querySelector(".ant-select-selection--multiple");
+      let hasTag = pDom.querySelector(".quick-input-select-span");
+      if (!hasTag) {
+        let tag = document.createElement("span");
+        tag.className = "quick-input-select-span";
+        let icon = `<i aria-label="\u56FE\u6807: down" class="anticon anticon-down ant-select-arrow-icon"><svg viewBox="64 64 896 896" data-icon="down" width="1em" height="1em" fill="currentColor" aria-hidden="true" focusable="false" class=""><path d="M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z"></path></svg></i>`;
+        tag.innerHTML = icon;
+        pDom.appendChild(tag);
+      }
+    }
+    watch(
+      () => props.item,
+      (val) => {
+        var _a;
+        let ctx = (_a = getCurrentInstance()) == null ? void 0 : _a.ctx;
+        handleDisabledTreeData(treeData.value, {
+          showRemoveIcon: showRemoveIcon.value
+        });
+        ctx.$forceUpdate();
+      },
+      { immediate: true, deep: true }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(NTreeSelect), {
+        value: __props.item.value,
+        "onUpdate:value": [
+          _cache[0] || (_cache[0] = ($event) => __props.item.value = $event),
+          change
+        ],
+        maxTagCount: unref(handleMaxTagCount)(__props.item),
+        multiple: "",
+        filterable: "",
+        clearable: "",
+        style: normalizeStyle(`width: ${__props.item.advanceColWidth || 160}px`),
+        class: normalizeClass([!unref(showRemoveIcon) && "c-a-tree-select-show-hide-icon", "c-a-quick-input-tree-mul"]),
+        options: treeData.value,
+        allowClear: __props.item.explicitRequired != 1,
+        placeholder: __props.item.placeholder || `\u8BF7\u9009\u62E9${__props.item.alias || __props.item.title}`,
+        "onUpdate:indeterminateKeys": treeSelect
+      }, {
+        action: withCtx(({ key, value }) => [
+          key === "_init_key_" ? (openBlock(), createElementBlock("span", _hoisted_1, [
+            createVNode(unref(NSpin), { tip: `\u52A0\u8F7D\u4E2D...` }, null, 8, ["tip"])
+          ])) : createCommentVNode("v-if", true)
+        ]),
+        _: 1
+      }, 8, ["value", "maxTagCount", "style", "class", "options", "allowClear", "placeholder"]);
+    };
+  }
+});
+var cTreeSelect = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "tree-select.vue"]]);
+
+export { cTreeSelect as default };

package/es/components/table-filter/src/components/classify-filter/ValueCfg.vue.d.ts

@@ -0,0 +1,112 @@
+declare const _default: import("vue").DefineComponent<{
+    paramCfg: {
+        type: ObjectConstructor;
+        default: null;
+    };
+    modelValue: {
+        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+        default: null;
+    };
+    presetVal: {
+        type: StringConstructor;
+        default: null;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        paramCfg: {
+            type: ObjectConstructor;
+            default: null;
+        };
+        modelValue: {
+            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+            default: null;
+        };
+        presetVal: {
+            type: StringConstructor;
+            default: null;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
+    }>>;
+    emit: (event: "update:modelValue" | "update:presetVal", ...args: any[]) => void;
+    valueCp: import("vue").WritableComputedRef<unknown>;
+    presetValCp: import("vue").WritableComputedRef<unknown>;
+    widgetType: import("vue").ComputedRef<any>;
+    optionSetting: import("vue").ComputedRef<any>;
+    mappingConfig: import("vue").ComputedRef<any>;
+    widgetOptions: import("vue").ComputedRef<{
+        label: string;
+        value: string;
+    }[]>;
+    NInputNumber: any;
+    NInput: any;
+    NSelect: any;
+    NDatePicker: any;
+    WidgetTypeEnums: {
+        INPUT_NUMBER: string;
+        INPUT: string;
+        SELECT: string;
+        DATE: string;
+        DATE_TIME: string;
+    };
+    WidgetValEnums: {
+        CUSTOM: string;
+        FIRST_VAL: string;
+        NOW: string;
+        TODAY: string;
+        TODAY_START: string;
+        TODAY_END: string;
+        TOMORROW: string;
+        TOMORROW_START: string;
+        TOMORROW_END: string;
+        YESTERDAY: string;
+        YESTERDAY_START: string;
+        YESTERDAY_END: string;
+        THIS_WEEK: string;
+        WEEK_START: string;
+        WEEK_END: string;
+        NEXT_WEEK: string;
+        LAST_WEEK: string;
+        THIS_MONTH: string;
+        MONTH_START: string;
+        MONTH_END: string;
+        NEXT_MONTH: string;
+        LAST_MONTH: string;
+        THIS_QUARTER: string;
+        NEXT_QUARTER: string;
+        LAST_QUARTER: string;
+        THIS_YEAR: string;
+        NEXT_YEAR: string;
+        LAST_YEAR: string;
+    };
+    WidgetOptionEnums: {
+        RADIO: string;
+        MULTIPLE: string;
+        ALL: string;
+        SELECT_TIME: string;
+        PAST_TIME: string;
+        FUTURE_TIME: string;
+    };
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:presetVal")[], "update:modelValue" | "update:presetVal", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    paramCfg: {
+        type: ObjectConstructor;
+        default: null;
+    };
+    modelValue: {
+        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+        default: null;
+    };
+    presetVal: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: string | number | unknown[];
+    presetVal: string;
+    paramCfg: Record<string, any>;
+}>;
+export default _default;

package/es/components/table-filter/src/components/classify-filter/ValueCfg.vue.js

@@ -0,0 +1,114 @@
+import { defineComponent, computed, openBlock, createElementBlock, unref, createBlock, isRef, createCommentVNode, Fragment, createVNode } from 'vue';
+import { NInputNumber, NInput, NSelect, NDatePicker } from 'naive-ui';
+import { WidgetTypeEnums, WidgetValEnums, WidgetOptionEnums } from '../../types/enums.js';
+import { generateDefOptionsInApi } from '../../tool/generateDefOptions.js';
+import _export_sfc from '../../../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "value-cfg_wrapper" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ValueCfg",
+  props: {
+    paramCfg: {
+      type: Object,
+      default: null
+    },
+    modelValue: {
+      type: [String, Number, Array],
+      default: null
+    },
+    presetVal: {
+      type: String,
+      default: null
+    }
+  },
+  emits: [
+    "update:modelValue",
+    "update:presetVal"
+  ],
+  setup(__props, { emit }) {
+    const props = __props;
+    const valueCp = computed({
+      set(val) {
+        emit("update:modelValue", val);
+      },
+      get() {
+        return props.modelValue;
+      }
+    });
+    const presetValCp = computed({
+      set(val) {
+        emit("update:presetVal", val);
+      },
+      get() {
+        return props.presetVal;
+      }
+    });
+    const widgetType = computed(() => {
+      var _a;
+      return (_a = props.paramCfg) == null ? void 0 : _a.type;
+    });
+    const optionSetting = computed(() => {
+      var _a;
+      return (_a = props.paramCfg) == null ? void 0 : _a.optionSetting;
+    });
+    const mappingConfig = computed(() => {
+      var _a;
+      return (_a = props.paramCfg) == null ? void 0 : _a.mappingConfig;
+    });
+    const widgetOptions = computed(() => {
+      const options = generateDefOptionsInApi(widgetType.value, mappingConfig.value).slice(0);
+      if (widgetType.value === WidgetTypeEnums.DATE || widgetType.value === WidgetTypeEnums.DATE_TIME) {
+        options.unshift({ label: "\u81EA\u5B9A\u4E49\u8F93\u5165", value: WidgetValEnums.CUSTOM });
+      }
+      return options;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        unref(widgetType) === unref(WidgetTypeEnums).INPUT_NUMBER ? (openBlock(), createBlock(unref(NInputNumber), {
+          key: 0,
+          class: "form-item",
+          value: unref(valueCp),
+          "onUpdate:value": _cache[0] || (_cache[0] = ($event) => isRef(valueCp) ? valueCp.value = $event : null)
+        }, null, 8, ["value"])) : createCommentVNode("v-if", true),
+        unref(widgetType) === unref(WidgetTypeEnums).INPUT ? (openBlock(), createBlock(unref(NInput), {
+          key: 1,
+          value: unref(valueCp),
+          "onUpdate:value": _cache[1] || (_cache[1] = ($event) => isRef(valueCp) ? valueCp.value = $event : null),
+          maxlength: "255",
+          clearable: ""
+        }, null, 8, ["value"])) : createCommentVNode("v-if", true),
+        unref(widgetType) === unref(WidgetTypeEnums).SELECT ? (openBlock(), createBlock(unref(NSelect), {
+          key: 2,
+          style: { "width": "120px" },
+          class: "form-item",
+          value: unref(valueCp),
+          "onUpdate:value": _cache[2] || (_cache[2] = ($event) => isRef(valueCp) ? valueCp.value = $event : null),
+          filterable: "",
+          options: unref(widgetOptions),
+          multiple: unref(optionSetting) === unref(WidgetOptionEnums).MULTIPLE,
+          maxTagCount: 1
+        }, null, 8, ["value", "options", "multiple"])) : createCommentVNode("v-if", true),
+        unref(widgetType) === unref(WidgetTypeEnums).DATE || unref(widgetType) === unref(WidgetTypeEnums).DATE_TIME ? (openBlock(), createElementBlock(Fragment, { key: 3 }, [
+          createVNode(unref(NSelect), {
+            style: { "width": "120px" },
+            class: "form-item",
+            value: unref(presetValCp),
+            "onUpdate:value": _cache[3] || (_cache[3] = ($event) => isRef(presetValCp) ? presetValCp.value = $event : null),
+            options: unref(widgetOptions)
+          }, null, 8, ["value", "options"]),
+          unref(presetValCp) === unref(WidgetValEnums).CUSTOM ? (openBlock(), createBlock(unref(NDatePicker), {
+            key: 0,
+            class: "form-item",
+            type: unref(widgetType).toLowerCase(),
+            format: "yyyy-MM-dd HH:mm:ss",
+            "formatted-value": unref(valueCp),
+            "onUpdate:formatted-value": _cache[4] || (_cache[4] = ($event) => isRef(valueCp) ? valueCp.value = $event : null)
+          }, null, 8, ["type", "formatted-value"])) : createCommentVNode("v-if", true)
+        ], 64)) : createCommentVNode("v-if", true)
+      ]);
+    };
+  }
+});
+var ValueCfg = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "ValueCfg.vue"]]);
+
+export { ValueCfg as default };

package/es/components/table-filter/src/components/classify-filter/helpers/options.d.ts

@@ -0,0 +1,4 @@
+export declare const conditionOptions: {
+    label: string;
+    value: string;
+}[];

package/es/components/table-filter/src/components/classify-filter/helpers/options.js

@@ -0,0 +1,14 @@
+import { ConditionEnums } from '../../../types/enums.js';
+
+const conditionOptions = [
+  {
+    label: "\u81EA\u5B9A\u4E49",
+    value: ConditionEnums.EQUAL
+  },
+  {
+    label: "\u4E3A\u7A7A",
+    value: ConditionEnums.NULL
+  }
+];
+
+export { conditionOptions };

package/es/components/table-filter/src/components/classify-filter/hooks/useDisplayCategory.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'vue';
+import { ICategoryItemType } from '../../../../../../../es/components/table-filter/src/types';
+export declare const useDisplayCategory: (selectedDisplayCategory: Ref, { conditionList }: any) => {
+    State: {
+        addDisplayCategory: string;
+        displayCategories: {
+            disabled: boolean;
+            value: string;
+        }[];
+        displayCategoryOriginLen: number;
+        showAdd: boolean;
+    };
+    isEnableAddDisplayCategory: import("vue").ComputedRef<boolean>;
+    editDisplayCategory: (e: any, item: ICategoryItemType) => void;
+    handleDisplayCategorySelect: (item: ICategoryItemType) => void;
+    handleDisplayCategoryRemove: (index: number, item: ICategoryItemType) => void;
+    handleDisplayCategoryAdd: (e: any) => void;
+    handlerBlur: () => void;
+    initDisplayCategories: (rawDataDisplayCategories: any, displayCategory: any) => void;
+};