fix(overlays): rework setup and teardown logic of OverlayMixin

ing-bank · Jan 7, 2025 · f4af9e6 · f4af9e6
1 parent fef94cd
commit f4af9e6
Show file tree

Hide file tree

Showing 8 changed files with 180 additions and 32 deletions.
diff --git a/.changeset/smooth-boats-argue.md b/.changeset/smooth-boats-argue.md
@@ -2,4 +2,4 @@
 '@lion/ui': patch
 ---
 
-overlayController teardown cleanup (removes logs in test files)
+[overlays]: overlayController teardown cleanup (removes logs in test files)
diff --git a/.changeset/tricky-suns-change.md b/.changeset/tricky-suns-change.md
@@ -0,0 +1,5 @@
+---
+'@lion/ui': patch
+---
+
+[overlays]: allow Subclassers to teardown at the right moment
diff --git a/.changeset/tricky-suns-changerz.md b/.changeset/tricky-suns-changerz.md
@@ -0,0 +1,5 @@
+---
+'@lion/ui': minor
+---
+
+[overlays]: rework setup and teardown logic of OverlayMixin (allow to reconnect offline dom nodes; allow moving dom nodes in performant way)
diff --git a/packages/ui/components/combobox/test/lion-combobox.test.js b/packages/ui/components/combobox/test/lion-combobox.test.js
@@ -229,6 +229,8 @@ describe('lion-combobox', () => {
             </lion-combobox>
           `)
         );
+        await el.updateComplete;
+
         const { _inputNode } = getComboboxMembers(el);
 
         _inputNode.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape' }));

diff --git a/packages/ui/components/overlays/src/OverlayController.js b/packages/ui/components/overlays/src/OverlayController.js
@@ -1003,16 +1003,16 @@ export class OverlayController extends EventTarget {
    * @param {{ phase: OverlayPhase }} config
    */
   _handleVisibilityTriggers({ phase }) {
-    if (typeof this.visibilityTriggerFunction !== 'function') return;
-
-    if (phase === 'init') {
-      this.__visibilityTriggerHandler = this.visibilityTriggerFunction({
-        phase,
-        controller: this,
-      });
-    }
-    if (this.__visibilityTriggerHandler[phase]) {
-      this.__visibilityTriggerHandler[phase]();
+    if (typeof this.visibilityTriggerFunction === 'function') {
+      if (phase === 'init') {
+        this.__visibilityTriggerHandler = this.visibilityTriggerFunction({
+          phase,
+          controller: this,
+        });
+      }
+      if (this.__visibilityTriggerHandler[phase]) {
+        this.__visibilityTriggerHandler[phase]();
+      }
     }
   }
 
@@ -1192,7 +1192,6 @@ export class OverlayController extends EventTarget {
       event.composedPath().includes(this.contentNode) ||
       deepContains(this.contentNode, /** @type {HTMLElement|ShadowRoot} */ (event.target));
     if (hasPressedInside) return;
-
     this.hide();
   };
 

diff --git a/packages/ui/components/overlays/src/OverlayMixin.js b/packages/ui/components/overlays/src/OverlayMixin.js
@@ -24,6 +24,8 @@ export const OverlayMixinImplementation = superclass =>
       };
     }
 
+    #hasSetup = false;
+
     constructor() {
       super();
       /**
@@ -173,22 +175,23 @@ export const OverlayMixinImplementation = superclass =>
       }
     }
 
-    /**
-     * @param {import('lit-element').PropertyValues } changedProperties
-     */
-    firstUpdated(changedProperties) {
-      super.firstUpdated(changedProperties);
+    connectedCallback() {
+      super.connectedCallback();
 
-      this._setupOverlayCtrl();
+      this.updateComplete.then(() => {
+        if (this.#hasSetup) return;
+        this._setupOverlayCtrl();
+        this.#hasSetup = true;
+      });
     }
 
     async disconnectedCallback() {
       super.disconnectedCallback();
 
-      if (!this._overlayCtrl) return;
-      if (await this.#isMovingInDom()) return;
-
-      this._teardownOverlayCtrl();
+      if (await this._isPermanentlyDisconnected()) {
+        this._teardownOverlayCtrl();
+        this.#hasSetup = false;
+      }
     }
 
     /**
@@ -238,6 +241,8 @@ export const OverlayMixinImplementation = superclass =>
 
     /** @protected */
     _setupOverlayCtrl() {
+      if (this._overlayCtrl) return;
+
       /** @type {OverlayController} */
       this._overlayCtrl = this._defineOverlay({
         contentNode: this._overlayContentNode,
@@ -253,11 +258,12 @@ export const OverlayMixinImplementation = superclass =>
 
     /** @protected */
     _teardownOverlayCtrl() {
+      if (!this._overlayCtrl) return;
+
       this._teardownOpenCloseListeners();
       this.__teardownSyncFromOverlayController();
 
-      /** @type {OverlayController} */
-      (this._overlayCtrl).teardown();
+      /** @type {OverlayController} */ (this._overlayCtrl).teardown();
     }
 
     /**
@@ -396,9 +402,9 @@ export const OverlayMixinImplementation = superclass =>
      * Before we decide to teardown, let's wait to see if we were not just moving nodes around.
      * @return {Promise<boolean>}
      */
-    async #isMovingInDom() {
+    async _isPermanentlyDisconnected() {
       await this.updateComplete;
-      return this.isConnected;
+      return !this.isConnected;
     }
   };
 export const OverlayMixin = dedupeMixin(OverlayMixinImplementation);
diff --git a/packages/ui/components/overlays/test-suites/OverlayMixin.suite.js b/packages/ui/components/overlays/test-suites/OverlayMixin.suite.js
@@ -1,10 +1,18 @@
-import { expect, fixture, html, nextFrame, aTimeout } from '@open-wc/testing';
-
-import sinon from 'sinon';
+import {
+  unsafeStatic,
+  nextFrame,
+  aTimeout,
+  defineCE,
+  fixture,
+  expect,
+  html,
+} from '@open-wc/testing';
 import { overlays as overlaysManager, OverlayController } from '@lion/ui/overlays.js';
-
-import '@lion/ui/define/lion-dialog.js';
 import { browserDetection } from '@lion/ui/core.js';
+import { cache } from 'lit/directives/cache.js';
+import '@lion/ui/define/lion-dialog.js';
+import { LitElement } from 'lit';
+import sinon from 'sinon';
 
 /**
  * @typedef {import('../types/OverlayConfig.js').OverlayConfig} OverlayConfig
@@ -331,6 +339,125 @@ export function runOverlayMixinSuite({ tagString, tag, suffix = '' }) {
       }).to.not.throw;
       stub.restore();
     });
+
+    it('does not teardown when moving dom nodes', async () => {
+      const el = /** @type {OverlayEl} */ (
+        await fixture(html`
+        <${tag}>
+          <div slot="content">content</div>
+          <button slot="invoker">invoker button</button>
+        </${tag}>
+      `)
+      );
+      // @ts-expect-error [allow-protected] in tests
+      const teardownSpy = sinon.spy(el, '_teardownOverlayCtrl');
+      // @ts-expect-error [allow-protected] in tests
+      const spyDisconnected = sinon.spy(el, '_isPermanentlyDisconnected');
+
+      // move around in dom
+      const newParent = document.createElement('div');
+      document.body.appendChild(newParent);
+      newParent.appendChild(el);
+      await aTimeout(0);
+
+      expect(spyDisconnected.callCount).to.equal(1);
+      expect(teardownSpy.callCount).to.equal(0);
+
+      // simulate a permanent disconnect
+      newParent.removeChild(el);
+      await aTimeout(0);
+
+      expect(teardownSpy.callCount).to.equal(1);
+    });
+
+    it('allows to disconnect and reconnect later', async () => {
+      const el = /** @type {OverlayEl} */ (
+        await fixture(html`
+        <${tag}>
+          <div slot="content">content</div>
+          <button slot="invoker">invoker button</button>
+        </${tag}>
+      `)
+      );
+      // @ts-expect-error [allow-protected] in tests
+      const teardownSpy = sinon.spy(el, '_teardownOverlayCtrl');
+      // @ts-expect-error [allow-protected] in tests
+      const spyDisconnected = sinon.spy(el, '_isPermanentlyDisconnected');
+      // @ts-expect-error [allow-protected] in tests
+      const setupSpy = sinon.spy(el, '_setupOverlayCtrl');
+
+      // 'permanently' disconnect (although we will reconnect later)
+      const offlineParent = document.createElement('div');
+      offlineParent.appendChild(el);
+      await aTimeout(0);
+
+      expect(spyDisconnected.callCount).to.equal(1);
+      expect(teardownSpy.callCount).to.equal(1);
+
+      // reconnect
+      document.body.appendChild(offlineParent);
+      await aTimeout(0);
+
+      expect(setupSpy.callCount).to.equal(1);
+    });
+
+    it('works with cache directive when reconnected', async () => {
+      class CachingContext extends LitElement {
+        static properties = {
+          switched: { type: Boolean },
+        };
+
+        constructor() {
+          super();
+
+          this.switched = false;
+        }
+
+        get overlayEl() {
+          return this.shadowRoot?.querySelector('#myOverlay');
+        }
+
+        render() {
+          return html`${cache(
+            this.switched
+              ? html`something else`
+              : html`<${tag} id="myOverlay">
+              <div slot="content">content b</div>
+              <button slot="invoker">invoker button b</button>
+            </${tag}>`,
+          )}`;
+        }
+      }
+      const cachingTagName = defineCE(CachingContext);
+      const cachingTag = unsafeStatic(cachingTagName);
+
+      const el = /** @type {CachingContext} */ (
+        await fixture(html`
+        <${cachingTag}></${cachingTag}>
+      `)
+      );
+      // @ts-expect-error [allow-protected] in tests
+      const teardownSpy = sinon.spy(el.overlayEl, '_teardownOverlayCtrl');
+      // @ts-expect-error [allow-protected] in tests
+      const spyDisconnected = sinon.spy(el.overlayEl, '_isPermanentlyDisconnected');
+      // @ts-expect-error [allow-protected] in tests
+      const setupSpy = sinon.spy(el.overlayEl, '_setupOverlayCtrl');
+
+      el.switched = true;
+      // render the new content
+      await el.updateComplete;
+      // wait for the teardown to complete
+      await el.updateComplete;
+
+      expect(spyDisconnected.callCount).to.equal(1);
+      expect(teardownSpy.callCount).to.equal(1);
+      expect(setupSpy.callCount).to.equal(0);
+
+      el.switched = false;
+      await el.updateComplete;
+
+      expect(setupSpy.callCount).to.equal(1);
+    });
   });
 
   describe(`OverlayMixin${suffix} nested`, () => {
@@ -388,6 +515,7 @@ export function runOverlayMixinSuite({ tagString, tag, suffix = '' }) {
         const moveTarget = /** @type {OverlayEl} */ (await fixture('<div id="target"></div>'));
         moveTarget.appendChild(el);
         await el.updateComplete;
+
         expect(getGlobalOverlayCtrls().length).to.equal(1);
       }
     });

diff --git a/packages/ui/components/select-rich/src/LionSelectRich.js b/packages/ui/components/select-rich/src/LionSelectRich.js
@@ -423,6 +423,8 @@ export class LionSelectRich extends SlotMixin(ScopedElementsMixin(OverlayMixin(L
    */
   _teardownOverlayCtrl() {
     super._teardownOverlayCtrl();
+    if (!this._overlayCtrl) return;
+
     this._overlayCtrl.removeEventListener('show', this.__overlayOnShow);
     this._overlayCtrl.removeEventListener('before-show', this.__overlayBeforeShow);
     this._overlayCtrl.removeEventListener('hide', this.__overlayOnHide);
@@ -434,11 +436,12 @@ export class LionSelectRich extends SlotMixin(ScopedElementsMixin(OverlayMixin(L
    * @protected
    */
   async _alignInvokerWidth() {
+    await this.updateComplete;
+
     if (!this._overlayCtrl?.content) {
       return;
     }
 
-    await this.updateComplete;
     const initContentDisplay = this._overlayCtrl.content.style.display;
     const initContentMinWidth = this._overlayCtrl.contentWrapperNode.style.minWidth;
     const initContentWidth = this._overlayCtrl.contentWrapperNode.style.width;