@type-dom/ui 0.1.3 → 0.2.0

package/src/components/feedback/td-focus-trap/td-focus-trap.class.js

@@ -1,269 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TdFocusTrap = void 0;
-const tslib_1 = require("tslib");
-const utils_1 = require("@type-dom/utils");
-const framework_1 = require("@type-dom/framework");
-const signals_1 = require("@type-dom/signals");
-const use_escape_keydown_1 = require("../../../hooks/use-escape-keydown");
-const aria_1 = require("../../../constants/aria");
-const utils_2 = require("./utils");
-const tokens_1 = require("./tokens");
-class TdFocusTrap extends framework_1.TypeFragment {
-    constructor(params = {}) {
-        super();
-        this.className = 'TdFocusTrap';
-        this.assignProps({ focusStartEl: 'first' });
-        this.props = this.useParams(params);
-    }
-    setup() {
-        var _a;
-        const props = this.props;
-        const emit = this.emit;
-        const forwardRef = (0, signals_1.signal)();
-        let lastFocusBeforeTrapped;
-        let lastFocusAfterTrapped;
-        const { focusReason } = (0, utils_2.useFocusReason)();
-        (0, use_escape_keydown_1.useEscapeKeydown)((event) => {
-            if (props.trapped && !focusLayer.paused) {
-                emit('releaseRequested', event);
-            }
-        });
-        const focusLayer = {
-            paused: false,
-            pause() {
-                this.paused = true;
-            },
-            resume() {
-                this.paused = false;
-            },
-        };
-        const onKeydown = (e) => {
-            if (!props.loop && !props.trapped)
-                return;
-            if (focusLayer.paused)
-                return;
-            const { code, altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
-            const { loop } = props;
-            const isTabbing = code === aria_1.EVENT_CODE.tab && !altKey && !ctrlKey && !metaKey;
-            const currentFocusingEl = document.activeElement;
-            if (isTabbing && currentFocusingEl) {
-                const container = currentTarget;
-                const [first, last] = (0, utils_2.getEdges)(container);
-                const isTabbable = first && last;
-                if (!isTabbable) {
-                    if (currentFocusingEl === container) {
-                        const focusoutPreventedEvent = (0, utils_2.createFocusOutPreventedEvent)({
-                            focusReason: focusReason.get(),
-                        });
-                        emit('focusoutPrevented', focusoutPreventedEvent);
-                        if (!focusoutPreventedEvent.defaultPrevented) {
-                            e.preventDefault();
-                        }
-                    }
-                }
-                else {
-                    if (!shiftKey && currentFocusingEl === last) {
-                        const focusoutPreventedEvent = (0, utils_2.createFocusOutPreventedEvent)({
-                            focusReason: focusReason.get(),
-                        });
-                        emit('focusoutPrevented', focusoutPreventedEvent);
-                        if (!focusoutPreventedEvent.defaultPrevented) {
-                            e.preventDefault();
-                            if (loop)
-                                (0, utils_2.tryFocus)(first, true);
-                        }
-                    }
-                    else if (shiftKey &&
-                        [first, container].includes(currentFocusingEl)) {
-                        const focusoutPreventedEvent = (0, utils_2.createFocusOutPreventedEvent)({
-                            focusReason: focusReason.get(),
-                        });
-                        emit('focusoutPrevented', focusoutPreventedEvent);
-                        if (!focusoutPreventedEvent.defaultPrevented) {
-                            e.preventDefault();
-                            if (loop)
-                                (0, utils_2.tryFocus)(last, true);
-                        }
-                    }
-                }
-            }
-        };
-        (0, framework_1.provide)(tokens_1.FOCUS_TRAP_INJECTION_KEY, {
-            focusTrapRef: forwardRef,
-            onKeydown,
-        });
-        const trapOnFocus = (e) => {
-            emit(tokens_1.ON_TRAP_FOCUS_EVT, e);
-        };
-        const releaseOnFocus = (e) => emit(tokens_1.ON_RELEASE_FOCUS_EVT, e);
-        const onFocusIn = (e) => {
-            const trapContainer = (0, signals_1.unref)(forwardRef);
-            if (!trapContainer)
-                return;
-            const target = e.target;
-            const relatedTarget = e.relatedTarget;
-            const isFocusedInTrap = target && trapContainer.contains(target);
-            if (!props.trapped) {
-                const isPrevFocusedInTrap = relatedTarget && trapContainer.contains(relatedTarget);
-                if (!isPrevFocusedInTrap) {
-                    lastFocusBeforeTrapped = relatedTarget;
-                }
-            }
-            if (isFocusedInTrap)
-                emit('focusin', e);
-            if (focusLayer.paused)
-                return;
-            if (props.trapped) {
-                if (isFocusedInTrap) {
-                    lastFocusAfterTrapped = target;
-                }
-                else {
-                    (0, utils_2.tryFocus)(lastFocusAfterTrapped, true);
-                }
-            }
-        };
-        const onFocusOut = (e) => {
-            const trapContainer = (0, signals_1.unref)(forwardRef);
-            if (focusLayer.paused || !trapContainer)
-                return;
-            if (props.trapped) {
-                const relatedTarget = e
-                    .relatedTarget;
-                if (!(0, utils_1.isNil)(relatedTarget) && !trapContainer.contains(relatedTarget)) {
-                    // Give embedded focus layer time to pause this layer before reclaiming focus
-                    // And only reclaim focus if it should currently be trapping
-                    setTimeout(() => {
-                        if (!focusLayer.paused && props.trapped) {
-                            const focusoutPreventedEvent = (0, utils_2.createFocusOutPreventedEvent)({
-                                focusReason: focusReason.get(),
-                            });
-                            emit('focusoutPrevented', focusoutPreventedEvent);
-                            if (!focusoutPreventedEvent.defaultPrevented) {
-                                (0, utils_2.tryFocus)(lastFocusAfterTrapped, true);
-                            }
-                        }
-                    }, 0);
-                }
-            }
-            else {
-                const target = e.target;
-                const isFocusedInTrap = target && trapContainer.contains(target);
-                if (!isFocusedInTrap)
-                    emit('focusout', e);
-            }
-        };
-        function startTrap() {
-            return tslib_1.__awaiter(this, void 0, void 0, function* () {
-                // Wait for forwardRef to resolve
-                yield (0, framework_1.nextTick)();
-                const trapContainer = (0, signals_1.unref)(forwardRef);
-                if (trapContainer) {
-                    utils_2.focusableStack.push(focusLayer);
-                    const prevFocusedElement = trapContainer.contains(document.activeElement)
-                        ? lastFocusBeforeTrapped
-                        : document.activeElement;
-                    lastFocusBeforeTrapped = prevFocusedElement;
-                    const isPrevFocusContained = trapContainer.contains(prevFocusedElement);
-                    if (!isPrevFocusContained) {
-                        const focusEvent = new Event(tokens_1.FOCUS_AFTER_TRAPPED, tokens_1.FOCUS_AFTER_TRAPPED_OPTS);
-                        trapContainer.addEventListener(tokens_1.FOCUS_AFTER_TRAPPED, trapOnFocus);
-                        trapContainer.dispatchEvent(focusEvent);
-                        if (!focusEvent.defaultPrevented) {
-                            (0, framework_1.nextTick)(() => {
-                                let focusStartEl = props.focusStartEl;
-                                if (!(0, utils_1.isString)(focusStartEl)) {
-                                    (0, utils_2.tryFocus)((0, signals_1.toRaw)(focusStartEl));
-                                    if (document.activeElement !== focusStartEl) {
-                                        focusStartEl = 'first';
-                                    }
-                                }
-                                if (focusStartEl === 'first') {
-                                    (0, utils_2.focusFirstDescendant)((0, utils_2.obtainAllFocusableElements)(trapContainer), true);
-                                }
-                                if (document.activeElement === prevFocusedElement ||
-                                    focusStartEl === 'container') {
-                                    (0, utils_2.tryFocus)(trapContainer);
-                                }
-                            });
-                        }
-                    }
-                }
-            });
-        }
-        function stopTrap() {
-            const trapContainer = (0, signals_1.unref)(forwardRef);
-            if (trapContainer) {
-                trapContainer.removeEventListener(tokens_1.FOCUS_AFTER_TRAPPED, trapOnFocus);
-                const releasedEvent = new CustomEvent(tokens_1.FOCUS_AFTER_RELEASED, Object.assign(Object.assign({}, tokens_1.FOCUS_AFTER_TRAPPED_OPTS), { detail: {
-                        focusReason: focusReason.get(),
-                    } }));
-                trapContainer.addEventListener(tokens_1.FOCUS_AFTER_RELEASED, releaseOnFocus);
-                trapContainer.dispatchEvent(releasedEvent);
-                if (!releasedEvent.defaultPrevented &&
-                    (focusReason.get() == 'keyboard' ||
-                        !(0, utils_2.isFocusCausedByUserEvent)() ||
-                        trapContainer.contains(document.activeElement))) {
-                    (0, utils_2.tryFocus)(lastFocusBeforeTrapped !== null && lastFocusBeforeTrapped !== void 0 ? lastFocusBeforeTrapped : document.body);
-                }
-                trapContainer.removeEventListener(tokens_1.FOCUS_AFTER_RELEASED, releaseOnFocus);
-                utils_2.focusableStack.remove(focusLayer);
-            }
-        }
-        (0, signals_1.watch)(() => (0, signals_1.unref)(props.focusTrapEl), (focusTrapEl) => {
-            if (focusTrapEl) {
-                forwardRef.set(focusTrapEl);
-            }
-        }, { immediate: true });
-        (0, signals_1.watch)(() => forwardRef.get(), (forwardRef, oldForwardRef) => {
-            if (forwardRef) {
-                forwardRef.addEventListener('keydown', onKeydown);
-                forwardRef.addEventListener('focusin', onFocusIn);
-                forwardRef.addEventListener('focusout', onFocusOut);
-            }
-            if (oldForwardRef) {
-                oldForwardRef.removeEventListener('keydown', onKeydown);
-                oldForwardRef.removeEventListener('focusin', onFocusIn);
-                oldForwardRef.removeEventListener('focusout', onFocusOut);
-            }
-        });
-        (0, framework_1.onMounted)(() => {
-            if (props.trapped) {
-                startTrap();
-            }
-            (0, signals_1.watch)(() => (0, signals_1.unref)(props.trapped), (trapped) => {
-                if (trapped) {
-                    startTrap();
-                }
-                else {
-                    stopTrap();
-                }
-            });
-        });
-        (0, framework_1.onBeforeUnmount)(() => {
-            var _a, _b, _c;
-            if (props.trapped) {
-                stopTrap();
-            }
-            if (forwardRef.get()) {
-                (_a = forwardRef.get()) === null || _a === void 0 ? void 0 : _a.removeEventListener('keydown', onKeydown);
-                (_b = forwardRef.get()) === null || _b === void 0 ? void 0 : _b.removeEventListener('focusin', onFocusIn);
-                (_c = forwardRef.get()) === null || _c === void 0 ? void 0 : _c.removeEventListener('focusout', onFocusOut);
-                forwardRef.set(undefined);
-            }
-        });
-        // return {
-        //   onKeydown,
-        // }
-        this.addEmits({
-            // todo
-            handleKeydown: onKeydown,
-        });
-        this.slotChildren((0, utils_1.isFunction)(props.slot) ?
-            (_a = props.slot) === null || _a === void 0 ? void 0 : _a.call(props, {
-                handleKeydown: onKeydown,
-            })
-            : props.slot);
-    }
-}
-exports.TdFocusTrap = TdFocusTrap;

package/src/components/feedback/td-focus-trap/td-focus-trap.interface.d.ts

@@ -1,21 +0,0 @@
-import { ITypeFragment, TypeFragmentProps } from '@type-dom/framework';
-import { ON_RELEASE_FOCUS_EVT, ON_TRAP_FOCUS_EVT } from './tokens';
-import { MaybeRef } from '@type-dom/signals';
-export interface ITdFocusTrap extends ITypeFragment {
-    className: 'TdFocusTrap';
-}
-export interface FocusTrapProps extends TypeFragmentProps {
-    loop?: boolean;
-    trapped?: MaybeRef<boolean>;
-    trapOnFocusIn?: boolean;
-    focusTrapEl?: MaybeRef<HTMLElement | undefined>;
-    focusStartEl?: MaybeRef<'container' | 'first' | HTMLElement | undefined>;
-    emits?: {
-        [ON_TRAP_FOCUS_EVT]?: () => void;
-        [ON_RELEASE_FOCUS_EVT]?: () => void;
-        focusin?: () => void;
-        focusout?: () => void;
-        focusoutPrevented?: () => void;
-        releaseRequested?: () => void;
-    };
-}

package/src/components/feedback/td-focus-trap/td-focus-trap.interface.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tokens_1 = require("./tokens");

package/src/components/feedback/td-focus-trap/tokens.d.ts

@@ -1,14 +0,0 @@
-import { Ref } from '@type-dom/signals';
-import { InjectionKey } from '@type-dom/framework';
-export declare const FOCUS_AFTER_TRAPPED = "focus-trap.focus-after-trapped";
-export declare const FOCUS_AFTER_RELEASED = "focus-trap.focus-after-released";
-export declare const FOCUSOUT_PREVENTED = "focus-trap.focusout-prevented";
-export declare const FOCUS_AFTER_TRAPPED_OPTS: EventInit;
-export declare const FOCUSOUT_PREVENTED_OPTS: EventInit;
-export declare const ON_TRAP_FOCUS_EVT = "focusAfterTrapped";
-export declare const ON_RELEASE_FOCUS_EVT = "focusAfterReleased";
-export type FocusTrapInjectionContext = {
-    focusTrapRef: Ref<HTMLElement | undefined>;
-    onKeydown: (e: KeyboardEvent) => void;
-};
-export declare const FOCUS_TRAP_INJECTION_KEY: InjectionKey<FocusTrapInjectionContext>;

package/src/components/feedback/td-focus-trap/tokens.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FOCUS_TRAP_INJECTION_KEY = exports.ON_RELEASE_FOCUS_EVT = exports.ON_TRAP_FOCUS_EVT = exports.FOCUSOUT_PREVENTED_OPTS = exports.FOCUS_AFTER_TRAPPED_OPTS = exports.FOCUSOUT_PREVENTED = exports.FOCUS_AFTER_RELEASED = exports.FOCUS_AFTER_TRAPPED = void 0;
-exports.FOCUS_AFTER_TRAPPED = 'focus-trap.focus-after-trapped';
-exports.FOCUS_AFTER_RELEASED = 'focus-trap.focus-after-released';
-exports.FOCUSOUT_PREVENTED = 'focus-trap.focusout-prevented';
-exports.FOCUS_AFTER_TRAPPED_OPTS = {
-    cancelable: true,
-    bubbles: false,
-};
-exports.FOCUSOUT_PREVENTED_OPTS = {
-    cancelable: true,
-    bubbles: false,
-};
-exports.ON_TRAP_FOCUS_EVT = 'focusAfterTrapped';
-exports.ON_RELEASE_FOCUS_EVT = 'focusAfterReleased';
-exports.FOCUS_TRAP_INJECTION_KEY = Symbol('elFocusTrap');

package/src/components/feedback/td-focus-trap/utils.d.ts

@@ -1,29 +0,0 @@
-declare const focusReason: import("@type-dom/signals").Signal<"pointer" | "keyboard">;
-declare const lastUserFocusTimestamp: import("@type-dom/signals").Signal<number>;
-declare const lastAutomatedFocusTimestamp: import("@type-dom/signals").Signal<number>;
-export type FocusLayer = {
-    paused: boolean;
-    pause: () => void;
-    resume: () => void;
-};
-export type FocusStack = FocusLayer[];
-export declare const obtainAllFocusableElements: (element: HTMLElement) => HTMLElement[];
-export declare const getVisibleElement: (elements: HTMLElement[], container: HTMLElement) => HTMLElement | undefined;
-export declare const isHidden: (element: HTMLElement, container: HTMLElement) => boolean;
-export declare const getEdges: (container: HTMLElement) => (HTMLElement | undefined)[];
-export declare const tryFocus: (element?: HTMLElement | {
-    focus: () => void;
-} | null, shouldSelect?: boolean) => void;
-export declare const focusFirstDescendant: (elements: HTMLElement[], shouldSelect?: boolean) => void;
-export declare const focusableStack: {
-    push: (layer: FocusLayer) => void;
-    remove: (layer: FocusLayer) => void;
-};
-export declare const isFocusCausedByUserEvent: () => boolean;
-export declare const useFocusReason: () => {
-    focusReason: typeof focusReason;
-    lastUserFocusTimestamp: typeof lastUserFocusTimestamp;
-    lastAutomatedFocusTimestamp: typeof lastAutomatedFocusTimestamp;
-};
-export declare const createFocusOutPreventedEvent: (detail: CustomEventInit["detail"]) => CustomEvent<any>;
-export {};

package/src/components/feedback/td-focus-trap/utils.js

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFocusOutPreventedEvent = exports.useFocusReason = exports.isFocusCausedByUserEvent = exports.focusableStack = exports.focusFirstDescendant = exports.tryFocus = exports.getEdges = exports.isHidden = exports.getVisibleElement = exports.obtainAllFocusableElements = void 0;
-// import { onBeforeUnmount, onMounted, ref } from 'vue'
-const tokens_1 = require("./tokens");
-const signals_1 = require("@type-dom/signals");
-const framework_1 = require("@type-dom/framework");
-const focusReason = (0, signals_1.signal)();
-const lastUserFocusTimestamp = (0, signals_1.signal)(0);
-const lastAutomatedFocusTimestamp = (0, signals_1.signal)(0);
-let focusReasonUserCount = 0;
-const obtainAllFocusableElements = (element) => {
-    const nodes = [];
-    const walker = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT, {
-        acceptNode: (node) => {
-            const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';
-            if (node.disabled || node.hidden || isHiddenInput)
-                return NodeFilter.FILTER_SKIP;
-            return node.tabIndex >= 0 || node === document.activeElement
-                ? NodeFilter.FILTER_ACCEPT
-                : NodeFilter.FILTER_SKIP;
-        },
-    });
-    while (walker.nextNode())
-        nodes.push(walker.currentNode);
-    return nodes;
-};
-exports.obtainAllFocusableElements = obtainAllFocusableElements;
-const getVisibleElement = (elements, container) => {
-    for (const element of elements) {
-        if (!(0, exports.isHidden)(element, container))
-            return element;
-    }
-    return;
-};
-exports.getVisibleElement = getVisibleElement;
-const isHidden = (element, container) => {
-    if (process.env.NODE_ENV === 'test')
-        return false;
-    if (getComputedStyle(element).visibility === 'hidden')
-        return true;
-    while (element) {
-        if (container && element === container)
-            return false;
-        if (getComputedStyle(element).display === 'none')
-            return true;
-        element = element.parentElement;
-    }
-    return false;
-};
-exports.isHidden = isHidden;
-const getEdges = (container) => {
-    const focusable = (0, exports.obtainAllFocusableElements)(container);
-    const first = (0, exports.getVisibleElement)(focusable, container);
-    const last = (0, exports.getVisibleElement)(focusable.reverse(), container);
-    return [first, last];
-};
-exports.getEdges = getEdges;
-const isSelectable = (element) => {
-    return element instanceof HTMLInputElement && 'select' in element;
-};
-const tryFocus = (element, shouldSelect) => {
-    if (element && element.focus) {
-        const prevFocusedElement = document.activeElement;
-        element.focus({ preventScroll: true });
-        lastAutomatedFocusTimestamp.set(window.performance.now());
-        if (element !== prevFocusedElement &&
-            isSelectable(element) &&
-            shouldSelect) {
-            element.select();
-        }
-    }
-};
-exports.tryFocus = tryFocus;
-function removeFromStack(list, item) {
-    const copy = [...list];
-    const idx = list.indexOf(item);
-    if (idx !== -1) {
-        copy.splice(idx, 1);
-    }
-    return copy;
-}
-const createFocusableStack = () => {
-    let stack = [];
-    const push = (layer) => {
-        const currentLayer = stack[0];
-        if (currentLayer && layer !== currentLayer) {
-            currentLayer.pause();
-        }
-        stack = removeFromStack(stack, layer);
-        stack.unshift(layer);
-    };
-    const remove = (layer) => {
-        var _a, _b;
-        stack = removeFromStack(stack, layer);
-        (_b = (_a = stack[0]) === null || _a === void 0 ? void 0 : _a.resume) === null || _b === void 0 ? void 0 : _b.call(_a);
-    };
-    return {
-        push,
-        remove,
-    };
-};
-const focusFirstDescendant = (elements, shouldSelect = false) => {
-    const prevFocusedElement = document.activeElement;
-    for (const element of elements) {
-        (0, exports.tryFocus)(element, shouldSelect);
-        if (document.activeElement !== prevFocusedElement)
-            return;
-    }
-};
-exports.focusFirstDescendant = focusFirstDescendant;
-exports.focusableStack = createFocusableStack();
-const isFocusCausedByUserEvent = () => {
-    return lastUserFocusTimestamp.get() > lastAutomatedFocusTimestamp.get();
-};
-exports.isFocusCausedByUserEvent = isFocusCausedByUserEvent;
-const notifyFocusReasonPointer = () => {
-    focusReason.set('pointer');
-    lastUserFocusTimestamp.set(window.performance.now());
-};
-const notifyFocusReasonKeydown = () => {
-    focusReason.set('keyboard');
-    lastUserFocusTimestamp.set(window.performance.now());
-};
-const useFocusReason = () => {
-    (0, framework_1.onMounted)(() => {
-        if (focusReasonUserCount === 0) {
-            document.addEventListener('mousedown', notifyFocusReasonPointer);
-            document.addEventListener('touchstart', notifyFocusReasonPointer);
-            document.addEventListener('keydown', notifyFocusReasonKeydown);
-        }
-        focusReasonUserCount++;
-    });
-    (0, framework_1.onBeforeUnmount)(() => {
-        focusReasonUserCount--;
-        if (focusReasonUserCount <= 0) {
-            document.removeEventListener('mousedown', notifyFocusReasonPointer);
-            document.removeEventListener('touchstart', notifyFocusReasonPointer);
-            document.removeEventListener('keydown', notifyFocusReasonKeydown);
-        }
-    });
-    return {
-        focusReason,
-        lastUserFocusTimestamp,
-        lastAutomatedFocusTimestamp,
-    };
-};
-exports.useFocusReason = useFocusReason;
-const createFocusOutPreventedEvent = (detail) => {
-    return new CustomEvent(tokens_1.FOCUSOUT_PREVENTED, Object.assign(Object.assign({}, tokens_1.FOCUSOUT_PREVENTED_OPTS), { detail }));
-};
-exports.createFocusOutPreventedEvent = createFocusOutPreventedEvent;

