bge-ui 1.0.1 → 1.0.2

package/dist/tabs/index.vue.d.ts

@@ -0,0 +1,32 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    type: {
+        default: string;
+        value: string[];
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        default: string;
+        value: string[];
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    type: string;
+    modelValue: string;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tabs/tab-pane.vue.d.ts

@@ -0,0 +1,21 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    value: {
+        default: string;
+        type: StringConstructor;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        default: string;
+        type: StringConstructor;
+    };
+}>>, {
+    value: string;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/index.vue.d.ts

@@ -0,0 +1,221 @@
+import type { PropType } from 'vue';
+import type { PositioningStrategy, Placement, Modifier } from '@popperjs/core';
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    /**
+     * 是否将弹出层追加到body元素下
+     */
+    teleported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Trigger element on hover
+     */
+    hover: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Disable clicking outside to close
+     */
+    disableClickOutside: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * How many milliseconds to wait before opening the tooltip
+     */
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: number) => boolean;
+    };
+    /**
+     * How many milliseconds to wait before closing the tooltip
+     */
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: number) => boolean;
+    };
+    /**
+     * Display an arrow on the tooltip
+     */
+    showArrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Whether to interact with tooltip when hover is true
+     */
+    interactive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Set the strategy used to position the popper
+     *
+     * @values absolute | fixed
+     */
+    strategy: {
+        type: PropType<PositioningStrategy>;
+        default: string;
+    };
+    /**
+     * Set the placement of the popper
+     */
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /**
+     * Set the modifiers of the popper
+     */
+    modifiers: {
+        type: PropType<Modifier<any, any>[]>;
+        default: () => never[];
+    };
+    /**
+     * Set the type of animation
+     *
+     * @values none, fade, shift-in, shift-out, scale, CUSTOM
+     */
+    animation: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Animation duration in milliseconds
+     */
+    animationDuration: {
+        type: (ArrayConstructor | NumberConstructor)[];
+        default: number;
+        validator(value: unknown): boolean;
+    };
+}, {
+    popper: import("vue").Ref<any>;
+    isOpened: import("vue").ComputedRef<any>;
+    toggleTooltip: import("vue").Ref<any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    transition: (...args: any[]) => void;
+    opened: (...args: any[]) => void;
+    closed: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * 是否将弹出层追加到body元素下
+     */
+    teleported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Trigger element on hover
+     */
+    hover: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Disable clicking outside to close
+     */
+    disableClickOutside: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * How many milliseconds to wait before opening the tooltip
+     */
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: number) => boolean;
+    };
+    /**
+     * How many milliseconds to wait before closing the tooltip
+     */
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: number) => boolean;
+    };
+    /**
+     * Display an arrow on the tooltip
+     */
+    showArrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Whether to interact with tooltip when hover is true
+     */
+    interactive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Set the strategy used to position the popper
+     *
+     * @values absolute | fixed
+     */
+    strategy: {
+        type: PropType<PositioningStrategy>;
+        default: string;
+    };
+    /**
+     * Set the placement of the popper
+     */
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /**
+     * Set the modifiers of the popper
+     */
+    modifiers: {
+        type: PropType<Modifier<any, any>[]>;
+        default: () => never[];
+    };
+    /**
+     * Set the type of animation
+     *
+     * @values none, fade, shift-in, shift-out, scale, CUSTOM
+     */
+    animation: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Animation duration in milliseconds
+     */
+    animationDuration: {
+        type: (ArrayConstructor | NumberConstructor)[];
+        default: number;
+        validator(value: unknown): boolean;
+    };
+}>> & {
+    onTransition?: ((...args: any[]) => any) | undefined;
+    onOpened?: ((...args: any[]) => any) | undefined;
+    onClosed?: ((...args: any[]) => any) | undefined;
+}, {
+    modifiers: Modifier<any, any>[];
+    animation: string;
+    animationDuration: number | unknown[];
+    placement: Placement;
+    strategy: PositioningStrategy;
+    teleported: boolean;
+    hover: boolean;
+    disableClickOutside: boolean;
+    openDelay: number;
+    closeDelay: number;
+    showArrow: boolean;
+    interactive: boolean;
+}, {}>, {
+    default?(_: {}): any;
+    content?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/tooltip/only-child.d.ts

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

package/dist/tooltip/usePopper.d.ts

@@ -0,0 +1,252 @@
+import type { SetupContext, VNode } from 'vue';
+import type { PositioningStrategy, Placement, Modifier, Options as ModifierOptions } from '@popperjs/core';
+type Options = {
+    placement?: Placement;
+    hover?: boolean;
+    disableClickOutside?: boolean;
+    openDelay?: number;
+    closeDelay?: number;
+    showArrow?: boolean;
+    strategy?: PositioningStrategy;
+    interactive?: boolean;
+    animation?: string;
+    animationDuration?: number | number[];
+    popperOptions?: object;
+    modifiers?: Modifier<string, ModifierOptions>[];
+    onOpened?: () => void;
+    onClosed?: () => void;
+    onTransition?: (transition: string, element: HTMLElement) => void;
+};
+declare const usePopper: (triggerReference: any, suppliedOptions?: Options) => {
+    triggerElement: any;
+    tooltipElement: (props: object, context: SetupContext) => VNode;
+    popperInstance: import("vue").Ref<{
+        state: {
+            elements: {
+                reference: Element | {
+                    getBoundingClientRect: () => DOMRect | ClientRect;
+                    contextElement?: Element | undefined;
+                };
+                popper: HTMLElement;
+                arrow?: HTMLElement | undefined;
+            };
+            options: {
+                placement: Placement;
+                modifiers: any[];
+                strategy: PositioningStrategy;
+                onFirstUpdate?: ((arg0: Partial<import("@popperjs/core").State>) => void) | undefined;
+            };
+            placement: Placement;
+            strategy: PositioningStrategy;
+            orderedModifiers: {
+                name: any;
+                enabled: boolean;
+                phase: import("@popperjs/core").ModifierPhases;
+                requires?: string[] | undefined;
+                requiresIfExists?: string[] | undefined;
+                fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => void | import("@popperjs/core").State;
+                effect?: ((arg0: import("@popperjs/core").ModifierArguments<any>) => void | (() => void)) | undefined;
+                options?: Partial<any> | undefined;
+                data?: import("@popperjs/core").Obj | undefined;
+            }[];
+            rects: {
+                reference: {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                };
+                popper: {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                };
+            };
+            scrollParents: {
+                reference: (Element | {
+                    innerHeight: number;
+                    offsetHeight: number;
+                    innerWidth: number;
+                    offsetWidth: number;
+                    pageXOffset: number;
+                    pageYOffset: number;
+                    getComputedStyle: typeof getComputedStyle;
+                    addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                    removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                    Element: Element;
+                    HTMLElement: HTMLElement;
+                    Node: Node;
+                    toString: () => "[object Window]";
+                    devicePixelRatio: number;
+                    visualViewport?: {
+                        addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                        dispatchEvent: (event: Event) => boolean;
+                        removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                        width: number;
+                        height: number;
+                        offsetLeft: number;
+                        offsetTop: number;
+                        scale: number;
+                    } | undefined;
+                    ShadowRoot: ShadowRoot;
+                } | {
+                    addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                    dispatchEvent: (event: Event) => boolean;
+                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                })[];
+                popper: (Element | {
+                    innerHeight: number;
+                    offsetHeight: number;
+                    innerWidth: number;
+                    offsetWidth: number;
+                    pageXOffset: number;
+                    pageYOffset: number;
+                    getComputedStyle: typeof getComputedStyle;
+                    addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                    removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                    Element: Element;
+                    HTMLElement: HTMLElement;
+                    Node: Node;
+                    toString: () => "[object Window]";
+                    devicePixelRatio: number;
+                    visualViewport?: {
+                        addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                        dispatchEvent: (event: Event) => boolean;
+                        removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                        width: number;
+                        height: number;
+                        offsetLeft: number;
+                        offsetTop: number;
+                        scale: number;
+                    } | undefined;
+                    ShadowRoot: ShadowRoot;
+                } | {
+                    addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                    dispatchEvent: (event: Event) => boolean;
+                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                })[];
+            };
+            styles: {
+                [key: string]: Partial<CSSStyleDeclaration>;
+            };
+            attributes: {
+                [key: string]: {
+                    [key: string]: string | boolean;
+                };
+            };
+            modifiersData: {
+                [x: string]: any;
+                arrow?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                    centerOffset: number;
+                } | undefined;
+                hide?: {
+                    isReferenceHidden: boolean;
+                    hasPopperEscaped: boolean;
+                    referenceClippingOffsets: {
+                        top: number;
+                        left: number;
+                        right: number;
+                        bottom: number;
+                    };
+                    popperEscapeOffsets: {
+                        top: number;
+                        left: number;
+                        right: number;
+                        bottom: number;
+                    };
+                } | undefined;
+                offset?: {
+                    auto?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    top?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    bottom?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    left?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    right?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "auto-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "auto-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "top-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "top-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "bottom-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "bottom-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "right-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "right-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "left-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "left-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                } | undefined;
+                preventOverflow?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                popperOffsets?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+            };
+            reset: boolean;
+        };
+        destroy: () => void;
+        forceUpdate: () => void;
+        update: () => Promise<Partial<import("@popperjs/core").State>>;
+        setOptions: (setOptionsAction: Partial<import("@popperjs/core").OptionsGeneric<any>> | ((prev: Partial<import("@popperjs/core").OptionsGeneric<any>>) => Partial<import("@popperjs/core").OptionsGeneric<any>>)) => Promise<Partial<import("@popperjs/core").State>>;
+    } | undefined>;
+    toggleTooltip: (status?: string) => void;
+    isOpened: import("vue").ComputedRef<boolean>;
+};
+export { usePopper };

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "bge-ui",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "type": "module",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "scripts": {
     "build": "vite build",
     "generate-icon": "tsx icons/generate.ts"
   },
   "files": [
+    "dist",
     "icons",
     "src"
   ],