cnhis-design-vue 3.1.31-beta.6 → 3.1.31-beta.8

package/es/components/recommend-search/src/RecommendSearch.vue.d.ts

@@ -0,0 +1,280 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    mode: {
+        type: PropType<"select" | "input">;
+        default: string;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        mode: {
+            type: PropType<"select" | "input">;
+            default: string;
+        };
+    }>> & {}>>;
+    componentMap: {
+        input: import("vue").DefineComponent<{
+            value: {
+                type: StringConstructor;
+                required: true;
+            };
+            options: {
+                type: ArrayConstructor;
+                required: false;
+                default: () => never[];
+            };
+            commonList: {
+                type: ArrayConstructor;
+                required: false;
+                default: () => never[];
+            };
+            recentList: {
+                type: ArrayConstructor;
+                required: false;
+                default: () => never[];
+            };
+        }, {
+            props: {
+                value: string;
+                options: import("./types").RecommendItem[];
+                commonList: import("./types").RecommendItem[];
+                recentList: import("./types").RecommendItem[];
+            };
+            emits: (event: "delete" | "update:value" | "search" | "choose", ...args: any[]) => void;
+            baseSearchRef: import("vue").Ref<import("./types").BaseSearchExpose | undefined>;
+            setPattern: (value: string) => void;
+            valueRef: import("vue").Ref<string> | import("vue").WritableComputedRef<string>;
+            parsedOptions: import("vue").ComputedRef<import("./types").RecommendItem[]>;
+            search: (value: string) => void;
+            onChoose: ({ value }: {
+                type?: import("./constant").RecommendType | undefined;
+                value: import("./types").RecommendItem;
+            }) => void;
+            list: import("vue").Ref<import("@vueuse/core").UseVirtualListItem<import("./types").RecommendItem>[]>;
+            wrapperProps: import("vue").ComputedRef<{
+                style: {
+                    width: string;
+                    height: string;
+                    marginTop: string;
+                };
+            }>;
+            containerProps: {
+                ref: import("vue").Ref<any>;
+                onScroll: () => void;
+                style: Partial<CSSStyleDeclaration>;
+            };
+            RecommendMenu: import("vue").DefineComponent<{
+                getDisplayValue: {
+                    type: FunctionConstructor;
+                    required: false;
+                    default: (item: import("./types").RecommendItem) => string;
+                };
+                commonList: {
+                    type: ArrayConstructor;
+                    required: true;
+                    default: () => never[];
+                };
+                recentList: {
+                    type: ArrayConstructor;
+                    required: true;
+                    default: () => never[];
+                };
+            }, {
+                emits: (event: "delete" | "choose", ...args: any[]) => void;
+                clickTag: (type: import("./constant").RecommendType, value: import("./types").RecommendItem) => void;
+                clickCommonTag: (value: import("./types").RecommendItem) => void;
+                clickRecentTag: (value: import("./types").RecommendItem) => void;
+                closeTag: (type: import("./constant").RecommendType, value: import("./types").RecommendItem) => void;
+                closeCommonTag: (value: import("./types").RecommendItem) => void;
+                closeRecentTag: (value: import("./types").RecommendItem) => void;
+                NTag: any;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "choose")[], "delete" | "choose", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+                getDisplayValue: {
+                    type: FunctionConstructor;
+                    required: false;
+                    default: (item: import("./types").RecommendItem) => string;
+                };
+                commonList: {
+                    type: ArrayConstructor;
+                    required: true;
+                    default: () => never[];
+                };
+                recentList: {
+                    type: ArrayConstructor;
+                    required: true;
+                    default: () => never[];
+                };
+            }>> & {
+                onDelete?: ((...args: any[]) => any) | undefined;
+                onChoose?: ((...args: any[]) => any) | undefined;
+            }, {
+                commonList: unknown[];
+                recentList: unknown[];
+                getDisplayValue: Function;
+            }>;
+            BaseSearch: import("vue").DefineComponent<{
+                value: {
+                    type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+                };
+                displayValue: {
+                    type: StringConstructor;
+                };
+                valueFormatter: {
+                    type: PropType<(value: string | number | any[] | undefined) => string>;
+                };
+                show: {
+                    type: BooleanConstructor;
+                };
+                placeholder: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inputProps: {
+                    type: ObjectConstructor;
+                    default: () => {};
+                };
+                popProps: {
+                    type: ObjectConstructor;
+                    default: () => {};
+                };
+                searchOnOpenMenu: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }, {
+                props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                    value: {
+                        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+                    };
+                    displayValue: {
+                        type: StringConstructor;
+                    };
+                    valueFormatter: {
+                        type: PropType<(value: string | number | any[] | undefined) => string>;
+                    };
+                    show: {
+                        type: BooleanConstructor;
+                    };
+                    placeholder: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    inputProps: {
+                        type: ObjectConstructor;
+                        default: () => {};
+                    };
+                    popProps: {
+                        type: ObjectConstructor;
+                        default: () => {};
+                    };
+                    searchOnOpenMenu: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+                    onSearch?: ((...args: any[]) => any) | undefined;
+                    onClear?: ((...args: any[]) => any) | undefined;
+                    onOpenMenu?: ((...args: any[]) => any) | undefined;
+                    onCloseMenu?: ((...args: any[]) => any) | undefined;
+                }>>;
+                uuid: string;
+                emits: (event: "clear" | "update:show" | "search" | "openMenu" | "closeMenu", ...args: any[]) => void;
+                search: (content?: any) => void;
+                popoverRef: import("vue").Ref<{
+                    syncPosition: import("../../../shared/types").Func<any[], any>;
+                } | undefined>;
+                _show: import("vue").Ref<boolean>;
+                show: import("vue").WritableComputedRef<boolean>;
+                inputRef: import("vue").Ref<HTMLElement | undefined>;
+                patternContent: import("vue").Ref<string>;
+                displayValueRef: import("vue").WritableComputedRef<string | undefined>;
+                onInputClick: (evt: PointerEvent) => void;
+                openMenu: () => void;
+                closeMenu: () => void;
+                onClear: () => void;
+                NInput: any;
+                NPopover: any;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "update:show" | "search" | "openMenu" | "closeMenu")[], "search" | "closeMenu" | "clear" | "update:show" | "openMenu", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+                };
+                displayValue: {
+                    type: StringConstructor;
+                };
+                valueFormatter: {
+                    type: PropType<(value: string | number | any[] | undefined) => string>;
+                };
+                show: {
+                    type: BooleanConstructor;
+                };
+                placeholder: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inputProps: {
+                    type: ObjectConstructor;
+                    default: () => {};
+                };
+                popProps: {
+                    type: ObjectConstructor;
+                    default: () => {};
+                };
+                searchOnOpenMenu: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+                onSearch?: ((...args: any[]) => any) | undefined;
+                onClear?: ((...args: any[]) => any) | undefined;
+                onOpenMenu?: ((...args: any[]) => any) | undefined;
+                onCloseMenu?: ((...args: any[]) => any) | undefined;
+            }, {
+                show: boolean;
+                placeholder: string;
+                inputProps: Record<string, any>;
+                popProps: Record<string, any>;
+                searchOnOpenMenu: boolean;
+            }>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "update:value" | "search" | "choose")[], "search" | "delete" | "update:value" | "choose", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: StringConstructor;
+                required: true;
+            };
+            options: {
+                type: ArrayConstructor;
+                required: false;
+                default: () => never[];
+            };
+            commonList: {
+                type: ArrayConstructor;
+                required: false;
+                default: () => never[];
+            };
+            recentList: {
+                type: ArrayConstructor;
+                required: false;
+                default: () => never[];
+            };
+        }>> & {
+            "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+            onDelete?: ((...args: any[]) => any) | undefined;
+            onSearch?: ((...args: any[]) => any) | undefined;
+            onChoose?: ((...args: any[]) => any) | undefined;
+        }, {
+            options: unknown[];
+            commonList: unknown[];
+            recentList: unknown[];
+        }>;
+        select: import("vue").DefineComponent<unknown, object, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<unknown>, {}>;
+    };
+    currentComponent: import("vue").ComputedRef<any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    mode: {
+        type: PropType<"select" | "input">;
+        default: string;
+    };
+}>>, {
+    mode: "select" | "input";
+}>;
+export default _default;

