@streamlayer/feature-gamification 1.5.4 → 1.6.1

package/lib/advertisement/index.d.ts

@@ -1,25 +1,15 @@
-import { createMapStore, StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
-import { PromotionOptions } from '@streamlayer/sdk-web-types';
-import { QuestionNotification } from '@streamlayer/sl-eslib/interactive/interactive.common_pb';
+import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
 import { type GamificationBackground } from '../background';
 import { getPromotionDetail } from '../queries';
-type AdvertisementData = {
-    loading?: boolean;
-    error?: unknown;
-    data?: {
-        promotions: PromotionOptions;
-        notification?: QuestionNotification;
-    };
-};
+type AdvertisementData = Exclude<Awaited<ReturnType<typeof getPromotionDetail>>, undefined>;
 export type Advertisement = {
-    autoHideDuration: number;
-    delay?: number;
+    data?: AdvertisementData;
+    loading?: boolean;
     hiding?: boolean;
-    action?: (...args: unknown[]) => void;
-    close?: (...args: unknown[]) => void;
-    data: ReturnType<typeof createMapStore<AdvertisementData>>;
-    promise: () => Promise<void>;
-    id: string;
+    isViewed?: boolean;
+    close?: () => void;
+    error?: string;
+    ctx?: Record<string, unknown>;
 };
 /**
  * @name Advertisement
@@ -34,9 +24,8 @@ export type Advertisement = {
  * - we subscribe to $feedSubscription, and show advertisement on activate
  */
 export declare const advertisement: ($slStreamId: GamificationBackground["slStreamId"], $feedSubscription: GamificationBackground["feedSubscription"], instance: StreamLayerContext) => {
-    hide: (notificationId: string) => void;
+    hide: (notificationId?: string) => void;
     show: (advertisementId: string, data?: Awaited<ReturnType<typeof getPromotionDetail>>) => void;
-    $list: import("nanostores").WritableAtom<Map<string, Advertisement> | undefined>;
-    getActiveAdvertisement: (persistent?: boolean) => Advertisement | null;
+    $store: import("nanostores").MapStore<Advertisement>;
 };
 export {};

package/lib/advertisement/index.js

@@ -1,11 +1,10 @@
-import { ApiStore, createMapStore, eventBus } from '@streamlayer/sdk-web-interfaces';
+import { createMapStore, eventBus } from '@streamlayer/sdk-web-interfaces';
 import { QuestionStatus } from '@streamlayer/sdk-web-types';
 import { createLogger } from '@streamlayer/sdk-web-logger';
-import { onMount } from 'nanostores';
 import { NotificationEnabled } from '@streamlayer/sl-eslib/interactive/interactive.common_pb';
-import { $promotionList, getPromotionDetail } from '../queries';
+import { $activePromotionId, getPromotionDetail } from '../queries';
 import { AdvertisementStorage } from './storage';
-import { AdvertisementsQueue } from './queue';
+import { parsePromotion } from './utils';
 /**
  * @name Advertisement
  * @description advertisement functionality, show, hide
@@ -20,159 +19,107 @@ import { AdvertisementsQueue } from './queue';
  */
 export const advertisement = ($slStreamId, $feedSubscription, instance) => {
     const transport = instance.transport;
-    const logger = createLogger('advertisement_queue');
-    const queue = new AdvertisementsQueue({ concurrency: 1, animationDelay: 1000 });
+    const logger = createLogger('advertisement');
     const storage = new AdvertisementStorage();
-    const $advertisementList = new ApiStore($promotionList($slStreamId, transport), 'gamification:promotionList');
+    const $store = createMapStore({});
+    const $activeAdvertisement = $activePromotionId($slStreamId, transport);
     /**
-     * Show advertisement by id, if it was not showed before.
+     * Show advertisement by id
      */
     const show = (advertisementId, data) => {
-        eventBus.emit('advertisement', {
-            action: 'received',
-            payload: {
-                advertisementId,
-                advertisementType: data?.promotions.type,
-            },
-        });
-        queue.addToQueue({
-            id: advertisementId,
-            autoHideDuration: Infinity,
-            data: createMapStore({ loading: false, error: undefined, data: undefined }),
-            close: () => hide(advertisementId),
-            promise: async function () {
-                this.data.setKey('loading', true);
-                try {
-                    const response = data || (await getPromotionDetail(advertisementId, transport));
-                    instance.sdk.onAdvertisementActivate({
-                        stage: 'activate',
-                        id: advertisementId,
-                        hasNotification: response?.notification?.enabled === NotificationEnabled.NOTIFICATION_ENABLED,
-                        isShowed: !!storage.isShowed(advertisementId),
-                    });
-                    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);
-                }
-            },
-        });
+        if (!data) {
+            $store.setKey('loading', true);
+            void getPromotionDetail(advertisementId, transport)
+                .then((response) => $store.set({
+                loading: false,
+                error: undefined,
+                data: response,
+                close: () => hide(response?.question.id),
+                isViewed: response && !!storage.isViewed(response.question.id),
+            }))
+                .catch((error) => $store.set({
+                loading: false,
+                error,
+                data: undefined,
+            }));
+        }
+        else {
+            $store.set({
+                loading: false,
+                error: undefined,
+                data,
+                close: () => hide(data.question.id),
+                isViewed: !!storage.isViewed(data.question.id),
+            });
+        }
     };
+    $activeAdvertisement.subscribe((active, prevActive) => {
+        if (active.data) {
+            eventBus.emit('advertisement', {
+                action: 'received',
+                payload: {
+                    advertisementId: active.data.question.id,
+                    advertisementType: active.data?.promotion?.type,
+                },
+            });
+            if (!prevActive?.data || active.data.id !== prevActive.data.id) {
+                show(active.data.question.id, active.data);
+            }
+        }
+    });
+    $store.subscribe((active, prevActive) => {
+        if (active.data) {
+            instance.sdk.onAdvertisementActivate({
+                stage: 'activate',
+                id: active.data.question.id,
+                hasNotification: active.data.notification?.enabled === NotificationEnabled.NOTIFICATION_ENABLED,
+                isViewed: !!storage.isViewed(active.data.question.id),
+            });
+            eventBus.emit('advertisement', {
+                action: 'opened',
+                payload: {
+                    advertisementId: active.data.question.id,
+                    advertisementType: active.data?.promotion?.type,
+                },
+            });
+        }
+        if (!active?.data && prevActive?.data) {
+            instance.sdk.onAdvertisementActivate({
+                stage: 'deactivate',
+                id: prevActive.data.question.id,
+                isViewed: !!storage.isViewed(prevActive.data.question.id),
+            });
+        }
+    });
     const markAsViewed = (notificationId) => {
         logger.debug({ notificationId }, 'markAsViewed: %o');
         storage.setShowed(notificationId);
     };
     const hide = (notificationId) => {
-        queue.closeAdvertisement(notificationId);
-        markAsViewed(notificationId);
-        instance.sdk.onAdvertisementActivate({
-            stage: 'deactivate',
-            id: notificationId,
-        });
-    };
-    const getActiveAdvertisement = (persistent) => {
-        const advertisements = queue.advertisementList.get();
-        if (!advertisements?.size) {
-            return null;
-        }
-        const advertisement = advertisements.values().next().value;
-        const advertisementData = advertisement.data.get();
-        if (!persistent && storage.isShowed(advertisement.id)) {
-            queue.removeFromList(advertisement.id);
-            return getActiveAdvertisement(persistent);
+        if (!notificationId || $store.get()?.data?.question.id === notificationId) {
+            $store.set({});
         }
-        if (!advertisementData.data && !advertisementData.error && !advertisementData.loading) {
-            void advertisement.promise();
+        if (notificationId) {
+            markAsViewed(notificationId);
         }
-        eventBus.emit('advertisement', {
-            action: 'opened',
-            payload: {
-                advertisementId: advertisement.id,
-                advertisementType: advertisementData.data?.promotions.type,
-            },
-        });
-        return advertisement;
     };
-    $advertisementList.subscribe((list) => {
-        if (list.data) {
-            const last = list.data[list.data.length - 1];
-            if (last) {
-                show(last.id);
-            }
-        }
-    });
-    $feedSubscription.addListener('promotion cb', (response) => {
-        const feedItem = response.data?.attributes?.feedItem?.attributes?.attributes?.case === 'promotion'
-            ? response.data.attributes.feedItem.attributes
-            : undefined;
-        const promotionItem = response.data?.attributes?.question?.options?.options.case === 'promotion'
-            ? response.data.attributes.question.options.options.value
-            : undefined;
-        if (feedItem === undefined || promotionItem === undefined) {
-            logger.debug('not promotion');
+    $feedSubscription.addListener('promotion', (response) => {
+        const promotion = parsePromotion(response);
+        if (!promotion) {
             return;
         }
-        if (feedItem.status === QuestionStatus.RESOLVED) {
-            hide(feedItem.id);
-            logger.debug({ feedItem }, 'resolved: %o');
+        if (promotion.question.status === QuestionStatus.RESOLVED) {
+            hide(promotion.question.id);
+            logger.debug({ promotion }, 'resolved: %o');
             return;
         }
-        if (feedItem.status === QuestionStatus.ACTIVE) {
-            logger.debug({ feedItem }, 'active: %o');
-            show(feedItem.id);
+        if (promotion.question.status === QuestionStatus.ACTIVE) {
+            logger.debug({ promotion }, 'active: %o');
+            show(promotion.question.id, promotion);
             return;
         }
-        logger.debug({ feedItem }, 'skip: %o');
-        return;
-    });
-    onMount(queue.advertisementList, () => {
-        $advertisementList.subscribe((list) => {
-            if (list.data) {
-                const last = list.data[list.data.length - 1];
-                if (last) {
-                    show(last.id);
-                }
-            }
-        });
-        $feedSubscription.addListener('promotion', (response) => {
-            const feedItem = response.data?.attributes?.feedItem?.attributes?.attributes?.case === 'promotion'
-                ? response.data.attributes.feedItem.attributes
-                : undefined;
-            const promotionItem = response.data?.attributes?.question?.options?.options.case === 'promotion'
-                ? response.data.attributes.question.options.options.value
-                : undefined;
-            if (feedItem === undefined || promotionItem === undefined) {
-                logger.debug('not promotion');
-                return;
-            }
-            if (feedItem.status === QuestionStatus.RESOLVED) {
-                hide(feedItem.id);
-                logger.debug({ feedItem }, 'resolved: %o');
-                return;
-            }
-            if (feedItem.status === QuestionStatus.ACTIVE) {
-                logger.debug({ feedItem }, 'active: %o');
-                show(feedItem.id, {
-                    promotions: promotionItem,
-                    notification: response.data?.attributes?.question?.notification,
-                });
-                return;
-            }
-            logger.debug({ feedItem }, 'skip: %o');
-            return;
-        });
+        logger.debug({ promotion }, 'skip: %o');
         return;
-        // return () => {
-        //   queue.drain()
-        // }
     });
-    return { hide, show, $list: queue.advertisementList, getActiveAdvertisement };
+    return { hide, show, $store };
 };

package/lib/advertisement/storage.d.ts

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

package/lib/advertisement/storage.js

@@ -10,7 +10,7 @@ export class AdvertisementStorage extends Storage {
     setShowed = (advertId) => {
         this.write(KEY_PREFIX.SHOWED, advertId, 'true');
     };
-    isShowed = (advertId) => {
+    isViewed = (advertId) => {
         return this.read(KEY_PREFIX.SHOWED, advertId);
     };
 }

package/lib/advertisement/utils.d.ts

@@ -0,0 +1,31 @@
+import { SubscriptionResponse } from '@streamlayer/sdk-web-types';
+export declare const parsePromotion: (response: SubscriptionResponse) => {
+    id: string;
+    question: {
+        id: string;
+        type: import("@streamlayer/sdk-web-types").QuestionType;
+        subject?: string;
+        appearance?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAppearance;
+        sponsorship?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").Sponsorship;
+        answers: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAnswer[];
+        status: import("@streamlayer/sdk-web-types").QuestionStatus;
+        position?: number;
+        marketClosed: boolean;
+        activatedAt: string;
+        answerSetAt: string;
+        overrides: {
+            [key: string]: boolean;
+        };
+        eventId: string;
+        streamTimestamp?: import("@bufbuild/protobuf").Timestamp;
+        tags: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").Tag[];
+        bypassNotifications?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").BypassNotifications;
+        importId: string;
+        activationTriggerCount?: number;
+        source: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionSource;
+        ai?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAi;
+        hasTriggers?: boolean;
+    };
+    notification: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionNotification | undefined;
+    promotion: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionOptions_PromotionOptions | undefined;
+} | undefined;

package/lib/advertisement/utils.js

@@ -0,0 +1,16 @@
+export const parsePromotion = (response) => {
+    const questionItem = response.data?.attributes?.question;
+    const feedItem = response.data?.attributes?.feedItem?.type === 'promotion' ? response.data.attributes.feedItem : undefined;
+    if (feedItem === undefined || !questionItem) {
+        return;
+    }
+    const { options, notification, ...question } = questionItem;
+    const promotionItem = options?.options.case === 'promotion' ? options.options.value : undefined;
+    // eslint-disable-next-line consistent-return
+    return {
+        id: question.id,
+        question,
+        notification,
+        promotion: promotionItem,
+    };
+};

package/lib/background.js

@@ -84,8 +84,10 @@ export class GamificationBackground {
             if (!question || question.type === QuestionType.PROMOTION) {
                 return;
             }
-            // skip update question, avoid race condition
-            if (activeQuestionId && question.status === QuestionStatus.RESOLVED && question.id !== activeQuestionId) {
+            if (question.status === QuestionStatus.RESOLVED) {
+                if (activeQuestionId === question.id) {
+                    this.activeQuestionId.mutate(undefined);
+                }
                 return;
             }
             this.activeQuestionId.mutate(response.data?.attributes);
@@ -100,6 +102,26 @@ export class GamificationBackground {
                 }
             });
         }));
+        this.cancels.add(this.activeQuestionId.subscribe((item, prevItem) => {
+            if (item.data?.feedItem) {
+                instance.sdk.onQuestionActivate({
+                    stage: 'activate',
+                    id: item.data.feedItem.id,
+                    isViewed: !!this.notifications.isViewed(item.data.feedItem.id),
+                    hasNotification: true,
+                    type: item.data.feedItem.type,
+                });
+            }
+            if (!item.data?.feedItem && prevItem?.data?.feedItem) {
+                instance.sdk.onQuestionActivate({
+                    stage: 'deactivate',
+                    id: prevItem.data.feedItem.id,
+                    isViewed: !!this.notifications.isViewed(prevItem.data.feedItem.id),
+                    hasNotification: true,
+                    type: prevItem.data.feedItem.type,
+                });
+            }
+        }));
         this.feedSubscription.connect();
         /**
          * invalidate active question on interactiveAllowed change

package/lib/gamification.d.ts

@@ -67,7 +67,7 @@ export declare class Gamification extends AbstractFeature<'games', PlainMessage<
         openedFrom?: "list" | "notification";
     }) => void | (() => void);
     getFeedItem: (id: string) => Promise<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedItem | undefined>;
-    isOpenedQuestion: (questionId: string) => string | undefined;
+    isOpenedQuestion: (questionId: string) => boolean;
     closeQuestion: (questionId?: string) => void;
     openUser: (friendId: string) => Promise<void>;
     closeUser: () => void;

package/lib/gamification.js

@@ -401,7 +401,7 @@ export class Gamification extends AbstractFeature {
         return queries.getFeedItem(id, this.transport);
     };
     isOpenedQuestion = (questionId) => {
-        return this.notifications.isViewed(questionId);
+        return !!this.notifications.isViewed(questionId);
     };
     closeQuestion = (questionId) => {
         return this.background.closeQuestion(questionId);

package/lib/queries/index.d.ts

@@ -351,18 +351,67 @@ 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> | 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<{
-    promotions: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionOptions_PromotionOptions;
+    id: string;
+    question: {
+        id: string;
+        type: QuestionType;
+        subject?: string;
+        appearance?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAppearance;
+        sponsorship?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").Sponsorship;
+        answers: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAnswer[];
+        status: QuestionStatus;
+        position?: number;
+        marketClosed: boolean;
+        activatedAt: string;
+        answerSetAt: string;
+        overrides: {
+            [key: string]: boolean;
+        };
+        eventId: string;
+        streamTimestamp?: import("@bufbuild/protobuf").Timestamp;
+        tags: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").Tag[];
+        bypassNotifications?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").BypassNotifications;
+        importId: string;
+        activationTriggerCount?: number;
+        source: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionSource;
+        ai?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAi;
+        hasTriggers?: boolean;
+    };
+    promotion: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionOptions_PromotionOptions | undefined;
     notification: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionNotification | undefined;
 } | 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 declare const $promotionList: ($slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<({
-    attributes: import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PromotionHistory;
+export declare const $activePromotionId: ($slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<{
     id: string;
-    type: QuestionType;
-    status: QuestionStatus;
-    created: string;
-} | undefined)[], any>;
+    question: {
+        id: string;
+        type: QuestionType;
+        subject?: string;
+        appearance?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAppearance;
+        sponsorship?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").Sponsorship;
+        answers: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAnswer[];
+        status: QuestionStatus;
+        position?: number;
+        marketClosed: boolean;
+        activatedAt: string;
+        answerSetAt: string;
+        overrides: {
+            [key: string]: boolean;
+        };
+        eventId: string;
+        streamTimestamp?: import("@bufbuild/protobuf").Timestamp;
+        tags: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").Tag[];
+        bypassNotifications?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").BypassNotifications;
+        importId: string;
+        activationTriggerCount?: number;
+        source: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionSource;
+        ai?: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionAi;
+        hasTriggers?: boolean;
+    };
+    promotion: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionOptions_PromotionOptions | undefined;
+    notification: import("@streamlayer/sl-eslib/interactive/interactive.common_pb").QuestionNotification | undefined;
+} | undefined, any>;
 export { $userSummary, $leaderboardList } from './leaderboard';
 export { $friends } from './friends';
 export { $moderation } from './moderation';

package/lib/queries/index.js

@@ -80,10 +80,12 @@ export const getPromotionDetail = async (promoId, transport) => {
     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 ? { promotions, notification: res.data?.attributes?.notification } : undefined;
+    if (!res.data?.attributes) {
+        return undefined;
+    }
+    const { options, notification, ...question } = res.data.attributes;
+    const promotion = options?.options.case === 'promotion' ? options?.options.value : undefined;
+    return { id: question.id, question, promotion, notification };
 };
 export const $pickHistory = (slStreamId, transport) => {
     const { client, queryKey } = transport.createPromiseClient(Feed, { method: 'pickHistory', params: [slStreamId] });
@@ -124,7 +126,7 @@ export const $feedList = ($slStreamId, $interactiveAllowed, transport) => {
         refetchInterval: 0,
     });
 };
-export const $promotionList = ($slStreamId, transport) => {
+export const $activePromotionId = ($slStreamId, transport) => {
     const { client, queryKey } = transport.createPromiseClient(Feed, {
         method: 'list',
         params: [$slStreamId],
@@ -132,7 +134,7 @@ export const $promotionList = ($slStreamId, transport) => {
     return transport.nanoquery.createFetcherStore(queryKey, {
         fetcher: async (_, __, slStreamId) => {
             if (!slStreamId) {
-                return [];
+                return undefined;
             }
             const res = await client.list({
                 eventId: slStreamId,
@@ -140,18 +142,16 @@ export const $promotionList = ($slStreamId, transport) => {
                     types: [QuestionType.PROMOTION],
                     statuses: [QuestionStatus.ACTIVE],
                 },
+                pagination: {
+                    page: 0,
+                    pageSize: 1,
+                },
             });
-            return res.data
-                .map(({ attributes }) => {
-                if (!attributes || attributes.attributes.case !== 'promotion') {
-                    return undefined;
-                }
-                return {
-                    ...attributes,
-                    attributes: attributes.attributes.value,
-                };
-            })
-                .filter(Boolean);
+            const feedItem = res.data?.[0];
+            if (feedItem.type === 'promotion') {
+                return getPromotionDetail(feedItem.id, transport);
+            }
+            return undefined;
         },
         dedupeTime: 0,
         refetchInterval: 0,

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@streamlayer/feature-gamification",
-  "version": "1.5.4",
+  "version": "1.6.1",
   "peerDependencies": {
     "@bufbuild/protobuf": "^1.10.0",
     "@fastify/deepmerge": "^2.0.0",
-    "@streamlayer/sl-eslib": "^5.122.0",
+    "@streamlayer/sl-eslib": "^5.123.1",
     "nanostores": "^0.10.3",
-    "@streamlayer/sdk-web-api": "^1.4.1",
-    "@streamlayer/sdk-web-core": "^1.3.1",
-    "@streamlayer/sdk-web-interfaces": "^1.1.11",
-    "@streamlayer/sdk-web-logger": "^1.0.16",
-    "@streamlayer/sdk-web-notifications": "^1.1.11",
-    "@streamlayer/sdk-web-storage": "^1.0.16",
-    "@streamlayer/sdk-web-types": "^1.5.1"
+    "@streamlayer/sdk-web-api": "^1.5.1",
+    "@streamlayer/sdk-web-core": "^1.4.1",
+    "@streamlayer/sdk-web-interfaces": "^1.1.13",
+    "@streamlayer/sdk-web-logger": "^1.0.18",
+    "@streamlayer/sdk-web-storage": "^1.0.18",
+    "@streamlayer/sdk-web-notifications": "^1.1.13",
+    "@streamlayer/sdk-web-types": "^1.6.1"
   },
   "devDependencies": {
     "tslib": "^2.7.0"

package/lib/advertisement/queue.d.ts

@@ -1,25 +0,0 @@
-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;
-    removeFromList: (advertisementId: string) => void;
-    closeAdvertisement: (advertisementId: string, { animateHiding }?: {
-        animateHiding?: boolean | undefined;
-    }) => Advertisement | undefined;
-    drain: () => void;
-}

package/lib/advertisement/queue.js

@@ -1,142 +0,0 @@
-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();
-    };
-    removeFromList = (advertisementId) => {
-        const prevQueue = new Map(this.advertisementList.get());
-        prevQueue.delete(advertisementId);
-        this.advertisementList.set(prevQueue);
-        this.store.delete(advertisementId);
-        this.activeQueue.delete(advertisementId);
-        this.waitingQueue.delete(advertisementId);
-        this.logger.debug({ advertisementId }, 'advertisement removed from list');
-    };
-    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');
-            }, animateHiding ? this.options.animationDelay || 0 : 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());
-    };
-}