bkui-vue 0.0.1-beta.35 → 0.0.1-beta.350

package/lib/search-select/selected.d.ts

@@ -0,0 +1,139 @@
+import { PropType } from 'vue';
+import { GetMenuListFunc, ICommonItem, ISearchItem, SearchInputMode, SelectedItem, ValidateValuesFunc } from './utils';
+declare const _default: import("vue").DefineComponent<{
+    data: {
+        type: PropType<ISearchItem[]>;
+        required: true;
+    };
+    selectedList: {
+        type: PropType<SelectedItem[]>;
+        required: true;
+    };
+    overflowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    conditions: {
+        type: PropType<ICommonItem[]>;
+        default: () => any[];
+    };
+    getMenuList: PropType<GetMenuListFunc>;
+    validateValues: PropType<ValidateValuesFunc>;
+}, {
+    inputRef: import("vue").Ref<import("vue").DefineComponent<{
+        data: {
+            type: PropType<ISearchItem[]>;
+            required: true;
+        };
+        showInputBefore: BooleanConstructor;
+        showCondition: BooleanConstructor;
+        clickOutside: FunctionConstructor;
+        conditions: {
+            type: PropType<ICommonItem[]>;
+            default: () => any[];
+        };
+        defautUsingItem: PropType<SelectedItem>;
+        mode: {
+            type: PropType<SearchInputMode>;
+            default: SearchInputMode;
+        };
+        getMenuList: PropType<GetMenuListFunc>;
+        validateValues: PropType<ValidateValuesFunc>;
+    }, {
+        popoverRef: import("vue").Ref<HTMLDivElement>;
+        inputRef: import("vue").Ref<HTMLDivElement>;
+        keyword: import("vue").Ref<string>;
+        loading: import("vue").Ref<boolean>;
+        remoteMenuList: import("vue").Ref<{
+            id: string;
+            name: string;
+            disabled?: boolean;
+            realId?: string;
+            value?: {
+                name: string;
+                id: string;
+                realId?: string;
+                isSelected?: boolean;
+            };
+            isSelected?: boolean;
+        }[]>;
+        menuList: import("vue").Ref<ISearchItem[]>;
+        menuHoverId: import("vue").Ref<string>;
+        isFocus: import("vue").Ref<boolean>;
+        usingItem: import("vue").Ref<SelectedItem>;
+        showPopover: import("vue").Ref<boolean>;
+        showNoSelectValueError: import("vue").Ref<boolean>;
+        debounceSetMenuList: {
+            (this: any): any;
+            cancel(): void;
+        };
+        documentArrowEvent: (e: KeyboardEvent) => void;
+        handleClickOutside: (e: MouseEvent) => void;
+        handleInputFocus: (e: FocusEvent) => void;
+        handleInputChange: (event: Event) => void;
+        handleInputKeyup: (event: KeyboardEvent) => void;
+        handleSelectItem: (item: ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
+        handleSelectCondtionItem: (item: ICommonItem) => void;
+        handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "add" | "delete")[], "focus" | "add" | "delete", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        data: {
+            type: PropType<ISearchItem[]>;
+            required: true;
+        };
+        showInputBefore: BooleanConstructor;
+        showCondition: BooleanConstructor;
+        clickOutside: FunctionConstructor;
+        conditions: {
+            type: PropType<ICommonItem[]>;
+            default: () => any[];
+        };
+        defautUsingItem: PropType<SelectedItem>;
+        mode: {
+            type: PropType<SearchInputMode>;
+            default: SearchInputMode;
+        };
+        getMenuList: PropType<GetMenuListFunc>;
+        validateValues: PropType<ValidateValuesFunc>;
+    }>> & {
+        onFocus?: (...args: any[]) => any;
+        onAdd?: (...args: any[]) => any;
+        onDelete?: (...args: any[]) => any;
+    }, {
+        mode: SearchInputMode;
+        conditions: ICommonItem[];
+        showInputBefore: boolean;
+        showCondition: boolean;
+    }>>;
+    editKey: import("vue").Ref<String>;
+    copySeletedItem: (item: SelectedItem) => SelectedItem;
+    handleDeleteSelected: (index: number) => void;
+    handleEditSeleted: (e: MouseEvent, item: SelectedItem, index: number) => void;
+    handleInputOutside: () => boolean;
+    handleAddSelected: (item: SelectedItem, index: number) => void;
+    handleInputFocus: (isFocus: boolean) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "delete"[], "delete", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: PropType<ISearchItem[]>;
+        required: true;
+    };
+    selectedList: {
+        type: PropType<SelectedItem[]>;
+        required: true;
+    };
+    overflowIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    conditions: {
+        type: PropType<ICommonItem[]>;
+        default: () => any[];
+    };
+    getMenuList: PropType<GetMenuListFunc>;
+    validateValues: PropType<ValidateValuesFunc>;
+}>> & {
+    onDelete?: (...args: any[]) => any;
+}, {
+    conditions: ICommonItem[];
+    overflowIndex: number;
+}>;
+export default _default;

package/lib/search-select/utils.d.ts

