@streamlayer/feature-gamification 0.41.3 → 1.1.0

package/lib/advertisement/index.d.ts

@@ -0,0 +1,38 @@
+import { createMapStore } from '@streamlayer/sdk-web-interfaces';
+import { PromotionOptions } from '@streamlayer/sdk-web-types';
+import type { Transport } from '@streamlayer/sdk-web-api';
+import { type GamificationBackground } from '../background';
+type AdvertisementData = {
+    loading?: boolean;
+    error?: unknown;
+    data?: PromotionOptions;
+};
+export type Advertisement = {
+    autoHideDuration: number;
+    delay?: number;
+    hiding?: boolean;
+    action?: (...args: unknown[]) => void;
+    close?: (...args: unknown[]) => void;
+    data: ReturnType<typeof createMapStore<AdvertisementData>>;
+    promise: () => Promise<void>;
+    id: string;
+};
+/**
+ * @name Advertisement
+ * @description advertisement functionality, show, hide
+ * - show: show advertisement by id, if it was not showed before
+ * - hide: hide advertisement by id
+ * - markAsViewed: mark advertisement as viewed, called when UI is requested to show advertisement
+ * - getActiveAdvertisement: request active advertisement from queue by UI
+ *
+ * On mount:
+ * - we subscribe to $feedList, and show last advertisement from list
+ * - we subscribe to $feedSubscription, and show advertisement on activate
+ */
+export declare const advertisement: ($feedList: GamificationBackground["feedList"], $feedSubscription: GamificationBackground["feedSubscription"], transport: Transport) => {
+    hide: (notificationId: string) => void;
+    show: (advertisementId: string) => void;
+    $list: import("nanostores").WritableAtom<Map<string, Advertisement> | undefined>;
+    getActiveAdvertisement: () => Advertisement | null;
+};
+export {};

package/lib/advertisement/index.js

