@streamscloud/embeddable 13.0.1 → 13.1.0

package/dist/media-center/media-center/media-center-settings.svelte.js

@@ -3,21 +3,15 @@ export class MediaCenterSettings {
     showStreamsCloudWatermark = $state(true);
     disableBackground = $state(false);
     theme = $state('dark');
+    state = $state.raw(null);
     constructor(init) {
-        this.patch(init);
+        this.update(init);
     }
-    patch = (data) => {
-        if (data?.locale !== undefined) {
-            this.locale = data.locale;
-        }
-        if (data?.showStreamsCloudWatermark !== undefined) {
-            this.showStreamsCloudWatermark = data.showStreamsCloudWatermark;
-        }
-        if (data?.disableBackground !== undefined) {
-            this.disableBackground = data.disableBackground;
-        }
-        if (data?.theme !== undefined) {
-            this.theme = data.theme;
-        }
+    update = (data) => {
+        this.locale = data?.locale ?? 'en';
+        this.showStreamsCloudWatermark = data?.showStreamsCloudWatermark ?? true;
+        this.disableBackground = data?.disableBackground ?? false;
+        this.theme = data?.theme ?? 'dark';
+        this.state = data?.state ?? null;
     };
 }

package/dist/media-center/media-center/media-center-view.svelte

@@ -22,24 +22,21 @@ let { context, dynamicActions } = $props();
 let headerHeight = $state(0);
 let isMobileView = $state(false);
 const selectCategory = (categoryId) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!context.mediaCenterMode) {
+        return;
+    }
     switch (context.mediaCenterMode) {
-        case 'feed':
-            if (!context.feedPlayerProps) {
+        case 'posts-feed':
+            if (!context.postsFeedHandler.feedPlayerProps) {
                 return;
             }
-            switch (context.feedPlayerProps.type) {
-                case 'posts':
-                    if (context.categoriesHandler.selectedCategoryId === categoryId) {
-                        return;
-                    }
-                    context.playPostsFeed({ filter: { categoryId } });
-                    break;
-                case 'streams':
-                    context.tryActivateStreamsInCategory(categoryId);
-                    return;
-                default:
-                    Utils.assertUnreachable(context.feedPlayerProps);
+            if (context.categoriesHandler.selectedCategoryId === categoryId) {
+                return;
             }
+            context.playPostsFeed({ filter: { categoryId } });
+            break;
+        case 'streams-feed':
+            context.tryActivateStreamsInCategory(categoryId);
             break;
         case 'discover':
             context.activateDiscover({ categoryId });
@@ -52,13 +49,13 @@ const selectCategory = (categoryId) => __awaiter(void 0, void 0, void 0, functio
     }
 });
 const activateSelectedShortVideoPlayer = (shortVideo) => {
-    context.playPostsFeed({ filter: { prefetchedItems: [shortVideo] } });
+    context.playPostsFeed({ init: { prefetchedItems: [shortVideo] } });
 };
 const activateSelectedStreamPlayer = (stream) => {
-    context.playStreamsFeed({ filter: { prefetchedStreams: [stream] } });
+    context.playStreamsFeed({ init: { prefetchedStreams: [stream] } });
 };
 const activateSelectedStreamOfCategoryPlayer = (id, prefetchedStreams, categoryId) => {
-    context.playStreamsFeed({ filter: { categoryId, prefetchedStreams, initialStreamId: id } });
+    context.playStreamsFeed({ filter: { categoryId }, init: { prefetchedStreams, initialStreamId: id } });
 };
 const onHeaderHeightChanged = (height) => {
     headerHeight = height;
@@ -139,13 +136,13 @@ const swipeToOpen = (node) => {
     {/if}
 
     <div class="media-center__content-container" use:swipeToOpen>
-      {#if context.mediaCenterMode === 'feed' && context.feedPlayerProps}
+      {#if context.mediaCenterMode === 'posts-feed' && context.postsFeedHandler.feedPlayerProps}
+        <div class="media-center__content" class:media-center__content--faded={context.overlayIsActive} transition:fade={{ duration: 300 }}>
+          <PostsPlayerView {...context.postsFeedHandler.feedPlayerProps} />
+        </div>
+      {:else if context.mediaCenterMode === 'streams-feed' && context.streamsFeedHandler.feedPlayerProps}
         <div class="media-center__content" class:media-center__content--faded={context.overlayIsActive} transition:fade={{ duration: 300 }}>
-          {#if context.feedPlayerProps.type === 'posts'}
-            <PostsPlayerView {...context.feedPlayerProps.props} />
-          {:else if context.feedPlayerProps.type === 'streams'}
-            <StreamsPlayerView {...context.feedPlayerProps.props} />
-          {/if}
+          <StreamsPlayerView {...context.streamsFeedHandler.feedPlayerProps} />
         </div>
       {:else if context.mediaCenterMode === 'discover'}
         <div class="media-center__content" transition:fade={{ duration: 300 }}>
@@ -156,9 +153,9 @@ const swipeToOpen = (node) => {
               streamSelected: (stream) => activateSelectedStreamPlayer(stream)
             }} />
         </div>
-      {:else if context.mediaCenterMode === 'moments' && context.momentsPlayerProps}
+      {:else if context.mediaCenterMode === 'moments' && context.momentsFeedHandler.momentsPlayerProps}
         <div class="media-center__content" class:media-center__content--faded={context.overlayIsActive} transition:fade={{ duration: 300 }}>
-          <PostsPlayerView {...context.momentsPlayerProps} />
+          <PostsPlayerView {...context.momentsFeedHandler.momentsPlayerProps} />
         </div>
       {/if}
     </div>

package/dist/media-center/media-center/moments/moments-feed-handler.svelte.d.ts

@@ -1,4 +1,5 @@
-import type { IMediaCenterDataProvider } from '../..';
+import type { IMediaCenterDataProvider } from '../../config/types';
+import type { MediaCenterState } from '../../navigation';
 import type { PostsPlayerProps } from '../../../posts/posts-player/types';
 import type { ICloseOrchestrator } from '../../../ui/player/close-orchestrator';
 import { MomentsState } from './moments-state.svelte';
@@ -10,17 +11,25 @@ export declare class MomentsFeedHandler {
     private _dataProvider;
     private _mediaCenterSettingsHandler;
     private _closeOrchestrator;
-    private _onPlayerReachedEnd;
+    private _callbacks;
     constructor(data: {
         dataProvider: IMediaCenterDataProvider;
         mediaCenterSettingsHandler: MediaCenterSettingsHandler;
         closeOrchestrator: ICloseOrchestrator;
-        onPlayerReachedEnd: () => void;
+        on: Callbacks;
     });
     get active(): boolean;
     get momentsPlayerProps(): PostsPlayerProps | null;
     get hasUnwatchedMoments(): boolean;
     get hasMoments(): boolean;
     deactivate: () => void;
-    activateMoments: () => Promise<void>;
+    activate: (data?: {
+        initialMomentId?: string | null;
+    }) => Promise<void>;
+    private tryRestoreState;
 }
+type Callbacks = {
+    playerReachedEnd: () => void;
+    navigationStateChanged: (state: MediaCenterState) => void;
+};
+export {};

package/dist/media-center/media-center/moments/moments-feed-handler.svelte.js

@@ -8,14 +8,14 @@ export class MomentsFeedHandler {
     _dataProvider;
     _mediaCenterSettingsHandler;
     _closeOrchestrator;
-    _onPlayerReachedEnd;
+    _callbacks;
     constructor(data) {
-        const { dataProvider, mediaCenterSettingsHandler, closeOrchestrator, onPlayerReachedEnd } = data;
+        const { dataProvider, mediaCenterSettingsHandler, closeOrchestrator, on } = data;
         this.momentsState = new MomentsState(dataProvider);
         this._mediaCenterSettingsHandler = mediaCenterSettingsHandler;
         this._dataProvider = dataProvider;
         this._closeOrchestrator = closeOrchestrator;
-        this._onPlayerReachedEnd = onPlayerReachedEnd;
+        this._callbacks = on;
     }
     get active() {
         return this._active;
@@ -31,19 +31,43 @@ export class MomentsFeedHandler {
     }
     deactivate = () => {
         this._active = false;
+        this._momentsPlayerProps = null;
     };
-    activateMoments = async () => {
+    activate = async (data) => {
+        if (data?.initialMomentId && this.tryRestoreState(data.initialMomentId)) {
+            // Already active with the requested buffer
+            return;
+        }
         this._momentsPlayerProps = {
-            dataProvider: { type: 'buffer', buffer: initBufferFromProvider(this.momentsState.generatePlayerDataProvider(this._onPlayerReachedEnd)) },
+            dataProvider: {
+                type: 'buffer',
+                buffer: initBufferFromProvider(this.momentsState.generatePlayerDataProvider({
+                    initialId: data?.initialMomentId,
+                    onEndReached: this._callbacks.playerReachedEnd
+                }))
+            },
             socialInteractionsHandler: this._dataProvider.handlers?.socialInteractionsHandler,
             analyticsHandler: this._dataProvider.handlers?.analyticsHandler,
             playerSettings: this._mediaCenterSettingsHandler.playerSettings,
             closeOrchestrator: this._closeOrchestrator,
             on: {
-                postActivated: (id) => this.momentsState.markMomentAsSeen(id),
+                postActivated: (id) => {
+                    this.momentsState.markMomentAsSeen(id);
+                    this._callbacks.navigationStateChanged({ mode: 'moments', momentId: id });
+                },
                 backgroundImageLoaded: this._mediaCenterSettingsHandler.backgroundImageLoadedHandler
             }
         };
         this._active = true;
     };
+    tryRestoreState = (initialMomentId) => {
+        if (!this._active || !this._momentsPlayerProps) {
+            return false;
+        }
+        const buffer = this._momentsPlayerProps.dataProvider.type === 'buffer' ? this._momentsPlayerProps.dataProvider.buffer : null;
+        if (!buffer) {
+            return false;
+        }
+        return buffer.tryActivateItemById(initialMomentId);
+    };
 }

package/dist/media-center/media-center/moments/moments-state.svelte.d.ts

@@ -16,5 +16,8 @@ export declare class MomentsState {
         isSeen: boolean;
     }[];
     markMomentAsSeen: (momentId: string) => void;
-    generatePlayerDataProvider: (onEndReached: () => void) => IChunksPlayerDataProvider<PostPlayerModel>;
+    generatePlayerDataProvider: (data: {
+        initialId: string | null | undefined;
+        onEndReached: () => void;
+    }) => IChunksPlayerDataProvider<PostPlayerModel>;
 }

package/dist/media-center/media-center/moments/moments-state.svelte.js

@@ -17,7 +17,8 @@ export class MomentsState {
             this.momentsSeenLocally = [...this.momentsSeenLocally, momentId];
         }
     };
-    generatePlayerDataProvider = (onEndReached) => {
+    generatePlayerDataProvider = (data) => {
+        const { initialId, onEndReached } = data;
         const collectionCapacity = 5;
         const sortedMoments = [...this.allMoments].sort((a, b) => {
             const aUnwatched = !a.isSeen && !this.momentsSeenLocally.includes(a.id);
@@ -27,6 +28,13 @@ export class MomentsState {
             }
             return aUnwatched ? -1 : 1;
         });
+        if (initialId) {
+            const initialIndex = sortedMoments.findIndex((m) => m.id === initialId);
+            if (initialIndex >= 0) {
+                const [initialMoment] = sortedMoments.splice(initialIndex, 1);
+                sortedMoments.unshift(initialMoment);
+            }
+        }
         const ids = sortedMoments.map((m) => m.id);
         const idOrder = new Map();
         ids.forEach((id, idx) => idOrder.set(id, idx));
@@ -62,7 +70,7 @@ export class MomentsState {
                 const moments = await this.dataProvider.postsPlayer.getPostsCursor({
                     filter: {
                         types: [PostType.Moment],
-                        includeIds: momentsInChunk
+                        ids: momentsInChunk
                     },
                     limit: collectionCapacity
                 });

package/dist/media-center/media-center/{feed → posts-feed}/feed-providers-generator.d.ts

@@ -1,17 +1,13 @@
 import type { IMediaCenterDataProvider } from '../../config/types';
 import type { PostPlayerModel } from '../../../posts/posts-player/types';
-import type { IStreamsPlayerDataProvider } from '../../../streams/streams-player/types';
 import type { IFeedPlayerDataProvider } from '../../../ui/player/providers';
-import type { PostsDataProviderFilter, StreamsDataProviderFilter } from './types';
+import type { PostsFeedFilter, PostsFeedProviderInit } from './types';
 export declare class FeedProvidersGenerator {
     private dataProvider;
     constructor(dataProvider: IMediaCenterDataProvider);
     makePostPlayerItemsProvider: (data: {
-        filter?: PostsDataProviderFilter;
+        filter: PostsFeedFilter | undefined;
+        init: PostsFeedProviderInit | undefined;
         onEndReached: () => void;
-    }) => IFeedPlayerDataProvider<PostPlayerModel>;
-    makeStreamsPlayerDataProvider: (data: {
-        filter?: StreamsDataProviderFilter;
-        onEndReached: () => void;
-    }) => IStreamsPlayerDataProvider;
+    }) => Promise<IFeedPlayerDataProvider<PostPlayerModel>>;
 }

package/dist/media-center/media-center/posts-feed/feed-providers-generator.js

@@ -0,0 +1,61 @@
+import { ContinuationToken } from '../../../core/continuation-token';
+import { CursorDataLoader } from '../../../core/data-loaders';
+import { PostType } from '../../../core/enums';
+const SUPPORTED_POST_TYPES = [PostType.Article, PostType.Media, PostType.ShortVideo, PostType.Video];
+export class FeedProvidersGenerator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    makePostPlayerItemsProvider = async (data) => {
+        const { filter, init, onEndReached } = data;
+        const { categoryId } = filter || {};
+        const { prefetchedItems: initialPrefetchedItems = [], initialPostId } = init || {};
+        const loader = new CursorDataLoader({
+            loadPage: async (continuationToken) => {
+                const result = await this.dataProvider.postsPlayer.getPostsCursor({
+                    filter: {
+                        types: SUPPORTED_POST_TYPES,
+                        categoryId: categoryId || undefined,
+                        excludeIds: initialPrefetchedItems.length ? initialPrefetchedItems.map((i) => i.id) : undefined
+                    },
+                    continuationToken: continuationToken.toNextChunkString(),
+                    limit: 20
+                });
+                const items = result.items;
+                return {
+                    items: items,
+                    continuationToken: ContinuationToken.fromPayload(result.continuationToken)
+                };
+            }
+        });
+        if (initialPostId && !initialPrefetchedItems.find((p) => p.id === initialPostId)) {
+            const fetchedPost = await this.dataProvider.postsPlayer.getPostsCursor({
+                filter: {
+                    types: SUPPORTED_POST_TYPES,
+                    ids: [initialPostId]
+                },
+                limit: 1
+            });
+            if (fetchedPost.items.length) {
+                initialPrefetchedItems.push(fetchedPost.items[0]);
+            }
+        }
+        let prefetchedItems = initialPrefetchedItems;
+        if (initialPostId) {
+            const targetPost = prefetchedItems.find((p) => p.id === initialPostId);
+            if (targetPost) {
+                prefetchedItems = [targetPost, ...prefetchedItems.filter((p) => p.id !== initialPostId)];
+            }
+        }
+        return {
+            kind: 'feed',
+            initialData: {
+                prefetchedItems,
+                startIndex: prefetchedItems.length ? 0 : -1
+            },
+            loadMore: loader.loadMore,
+            onEndReached
+        };
+    };
+}

package/dist/media-center/media-center/posts-feed/index.d.ts

@@ -0,0 +1 @@
+export { PostsFeedHandler } from './posts-feed-handler.svelte';

package/dist/media-center/media-center/posts-feed/index.js

@@ -0,0 +1 @@
+export { PostsFeedHandler } from './posts-feed-handler.svelte';

package/dist/media-center/media-center/posts-feed/posts-feed-handler.svelte.d.ts

@@ -0,0 +1,42 @@
+import type { IMediaCenterDataProvider } from '../../config/types';
+import type { MediaCenterState } from '../../navigation';
+import type { PostPlayerModel, PostsPlayerProps } from '../../../posts/posts-player/types';
+import type { ICloseOrchestrator } from '../../../ui/player/close-orchestrator';
+import type { IPlayerDataProvider } from '../../../ui/player/providers';
+import { MediaCenterSettingsHandler } from '../handlers';
+import type { PostsFeedFilter, PostsFeedProviderInit } from './types';
+export declare class PostsFeedHandler {
+    private _state;
+    private _providersGenerator;
+    private _feedPlayerData;
+    private _dataProvider;
+    private _mediaCenterSettingsHandler;
+    private _closeOrchestrator;
+    private _callbacks;
+    constructor(data: {
+        dataProvider: IMediaCenterDataProvider;
+        mediaCenterSettingsHandler: MediaCenterSettingsHandler;
+        closeOrchestrator: ICloseOrchestrator;
+        on: Callbacks;
+    });
+    get activated(): boolean;
+    get active(): boolean;
+    get loading(): boolean;
+    get feedPlayerProps(): PostsPlayerProps | null;
+    deactivate: () => void;
+    activateWithExistingProvider: (data: {
+        dataProvider: IPlayerDataProvider<PostPlayerModel>;
+        onPostActivated?: (id: string) => void;
+    }) => Promise<void>;
+    activate: (options: Partial<{
+        filter: PostsFeedFilter;
+        init: PostsFeedProviderInit;
+    }>) => Promise<void>;
+    private tryRestoreState;
+    private makePostsPlayerProps;
+}
+type Callbacks = {
+    playerReachedEnd: () => void;
+    navigationStateChanged: (state: MediaCenterState) => void;
+};
+export {};

package/dist/media-center/media-center/posts-feed/posts-feed-handler.svelte.js

@@ -0,0 +1,106 @@
+import { Utils } from '../../../core/utils';
+import { initBufferFromProvider } from '../../../ui/player/providers/service';
+import { MediaCenterSettingsHandler } from '../handlers';
+import { FeedProvidersGenerator } from './feed-providers-generator';
+export class PostsFeedHandler {
+    _state = $state('inactive');
+    _providersGenerator;
+    _feedPlayerData = $state.raw(null);
+    _dataProvider;
+    _mediaCenterSettingsHandler;
+    _closeOrchestrator;
+    _callbacks;
+    constructor(data) {
+        const { dataProvider, mediaCenterSettingsHandler, closeOrchestrator, on } = data;
+        this._providersGenerator = new FeedProvidersGenerator(dataProvider);
+        this._mediaCenterSettingsHandler = mediaCenterSettingsHandler;
+        this._dataProvider = dataProvider;
+        this._closeOrchestrator = closeOrchestrator;
+        this._callbacks = on;
+    }
+    get activated() {
+        return this._state !== 'inactive';
+    }
+    get active() {
+        return this._state === 'ready';
+    }
+    get loading() {
+        return this._state === 'loading';
+    }
+    get feedPlayerProps() {
+        return this._feedPlayerData?.props || null;
+    }
+    deactivate = () => {
+        this._state = 'inactive';
+        this._feedPlayerData = null;
+    };
+    activateWithExistingProvider = async (data) => {
+        const { dataProvider, onPostActivated } = data;
+        const on = {
+            postActivated: (id) => {
+                onPostActivated?.(id);
+                this._callbacks.navigationStateChanged({ mode: 'posts-feed', postId: id, categoryId: null });
+            }
+        };
+        try {
+            this._state = 'loading';
+            if (!dataProvider.onEndReached) {
+                dataProvider.onEndReached = this._callbacks.playerReachedEnd;
+            }
+            this._feedPlayerData = {
+                props: this.makePostsPlayerProps({ dataProvider, on }),
+                filter: {}
+            };
+        }
+        finally {
+            this._state = 'ready';
+        }
+    };
+    activate = async (options) => {
+        const { filter, init } = options;
+        if (init?.initialPostId && this.tryRestoreState(init.initialPostId, filter)) {
+            // Already active with the requested buffer
+            return;
+        }
+        const on = {
+            postActivated: (id) => {
+                this._callbacks.navigationStateChanged({ mode: 'posts-feed', postId: id, categoryId: filter?.categoryId ?? null });
+            }
+        };
+        try {
+            this._state = 'loading';
+            const dataProvider = await this._providersGenerator.makePostPlayerItemsProvider({ filter, init, onEndReached: this._callbacks.playerReachedEnd });
+            this._feedPlayerData = {
+                props: this.makePostsPlayerProps({ dataProvider, on }),
+                filter: filter || {}
+            };
+        }
+        finally {
+            this._state = 'ready';
+        }
+    };
+    tryRestoreState = (initialPostId, filter) => {
+        if (this._state !== 'ready' || !this._feedPlayerData || !Utils.areEqual(this._feedPlayerData.filter, filter)) {
+            return false;
+        }
+        const buffer = this._feedPlayerData.props.dataProvider.type === 'buffer' ? this._feedPlayerData.props.dataProvider.buffer : null;
+        if (!buffer) {
+            return false;
+        }
+        return buffer.tryActivateItemById(initialPostId);
+    };
+    makePostsPlayerProps = (data) => {
+        const { dataProvider, on } = data;
+        return {
+            dataProvider: { type: 'buffer', buffer: initBufferFromProvider(dataProvider) },
+            socialInteractionsHandler: this._dataProvider.handlers?.socialInteractionsHandler,
+            analyticsHandler: this._dataProvider.handlers?.analyticsHandler,
+            playerSettings: this._mediaCenterSettingsHandler.playerSettings,
+            closeOrchestrator: this._closeOrchestrator,
+            on: {
+                postActivated: on.postActivated,
+                backgroundImageLoaded: this._mediaCenterSettingsHandler.backgroundImageLoadedHandler
+            }
+        };
+    };
+}

package/dist/media-center/media-center/posts-feed/types.d.ts

@@ -0,0 +1,8 @@
+import type { PostPlayerModel } from '../../../posts/posts-player/types';
+export type PostsFeedFilter = {
+    categoryId?: string | null;
+};
+export type PostsFeedProviderInit = {
+    prefetchedItems?: PostPlayerModel[];
+    initialPostId?: string | null;
+};

package/dist/media-center/media-center/streams-feed/feed-providers-generator.d.ts

@@ -0,0 +1,12 @@
+import type { IMediaCenterDataProvider } from '../../config/types';
+import type { IStreamsPlayerDataProvider } from '../../../streams/streams-player/types';
+import type { StreamsFeedFilter, StreamsFeedProviderInit } from './types';
+export declare class FeedProvidersGenerator {
+    private dataProvider;
+    constructor(dataProvider: IMediaCenterDataProvider);
+    makeStreamsPlayerDataProvider: (data: {
+        filter: StreamsFeedFilter | undefined;
+        init: StreamsFeedProviderInit | undefined;
+        onEndReached: () => void;
+    }) => Promise<IStreamsPlayerDataProvider>;
+}

package/dist/media-center/media-center/streams-feed/feed-providers-generator.js

@@ -0,0 +1,56 @@
+import { ContinuationToken } from '../../../core/continuation-token';
+import { CursorDataLoader } from '../../../core/data-loaders';
+export class FeedProvidersGenerator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    makeStreamsPlayerDataProvider = async (data) => {
+        const { filter, init, onEndReached } = data;
+        const { categoryId } = filter || {};
+        const { prefetchedStreams: initialPrefetchedStreams = [], initialStreamId } = init || {};
+        const loader = new CursorDataLoader({
+            loadPage: async (continuationToken) => {
+                const result = await this.dataProvider.streamPlayer.getStreamsCursor({
+                    filter: {
+                        categoryId: categoryId || undefined,
+                        excludeIds: initialPrefetchedStreams.length ? initialPrefetchedStreams.map((i) => i.id) : undefined
+                    },
+                    continuationToken: continuationToken.toNextChunkString(),
+                    limit: 20
+                });
+                const items = result.items;
+                return {
+                    items: items,
+                    continuationToken: ContinuationToken.fromPayload(result.continuationToken)
+                };
+            }
+        });
+        if (initialStreamId && !initialPrefetchedStreams.find((p) => p.id === initialStreamId)) {
+            const fetchedStreams = await this.dataProvider.streamPlayer.getStreamsCursor({
+                filter: {
+                    ids: [initialStreamId]
+                },
+                limit: 1
+            });
+            if (fetchedStreams.items.length) {
+                initialPrefetchedStreams.push(fetchedStreams.items[0]);
+            }
+        }
+        let prefetchedStreams = initialPrefetchedStreams;
+        if (initialStreamId) {
+            const targetStream = prefetchedStreams.find((stream) => stream.id === initialStreamId);
+            if (targetStream) {
+                prefetchedStreams = [targetStream, ...prefetchedStreams.filter((stream) => stream.id !== initialStreamId)];
+            }
+        }
+        return {
+            initialData: {
+                prefetchedStreams
+            },
+            loadMoreStreams: loader.loadMore,
+            getStreamPages: this.dataProvider.streamPlayer.getStreamPages,
+            onEndReached
+        };
+    };
+}

package/dist/media-center/media-center/streams-feed/index.d.ts

@@ -0,0 +1 @@
+export { StreamsFeedHandler } from './streams-feed-handler.svelte';

package/dist/media-center/media-center/streams-feed/index.js

@@ -0,0 +1 @@
+export { StreamsFeedHandler } from './streams-feed-handler.svelte';

package/dist/media-center/media-center/streams-feed/streams-feed-handler.svelte.d.ts

@@ -0,0 +1,45 @@
+import type { IMediaCenterDataProvider } from '../../config/types';
+import type { MediaCenterState } from '../../navigation';
+import type { StreamsPlayerProps, IStreamsPlayerDataProvider } from '../../../streams/streams-player/types';
+import type { ICloseOrchestrator } from '../../../ui/player/close-orchestrator';
+import { MediaCenterSettingsHandler } from '../handlers';
+import type { StreamsFeedFilter, StreamsFeedProviderInit } from './types';
+export declare class StreamsFeedHandler {
+    private _state;
+    private _providersGenerator;
+    private _feedPlayerData;
+    private _dataProvider;
+    private _mediaCenterSettingsHandler;
+    private _closeOrchestrator;
+    private _callbacks;
+    constructor(data: {
+        dataProvider: IMediaCenterDataProvider;
+        mediaCenterSettingsHandler: MediaCenterSettingsHandler;
+        closeOrchestrator: ICloseOrchestrator;
+        on: Callbacks;
+    });
+    get activated(): boolean;
+    get active(): boolean;
+    get loading(): boolean;
+    get feedPlayerProps(): StreamsPlayerProps | null;
+    deactivate: () => void;
+    activateWithExistingProvider: (data: {
+        dataProvider: IStreamsPlayerDataProvider;
+        onStreamActivated?: (data: {
+            id: string;
+            title: string;
+            image: string | null;
+        }) => void;
+    }) => Promise<void>;
+    activate: (options: Partial<{
+        filter: StreamsFeedFilter;
+        init: StreamsFeedProviderInit;
+    }>) => Promise<void>;
+    private tryRestoreState;
+    private makeStreamsPlayerProps;
+}
+type Callbacks = {
+    playerReachedEnd: () => void;
+    navigationStateChanged: (state: MediaCenterState) => void;
+};
+export {};