@streamlayer/feature-gamification 0.34.0 → 0.35.0

package/lib/background.d.ts

@@ -4,6 +4,10 @@ import '@streamlayer/sdk-web-core/store';
 import { ReadableAtom, WritableAtom } from 'nanostores';
 import * as queries from './queries';
 import { detail } from './detail';
+export declare enum InteractiveAllowed {
+    ALLOWED = "allowed",
+    DISALLOWED = "disallowed"
+}
 /**
  * Background class for Gamification feature
  */
@@ -14,6 +18,11 @@ export declare class GamificationBackground {
     organizationId: ReadableAtom<string | undefined>;
     /** current user id */
     userId: ReadableAtom<string | undefined>;
+    /**
+     * flag to allow interactive questions (polls, trivia, predictions)
+     * controlled by opt-in and onboarding flags
+     */
+    interactiveAllowed: WritableAtom<InteractiveAllowed>;
     /** opened question, using to download statistics */
     openedQuestionId: WritableAtom<string | undefined>;
     /** opened question statistics */

package/lib/background.js

@@ -3,6 +3,11 @@ import { createLogger } from '@streamlayer/sdk-web-logger';
 import '@streamlayer/sdk-web-core/store';
 import * as queries from './queries';
 import { detail } from './detail';
+export var InteractiveAllowed;
+(function (InteractiveAllowed) {
+    InteractiveAllowed["ALLOWED"] = "allowed";
+    InteractiveAllowed["DISALLOWED"] = "disallowed";
+})(InteractiveAllowed || (InteractiveAllowed = {}));
 /**
  * Background class for Gamification feature
  */
@@ -13,6 +18,11 @@ export class GamificationBackground {
     organizationId;
     /** current user id */
     userId;
+    /**
+     * flag to allow interactive questions (polls, trivia, predictions)
+     * controlled by opt-in and onboarding flags
+     */
+    interactiveAllowed;
     /** opened question, using to download statistics */
     openedQuestionId;
     /** opened question statistics */
@@ -36,10 +46,11 @@ export class GamificationBackground {
         this.organizationId = instance.stores.organizationSettings.getAtomStore();
         this.userId = instance.stores.user.getAtomStore();
         this.moderationId = new SingleStore(createSingleStore(undefined), 'moderationId').getStore();
+        this.interactiveAllowed = new SingleStore(createSingleStore(InteractiveAllowed.DISALLOWED), 'interactiveAllowed').getStore();
         this.openedQuestionId = new SingleStore(createSingleStore(undefined), 'openedQuestionId').getStore();
         this.notifications = instance.notifications;
         this.moderation = new ApiStore(queries.$moderation(this.slStreamId, instance.transport), 'gamification:moderation');
-        this.feedList = new ApiStore(queries.$feedList(this.slStreamId, instance.transport), 'gamification:feedList');
+        this.feedList = new ApiStore(queries.$feedList(this.slStreamId, this.interactiveAllowed, instance.transport), 'gamification:feedList');
         this.activeQuestionId = new ApiStore(queries.$activeQuestion(this.slStreamId, instance.transport), 'gamification:activeQuestionId');
         this.openedQuestion = detail(instance.transport, this.openedQuestionId, this.feedList.getStore());
         this.openedQuestionId.listen((questionId) => {
@@ -82,6 +93,16 @@ export class GamificationBackground {
             });
         });
         this.feedSubscription.connect();
+        /**
+         * invalidate active question on interactiveAllowed change
+         * close question if interactiveAllowed changed to disallowed
+         * open question if interactiveAllowed changed to allowed
+         */
+        this.interactiveAllowed.listen(() => {
+            window.requestAnimationFrame(() => {
+                this.activeQuestionId.invalidate();
+            });
+        });
     }
     /**
      * Get id for notifications and link with current session

package/lib/gamification.d.ts

@@ -9,7 +9,7 @@ import { leaderboard } from './leaderboard';
 import { deepLink } from './deepLink';
 import { OnboardingStatus } from './onboarding';
 import { LeaderboardItem } from './queries/leaderboard';
-import { GamificationBackground } from './';
+import { GamificationBackground } from './background';
 /**
  * Gamification (Games) Overlay
  * Includes:
@@ -24,6 +24,8 @@ export declare class Gamification extends AbstractFeature<'games', PlainMessage<
     userSummary: ApiStore<GetApiResponseType<typeof queries.$userSummary>>;
     /** feed list (pick history) */
     feedList: ApiStore<GetApiResponseType<typeof queries.$feedList>>;
+    /** friends list */
+    friends: ApiStore<GetApiResponseType<typeof queries.$friends>>;
     /** pinned leaderboard id */
     leaderboardId: WritableAtom<string | undefined>;
     /** leaderboard list */
@@ -49,6 +51,8 @@ export declare class Gamification extends AbstractFeature<'games', PlainMessage<
     /** Browser cache */
     private storage;
     constructor(config: FeatureProps, source: FeatureSource, instance: StreamLayerContext);
+    get isInteractiveAllowed(): boolean;
+    checkInteractiveFlag: () => void;
     connect: (transport: StreamLayerContext['transport']) => void;
     disconnect: () => void;
     submitAnswer: (questionId: string, answerId: string) => Promise<void>;
@@ -57,4 +61,11 @@ export declare class Gamification extends AbstractFeature<'games', PlainMessage<
     closeQuestion: (questionId?: string) => void;
     openUser: (userId: string) => void;
     closeUser: () => void;
+    /**
+     * Show in-app notification for active question
+     * for interactive questions we show notification only if interactiveAllowed
+     * for factoid and tweet questions we show notification always
+     * skipping questions with inAppSilence === ON
+     */
+    private showInApp;
 }