@@ -0,0 +1,119 @@
+import { createComputedStore, createMapStore, eventBus } from '@streamlayer/sdk-web-interfaces';
+import { QuestionStatus, QuestionType } from '@streamlayer/sdk-web-types';
+import { createLogger } from '@streamlayer/sdk-web-logger';
+import { onMount } from 'nanostores';
+import { getPromotionDetail } from '../queries';
+import { AdvertisementStorage } from './storage';
+import { AdvertisementsQueue } from './queue';
+/**
+ * @name Advertisement
+ * @description advertisement functionality, show, hide
+ * - show: show advertisement by id, if it was not showed before
+ * - hide: hide advertisement by id
+ * - markAsViewed: mark advertisement as viewed, called when UI is requested to show advertisement
+ * - getActiveAdvertisement: request active advertisement from queue by UI
+ *
+ * On mount:
+ * - we subscribe to $feedList, and show last advertisement from list
+ * - we subscribe to $feedSubscription, and show advertisement on activate
+ */
+export const advertisement = ($feedList, $feedSubscription, transport) => {
+    const logger = createLogger('advertisement_queue');
+    const queue = new AdvertisementsQueue({ concurrency: 1, animationDelay: 0 });
+    const storage = new AdvertisementStorage();
+    const $advertisementList = createComputedStore($feedList.getStore(), (feedList) => {
+        return feedList.data?.filter((item) => item.type === 'promotion');
+    });
+    /**
+     * Show advertisement by id, if it was not showed before.
+     */
+    const show = (advertisementId) => {
+        if (storage.isShowed(advertisementId)) {
+            return;
+        }
+        queue.addToQueue({
+            id: advertisementId,
+            autoHideDuration: Infinity,
+            data: createMapStore({ loading: false, error: undefined, data: undefined }),
+            promise: async function () {
+                this.data.setKey('loading', true);
+                try {
+                    const response = await getPromotionDetail(advertisementId, transport);
+                    if (!response) {
+                        this.data.setKey('error', new Error('No promotion found'));
+                    }
+                    else {
+                        this.data.setKey('data', response);
+                    }
+                }
+                catch (error) {
+                    this.data.setKey('error', error);
+                }
+                finally {
+                    this.data.setKey('loading', false);
+                }
+            },
+        });
+    };
+    const markAsViewed = (notificationId) => {
+        logger.debug({ notificationId }, 'markAsViewed: %o');
+        storage.setShowed(notificationId);
+    };
+    const hide = (notificationId) => {
+        queue.closeAdvertisement(notificationId);
+        markAsViewed(notificationId);
+    };
+    const getActiveAdvertisement = () => {
+        const advertisements = queue.advertisementList.get();
+        if (!advertisements?.size) {
+            return null;
+        }
+        const advertisement = advertisements.values().next().value;
+        const advertisementData = advertisement.data.get();
+        if (!advertisementData.data && !advertisementData.error && !advertisementData.loading) {
+            void advertisement.promise();
+            eventBus.emit('poll', {
+                action: 'opened',
+                payload: {
+                    questionId: advertisement.id,
+                    questionType: QuestionType.PROMOTION,
+                    questionOpenedFrom: 'notification', // ToDo: add openedFrom to notification
+                },
+            });
+            markAsViewed(advertisement.id);
+        }
+        return advertisement;
+    };
+    onMount(queue.advertisementList, () => {
+        $advertisementList.subscribe((list) => {
+            if (list) {
+                const last = list[list.length - 1];
+                show(last.id);
+            }
+        });
+        $feedSubscription.addListener('promotion', (response) => {
+            const feedItem = response.data?.attributes?.feedItem;
+            if (feedItem?.attributes?.attributes.case !== 'promotion') {
+                logger.debug('not promotion');
+                return;
+            }
+            if (feedItem.attributes.status === QuestionStatus.RESOLVED) {
+                hide(feedItem.id);
+                logger.debug({ feedItem }, 'resolved: %o');
+                return;
+            }
+            if (feedItem.attributes.status === QuestionStatus.ACTIVE) {
+                logger.debug({ feedItem }, 'active: %o');
+                show(feedItem.id);
+                return;
+            }
+            logger.debug({ feedItem }, 'skip: %o');
+            return;
+        });
+        return;
+        // return () => {
+        //   queue.drain()
+        // }
+    });
+    return { hide, show, $list: queue.advertisementList, getActiveAdvertisement };
+};

package/lib/advertisement/queue.d.ts

@@ -0,0 +1,24 @@
+import { SingleStore, createComputedStore } from '@streamlayer/sdk-web-interfaces';
+import { Advertisement } from '.';
+export type AdvertisementsQueueOptions = {
+    concurrency: number;
+    animationDelay: number;
+};
+export type AdvertisementsList = ReturnType<typeof createComputedStore<Advertisement[]>>;
+export declare class AdvertisementsQueue {
+    advertisementList: ReturnType<SingleStore<Map<Advertisement['id'], Advertisement>>['getStore']>;
+    private store;
+    private timeouts;
+    private waitingQueue;
+    private activeQueue;
+    private options;
+    private logger;
+    constructor(options: AdvertisementsQueueOptions);
+    addToQueue: (advertisement: Advertisement) => void;
+    tickWaitingQueue: () => void;
+    tickActiveQueue: (advertisementId: string) => void;
+    closeAdvertisement: (advertisementId: string, { animateHiding }?: {
+        animateHiding?: boolean | undefined;
+    }) => Advertisement | undefined;
+    drain: () => void;
+}

package/lib/advertisement/queue.js

