@schibsted/pulse-sdk 8.0.0-alpha.9 → 8.0.0-rc.0

package/dist/cjs/EventBus/EventBus.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventBus = createEventBus;
+const loglevel_1 = __importDefault(require("loglevel"));
+function createEventBus(options = {}) {
+    const { domBridge = false, namespace, preventBridgeEcho = true } = options;
+    const listeners = new Map();
+    const lastState = new Map();
+    let addListener = (eventKey, eventHandler) => {
+        let eventHandlersSet = listeners.get(eventKey);
+        if (!eventHandlersSet) {
+            eventHandlersSet = new Set();
+            listeners.set(eventKey, eventHandlersSet);
+        }
+        eventHandlersSet.add(eventHandler);
+        return () => {
+            eventHandlersSet.delete(eventHandler);
+        };
+    };
+    function removeListener(event, fn) {
+        const set = listeners.get(event);
+        if (set)
+            set.delete(fn);
+    }
+    const toDomName = (eventKey) => (namespace ? `${namespace}:${String(eventKey)}` : String(eventKey));
+    let domBridgeCleanup = null;
+    let emitOriginToken = 0;
+    let currentOriginToken = 0;
+    let internalEmit = (event, payload, _fromLocal = false) => {
+        lastState.set(event, payload);
+        const set = listeners.get(event);
+        if (!set || set.size === 0)
+            return;
+        // Execute listeners synchronously, but catch errors so one bad listener doesn’t break others
+        for (const fn of Array.from(set)) {
+            try {
+                // Allow async listeners but don't await
+                void fn(payload);
+            }
+            catch (err) {
+                loglevel_1.default.error('EventBus listener error', err);
+            }
+        }
+    };
+    if (domBridge && typeof window !== 'undefined') {
+        const handler = (event) => {
+            // Only handle CustomEvent
+            if (!(event instanceof CustomEvent))
+                return;
+            const name = event.type;
+            // If echo prevention is on and event has our token, ignore
+            const detail = event.detail;
+            if (preventBridgeEcho && detail && detail.__origin === currentOriginToken)
+                return;
+            // Re-emit into this bus
+            internalEmit(name, detail.payload);
+        };
+        // We attach one listener to the window that handles all names under the namespace.
+        // Because addEventListener doesn't support namespace patterns, we will dynamically
+        // add listeners when we see new events emitted or `on`-registered.
+        const attached = new Set();
+        const ensureDomListener = (eventKey) => {
+            const name = toDomName(eventKey);
+            if (attached.has(name))
+                return;
+            window.addEventListener(name, handler);
+            attached.add(name);
+        };
+        // Hook into addListener/emit to ensure DOM listener exists for those names:
+        const originalAddListener = addListener;
+        addListener = ((eventKey, eventHandler) => {
+            ensureDomListener(eventKey);
+            return originalAddListener(eventKey, eventHandler);
+        });
+        const originalInternalEmit = internalEmit;
+        internalEmit = ((eventKey, payload, fromLocal) => {
+            // Ensure we listen for external sends on the same name
+            ensureDomListener(eventKey);
+            originalInternalEmit(eventKey, payload, fromLocal);
+            // Mirror to DOM if emitted locally
+            if (fromLocal) {
+                currentOriginToken = ++emitOriginToken;
+                const evt = new CustomEvent(toDomName(eventKey), {
+                    detail: { payload, __origin: currentOriginToken },
+                });
+                window.dispatchEvent(evt);
+            }
+        });
+        domBridgeCleanup = () => {
+            attached.forEach((n) => {
+                window.removeEventListener(n, handler);
+            });
+            attached.clear();
+        };
+    }
+    return {
+        on: addListener,
+        once(eventKey, eventHandler) {
+            const off = addListener(eventKey, (p) => {
+                try {
+                    void eventHandler(p);
+                }
+                finally {
+                    off();
+                }
+            });
+            return off;
+        },
+        off: removeListener,
+        emit(eventKey, payload) {
+            internalEmit(eventKey, payload, true);
+        },
+        getState(eventKey) {
+            return lastState.get(eventKey);
+        },
+        onWithState(eventKey, eventHandler) {
+            const off = addListener(eventKey, eventHandler);
+            const lastEventState = lastState.get(eventKey);
+            if (lastEventState !== undefined) {
+                // fire microtask to ensure consistent ordering vs. current call stack
+                queueMicrotask(() => void eventHandler(lastEventState));
+            }
+            return off;
+        },
+        waitFor(eventKey, predicate) {
+            return new Promise((resolve) => {
+                const off = addListener(eventKey, (p) => {
+                    if (!predicate || predicate(p)) {
+                        off();
+                        resolve(p);
+                    }
+                });
+            });
+        },
+        destroy() {
+            listeners.clear();
+            lastState.clear();
+            if (domBridgeCleanup) {
+                domBridgeCleanup();
+            }
+        },
+    };
+}