@lion/ui 0.8.2 → 0.8.3

package/components/overlays/src/OverlayController.js

@@ -1,16 +1,17 @@
 import { overlays } from './singleton.js';
 import { containFocus } from './utils/contain-focus.js';
+import { deepContains } from './utils/deep-contains.js';
 import { overlayShadowDomStyle } from './overlayShadowDomStyle.js';
 import { _adoptStyleUtils } from './utils/adopt-styles.js';
 
 /**
- * @typedef {import('@lion/ui/types/overlays.js').OverlayConfig} OverlayConfig
+ * @typedef {'setup'|'init'|'teardown'|'before-show'|'show'|'hide'|'add'|'remove'} OverlayPhase
  * @typedef {import('@lion/ui/types/overlays.js').ViewportConfig} ViewportConfig
- * @typedef {import('@popperjs/core').createPopper} Popper
+ * @typedef {import('@lion/ui/types/overlays.js').OverlayConfig} OverlayConfig
  * @typedef {import('@popperjs/core').Options} PopperOptions
  * @typedef {import('@popperjs/core').Placement} Placement
+ * @typedef {import('@popperjs/core').createPopper} Popper
  * @typedef {{ createPopper: Popper }} PopperModule
- * @typedef {'setup'|'init'|'teardown'|'before-show'|'show'|'hide'|'add'|'remove'} OverlayPhase
  */
 
 /**
@@ -103,6 +104,8 @@ async function preloadPopper() {
   return /** @type {* & Promise<PopperModule>} */ (import('@popperjs/core/dist/esm/popper.js'));
 }
 