@@ -0,0 +1,133 @@
+import { createSingleStore } from '@streamlayer/sdk-web-interfaces';
+import { createLogger } from '@streamlayer/sdk-web-logger';
+export class AdvertisementsQueue {
+    advertisementList;
+    store;
+    timeouts;
+    waitingQueue;
+    activeQueue;
+    options;
+    logger;
+    constructor(options) {
+        this.options = options;
+        this.logger = createLogger('advertisement_queue');
+        this.store = new Map();
+        this.timeouts = new Map();
+        this.waitingQueue = new Set();
+        this.activeQueue = new Set();
+        this.advertisementList = createSingleStore(new Map());
+    }
+    addToQueue = (advertisement) => {
+        if (this.store.has(advertisement.id)) {
+            this.logger.debug({ advertisement }, 'skip existed advertisement: %o');
+            return;
+        }
+        const close = advertisement.close;
+        const action = advertisement.action;
+        this.store.set(advertisement.id, {
+            ...advertisement,
+            close: (...args) => {
+                if (close) {
+                    close(...args);
+                }
+                this.closeAdvertisement(advertisement.id);
+            },
+            action: (...args) => {
+                if (action) {
+                    action(...args);
+                }
+                this.closeAdvertisement(advertisement.id, { animateHiding: false });
+            },
+        });
+        this.waitingQueue.add(advertisement.id);
+        /**
+         * Hide an oldest advertisement if the active queue is full,
+         * and show a new advertisement on the next tick
+         */
+        if (this.activeQueue.size === this.options.concurrency) {
+            const [job] = this.activeQueue;
+            this.closeAdvertisement(job);
+        }
+        else {
+            this.tickWaitingQueue();
+        }
+    };
+    tickWaitingQueue = () => {
+        if (this.activeQueue.size < this.options.concurrency) {
+            const [job] = this.waitingQueue;
+            if (!job) {
+                return;
+            }
+            this.activeQueue.add(job);
+            this.waitingQueue.delete(job);
+            this.logger.debug({ job }, 'waiting queue tick');
+            this.tickActiveQueue(job);
+        }
+        else {
+            this.logger.debug({ queueSize: this.activeQueue.size, concurrency: this.options.concurrency }, 'waiting queue tick skipped');
+        }
+    };
+    tickActiveQueue = (advertisementId) => {
+        if (!advertisementId) {
+            return;
+        }
+        const advertisement = this.store.get(advertisementId);
+        if (!advertisement) {
+            this.logger.debug({ advertisementId }, 'active queue tick skipped, advertisement not exist');
+            return;
+        }
+        const timeout = setTimeout(() => {
+            const closureId = advertisementId;
+            const prevQueue = new Map(this.advertisementList.get());
+            prevQueue.set(advertisement.id, advertisement);
+            this.advertisementList.set(prevQueue);
+            if (advertisement.autoHideDuration !== Infinity) {
+                const timeout = setTimeout(() => {
+                    this.logger.debug({ advertisementId: closureId, delay: advertisement.autoHideDuration || 5000 }, 'advertisement hiding by autoHideDuration');
+                    this.closeAdvertisement(closureId);
+                }, advertisement.autoHideDuration || 5000);
+                this.timeouts.set(closureId, timeout);
+            }
+            this.logger.debug({ advertisementId: closureId, queue: [...prevQueue.values()] }, 'advertisement displayed');
+        }, advertisement.delay || 0);
+        this.timeouts.set(advertisementId, timeout);
+        this.logger.debug({ advertisementId }, 'active queue tick completed');
+        this.tickWaitingQueue();
+    };
+    closeAdvertisement = (advertisementId, { animateHiding = true } = {}) => {
+        const prevQueue = new Map(this.advertisementList.get());
+        const advertisement = prevQueue.get(advertisementId);
+        if (advertisement) {
+            // do not hide advertisement if we have more than one advertisement in waiting queue,
+            // because we need to show next advertisement immediately
+            advertisement.hiding = !(this.waitingQueue.size >= this.options.concurrency) && animateHiding;
+            this.advertisementList.set(prevQueue);
+            const timeout = setTimeout(() => {
+                const prevQueue = new Map(this.advertisementList.get());
+                prevQueue.delete(advertisementId);
+                this.advertisementList.set(prevQueue);
+                const timeout = this.timeouts.get(advertisementId);
+                if (timeout !== undefined) {
+                    clearTimeout(timeout);
+                    this.timeouts.delete(advertisementId);
+                }
+                this.logger.debug({ advertisementId }, 'advertisement hidden');
+            }, this.options.animationDelay || 0);
+            this.timeouts.set(advertisementId, timeout);
+        }
+        this.store.delete(advertisementId);
+        this.activeQueue.delete(advertisementId);
+        this.waitingQueue.delete(advertisementId);
+        this.tickWaitingQueue();
+        this.logger.debug({ advertisementId }, 'advertisement hiding');
+        return advertisement;
+    };
+    drain = () => {
+        this.store.clear();
+        this.timeouts.clear();
+        this.waitingQueue.clear();
+        this.activeQueue.clear();
+        this.advertisementList.off();
+        this.advertisementList.set(new Map());
+    };
+}

