@streamlayer/sdk-web-interfaces 0.20.6 → 0.21.0

package/lib/event-bus/index.d.ts

@@ -0,0 +1,61 @@
+import { InvitationFrom, QuestionType } from '@streamlayer/sdk-web-types';
+declare const EventBusActions: {
+    notification: {
+        received: string;
+        opened: string;
+        rendered: string;
+        closed: string;
+    };
+    invitation: {
+        accepted: string;
+        sent: string;
+    };
+    interactions: {
+        tap: string;
+        scroll: string;
+    };
+    poll: {
+        voted: string;
+        navigated: string;
+        opened: string;
+        received: string;
+        onboardingPassed: string;
+    };
+};
+export type EventBusActionPayload = {
+    notification: {
+        eventId?: string;
+        questionId?: string;
+        questionType?: QuestionType;
+    };
+    invitation: {
+        from?: InvitationFrom;
+    };
+    interactions: unknown;
+    poll: {
+        questionId?: string;
+        questionType?: QuestionType;
+        questionOpenedFrom?: 'list' | 'notification';
+    };
+};
+type EventBusActionsKeys = keyof typeof EventBusActions;
+type EventBusActions<T> = T extends EventBusActionsKeys ? keyof (typeof EventBusActions)[T] : never;
+export type EventBusData<T extends EventBusActionsKeys = EventBusActionsKeys> = {
+    type: T;
+    action: EventBusActions<T>;
+    payload: EventBusActionPayload[T];
+};
+export declare class EventBusEvent<T extends EventBusActionsKeys = EventBusActionsKeys> extends Event {
+    slEventBus?: EventBusData<T>;
+    constructor(name: string, payload?: EventBusData<T>);
+}
+export declare class EventBus {
+    private name;
+    private listeners;
+    constructor(name?: string);
+    emit: <K extends "notification" | "invitation" | "interactions" | "poll" = "notification" | "invitation" | "interactions" | "poll">(type: K, payload: Omit<EventBusData<K>, "type">) => void;
+    listen<T extends EventBusActionsKeys>(listener: (event: EventBusEvent<T>) => void): () => void;
+    off<T extends EventBusActionsKeys>(listener: (event: EventBusEvent<T>) => void): void;
+    destroy: () => void;
+}
+export {};

package/lib/event-bus/index.js

@@ -0,0 +1,63 @@
+import { createLogger } from '@streamlayer/sdk-web-logger';
+const EventBusActions = {
+    notification: {
+        received: 'received',
+        opened: 'opened',
+        rendered: 'rendered',
+        closed: 'closed',
+    },
+    invitation: {
+        accepted: 'accepted',
+        sent: 'sent',
+    },
+    interactions: {
+        tap: 'tap',
+        scroll: 'scroll',
+    },
+    poll: {
+        voted: 'voted',
+        navigated: 'navigated',
+        opened: 'opened',
+        received: 'received',
+        onboardingPassed: 'onboardingPassed',
+    },
+};
+export class EventBusEvent extends Event {
+    slEventBus;
+    constructor(name, payload) {
+        super(name);
+        this.slEventBus = payload;
+    }
+}
+const logger = createLogger('event-bus');
+export class EventBus {
+    name;
+    listeners;
+    constructor(name = 'sl-event-bus') {
+        this.name = name;
+        this.listeners = new Set();
+    }
+    emit = (type, payload) => {
+        const event = new EventBusEvent(this.name, { ...payload, type });
+        logger.debug(event, 'Emitting event');
+        window.dispatchEvent(event);
+    };
+    listen(listener) {
+        window.addEventListener(this.name, listener);
+        this.listeners.add(listener);
+        return () => {
+            this.off(listener);
+        };
+    }
+    off(listener) {
+        window.removeEventListener(this.name, listener);
+        this.listeners.delete(listener);
+    }
+    destroy = () => {
+        this.listeners.forEach((listener) => {
+            window.removeEventListener(this.name, listener);
+            this.listeners.delete(listener);
+        });
+        this.listeners.clear();
+    };
+}

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 import { FeatureType } from '@streamlayer/sdk-web-types';
+import { EventBus, EventBusEvent, EventBusData, EventBusActionPayload } from './event-bus';
 export { AbstractAuthenticationProvider } from './auth';
 export { AbstractFeature, FeatureSource, type FeatureProps, FeatureStatus } from './feature';
 export { MapStore, createMapStore } from './store/map';
@@ -6,7 +7,10 @@ export type { MapStoreListeners } from './store/map';
 export { SingleStore, createSingleStore, createComputedStore } from './store/single';
 export { AbstractStore, mergeStores } from './store/abstract';
 export { ApiStore } from './store/api';
