@streamlayer/sdk-web-analytics 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# sdk-web-analytics
+
+This library was generated with [Nx](https://nx.dev).

package/lib/analytics.d.ts

@@ -0,0 +1,48 @@
+import { MapStore, StreamLayerContext, OnMountCb } from '@streamlayer/sdk-web-interfaces';
+import { Logger } from '@streamlayer/sdk-web-logger';
+import { GamesMessage, NotificationMessage, SendInvitationsMessage, EventOpenedMessage, SendInteractionsMessage, CommonData } from '@streamlayer/sl-eslib/analytics/v2/streaming/streaming_pb';
+import { PlainMessage } from '@bufbuild/protobuf';
+import { InvitationAnalytics } from './invitation';
+import { InteractionsAnalytics } from './interactions';
+import { NotificationsAnalytics } from './notifications';
+import { PollsAnalytics } from './polls';
+import '@streamlayer/sdk-web-features';
+type AnalyticsMessages = {
+    games?: PlainMessage<GamesMessage>;
+    notification?: PlainMessage<NotificationMessage>;
+    invitation?: PlainMessage<SendInvitationsMessage>;
+    eventOpened?: PlainMessage<EventOpenedMessage>;
+    interactions?: PlainMessage<SendInteractionsMessage>;
+    common: PlainMessage<CommonData>;
+};
+export declare const logger: Logger;
+/**
+ * analytics events
+ * 1. start (on start we should send heartbeats, generate session id)
+ * 2. overlay open (on open we should update store, create overlay session id)
+ * 3. overlay close (on close we should update store, remove overlay session id)
+ * 4. switch event
+ * 5. on update screen orientation
+ * 6. on open question we should update topicId, topicType (???parentTopicId, ???topicSubType)
+ * 7. on close question we should clear topicId, topicType
+ */
+export declare class Analytics {
+    readonly commonStore: MapStore<AnalyticsMessages['common']>;
+    readonly notifications: NotificationsAnalytics;
+    readonly polls: PollsAnalytics;
+    readonly invitation: InvitationAnalytics;
+    readonly interactions: InteractionsAnalytics;
+    private heartbeat;
+    private analyticsClient;
+    private listeners;
+    private listenersCancels;
+    private connected;
+    constructor(instance: StreamLayerContext);
+    connect: () => void;
+    disconnect: () => void;
+    write: <T extends "invitation" | "notification" | "interactions" | "games" | "eventOpened" = "invitation" | "notification" | "interactions" | "games" | "eventOpened">(key: T, value: AnalyticsMessages[T]) => void;
+    writeCommon: <T extends "category" | "eventId" | "kind" | "screenOrientation" | "sessionId" | "overlaySessionId" | "topicId" | "topicType" | "parentTopicId" | "parentTopicType" | "participantsCount" | "routeMap" | "trackTimestamp" | "topicSubType" | "country" = "category" | "eventId" | "kind" | "screenOrientation" | "sessionId" | "overlaySessionId" | "topicId" | "topicType" | "parentTopicId" | "parentTopicType" | "participantsCount" | "routeMap" | "trackTimestamp" | "topicSubType" | "country">(key: T, value: PlainMessage<CommonData>[T]) => void;
+    onConnect: (cb: OnMountCb) => void;
+    private connectToSDK;
+}
+export {};

package/lib/analytics.js

@@ -0,0 +1,121 @@
+import { createMapStore, MapStore } from '@streamlayer/sdk-web-interfaces';
+import { FeatureType } from '@streamlayer/sdk-web-types';
+import { createLogger } from '@streamlayer/sdk-web-logger';
+import { nanoid } from 'nanoid';
+import { ScreenOrientation } from '@streamlayer/sl-eslib/analytics/v1/common/analytics.common_pb';
+import { AnalyticsService } from '@streamlayer/sl-eslib/analytics/v2/streaming/streaming_connect';
+import { InvitationAnalytics } from './invitation';
+import { InteractionsAnalytics } from './interactions';
+import { NotificationsAnalytics } from './notifications';
+import { PollsAnalytics } from './polls';
+import { heartbeat } from './heartbeat';
+import { CATEGORY_TYPE_MAP } from './constants';
+import '@streamlayer/sdk-web-features';
+export const logger = createLogger('analytics');
+// analytics events
+/**
+ * analytics events
+ * 1. start (on start we should send heartbeats, generate session id)
+ * 2. overlay open (on open we should update store, create overlay session id)
+ * 3. overlay close (on close we should update store, remove overlay session id)
+ * 4. switch event
+ * 5. on update screen orientation
+ * 6. on open question we should update topicId, topicType (???parentTopicId, ???topicSubType)
+ * 7. on close question we should clear topicId, topicType
+ */
+export class Analytics {
+    commonStore;
+    notifications;
+    polls;
+    invitation;
+    interactions;
+    heartbeat;
+    analyticsClient;
+    listeners;
+    listenersCancels;
+    connected = false;
+    constructor(instance) {
+        this.listeners = new Set();
+        this.listenersCancels = new Set();
+        this.commonStore = new MapStore(createMapStore({}), 'common-analytics');
+        this.connectToSDK(instance);
+        this.heartbeat = heartbeat({ transport: instance.analyticsTransport, $commonStore: this.commonStore });
+        this.notifications = new NotificationsAnalytics(this);
+        this.polls = new PollsAnalytics(this);
+        this.invitation = new InvitationAnalytics(this);
+        this.interactions = new InteractionsAnalytics(this);
+        const { client } = instance.analyticsTransport.createPromiseClient(AnalyticsService, {
+            method: 'send',
+        });
+        this.analyticsClient = client;
+    }
+    connect = () => {
+        this.writeCommon('sessionId', nanoid());
+        this.heartbeat.enable();
+        this.listeners.forEach((cb) => this.listenersCancels.add(cb()));
+        this.connected = true;
+        logger.debug('analytics connected');
+    };
+    disconnect = () => {
+        this.writeCommon('sessionId', '');
+        this.writeCommon('overlaySessionId', '');
+        this.heartbeat.unmount();
+        this.listenersCancels.forEach((cancel) => cancel());
+        this.connected = false;
+        logger.debug('analytics disconnected');
+    };
+    write = (key, value) => {
+        if (value) {
+            this.analyticsClient
+                .unary({ message: { case: key, value } })
+                .then(() => {
+                logger.trace('send analytics success', key, value);
+            })
+                .catch((e) => {
+                logger.error(e, 'send analytics failed');
+            });
+        }
+    };
+    writeCommon = (key, value) => {
+        this.commonStore.setValue(key, value);
+    };
+    // calls the cb when connected/reconnected, callbacks return a cancel function to be called when disconnected
+    onConnect = (cb) => {
+        this.listeners.add(cb);
+        // if already connected, call the cb
+        if (this.connected) {
+            this.listenersCancels.add(cb());
+        }
+    };
+    connectToSDK = (instance) => {
+        this.onConnect(() => instance.stores.slStreamId.getAtomStore().subscribe((eventId) => {
+            this.writeCommon('eventId', eventId);
+        }));
+        this.onConnect(() => instance.sdk.getActiveFeature().subscribe((feature) => {
+            if (feature) {
+                this.writeCommon('category', CATEGORY_TYPE_MAP[feature]);
+            }
+            if (feature !== FeatureType.UNSET) {
+                this.writeCommon('overlaySessionId', nanoid());
+            }
+            else {
+                this.writeCommon('overlaySessionId', '');
+            }
+        }));
+        this.onConnect(() => {
+            const mediaQuery = window.matchMedia('(orientation: portrait)');
+            const handleOrientationChange = (e) => {
+                this.writeCommon('screenOrientation', e.matches ? ScreenOrientation.PORTRAIT : ScreenOrientation.LANDSCAPE);
+            };
+            mediaQuery.addEventListener('change', handleOrientationChange);
+            return () => {
+                mediaQuery.removeEventListener('change', handleOrientationChange);
+            };
+        });
+        this.onConnect(() => instance.deepLink.$store.subscribe((deepLink) => {
+            if (deepLink?.handled) {
+                this.invitation.accepted();
+            }
+        }));
+    };
+}

package/lib/constants.d.ts

@@ -0,0 +1,45 @@
+import { TopicType, Category } from '@streamlayer/sl-eslib/analytics/v1/common/analytics.common_pb';
+import { NotificationKind } from '@streamlayer/sl-eslib/analytics/v1/notifications/notifications_pb';
+export declare const AllowedCases: {
+    games: string;
+    notification: string;
+    invitation: string;
+    eventOpened: string;
+    interactions: string;
+};
+export declare const TOPIC_TYPE_MAP: {
+    0: TopicType;
+    4: TopicType;
+    1: TopicType;
+    3: TopicType;
+    6: TopicType;
+    2: TopicType;
+    5: TopicType;
+};
+export declare const QUESTION_NOTIFICATION_KIND_MAP: {
+    0: NotificationKind;
+    4: NotificationKind;
+    1: NotificationKind;
+    3: NotificationKind;
+    6: NotificationKind;
+    2: NotificationKind;
+    5: NotificationKind;
+};
+export declare const CATEGORY_TYPE_MAP: {
+    0: Category;
+    1: Category;
+    2: Category;
+    3: Category;
+    4: Category;
+    5: Category;
+    6: Category;
+    7: Category;
+    8: Category;
+    9: Category;
+    10: Category;
+    11: Category;
+    12: Category;
+    13: Category;
+    14: Category;
+    15: Category;
+};

package/lib/constants.js

@@ -0,0 +1,46 @@
+import { QuestionType, FeatureType } from '@streamlayer/sdk-web-types';
+import { TopicType, Category } from '@streamlayer/sl-eslib/analytics/v1/common/analytics.common_pb';
+import { NotificationKind } from '@streamlayer/sl-eslib/analytics/v1/notifications/notifications_pb';
+export const AllowedCases = {
+    games: 'games',
+    notification: 'notification',
+    invitation: 'invitation',
+    eventOpened: 'eventOpened',
+    interactions: 'interactions',
+};
+export const TOPIC_TYPE_MAP = {
+    [QuestionType.UNSET]: TopicType.UNSET,
+    [QuestionType.FACTOID]: TopicType.POLLS_INSIGHT,
+    [QuestionType.POLL]: TopicType.POLLS_POLL,
+    [QuestionType.PREDICTION]: TopicType.POLLS_PREDICTION,
+    [QuestionType.PROMOTION]: TopicType.POLLS_PROMOTION,
+    [QuestionType.TRIVIA]: TopicType.POLLS_TRIVIA,
+    [QuestionType.TWEET]: TopicType.POLLS_TWITTER,
+};
+export const QUESTION_NOTIFICATION_KIND_MAP = {
+    [QuestionType.UNSET]: NotificationKind.UNSET,
+    [QuestionType.FACTOID]: NotificationKind.POLLS,
+    [QuestionType.POLL]: NotificationKind.POLLS,
+    [QuestionType.PREDICTION]: NotificationKind.POLLS,
+    [QuestionType.PROMOTION]: NotificationKind.POLLS,
+    [QuestionType.TRIVIA]: NotificationKind.POLLS,
+    [QuestionType.TWEET]: NotificationKind.POLLS,
+};
+export const CATEGORY_TYPE_MAP = {
+    [FeatureType.UNSET]: Category.UNSET,
+    [FeatureType.INPLAY]: Category.INPLAY,
+    [FeatureType.MESSAGING]: Category.MESSAGING,
+    [FeatureType.STATISTICS]: Category.STATS,
+    [FeatureType.BETTING]: Category.BETTING,
+    [FeatureType.TWITTER]: Category.TWITTER,
+    [FeatureType.MERCHANDISE]: Category.MERCHANDISE,
+    [FeatureType.CONTESTS]: Category.CONTESTS,
+    [FeatureType.VOICE_CHAT]: Category.CALLING,
+    [FeatureType.TICKETS]: Category.TICKETS,
+    [FeatureType.WHOIS_WATCHING]: Category.WHOISWATCHING,
+    [FeatureType.PROFILE]: Category.PROFILE,
+    [FeatureType.GAMES]: Category.POLLS, // ??
+    [FeatureType.GOLF_STATISTICS]: Category.STATS, // ??
+    [FeatureType.HIGHLIGHTS]: Category.HIGHLIGHTS,
+    [FeatureType.PUBLIC_CHAT]: Category.PUBLIC_CHAT,
+};

package/lib/heartbeat.d.ts

@@ -0,0 +1,13 @@
+import { Transport } from '@streamlayer/sdk-web-api';
+import { Analytics } from './analytics';
+type IHeartbeat = {
+    transport: Transport;
+    $commonStore: Analytics['commonStore'];
+};
+export declare const heartbeat: ({ transport, $commonStore }: IHeartbeat) => {
+    enable: () => void;
+    disable: () => void;
+    mount: () => void;
+    unmount: () => void;
+};
+export {};

package/lib/heartbeat.js

@@ -0,0 +1,59 @@
+import { createSingleStore } from '@streamlayer/sdk-web-interfaces';
+import { AnalyticsService } from '@streamlayer/sl-eslib/analytics/v2/streaming/streaming_connect';
+import { Kind } from '@streamlayer/sl-eslib/analytics/v1/common/analytics.common_pb';
+import { logger } from './analytics';
+export const heartbeat = ({ transport, $commonStore }) => {
+    let cancelFn = undefined;
+    const enabled = createSingleStore(false);
+    const refetchInterval = 5000;
+    const { client, queryKey } = transport.createPromiseClient(AnalyticsService, {
+        method: 'send',
+        params: [enabled],
+    });
+    const $api = transport.nanoquery.createFetcherStore(queryKey, {
+        fetcher: async () => {
+            const common = $commonStore.getStore().get();
+            try {
+                await client.unary({
+                    message: {
+                        case: 'heartbeat',
+                        value: {
+                            common: {
+                                ...common,
+                                kind: Kind.SESSION_HEARTBEAT,
+                            },
+                        },
+                    },
+                });
+            }
+            catch (e) {
+                logger.error(e, 'send heartbeat failed');
+            }
+            return Date.now();
+        },
+        refetchInterval,
+    });
+    const mount = () => {
+        logger.debug('mounted heartbeat');
+        cancelFn = $api.subscribe(() => { });
+    };
+    const enable = () => {
+        logger.debug('enabled heartbeat');
+        enabled.set(true);
+        if ($api.lc === 0) {
+            mount();
+        }
+    };
+    const disable = () => {
+        logger.debug('disabled heartbeat');
+        enabled.set(false);
+    };
+    const unmount = () => {
+        logger.debug('unmounted heartbeat');
+        $api.off();
+        cancelFn?.();
+        cancelFn = undefined;
+        disable();
+    };
+    return { enable, disable, mount, unmount };
+};

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+import { type StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
+import type { DeepLinkContext } from '@streamlayer/sdk-web-core';
+import { Transport } from '@streamlayer/sdk-web-api';
+import { Analytics } from './analytics';
+declare module '@streamlayer/sdk-web-interfaces' {
+    interface StreamLayerContext {
+        analytics: Analytics;
+        deepLink: DeepLinkContext;
+        analyticsTransport: Transport;
+    }
+}
+export declare const analytics: (instance: StreamLayerContext, opts: unknown, done: Function) => void;

package/lib/index.js

@@ -0,0 +1,11 @@
+import { Analytics } from './analytics';
+export const analytics = (instance, opts, done) => {
+    instance.analytics = new Analytics(instance);
+    instance.sdk.onMount(() => {
+        instance.analytics.connect();
+        return () => {
+            instance.analytics.disconnect();
+        };
+    });
+    done();
+};

package/lib/interactions.d.ts

@@ -0,0 +1,7 @@
+import { Analytics } from './analytics';
+export declare class InteractionsAnalytics {
+    private analytics;
+    constructor(analytics: Analytics);
+    tap: () => void;
+    scroll: () => void;
+}

package/lib/interactions.js

@@ -0,0 +1,42 @@
+import { eventBus } from '@streamlayer/sdk-web-interfaces';
+import { InteractionActionType } from '@streamlayer/sl-eslib/analytics/v1/interactions/interactions_pb';
+import { Kind } from '@streamlayer/sl-eslib/analytics/v1/common/analytics.common_pb';
+export class InteractionsAnalytics {
+    analytics;
+    constructor(analytics) {
+        this.analytics = analytics;
+        this.analytics.onConnect(() => {
+            const listener = (event) => {
+                if (event.slEventBus?.type === 'interactions') {
+                    switch (event.slEventBus.action) {
+                        case 'tap':
+                            this.tap();
+                            break;
+                        case 'scroll':
+                            this.scroll();
+                            break;
+                    }
+                }
+            };
+            return eventBus.listen(listener);
+        });
+    }
+    tap = () => {
+        this.analytics.write('interactions', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.INTERACTIONS,
+            },
+            actionType: InteractionActionType.TAP,
+        });
+    };
+    scroll = () => {
+        this.analytics.write('interactions', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.INTERACTIONS,
+            },
+            actionType: InteractionActionType.SCROLL,
+        });
+    };
+}

