fix(core events): await_pattern_init - check for event coming from correct element.

Check if the init/not-init events were thrown from the Pattern's own
element. When a child element did an unsuccessful Pattern init (rejected
because already initialized) and at the same time the parent element also tried
to initialized the same Pattern await_pattern_init could fail. The not-init
event bubbled up which was incorrectly catched by await_pattern_init on the
parent element.

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

@@ -133,6 +133,35 @@ describe("core.events tests", () => {
             // catched.
             expect(true).toBe(true);
         });
+
+        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 div = document.createElement("div");
+            const span = document.createElement("span");
+            div.append(span);
+
+            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);
+        });
     });
 
     describe("2 - event factories", () => {