@streamscloud/embeddable 8.3.0 → 10.0.0

package/dist/short-videos/data-providers/index.d.ts

@@ -0,0 +1 @@
+export { InternalShortVideoPlayerItemsProvider } from './internal-short-video-player-items-provider';

package/dist/short-videos/data-providers/index.js

@@ -0,0 +1 @@
+export { InternalShortVideoPlayerItemsProvider } from './internal-short-video-player-items-provider';

package/dist/short-videos/data-providers/internal-short-video-player-items-provider.d.ts

@@ -0,0 +1,17 @@
+import { type PostPlayerModel } from '../../posts/posts-player';
+import type { IFeedPlayerDataProvider } from '../../ui/player/providers';
+export declare class InternalShortVideoPlayerItemsProvider implements IFeedPlayerDataProvider<PostPlayerModel> {
+    readonly kind = "feed";
+    readonly initialData: IFeedPlayerDataProvider<PostPlayerModel>['initialData'];
+    private ids;
+    private idOrder;
+    private graphql;
+    private dataLoader;
+    constructor(input: {
+        ids: string[];
+        initiator?: string;
+        graphqlOrigin?: string;
+        initialId?: string;
+    });
+    loadMore: IFeedPlayerDataProvider<PostPlayerModel>['loadMore'];
+}

package/dist/short-videos/{short-videos-player/internal-short-video-player-provider.js → data-providers/internal-short-video-player-items-provider.js}

@@ -1,15 +1,15 @@
-import { ImageScale } from '../..';
+import { PostType } from '../..';
 import { ContinuationToken } from '../../core/continuation-token';
 import { CursorDataLoader } from '../../core/data-loaders';
 import { createLocalGQLClient } from '../../core/graphql';
-import { mapToShortVideoPlayerModel } from './mapper';
-import { GetShortVideosDocument } from './operations.generated';
+import { getPostsCursor } from '../../posts/data-loaders';
+import {} from '../../posts/posts-player';
 const CHUNK_SIZE = 20;