package/lib/gamification.js

@@ -8,8 +8,8 @@ import { GamificationStorage } from './storage';
 import { leaderboard } from './leaderboard';
 import { deepLink } from './deepLink';
 import { OnboardingStatus, onboarding } from './onboarding';
-import { GamificationBackground } from './';
-const GamificationQuestionTypes = new Set([QuestionType.POLL, QuestionType.PREDICTION, QuestionType.TRIVIA]);
+import { GamificationBackground, InteractiveAllowed } from './background';
+const InteractiveQuestionTypes = new Set([QuestionType.POLL, QuestionType.PREDICTION, QuestionType.TRIVIA]);
 /**
  * Gamification (Games) Overlay
  * Includes:
@@ -24,6 +24,8 @@ export class Gamification extends AbstractFeature {
     userSummary;
     /** feed list (pick history) */
     feedList;
+    /** friends list */
+    friends;
     /** pinned leaderboard id */
     leaderboardId;
     /** leaderboard list */
@@ -51,6 +53,7 @@ export class Gamification extends AbstractFeature {
         this.storage = new GamificationStorage();
         this.userSummary = new ApiStore(queries.$userSummary(this.background.slStreamId, this.background.userId, instance.transport), 'gamification:userSummary');
         this.feedList = this.background.feedList;
+        this.friends = new ApiStore(queries.$friends(this.background.userId, instance.transport), 'gamification:friends');
         this.currentUserId = this.background.userId;
         this.openedUser = createSingleStore(undefined);
         this.leaderboardId = new SingleStore(createSingleStore(this.settings.getValue('pinnedLeaderboardId')), 'pinnedLeaderboardId').getStore();
@@ -61,7 +64,7 @@ export class Gamification extends AbstractFeature {
         this.openFeature = () => instance.sdk.openFeature(FeatureType.GAMES);
         this.openedQuestion = this.background.openedQuestion;
         this.deepLink = deepLink(this.transport, this.background.slStreamId, this.background.userId);
-        this.leaderboardList = leaderboard(this.transport, this.background.slStreamId);
+        this.leaderboardList = leaderboard(this.transport, this.background.slStreamId, this.background.userId, this.friends);
         this.status.subscribe((status) => {
             if (status === FeatureStatus.Ready) {
                 this.connect(instance.transport);
@@ -70,97 +73,45 @@ export class Gamification extends AbstractFeature {
                 this.disconnect();
             }
         });
+        // refresh leaderboard on user summary update after earning points
+        this.userSummary.listen((userSummary) => {
+            if (this.leaderboardList.$store.lc !== 0 && userSummary?.data?.summary) {
+                window.requestAnimationFrame(() => {
+                    this.leaderboardList.invalidate();
+                });
+            }
+        });
         /**
          * listen for active question and show in-app notification
          */
-        this.background.activeQuestionId.listen((question) => {
-            const onboardingStatus = this.onboardingStatus.$store.get();
-            if (question && question.data && onboardingStatus && onboardingStatus !== OnboardingStatus.Unset) {
-                if (question.data.question?.id !== undefined &&
-                    question.data.question.notification !== undefined &&
-                    question.data.question?.bypassNotifications?.inAppSilence !== SilenceSetting.ON &&
-                    question.data.question.status === QuestionStatus.ACTIVE) {
-                    if (GamificationQuestionTypes.has(question.data.question.type)) {
-                        const onboardingEnabled = this.background.moderation.getStore().value?.data?.options?.onboardingEnabled;
-                        const optInEnabled = this.settings.getValues().inplayGame?.titleCard?.optIn;
-                        const onboardingCompleted = onboardingStatus === OnboardingStatus.Completed;
-                        if (!onboardingEnabled || onboardingCompleted || optInEnabled !== true) {
-                            this.notifications.add({
-                                type: NotificationType.QUESTION,
-                                action: () => question.data?.question && this.openQuestion(question.data.question.id),
-                                close: () => question.data?.question && this.closeQuestion(question.data.question.id),
-                                autoHideDuration: 1000 * 60,
-                                id: this.background.getCurrentSessionId({
-                                    prefix: 'notification',
-                                    entity: question.data.question.id,
-                                }),
-                                data: {
-                                    questionType: question.data.question.type,
-                                    question: {
-                                        title: question.data.question.notification.title,
-                                    },
-                                },
-                            });
-                        }
-                    }
-                    else if (question.data.question.type === QuestionType.FACTOID) {
-                        const optionsValue = question.data.question.options?.options.value;
-                        const instantView = {
-                            heading: question.data.question.notification.title,
-                            body: question.data.question.notification.body,
-                            image: question.data.question.notification.image,
-                            video: {
-                                id: optionsValue?.video?.id || '',
-                                url: optionsValue?.video?.url || '',
-                                thumbnailUrl: optionsValue?.video?.thumbnailUrl || '',
-                            },
-                            webLink: {
-                                label: '',
-                                url: '',
-                            },
-                        };
-                        this.notifications.add({
-                            type: NotificationType.QUESTION,
-                            action: () => question.data?.question && this.openQuestion(question.data.question.id),
-                            close: () => question.data?.question && this.closeQuestion(question.data.question.id),
-                            autoHideDuration: 1000 * 120,
-                            id: this.background.getCurrentSessionId({ prefix: 'notification', entity: question.data.question.id }),
-                            data: {
-                                questionType: question.data.question.type,
-                                insight: instantView,
-                            },
-                        });
-                    }
-                    else if (question.data.question.type === QuestionType.TWEET) {
-                        const optionsValue = question.data.question.options?.options.value;
-                        const tweetView = {
-                            title: question.data.question.notification.title,
-                            body: question.data.question.notification.body,
-                            image: question.data.question.notification.image,
-                            account: optionsValue?.tweetMeta?.account || '',
-                            accountVerified: !!optionsValue?.tweetMeta?.accountVerified,
-                        };
-                        this.notifications.add({
-                            type: NotificationType.QUESTION,
-                            action: () => question.data?.question && this.openQuestion(question.data.question.id),
-                            close: () => question.data?.question && this.closeQuestion(question.data.question.id),
-                            autoHideDuration: 1000 * 120,
-                            id: this.background.getCurrentSessionId({ prefix: 'notification', entity: question.data.question.id }),
-                            data: {
-                                questionType: question.data.question.type,
-                                tweet: tweetView,
-                            },
-                        });
-                    }
-                }
-            }
-        });
+        this.background.activeQuestionId.listen(this.showInApp);
+        /**
+         * listen for onboarding status, moderation onboarding changes and opt-in settings
+         */
+        this.onboardingStatus.$store.listen(this.checkInteractiveFlag);
+        this.background.moderation.getStore().listen(this.checkInteractiveFlag);
+        this.settings.subscribe(this.checkInteractiveFlag);
     }
+    get isInteractiveAllowed() {
+        return this.background.interactiveAllowed.get() === InteractiveAllowed.ALLOWED;
+    }
+    checkInteractiveFlag = () => {
+        const onboardingStatus = this.onboardingStatus.$store.get();
+        const onboardingEnabled = this.background.moderation.getStore().value?.data?.options?.onboardingEnabled;
+        const optInEnabled = this.settings.getValues().inplayGame?.titleCard?.optIn;
+        const onboardingCompleted = onboardingStatus === OnboardingStatus.Completed;
+        const allowed = !onboardingEnabled || onboardingCompleted || optInEnabled !== true;
+        this.background.interactiveAllowed.set(allowed ? InteractiveAllowed.ALLOWED : InteractiveAllowed.DISALLOWED);
+    };
     connect = (transport) => {
         this.userSummary.invalidate();
         this.leaderboardList.invalidate();
         this.feedList.invalidate();
+        this.friends.invalidate();
         this.background.feedSubscription.addListener('feed-subscription-prediction-close', (response) => {
+            if (!this.isInteractiveAllowed) {
+                return;
+            }
             window.requestAnimationFrame(async () => {
                 const question = response.data?.attributes?.question;
                 if (!question) {
@@ -241,4 +192,89 @@ export class Gamification extends AbstractFeature {
     closeUser = () => {
         this.openedUser.set(undefined);
     };
+    /**
+     * Show in-app notification for active question
+     * for interactive questions we show notification only if interactiveAllowed
+     * for factoid and tweet questions we show notification always
+     * skipping questions with inAppSilence === ON
+     */
+    showInApp = (question) => {
+        const onboardingStatus = this.onboardingStatus.$store.get();
+        if (question && question.data && onboardingStatus && onboardingStatus !== OnboardingStatus.Unset) {
+            if (question.data.question?.id !== undefined &&
+                question.data.question.notification !== undefined &&
+                question.data.question?.bypassNotifications?.inAppSilence !== SilenceSetting.ON &&
+                question.data.question.status === QuestionStatus.ACTIVE) {
+                if (InteractiveQuestionTypes.has(question.data.question.type)) {
+                    if (this.isInteractiveAllowed) {
+                        this.notifications.add({
+                            type: NotificationType.QUESTION,
+                            action: () => question.data?.question && this.openQuestion(question.data.question.id),
+                            close: () => question.data?.question && this.closeQuestion(question.data.question.id),
+                            autoHideDuration: 1000 * 60,
+                            id: this.background.getCurrentSessionId({
+                                prefix: 'notification',
+                                entity: question.data.question.id,
+                            }),
+                            data: {
+                                questionType: question.data.question.type,
+                                question: {
+                                    title: question.data.question.notification.title,
+                                },
+                            },
+                        });
+                    }
+                }
+                else if (question.data.question.type === QuestionType.FACTOID) {
+                    const optionsValue = question.data.question.options?.options.value;
+                    const instantView = {
+                        heading: question.data.question.notification.title,
+                        body: question.data.question.notification.body,
+                        image: optionsValue.image,
+                        video: {
+                            id: optionsValue?.video?.id || '',
+                            url: optionsValue?.video?.url || '',
+                            thumbnailUrl: optionsValue?.video?.thumbnailUrl || '',
+                        },
+                        webLink: {
+                            label: '',
+                            url: '',
+                        },
+                    };
+                    this.notifications.add({
+                        type: NotificationType.QUESTION,
+                        action: () => question.data?.question && this.openQuestion(question.data.question.id),
+                        close: () => question.data?.question && this.closeQuestion(question.data.question.id),
+                        autoHideDuration: 1000 * 120,
+                        id: this.background.getCurrentSessionId({ prefix: 'notification', entity: question.data.question.id }),
+                        data: {
+                            questionType: question.data.question.type,
+                            insight: instantView,
+                        },
+                    });
+                }
+                else if (question.data.question.type === QuestionType.TWEET) {
+                    const optionsValue = question.data.question.options?.options.value;
+                    const tweetView = {
+                        title: question.data.question.notification.title,
+                        body: question.data.question.notification.body,
+                        image: question.data.question.notification.image,
+                        account: optionsValue?.tweetMeta?.account || '',
+                        accountVerified: !!optionsValue?.tweetMeta?.accountVerified,
+                    };
+                    this.notifications.add({
+                        type: NotificationType.QUESTION,
+                        action: () => question.data?.question && this.openQuestion(question.data.question.id),
+                        close: () => question.data?.question && this.closeQuestion(question.data.question.id),
+                        autoHideDuration: 1000 * 120,
+                        id: this.background.getCurrentSessionId({ prefix: 'notification', entity: question.data.question.id }),
+                        data: {
+                            questionType: question.data.question.type,
+                            tweet: tweetView,
+                        },
+                    });
+                }
+            }
+        }
+    };
 }

package/lib/leaderboard.d.ts

@@ -1,16 +1,18 @@
 import type { Transport } from '@streamlayer/sdk-web-api';
 import { ReadableAtom } from 'nanostores';
 import { type LeaderboardItem } from './queries/leaderboard';
+import { Gamification } from './';
 type LeaderboardOptions = {
     pageSize?: number;
 };
 type LeaderboardStore = {
-    data?: LeaderboardItem[];
+    data: LeaderboardItem[];
     loading?: boolean;
+    key: number;
     hasMore: boolean;
     error?: string;
 };
-export declare const leaderboard: (transport: Transport, $eventId: ReadableAtom<string | undefined>, options?: LeaderboardOptions) => {
+export declare const leaderboard: (transport: Transport, $eventId: ReadableAtom<string | undefined>, $userId: ReadableAtom<string | undefined>, $friends: Gamification['friends'], options?: LeaderboardOptions) => {
     $store: import("nanostores").MapStore<LeaderboardStore>;
     fetchMore: (page?: number) => void;
     invalidate: () => void;

package/lib/leaderboard.js

@@ -4,25 +4,43 @@ import { createLeaderboardListFetch } from './queries/leaderboard';
 const defaultOptions = {
     pageSize: 10,
 };
-export const leaderboard = (transport, $eventId, options) => {
+export const leaderboard = (transport, $eventId, $userId, $friends, options) => {
     let maxPage = 0;
     const $pagination = createSingleStore({ pageSize: options?.pageSize || defaultOptions.pageSize, page: 0 });
-    const $store = createMapStore({ data: [], hasMore: true, loading: undefined, error: undefined });
+    const $store = createMapStore({
+        data: [],
+        key: Date.now(),
+        hasMore: true,
+        loading: undefined,
+        error: undefined,
+    });
     const fetch = createLeaderboardListFetch(transport);
     /**
      * Refetch leaderboard data, reset pagination
      */
-    const refetch = async (eventId) => {
-        if (eventId) {
+    const refetch = async () => {
+        const eventId = $eventId.get();
+        const friendsIds = $friends
+            .getStore()
+            .get()
+            .data?.map((friend) => friend.slId) || [];
+        if (eventId && friendsIds?.length) {
+            const userId = $userId.get();
+            if (userId) {
+                friendsIds.push(userId);
+            }
             $store.setKey('loading', true);
+            $store.setKey('data', []);
             const request = {
                 eventId: eventId,
+                usersIds: friendsIds,
                 pagination: { page: 0, pageSize: options?.pageSize || defaultOptions.pageSize },
             };
             const newData = await fetch(request);
             $store.set({
                 data: newData.data.map((item) => item.attributes),
                 hasMore: true,
+                key: Date.now(),
                 loading: false,
             });
             if (newData.meta) {
@@ -32,7 +50,7 @@ export const leaderboard = (transport, $eventId, options) => {
         }
     };
     const invalidate = () => {
-        void refetch($eventId.get());
+        void refetch();
     };
     /**
      * Whether there is more data to fetch
@@ -46,6 +64,7 @@ export const leaderboard = (transport, $eventId, options) => {
     };
     onMount($store, () => {
         const cancelRefetchListener = $eventId.listen(refetch);
+        const cancelRefetchByFriendsListener = $friends.listen(refetch);
         const cancelPaginationListener = $pagination.listen(async (pagination) => {
             const eventId = $eventId.get();
             if (pagination.page > 0 && eventId) {
@@ -59,6 +78,7 @@ export const leaderboard = (transport, $eventId, options) => {
                     const prevData = $store.get().data || [];
                     $store.set({
                         data: [...prevData, ...newData.data.map((item) => item.attributes)],
+                        key: $store.get().key,
                         loading: false,
                         hasMore: true,
                     });
@@ -70,6 +90,7 @@ export const leaderboard = (transport, $eventId, options) => {
         });
         return () => {
             cancelRefetchListener();
+            cancelRefetchByFriendsListener();
             cancelPaginationListener();
         };
     });

package/lib/onboarding.js

@@ -28,9 +28,6 @@ const showOnboardingInApp = (service, background, notifications, storage) => {
             type: NotificationType.ONBOARDING,
             id: notificationId,
             action: service.openFeature,
-            close: () => {
-                notifications.markAsViewed(notificationId);
-            },
             persistent: true,
             autoHideDuration: 1000000,
             data: {
@@ -100,6 +97,8 @@ const onboardingProcess = ($store, background, service, notifications, storage,
     }
 };
 export const onboarding = (service, background, transport, notifications) => {
+    // show onboarding each time when user open new sdk session
+    let onboardingShowed = false;
     const storage = new GamificationStorage();
     const $store = createSingleStore(OnboardingStatus.Unset);
     $store.subscribe((onboardingStatus) => {
@@ -107,7 +106,10 @@ export const onboarding = (service, background, transport, notifications) => {
             return;
         }
         if (onboardingStatus === OnboardingStatus.Optional || onboardingStatus === OnboardingStatus.Required) {
-            showOnboardingInApp(service, background, notifications, storage);
+            if (onboardingShowed === false) {
+                showOnboardingInApp(service, background, notifications, storage);
+                onboardingShowed = true;
+            }
         }
         if (onboardingStatus === OnboardingStatus.Completed) {
             background.activeQuestionId.invalidate();

package/lib/queries/friends.d.ts

@@ -0,0 +1,3 @@
+import type { Transport } from '@streamlayer/sdk-web-api';
+import { ReadableAtom } from 'nanostores';
+export declare const $friends: ($userId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/users/users_pb").GetFriendsResponse_FriendData[], any>;

package/lib/queries/friends.js

@@ -0,0 +1,16 @@
+import { Users } from '@streamlayer/sl-eslib/users/users_connect';
+export const $friends = ($userId, transport) => {
+    const { client, queryKey } = transport.createPromiseClient(Users, {
+        method: 'getFriends',
+        params: [$userId],
+    });
+    return transport.nanoquery.createFetcherStore(queryKey, {
+        fetcher: async (_, __, userId) => {
+            if (!userId) {
+                return [];
+            }
+            const res = await client.getFriends({});
+            return res.data;
+        },
+    });
+};

package/lib/queries/index.d.ts

@@ -1,6 +1,7 @@
 import type { Transport } from '@streamlayer/sdk-web-api';
 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';
 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 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<{
     readonly typeName: "streamlayer.interactive.feed.Feed";
@@ -330,7 +331,7 @@ export declare const getQuestionByUser: (questionId: string, transport: Transpor
 export declare const getQuestionDetail: (questionId: string, transport: Transport) => Promise<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").Question | undefined>;
 export declare const $questionByUser: ($questionId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sdk-web-types").ExtendedQuestion | undefined, any>;
 export declare const $pickHistory: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<(import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PickHistory | undefined)[], any>;
-export declare const $feedList: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedItem[], any>;
-export declare const $insightHistory: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<(import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InsightHistory | undefined)[] | undefined, any>;
+export declare const $feedList: ($slStreamId: ReadableAtom<string | undefined>, $interactiveAllowed: ReadableAtom<InteractiveAllowed>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedItem[], any>;
 export { $userSummary, $leaderboardList } from './leaderboard';
+export { $friends } from './friends';
 export { $moderation } from './moderation';

package/lib/queries/index.js

@@ -1,6 +1,7 @@
-import { QuestionStatus } from '@streamlayer/sdk-web-types';
+import { QuestionStatus, QuestionType } from '@streamlayer/sdk-web-types';
 import { atom } from 'nanostores';
 import { Feed } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_connect';
+import { InteractiveAllowed } from '../background';
 export const $activeQuestion = (slStreamId, transport) => {
     const { client, queryKey } = transport.createPromiseClient(Feed, { method: 'syncQuestion', params: [slStreamId] });
     return transport.nanoquery.createFetcherStore(queryKey, {
@@ -75,16 +76,22 @@ export const $pickHistory = (slStreamId, transport) => {
         },
     });
 };
-export const $feedList = (slStreamId, transport) => {
-    const { client, queryKey } = transport.createPromiseClient(Feed, { method: 'list', params: [slStreamId] });
+export const $feedList = ($slStreamId, $interactiveAllowed, transport) => {
+    const { client, queryKey } = transport.createPromiseClient(Feed, {
+        method: 'list',
+        params: [$slStreamId, $interactiveAllowed],
+    });
     return transport.nanoquery.createFetcherStore(queryKey, {
-        fetcher: async (_, __, eventId) => {
-            if (!eventId) {
+        fetcher: async (_, __, slStreamId, interactiveAllowed) => {
+            if (!slStreamId) {
                 return [];
             }
             const res = await client.list({
-                eventId: eventId,
+                eventId: slStreamId,
                 filter: {
+                    types: interactiveAllowed === InteractiveAllowed.ALLOWED
+                        ? [] // allow all types
+                        : [QuestionType.FACTOID, QuestionType.PROMOTION, QuestionType.TWEET],
                     statuses: [QuestionStatus.ACTIVE, QuestionStatus.RESOLVED],
                 },
             });
@@ -92,19 +99,6 @@ export const $feedList = (slStreamId, transport) => {
         },
     });
 };
-export const $insightHistory = (slStreamId, transport) => {
-    const { client, queryKey } = transport.createPromiseClient(Feed, { method: 'insightHistory', params: [slStreamId] });
-    return transport.nanoquery.createFetcherStore(queryKey, {
-        fetcher: async (_, __, eventId) => {
-            if (!eventId) {
-                return undefined;
-            }
-            const res = await client.insightHistory({
-                eventId: eventId,
-            });
-            return res.data?.map(({ attributes }) => attributes);
-        },
-    });
-};
 export { $userSummary, $leaderboardList } from './leaderboard';
+export { $friends } from './friends';
 export { $moderation } from './moderation';

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@streamlayer/feature-gamification",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "peerDependencies": {
     "@bufbuild/protobuf": "^1.6.0",
     "@fastify/deepmerge": "*",
     "@streamlayer/sl-eslib": "^5.63.3",
     "nanostores": "^0.9.5",
-    "@streamlayer/sdk-web-api": "^0.18.0",
-    "@streamlayer/sdk-web-core": "^0.17.8",
-    "@streamlayer/sdk-web-interfaces": "^0.18.21",
-    "@streamlayer/sdk-web-logger": "^0.5.10",
-    "@streamlayer/sdk-web-notifications": "^0.13.4",
-    "@streamlayer/sdk-web-storage": "^0.3.10",
-    "@streamlayer/sdk-web-types": "^0.20.1"
+    "@streamlayer/sdk-web-api": "^0.20.0",
+    "@streamlayer/sdk-web-core": "^0.18.1",
+    "@streamlayer/sdk-web-interfaces": "^0.20.0",
+    "@streamlayer/sdk-web-logger": "^0.5.11",
+    "@streamlayer/sdk-web-notifications": "^0.13.6",
+    "@streamlayer/sdk-web-storage": "^0.3.11",
+    "@streamlayer/sdk-web-types": "^0.21.0"
   },
   "devDependencies": {
     "tslib": "^2.6.2"