@type-dom/ui 0.0.10 → 0.1.1

package/src/components/feedback/td-popper/arrow/arrow.const.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.popperArrowProps = void 0;
+const signals_1 = require("@type-dom/signals");
+exports.popperArrowProps = {
+    arrowOffset: (0, signals_1.signal)(5),
+};

package/src/components/feedback/td-popper/arrow/arrow.interface.d.ts

@@ -1,11 +1,11 @@
-import { IUI, IUIConfig } from '../../../../ui/ui.interface';
-export interface ITdPopperArrow extends IUI {
+import { ITypeSpan, TypeSpanProps } from '@type-dom/framework';
+import { Signal } from '@type-dom/signals';
+export interface ITdPopperArrow extends ITypeSpan {
     className: 'TdPopperArrow';
 }
-export interface ITdPopperArrowConfig extends IUIConfig {
+export interface PopperArrowProps extends TypeSpanProps {
     /**
-     *
      *     default: 5,
      */
-    arrowOffset?: number;
+    arrowOffset?: Signal<number>;
 }

package/src/components/feedback/td-popper/composable/use-content-dom.d.ts

@@ -0,0 +1,35 @@
+import { IStyle } from '@type-dom/css-type';
+import { PopperContentProps } from '../content/content.interface';
+export declare const usePopperContentDOM: (props: PopperContentProps, { styles, role, }: any) => {
+    ariaModal: import("@type-dom/signals").Computed<string | undefined>;
+    arrowStyle: import("@type-dom/signals").Computed<IStyle<string | 0, string>>;
+    contentClass: import("@type-dom/signals").Computed<((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | ((string | {
+        [x: string]: boolean;
+    } | /*elided*/ any) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]) | undefined)[]>;
+    contentStyle: IStyle<string | 0, string>;
+    contentZIndex: import("@type-dom/signals").Signal<number>;
+    updateZIndex: () => void;
+};
+export type UsePopperContentDOMReturn = ReturnType<typeof usePopperContentDOM>;

package/src/components/feedback/td-popper/composable/use-content-dom.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePopperContentDOM = void 0;
+const utils_1 = require("@type-dom/utils");
+const signals_1 = require("@type-dom/signals");
+const use_namespace_1 = require("../../../../hooks/use-namespace");
+const use_z_index_1 = require("../../../../hooks/use-z-index");
+const usePopperContentDOM = (props, { 
+// attributes,
+styles, role, } //: Pick<UsePopperReturn, 'attributes' | 'styles'> &
+) => {
+    const { nextZIndex } = (0, use_z_index_1.useZIndex)();
+    const ns = (0, use_namespace_1.useNamespace)('popper');
+    // const contentAttrs = computed(() => unref(attributes).popper)
+    const contentZIndex = (0, signals_1.signal)((0, utils_1.isNumber)(props.zIndex) ? props.zIndex : nextZIndex());
+    const contentClass = (0, signals_1.computed)(() => [
+        ns.b(),
+        ns.is('pure', props.pure),
+        ns.is(props.effect || ''),
+        props.popperClass,
+    ]);
+    const contentStyle = Object.assign(Object.assign({ zIndex: (0, signals_1.unref)(contentZIndex) }, styles.popper), (props.popperStyle || {}));
+    const ariaModal = (0, signals_1.computed)(() => role === 'dialog' ? 'false' : undefined);
+    const arrowStyle = (0, signals_1.computed)(() => ((0, signals_1.unref)(styles).arrow || {}));
+    const updateZIndex = () => {
+        contentZIndex.set((0, utils_1.isNumber)(props.zIndex) ? props.zIndex : nextZIndex());
+    };
+    return {
+        ariaModal,
+        arrowStyle,
+        // contentAttrs,
+        contentClass,
+        contentStyle,
+        contentZIndex,
+        updateZIndex,
+    };
+};
+exports.usePopperContentDOM = usePopperContentDOM;

package/src/components/feedback/td-popper/composable/use-content.d.ts

@@ -0,0 +1,45 @@
+import { Computed } from '@type-dom/signals';
+import { Middleware } from '@type-dom/popper';
+import { PopperContentProps } from '../content/content.interface';
+export declare const usePopperContent: (props: PopperContentProps) => {
+    attributes: Computed<{
+        [key: string]: {
+            [key: string]: string | boolean;
+        };
+    }>;
+    arrowRef: import("@type-dom/signals").Signal<HTMLElement | undefined>;
+    contentRef: import("@type-dom/signals").Signal<HTMLElement | undefined>;
+    instanceRef: Computed<import("@type-dom/popper").Instance | undefined>;
+    state: Computed<{
+        elements?: {
+            reference: Element | import("@type-dom/popper").VirtualElement;
+            popper: HTMLElement;
+            arrow?: HTMLElement;
+        } | undefined;
+        options?: {
+            placement?: import("@type-dom/popper").Placement | undefined;
+            strategy?: import("@type-dom/popper").Strategy | undefined;
+            middleware?: Array<Middleware | null | undefined | false> | undefined;
+            platform?: import("@type-dom/popper").Platform | undefined;
+        } | undefined;
+        placement?: import("@type-dom/popper").Placement | undefined;
+        strategy?: import("@type-dom/popper").Strategy;
+        scrollParents?: {
+            reference: Array<Element | Window | VisualViewport>;
+            popper: Array<Element | Window | VisualViewport>;
+        };
+        styles?: Record<string, import("dist/libs/css-type/src").IStyle<string | 0, string>> | undefined;
+        attributes?: {
+            [key: string]: {
+                [key: string]: string | boolean;
+            };
+        } | undefined;
+        middlewareData?: import("@type-dom/popper").MiddlewareData | undefined;
+        reset?: boolean;
+    }>;
+    styles: Computed<Record<string, import("dist/libs/css-type/src").IStyle<string | 0, string>>>;
+    role: Computed<import("../td-popper.interface").RoleTypes | undefined>;
+    forceUpdate: () => Promise<import("@type-dom/popper").State | undefined> | undefined;
+    update: () => Promise<import("@type-dom/popper").State | undefined> | undefined;
+};
+export type UsePopperContentReturn = ReturnType<typeof usePopperContent>;

package/src/components/feedback/td-popper/composable/use-content.js

@@ -0,0 +1,83 @@
+"use strict";
+// import { computed, inject, onMounted, ref, unref, watch } from 'vue'
+// import { isUndefined } from 'lodash-unified'
+// import { usePopper } from '@element-plus/hooks'
+// import { buildPopperOptions, unwrapMeasurableEl } from '../utils'
+// import type { Modifier } from '@popperjs/core'
+// import type { PartialOptions } from '@element-plus/hooks'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePopperContent = void 0;
+const signals_1 = require("@type-dom/signals");
+const popper_1 = require("@type-dom/popper");
+const utils_1 = require("@type-dom/utils");
+const framework_1 = require("@type-dom/framework");
+const use_popper_1 = require("../../../../hooks/use-popper");
+const utils_2 = require("../utils");
+const constants_1 = require("../constants");
+const DEFAULT_ARROW_OFFSET = 0;
+const usePopperContent = (props) => {
+    const { popperInstanceRef, contentRef, triggerRef, role } = (0, framework_1.inject)(constants_1.POPPER_INJECTION_KEY, undefined);
+    const arrowRef = (0, signals_1.signal)();
+    const arrowOffset = (0, signals_1.signal)(5);
+    // const eventListenerModifier = computed(() => {
+    //   return {
+    //     name: 'eventListeners',
+    //     enabled: !!props.visible,
+    //   } // as Modifier<'eventListeners', any>
+    // })
+    // middleWare
+    const arrowMiddleware = (0, signals_1.computed)(() => {
+        var _a;
+        console.log('arrowMiddleware', arrowRef, arrowOffset);
+        const arrowEl = (0, signals_1.unref)(arrowRef);
+        const offset = (_a = (0, signals_1.unref)(arrowOffset)) !== null && _a !== void 0 ? _a : DEFAULT_ARROW_OFFSET;
+        // Seems like the `phase` and `fn` is required by Modifier type
+        // But on its documentation they didn't specify that.
+        // Refer to https://popper.js.org/docs/v2/modifiers/arrow/
+        // return {
+        //   name: 'arrow',
+        //   enabled: !isUndefined(arrowEl),
+        //   options: {
+        //     element: arrowEl,
+        //     padding: offset,
+        //   },
+        // }
+        if (!(0, utils_1.isUndefined)(arrowEl)) {
+            return (0, popper_1.arrow)({ element: arrowEl, padding: offset });
+        }
+        else {
+            return undefined;
+        }
+    });
+    // 这个 options 对应的是 中间件 Middleware, 不包含其它的选项。
+    const options = (0, signals_1.computed)(() => {
+        console.warn('useContent options computed . ');
+        return Object.assign({}, (0, utils_2.buildPopperOptions)(props, [
+            (0, signals_1.unref)(arrowMiddleware),
+            // unref(eventListenerModifier),
+        ]));
+    });
+    const computedReference = (0, signals_1.computed)(() => ((0, utils_2.unwrapMeasurableEl)(props.referenceEl) || (0, signals_1.unref)(triggerRef)));
+    const { attributes, state, styles, instanceRef, update, forceUpdate } = (0, use_popper_1.usePopper)(computedReference, contentRef, options);
+    (0, signals_1.watch)(instanceRef, (instance) => popperInstanceRef.set(instance));
+    (0, framework_1.onMounted)(() => {
+        (0, signals_1.watch)(() => {
+            var _a;
+            return (_a = (0, signals_1.unref)(computedReference)) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+        }, () => {
+            update();
+        });
+    });
+    return {
+        attributes,
+        arrowRef,
+        contentRef,
+        instanceRef,
+        state,
+        styles,
+        role,
+        forceUpdate,
+        update,
+    };
+};
+exports.usePopperContent = usePopperContent;

package/src/components/feedback/td-popper/composable/use-focus-trap.d.ts

@@ -0,0 +1,11 @@
+import { PopperContentProps } from '../content/content.interface';
+export declare const usePopperContentFocusTrap: (props: PopperContentProps, emit: (evt: string) => void) => {
+    focusStartRef: import("@type-dom/signals").Signal<HTMLElement | "first" | "container" | undefined>;
+    trapped: import("@type-dom/signals").Signal<boolean>;
+    onFocusAfterReleased: (event?: CustomEvent) => void;
+    onFocusAfterTrapped: () => void;
+    onFocusInTrap: (event?: FocusEvent) => void;
+    onFocusoutPrevented: (event?: CustomEvent) => void;
+    onReleaseRequested: () => void;
+};
+export type UsePopperContentFocusTrapReturn = ReturnType<typeof usePopperContentFocusTrap>;

package/src/components/feedback/td-popper/composable/use-focus-trap.js

@@ -1 +1,48 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePopperContentFocusTrap = void 0;
+const signals_1 = require("@type-dom/signals");
+const usePopperContentFocusTrap = (props, emit) => {
+    const trapped = (0, signals_1.signal)(false);
+    const focusStartRef = (0, signals_1.signal)();
+    const onFocusAfterTrapped = () => {
+        emit('focus');
+    };
+    const onFocusAfterReleased = (event) => {
+        var _a;
+        if (((_a = event === null || event === void 0 ? void 0 : event.detail) === null || _a === void 0 ? void 0 : _a.focusReason) !== 'pointer') {
+            focusStartRef.set('first');
+            emit('blur');
+        }
+    };
+    const onFocusInTrap = (event) => {
+        if (props.visible && !trapped.get()) {
+            if (event === null || event === void 0 ? void 0 : event.target) {
+                focusStartRef.set(event.target);
+            }
+            trapped.set(true);
+        }
+    };
+    const onFocusoutPrevented = (event) => {
+        if (!props.trapping) {
+            if ((event === null || event === void 0 ? void 0 : event.detail.focusReason) === 'pointer') {
+                event.preventDefault();
+            }
+            trapped.set(false);
+        }
+    };
+    const onReleaseRequested = () => {
+        trapped.set(false);
+        emit('close');
+    };
+    return {
+        focusStartRef,
+        trapped,
+        onFocusAfterReleased,
+        onFocusAfterTrapped,
+        onFocusInTrap,
+        onFocusoutPrevented,
+        onReleaseRequested,
+    };
+};
+exports.usePopperContentFocusTrap = usePopperContentFocusTrap;

package/src/components/feedback/td-popper/constants.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey } from '@type-dom/framework';
+import { TdPopperContentInjectionContext, TdPopperInjectionContext } from './td-popper.interface';
+export declare const POPPER_INJECTION_KEY: InjectionKey<TdPopperInjectionContext>;
+export declare const POPPER_CONTENT_INJECTION_KEY: InjectionKey<TdPopperContentInjectionContext>;

package/src/components/feedback/td-popper/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POPPER_CONTENT_INJECTION_KEY = exports.POPPER_INJECTION_KEY = void 0;
+exports.POPPER_INJECTION_KEY = Symbol('popper');
+exports.POPPER_CONTENT_INJECTION_KEY = Symbol('popperContent');

package/src/components/feedback/td-popper/content/content.class.d.ts

@@ -1,9 +1,15 @@
-import { UI } from '../../../../ui/ui.abstract';
-import { ITdPopperContent, ITdPopperContentConfig } from './content.interface';
-export declare class TdPopperContent extends UI implements ITdPopperContent {
+import { Computed, Signal } from '@type-dom/signals';
+import { TypeDivProps, TypeDiv } from '@type-dom/framework';
+import { IStyle } from '@type-dom/css-type';
+import { Instance } from '@type-dom/popper';
+import { ITdPopperContent, PopperContentProps } from './content.interface';
+export declare class TdPopperContent extends TypeDiv implements ITdPopperContent {
     className: 'TdPopperContent';
-    props: ITdPopperContentConfig;
-    private focusTrap;
-    constructor(params?: ITdPopperContentConfig);
+    props: PopperContentProps & TypeDivProps;
+    popperContentRef: Signal<HTMLElement | undefined>;
+    popperInstanceRef?: Computed<Instance | undefined>;
+    updatePopper: (shouldUpdateZIndex?: boolean) => void;
+    contentStyle: IStyle;
+    constructor(params?: PopperContentProps);
     setup(): void;
 }

package/src/components/feedback/td-popper/content/content.class.js

@@ -1,46 +1,176 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TdPopperContent = void 0;
+const tslib_1 = require("tslib");
+const signals_1 = require("@type-dom/signals");
 const utils_1 = require("@type-dom/utils");
-const ui_abstract_1 = require("../../../../ui/ui.abstract");
+const framework_1 = require("@type-dom/framework");
+const td_form_const_1 = require("../../../form/td-form/td-form.const");
 const td_focus_trap_class_1 = require("../../td-focus-trap/td-focus-trap.class");
+const constants_1 = require("../constants");
+const use_content_1 = require("../composable/use-content");
+const use_content_dom_1 = require("../composable/use-content-dom");
+const use_focus_trap_1 = require("../composable/use-focus-trap");
 const content_const_1 = require("./content.const");
-const td_form_const_1 = require("../../../form/td-form/td-form.const");
-const td_popper_const_1 = require("../td-popper.const");
-class TdPopperContent extends ui_abstract_1.UI {
+class TdPopperContent extends framework_1.TypeDiv {
     constructor(params = {}) {
-        super(params);
+        super();
+        console.log('TdPopperContent . ');
         this.className = 'TdPopperContent';
         this.attr.addName('td-popper-content');
-        this.attr.addObj({
-            tabindex: -1
-        });
-        this.style.addObj({
-        // padding: '10px',
-        // backgroundColor: $bgColors.default,
-        // borderRadius: $borderRadius.base,
-        // boxShadow: $boxShadow.base,
-        });
-        this.focusTrap = new td_focus_trap_class_1.TdFocusTrap();
-        this.addChild(this.focusTrap);
-        if (params.contentStyle) { // todo
-            this.style.addObj(params.contentStyle);
-        }
-        this.buildProps(content_const_1.popperContentProps);
+        this.addEmits(content_const_1.popperContentEmits);
         this.props = this.useParams(params);
     }
     setup() {
+        const props = this.props;
+        const emit = this.emit;
+        const { focusStartRef, trapped, onFocusAfterReleased, onFocusAfterTrapped, onFocusInTrap, onFocusoutPrevented, onReleaseRequested, } = (0, use_focus_trap_1.usePopperContentFocusTrap)(props, emit);
+        const { attributes, arrowRef, contentRef, state, styles, instanceRef, role, update, } = (0, use_content_1.usePopperContent)(props);
+        const { ariaModal, arrowStyle, 
+        // contentAttrs,
+        contentClass, contentStyle, updateZIndex, } = (0, use_content_dom_1.usePopperContentDOM)(props, {
+            styles,
+            attributes,
+            role,
+        });
         const formItemContext = this.inject(td_form_const_1.formItemContextKey, undefined);
-        const arrowOffset = 0;
-        this.provide(td_popper_const_1.POPPER_CONTENT_INJECTION_KEY, {
-            // arrowStyle,
-            // arrowRef,
+        const arrowOffset = (0, signals_1.signal)();
+        this.provide(constants_1.POPPER_CONTENT_INJECTION_KEY, {
+            arrowStyle,
+            arrowRef,
             arrowOffset,
         });
         if (formItemContext) {
             // disallow auto-id from inside popper content
             this.provide(td_form_const_1.formItemContextKey, Object.assign(Object.assign({}, formItemContext), { addInputId: utils_1.NOOP, removeInputId: utils_1.NOOP }));
         }
+        let triggerTargetAriaStopWatch = undefined;
+        const updatePopper = (...args_1) => tslib_1.__awaiter(this, [...args_1], void 0, function* (shouldUpdateZIndex = true) {
+            console.warn('updatePopper . ');
+            if (!instanceRef.get()) {
+                return;
+            }
+            const state = yield update();
+            console.warn('state is ', state);
+            if (!state)
+                return;
+            if (contentRef.get()) {
+                this.attr.setObj({
+                    // maybe flip
+                    dataPopperPlacement: state.placement,
+                });
+                const popperStyle = state === null || state === void 0 ? void 0 : state.styles.popper;
+                if (popperStyle) {
+                    (0, utils_1.setStyle)(contentRef.get(), {
+                        position: state.strategy,
+                        left: popperStyle.left + 'px',
+                        top: popperStyle.top + 'px',
+                    });
+                }
+                const arrowDom = arrowRef.get();
+                if (arrowDom && (state === null || state === void 0 ? void 0 : state.middlewareData.arrow)) {
+                    // const arrowStyle = matchPlacement(state.placement?.split('-')?.shift() as keyof typeof $placements || 'top');
+                    // setStyle(arrowDom, {
+                    //   position: state.strategy,
+                    //   ...arrowStyle
+                    // });
+                    const arrowParams = state.middlewareData.arrow;
+                    if (arrowParams === null || arrowParams === void 0 ? void 0 : arrowParams.x) {
+                        (0, utils_1.setStyle)(arrowDom, {
+                            left: arrowParams.x + 'px',
+                        });
+                    }
+                    if (arrowParams === null || arrowParams === void 0 ? void 0 : arrowParams.y) {
+                        (0, utils_1.setStyle)(arrowDom, {
+                            top: arrowParams.y + 'px',
+                        });
+                    }
+                }
+            }
+            shouldUpdateZIndex && updateZIndex();
+        });
+        const togglePopperAlive = () => {
+            console.warn('togglePopperAlive . ');
+            updatePopper(false);
+            if ((0, signals_1.unref)(props.visible) && props.focusOnShow) {
+                trapped.set(true);
+            }
+            else if ((0, signals_1.unref)(props.visible) === false) {
+                trapped.set(false);
+            }
+        };
+        (0, framework_1.onMounted)(() => {
+            (0, signals_1.watch)(() => props.triggerTargetEl, (triggerTargetEl, prevTriggerTargetEl) => {
+                triggerTargetAriaStopWatch === null || triggerTargetAriaStopWatch === void 0 ? void 0 : triggerTargetAriaStopWatch();
+                triggerTargetAriaStopWatch = undefined;
+                const el = (0, signals_1.unref)(triggerTargetEl || (contentRef === null || contentRef === void 0 ? void 0 : contentRef.get()));
+                const prevEl = (0, signals_1.unref)(prevTriggerTargetEl || (contentRef === null || contentRef === void 0 ? void 0 : contentRef.get()));
+                if ((0, utils_1.isElement)(el)) {
+                    triggerTargetAriaStopWatch = (0, signals_1.watch)(() => [
+                        role.get(),
+                        (0, signals_1.unref)(props.ariaLabel),
+                        ariaModal.get(),
+                        (0, signals_1.unref)(props.id),
+                    ], (watches) => {
+                        ['role', 'aria-label', 'aria-modal', 'id'].forEach((key, idx) => {
+                            (0, utils_1.isNil)(watches[idx])
+                                ? el.removeAttribute(key)
+                                : el.setAttribute(key, watches[idx]);
+                        });
+                    }, { immediate: true });
+                }
+                if (prevEl !== el && (0, utils_1.isElement)(prevEl)) {
+                    ['role', 'aria-label', 'aria-modal', 'id'].forEach((key) => {
+                        prevEl.removeAttribute(key);
+                    });
+                }
+            }, { immediate: true });
+            (0, signals_1.watch)(() => (0, signals_1.unref)(props.visible), togglePopperAlive, { immediate: true });
+        });
+        (0, framework_1.onBeforeUnmount)(() => {
+            triggerTargetAriaStopWatch === null || triggerTargetAriaStopWatch === void 0 ? void 0 : triggerTargetAriaStopWatch();
+            triggerTargetAriaStopWatch = undefined;
+        });
+        (0, framework_1.defineExpose)({
+            /**
+             * @description popper content element
+             */
+            popperContentRef: contentRef,
+            /**
+             * @description popperjs instance
+             */
+            popperInstanceRef: instanceRef,
+            /**
+             * @description method for updating popper
+             */
+            updatePopper,
+            /**
+             * @description content style
+             */
+            contentStyle,
+        });
+        this.assignProps({
+            refDom: contentRef,
+        });
+        this.attr.addObj({
+            tabindex: -1,
+            class: contentClass,
+        });
+        this.style.addObj(contentStyle);
+        this.addChild(new td_focus_trap_class_1.TdFocusTrap({
+            trapped: trapped,
+            trapOnFocusIn: true,
+            focusTrapEl: contentRef,
+            focusStartEl: focusStartRef,
+            emits: {
+                focusAfterTrapped: onFocusAfterTrapped,
+                focusAfterReleased: onFocusAfterReleased,
+                focusin: onFocusInTrap,
+                focusoutPrevented: onFocusoutPrevented,
+                releaseRequested: onReleaseRequested,
+            },
+            slot: props.slot,
+        }));
     }
 }
 exports.TdPopperContent = TdPopperContent;

package/src/components/feedback/td-popper/content/content.const.d.ts

@@ -1,3 +1,10 @@
-import { IPopperCoreConfigProps, ITdPopperContentConfig } from './content.interface';
-export declare const popperCoreConfigProps: IPopperCoreConfigProps;
-export declare const popperContentProps: ITdPopperContentConfig;
+import { PopperCoreConfigProps, PopperContentProps } from './content.interface';
+export declare const popperCoreConfigProps: PopperCoreConfigProps;
+export declare const popperContentProps: PopperContentProps;
+export declare const popperContentEmits: {
+    mouseenter: (evt?: MouseEvent) => evt is MouseEvent;
+    mouseleave: (evt?: MouseEvent) => evt is MouseEvent;
+    focus: () => boolean;
+    blur: () => boolean;
+    close: () => boolean;
+};

package/src/components/feedback/td-popper/content/content.const.js

@@ -1,29 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.popperContentProps = exports.popperCoreConfigProps = void 0;
+exports.popperContentEmits = exports.popperContentProps = exports.popperCoreConfigProps = void 0;
 exports.popperCoreConfigProps = {
     boundariesPadding: 0,
-    // fallbackPlacements: undefined,
     gpuAcceleration: true,
-    /**
-     * @description offset of the Tooltip
-     */
     offset: 12,
-    /**
-     * @description position of Tooltip
-     */
     placement: 'bottom',
-    /**
-     * @description [popper.js](https://popper.js.org/docs/v2/) parameters
-     */
-    // popperOptions:  () => ({}),
     strategy: 'absolute',
 };
-exports.popperContentProps = Object.assign(Object.assign({}, exports.popperCoreConfigProps), { 
-    // style: {
-    //   type: definePropType<StyleValue>([String, Array, Object]),
-    // },
-    // className: {
-    //   type: definePropType<ClassType>([String, Array, Object]),
-    // },
-    effect: 'dark', enterable: true, focusOnShow: false, trapping: false, stopPopperMouseEvent: true });
+exports.popperContentProps = {
+    boundariesPadding: 0,
+    gpuAcceleration: true,
+    offset: 12,
+    placement: 'bottom',
+    strategy: 'absolute',
+    // ...popperCoreConfigProps,
+    effect: 'dark',
+    enterable: true,
+    focusOnShow: false,
+    trapping: false,
+    stopPopperMouseEvent: true,
+};
+exports.popperContentEmits = {
+    mouseenter: (evt) => evt instanceof MouseEvent,
+    mouseleave: (evt) => evt instanceof MouseEvent,
+    focus: () => true,
+    blur: () => true,
+    close: () => true,
+};