@streamlayer/feature-gamification 1.14.1 → 1.15.1

package/lib/background.d.ts

@@ -6,6 +6,7 @@ import { ReadableAtom, WritableAtom } from 'nanostores';
 import * as queries from './queries';
 import { detail } from './detail';
 import { advertisement } from './advertisement';
+import { GamificationStorage } from './storage';
 export declare enum InteractiveAllowed {
     ALLOWED = "allowed",
     DISALLOWED = "disallowed"
@@ -47,6 +48,7 @@ export declare class GamificationBackground {
     /** subscription to opened question (vote percentage) */
     questionSubscription?: ReturnType<typeof queries.questionSubscription>;
     advertisement: ReturnType<typeof advertisement>;
+    storage: GamificationStorage;
     private notifications;
     private log;
     private transport;

package/lib/background.js

@@ -5,6 +5,7 @@ import '@streamlayer/sdk-web-core/store';
 import * as queries from './queries';
 import { detail } from './detail';
 import { advertisement } from './advertisement';
+import { GamificationStorage } from './storage';
 export var InteractiveAllowed;
 (function (InteractiveAllowed) {
     InteractiveAllowed["ALLOWED"] = "allowed";
@@ -42,6 +43,7 @@ export class GamificationBackground {
     /** subscription to opened question (vote percentage) */
     questionSubscription;
     advertisement;
+    storage;
     notifications;
     log;
     transport;
@@ -49,6 +51,7 @@ export class GamificationBackground {
     constructor(instance) {
         this.transport = instance.transport;
         this.log = createLogger('gamification-background');
+        this.storage = new GamificationStorage();
         this.slStreamId = instance.stores.slStreamId.getAtomStore();
         this.organizationId = instance.stores.organizationSettings.getAtomStore();
         this.userId = instance.stores.user.getAtomStore();
@@ -58,15 +61,34 @@ export class GamificationBackground {
         this.notifications = instance.notifications;
         this.moderation = new ApiStore(queries.$moderation(this.slStreamId, instance.transport), 'gamification:moderation');
         this.feedList = new ApiStore(queries.$feedList(this.slStreamId, this.interactiveAllowed, instance.transport), 'gamification:feedList');
-        this.betPack = new ApiStore(queries.$betPack(this.slStreamId, instance.transport), 'gamification:betPack');
+        this.betPack = new ApiStore(queries.$betPack(this.slStreamId, this.userId, this.organizationId, this.storage, instance.transport), 'gamification:betPack');
         this.activeQuestionId = queries.$activeQuestion(this.slStreamId, instance.transport);
         this.openedQuestion = detail(instance.transport, this.openedQuestionId, this.feedList.getStore());
         this.cancels.add(this.openedQuestionId.listen((item) => {
             this.log.debug({ item }, 'received question');
             if (item?.questionId) {
                 this.questionSubscription = queries.questionSubscription(item.questionId, instance.transport);
-                this.questionSubscription.addListener('feed-subscription-opened-question', (response) => {
-                    this.openedQuestion.updateExtendedQuestion(response.data?.attributes?.question);
+                this.questionSubscription.addListener('feed-subscription-opened-question', async (response) => {
+                    const question = response.data?.attributes?.question;
+                    this.openedQuestion.updateExtendedQuestion(question);
+                    if (question?.type === QuestionType.PREDICTION) {
+                        const betPackData = this.betPack.getValues().data || {};
+                        const betPackItem = betPackData?.[question.id];
+                        if (betPackItem || Object.keys(betPackData).length < 5) {
+                            const data = queries.$questionByUser(question.id, this.transport);
+                            const cancel = data.subscribe(() => { });
+                            await data.get().promise;
+                            const extendedQuestion = await queries.questionByUser(question.id, this.transport);
+                            cancel();
+                            window.requestAnimationFrame(() => {
+                                data.invalidate();
+                            });
+                            this.betPack.getStore().mutate({
+                                ...betPackData,
+                                [question.id]: extendedQuestion,
+                            });
+                        }
+                    }
                 });
                 this.questionSubscription.connect();
             }

package/lib/friendSummary.js

@@ -4,7 +4,7 @@ export const friendSummary = async ($eventId, $userId, $friends, friendId, trans
     const eventId = $eventId.get();
     const userId = $userId.get();
     const usersIds = $friends
-        .getStore()
+        ?.getStore()
         .get()
         .data?.map((friend) => friend.slId) || [];
     const request = {

package/lib/gamification.d.ts

@@ -28,11 +28,11 @@ export declare class Gamification extends AbstractFeature<'games', PlainMessage<
     /** list (pack) of predefined questions */
     betPack: ApiStore<GetApiResponseType<typeof queries.$betPack>>;
     /** friends list */
-    friends: ApiStore<GetApiResponseType<typeof queries.$friends>>;
+    friends?: ApiStore<GetApiResponseType<typeof queries.$friends>>;
     /** pinned leaderboard id */
     leaderboardId: WritableAtom<string | undefined>;
     /** leaderboard list */
-    leaderboardList: ReturnType<typeof leaderboard>;
+    leaderboardList?: ReturnType<typeof leaderboard>;
     deepLink: ReturnType<typeof deepLink>;
     /** onboarding status */
     onboardingStatus: {
@@ -44,7 +44,7 @@ export declare class Gamification extends AbstractFeature<'games', PlainMessage<
     /** current user id */
     currentUserId: GamificationBackground['userId'];
     /** pinned leaderboard id */
-    openedUser: WritableAtom<LeaderboardItem | undefined>;
+    openedUser?: WritableAtom<LeaderboardItem | undefined>;
     closeFeature: (destroy?: boolean) => void;
     openFeature: () => void;
     feedSubscription: GamificationBackground['feedSubscription'];

package/lib/gamification.js

@@ -5,7 +5,6 @@ import { NotificationType } from '@streamlayer/sdk-web-notifications';
 import '@streamlayer/sdk-web-core/store';
 import * as queries from './queries';
 import * as actions from './queries/actions';
-import { GamificationStorage } from './storage';
 import { leaderboard } from './leaderboard';
 import { deepLink } from './deepLink';
 import { OnboardingStatus, onboarding } from './onboarding';
@@ -71,15 +70,15 @@ export class Gamification extends AbstractFeature {
         this.feedSubscription = this.background.feedSubscription;
         this.activeQuestionId = this.background.activeQuestionId;
         this.openedQuestionId = this.background.openedQuestionId;
-        this.storage = new GamificationStorage();
+        this.storage = this.background.storage;
         this.feedList = this.background.feedList;
         this.betPack = this.background.betPack;
-        this.friends = new ApiStore(queries.$friends(this.background.userId, instance.transport), 'gamification:friends');
         this.currentUserId = this.background.userId;
-        this.openedUser = createSingleStore(undefined);
         this.onboardingProcessed = createSingleStore(!instance.sdk.withAuth);
         this.leaderboardId = new SingleStore(createSingleStore(this.settings.getValue('pinnedLeaderboardId')), 'pinnedLeaderboardId').getStore();
-        this.onboardingStatus = onboarding(this, this.background, instance.transport, instance.notifications);
+        this.onboardingStatus = onboarding(this, this.background, instance.transport, instance.notifications, {
+            skipOnboarding: instance.sdk.options.get().skipOnboarding,
+        });
         this.notifications = instance.notifications;
         this.transport = instance.transport;
         this.closeFeature = (destroy = true) => instance.sdk.closeFeature(destroy);
@@ -87,14 +86,18 @@ export class Gamification extends AbstractFeature {
         this.openedQuestion = this.background.openedQuestion;
         this.deepLink = deepLink(this.transport, this.background.slStreamId, instance.stores.providerStreamId.getStore(), this.background.userId);
         this.userSummary = summary(this.background.slStreamId, this.background.userId, this.friends, this.transport);
-        this.leaderboardList = leaderboard(this.transport, this.background.slStreamId, this.background.userId, this.friends);
+        if (!instance.sdk.options.get().hideFriends) {
+            this.friends = new ApiStore(queries.$friends(this.background.userId, instance.transport), 'gamification:friends');
+            this.openedUser = createSingleStore(undefined);
+            const leaderboardList = (this.leaderboardList = leaderboard(this.transport, this.background.slStreamId, this.background.userId, this.friends));
+            // refresh leaderboard on user summary update after earning points
+            this.cancels.add(this.userSummary.$store.listen((userSummary, prevValue) => {
+                if (prevValue?.summary && userSummary?.summary) {
+                    leaderboardList.invalidate(); // verified, it's necessary
+                }
+            }));
+        }
         this.connect();
-        // refresh leaderboard on user summary update after earning points
-        this.cancels.add(this.userSummary.$store.listen((userSummary, prevValue) => {
-            if (prevValue?.summary && userSummary?.summary) {
-                this.leaderboardList.invalidate(); // verified, it's necessary
-            }
-        }));
         /**
          * listen for onboarding status, moderation onboarding changes and opt-in settings
          */
@@ -333,15 +336,6 @@ export class Gamification extends AbstractFeature {
         const betPackList = { ...this.betPack.getValues().data };
         const question = betPackList?.[questionId];
         if (question) {
-            question.answers = betPackList[questionId].answers.map((answer) => {
-                if (answer.id === answerId) {
-                    return {
-                        ...answer,
-                        youVoted: true,
-                    };
-                }
-                return answer;
-            });
             eventBus.emit('poll', {
                 action: 'voted',
                 payload: {
@@ -349,10 +343,6 @@ export class Gamification extends AbstractFeature {
                     questionType: question.type,
                 },
             });
-            this.betPack.getStore().mutate({
-                ...betPackList,
-                [questionId]: question,
-            });
         }
     };
     submitAnswer = async (questionId, answerId) => {
@@ -444,14 +434,22 @@ export class Gamification extends AbstractFeature {
             const feedList = this.feedList.getStore().value?.data || [];
             questionType = feedList.find((item) => item.id === questionId)?.attributes?.type;
         }
-        eventBus.emit('poll', {
-            action: 'opened',
-            payload: {
-                questionId,
-                questionType,
-                questionOpenedFrom: question?.openedFrom,
-            },
-        });
+        const flags = {
+            eventId: this.background.slStreamId.get() || '',
+            userId: this.background.userId.get() || '',
+            organizationId: this.background.organizationId.get() || '',
+        };
+        if (!this.storage.isQuestionOpened(flags, questionId)) {
+            eventBus.emit('poll', {
+                action: 'opened',
+                payload: {
+                    questionId,
+                    questionType,
+                    questionOpenedFrom: question?.openedFrom,
+                },
+            });
+            this.storage.saveQuestionOpened(flags, questionId);
+        }
         this.openFeature();
         return this.background.openQuestion(questionId, question);
     };
@@ -475,20 +473,23 @@ export class Gamification extends AbstractFeature {
         return this.background.closeQuestion(questionId);
     };
     openUser = async (friendId) => {
-        const user = this.leaderboardList.$store.get().data?.find((item) => item.userId === friendId);
+        if (!this.leaderboardList) {
+            return;
+        }
+        const user = this.leaderboardList?.$store.get().data?.find((item) => item.userId === friendId);
         if (!user) {
-            this.openedUser.set(user);
+            this.openedUser?.set(user);
             return;
         }
         if (user.summaryLoaded) {
-            this.openedUser.set(user);
+            this.openedUser?.set(user);
             return;
         }
         const userCopy = { ...user };
         try {
             const friendDetail = await friendSummary(this.background.slStreamId, this.background.userId, this.friends, friendId, this.transport);
             if (friendDetail?.inTop !== undefined) {
-                this.leaderboardList.$store.setKey('data', this.leaderboardList.$store.get().data?.map((item) => {
+                this.leaderboardList?.$store.setKey('data', this.leaderboardList.$store.get().data?.map((item) => {
                     if (item.userId === friendId) {
                         item.inTop = friendDetail.inTop;
                     }
@@ -504,7 +505,7 @@ export class Gamification extends AbstractFeature {
         this.openedUser.set(userCopy);
     };
     closeUser = () => {
-        this.openedUser.set(undefined);
+        this.openedUser?.set(undefined);
     };
     /**
      * Show in-app notification for active question

package/lib/leaderboard.js

@@ -21,7 +21,7 @@ export const leaderboard = (transport, $eventId, $userId, $friends, options) =>
     const refetch = async () => {
         const eventId = $eventId.get();
         const friendsIds = $friends
-            .getStore()
+            ?.getStore()
             .get()
             .data?.map((friend) => friend.slId) || [];
         if (eventId && friendsIds?.length) {
@@ -65,7 +65,7 @@ export const leaderboard = (transport, $eventId, $userId, $friends, options) =>
     };
     onMount($store, () => {
         const cancelRefetchListener = $eventId.listen(refetch);
-        const cancelRefetchByFriendsListener = $friends.listen(refetch);
+        const cancelRefetchByFriendsListener = $friends?.listen(refetch);
         // const cancelPaginationListener = $pagination.listen(async (pagination) => {
         //   const eventId = $eventId.get()
         //   if (pagination.page > 0 && eventId) {
@@ -90,7 +90,7 @@ export const leaderboard = (transport, $eventId, $userId, $friends, options) =>
         // })
         return () => {
             cancelRefetchListener();
-            cancelRefetchByFriendsListener();
+            cancelRefetchByFriendsListener?.();
             // cancelPaginationListener()
         };
     });

package/lib/onboarding.d.ts

@@ -17,7 +17,9 @@ export declare enum OnboardingStatus {
     Disabled = "disabled",
     Unavailable = "unavailable"
 }
-export declare const onboarding: (service: Gamification, background: GamificationBackground, transport: Transport, notifications: Notifications) => {
+export declare const onboarding: (service: Gamification, background: GamificationBackground, transport: Transport, notifications: Notifications, options?: {
+    skipOnboarding?: boolean;
+}) => {
     $store: import("nanostores").WritableAtom<OnboardingStatus>;
     submitInplay: () => Promise<void>;
 };

package/lib/onboarding.js

@@ -1,7 +1,6 @@
 import { createSingleStore, eventBus } from '@streamlayer/sdk-web-interfaces';
 import { NotificationType } from '@streamlayer/sdk-web-notifications';
 import { QuestionType } from '@streamlayer/sdk-web-types';
-import { GamificationStorage } from './storage';
 import { submitInplay as submitInplayApi } from './queries/actions';
 /**
  * Required: in-app should be displayed and questions not available
@@ -52,22 +51,32 @@ const showOnboardingInApp = (service, background, notifications, storage) => {
  * check onboarding status, sync with browser cache
  * retrieve onboarding settings from api
  */
-const onboardingProcess = ($store, background, service, notifications, storage, listeners) => {
+const onboardingProcess = ($store, background, service, notifications, storage, listeners, transport, options) => {
     try {
         const userId = background.userId.get();
-        if (!userId) {
+        const organizationId = background.organizationId.get();
+        const eventId = background.slStreamId.get();
+        if (!userId || !organizationId || !eventId) {
             return;
         }
         const onboardingStatus = storage.getOnboardingStatus({
             userId,
-            organizationId: background.organizationId.get() || '',
-            eventId: background.slStreamId.get() || '',
+            organizationId,
+            eventId,
         });
-        if (onboardingStatus === OnboardingStatus.Completed) {
+        if (onboardingStatus === OnboardingStatus.Completed || options?.skipOnboarding) {
             $store.set(OnboardingStatus.Completed);
             for (const cancel of listeners) {
                 cancel();
             }
+            if (options?.skipOnboarding && onboardingStatus !== OnboardingStatus.Completed) {
+                storage.saveOnboardingStatus({
+                    organizationId,
+                    userId,
+                    eventId,
+                }, OnboardingStatus.Completed);
+                void submitInplayApi(transport, background.slStreamId.get() || '');
+            }
             return;
         }
         const moderation = background.moderation.getStore().value?.data;
@@ -100,10 +109,10 @@ const onboardingProcess = ($store, background, service, notifications, storage,
         console.error(error);
     }
 };
-export const onboarding = (service, background, transport, notifications) => {
+export const onboarding = (service, background, transport, notifications, options) => {
     // show onboarding each time when user open new sdk session
-    let onboardingShowed = false;
-    const storage = new GamificationStorage();
+    let onboardingShowed = !!options?.skipOnboarding;
+    const storage = background.storage;
     const $store = createSingleStore(OnboardingStatus.Unset);
     $store.subscribe((onboardingStatus) => {
         if (onboardingStatus === OnboardingStatus.Unset) {
@@ -128,24 +137,24 @@ export const onboarding = (service, background, transport, notifications) => {
         });
     });
     const listeners = [];
-    onboardingProcess($store, background, service, notifications, storage, listeners);
     if ($store.get() !== OnboardingStatus.Completed) {
         listeners.push(background.userId.listen((userId) => {
             if (userId) {
-                onboardingProcess($store, background, service, notifications, storage, listeners);
+                onboardingProcess($store, background, service, notifications, storage, listeners, transport, options);
             }
         }));
         listeners.push(background.moderation.listen((value) => {
             if (value.data) {
-                onboardingProcess($store, background, service, notifications, storage, listeners);
+                onboardingProcess($store, background, service, notifications, storage, listeners, transport, options);
             }
         }));
         listeners.push(service.featureSettings.listen((value) => {
             if (value) {
-                onboardingProcess($store, background, service, notifications, storage, listeners);
+                onboardingProcess($store, background, service, notifications, storage, listeners, transport, options);
             }
         }));
     }
+    onboardingProcess($store, background, service, notifications, storage, listeners, transport, options);
     const submitInplay = async () => {
         const eventId = background.slStreamId.get();
         if (eventId) {

package/lib/queries/index.d.ts

@@ -3,6 +3,7 @@ import { QuestionStatus, QuestionType } from '@streamlayer/sdk-web-types';
 import { ReadableAtom } from 'nanostores';
 import type { SubscriptionRequest, SubscriptionResponse, VotingSubscriptionRequest, VotingSubscriptionResponse, QuestionSubscriptionRequest, QuestionSubscriptionResponse } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb';
 import { InteractiveAllowed } from '../background';
+import { GamificationStorage } from '../storage';
 export declare const $activeQuestion: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedQuestion | undefined, any>;
 export declare const getFeedItem: (questionId: string, transport: Transport) => Promise<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedItem | undefined>;
 export declare const feedSubscription: ($slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("packages/sdk-web-api/lib/grpc/subscription").ServerStreamSubscription<import("@bufbuild/protobuf").ServiceType, import("@bufbuild/protobuf").Message<import("@bufbuild/protobuf").AnyMessage>, import("@bufbuild/protobuf").Message<import("@bufbuild/protobuf").AnyMessage>, never, never> | import("packages/sdk-web-api/lib/grpc/subscription").ServerStreamSubscription<{
@@ -434,4 +435,4 @@ export declare const $activePromotionId: ($slStreamId: ReadableAtom<string | und
 export { $userSummary, $leaderboardList } from './leaderboard';
 export { $friends } from './friends';
 export { $moderation } from './moderation';
-export declare const $betPack: ($slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<Record<string, import("@bufbuild/protobuf").PlainMessage<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").ExtendedQuestion>> | null, any>;
+export declare const $betPack: ($slStreamId: ReadableAtom<string | undefined>, $slUserId: ReadableAtom<string | undefined>, $slOrganizationId: ReadableAtom<string | undefined>, storage: GamificationStorage, transport: Transport) => import("@nanostores/query").FetcherStore<Record<string, import("@bufbuild/protobuf").PlainMessage<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").ExtendedQuestion>> | null, any>;

package/lib/queries/index.js

@@ -1,4 +1,5 @@
 import { QuestionStatus, QuestionType } from '@streamlayer/sdk-web-types';
+import { eventBus } from '@streamlayer/sdk-web-interfaces';
 import { atom } from 'nanostores';
 import { Feed } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_connect';
 import { InteractiveAllowed } from '../background';
@@ -170,14 +171,14 @@ export const $activePromotionId = ($slStreamId, transport) => {
 export { $userSummary, $leaderboardList } from './leaderboard';
 export { $friends } from './friends';
 export { $moderation } from './moderation';
-export const $betPack = ($slStreamId, transport) => {
+export const $betPack = ($slStreamId, $slUserId, $slOrganizationId, storage, transport) => {
     const { client, queryKey } = transport.createPromiseClient(Feed, {
         method: 'betPack',
-        params: [$slStreamId],
+        params: [$slStreamId, $slUserId, $slOrganizationId],
     });
     return transport.nanoquery.createFetcherStore(queryKey, {
-        fetcher: async (_, __, slStreamId) => {
-            if (!slStreamId) {
+        fetcher: async (_, __, slStreamId, userId, organizationId) => {
+            if (!slStreamId || !userId || !organizationId) {
                 return null;
             }
             const res = await client.betPack({
@@ -193,7 +194,28 @@ export const $betPack = ($slStreamId, transport) => {
             if (!res.data || !res.data.length) {
                 return null;
             }
-            return res.data?.reduce((acc, item) => item?.attributes?.question?.id ? { ...acc, [item.attributes.question.id]: item.attributes.question } : acc, {});
+            return res.data?.reduce((acc, item) => {
+                const question = item?.attributes?.question;
+                if (!question?.id) {
+                    return acc;
+                }
+                const flags = {
+                    eventId: slStreamId,
+                    userId: userId,
+                    organizationId: organizationId,
+                };
+                if (!storage.isBetPackQuestionReceived(flags, question.id)) {
+                    eventBus.emit('poll', {
+                        action: 'received',
+                        payload: {
+                            questionId: question.id,
+                            questionType: question.type,
+                        },
+                    });
+                    storage.saveBetPackQuestionReceived(flags, question.id);
+                }
+                return { ...acc, [question.id]: question };
+            }, {});
         },
         dedupeTime: 0,
         refetchInterval: 0,

package/lib/storage.d.ts

@@ -8,6 +8,10 @@ type UserProps = {
 export declare class GamificationStorage extends Storage {
     private sessionStorage;
     constructor();
+    saveBetPackQuestionReceived: ({ userId, eventId, organizationId }: UserProps, questionId: string) => void;
+    isBetPackQuestionReceived: ({ userId, eventId, organizationId }: UserProps, questionId: string) => boolean;
+    saveQuestionOpened: ({ userId, eventId, organizationId }: UserProps, questionId: string) => void;
+    isQuestionOpened: ({ userId, eventId, organizationId }: UserProps, questionId: string) => boolean;
     saveOnboardingStatus: ({ userId, eventId, organizationId }: UserProps, status: OnboardingStatus) => void;
     getOnboardingStatus: ({ userId, eventId, organizationId }: UserProps) => string | undefined;
     setOnboardingInstantOpen: ({ userId, eventId, organizationId }: UserProps) => void;

package/lib/storage.js

@@ -3,6 +3,8 @@ var KEY_PREFIX;
 (function (KEY_PREFIX) {
     KEY_PREFIX["ONBOARDING"] = "onboarding";
     KEY_PREFIX["ONBOARDING_IO"] = "onboarding_io";
+    KEY_PREFIX["BET_PACK_ITEM_RECEIVED"] = "bp-item-received";
+    KEY_PREFIX["QUESTION_OPENED"] = "q-opened";
 })(KEY_PREFIX || (KEY_PREFIX = {}));
 class GamificationSessionStorage extends Storage {
     constructor() {
@@ -21,6 +23,18 @@ export class GamificationStorage extends Storage {
         super('gamification');
         this.sessionStorage = new GamificationSessionStorage();
     }
+    saveBetPackQuestionReceived = ({ userId, eventId, organizationId }, questionId) => {
+        this.write(KEY_PREFIX.BET_PACK_ITEM_RECEIVED, organizationId, userId, eventId, questionId);
+    };
+    isBetPackQuestionReceived = ({ userId, eventId, organizationId }, questionId) => {
+        return !!this.read(KEY_PREFIX.BET_PACK_ITEM_RECEIVED, organizationId, userId, eventId, questionId);
+    };
+    saveQuestionOpened = ({ userId, eventId, organizationId }, questionId) => {
+        this.write(KEY_PREFIX.QUESTION_OPENED, organizationId, userId, eventId, questionId);
+    };
+    isQuestionOpened = ({ userId, eventId, organizationId }, questionId) => {
+        return !!this.read(KEY_PREFIX.QUESTION_OPENED, organizationId, userId, eventId, questionId);
+    };
     saveOnboardingStatus = ({ userId, eventId, organizationId }, status) => {
         this.write(KEY_PREFIX.ONBOARDING, organizationId, userId, eventId, status);
     };

package/lib/userSummary.d.ts

@@ -2,7 +2,7 @@ import type { Transport } from '@streamlayer/sdk-web-api';
 import { ReadableAtom } from 'nanostores';
 import { LeaderboardSummaryItem } from '@streamlayer/sl-eslib/interactive/leaderboard/interactive.leaderboard_pb';
 import { Gamification } from '.';
-export declare const summary: ($eventId: ReadableAtom<string | undefined>, $userId: ReadableAtom<string | undefined>, $friends: Gamification["friends"], transport: Transport) => {
+export declare const summary: ($eventId: ReadableAtom<string | undefined>, $userId: ReadableAtom<string | undefined>, $friends: Gamification["friends"] | undefined, transport: Transport) => {
     $store: import("nanostores").MapStore<LeaderboardSummaryItem | undefined>;
     invalidate: () => void;
 };

package/lib/userSummary.js

@@ -10,9 +10,11 @@ export const summary = ($eventId, $userId, $friends, transport) => {
         const eventId = $eventId.get();
         const userId = $userId.get();
         const usersIds = $friends
-            .getStore()
-            .get()
-            .data?.map((friend) => friend.slId);
+            ? $friends
+                .getStore()
+                .get()
+                .data?.map((friend) => friend.slId)
+            : [];
         if (!usersIds) {
             return;
         }
@@ -28,12 +30,13 @@ export const summary = ($eventId, $userId, $friends, transport) => {
         void refetch();
     };
     onMount($store, () => {
+        invalidate();
         const cancelRefetchListener = $eventId.listen(refetch);
-        const cancelRefetchByFriendsListener = $friends.listen(refetch);
+        const cancelRefetchByFriendsListener = $friends?.listen(refetch);
         const cancelRefetchByUserListener = $userId.listen(refetch);
         return () => {
             cancelRefetchListener();
-            cancelRefetchByFriendsListener();
+            cancelRefetchByFriendsListener?.();
             cancelRefetchByUserListener();
         };
     });

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@streamlayer/feature-gamification",
-  "version": "1.14.1",
+  "version": "1.15.1",
   "peerDependencies": {
     "@bufbuild/protobuf": "^1.10.0",
     "@fastify/deepmerge": "^2.0.0",
     "@streamlayer/sl-eslib": "^5.149.1",
     "nanostores": "^0.10.3",
-    "@streamlayer/sdk-web-api": "^1.7.1",
-    "@streamlayer/sdk-web-interfaces": "^1.4.10",
-    "@streamlayer/sdk-web-core": "^1.10.1",
-    "@streamlayer/sdk-web-logger": "^1.0.44",
-    "@streamlayer/sdk-web-notifications": "^1.3.6",
-    "@streamlayer/sdk-web-storage": "^1.0.44",
-    "@streamlayer/sdk-web-types": "^1.10.1"
+    "@streamlayer/sdk-web-api": "^1.7.3",
+    "@streamlayer/sdk-web-core": "^1.11.1",
+    "@streamlayer/sdk-web-interfaces": "^1.4.12",
+    "@streamlayer/sdk-web-logger": "^1.0.46",
+    "@streamlayer/sdk-web-notifications": "^1.3.8",
+    "@streamlayer/sdk-web-storage": "^1.0.46",
+    "@streamlayer/sdk-web-types": "^1.10.3"
   },
   "devDependencies": {
     "tslib": "^2.7.0"