Merge pull request #1136 from Patternslib/fix-await-pattern-init

Fix await pattern init

Author: thet

src/core/events.js

@@ -102,7 +102,13 @@ const await_pattern_init = (pattern) => {
     // See: https://stackoverflow.com/a/44746691/1337474
     return new Promise((resolve, reject) => {
         // Case initialized
-        pattern.one("init", () => {
+        pattern.one("init", (e) => {
+            if (e.target !== pattern.el) {
+                // Don't handle bubbling init events from child elements. We
+                // want to check on init events coming directly from this
+                // Pattern's element.
+                return;
+            }
             // Resolve promise and unregister the not-init event handler.
             remove_event_listener(
                 pattern.el,
@@ -112,7 +118,13 @@ const await_pattern_init = (pattern) => {
         });
 
         // Case not initialized
-        pattern.one("not-init", () => {
+        pattern.one("not-init", (e) => {
+            if (e.target !== pattern.el) {
+                // Don't handle bubbling not-init events from child elements.
+                // We want to check on not-init events coming directly from
+                // this Pattern's element.
+                return;
+            }
             // Reject promise and unregister the init event handler.
             remove_event_listener(
                 pattern.el,

src/core/events.test.js

@@ -134,17 +134,30 @@ describe("core.events tests", () => {
             expect(true).toBe(true);
         });
 
-        it("Handles double-registration attempts by rejecting the await_pattern_init promise.", async () => {
+        it("Allows to initialize the same pattern in a nested structure.", async () => {
             class Pat extends BasePattern {
                 static name = "tmp";
                 static trigger = ".pat-tmp";
                 init() {}
             }
 
-            const el = document.createElement("div");
-            const instance = new Pat(el);
+            const div = document.createElement("div");
+            const span = document.createElement("span");
+            div.append(span);
 
-            await events.await_pattern_init(instance);
+            new Pat(span);
+            // need to wait a tick as basepattern initializes also with a
+            // tick delay.
+            await utils.timeout(1);
+
+            // Next one isn't initialized and throws an bubbling not-init error.
+            new Pat(span);
+            const instance_div = new Pat(div);
+
+            // The bubbling not-init error would be catched if there wasn't a
+            // check for the origin of the error which has to be the same as
+            // the Pattern element.
+            await events.await_pattern_init(instance_div);
 
             // If test reaches this expect statement, all is fine.
             expect(true).toBe(true);

src/core/utils.test.js

@@ -625,6 +625,9 @@ describe("debounce ...", function () {
         debouncer();
         expect(test_func).not.toHaveBeenCalled();
         await utils.timeout(1);
+        await utils.timeout(1);
+        await utils.timeout(1);
+        await utils.timeout(1);
         expect(test_func).toHaveBeenCalledTimes(1);
     });
     it("incorrect usage by multi instantiation won't cancel previous runs", async () => {