package/lib/advertisement/storage.d.ts

@@ -0,0 +1,6 @@
+import { Storage } from '@streamlayer/sdk-web-storage';
+export declare class AdvertisementStorage extends Storage {
+    constructor();
+    setShowed: (advertId: string) => void;
+    isShowed: (advertId: string) => string | undefined;
+}

package/lib/advertisement/storage.js

@@ -0,0 +1,16 @@
+import { Storage } from '@streamlayer/sdk-web-storage';
+var KEY_PREFIX;
+(function (KEY_PREFIX) {
+    KEY_PREFIX["SHOWED"] = "showed";
+})(KEY_PREFIX || (KEY_PREFIX = {}));
+export class AdvertisementStorage extends Storage {
+    constructor() {
+        super('advertisement');
+    }
+    setShowed = (advertId) => {
+        this.write(KEY_PREFIX.SHOWED, advertId, 'true');
+    };
+    isShowed = (advertId) => {
+        return this.read(KEY_PREFIX.SHOWED, advertId);
+    };
+}

package/lib/background.d.ts

@@ -5,6 +5,7 @@ import '@streamlayer/sdk-web-core/store';
 import { ReadableAtom, WritableAtom } from 'nanostores';
 import * as queries from './queries';
 import { detail } from './detail';
+import { advertisement } from './advertisement';
 export declare enum InteractiveAllowed {
     ALLOWED = "allowed",
     DISALLOWED = "disallowed"
@@ -44,6 +45,7 @@ export declare class GamificationBackground {
     feedSubscription: ReturnType<typeof queries.feedSubscription>;
     /** subscription to opened question (vote percentage) */
     questionSubscription?: ReturnType<typeof queries.questionSubscription>;
+    advertisement: ReturnType<typeof advertisement>;
     private notifications;
     private log;
     private transport;
@@ -69,7 +71,7 @@ export declare class GamificationBackground {
      * Open question and mark notification for this question as viewed
      */
     openQuestion: (questionId: string, question?: FeedItem & {
-        openedFrom?: 'list' | 'notification';
+        openedFrom?: "list" | "notification";
     }) => void;
     /**
      * Close question and mark notification for this question as viewed

package/lib/background.js

@@ -4,6 +4,7 @@ import { QuestionStatus } from '@streamlayer/sdk-web-types';
 import '@streamlayer/sdk-web-core/store';
 import * as queries from './queries';
 import { detail } from './detail';
+import { advertisement } from './advertisement';
 export var InteractiveAllowed;
 (function (InteractiveAllowed) {
     InteractiveAllowed["ALLOWED"] = "allowed";
@@ -39,6 +40,7 @@ export class GamificationBackground {
     feedSubscription;
     /** subscription to opened question (vote percentage) */
     questionSubscription;
+    advertisement;
     notifications;
     log;
     transport;
@@ -118,6 +120,7 @@ export class GamificationBackground {
                 }
             };
         });