+export type CancelMountCb = () => void;
+export type OnMountCb = () => CancelMountCb;
 export interface StreamLayerSDK {
+    onMount: (cb: OnMountCb) => void;
     closeFeature: (destroy?: boolean) => void;
     openFeature: (featureType: FeatureType) => void;
 }
@@ -15,3 +19,5 @@ export interface StreamLayerContext {
 }
 type DoneFn = Function;
 export type StreamLayerPlugin = (instance: StreamLayerContext, opts: unknown, done: DoneFn) => void;
+export declare const eventBus: EventBus;
+export type { EventBusEvent, EventBusData, EventBusActionPayload };

package/lib/index.js

@@ -1,6 +1,8 @@
+import { EventBus } from './event-bus';
 export { AbstractAuthenticationProvider } from './auth';
 export { AbstractFeature, FeatureSource, FeatureStatus } from './feature';
 export { MapStore, createMapStore } from './store/map';
 export { SingleStore, createSingleStore, createComputedStore } from './store/single';
 export { AbstractStore, mergeStores } from './store/abstract';
 export { ApiStore } from './store/api';
+export const eventBus = new EventBus();

package/lib/store/abstract.d.ts

@@ -1,4 +1,4 @@
-import type { AnyStore } from 'nanostores';
+import { type AnyStore } from 'nanostores';
 declare global {
     interface Window {
         slStore: any;

package/lib/store/abstract.js

@@ -1,54 +1,5 @@
 import { computed } from 'nanostores';
-import { buildLogger } from '@nanostores/logger';
-import diff from 'microdiff';
 window.slStore = Object.create(null);
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const slStoreLogger = (store, name) => buildLogger(store, name, {
-    mount: ({ storeName }) => {
-        if (!window.slStore[storeName]) {
-            window.slStore[storeName] = { mounted: true, history: [{ type: 'mount' }] };
-        }
-        window.slStore[storeName].store = store;
-    },
-    unmount: ({ storeName }) => {
-        window.slStore[storeName].mounted = false;
-        window.slStore[storeName]?.history.push({ type: 'unmount' });
-    },
-    change: ({ actionName, storeName, changed, newValue, oldValue, valueMessage }) => {
-        window.slStore[storeName]?.history.push({
-            type: 'change',
-            changed,
-            newValue,
-            oldValue,
-            diff: diff({ ...oldValue }, { ...newValue }, { cyclesFix: false }),
-            actionName,
-            valueMessage,
-        });
-    },
-    action: {
-        start: ({ actionName, args, storeName }) => {
-            window.slStore[storeName]?.history.push({
-                type: 'action:start',
-                actionName,
-                args,
-                storeName,
-            });
-        },
-        error: ({ actionName, error, storeName }) => {
-            window.slStore[storeName]?.history.push({
-                type: 'action:error',
-                actionName,
-                error,
-            });
-        },
-        end: ({ actionName, storeName }) => {
-            window.slStore[storeName]?.history.push({
-                type: 'action:end',
-                actionName,
-            });
-        },
-    },
-});
 /**
  * An abstract store is a wrapper for third-party stores,
  * providing developers with a consistent interface inspired

package/lib/store/map.d.ts

@@ -1,4 +1,4 @@
-import type { MapStoreKeys, MapStore as NMapStore } from 'nanostores';
+import { type MapStoreKeys, type MapStore as NMapStore } from 'nanostores';
 import { AbstractStore } from './abstract';
 /**
  * Wrapper for nanostores MapStore

package/lib/store/single.d.ts

@@ -1,4 +1,4 @@
-import type { StoreValue, WritableAtom } from 'nanostores';
+import { type StoreValue, type WritableAtom } from 'nanostores';
 import { AbstractStore } from './abstract';
 /**
  * Wrapper for nanostores WritableAtom

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamlayer/sdk-web-interfaces",
-  "version": "0.20.6",
+  "version": "0.21.0",
   "type": "module",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
@@ -17,11 +17,10 @@
   },
   "peerDependencies": {
     "@bufbuild/protobuf": "^1.7.2",
-    "@nanostores/logger": "^0.2.4",
-    "@nanostores/query": "^0.2.8",
-    "microdiff": "^1.3.2",
-    "nanostores": "^0.9.5",
-    "@streamlayer/sdk-web-types": "^0.22.4"
+    "@nanostores/query": "^0.2.10",
+    "nanostores": "^0.10.0",
+    "@streamlayer/sdk-web-logger": "^0.5.18",
+    "@streamlayer/sdk-web-types": "^0.23.0"
   },
   "devDependencies": {
     "tslib": "^2.6.2"