@lion/ui 0.0.1

package/dist-types/components/overlays/src/OverlayController.d.ts

@@ -0,0 +1,483 @@
+/**
+ * @desc OverlayController is the fundament for every single type of overlay. With the right
+ * configuration, it can be used to build (modal) dialogs, tooltips, dropdowns, popovers,
+ * bottom/top/left/right sheets etc.
+ *
+ * ### About contentNode, contentWrapperNode and renderTarget.
+ *
+ * #### contentNode
+ * Node containing actual overlay contents.
+ * It will not be touched by the OverlayController, it will only set attributes needed
+ * for accessibility.
+ *
+ * #### contentWrapperNode
+ * The 'positioning' element.
+ * For local overlays, this node will be provided to Popper and all
+ * inline positioning styles will be added here. It will also act as the container of an arrow
+ * element (the arrow needs to be a sibling of contentNode for Popper to work correctly).
+ * When projecting a contentNode from a shadowRoot, it is essential to have the wrapper in
+ * shadow dom, so that contentNode can be styled via `::slotted` from the shadow root.
+ * The Popper arrow can then be styled from that same shadow root as well.
+ * For global overlays, the contentWrapperNode will be appended to the globalRootNode structure.
+ *
+ * #### renderTarget
+ * Usually the parent node of contentWrapperNode that either exists locally or globally.
+ * When a responsive scenario is created (in which we switch from global to local or vice versa)
+ * we need to know where we should reappend contentWrapperNode (or contentNode in case it's projected)
+ *
+ * So a regular flow can be summarized as follows:
+ * 1. Application Developer spawns an OverlayController with a contentNode reference
+ * 2. OverlayController will create a contentWrapperNode around contentNode (or consumes when provided)
+ * 3. contentWrapperNode will be appended to the right renderTarget
+ *
+ * There are subtle differences depending on the following factors:
+ * - whether in global/local placement mode
+ * - whether contentNode projected
+ * - whether an arrow is provided
+ *
+ * This leads to the following possible combinations:
+ * - [l1]. local + no content projection + no arrow
+ * - [l2]. local +    content projection + no arrow
+ * - [l3]. local + no content projection +    arrow
+ * - [l4]. local +    content projection +    arrow
+ * - [g1]. global
+ *
+ * #### html structure for a content projected node
+ * <div id="contentWrapperNode">
+ *  <slot name="contentNode"></slot>
+ *  <div x-arrow></div>
+ * </div>
+ *
+ * Structure above depicts [l4]
+ * So in case of [l1] and [l3], the <slot> element would be a regular element
+ * In case of [l1] and [l2], there would be no arrow.
+ * Note that a contentWrapperNode should be provided for [l2], [l3] and [l4]
+ * In case of a global overlay ([g1]), it's enough to provide just the contentNode.
+ * In case of a local overlay or a responsive overlay switching from placementMode, one should
+ * always configure as if it were a local overlay.
+ */
+export class OverlayController extends EventTargetShim {
+    /**
+     * @constructor
+     * @param {OverlayConfig} config initial config. Will be remembered as shared config
+     * when `.updateConfig()` is called.
+     */
+    constructor(config?: OverlayConfig, manager?: any);
+    manager: any;
+    /** @private */
+    private __sharedConfig;
+    /**
+     * @type {OverlayConfig}
+     * @protected
+     */
+    protected _defaultConfig: OverlayConfig;
+    /** @protected */
+    protected _contentId: string;
+    /** @private */
+    private __originalAttrs;
+    __isContentNodeProjected: boolean | undefined;
+    /** @private */
+    private __hasActiveTrapsKeyboardFocus;
+    /** @private */
+    private __hasActiveBackdrop;
+    /**
+     * @type {HTMLElement | undefined}
+     * @private
+     */
+    private __backdropNodeToBeTornDown;
+    /** @private */
+    private __escKeyHandler;
+    /**
+     * The invokerNode
+     * @type {HTMLElement | undefined}
+     */
+    get invoker(): HTMLElement | undefined;
+    /**
+     * The contentWrapperNode
+     * @type {HTMLElement}
+     */
+    get content(): HTMLElement;
+    /**
+     * Determines the connection point in DOM (body vs next to invoker).
+     * @type {'global' | 'local' | undefined}
+     */
+    get placementMode(): "global" | "local" | undefined;
+    /**
+     * The interactive element (usually a button) invoking the dialog or tooltip
+     * @type {HTMLElement | undefined}
+     */
+    get invokerNode(): HTMLElement | undefined;
+    /**
+     * The element that is used to position the overlay content relative to. Usually,
+     * this is the same element as invokerNode. Should only be provided when invokerNode should not
+     * be positioned against.
+     * @type {HTMLElement}
+     */
+    get referenceNode(): HTMLElement;
+    /**
+     * The most important element: the overlay itself
+     * @type {HTMLElement}
+     */
+    get contentNode(): HTMLElement;
+    /**
+     * The wrapper element of contentNode, used to supply inline positioning styles. When a Popper
+     * arrow is needed, it acts as parent of the arrow node. Will be automatically created for global
+     * and non projected contentNodes. Required when used in shadow dom mode or when Popper arrow is
+     * supplied. Essential for allowing webcomponents to style their projected contentNodes
+     * @type {HTMLElement}
+     */
+    get contentWrapperNode(): HTMLElement;
+    /**
+     * The element that is placed behind the contentNode. When not provided and `hasBackdrop` is true,
+     * a backdropNode will be automatically created
+     * @type {HTMLElement}
+     */
+    get backdropNode(): HTMLElement;
+    /**
+     * The element that should be called `.focus()` on after dialog closes
+     * @type {HTMLElement}
+     */
+    get elementToFocusAfterHide(): HTMLElement;
+    /**
+     * Whether it should have a backdrop (currently exclusive to globalOverlayController)
+     * @type {boolean}
+     */
+    get hasBackdrop(): boolean;
+    /**
+     * Hides other overlays when mutiple are opened (currently exclusive to globalOverlayController)
+     * @type {boolean}
+     */
+    get isBlocking(): boolean;
+    /**
+     * Hides other overlays when mutiple are opened (currently exclusive to globalOverlayController)
+     * @type {boolean}
+     */
+    get preventsScroll(): boolean;
+    /**
+     * Rotates tab, implicitly set when 'isModal'
+     * @type {boolean}
+     */
+    get trapsKeyboardFocus(): boolean;
+    /**
+     * Hides the overlay when pressing [ esc ]
+     * @type {boolean}
+     */
+    get hidesOnEsc(): boolean;
+    /**
+     * Hides the overlay when clicking next to it, exluding invoker
+     * @type {boolean}
+     */
+    get hidesOnOutsideClick(): boolean;
+    /**
+     * Hides the overlay when pressing esc, even when contentNode has no focus
+     * @type {boolean}
+     */
+    get hidesOnOutsideEsc(): boolean;
+    /**
+     * Will align contentNode with referenceNode (invokerNode by default) for local overlays.
+     * Usually needed for dropdowns. 'max' will prevent contentNode from exceeding width of
+     * referenceNode, 'min' guarantees that contentNode will be at least as wide as referenceNode.
+     * 'full' will make sure that the invoker width always is the same.
+     * @type {'max' | 'full' | 'min' | 'none' | undefined }
+     */
+    get inheritsReferenceWidth(): "none" | "max" | "full" | "min" | undefined;
+    /**
+     * For non `isTooltip`:
+     *  - sets aria-expanded="true/false" and aria-haspopup="true" on invokerNode
+     *  - sets aria-controls on invokerNode
+     *  - returns focus to invokerNode on hide
+     *  - sets focus to overlay content(?)
+     *
+     * For `isTooltip`:
+     *  - sets role="tooltip" and aria-labelledby/aria-describedby on the content
+     *
+     * @type {boolean}
+     */
+    get handlesAccessibility(): boolean;
+    /**
+     * Has a totally different interaction- and accessibility pattern from all other overlays.
+     * Will behave as role="tooltip" element instead of a role="dialog" element
+     * @type {boolean}
+     */
+    get isTooltip(): boolean;
+    /**
+     * By default, the tooltip content is a 'description' for the invoker (uses aria-describedby).
+     * Setting this property to 'label' makes the content function as a label (via aria-labelledby)
+     * @type {'label' | 'description'| undefined}
+     */
+    get invokerRelation(): "label" | "description" | undefined;
+    /**
+     * Popper configuration. Will be used when placementMode is 'local'
+     * @type {PopperOptions}
+     */
+    get popperConfig(): import("@popperjs/core/lib/types.js").Options;
+    /**
+     * Viewport configuration. Will be used when placementMode is 'global'
+     * @type {ViewportConfig}
+     */
+    get viewportConfig(): import("../types/OverlayConfig.js").ViewportConfig;
+    /**
+     * Usually the parent node of contentWrapperNode that either exists locally or globally.
+     * When a responsive scenario is created (in which we switch from global to local or vice versa)
+     * we need to know where we should reappend contentWrapperNode (or contentNode in case it's
+     * projected).
+     * @type {HTMLElement}
+     * @protected
+     */
+    protected get _renderTarget(): HTMLElement;
+    /**
+     * @desc The element our local overlay will be positioned relative to.
+     * @type {HTMLElement | undefined}
+     * @protected
+     */
+    protected get _referenceNode(): HTMLElement | undefined;
+    /**
+     * @param {number} value
+     */
+    set elevation(arg: number);
+    /**
+     * @type {number}
+     */
+    get elevation(): number;
+    /**
+     * Allows to dynamically change the overlay configuration. Needed in case the
+     * presentation of the overlay changes depending on screen size.
+     * Note that this method is the only allowed way to update a configuration of an
+     * OverlayController instance.
+     * @param { OverlayConfig } cfgToAdd
+     */
+    updateConfig(cfgToAdd: OverlayConfig): void;
+    /**
+     * @type {OverlayConfig}
+     * @private
+     */
+    private __prevConfig;
+    /** @type {OverlayConfig} */
+    config: import("../types/OverlayConfig.js").OverlayConfig | undefined;
+    /** @private */
+    private __elementToFocusAfterHide;
+    /**
+     * @param {OverlayConfig} newConfig
+     * @private
+     */
+    private __validateConfiguration;
+    /**
+     * @param {{ cfgToAdd: OverlayConfig }} options
+     * @protected
+     */
+    protected _init({ cfgToAdd }: {
+        cfgToAdd: OverlayConfig;
+    }): void;
+    /** @private */
+    private __initConnectionTarget;
+    /**
+     * Cleanup ._contentWrapperNode. We do this, because creating a fresh wrapper
+     * can lead to problems with event listeners...
+     * @param {{ cfgToAdd: OverlayConfig }} options
+     * @private
+     */
+    private __initContentWrapperNode;
+    /** config [l2],[l3],[l4] */
+    __contentWrapperNode: HTMLElement | HTMLDivElement | undefined;
+    /** config [l2], [l4] */
+    __originalContentParent: HTMLElement | undefined;
+    /**
+     * Display local overlays on top of elements with no z-index that appear later in the DOM
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleZIndex({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @private
+     */
+    private __setupTeardownAccessibility;
+    /**
+     * @param {HTMLElement} node
+     * @param {string[]} attrs
+     * @private
+     */
+    private __storeOriginalAttrs;
+    /** @private */
+    private __restoreOriginalAttrs;
+    get isShown(): boolean;
+    /**
+     * @event before-show right before the overlay shows. Used for animations and switching overlays
+     * @event show right after the overlay is shown
+     * @param {HTMLElement} elementToFocusAfterHide
+     */
+    show(elementToFocusAfterHide?: HTMLElement): Promise<void>;
+    _showComplete: Promise<any> | undefined;
+    _showResolve: ((value: any) => void) | undefined;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handlePosition({ phase }: {
+        phase: OverlayPhase;
+    }): Promise<void>;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _keepBodySize({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    __bodyClientWidth: number | undefined;
+    __bodyClientHeight: number | undefined;
+    __bodyMarginRightInline: string | undefined;
+    __bodyMarginBottomInline: string | undefined;
+    __bodyMarginRight: number | undefined;
+    __bodyMarginBottom: number | undefined;
+    /**
+     * @event before-hide right before the overlay hides. Used for animations and switching overlays
+     * @event hide right after the overlay is hidden
+     */
+    hide(): Promise<void>;
+    _hideComplete: Promise<any> | undefined;
+    _hideResolve: ((value: any) => void) | undefined;
+    /**
+     * Method to be overriden by subclassers
+     *
+     * @param {{backdropNode:HTMLElement, contentNode:HTMLElement}} hideConfig
+     */
+    transitionHide(hideConfig: {
+        backdropNode: HTMLElement;
+        contentNode: HTMLElement;
+    }): Promise<void>;
+    /**
+     * @param {{backdropNode:HTMLElement, contentNode:HTMLElement}} hideConfig
+     * @protected
+     */
+    protected _transitionHide(hideConfig: {
+        backdropNode: HTMLElement;
+        contentNode: HTMLElement;
+    }): Promise<void>;
+    __backdropAnimation: Promise<any> | undefined;
+    /**
+     * To be overridden by subclassers
+     *
+     * @param {{backdropNode:HTMLElement, contentNode:HTMLElement}} showConfig
+     */
+    transitionShow(showConfig: {
+        backdropNode: HTMLElement;
+        contentNode: HTMLElement;
+    }): Promise<void>;
+    /**
+     * @param {{backdropNode:HTMLElement, contentNode:HTMLElement}} showConfig
+     */
+    _transitionShow(showConfig: {
+        backdropNode: HTMLElement;
+        contentNode: HTMLElement;
+    }): Promise<void>;
+    /** @protected */
+    protected _restoreFocus(): void;
+    toggle(): Promise<void>;
+    /**
+     * All features are handled here.
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleFeatures({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handlePreventsScroll({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleBlocking({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    get hasActiveBackdrop(): boolean;
+    /**
+     * Sets up backdrop on the given overlay. If there was a backdrop on another element
+     * it is removed. Otherwise this is the first time displaying a backdrop, so a animation-in
+     * animation is played.
+     * @param {{ animation?: boolean, phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleBackdrop({ phase }: {
+        animation?: boolean | undefined;
+        phase: OverlayPhase;
+    }): void;
+    __backdropNode: HTMLDivElement | undefined;
+    get hasActiveTrapsKeyboardFocus(): boolean;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleTrapsKeyboardFocus({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    enableTrapsKeyboardFocus(): void;
+    _containFocusHandler: {
+        disconnect: () => void;
+    } | undefined;
+    disableTrapsKeyboardFocus({ findNewTrap }?: {
+        findNewTrap?: boolean | undefined;
+    }): void;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleHidesOnEsc({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleHidesOnOutsideEsc({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    /** @protected */
+    protected _handleInheritsReferenceWidth(): void;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleHidesOnOutsideClick({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    /** @type {EventListenerOrEventListenerObject} */
+    __onInsideMouseDown: EventListenerOrEventListenerObject | undefined;
+    __onInsideMouseUp: (() => void) | undefined;
+    /** @type {EventListenerOrEventListenerObject} */
+    __onDocumentMouseUp: EventListenerOrEventListenerObject | undefined;
+    /**
+     * @param {{ phase: OverlayPhase }} config
+     * @protected
+     */
+    protected _handleAccessibility({ phase }: {
+        phase: OverlayPhase;
+    }): void;
+    teardown(): void;
+    /** @protected */
+    protected _teardownContentWrapperNode(): void;
+    /** @private */
+    private __createPopperInstance;
+    _popper: any;
+}
+export namespace OverlayController {
+    const popperModule: Promise<PopperModule> | undefined;
+}
+export type OverlayConfig = import('../types/OverlayConfig.js').OverlayConfig;
+export type ViewportConfig = import('../types/OverlayConfig.js').ViewportConfig;
+export type Popper = any;
+export type PopperOptions = import('@popperjs/core/lib/popper.js').Options;
+export type Placement = import('@popperjs/core/lib/enums.js').Placement;
+export type PopperModule = {
+    createPopper: Popper;
+};
+export type OverlayPhase = 'setup' | 'init' | 'teardown' | 'before-show' | 'show' | 'hide' | 'add' | 'remove';
+import { EventTargetShim } from "../../../exports/core.js";
+//# sourceMappingURL=OverlayController.d.ts.map

package/dist-types/components/overlays/src/OverlayController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlayController.d.ts","sourceRoot":"","sources":["../../../../components/overlays/src/OverlayController.js"],"names":[],"mappings":"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"}

package/dist-types/components/overlays/src/OverlayMixin.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @typedef {import('../types/OverlayConfig.js').OverlayConfig} OverlayConfig
+ * @typedef {import('../types/OverlayMixinTypes.js').DefineOverlayConfig} DefineOverlayConfig
+ * @typedef {import('../types/OverlayMixinTypes.js').OverlayMixin} OverlayMixin
+ */
+/**
+ * @type {OverlayMixin}
+ * @param {import('@open-wc/dedupe-mixin').Constructor<import('lit').LitElement>} superclass
+ */
+export const OverlayMixinImplementation: OverlayMixin;
+export type OverlayMixin = import('../types/OverlayMixinTypes.js').OverlayMixin;
+export const OverlayMixin: typeof import("../types/OverlayMixinTypes.js").OverlayImplementation;
+export type OverlayConfig = import('../types/OverlayConfig.js').OverlayConfig;
+export type DefineOverlayConfig = import('../types/OverlayMixinTypes.js').DefineOverlayConfig;
+//# sourceMappingURL=OverlayMixin.d.ts.map

package/dist-types/components/overlays/src/OverlayMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlayMixin.d.ts","sourceRoot":"","sources":["../../../../components/overlays/src/OverlayMixin.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;;;GAGG;AACH,yCAHU,YAAY,CAwWlB;2BA5WS,OAAO,+BAA+B,EAAE,YAAY;AA6WjE,gGAAoE;4BA/WvD,OAAO,2BAA2B,EAAE,aAAa;kCACjD,OAAO,+BAA+B,EAAE,mBAAmB"}

package/dist-types/components/overlays/src/OverlaysManager.d.ts

@@ -0,0 +1,91 @@
+/**
+ * `OverlaysManager` which manages overlays which are rendered into the body
+ */
+export class OverlaysManager {
+    static __createGlobalRootNode(): HTMLDivElement;
+    static __createGlobalStyleNode(): HTMLStyleElement;
+    /**
+     * no setter as .list is intended to be read-only
+     * You can use .add or .remove to modify it
+     */
+    get globalRootNode(): HTMLElement;
+    /**
+     * no setter as .list is intended to be read-only
+     * You can use .add or .remove to modify it
+     */
+    get list(): import("./OverlayController.js").OverlayController[];
+    /**
+     * no setter as .shownList is intended to be read-only
+     * You can use .show or .hide on individual controllers to modify
+     */
+    get shownList(): import("./OverlayController.js").OverlayController[];
+    /**
+     * @type {OverlayController[]}
+     * @private
+     */
+    private __list;
+    /**
+     * @type {OverlayController[]}
+     * @private
+     */
+    private __shownList;
+    /** @private */
+    private __siblingsInert;
+    /**
+     * @type {WeakMap<OverlayController, OverlayController[]>}
+     * @private
+     */
+    private __blockingMap;
+    /**
+     * Registers an overlay controller.
+     * @param {OverlayController} ctrlToAdd controller of the newly added overlay
+     * @returns {OverlayController} same controller after adding to the manager
+     */
+    add(ctrlToAdd: OverlayController): OverlayController;
+    /**
+     * @param {OverlayController} ctrlToRemove
+     */
+    remove(ctrlToRemove: OverlayController): void;
+    /**
+     * @param {OverlayController} ctrlToShow
+     */
+    show(ctrlToShow: OverlayController): void;
+    /**
+     * @param {any} ctrlToHide
+     */
+    hide(ctrlToHide: any): void;
+    teardown(): void;
+    /** Features right now only for Global Overlay Manager */
+    get siblingsInert(): boolean;
+    disableTrapsKeyboardFocusForAll(): void;
+    /**
+     * @param {'local' | 'global' | undefined} placementMode
+     */
+    informTrapsKeyboardFocusGotEnabled(placementMode: 'local' | 'global' | undefined): void;
+    /**
+     * @param {{ disabledCtrl?:OverlayController, findNewTrap?:boolean }} options
+     */
+    informTrapsKeyboardFocusGotDisabled({ disabledCtrl, findNewTrap }?: {
+        disabledCtrl?: import("./OverlayController.js").OverlayController | undefined;
+        findNewTrap?: boolean | undefined;
+    }): void;
+    /** PreventsScroll */
+    requestToPreventScroll(): void;
+    requestToEnableScroll(): void;
+    /**
+     * Blocking
+     * @param {OverlayController} blockingCtrl
+     */
+    requestToShowOnly(blockingCtrl: OverlayController): void;
+    /**
+     * @param {OverlayController} blockingCtrl
+     */
+    retractRequestToShowOnly(blockingCtrl: OverlayController): void;
+}
+export namespace OverlaysManager {
+    const __globalRootNode: HTMLElement | undefined;
+    const __globalStyleNode: HTMLStyleElement | undefined;
+}
+export type CSSResult = import('lit').CSSResult;
+export type OverlayController = import('./OverlayController.js').OverlayController;
+//# sourceMappingURL=OverlaysManager.d.ts.map

package/dist-types/components/overlays/src/OverlaysManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlaysManager.d.ts","sourceRoot":"","sources":["../../../../components/overlays/src/OverlaysManager.js"],"names":[],"mappings":"AAUA;;GAEG;AACH;IACE,gDAKC;IAED,mDAMC;IAED;;;OAGG;IAEH,kCAMC;IAED;;;OAGG;IACH,iEAEC;IAED;;;OAGG;IACH,sEAEC;IAGC;;;OAGG;IACH,eAAgB;IAChB;;;OAGG;IACH,oBAAqB;IACrB,eAAe;IACf,wBAA4B;IAC5B;;;OAGG;IACH,sBAAkC;IAGpC;;;;OAIG;IACH,eAHW,iBAAiB,GACf,iBAAiB,CAQ7B;IAED;;OAEG;IACH,qBAFW,iBAAiB,QAO3B;IAED;;OAEG;IACH,iBAFW,iBAAiB,QAe3B;IAED;;OAEG;IACH,iBAFW,GAAG,QAOb;IAED,iBAqBC;IAED,yDAAyD;IAEzD,6BAEC;IAED,wCAMC;IAED;;OAEG;IACH,kDAFW,OAAO,GAAG,QAAQ,GAAG,SAAS,QASxC;IAED;;OAEG;IACH;;;aAcC;IAED,qBAAqB;IAGrB,+BASC;IAED,8BAQC;IAED;;;OAGG;IACH,gCAFW,iBAAiB,QAO3B;IAED;;OAEG;IACH,uCAFW,iBAAiB,QAS3B;CACF;;4BACU,WAAW,GAAG,SAAS;6BAEvB,gBAAgB,GAAG,SAAS;;wBArP1B,OAAO,KAAK,EAAE,SAAS;gCACvB,OAAO,wBAAwB,EAAE,iBAAiB"}

package/dist-types/components/overlays/src/configurations/withBottomSheetConfig.d.ts

@@ -0,0 +1,3 @@
+export function withBottomSheetConfig(): import("../../types/OverlayConfig.js").OverlayConfig;
+export type OverlayConfig = import('../../types/OverlayConfig.js').OverlayConfig;
+//# sourceMappingURL=withBottomSheetConfig.d.ts.map

package/dist-types/components/overlays/src/configurations/withBottomSheetConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withBottomSheetConfig.d.ts","sourceRoot":"","sources":["../../../../../components/overlays/src/configurations/withBottomSheetConfig.js"],"names":[],"mappings":"AAIO,8FAWH;4BAdS,OAAO,8BAA8B,EAAE,aAAa"}

package/dist-types/components/overlays/src/configurations/withDropdownConfig.d.ts

@@ -0,0 +1,3 @@
+export function withDropdownConfig(): import("../../types/OverlayConfig.js").OverlayConfig;
+export type OverlayConfig = import('../../types/OverlayConfig.js').OverlayConfig;
+//# sourceMappingURL=withDropdownConfig.d.ts.map

package/dist-types/components/overlays/src/configurations/withDropdownConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDropdownConfig.d.ts","sourceRoot":"","sources":["../../../../../components/overlays/src/configurations/withDropdownConfig.js"],"names":[],"mappings":"AAIO,2FAiBH;4BApBS,OAAO,8BAA8B,EAAE,aAAa"}

package/dist-types/components/overlays/src/configurations/withModalDialogConfig.d.ts

@@ -0,0 +1,3 @@
+export function withModalDialogConfig(): import("../../types/OverlayConfig.js").OverlayConfig;
+export type OverlayConfig = import('../../types/OverlayConfig.js').OverlayConfig;
+//# sourceMappingURL=withModalDialogConfig.d.ts.map

package/dist-types/components/overlays/src/configurations/withModalDialogConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withModalDialogConfig.d.ts","sourceRoot":"","sources":["../../../../../components/overlays/src/configurations/withModalDialogConfig.js"],"names":[],"mappings":"AAIO,8FAWH;4BAdS,OAAO,8BAA8B,EAAE,aAAa"}

package/dist-types/components/overlays/src/globalOverlaysStyle.d.ts

@@ -0,0 +1,2 @@
+export const globalOverlaysStyle: import("lit").CSSResult;
+//# sourceMappingURL=globalOverlaysStyle.d.ts.map

package/dist-types/components/overlays/src/globalOverlaysStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalOverlaysStyle.d.ts","sourceRoot":"","sources":["../../../../components/overlays/src/globalOverlaysStyle.js"],"names":[],"mappings":"AAEA,0DA8HE"}

package/dist-types/components/overlays/src/singleton.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {OverlaysManager} newOverlays
+ */
+export function setOverlays(newOverlays: OverlaysManager): void;
+export let overlays: any;
+import { OverlaysManager } from "./OverlaysManager.js";
+//# sourceMappingURL=singleton.d.ts.map

package/dist-types/components/overlays/src/singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../../../../components/overlays/src/singleton.js"],"names":[],"mappings":"AAOA;;GAEG;AACH,yCAFW,eAAe,QAIzB;AARD,yBACoF"}

package/dist-types/components/overlays/src/utils/contain-focus.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rotates focus within a list of elements. If shift key was not pressed and focus
+ * is on last item, puts focus on the first item. Reversed if shift key.
+ *
+ * @param {HTMLElement} rootElement The root element
+ * @param {KeyboardEvent} e The keyboard event
+ */
+export function rotateFocus(rootElement: HTMLElement, e: KeyboardEvent): void;
+/**
+ * Contains focus within given root element. When focus is on the last focusable
+ * element inside the root element, the next focus will be redirected to the first
+ * focusable element.
+ *
+ * @param {HTMLElement} rootElement The element to contain focus within
+ * @returns {{ disconnect: () => void }} handler with a disconnect callback
+ */
+export function containFocus(rootElement: HTMLElement): {
+    disconnect: () => void;
+};
+//# sourceMappingURL=contain-focus.d.ts.map

package/dist-types/components/overlays/src/utils/contain-focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contain-focus.d.ts","sourceRoot":"","sources":["../../../../../components/overlays/src/utils/contain-focus.js"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,yCAHW,WAAW,KACX,aAAa,QA6CvB;AAED;;;;;;;GAOG;AACH,0CAHW,WAAW;gBACK,MAAM,IAAI;EAkIpC"}