+        this.advertisement = advertisement(this.feedList, this.feedSubscription, instance.transport);
     }
     /**
      * Get id for notifications and link with current session

package/lib/deepLink.js

@@ -34,11 +34,20 @@ export const deepLink = (transport, $eventId, $externalEventId, $userId) => {
                     hash = `#${createUrlParams('', urlParamsData)}`;
                 }
                 const desktopLink = window.location.origin + window.location.pathname + search + hash;
-                const shortLink = await generateShortLink(transport, { web: desktopLink, mobile: mobileDeepLink });
-                $store.set({
-                    data: shortLink.data?.link,
-                    loading: false,
-                });
+                try {
+                    const shortLink = await generateShortLink(transport, { web: desktopLink, mobile: mobileDeepLink });
+                    $store.set({
+                        data: shortLink.data?.link,
+                        loading: false,
+                    });
+                }
+                catch (error) {
+                    $store.set({
+                        loading: false,
+                        error: 'Failed to generate short link',
+                        data: undefined,
+                    });
+                }
             }
             else {
                 $store.setKey('loading', true);

package/lib/detail.d.ts

@@ -5,11 +5,11 @@ import { type GamificationBackground } from './background';
 export declare const detail: (transport: Transport, $openedQuestionId: ReadableAtom<{
     questionId: string;
     question?: FeedItem & {
-        openedFrom?: 'list' | 'notification';
+        openedFrom?: "list" | "notification";
     };
-} | undefined>, $feedList: ReturnType<GamificationBackground['feedList']['getStore']>) => {
+} | undefined>, $feedList: ReturnType<GamificationBackground["feedList"]["getStore"]>) => {
     $store: ReadableAtom<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedItem | (import("@bufbuild/protobuf").PlainMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedItem> & {
-        openedFrom?: "list" | "notification" | undefined;
+        openedFrom?: "list" | "notification";
     }) | undefined>;
     $extendedStore: import("@nanostores/query").FetcherStore<import("@bufbuild/protobuf").PlainMessage<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").ExtendedQuestion>, any>;
     updateExtendedQuestion: (question: ExtendedQuestion | undefined) => void;

package/lib/friendSummary.d.ts

@@ -2,4 +2,4 @@ import type { Transport } from '@streamlayer/sdk-web-api';
 import { ReadableAtom } from 'nanostores';
 import { LeaderboardItem } from '@streamlayer/sl-eslib/interactive/leaderboard/interactive.leaderboard_pb';
 import { Gamification } from '.';
-export declare const friendSummary: ($eventId: ReadableAtom<string | undefined>, $userId: ReadableAtom<string | undefined>, $friends: Gamification['friends'], friendId: string, transport: Transport) => Promise<LeaderboardItem | undefined>;
+export declare const friendSummary: ($eventId: ReadableAtom<string | undefined>, $userId: ReadableAtom<string | undefined>, $friends: Gamification["friends"], friendId: string, transport: Transport) => Promise<LeaderboardItem | undefined>;

package/lib/gamification.d.ts

@@ -48,6 +48,7 @@ export declare class Gamification extends AbstractFeature<'games', PlainMessage<
     feedSubscription: GamificationBackground['feedSubscription'];
     activeQuestionId: GamificationBackground['activeQuestionId'];
     openedQuestionId: GamificationBackground['openedQuestionId'];
+    advertisement: GamificationBackground['advertisement'];
     private notifications;
     private transport;
     /** gamification background class, handle subscriptions and notifications for closed overlay */
@@ -63,7 +64,7 @@ export declare class Gamification extends AbstractFeature<'games', PlainMessage<
     disconnect: () => void;
     submitAnswer: (questionId: string, answerId: string) => Promise<void>;
     openQuestion: (questionId?: string, question?: FeedItem & {
-        openedFrom?: 'list' | 'notification';
+        openedFrom?: "list" | "notification";
     }) => void | (() => void);
     closeQuestion: (questionId?: string) => void;
     openUser: (friendId: string) => Promise<void>;

package/lib/gamification.js