package/lib/invitation.d.ts

@@ -0,0 +1,10 @@
+import { InvitationFrom } from '@streamlayer/sl-eslib/analytics/v1/invitations/invitations_pb';
+import { Analytics } from './analytics';
+export declare class InvitationAnalytics {
+    private analytics;
+    constructor(analytics: Analytics);
+    accepted: () => void;
+    sent: ({ from }: {
+        from?: InvitationFrom | undefined;
+    }) => void;
+}

package/lib/invitation.js

@@ -0,0 +1,41 @@
+import { eventBus } from '@streamlayer/sdk-web-interfaces';
+import { Kind } from '@streamlayer/sl-eslib/analytics/v1/common/analytics.common_pb';
+import { InvitationCategory, InvitationFrom } from '@streamlayer/sl-eslib/analytics/v1/invitations/invitations_pb';
+export class InvitationAnalytics {
+    analytics;
+    constructor(analytics) {
+        this.analytics = analytics;
+        this.analytics.onConnect(() => {
+            const listener = (event) => {
+                if (event.slEventBus?.type === 'invitation') {
+                    switch (event.slEventBus.action) {
+                        case 'sent':
+                            this.sent(event.slEventBus.payload);
+                            break;
+                    }
+                }
+            };
+            return eventBus.listen(listener);
+        });
+    }
+    accepted = () => {
+        this.analytics.write('invitation', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.INVITATION_ACCEPTED,
+            },
+            category: InvitationCategory.GAMES,
+            from: InvitationFrom.UNSET,
+        });
+    };
+    sent = ({ from }) => {
+        this.analytics.write('invitation', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.INVITATION_SENT,
+            },
+            category: InvitationCategory.GAMES,
+            from: from ? from : InvitationFrom.UNSET,
+        });
+    };
+}