-export class InternalShortVideoPlayerProvider {
+export class InternalShortVideoPlayerItemsProvider {
+    kind = 'feed';
     initialData;
     ids;
     idOrder = new Map();
-    initialId;
     graphql;
     dataLoader = new CursorDataLoader({
         loadPage: async (continuationToken) => {
@@ -17,22 +17,12 @@ export class InternalShortVideoPlayerProvider {
             const endIdIndex = Math.min(startIdIndex + CHUNK_SIZE, this.ids.length);
             const idsChunk = this.ids.slice(startIdIndex, endIdIndex);
             try {
-                const payload = await this.graphql
-                    .query(GetShortVideosDocument, {
-                    input: {
-                        limit: idsChunk.length,
-                        filter: {
-                            ids: idsChunk
-                        }
-                    },
-                    image_scale: ImageScale.OriginalEncoded
-                })
-                    .toPromise();
-                const data = payload.data?.shortVideos;
-                if (!data) {
-                    return null;
-                }
-                const items = data.items.map(mapToShortVideoPlayerModel).sort((a, b) => {
+                const posts = await getPostsCursor({
+                    filter: { ids: idsChunk, types: [PostType.ShortVideo] },
+                    limit: idsChunk.length,
+                    graphql: this.graphql
+                });
+                const items = posts.items.sort((a, b) => {
                     const ia = this.idOrder.get(a.id) ?? Number.MAX_SAFE_INTEGER;
                     const ib = this.idOrder.get(b.id) ?? Number.MAX_SAFE_INTEGER;
                     return ia - ib;
@@ -52,18 +42,8 @@ export class InternalShortVideoPlayerProvider {
         this.graphql = createLocalGQLClient(graphqlOrigin, initiator ? { 'x-initiator': initiator } : undefined);
         this.ids = ids;
         ids.forEach((id, idx) => this.idOrder.set(id, idx));
-        this.initialId = initialId;
-        this.initialData = { prefetchedItems: [], startIndex: 0 };
+        const startIndex = initialId ? ids.indexOf(initialId) : 0;
+        this.initialData = { prefetchedItems: [], startIndex };
     }
     loadMore = () => this.dataLoader.loadMore();
-    prefetch = async () => {
-        const items = await this.loadMore();
-        if (this.initialId && items.length) {
-            const initialIndex = items.findIndex((i) => i.id === this.initialId);
-            this.initialData = { prefetchedItems: items, startIndex: initialIndex >= 0 ? initialIndex : 0 };
-        }
-        else {
-            this.initialData = { prefetchedItems: items, startIndex: 0 };
-        }
-    };
 }

package/dist/short-videos/short-videos-player/index.d.ts

@@ -1,27 +1,11 @@
+import type { Locale } from '../../core/locale';
 import { type IMediaCenterConfig } from '../../media-center/config/types';
-import type { IPostSocialInteractionsHandler } from '../../posts/social-interactions';
-import type { IPlayerItemsProvider } from '../../ui/player-slider';
-import { default as ShortVideosPlayer } from './cmp.short-videos-player.svelte';
-import { mapToShortVideoPlayerModel } from './mapper';
-import type { IShortVideoAnalyticsHandler, ShortVideoPlayerModel, ShortVideoPlayerSettings } from './types';
-export { ShortVideosPlayer, type ShortVideoPlayerModel };
-export type { IMediaCenterConfig, IPlayerItemsProvider, IShortVideoAnalyticsHandler };
-export { mapToShortVideoPlayerModel };
+export type { IMediaCenterConfig };
 /**
  * Opens the short videos player modal.
  *
- * Two overloads (mutually exclusive):
- * - Provider mode: openShortVideosPlayer({ shortVideosProvider, mediaCenterConfig?, ...common })
- * - IDs mode: openShortVideosPlayer({ ids, initiator, graphqlOrigin?, initialId?, mediaPageId?, ...common })
- *
  * @param init Configuration options.
  *
- * Provider mode (overload 1)
- * @param {IPlayerItemsProvider<ShortVideoPlayerModel>} init.shortVideosProvider
- *   Provider that supplies short-video items to the player.
- * @param {IMediaCenterConfig} [init.mediaCenterConfig]
- *   Optional media-center config.
- *
  * IDs mode (overload 2)
  * @param {string[]} init.ids
  *   List of short-video IDs to display.
@@ -34,22 +18,18 @@ export { mapToShortVideoPlayerModel };
  * @param {string} [init.mediaPageId]
  *   Optional media page ID used to construct an internal media-center config.
  *
- * Common settings
+ * Player settings
  * @param {IPostSocialInteractionsHandler} [init.socialInteractionsHandler]
  *   Handler for social interactions (like, share, etc.).
- * @param {ContentPlayerSettings} [init.playerSettings]
+ * @param [init.playerSettings]
  *   Player UI and behavior settings.
  *
  *   Fields of ContentPlayerSettings:
- *   - {boolean} [disableBackground]
- *       If true, hides the player's background image.
  *   - {boolean} [hideCloseButton]
  *       If true, hides the close button.
  *   - {Locale} [locale='en']
  *       Localization for the player UI. Supported values: 'en' | 'no'.
  *       If omitted, the default locale 'en' is used.
- *   - {boolean} [showStreamsCloudWatermark]
- *       If true, shows the StreamsCloud watermark.
  *
  * Events
  * @param {{ playerClosed?: () => void; videoActivated?: (id: string) => void }} [init.on]
@@ -61,70 +41,40 @@ export { mapToShortVideoPlayerModel };
  *
  * @returns {void}
  *
- * @example <caption>Provider mode</caption>
- * ```ts
- * import { openShortVideosPlayer } from '@streamscloud/embeddable/short-videos-player';
- *
- * openShortVideosPlayer({
- *   shortVideosProvider: myShortVideosProvider,
- *   mediaCenterConfig: mymediaCenterConfig,
- *   playerSettings: {
- *     // Locale is 'en' by default; set 'no' to switch to Norwegian:
- *     locale: 'no',
- *     disableBackground: false,
- *     hideCloseButton: false,
- *     showStreamsCloudWatermark: true,
- *   },
- *   on: {
- *     playerClosed: () => console.log('Player closed'),
- *     videoActivated: (id) => console.log('Activated', id)
- *   }
- * });
- * ```
- *
  * @example <caption>IDs mode</caption>
  * ```ts
  * import { openShortVideosPlayer } from '@streamscloud/embeddable/short-videos-player';
  *
  * openShortVideosPlayer({
  *   ids: ['id1', 'id2', 'id3'],
- *   initiator: 'marketing-campaign',
+ *   initiator: 'campaign-autumn',
  *   graphqlOrigin: 'https://graphql.example.com',
  *   initialId: 'id2',
  *   mediaPageId: 'media-page-123',
  *   playerSettings: {
- *     locale: 'en',
- *     disableBackground: true,
+ *     // Default locale is 'en'; set 'no' to switch to Norwegian:
+ *     locale: 'no',
+ *     disableBackground: false,
  *     hideCloseButton: false,
- *     showStreamsCloudWatermark: false,
+ *     showStreamsCloudWatermark: true,
  *   },
  *   on: {
  *     playerClosed: () => console.log('Player closed'),
- *     videoActivated: (id) => console.log('Activated', id)
  *   }
  * });
  * ```
  */
-export declare function openShortVideosPlayer(init: {
-    shortVideosProvider: IPlayerItemsProvider<ShortVideoPlayerModel>;
-    mediaCenterConfig?: IMediaCenterConfig;
-    analyticsHandler?: IShortVideoAnalyticsHandler;
-    socialInteractionsHandler?: IPostSocialInteractionsHandler;
-    playerSettings?: ShortVideoPlayerSettings;
-    on?: {
-        playerClosed?: () => void;
-        videoActivated?: (id: string) => void;
-    };
-}): void;
 export declare function openShortVideosPlayer(init: {
     ids: string[];
     initiator: string;
     graphqlOrigin?: string;
     initialId?: string;
     mediaPageId?: string;
-    playerSettings?: ShortVideoPlayerSettings;
+    playerSettings?: {
+        hideCloseButton?: boolean;
+        locale?: Locale;
+    };
     on?: {
         playerClosed?: () => void;
-        videoActivated?: (id: string) => void;
     };
-}): void;
+}): Promise<void>;

package/dist/short-videos/short-videos-player/index.js

@@ -1,46 +1,93 @@
-import { toastrWarning } from '../../core/toastr';
 import { InternalMediaCenterConfig } from '../../media-center/config/internal-media-center-config';
 import {} from '../../media-center/config/types';
 import { MediaCenter } from '../../media-center/media-center';
+import { InternalPostAnalyticsHandler } from '../../posts/handlers';
+import { InternalShortVideoPlayerItemsProvider } from '../data-providers';
 import { ModalShadowHost } from '../../ui/shadow-dom';
-import { default as ShortVideosPlayer } from './cmp.short-videos-player.svelte';
-import { InternalShortVideoAnalyticsHandler } from './internal-short-video-analytics-handler';
-import { InternalShortVideoPlayerProvider } from './internal-short-video-player-provider';
-import { mapToShortVideoPlayerModel } from './mapper';
 import { mount, unmount } from 'svelte';
-export { ShortVideosPlayer };
-export { mapToShortVideoPlayerModel };
-export function openShortVideosPlayer(init) {
-    const { shortVideosProvider, ids, graphqlOrigin, initialId, initiator, socialInteractionsHandler, playerSettings, on } = init;
-    let dataProvider = shortVideosProvider;
-    if (!dataProvider && ids) {
-        dataProvider = new InternalShortVideoPlayerProvider({ ids, graphqlOrigin, initialId, initiator });
-    }
-    if (!dataProvider) {
-        toastrWarning('Data provider is not specified.');
-        return;
-    }
-    let mediaCenterConfig = init.mediaCenterConfig;
-    if (!mediaCenterConfig && init.mediaPageId) {
-        mediaCenterConfig = new InternalMediaCenterConfig(init.mediaPageId, graphqlOrigin);
-    }
-    let analyticsHandler = init.analyticsHandler;
-    if (!analyticsHandler && !init.shortVideosProvider) {
-        // Only create internal analytics handler if using internal data provider
-        analyticsHandler = new InternalShortVideoAnalyticsHandler(graphqlOrigin);
-    }
+/**
+ * Opens the short videos player modal.
+ *
+ * @param init Configuration options.
+ *
+ * IDs mode (overload 2)
+ * @param {string[]} init.ids
+ *   List of short-video IDs to display.
+ * @param {string} init.initiator
+ *   Identifier of the initiator (used for tracking/analytics and GraphQL).
+ * @param {string} [init.graphqlOrigin]
+ *   Optional GraphQL origin (base URL). If omitted, the default origin is determined internally.
+ * @param {string} [init.initialId]
+ *   ID of the video to open first (optional).
+ * @param {string} [init.mediaPageId]
+ *   Optional media page ID used to construct an internal media-center config.
+ *
+ * Player settings
+ * @param {IPostSocialInteractionsHandler} [init.socialInteractionsHandler]
+ *   Handler for social interactions (like, share, etc.).
+ * @param [init.playerSettings]
+ *   Player UI and behavior settings.
+ *
+ *   Fields of ContentPlayerSettings:
+ *   - {boolean} [hideCloseButton]
+ *       If true, hides the close button.
+ *   - {Locale} [locale='en']
+ *       Localization for the player UI. Supported values: 'en' | 'no'.
+ *       If omitted, the default locale 'en' is used.
+ *
+ * Events
+ * @param {{ playerClosed?: () => void; videoActivated?: (id: string) => void }} [init.on]
+ *   Optional event handlers.
+ * @param {() => void} [init.on.playerClosed]
+ *   Called after the player is fully closed (after unmount and removal from the DOM).
+ * @param {(id: string) => void} [init.on.videoActivated]
+ *   Called when a video becomes active (receives the video's id).
+ *
+ * @returns {void}
+ *
+ * @example <caption>IDs mode</caption>
+ * ```ts
+ * import { openShortVideosPlayer } from '@streamscloud/embeddable/short-videos-player';
+ *
+ * openShortVideosPlayer({
+ *   ids: ['id1', 'id2', 'id3'],
+ *   initiator: 'campaign-autumn',
+ *   graphqlOrigin: 'https://graphql.example.com',
+ *   initialId: 'id2',
+ *   mediaPageId: 'media-page-123',
+ *   playerSettings: {
+ *     // Default locale is 'en'; set 'no' to switch to Norwegian:
+ *     locale: 'no',
+ *     disableBackground: false,
+ *     hideCloseButton: false,
+ *     showStreamsCloudWatermark: true,
+ *   },
+ *   on: {
+ *     playerClosed: () => console.log('Player closed'),
+ *   }
+ * });
+ * ```
+ */
+export async function openShortVideosPlayer(init) {
+    const { ids, graphqlOrigin, initialId, initiator, playerSettings, on } = init;
+    const dataProvider = new InternalShortVideoPlayerItemsProvider({ ids, graphqlOrigin, initialId, initiator });
+    const mediaCenterConfig = init.mediaPageId ? new InternalMediaCenterConfig(init.mediaPageId, graphqlOrigin) : undefined;
+    const analyticsHandler = new InternalPostAnalyticsHandler(graphqlOrigin);
     const shadowHost = new ModalShadowHost();
     const mounted = mount(MediaCenter, {
         target: shadowHost.shadowRoot,
         props: {
             config: mediaCenterConfig || null,
             playerProps: {
-                mode: 'short-videos',
+                mode: 'posts',
                 props: {
                     dataProvider,
-                    socialInteractionsHandler,
                     analyticsHandler,
-                    playerSettings,
+                    playerSettings: {
+                        hideCloseButton: playerSettings?.hideCloseButton,
+                        locale: playerSettings?.locale,
+                        showStreamsCloudWatermark: true
+                    },
                     on: {
                         playerClosed: async () => {
                             await unmount(mounted);
@@ -48,8 +95,7 @@ export function openShortVideosPlayer(init) {
                             if (on?.playerClosed) {
                                 on.playerClosed();
                             }
-                        },
-                        videoActivated: on?.videoActivated
+                        }
                     }
                 }
             }

package/dist/streams/data-loaders/index.d.ts

@@ -0,0 +1,2 @@
+export { getStreamsCursor } from './streams-loader';
+export { getStreamPagesCursor } from './stream-pages-loader';

package/dist/streams/data-loaders/index.js

@@ -0,0 +1,2 @@
+export { getStreamsCursor } from './streams-loader';
+export { getStreamPagesCursor } from './stream-pages-loader';

package/dist/streams/{stream-player → data-loaders}/mapper.d.ts

@@ -1,3 +1,3 @@
+import type { StreamPlayerModel } from '../streams-player/types';
 import type { StreamPlayerPayloadFragment } from './operations.generated';
-import type { StreamPlayerModel } from './types';
 export declare const mapToStreamPlayerModel: (payload: StreamPlayerPayloadFragment) => StreamPlayerModel;

package/dist/streams/{stream-player → data-loaders}/operations.generated.d.ts

@@ -1,30 +1,33 @@
 import type * as SchemaTypes from '../../../gql/types';
 import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
-export type GetStreamQueryVariables = SchemaTypes.Exact<{
-    id: SchemaTypes.Scalars['String']['input'];
+export type GetStreamsQueryVariables = SchemaTypes.Exact<{
+    input: SchemaTypes.EmbedStreamsInput;
 }>;
-export type GetStreamQuery = {
-    stream: {
-        id: string;
-        title: string;
-        subTitle: string | null;
-        createdAt: any;
-        publishedAt: any | null;
-        pagesCount: number;
-        cover: {
-            url: string;
-        } | null;
-        ownerProfile: {
-            image: string | null;
-            name: string;
+export type GetStreamsQuery = {
+    streams: {
+        continuationToken: string | null;
+        items: Array<{
             id: string;
-            type: SchemaTypes.ProfileType;
-        };
-        availableFrom: {
-            image: string;
-            name: string;
-        } | null;
-    } | null;
+            title: string;
+            subTitle: string | null;
+            createdAt: any;
+            publishedAt: any | null;
+            pagesCount: number;
+            cover: {
+                url: string;
+            } | null;
+            ownerProfile: {
+                image: string | null;
+                name: string;
+                id: string;
+                type: SchemaTypes.ProfileType;
+            };
+            availableFrom: {
+                image: string;
+                name: string;
+            } | null;
+        }>;
+    };
 };
 export type GetStreamPagesQueryVariables = SchemaTypes.Exact<{
     input: SchemaTypes.EmbedStreamPagesInput;
@@ -65,5 +68,5 @@ export type StreamPlayerPayloadFragment = {
     } | null;
 };
 export declare const StreamPlayerPayloadFragmentDoc: DocumentNode<StreamPlayerPayloadFragment, unknown>;
-export declare const GetStreamDocument: DocumentNode<GetStreamQuery, GetStreamQueryVariables>;
+export declare const GetStreamsDocument: DocumentNode<GetStreamsQuery, GetStreamsQueryVariables>;
 export declare const GetStreamPagesDocument: DocumentNode<GetStreamPagesQuery, GetStreamPagesQueryVariables>;

package/dist/streams/{stream-player → data-loaders}/operations.generated.js

@@ -48,18 +48,18 @@ export const StreamPlayerPayloadFragmentDoc = {
         }
     ]
 };
-export const GetStreamDocument = {
+export const GetStreamsDocument = {
     kind: 'Document',
     definitions: [
         {
             kind: 'OperationDefinition',
             operation: 'query',
-            name: { kind: 'Name', value: 'GetStream' },
+            name: { kind: 'Name', value: 'GetStreams' },
             variableDefinitions: [
                 {
                     kind: 'VariableDefinition',
-                    variable: { kind: 'Variable', name: { kind: 'Name', value: 'id' } },
-                    type: { kind: 'NonNullType', type: { kind: 'NamedType', name: { kind: 'Name', value: 'String' } } }
+                    variable: { kind: 'Variable', name: { kind: 'Name', value: 'input' } },
+                    type: { kind: 'NonNullType', type: { kind: 'NamedType', name: { kind: 'Name', value: 'EmbedStreamsInput' } } }
                 }
             ],
             selectionSet: {
@@ -67,19 +67,20 @@ export const GetStreamDocument = {
                 selections: [
                     {
                         kind: 'Field',
-                        alias: { kind: 'Name', value: 'stream' },
-                        name: { kind: 'Name', value: 'embedStream' },
-                        arguments: [
-                            {
-                                kind: 'Argument',
-                                name: { kind: 'Name', value: 'input' },
-                                value: {
-                                    kind: 'ObjectValue',
-                                    fields: [{ kind: 'ObjectField', name: { kind: 'Name', value: 'id' }, value: { kind: 'Variable', name: { kind: 'Name', value: 'id' } } }]
-                                }
-                            }
-                        ],
-                        selectionSet: { kind: 'SelectionSet', selections: [{ kind: 'FragmentSpread', name: { kind: 'Name', value: 'StreamPlayerPayloadFragment' } }] }
+                        alias: { kind: 'Name', value: 'streams' },
+                        name: { kind: 'Name', value: 'embedStreams' },
+                        arguments: [{ kind: 'Argument', name: { kind: 'Name', value: 'input' }, value: { kind: 'Variable', name: { kind: 'Name', value: 'input' } } }],
+                        selectionSet: {
+                            kind: 'SelectionSet',
+                            selections: [
+                                {
+                                    kind: 'Field',
+                                    name: { kind: 'Name', value: 'items' },
+                                    selectionSet: { kind: 'SelectionSet', selections: [{ kind: 'FragmentSpread', name: { kind: 'Name', value: 'StreamPlayerPayloadFragment' } }] }
+                                },
+                                { kind: 'Field', name: { kind: 'Name', value: 'continuationToken' } }
+                            ]
+                        }
                     }
                 ]
             }

package/dist/streams/{stream-player → data-loaders}/operations.graphql

@@ -1,6 +1,9 @@
-query GetStream($id: String!) {
-  stream: embedStream(input: { id: $id }) {
-    ...StreamPlayerPayloadFragment
+query GetStreams($input: EmbedStreamsInput!) {
+  streams: embedStreams(input: $input) {
+    items {
+      ...StreamPlayerPayloadFragment
+    }
+    continuationToken
   }
 }
 

package/dist/streams/data-loaders/stream-pages-loader.d.ts

@@ -0,0 +1,10 @@
+import { type StreamPageViewerModel } from '../stream-page-viewer';
+import type { Client } from '@urql/core';
+export declare const getStreamPagesCursor: (input: {
+    streamId: string;
+    continuationToken: string | null | undefined;
+    graphql: Client;
+}) => Promise<{
+    items: StreamPageViewerModel[];
+    continuationToken: string | null;
+}>;

package/dist/streams/data-loaders/stream-pages-loader.js

@@ -0,0 +1,33 @@
+import { ImageScale } from '../..';
+import { mapToStreamPageViewerModel } from '../stream-page-viewer';
+import { GetStreamPagesDocument } from './operations.generated';
+export const getStreamPagesCursor = async (input) => {
+    const { streamId, continuationToken, graphql } = input;
+    const emptyResult = { items: [], continuationToken: null };
+    if (continuationToken === null) {
+        return emptyResult;
+    }
+    try {
+        const payload = await graphql
+            .query(GetStreamPagesDocument, {
+            input: {
+                limit: 10,
+                continuationToken,
+                filter: { streamId }
+            },
+            image_scale: ImageScale.OriginalEncoded
+        })
+            .toPromise();
+        const data = payload.data?.streamPages;
+        if (!data) {
+            return emptyResult;
+        }
+        return {
+            items: data.items.map(mapToStreamPageViewerModel),
+            continuationToken: data.continuationToken
+        };
+    }
+    catch {
+        return emptyResult;
+    }
+};

package/dist/streams/data-loaders/streams-loader.d.ts

@@ -0,0 +1,19 @@
+import { StreamStatus } from '../../core/enums';
+import type { StreamPlayerModel } from '../streams-player/types';
+import type { Client } from '@urql/core';
+export declare const getStreamsCursor: (input: {
+    filter: {
+        ids?: string[];
+        categoryId?: string;
+        excludeIds?: string[];
+        mediaPageId?: string;
+        statuses?: StreamStatus[];
+        showInFeed?: boolean;
+    };
+    limit: number;
+    continuationToken?: string | null;
+    graphql: Client;
+}) => Promise<{
+    items: StreamPlayerModel[];
+    continuationToken: string | null;
+}>;

package/dist/streams/data-loaders/streams-loader.js

@@ -0,0 +1,28 @@
+import { StreamStatus } from '../../core/enums';
+import { mapToStreamPlayerModel } from './mapper';
+import { GetStreamsDocument } from './operations.generated';
+export const getStreamsCursor = async (input) => {
+    const { filter, limit, continuationToken, graphql } = input;
+    const { mediaPageId, ids, categoryId, excludeIds, statuses, showInFeed } = filter;
+    const payload = await graphql
+        .query(GetStreamsDocument, {
+        input: {
+            filter: {
+                ids,
+                mediaPageId,
+                categoryId,
+                excludeIds,
+                statuses,
+                showInFeed
+            },
+            limit,
+            continuationToken
+        }
+    })
+        .toPromise();
+    const streams = payload.data?.streams.items ?? [];
+    return {
+        items: streams.map(mapToStreamPlayerModel),
+        continuationToken: payload.data?.streams?.continuationToken ?? null
+    };
+};