@@ -49,6 +49,7 @@ export class Gamification extends AbstractFeature {
     feedSubscription;
     activeQuestionId;
     openedQuestionId;
+    advertisement;
     notifications;
     transport;
     /** gamification background class, handle subscriptions and notifications for closed overlay */
@@ -60,6 +61,7 @@ export class Gamification extends AbstractFeature {
     constructor(config, source, instance) {
         super(config, source);
         this.background = new GamificationBackground(instance);
+        this.advertisement = this.background.advertisement;
         this.feedSubscription = this.background.feedSubscription;
         this.activeQuestionId = this.background.activeQuestionId;
         this.openedQuestionId = this.background.openedQuestionId;
@@ -214,6 +216,10 @@ export class Gamification extends AbstractFeature {
             if (!feedItem?.attributes) {
                 return;
             }
+            // skip promotions, they are tracked in the advertisement
+            if (feedItem.attributes.attributes.case === 'promotion') {
+                return;
+            }
             // skip questions with status other than active or resolved
             if (feedItem.attributes.status !== QuestionStatus.ACTIVE &&
                 feedItem.attributes.status !== QuestionStatus.RESOLVED) {
@@ -273,6 +279,7 @@ export class Gamification extends AbstractFeature {
             }
             if (questionIndex === -1) {
                 feedList.unshift(feedItem);
+                console.log('feedItem', feedItem);
                 eventBus.emit('poll', {
                     action: 'received',
                     payload: {

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 export { GamificationBackground } from './background';
 export { Gamification } from './gamification';
+export { Advertisement } from './advertisement';
 declare module '@streamlayer/sdk-web-interfaces' {
     interface StreamLayerContext {
         gamification: import('./background').GamificationBackground;

package/lib/leaderboard.d.ts

@@ -14,7 +14,7 @@ type LeaderboardStore = {
     hasMore: boolean;
     error?: string;
 };
-export declare const leaderboard: (transport: Transport, $eventId: ReadableAtom<string | undefined>, $userId: ReadableAtom<string | undefined>, $friends: Gamification['friends'], 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/queries/deepLink.js

@@ -10,10 +10,15 @@ export const $deepLink = (transport, params) => {
             if (!eventId) {
                 return {};
             }
-            const res = await client.generateDeepLink({
-                data: { gamification: true, externalEventId: externalEventId, eventId: eventId },
-            });
-            return res.data?.attributes;
+            try {
+                const res = await client.generateDeepLink({
+                    data: { gamification: true, externalEventId: externalEventId, eventId: eventId },
+                });
+                return res.data?.attributes;
+            }
+            catch (error) {
+                return undefined;
+            }
         },
         dedupeTime: 1000 * 60 * 60 * 24, // 24 hours
         refetchInterval: 0,

package/lib/queries/index.d.ts

@@ -109,7 +109,7 @@ export declare const feedSubscription: ($slStreamId: ReadableAtom<string | undef
             readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
         };
     };
-}, SubscriptionRequest, SubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<SubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<VotingSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<QuestionSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse>)>;
+}, SubscriptionRequest, SubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<SubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<VotingSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<QuestionSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse>)>;
 export declare const votingSubscription: (params: {
     questionId: string;
     feedId: string;
@@ -219,7 +219,7 @@ export declare const votingSubscription: (params: {
             readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
         };
     };
-}, VotingSubscriptionRequest, VotingSubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<SubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<VotingSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<QuestionSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse>)>;
+}, VotingSubscriptionRequest, VotingSubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<SubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<VotingSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<QuestionSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse>)>;
 export declare const questionSubscription: (questionId: string, 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";
     readonly methods: {
@@ -326,10 +326,11 @@ export declare const questionSubscription: (questionId: string, transport: Trans
             readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
         };
     };
-}, QuestionSubscriptionRequest, QuestionSubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<SubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<VotingSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<QuestionSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions | undefined) => AsyncIterable<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse>)>;
+}, QuestionSubscriptionRequest, QuestionSubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<SubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<VotingSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<QuestionSubscriptionResponse>) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, options?: import("@connectrpc/connect").CallOptions) => AsyncIterable<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse>)>;
 export declare const getQuestionByUser: (questionId: string, transport: Transport) => Promise<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").ExtendedQuestion | undefined>;
 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> | string, transport: Transport) => import("@nanostores/query").FetcherStore<import("@bufbuild/protobuf").PlainMessage<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").ExtendedQuestion>, any>;