package/lib/notifications.d.ts

@@ -0,0 +1,7 @@
+import { Analytics } from './analytics';
+export declare class NotificationsAnalytics {
+    private analytics;
+    constructor(analytics: Analytics);
+    private received;
+    private opened;
+}

package/lib/notifications.js

@@ -0,0 +1,49 @@
+import { eventBus } from '@streamlayer/sdk-web-interfaces';
+import { Kind, TopicType } from '@streamlayer/sl-eslib/analytics/v1/common/analytics.common_pb';
+import { NotificationKind, NotificationType } from '@streamlayer/sl-eslib/analytics/v1/notifications/notifications_pb';
+import { TOPIC_TYPE_MAP } from './constants';
+export class NotificationsAnalytics {
+    analytics;
+    constructor(analytics) {
+        this.analytics = analytics;
+        this.analytics.onConnect(() => {
+            const listener = (event) => {
+                if (event.slEventBus?.type === 'notification') {
+                    switch (event.slEventBus.action) {
+                        case 'rendered':
+                            this.received(event.slEventBus.payload);
+                            break;
+                        case 'opened':
+                            this.opened(event.slEventBus.payload);
+                            break;
+                    }
+                }
+            };
+            return eventBus.listen(listener);
+        });
+    }
+    received = ({ questionId, questionType }) => {
+        this.analytics.write('notification', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.NOTIFICATION_RECEIVED,
+                topicId: questionId,
+                topicType: questionType ? TOPIC_TYPE_MAP[questionType] : TopicType.UNSET,
+            },
+            notificationKind: NotificationKind.POLLS,
+            notificationType: NotificationType.IN_APP,
+        });
+    };
+    opened = ({ questionId, questionType }) => {
+        this.analytics.write('notification', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.NOTIFICATION_OPENED,
+                topicId: questionId,
+                topicType: questionType ? TOPIC_TYPE_MAP[questionType] : TopicType.UNSET,
+            },
+            notificationKind: NotificationKind.POLLS,
+            notificationType: NotificationType.IN_APP,
+        });
+    };
+}