package/es/components/recommend-search/src/RecommendSearch.vue.js

@@ -0,0 +1,35 @@
+import { defineComponent, computed, openBlock, createBlock, resolveDynamicComponent, unref, normalizeProps, guardReactiveProps, withCtx, renderSlot } from 'vue';
+import RecommendInput from './components/RecommendInput.vue.js';
+import RecommendSelect from './components/RecommendSelect.vue.js';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "RecommendSearch",
+  props: {
+    mode: {
+      type: String,
+      default: "input"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const componentMap = {
+      input: RecommendInput,
+      select: RecommendSelect
+    };
+    const currentComponent = computed(() => {
+      return componentMap[props.mode];
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(unref(currentComponent)), normalizeProps(guardReactiveProps(_ctx.$attrs)), {
+        empty: withCtx(() => [
+          renderSlot(_ctx.$slots, "empty")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+var script = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "RecommendSearch.vue"]]);
+
+export { script as default };

package/es/components/recommend-search/src/components/BaseSearch.vue.d.ts

@@ -0,0 +1,128 @@
+import { Func } from '../../../../../es/shared/types';
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    value: {
+        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+    };
+    displayValue: {
+        type: StringConstructor;
+    };
+    valueFormatter: {
+        type: PropType<(value: undefined | number | string | Array<any>) => string>;
+    };
+    show: {
+        type: BooleanConstructor;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    inputProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    popProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    searchOnOpenMenu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+        };
+        displayValue: {
+            type: StringConstructor;
+        };
+        valueFormatter: {
+            type: PropType<(value: undefined | number | string | Array<any>) => string>;
+        };
+        show: {
+            type: BooleanConstructor;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: string;
+        };
+        inputProps: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        popProps: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        searchOnOpenMenu: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {
+        "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+        onSearch?: ((...args: any[]) => any) | undefined;
+        onClear?: ((...args: any[]) => any) | undefined;
+        onOpenMenu?: ((...args: any[]) => any) | undefined;
+        onCloseMenu?: ((...args: any[]) => any) | undefined;
+    }>>;
+    uuid: string;
+    emits: (event: "clear" | "update:show" | "search" | "openMenu" | "closeMenu", ...args: any[]) => void;
+    search: (content?: any) => void;
+    popoverRef: import("vue").Ref<{
+        syncPosition: Func;
+    } | undefined>;
+    _show: import("vue").Ref<boolean>;
+    show: import("vue").WritableComputedRef<boolean>;
+    inputRef: import("vue").Ref<HTMLElement | undefined>;
+    patternContent: import("vue").Ref<string>;
+    displayValueRef: import("vue").WritableComputedRef<string | undefined>;
+    onInputClick: (evt: PointerEvent) => void;
+    openMenu: () => void;
+    closeMenu: () => void;
+    onClear: () => void;
+    NInput: any;
+    NPopover: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "update:show" | "search" | "openMenu" | "closeMenu")[], "search" | "closeMenu" | "clear" | "update:show" | "openMenu", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
+    };
+    displayValue: {
+        type: StringConstructor;
+    };
+    valueFormatter: {
+        type: PropType<(value: undefined | number | string | Array<any>) => string>;
+    };
+    show: {
+        type: BooleanConstructor;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    inputProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    popProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    searchOnOpenMenu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+    onSearch?: ((...args: any[]) => any) | undefined;
+    onClear?: ((...args: any[]) => any) | undefined;
+    onOpenMenu?: ((...args: any[]) => any) | undefined;
+    onCloseMenu?: ((...args: any[]) => any) | undefined;
+}, {
+    show: boolean;
+    placeholder: string;
+    inputProps: Record<string, any>;
+    popProps: Record<string, any>;
+    searchOnOpenMenu: boolean;
+}>;
+export default _default;

package/es/components/recommend-search/src/components/BaseSearch.vue.js

@@ -0,0 +1,153 @@
+import { defineComponent, ref, computed, openBlock, createBlock, unref, mergeProps, isRef, withCtx, createVNode, withKeys, createElementVNode, renderSlot } from 'vue';
+import { uuidGenerator } from '../../../../shared/utils/index.js';
+import { useDebounceFn, onClickOutside } from '@vueuse/core';
+import { isFunction, isArray } from 'lodash-es';
+import { NPopover, NInput } from 'naive-ui';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = ["id"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "BaseSearch",
+  props: {
+    value: { type: [String, Number, Array] },
+    displayValue: { type: String },
+    valueFormatter: {
+      type: Function
+    },
+    show: { type: Boolean },
+    placeholder: { type: String, default: "\u8BF7\u8F93\u5165" },
+    inputProps: { type: Object, default: () => ({}) },
+    popProps: { type: Object, default: () => ({}) },
+    searchOnOpenMenu: { type: Boolean, default: true }
+  },
+  emits: ["update:show", "clear", "search", "openMenu", "closeMenu"],
+  setup(__props, { expose, emit: emits }) {
+    const props = __props;
+    const uuid = uuidGenerator();
+    const search = useDebounceFn((content = "") => {
+      emits("search", content);
+    }, 300);
+    const popoverRef = ref();
+    const _show = ref(props.show);
+    const show = computed({
+      get() {
+        return _show.value || props.show;
+      },
+      set(value) {
+        emits("update:show", value);
+        _show.value = value;
+      }
+    });
+    const inputRef = ref();
+    const patternContent = ref("");
+    const displayValueRef = computed({
+      get() {
+        var _a;
+        if (show.value)
+          return patternContent.value;
+        if (props.displayValue)
+          return props.displayValue;
+        return isFunction(props.valueFormatter) ? props.valueFormatter(props.value) : isArray(props.value) ? props.value.join(",") : ((_a = props.value) != null ? _a : "") + "";
+      },
+      set(value) {
+        patternContent.value = value || "";
+        search(value);
+      }
+    });
+    function onInputClick(evt) {
+      var _a;
+      if (((_a = evt.target) == null ? void 0 : _a.tagName) !== "INPUT")
+        return;
+      openMenu();
+    }
+    function openMenu() {
+      if (show.value)
+        return;
+      show.value = true;
+      emits("openMenu");
+      if (!props.searchOnOpenMenu)
+        return;
+      patternContent.value = "";
+      search();
+    }
+    function closeMenu() {
+      var _a;
+      show.value = false;
+      (_a = inputRef.value) == null ? void 0 : _a.blur();
+      emits("closeMenu");
+    }
+    function onClear() {
+      emits("clear");
+    }
+    onClickOutside(inputRef, (evt) => {
+      var _a;
+      if (!show.value)
+        return;
+      const _evt = evt;
+      if (!_evt.target)
+        return closeMenu();
+      if (isInPopper(_evt.target)) {
+        (_a = inputRef.value) == null ? void 0 : _a.focus();
+        return;
+      }
+      closeMenu();
+      function isInPopper(targetEle) {
+        let result = false;
+        let current = targetEle;
+        while (current) {
+          if (current.id === uuid) {
+            result = true;
+            break;
+          }
+          current = current.parentElement;
+        }
+        return result;
+      }
+    });
+    expose({
+      setPattern(value) {
+        patternContent.value = value;
+      },
+      closeMenu,
+      openMenu
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(NPopover), mergeProps({
+        trigger: "manual",
+        class: "recommend-search",
+        placement: "bottom-start",
+        show: unref(show),
+        "onUpdate:show": _cache[1] || (_cache[1] = ($event) => isRef(show) ? show.value = $event : null),
+        "show-arrow": false,
+        ref_key: "popoverRef",
+        ref: popoverRef,
+        width: "trigger"
+      }, __props.popProps), {
+        trigger: withCtx(() => [
+          createVNode(unref(NInput), mergeProps(__props.inputProps, {
+            onClear,
+            onFocus: onInputClick,
+            onClick: onInputClick,
+            onKeydown: withKeys(onInputClick, ["enter"]),
+            ref_key: "inputRef",
+            ref: inputRef,
+            value: unref(displayValueRef),
+            "onUpdate:value": _cache[0] || (_cache[0] = ($event) => isRef(displayValueRef) ? displayValueRef.value = $event : null)
+          }), null, 16, ["onKeydown", "value"])
+        ]),
+        default: withCtx(() => [
+          createElementVNode("section", {
+            id: unref(uuid),
+            class: "base-search__menu"
+          }, [
+            renderSlot(_ctx.$slots, "menu")
+          ], 8, _hoisted_1)
+        ]),
+        _: 3
+      }, 16, ["show"]);
+    };
+  }
+});
+var BaseSearch = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "BaseSearch.vue"]]);
+
+export { BaseSearch as default };