+export declare const getPromotionDetail: (promoId: string, transport: Transport) => Promise<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionOptions_PromotionOptions | undefined>;
 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>, $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';

package/lib/queries/index.js

@@ -21,6 +21,7 @@ export const $activeQuestion = (slStreamId, transport) => {
     });
 };
 export const feedSubscription = ($slStreamId, transport) => {
+    console.log('feedSubscription', $slStreamId);
     const { client } = transport.createStreamClient(Feed);
     const params = atom({ eventId: $slStreamId.get() || '', feedId: '' });
     $slStreamId.subscribe((eventId = '') => {
@@ -65,6 +66,19 @@ export const $questionByUser = ($questionId, transport) => {
         dedupeTime: 1000 * 60 * 5,
     });
 };
+export const getPromotionDetail = async (promoId, transport) => {
+    if (!promoId) {
+        return undefined;
+    }
+    const { client } = transport.createPromiseClient(Feed, { method: 'getQuestion', params: [promoId] });
+    const res = await client.getQuestion({
+        id: promoId,
+    });
+    const promotions = res.data?.attributes?.options?.options.case === 'promotion'
+        ? res.data?.attributes?.options?.options.value
+        : undefined;
+    return promotions;
+};
 export const $pickHistory = (slStreamId, transport) => {
     const { client, queryKey } = transport.createPromiseClient(Feed, { method: 'pickHistory', params: [slStreamId] });
     return transport.nanoquery.createFetcherStore(queryKey, {

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"], transport: Transport) => {
     $store: import("nanostores").MapStore<LeaderboardSummaryItem | undefined>;
     invalidate: () => void;
 };

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@streamlayer/feature-gamification",
-  "version": "0.41.3",
+  "version": "1.1.0",
   "peerDependencies": {
-    "@bufbuild/protobuf": "^1.8.0",
-    "@fastify/deepmerge": "^1.3.0",
-    "@streamlayer/sl-eslib": "^5.85.0",
-    "nanostores": "^0.10.0",
-    "@streamlayer/sdk-web-api": "^0.25.2",
-    "@streamlayer/sdk-web-core": "^0.23.2",
-    "@streamlayer/sdk-web-interfaces": "^0.22.2",
-    "@streamlayer/sdk-web-logger": "^0.5.22",
-    "@streamlayer/sdk-web-notifications": "^0.16.2",
-    "@streamlayer/sdk-web-storage": "^0.4.9",
-    "@streamlayer/sdk-web-types": "^0.23.4"
+    "@bufbuild/protobuf": "^1.10.0",
+    "@fastify/deepmerge": "^2.0.0",
+    "@streamlayer/sl-eslib": "^5.104.1",
+    "nanostores": "^0.10.3",
+    "@streamlayer/sdk-web-api": "^1.1.0",
+    "@streamlayer/sdk-web-core": "^1.0.1",
+    "@streamlayer/sdk-web-interfaces": "^1.0.1",
+    "@streamlayer/sdk-web-logger": "^1.0.1",
+    "@streamlayer/sdk-web-notifications": "^1.0.1",
+    "@streamlayer/sdk-web-storage": "^1.0.1",
+    "@streamlayer/sdk-web-types": "^1.1.0"
   },
   "devDependencies": {
-    "tslib": "^2.6.2"
+    "tslib": "^2.6.3"
   },
   "type": "module",
   "main": "./lib/index.js",