package/lib/polls.d.ts

@@ -0,0 +1,25 @@
+import { QuestionType } from '@streamlayer/sdk-web-types';
+import { Analytics } from './analytics';
+/**
+ * PollsAnalytics is a class that is used to send analytics events related to polls.
+ * It is used to send events when a poll is received, opened, voted, onboarding passed, or navigated.
+ */
+export declare class PollsAnalytics {
+    private analytics;
+    constructor(analytics: Analytics);
+    received: ({ questionId, questionType }: {
+        questionId?: string | undefined;
+        questionType?: QuestionType | undefined;
+    }) => void;
+    opened: ({ questionId, questionType, questionOpenedFrom, }: {
+        questionId?: string | undefined;
+        questionType?: QuestionType | undefined;
+        questionOpenedFrom?: "notification" | "list" | undefined;
+    }) => void;
+    voted: ({ questionId, questionType }: {
+        questionId?: string | undefined;
+        questionType?: QuestionType | undefined;
+    }) => void;
+    onboardingPassed: () => void;
+    navigated: () => void;
+}

package/lib/polls.js

@@ -0,0 +1,93 @@
+import { eventBus } from '@streamlayer/sdk-web-interfaces';
+import { Kind, PollOpenedFrom, TopicType } from '@streamlayer/sl-eslib/analytics/v1/common/analytics.common_pb';
+import { TOPIC_TYPE_MAP } from './constants';
+/**
+ * PollsAnalytics is a class that is used to send analytics events related to polls.
+ * It is used to send events when a poll is received, opened, voted, onboarding passed, or navigated.
+ */
+export class PollsAnalytics {
+    analytics;
+    constructor(analytics) {
+        this.analytics = analytics;
+        this.analytics.onConnect(() => {
+            const listener = (event) => {
+                if (event.slEventBus?.type === 'poll') {
+                    switch (event.slEventBus.action) {
+                        case 'voted':
+                            this.voted(event.slEventBus.payload);
+                            break;
+                        case 'navigated':
+                            this.navigated();
+                            break;
+                        case 'onboardingPassed':
+                            this.onboardingPassed();
+                            break;
+                        case 'received':
+                            this.received(event.slEventBus.payload);
+                            break;
+                        case 'opened':
+                            this.opened(event.slEventBus.payload);
+                            break;
+                    }
+                }
+            };
+            return eventBus.listen(listener);
+        });
+    }
+    // event when a poll is received from subscription or active question request
+    received = ({ questionId, questionType }) => {
+        this.analytics.write('games', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.POLLS_RECEIVED,
+                topicId: questionId,
+                topicType: questionType ? TOPIC_TYPE_MAP[questionType] : TopicType.UNSET,
+            },
+            pollOpenedFrom: PollOpenedFrom.UNSET,
+        });
+    };
+    // poll is opened from notification or list
+    opened = ({ questionId, questionType, questionOpenedFrom, }) => {
+        this.analytics.write('games', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.POLLS_OPENED,
+                topicId: questionId,
+                topicType: questionType ? TOPIC_TYPE_MAP[questionType] : TopicType.UNSET,
+            },
+            pollOpenedFrom: questionOpenedFrom === 'list' ? PollOpenedFrom.PICK_HISTORY : PollOpenedFrom.IN_APP,
+        });
+    };
+    // poll is voted
+    voted = ({ questionId, questionType }) => {
+        this.analytics.write('games', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.POLLS_VOTE,
+                topicId: questionId,
+                topicType: questionType ? TOPIC_TYPE_MAP[questionType] : TopicType.UNSET,
+            },
+            pollOpenedFrom: PollOpenedFrom.UNSET,
+        });
+    };
+    // onboarding passed, user is now able to vote
+    onboardingPassed = () => {
+        this.analytics.write('games', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.GAMES_JOINED,
+            },
+            pollOpenedFrom: PollOpenedFrom.UNSET,
+        });
+    };
+    // user clicked on link in poll and navigated to another page
+    navigated = () => {
+        this.analytics.write('games', {
+            common: {
+                ...this.analytics.commonStore.getValues(),
+                kind: Kind.POLLS_NAVIGATED,
+            },
+            pollOpenedFrom: PollOpenedFrom.UNSET,
+        });
+    };
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@streamlayer/sdk-web-analytics",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./lib/index.js",
+  "typings": "./lib/index.d.ts",
+  "files": [
+    "lib/",
+    "package.json"
+  ],
+  "peerDependencies": {
+    "@bufbuild/protobuf": "^1.7.2",
+    "@connectrpc/connect": "^1.3.0",
+    "nanoid": "3.3.7",
+    "@streamlayer/sl-eslib": "^5.83.1",
+    "@streamlayer/sdk-web-api": "^0.24.0",
+    "@streamlayer/sdk-web-interfaces": "^0.21.0",
+    "@streamlayer/sdk-web-logger": "^0.5.18",
+    "@streamlayer/sdk-web-features": "^0.11.24",
+    "@streamlayer/sdk-web-core": "^0.22.0",
+    "@streamlayer/feature-gamification": "^0.39.0"
+  },
+  "exports": {
+    ".": {
+      "module": "./lib/index.js",
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  }
+}