@@ -0,0 +1,84 @@
+import { ComputedRef, InjectionKey, Ref, VNode } from 'vue';
+/**
+ * @description: 获取menu list方法
+ * @param {ISearchItem} item 已选择的key字段 为空则代表当前并未选择key字段
+ * @param {string} keyword 已输入的文本
+ * @return {*} menu list用于渲染选择弹层列表
+ */
+export declare type GetMenuListFunc = (item: ISearchItem, keyword: string) => Promise<ISearchItem[]>;
+export declare type ValidateValuesFunc = (item: ISearchItem, values: ICommonItem[]) => Promise<string | true>;
+export declare type MenuSlotParams = {
+    item: ISearchItem;
+    list: ISearchItem[];
+    hoverId: string;
+    multiple: boolean;
+    getSearchNode: (str: string) => string | (string | VNode)[];
+};
+export interface ISearchSelectProvider {
+    onEditClick: (item: SelectedItem, index: number) => void;
+    onEditEnter: (item: SelectedItem, index: number) => void;
+    onEditBlur: () => void;
+    onValidate: (str: string) => void;
+    editKey: Ref<String>;
+    valueSplitCode: ComputedRef<string>;
+}
+export declare const SEARCH_SLECT_PROVIDER_KEY: InjectionKey<ISearchSelectProvider>;
+export declare const useSearchSelectProvider: (data: ISearchSelectProvider) => void;
+export declare const useSearchSelectInject: () => ISearchSelectProvider;
+export declare enum SearchInputMode {
+    'DEFAULT' = "default",
+    'EDIT' = "edit"
+}
+export interface ICommonItem {
+    id: string;
+    name: string;
+    disabled?: boolean;
+    realId?: string;
+    value?: Omit<ICommonItem, 'disabled' | 'value'>;
+    isSelected?: boolean;
+}
+export interface ISearchValue extends Omit<ICommonItem, 'disabled' | 'value'> {
+    type?: SearchItemType;
+    values?: Omit<ICommonItem, 'disabled'>[];
+}
+export interface ISearchItem {
+    id: string;
+    name: string;
+    children?: ICommonItem[];
+    multiple?: boolean;
+    async?: boolean;
+    noValidate?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    value?: ICommonItem;
+    isSelected?: boolean;
+}
+export interface IMenuFooterItem {
+    id: 'confirm' | 'cancel';
+    name: string;
+    disabled?: boolean;
+}
+export declare type SearchItemType = 'text' | 'default' | 'condition';
+export declare class SelectedItem {
+    searchItem: ISearchItem;
+    type: SearchItemType;
+    splitCode: string;
+    id: string;
+    name: string;
+    values: ICommonItem[];
+    condition: string;
+    constructor(searchItem: ISearchItem, type?: SearchItemType, splitCode?: string);
+    get multiple(): boolean;
+    get placeholder(): string;
+    get children(): ICommonItem[];
+    get validate(): boolean;
+    get inputInnerHtml(): string;
+    get inputInnerText(): string;
+    get keyInnerHtml(): string;
+    get keyInnerText(): string;
+    isSpecialType(): boolean;
+    addValue(item: ICommonItem): void;
+    toValue(): ISearchValue;
+    toValueKey(): string;
+    isInValueList(item: ICommonItem): boolean;
+}

package/lib/select/common.d.ts

@@ -1,32 +1,25 @@
 import { InjectionKey, Ref } from 'vue';
-import { OnFirstUpdateFnType } from '@bkui-vue/shared';
 import { IOptionGroupContext, IPopoverConfig, ISelectContext } from './type';
 export declare const selectKey: InjectionKey<ISelectContext>;
 export declare const optionGroupKey: InjectionKey<IOptionGroupContext>;
-export declare function useFocus(): {
-    isFocus: Ref<boolean>;
-    handleFocus: () => void;
-    handleBlur: () => void;
-};
 export declare function useHover(): {
     isHover: Ref<boolean>;
     setHover: () => void;
     cancelHover: () => void;
 };
-export declare function useRegistry<T>(data: Ref<Set<T>>): {
-    register: (item: T) => Set<T>;
-    unregister: (item: T) => boolean;
+export declare function useRegistry<T>(data: Ref<Map<any, T>>): {
+    register: (key: any, item: T) => Map<any, T>;
+    unregister: (key: any) => void;
 };
 export declare function useDebouncedRef<T>(value: any, delay?: number): Ref<T>;
-export declare function usePopover(config: IPopoverConfig): {
+export declare function usePopover(config: IPopoverConfig, triggerRef: Ref<HTMLElement>): {
     isPopoverShow: Ref<boolean>;
     popperWidth: Ref<string | number>;
     togglePopover: () => void;
-    onPopoverFirstUpdate: OnFirstUpdateFnType;
     hidePopover: () => void;
     showPopover: () => void;
 };
-export declare function useRemoteSearch(method: Function): {
+export declare function useRemoteSearch(method: Function, callBack?: Function): {
     searchKey: Ref<string>;
     searchLoading: Ref<boolean>;
 };