vue-devui 1.2.0 → 1.2.1-alpha.0

package/types/select/index.d.ts

@@ -0,0 +1,12 @@
+import type { App } from 'vue';
+import Select from './src/select';
+import Option from './src/components/option';
+import OptionGroup from './src/components/option-group';
+export { Select, Option, OptionGroup };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/select/src/components/option-group.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import("vue").DefineComponent<{
+    label: {
+        type: StringConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+}>;
+export default _default;

package/types/select/src/components/option.d.ts

@@ -0,0 +1,41 @@
+declare const _default: import("vue").DefineComponent<{
+    value: {
+        type: import("vue").PropType<import("../select-types").OptionModelValue>;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    create: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<import("../select-types").OptionModelValue>;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    create: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    name: string;
+    value: import("../select-types").OptionModelValue;
+    disabled: boolean;
+    create: boolean;
+}>;
+export default _default;

package/types/select/src/components/select-arrow-icon.d.ts

@@ -0,0 +1,2 @@
+declare const SelectArrowIcon: () => JSX.Element;
+export default SelectArrowIcon;

package/types/select/src/components/select-content.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/types/select/src/composables/use-option.d.ts

@@ -0,0 +1,2 @@
+import { OptionProps, UseOptionReturnType } from '../select-types';
+export default function useOption(props: OptionProps): UseOptionReturnType;

package/types/select/src/composables/use-select-content.d.ts

@@ -0,0 +1,2 @@
+import { UseSelectContentReturnType } from '../select-types';
+export default function useSelectContent(): UseSelectContentReturnType;

package/types/select/src/composables/use-select-function.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { UseSelectFunctionReturn, SelectProps } from '../select-types';
+export default function useSelectFunction(props: SelectProps, selectRef: Ref<HTMLElement | undefined>): UseSelectFunctionReturn;

package/types/select/src/const.d.ts

@@ -0,0 +1,5 @@
+import { InjectionKey } from 'vue';
+import { SelectContext, OptionGroupContext } from './select-types';
+export declare const SELECT_TOKEN: InjectionKey<SelectContext>;
+export declare const OPTION_GROUP_TOKEN: InjectionKey<OptionGroupContext>;
+export declare const escapeStringRegexp: (string?: string) => string;

package/types/select/src/select-types.d.ts

@@ -0,0 +1,205 @@
+import { PropType, ComputedRef, ExtractPropTypes, Ref } from 'vue';
+export interface OptionObjectItem {
+    name: string;
+    value: string | number;
+    _checked: boolean;
+    [key: string]: unknown;
+}
+export declare type OptionItem = number | string | ({
+    value: string | number;
+} & Partial<OptionObjectItem>);
+export declare type Options = Array<OptionItem>;
+export declare type ModelValue = number | string | Array<number | string>;
+export declare type filterValue = boolean | ((query: string) => void);
+export declare type SelectSize = 'sm' | 'md' | 'lg';
+export declare const selectProps: {
+    readonly modelValue: {
+        readonly type: PropType<ModelValue>;
+        readonly default: "";
+    };
+    readonly 'onUpdate:modelValue': {
+        readonly type: PropType<(val: ModelValue) => void>;
+        readonly default: undefined;
+    };
+    readonly options: {
+        readonly type: PropType<Options>;
+        readonly default: () => never[];
+    };
+    readonly size: {
+        readonly type: PropType<SelectSize>;
+        readonly default: "md";
+    };
+    readonly overview: {
+        readonly type: PropType<"border" | "underlined">;
+        readonly default: "border";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowClear: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly optionDisabledKey: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly collapseTags: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly collapseTagsTooltip: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly filter: {
+        readonly type: PropType<filterValue>;
+        readonly default: false;
+    };
+    readonly remote: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowCreate: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly noDataText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly noMatchText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loadingText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly onToggleChange: {
+        readonly type: PropType<(bool: boolean) => void>;
+        readonly default: undefined;
+    };
+    readonly onValueChange: {
+        readonly type: PropType<(item: OptionItem, index: number) => void>;
+        readonly default: undefined;
+    };
+    readonly multipleLimit: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+};
+export declare type SelectProps = ExtractPropTypes<typeof selectProps>;
+export declare type OptionModelValue = number | string;
+export interface UseSelectReturnType {
+    selectDisabled: ComputedRef<boolean>;
+    selectSize: ComputedRef<SelectSize>;
+    originRef: Ref<HTMLElement | undefined>;
+    dropdownRef: Ref<HTMLElement | undefined>;
+    isOpen: Ref<boolean>;
+    selectCls: ComputedRef<string>;
+    mergeOptions: Ref<OptionObjectItem[]>;
+    selectedOptions: ComputedRef<OptionObjectItem[]>;
+    filterQuery: Ref<string>;
+    emptyText: ComputedRef<string>;
+    isLoading: Ref<boolean>;
+    isShowEmptyText: ComputedRef<boolean>;
+    handleClear: (e: MouseEvent) => void;
+    valueChange: (item: OptionObjectItem) => void;
+    handleClose: () => void;
+    updateInjectOptions: (item: Record<string, unknown>, operation: string, isObject: boolean) => void;
+    tagDelete: (data: OptionObjectItem) => void;
+    onFocus: (e: FocusEvent) => void;
+    onBlur: (e: FocusEvent) => void;
+    isDisabled: (item: OptionObjectItem) => boolean;
+    toggleChange: (bool: boolean) => void;
+    debounceQueryFilter: (query: string) => void;
+    isShowCreateOption: ComputedRef<boolean>;
+}
+export interface SelectContext extends SelectProps {
+    selectDisabled: boolean;
+    selectSize: string;
+    isOpen: boolean;
+    selectedOptions: OptionObjectItem[];
+    filterQuery: string;
+    valueChange: (item: OptionObjectItem) => void;
+    handleClear: () => void;
+    updateInjectOptions: (item: Record<string, unknown>, operation: string, isObject: boolean) => void;
+    tagDelete: (data: OptionObjectItem) => void;
+    onFocus: (e: FocusEvent) => void;
+    onBlur: (e: FocusEvent) => void;
+    debounceQueryFilter: (query: string) => void;
+}
+export declare const optionProps: {
+    value: {
+        type: PropType<OptionModelValue>;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    create: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare type OptionProps = ExtractPropTypes<typeof optionProps>;
+export interface UseOptionReturnType {
+    currentName: ComputedRef<OptionModelValue>;
+    selectOptionCls: ComputedRef<string>;
+    isVisible: ComputedRef<boolean>;
+    optionSelect: () => void;
+}
+export interface UseSelectContentReturnType {
+    searchQuery: Ref<string>;
+    selectedData: ComputedRef<OptionObjectItem[]>;
+    isSelectDisable: ComputedRef<boolean>;
+    isSupportCollapseTags: ComputedRef<boolean>;
+    isDisabledTooltip: ComputedRef<boolean>;
+    isReadOnly: ComputedRef<boolean>;
+    selectionCls: ComputedRef<string>;
+    inputCls: ComputedRef<string>;
+    tagSize: ComputedRef<string>;
+    placeholder: ComputedRef<string>;
+    isMultiple: ComputedRef<boolean>;
+    displayInputValue: ComputedRef<string>;
+    handleClear: (e: MouseEvent) => void;
+    tagDelete: (data: OptionObjectItem) => void;
+    onFocus: (e: FocusEvent) => void;
+    onBlur: (e: FocusEvent) => void;
+    queryFilter: (e: Event) => void;
+}
+export interface UseSelectFunctionReturn {
+    isSelectFocus: Ref<boolean>;
+    blur: () => void;
+    focus: () => void;
+}
+export declare const optionGroupProps: {
+    label: {
+        type: StringConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare type OptionGroupProps = ExtractPropTypes<typeof optionGroupProps>;
+export declare type OptionGroupContext = OptionGroupProps;

package/types/select/src/select.d.ts

@@ -0,0 +1,204 @@
+import './select.scss';
+declare const _default: import("vue").DefineComponent<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<import("./select-types").ModelValue>;
+        readonly default: "";
+    };
+    readonly 'onUpdate:modelValue': {
+        readonly type: import("vue").PropType<(val: import("./select-types").ModelValue) => void>;
+        readonly default: undefined;
+    };
+    readonly options: {
+        readonly type: import("vue").PropType<import("./select-types").Options>;
+        readonly default: () => never[];
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("./select-types").SelectSize>;
+        readonly default: "md";
+    };
+    readonly overview: {
+        readonly type: import("vue").PropType<"border" | "underlined">;
+        readonly default: "border";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowClear: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly optionDisabledKey: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly collapseTags: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly collapseTagsTooltip: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly filter: {
+        readonly type: import("vue").PropType<import("./select-types").filterValue>;
+        readonly default: false;
+    };
+    readonly remote: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowCreate: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly noDataText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly noMatchText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loadingText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly onToggleChange: {
+        readonly type: import("vue").PropType<(bool: boolean) => void>;
+        readonly default: undefined;
+    };
+    readonly onValueChange: {
+        readonly type: import("vue").PropType<(item: import("./select-types").OptionItem, index: number) => void>;
+        readonly default: undefined;
+    };
+    readonly multipleLimit: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "clear" | "blur" | "focus" | "update:modelValue" | "toggle-change" | "value-change" | "remove-tag", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<import("./select-types").ModelValue>;
+        readonly default: "";
+    };
+    readonly 'onUpdate:modelValue': {
+        readonly type: import("vue").PropType<(val: import("./select-types").ModelValue) => void>;
+        readonly default: undefined;
+    };
+    readonly options: {
+        readonly type: import("vue").PropType<import("./select-types").Options>;
+        readonly default: () => never[];
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("./select-types").SelectSize>;
+        readonly default: "md";
+    };
+    readonly overview: {
+        readonly type: import("vue").PropType<"border" | "underlined">;
+        readonly default: "border";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowClear: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly optionDisabledKey: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly collapseTags: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly collapseTagsTooltip: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly filter: {
+        readonly type: import("vue").PropType<import("./select-types").filterValue>;
+        readonly default: false;
+    };
+    readonly remote: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowCreate: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly noDataText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly noMatchText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loadingText: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly onToggleChange: {
+        readonly type: import("vue").PropType<(bool: boolean) => void>;
+        readonly default: undefined;
+    };
+    readonly onValueChange: {
+        readonly type: import("vue").PropType<(item: import("./select-types").OptionItem, index: number) => void>;
+        readonly default: undefined;
+    };
+    readonly multipleLimit: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+}>>, {
+    readonly filter: import("./select-types").filterValue;
+    readonly loading: boolean;
+    readonly disabled: boolean;
+    readonly multiple: boolean;
+    readonly options: import("./select-types").Options;
+    readonly size: import("./select-types").SelectSize;
+    readonly placeholder: string;
+    readonly modelValue: import("./select-types").ModelValue;
+    readonly 'onUpdate:modelValue': (val: import("./select-types").ModelValue) => void;
+    readonly onToggleChange: (bool: boolean) => void;
+    readonly allowClear: boolean;
+    readonly overview: "border" | "underlined";
+    readonly optionDisabledKey: string;
+    readonly collapseTags: boolean;
+    readonly collapseTagsTooltip: boolean;
+    readonly remote: boolean;
+    readonly allowCreate: boolean;
+    readonly noDataText: string;
+    readonly noMatchText: string;
+    readonly loadingText: string;
+    readonly onValueChange: (item: import("./select-types").OptionItem, index: number) => void;
+    readonly multipleLimit: number;
+}>;
+export default _default;

package/types/select/src/use-select.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import type { SetupContext } from 'vue';
+import { SelectProps, UseSelectReturnType } from './select-types';
+export default function useSelect(props: SelectProps, selectRef: Ref<HTMLElement | undefined>, ctx: SetupContext, focus: () => void, blur: () => void, isSelectFocus: Ref<boolean>, t: (path: string) => unknown): UseSelectReturnType;

package/types/select/src/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 动态获取class字符串
+ * @param classStr 是一个字符串，固定的class名
+ * @param classOpt 是一个对象，key表示class名，value为布尔值，true则添加，否则不添加
+ * @returns 最终的class字符串
+ */
+export declare function className(classStr: string, classOpt?: {
+    [key: string]: boolean;
+}): string;
+export declare type KeyType<T, K extends keyof T> = T[K];

package/types/shared/components/popper-trigger/index.d.ts

@@ -0,0 +1,2 @@
+import PopperTrigger from './src/popper-trigger';
+export { PopperTrigger };

package/types/shared/components/popper-trigger/src/popper-trigger-types.d.ts

@@ -0,0 +1,2 @@
+import type { InjectionKey, Ref } from 'vue';
+export declare const POPPER_TRIGGER_TOKEN: InjectionKey<Ref>;

package/types/shared/components/popper-trigger/src/popper-trigger.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/types/shared/components/popper-trigger/src/use-popper-trigger.d.ts

@@ -0,0 +1,2 @@
+import type { VNode } from 'vue';
+export declare function getFirstValidChild(nodes: VNode[]): VNode | null;

package/types/shared/devui-api/devui-api.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("vue").DefineComponent<Readonly<import("vue").ComponentPropsOptions<{
+    [x: string]: unknown;
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, readonly string[] | Readonly<import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+    [x: string]: unknown;
+}>>>>, {
+    [x: number]: string;
+} | {}>;
+export default _default;

package/types/shared/devui-api-table/devui-api-table.d.ts

@@ -0,0 +1,26 @@
+import { ITableColumn, ITableDataRow } from './devui-api-table.type';
+declare const _default: import("vue").DefineComponent<{
+    readonly columns: {
+        readonly type: import("vue").PropType<ITableColumn[]>;
+        readonly required: true;
+        readonly default: () => never[];
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<ITableDataRow[]>;
+        readonly default: () => never[];
+    };
+}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly columns: {
+        readonly type: import("vue").PropType<ITableColumn[]>;
+        readonly required: true;
+        readonly default: () => never[];
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<ITableDataRow[]>;
+        readonly default: () => never[];
+    };
+}>>, {
+    readonly data: ITableDataRow[];
+    readonly columns: ITableColumn[];
+}>;
+export default _default;

package/types/shared/devui-api-table/devui-api-table.type.d.ts

@@ -0,0 +1,19 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+export declare type ITableColumn = {
+    key: string;
+    title: string;
+    type?: 'turn';
+};
+export declare type ITableDataRow = Record<string, any>;
+export declare const apiTableProps: {
+    readonly columns: {
+        readonly type: PropType<ITableColumn[]>;
+        readonly required: true;
+        readonly default: () => never[];
+    };
+    readonly data: {
+        readonly type: PropType<ITableDataRow[]>;
+        readonly default: () => never[];
+    };
+};
+export declare type ApiTableProps = ExtractPropTypes<typeof apiTableProps>;

package/types/shared/devui-api-table/index.d.ts

@@ -0,0 +1 @@
+export { default } from './devui-api-table';

package/types/shared/devui-codebox/codebox-collapse-icon.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/types/shared/devui-codebox/codebox-copied-icon.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/types/shared/devui-codebox/codebox-copy-icon.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/types/shared/devui-codebox/devui-codebox.d.ts

@@ -0,0 +1,18 @@
+import { DevuiSourceData } from './devui-source-data';
+import './devui-codebox.scss';
+declare const _default: import("vue").DefineComponent<{
+    id: StringConstructor;
+    sourceData: {
+        type: () => DevuiSourceData[];
+        default: never[];
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    id: StringConstructor;
+    sourceData: {
+        type: () => DevuiSourceData[];
+        default: never[];
+    };
+}>>, {
+    sourceData: DevuiSourceData[];
+}>;
+export default _default;

package/types/shared/devui-codebox/devui-source-data.d.ts

@@ -0,0 +1,5 @@
+export interface DevuiSourceData {
+    title?: string;
+    language?: string;
+    code?: any;
+}

package/types/shared/devui-directive/clickoutside.d.ts

@@ -0,0 +1,12 @@
+/**
+ * v-clickoutside
+ * @desc 点击元素外面才会触发的事件
+ * @example
+ * <div v-clickoutside="handleClose">
+ */
+declare const clickoutsideDirective: {
+    beforeMount: (el: HTMLElement, binding: Record<string, any>, vnode: any) => void;
+    updated: (el: HTMLElement, binding: Record<string, any>, vnode: any) => void;
+    unmounted: (el: HTMLElement) => void;
+};
+export default clickoutsideDirective;

package/types/shared/devui-directive/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function on(element: HTMLElement | Document, eventName: string, handler: (this: Element, ev: Event) => any): void;
+export declare function off(element: HTMLElement | Document, eventName: string, handler: (this: Element, ev: Event) => any): void;