package/src/components/feedback/td-loading/index.d.ts

@@ -1,7 +0,0 @@
-import { Loading } from './service';
-export declare const TdLoading: {
-    service: (options?: import("./types").LoadingOptions) => TdLoading;
-};
-export default TdLoading;
-export { Loading as TdLoadingService, };
-export * from './types';

package/src/components/feedback/td-loading/index.js

@@ -1,21 +0,0 @@
-"use strict";
-// import { Loading } from './src/service'
-// import { vLoading } from './src/directive'
-//
-// import type { App } from 'vue'
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TdLoadingService = exports.TdLoading = void 0;
-const tslib_1 = require("tslib");
-// installer and everything in all
-const service_1 = require("./service");
-Object.defineProperty(exports, "TdLoadingService", { enumerable: true, get: function () { return service_1.Loading; } });
-exports.TdLoading = {
-    // install(app: App) {
-    //   app.directive('loading', vLoading)
-    //   app.config.globalProperties.$loading = Loading
-    // },
-    // directive: vLoading,
-    service: service_1.Loading,
-};
-exports.default = exports.TdLoading;
-tslib_1.__exportStar(require("./types"), exports);

package/src/components/feedback/td-loading/loading.d.ts

@@ -1,26 +0,0 @@
-import { LoadingOptionsResolved } from './types';
-export declare function createLoadingComponent(options: LoadingOptionsResolved): {
-    data: {
-        originalPosition: string;
-        originalOverflow: string;
-        visible: boolean;
-        parent: import("./types").LoadingParentElement;
-        background: import("@type-dom/signals").MaybeRef<string>;
-        svg: import("@type-dom/signals").MaybeRef<string>;
-        svgViewBox: import("@type-dom/signals").MaybeRef<string>;
-        spinner: import("@type-dom/signals").MaybeRef<boolean | string>;
-        text: import("@type-dom/signals").MaybeRef<string>;
-        fullscreen: boolean;
-        lock: boolean;
-        customClass: import("@type-dom/signals").MaybeRef<string>;
-        target: HTMLElement;
-        beforeClose?: () => boolean;
-        closed?: () => void;
-    };
-    setText: (text: string) => void;
-    removeElLoadingChild: () => void;
-    close: () => void;
-    handleAfterLeave: () => void;
-    vm: import("@type-dom/framework").TypeElement;
-    readonly $el: HTMLElement;
-};