+const childDialogsClosedInEventLoopWeakmap = new WeakMap();
+
 /**
  * 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,
@@ -498,9 +501,6 @@ export class OverlayController extends EventTarget {
         '[OverlayController] .isTooltip only takes effect when .handlesAccessibility is enabled',
       );
     }
-    // if (newConfig.popperConfig.modifiers.arrow && !newConfig.contentWrapperNode) {
-    //   throw new Error('You need to provide a .contentWrapperNode when Popper arrow is enabled');
-    // }
   }
 
   /**
@@ -1146,11 +1146,40 @@ export class OverlayController extends EventTarget {
     ev.preventDefault();
   }
 
-  /** @private */
-  __escKeyHandler(/** @type {KeyboardEvent} */ ev) {
-    return ev.key === 'Escape' && this.hide();
+  /**
+   * @param {KeyboardEvent} event
+   * @returns {void}
+   */
+  __escKeyHandler(event) {
+    if (event.key !== 'Escape' || childDialogsClosedInEventLoopWeakmap.has(event)) return;
+
+    const hasPressedInside =
+      event.composedPath().includes(this.contentNode) ||
+      deepContains(this.contentNode, /** @type {HTMLElement|ShadowRoot} */ (event.target));
+    if (hasPressedInside) {
+      this.hide();
+      // We could do event.stopPropagation() here, but we don't want to hide info for
+      // the outside world about user interactions. Instead, we store the event in a WeakMap
+      // that will be garbage collected after the event loop.
+      childDialogsClosedInEventLoopWeakmap.set(event, this);
+    }
   }
 
+  /**
+   * @param {KeyboardEvent} event
+   * @returns {void}
+   */
+  #outsideEscKeyHandler = event => {
+    if (event.key !== 'Escape') return;
+
+    const hasPressedInside =
+      event.composedPath().includes(this.contentNode) ||
+      deepContains(this.contentNode, /** @type {HTMLElement|ShadowRoot} */ (event.target));
+    if (!hasPressedInside) {
+      this.hide();
+    }
+  };
+
   /**
    * @param {{ phase: OverlayPhase }} config
    * @protected
@@ -1175,11 +1204,9 @@ export class OverlayController extends EventTarget {
    */
   _handleHidesOnOutsideEsc({ phase }) {
     if (phase === 'show') {
-      this.__escKeyHandler = (/** @type {KeyboardEvent} */ ev) =>
-        ev.key === 'Escape' && this.hide();
-      document.addEventListener('keyup', this.__escKeyHandler);
+      document.addEventListener('keyup', this.#outsideEscKeyHandler);
     } else if (phase === 'hide') {
-      document.removeEventListener('keyup', this.__escKeyHandler);
+      document.removeEventListener('keyup', this.#outsideEscKeyHandler);
     }
   }
 

package/components/overlays/test/OverlayController.test.js

@@ -1,28 +1,41 @@
 /* eslint-disable no-new */
+import { OverlayController, overlays } from '@lion/ui/overlays.js';
+import { mimicClick } from '@lion/ui/overlays-test-helpers.js';
+import sinon from 'sinon';
 import {
-  aTimeout,
+  unsafeStatic,
+  fixtureSync,
   defineCE,
-  expect,
+  aTimeout,
   fixture,
+  expect,
   html,
-  unsafeStatic,
-  fixtureSync,
 } from '@open-wc/testing';
-import sinon from 'sinon';
-import { OverlayController, overlays } from '@lion/ui/overlays.js';
-import { mimicClick } from '@lion/ui/overlays-test-helpers.js';
-import { keyCodes } from '../src/utils/key-codes.js';
-import { simulateTab } from '../src/utils/simulate-tab.js';
-import { _adoptStyleUtils } from '../src/utils/adopt-styles.js';
+
 import { createShadowHost } from '../test-helpers/createShadowHost.js';
+import { _adoptStyleUtils } from '../src/utils/adopt-styles.js';
+import { simulateTab } from '../src/utils/simulate-tab.js';
+import { keyCodes } from '../src/utils/key-codes.js';
 
 /**
- * @typedef {import('../types/OverlayConfig.js').OverlayConfig} OverlayConfig
  * @typedef {import('../types/OverlayConfig.js').ViewportPlacement} ViewportPlacement
+ * @typedef {import('../types/OverlayConfig.js').OverlayConfig} OverlayConfig
  */
 
 const wrappingDialogNodeStyle = 'display: none; z-index: 9999; padding: 0px;';
 
+/**
+ * A small wrapper function that closely mimics an escape press from a user
+ * (prevents common mistakes like no bubbling or keydown)
+ * @param {Element|Document} element
+ */
+async function mimicEscapePress(element) {
+  element.dispatchEvent(
+    new KeyboardEvent('keyup', { key: 'Escape', bubbles: true, composed: true }),
+  );
+  await aTimeout(0);
+}
+
 /**
  * Make sure that all browsers serialize html in a similar way
  * (Firefox tends to output empty style attrs)
@@ -74,6 +87,50 @@ const withLocalTestConfig = () =>
     ),
   });
 
+/**
+ * @param {HTMLDivElement} parentContent
+ * @returns {Promise<{parentOverlay: OverlayController; childOverlay: OverlayController}>}
+ */
+async function createNestedEscControllers(parentContent) {
+  const childContent = /** @type {HTMLDivElement} */ (parentContent.querySelector('div[id]'));
+  // Assert valid fixure
+  const isValid =
+    (parentContent.id === 'parent-overlay--hidesOnEsc' ||
+      parentContent.id === 'parent-overlay--hidesOnOutsideEsc') &&
+    (childContent.id === 'child-overlay--hidesOnEsc' ||
+      childContent.id === 'child-overlay--hidesOnOutsideEsc');
+  if (!isValid) {
+    throw new Error('Provide a valid fixture');
+  }
+
+  if (parentContent.hasAttribute('data-convert-to-shadow-root')) {
+    const shadowRootParent = parentContent.attachShadow({ mode: 'open' });
+    shadowRootParent.appendChild(childContent);
+  }
+
+  const parentHasOutsideOnEsc = parentContent.id === 'parent-overlay--hidesOnOutsideEsc';
+  const childHasOutsideOnEsc = childContent.id === 'child-overlay--hidesOnOutsideEsc';
+
+  const parentConfig = parentHasOutsideOnEsc ? { hidesOnOutsideEsc: true } : { hidesOnEsc: true };
+  const childConfig = childHasOutsideOnEsc ? { hidesOnOutsideEsc: true } : { hidesOnEsc: true };
+
+  const parentOverlay = new OverlayController({
+    ...withGlobalTestConfig(),
+    contentNode: parentContent,
+    ...parentConfig,
+  });
+  const childOverlay = new OverlayController({
+    ...withGlobalTestConfig(),
+    contentNode: childContent,
+    ...childConfig,
+  });
+
+  await parentOverlay.show();
+  await childOverlay.show();
+
+  return { parentOverlay, childOverlay };
+}
+
 afterEach(() => {
   overlays.teardown();
 });
@@ -574,74 +631,221 @@ describe('OverlayController', () => {
     });
 
     describe('hidesOnEsc', () => {
-      it('hides when [escape] is pressed', async () => {
+      it('hides on [Escape] press', async () => {
         const ctrl = new OverlayController({
           ...withGlobalTestConfig(),
           hidesOnEsc: true,
         });
         await ctrl.show();
-        ctrl.contentNode.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape' }));
-        await aTimeout(0);
+        await mimicEscapePress(ctrl.contentNode);
         expect(ctrl.isShown).to.be.false;
       });
 
-      it("doesn't hide when [escape] is pressed and hidesOnEsc is set to false", async () => {
+      it('stays shown on [Escape] press with `.hidesOnEsc` set to false', async () => {
         const ctrl = new OverlayController({
           ...withGlobalTestConfig(),
           hidesOnEsc: false,
         });
         await ctrl.show();
-        ctrl.contentNode.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape' }));
-        await aTimeout(0);
+        await mimicEscapePress(ctrl.contentNode);
         expect(ctrl.isShown).to.be.true;
       });
 
-      it('stays shown when [escape] is pressed on outside element', async () => {
+      it('stays shown on [Escape] press on outside element', async () => {
         const ctrl = new OverlayController({
           ...withGlobalTestConfig(),
           hidesOnEsc: true,
         });
         await ctrl.show();
-        document.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape' }));
+        await mimicEscapePress(document);
         expect(ctrl.isShown).to.be.true;
       });
 
-      it('does not hide when [escape] is pressed with modal <dialog> and "hidesOnEsc" is false', async () => {
+      it('stays shown on [Escape] press with modal <dialog> and `.hidesOnEsc` is false', async () => {
         const ctrl = new OverlayController({
           ...withGlobalTestConfig(),
           trapsKeyboardFocus: true,
           hidesOnEsc: false,
         });
         await ctrl.show();
-        ctrl.contentNode.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape' }));
-        await aTimeout(0);
+        await mimicEscapePress(ctrl.contentNode);
         expect(ctrl.isShown).to.be.true;
       });
+
+      it('parent stays shown on [Escape] press in a nested overlay', async () => {
+        const parentContent = /** @type {HTMLDivElement} */ (
+          await fixture(
+            html` <!-- -->
+              <div id="parent-overlay--hidesOnEsc">
+                <div id="child-overlay--hidesOnEsc">we press [Escape] here</div>
+              </div>`,
+          )
+        );
+        const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+        await mimicEscapePress(childOverlay.contentNode);
+
+        expect(parentOverlay.isShown).to.be.true;
+        expect(childOverlay.isShown).to.be.false;
+      });
     });
 
     describe('hidesOnOutsideEsc', () => {
-      it('hides when [escape] is pressed on outside element', async () => {
+      it('hides on [Escape] press on outside element', async () => {
         const ctrl = new OverlayController({
           ...withGlobalTestConfig(),
           hidesOnOutsideEsc: true,
         });
         await ctrl.show();
-        document.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape' }));
-        await aTimeout(0);
+        await mimicEscapePress(document);
         expect(ctrl.isShown).to.be.false;
       });
 
-      it('stays shown when [escape] is pressed on inside element', async () => {
+      it('stays shown on [Escape] press on inside element', async () => {
         const ctrl = new OverlayController({
           ...withGlobalTestConfig(),
           hidesOnOutsideEsc: true,
         });
         await ctrl.show();
-        ctrl.contentNode.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape' }));
+        await mimicEscapePress(ctrl.contentNode);
         expect(ctrl.isShown).to.be.true;
       });
+
+      it('stays shown on [Escape] press in a nested overlay', async () => {
+        const parentContent = /** @type {HTMLDivElement} */ (
+          await fixture(
+            html` <!-- -->
+              <div id="parent-overlay--hidesOnOutsideEsc">
+                <div id="child-overlay--hidesOnOutsideEsc">we press [Escape] here</div>
+              </div>`,
+          )
+        );
+        const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+        mimicEscapePress(childOverlay.contentNode);
+
+        expect(parentOverlay.isShown).to.be.true;
+        expect(childOverlay.isShown).to.be.true;
+      });
     });
 
+    describe('Nested hidesOnEsc / hidesOnOutsideEsc', () => {
+      describe('Parent has hidesOnEsc and child has hidesOnOutsideEsc', () => {
+        it('on [Escape] press in child overlay: parent hides, child stays shown', async () => {
+          const parentContent = /** @type {HTMLDivElement} */ (
+            await fixture(
+              html` <!-- -->
+                <div id="parent-overlay--hidesOnEsc">
+                  <div id="child-overlay--hidesOnOutsideEsc">we press [Escape] here</div>
+                </div>`,
+            )
+          );
+          const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+          await mimicEscapePress(childOverlay.contentNode);
+
+          expect(parentOverlay.isShown).to.be.false;
+          expect(childOverlay.isShown).to.be.true;
+        });
+
+        it('on [Escape] press outside overlays: parent stays shown, child hides', async () => {
+          const parentContent = /** @type {HTMLDivElement} */ (
+            await fixture(
+              html` <!-- we press [Escape] here -->
+                <div id="parent-overlay--hidesOnEsc">
+                  <div id="child-overlay--hidesOnOutsideEsc"></div>
+                </div>`,
+            )
+          );
+          const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+          await mimicEscapePress(document);
+
+          expect(parentOverlay.isShown).to.be.true;
+          expect(childOverlay.isShown).to.be.false;
+        });
+
+        it('on [Escape] press in parent overlay: parent is hidden, child is hidden', async () => {
+          const parentContent = /** @type {HTMLDivElement} */ (
+            await fixture(
+              html` <!-- -->
+                <div id="parent-overlay--hidesOnEsc">
+                  we press [Escape] here
+                  <div id="child-overlay--hidesOnOutsideEsc"></div>
+                </div>`,
+            )
+          );
+          const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+          await mimicEscapePress(parentContent);
+
+          expect(parentOverlay.isShown).to.be.false;
+          expect(childOverlay.isShown).to.be.false;
+        });
+      });
+      describe('Parent has hidesOnOutsideEsc and child has hidesOnEsc', () => {
+        it('on [Escape] press in child overlay: parent stays shown, child hides', async () => {
+          const parentContent = /** @type {HTMLDivElement} */ (
+            await fixture(
+              html` <!-- -->
+                <div id="parent-overlay--hidesOnOutsideEsc">
+                  <div id="child-overlay--hidesOnEsc">we press [Escape] here</div>
+                </div>`,
+            )
+          );
+          const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+          await mimicEscapePress(childOverlay.contentNode);
+
+          expect(parentOverlay.isShown).to.be.true;
+          expect(childOverlay.isShown).to.be.false;
+        });
+
+        it('on [Escape] press outside overlays: parent hides, child stays shown', async () => {
+          const parentContent = /** @type {HTMLDivElement} */ (
+            await fixture(
+              html` <!-- we press [Escape] here -->
+                <div id="parent-overlay--hidesOnOutsideEsc">
+                  <div id="child-overlay--hidesOnEsc"></div>
+                </div>`,
+            )
+          );
+          const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+          await mimicEscapePress(document);
+
+          expect(parentOverlay.isShown).to.be.false;
+          expect(childOverlay.isShown).to.be.true;
+        });
+
+        it('on [Escape] press in parent overlay: parent hides, child stays shown', async () => {
+          const parentContent = /** @type {HTMLDivElement} */ (
+            await fixture(
+              html` <!-- we press [Escape] here -->
+                <div id="parent-overlay--hidesOnOutsideEsc">
+                  <div id="child-overlay--hidesOnEsc"></div>
+                </div>`,
+            )
+          );
+          const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+          await mimicEscapePress(document);
+
+          expect(parentOverlay.isShown).to.be.false;
+          expect(childOverlay.isShown).to.be.true;
+        });
+      });
+
+      describe('With shadow dom', () => {
+        it('on [Escape] press in child overlay in shadow root: parent hides, child stays shown', async () => {
+          const parentContent = /** @type {HTMLDivElement} */ (
+            await fixture(
+              html` <!-- -->
+                <div id="parent-overlay--hidesOnEsc" data-convert-to-shadow-root>
+                  <div id="child-overlay--hidesOnOutsideEsc">we press [Escape] here</div>
+                </div>`,
+            )
+          );
+          const { parentOverlay, childOverlay } = await createNestedEscControllers(parentContent);
+          await mimicEscapePress(childOverlay.contentNode);
+
+          expect(parentOverlay.isShown).to.be.false;
+          expect(childOverlay.isShown).to.be.true;
+        });
+      });
+    });
     describe('hidesOnOutsideClick', () => {
       it('hides on outside click', async () => {
         const contentNode = /** @type {HTMLElement} */ (await fixture('<div>Content</div>'));
@@ -684,9 +888,8 @@ describe('OverlayController', () => {
         expect(ctrl.isShown).to.be.true;
 
         // Don't hide on inside mousedown & outside mouseup
-        ctrl.contentNode.dispatchEvent(new MouseEvent('mousedown'));
-        await aTimeout(0);
-        document.body.dispatchEvent(new MouseEvent('mouseup'));
+        await mimicClick(ctrl.contentNode, { releaseElement: document.body, isAsync: true });
+
         await aTimeout(0);
         expect(ctrl.isShown).to.be.true;
 

package/components/overlays/test-helpers/mimicClick.js

@@ -8,9 +8,9 @@ async function sleep(t = 0) {
 
 /**
  * @param {HTMLElement} el
- * @param {{isAsync?:boolean, releaseElement?: HTMLElement}} config
+ * @param {{isAsync?:boolean, releaseElement?: HTMLElement}} config releaseElement can be different when the mouse is dragged before release
  */
-export async function mimicClick(el, { isAsync, releaseElement } = { isAsync: false }) {
+export async function mimicClick(el, { isAsync = false, releaseElement } = {}) {
   const releaseEl = releaseElement || el;
   el.dispatchEvent(new MouseEvent('mousedown'));
   if (isAsync) {

package/custom-elements.json

@@ -114306,10 +114306,11 @@
               }
             },
             {
-              "name": "{ isAsync, releaseElement }",
-              "default": "{ isAsync: false }"
+              "name": "{ isAsync = false, releaseElement }",
+              "default": "{}"
             },
             {
+              "description": "releaseElement can be different when the mouse is dragged before release",
               "name": "config",
               "type": {
                 "text": "{isAsync?:boolean, releaseElement?: HTMLElement}"
@@ -114997,10 +114998,36 @@
               "name": "__escKeyHandler",
               "parameters": [
                 {
-                  "name": "ev"
+                  "name": "event",
+                  "type": {
+                    "text": "KeyboardEvent"
+                  }
                 }
               ],
-              "privacy": "private"
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "privacy": "protected"
+            },
+            {
+              "kind": "field",
+              "name": "#outsideEscKeyHandler",
+              "privacy": "private",
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "KeyboardEvent"
+                  }
+                }
+              ],
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
             },
             {
               "kind": "method",

package/dist-types/components/form-integrations/test/helpers/helpers.d.ts

@@ -5,15 +5,15 @@
 /**
  * @param {LionForm} formGroupEl
  */
-export function getAllFormElements(formGroupEl: LionForm): any[];
+export function getAllFormElements(formGroupEl: LionForm): any;
 /**
  * @param {LionForm} formGroupEl
  */
-export function getAllTagNames(formGroupEl: LionForm): any[];
+export function getAllTagNames(formGroupEl: LionForm): any;
 /**
  * @param {LionForm} formGroupEl
  */
-export function getAllFieldsAndFormGroups(formGroupEl: LionForm): any[];
+export function getAllFieldsAndFormGroups(formGroupEl: LionForm): any;
 export type LionForm = import('../../../form/src/LionForm.js').LionForm;
 export type LionField = import('../../../form-core/src/LionField.js').LionField;
 //# sourceMappingURL=helpers.d.ts.map

package/dist-types/components/form-integrations/test/helpers/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../components/form-integrations/test/helpers/helpers.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,gDAFW,QAAQ,SAWlB;AAED;;GAEG;AACH,4CAFW,QAAQ,SAWlB;AAED;;GAEG;AACH,uDAFW,QAAQ,SAKlB;uBAtCY,OAAO,+BAA+B,EAAE,QAAQ;wBAChD,OAAO,qCAAqC,EAAE,SAAS"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../components/form-integrations/test/helpers/helpers.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,gDAFW,QAAQ,OAWlB;AAED;;GAEG;AACH,4CAFW,QAAQ,OAWlB;AAED;;GAEG;AACH,uDAFW,QAAQ,OAKlB;uBAtCY,OAAO,+BAA+B,EAAE,QAAQ;wBAChD,OAAO,qCAAqC,EAAE,SAAS"}

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

@@ -31,8 +31,11 @@ export class OverlayController extends EventTarget {
     private __hasActiveTrapsKeyboardFocus;
     /** @private */
     private __hasActiveBackdrop;
-    /** @private */
-    private __escKeyHandler;
+    /**
+     * @param {KeyboardEvent} event
+     * @returns {void}
+     */
+    __escKeyHandler(event: KeyboardEvent): void;
     /**
      * When the overlay is a modal dialog hidesOnEsc works out of the box, so we prevent that.
      *
@@ -434,17 +437,18 @@ export class OverlayController extends EventTarget {
     private __createPopperInstance;
     _popper: any;
     _hasDisabledInvoker(): boolean;
+    #private;
 }
 export namespace OverlayController {
     const popperModule: Promise<PopperModule> | undefined;
 }
-export type OverlayConfig = import('@lion/ui/types/overlays.js').OverlayConfig;
+export type OverlayPhase = 'setup' | 'init' | 'teardown' | 'before-show' | 'show' | 'hide' | 'add' | 'remove';
 export type ViewportConfig = import('@lion/ui/types/overlays.js').ViewportConfig;
-export type Popper = any;
+export type OverlayConfig = import('@lion/ui/types/overlays.js').OverlayConfig;
 export type PopperOptions = import('@popperjs/core').Options;
 export type Placement = import('@popperjs/core').Placement;
+export type Popper = any;
 export type PopperModule = {
     createPopper: Popper;
 };
-export type OverlayPhase = 'setup' | 'init' | 'teardown' | 'before-show' | 'show' | 'hide' | 'add' | 'remove';
 //# sourceMappingURL=OverlayController.d.ts.map

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

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

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

@@ -1,3 +1,3 @@
-export type OverlayConfig = import('../types/OverlayConfig.js').OverlayConfig;
 export type ViewportPlacement = import('../types/OverlayConfig.js').ViewportPlacement;
+export type OverlayConfig = import('../types/OverlayConfig.js').OverlayConfig;
 //# sourceMappingURL=OverlayController.test.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"OverlayController.test.d.ts","sourceRoot":"","sources":["../../../../components/overlays/test/OverlayController.test.js"],"names":[],"mappings":"4BAmBa,OAAO,2BAA2B,EAAE,aAAa;gCACjD,OAAO,2BAA2B,EAAE,iBAAiB"}
+{"version":3,"file":"OverlayController.test.d.ts","sourceRoot":"","sources":["../../../../components/overlays/test/OverlayController.test.js"],"names":[],"mappings":"gCAoBa,OAAO,2BAA2B,EAAE,iBAAiB;4BACrD,OAAO,2BAA2B,EAAE,aAAa"}

package/dist-types/components/overlays/test-helpers/mimicClick.d.ts

@@ -1,6 +1,6 @@
 /**
  * @param {HTMLElement} el
- * @param {{isAsync?:boolean, releaseElement?: HTMLElement}} config
+ * @param {{isAsync?:boolean, releaseElement?: HTMLElement}} config releaseElement can be different when the mouse is dragged before release
  */
 export function mimicClick(el: HTMLElement, { isAsync, releaseElement }?: {
     isAsync?: boolean;