@streamscloud/embeddable 13.3.0 → 14.0.0

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

@@ -27,9 +27,6 @@ const selectCategory = (categoryId) => __awaiter(void 0, void 0, void 0, functio
     }
     switch (context.mediaCenterMode) {
         case 'posts-feed':
-            if (!context.postsFeedHandler.feedPlayerProps) {
-                return;
-            }
             if (context.categoriesHandler.selectedCategoryId === categoryId) {
                 return;
             }
@@ -48,11 +45,26 @@ const selectCategory = (categoryId) => __awaiter(void 0, void 0, void 0, functio
             Utils.assertUnreachable(context.mediaCenterMode);
     }
 });
-const activateSelectedShortVideoPlayer = (shortVideo) => {
-    context.playPostsFeed({ init: { prefetchedItems: [shortVideo] } });
+const resetMediaCenterMode = () => {
+    if (!context.mediaCenterMode) {
+        return;
+    }
+    switch (context.mediaCenterMode) {
+        case 'streams-feed':
+            context.playStreamsFeed({ filter: { categoryId: null } });
+            break;
+        case 'discover':
+            context.activateDiscover({ categoryId: null });
+            break;
+        default:
+            context.playPostsFeed({ filter: { categoryId: null } });
+    }
 };
-const activateSelectedStreamPlayer = (stream) => {
-    context.playStreamsFeed({ init: { prefetchedStreams: [stream] } });
+const activateSelectedShortVideoPlayer = (shortVideo, categoryId) => {
+    context.playPostsFeed({ init: { prefetchedItems: [shortVideo] }, filter: { categoryId } });
+};
+const activateSelectedStreamPlayer = (stream, categoryId) => {
+    context.playStreamsFeed({ init: { prefetchedStreams: [stream] }, filter: { categoryId } });
 };
 const activateSelectedStreamOfCategoryPlayer = (id, prefetchedStreams, categoryId) => {
     context.playStreamsFeed({ filter: { categoryId }, init: { prefetchedStreams, initialStreamId: id } });
@@ -138,24 +150,24 @@ const swipeToOpen = (node) => {
     <div class="media-center__content-container" use:swipeToOpen>
       {#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} />
+          <PostsPlayerView {...context.postsFeedHandler.feedPlayerProps} managementActions={context.postsFeedHandler.managementActions} />
         </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 }}>
-          <StreamsPlayerView {...context.streamsFeedHandler.feedPlayerProps} />
+          <StreamsPlayerView {...context.streamsFeedHandler.feedPlayerProps} managementActions={context.streamsFeedHandler.managementActions} />
         </div>
       {:else if context.mediaCenterMode === 'discover'}
         <div class="media-center__content" transition:fade={{ duration: 300 }}>
           <DiscoverPanel
             context={context}
             on={{
-              shortVideoSelected: (shortVideo) => activateSelectedShortVideoPlayer(shortVideo),
-              streamSelected: (stream) => activateSelectedStreamPlayer(stream)
+              shortVideoSelected: activateSelectedShortVideoPlayer,
+              streamSelected: activateSelectedStreamPlayer
             }} />
         </div>
       {: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.momentsFeedHandler.momentsPlayerProps} />
+          <PostsPlayerView {...context.momentsFeedHandler.momentsPlayerProps} managementActions={context.momentsFeedHandler.managementActions} />
         </div>
       {/if}
     </div>
@@ -163,7 +175,13 @@ const swipeToOpen = (node) => {
     {#if context.menuActive}
       <div class="menu-overlay" class:menu-overlay--mobile={isMobileView} onclick={context.hideMenu} onkeydown={() => {}} role="none">
         <div class="menu-overlay__panel">
-          <Menu context={context} on={{ categorySelected: selectCategory, streamSelected: activateSelectedStreamPlayer }} />
+          <Menu
+            context={context}
+            on={{
+              categorySelected: selectCategory,
+              streamSelected: (stream) => activateSelectedStreamPlayer(stream, null),
+              resetModeRequested: resetMediaCenterMode
+            }} />
         </div>
       </div>
     {/if}

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

@@ -71,7 +71,7 @@ const styles = $derived.by(() => {
     <div class="media-center-menu__tree">
       <div class="media-center-menu__tree-item">
         <div class="menu-item" class:menu-item--active={!context.categoriesHandler.selectedCategoryId}>
-          <div class="menu-item__content" onclick={() => context.playRootFeed()} onkeydown={() => {}} role="button" tabindex="0">
+          <div class="menu-item__content" onclick={() => on.resetModeRequested()} onkeydown={() => {}} role="button" tabindex="0">
             <div class="menu-item__text" class:menu-item__text--active={!context.categoriesHandler.selectedCategoryId}>
               {context.mediaCenterMode === 'discover' ? localization.discoverLabel : localization.feedLabel}
             </div>
@@ -94,7 +94,9 @@ const styles = $derived.by(() => {
             </div>
             {#if category.value.tag}
               <div class="menu-item__tag" style="background-color: {category.value.tag.backgroundColor}; color: {category.value.tag.fontColor};">
-                {category.value.tag.text}
+                <div class="menu-item__tag-text">
+                  {category.value.tag.text}
+                </div>
               </div>
             {/if}
           </div>
@@ -296,10 +298,19 @@ const styles = $derived.by(() => {
   border-radius: 0.25rem;
   padding: 0.3125rem 0.375rem;
   font-size: 0.5rem;
+  line-height: 1.2;
   font-weight: 600;
   margin-top: -1rem;
   margin-left: 0.25rem;
 }
+.menu-item__tag-text {
+  display: -webkit-box;
+  line-clamp: 2;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
 .menu-item__collapser {
   --icon--color: var(--sc-mc-color--text-primary);
   --icon--size: 1rem;

package/dist/media-center/media-center/menu/menu.svelte.d.ts

@@ -5,6 +5,7 @@ type Props = {
     on: {
         categorySelected: (categoryId: string) => void;
         streamSelected: (stream: StreamPlayerModel) => void;
+        resetModeRequested: () => void;
     };
 };
 declare const Menu: import("svelte").Component<Props, {}, "">;

package/dist/media-center/media-center/menu/popular-streams-panel-handler.svelte.d.ts

@@ -7,4 +7,11 @@ export declare class PopularStreamsPanelHandler {
     constructor(dataProvider: IMediaCenterDataProvider);
     get streamSectionItems(): StreamPlayerModel[];
     init: () => Promise<void>;
+    onStreamModified: (data: {
+        stream: StreamPlayerModel;
+    }) => void;
+    onStreamDeleted: (data: {
+        id: string;
+    }) => void;
+    private loadStreams;
 }

package/dist/media-center/media-center/menu/popular-streams-panel-handler.svelte.js

@@ -10,14 +10,29 @@ export class PopularStreamsPanelHandler {
     }
     init = async () => {
         if (this._state === 'not-initialized') {
-            this._state = 'loading';
-            try {
-                const streamsResponse = await this.dataProvider.streamPlayer.getStreamsCursor({ filter: {}, limit: 2 });
-                this._streams = streamsResponse.items;
-            }
-            finally {
-                this._state = 'ready';
-            }
+            await this.loadStreams();
+        }
+    };
+    onStreamModified = (data) => {
+        const { stream } = data;
+        if (this._streams.some((s) => s.id === stream.id)) {
+            this.loadStreams();
+        }
+    };
+    onStreamDeleted = (data) => {
+        const { id } = data;
+        if (this._streams.some((s) => s.id === id)) {
+            this.loadStreams();
+        }
+    };
+    loadStreams = async () => {
+        this._state = 'loading';
+        try {
+            const streamsResponse = await this.dataProvider.streamPlayer.getStreamsCursor({ filter: {}, limit: 2 });
+            this._streams = streamsResponse.items;
+        }
+        finally {
+            this._state = 'ready';
         }
     };
 }

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

@@ -1,20 +1,23 @@
 import type { IMediaCenterDataProvider } from '../../config/types';
 import type { MediaCenterState } from '../../navigation';
-import type { PostsPlayerProps } from '../../../posts/posts-player/types';
+import type { PostPlayerModel, PostsPlayerProps, PostManagementActions } from '../../../posts/posts-player/types';
 import type { ICloseOrchestrator } from '../../../ui/player/close-orchestrator';
+import type { IPlayerBuffer } from '../../../ui/player/providers';
 import { MomentsState } from './moments-state.svelte';
-import { MediaCenterSettingsHandler } from '../handlers';
+import { MediaCenterContentHandler, MediaCenterSettingsHandler } from '../handlers';
 export declare class MomentsFeedHandler {
     momentsState: MomentsState;
     private _active;
     private _momentsPlayerProps;
     private _dataProvider;
     private _mediaCenterSettingsHandler;
+    private _mediaCenterContentHandler;
     private _closeOrchestrator;
     private _callbacks;
     constructor(data: {
         dataProvider: IMediaCenterDataProvider;
         mediaCenterSettingsHandler: MediaCenterSettingsHandler;
+        mediaCenterContentHandler: MediaCenterContentHandler;
         closeOrchestrator: ICloseOrchestrator;
         on: Callbacks;
     });
@@ -22,10 +25,24 @@ export declare class MomentsFeedHandler {
     get momentsPlayerProps(): PostsPlayerProps | null;
     get hasUnwatchedMoments(): boolean;
     get hasMoments(): boolean;
+    get feedBuffer(): IPlayerBuffer<PostPlayerModel> | null;
+    get managementActions(): PostManagementActions;
     deactivate: () => void;
     activate: (data?: {
         initialMomentId?: string | null;
+        tryRestoreState?: boolean;
     }) => Promise<void>;
+    onPostCreated: (data: {
+        post: PostPlayerModel;
+        isPublished: boolean;
+    }) => void;
+    onPostModified: (data: {
+        post: PostPlayerModel;
+        isPublished: boolean;
+    }) => false | undefined;
+    onPostDeleted: (data: {
+        id: string;
+    }) => void;
     private tryRestoreState;
 }
 type Callbacks = {

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

@@ -1,18 +1,21 @@
+import { PostType } from '../../../core/enums';
 import { initBufferFromProvider } from '../../../ui/player/providers/service';
 import { MomentsState } from './moments-state.svelte';
-import { MediaCenterSettingsHandler } from '../handlers';
+import { MediaCenterContentHandler, MediaCenterSettingsHandler } from '../handlers';
 export class MomentsFeedHandler {
     momentsState;
     _active = $state(false);
     _momentsPlayerProps = $state.raw(null);
     _dataProvider;
     _mediaCenterSettingsHandler;
+    _mediaCenterContentHandler;
     _closeOrchestrator;
     _callbacks;
     constructor(data) {
         const { dataProvider, mediaCenterSettingsHandler, closeOrchestrator, on } = data;
         this.momentsState = new MomentsState(dataProvider);
         this._mediaCenterSettingsHandler = mediaCenterSettingsHandler;
+        this._mediaCenterContentHandler = data.mediaCenterContentHandler;
         this._dataProvider = dataProvider;
         this._closeOrchestrator = closeOrchestrator;
         this._callbacks = on;
@@ -29,12 +32,26 @@ export class MomentsFeedHandler {
     get hasMoments() {
         return this.momentsState.allMoments.length > 0;
     }
+    get feedBuffer() {
+        if (!this._momentsPlayerProps) {
+            return null;
+        }
+        const buffer = this._momentsPlayerProps.dataProvider.type === 'buffer' ? this._momentsPlayerProps.dataProvider.buffer : null;
+        return buffer;
+    }
+    get managementActions() {
+        return {
+            editPost: this._mediaCenterContentHandler.editPost,
+            editArticle: null,
+            deletePost: this._mediaCenterContentHandler.deletePost
+        };
+    }
     deactivate = () => {
         this._active = false;
         this._momentsPlayerProps = null;
     };
     activate = async (data) => {
-        if (data?.initialMomentId && this.tryRestoreState(data.initialMomentId)) {
+        if (data?.tryRestoreState && data?.initialMomentId && this.tryRestoreState(data.initialMomentId)) {
             // Already active with the requested buffer
             return;
         }
@@ -46,7 +63,8 @@ export class MomentsFeedHandler {
                     onEndReached: this._callbacks.playerReachedEnd
                 }))
             },
-            socialInteractionsHandler: this._dataProvider.handlers?.socialInteractionsHandler,
+            socialInteractionsHandler: this._dataProvider.handlers?.postSocialInteractionsHandler,
+            sharingHandler: this._dataProvider.handlers?.postSharingHandler,
             analyticsHandler: this._dataProvider.handlers?.analyticsHandler,
             playerSettings: this._mediaCenterSettingsHandler.playerSettings,
             closeOrchestrator: this._closeOrchestrator,
@@ -60,14 +78,41 @@ export class MomentsFeedHandler {
         };
         this._active = true;
     };
+    onPostCreated = (data) => {
+        if (!this._active || !data.isPublished || data.post.postType !== PostType.Moment) {
+            return;
+        }
+        // Reactivate to include the new moment
+        this.activate();
+    };
+    onPostModified = (data) => {
+        if (!this._active) {
+            return false;
+        }
+        const postStillInTheFeed = data.isPublished && data.post.postType === PostType.Moment;
+        if (postStillInTheFeed) {
+            this.activate({ initialMomentId: data.post.id });
+        }
+        else {
+            this.onPostDeleted({ id: data.post.id });
+        }
+    };
+    onPostDeleted = (data) => {
+        const nextMomentId = this.momentsState.removeMomentById(data.id);
+        if (nextMomentId) {
+            this.activate({ initialMomentId: nextMomentId });
+        }
+        else {
+            this._callbacks.playerReachedEnd();
+        }
+    };
     tryRestoreState = (initialMomentId) => {
         if (!this._active || !this._momentsPlayerProps) {
             return false;
         }
-        const buffer = this._momentsPlayerProps.dataProvider.type === 'buffer' ? this._momentsPlayerProps.dataProvider.buffer : null;
-        if (!buffer) {
+        if (!this.feedBuffer) {
             return false;
         }
-        return buffer.tryActivateItemById(initialMomentId);
+        return this.feedBuffer.tryActivateItemById(initialMomentId);
     };
 }

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

@@ -4,6 +4,7 @@ import type { IChunksPlayerDataProvider } from '../../../ui/player/providers';
 export declare class MomentsState {
     private readonly dataProvider;
     private momentsSeenLocally;
+    private removedMomentsIds;
     constructor(dataProvider: IMediaCenterDataProvider);
     get allMoments(): {
         id: string;
@@ -16,6 +17,7 @@ export declare class MomentsState {
         isSeen: boolean;
     }[];
     markMomentAsSeen: (momentId: string) => void;
+    removeMomentById: (id: string) => string | null;
     generatePlayerDataProvider: (data: {
         initialId: string | null | undefined;
         onEndReached: () => void;

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

@@ -3,11 +3,12 @@ import {} from '../../../posts/posts-player';
 export class MomentsState {
     dataProvider;
     momentsSeenLocally = $state.raw([]);
+    removedMomentsIds = $state.raw([]);
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
     }
     get allMoments() {
-        return this.dataProvider.model?.moments ?? [];
+        return (this.dataProvider.model?.moments ?? []).filter((m) => !this.removedMomentsIds.includes(m.id));
     }
     get unwatchedMoments() {
         return this.allMoments.filter((s) => !s.isSeen && !this.momentsSeenLocally.includes(s.id));
@@ -17,6 +18,20 @@ export class MomentsState {
             this.momentsSeenLocally = [...this.momentsSeenLocally, momentId];
         }
     };
+    removeMomentById = (id) => {
+        const currentIndex = this.allMoments.findIndex((m) => m.id === id);
+        let nextMomentId = null;
+        if (currentIndex !== -1) {
+            if (currentIndex < this.allMoments.length - 1) {
+                nextMomentId = this.allMoments[currentIndex + 1].id;
+            }
+            else if (currentIndex > 0) {
+                nextMomentId = this.allMoments[currentIndex - 1].id;
+            }
+        }
+        this.removedMomentsIds = [...this.removedMomentsIds, id];
+        return nextMomentId;
+    };
     generatePlayerDataProvider = (data) => {
         const { initialId, onEndReached } = data;
         const collectionCapacity = 5;

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

@@ -1,9 +1,9 @@
 import type { IMediaCenterDataProvider } from '../../config/types';
 import type { MediaCenterState } from '../../navigation';
-import type { PostPlayerModel, PostsPlayerProps } from '../../../posts/posts-player/types';
+import type { PostManagementActions, 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 { IPlayerBuffer, IPlayerDataProvider } from '../../../ui/player/providers';
+import { MediaCenterContentHandler, MediaCenterSettingsHandler } from '../handlers';
 import type { PostsFeedFilter, PostsFeedProviderInit } from './types';
 export declare class PostsFeedHandler {
     private _state;
@@ -11,11 +11,13 @@ export declare class PostsFeedHandler {
     private _feedPlayerData;
     private _dataProvider;
     private _mediaCenterSettingsHandler;
+    private _mediaCenterContentHandler;
     private _closeOrchestrator;
     private _callbacks;
     constructor(data: {
         dataProvider: IMediaCenterDataProvider;
         mediaCenterSettingsHandler: MediaCenterSettingsHandler;
+        mediaCenterContentHandler: MediaCenterContentHandler;
         closeOrchestrator: ICloseOrchestrator;
         on: Callbacks;
     });
@@ -23,15 +25,33 @@ export declare class PostsFeedHandler {
     get active(): boolean;
     get loading(): boolean;
     get feedPlayerProps(): PostsPlayerProps | null;
+    get feedBuffer(): IPlayerBuffer<PostPlayerModel> | null;
+    get managementActions(): PostManagementActions;
+    get canReload(): boolean;
     deactivate: () => void;
-    activateWithExistingProvider: (data: {
+    activateWithDataProvider: (data: {
         dataProvider: IPlayerDataProvider<PostPlayerModel>;
         onPostActivated?: (id: string) => void;
     }) => Promise<void>;
     activate: (options: Partial<{
         filter: PostsFeedFilter;
         init: PostsFeedProviderInit;
+        tryRestoreState?: boolean;
     }>) => Promise<void>;
+    onPostCreated: (data: {
+        post: PostPlayerModel;
+        categories: string[];
+        isPublished: boolean;
+    }) => false | undefined;
+    onPostModified: (data: {
+        post: PostPlayerModel;
+        categories: string[];
+        isPublished: boolean;
+    }) => false | undefined;
+    onPostDeleted: (data: {
+        id: string;
+    }) => false | undefined;
+    private checkIfEditedPostAffectsFeed;
     private tryRestoreState;
     private makePostsPlayerProps;
 }

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

@@ -1,6 +1,7 @@
+import { PostType } from '../../..';
 import { Utils } from '../../../core/utils';
 import { initBufferFromProvider } from '../../../ui/player/providers/service';
-import { MediaCenterSettingsHandler } from '../handlers';
+import { MediaCenterContentHandler, MediaCenterSettingsHandler } from '../handlers';
 import { FeedProvidersGenerator } from './feed-providers-generator';
 export class PostsFeedHandler {
     _state = $state('inactive');
@@ -8,12 +9,14 @@ export class PostsFeedHandler {
     _feedPlayerData = $state.raw(null);
     _dataProvider;
     _mediaCenterSettingsHandler;
+    _mediaCenterContentHandler;
     _closeOrchestrator;
     _callbacks;
     constructor(data) {
-        const { dataProvider, mediaCenterSettingsHandler, closeOrchestrator, on } = data;
+        const { dataProvider, mediaCenterSettingsHandler, mediaCenterContentHandler, closeOrchestrator, on } = data;
         this._providersGenerator = new FeedProvidersGenerator(dataProvider);
         this._mediaCenterSettingsHandler = mediaCenterSettingsHandler;
+        this._mediaCenterContentHandler = mediaCenterContentHandler;
         this._dataProvider = dataProvider;
         this._closeOrchestrator = closeOrchestrator;
         this._callbacks = on;
@@ -30,11 +33,44 @@ export class PostsFeedHandler {
     get feedPlayerProps() {
         return this._feedPlayerData?.props || null;
     }
+    get feedBuffer() {
+        if (!this._feedPlayerData) {
+            return null;
+        }
+        const buffer = this._feedPlayerData.props.dataProvider.type === 'buffer' ? this._feedPlayerData.props.dataProvider.buffer : null;
+        return buffer;
+    }
+    get managementActions() {
+        return {
+            editPost: this._mediaCenterContentHandler.editPost,
+            editArticle: this._mediaCenterContentHandler.editArticle,
+            deletePost: this._mediaCenterContentHandler.deletePost
+        };
+    }
+    get canReload() {
+        switch (this._state) {
+            case 'ready': {
+                if (!this.feedBuffer) {
+                    return true;
+                }
+                return this.feedBuffer.currentIndex > 0;
+            }
+            case 'inactive': {
+                return true;
+            }
+            case 'loading': {
+                return false;
+            }
+            default: {
+                Utils.assertUnreachable(this._state);
+            }
+        }
+    }
     deactivate = () => {
         this._state = 'inactive';
         this._feedPlayerData = null;
     };
-    activateWithExistingProvider = async (data) => {
+    activateWithDataProvider = async (data) => {
         const { dataProvider, onPostActivated } = data;
         const on = {
             postActivated: (id) => {
@@ -57,8 +93,8 @@ export class PostsFeedHandler {
         }
     };
     activate = async (options) => {
-        const { filter, init } = options;
-        if (init?.initialPostId && this.tryRestoreState(init.initialPostId, filter)) {
+        const { filter, init, tryRestoreState } = options;
+        if (tryRestoreState && init?.initialPostId && this.tryRestoreState(init.initialPostId, filter)) {
             // Already active with the requested buffer
             return;
         }
@@ -79,21 +115,66 @@ export class PostsFeedHandler {
             this._state = 'ready';
         }
     };
+    onPostCreated = (data) => {
+        if (this._state !== 'ready') {
+            return false;
+        }
+        if (!this.checkIfEditedPostAffectsFeed(data)) {
+            return;
+        }
+        this.activate({
+            filter: this._feedPlayerData?.filter,
+            init: { initialPostId: data.post.id, prefetchedItems: [data.post] }
+        });
+    };
+    onPostModified = (data) => {
+        if (this._state !== 'ready') {
+            return false;
+        }
+        const postStillInTheFeed = this.checkIfEditedPostAffectsFeed(data);
+        if (postStillInTheFeed) {
+            this.activate({
+                filter: this._feedPlayerData?.filter,
+                init: { initialPostId: data.post.id, prefetchedItems: [data.post] }
+            });
+        }
+        else {
+            this.onPostDeleted({ id: data.post.id });
+        }
+    };
+    onPostDeleted = (data) => {
+        if (this._state !== 'ready') {
+            return false;
+        }
+        this.feedBuffer?.removeItemById(data.id);
+    };
+    checkIfEditedPostAffectsFeed = (data) => {
+        const { post, categories, isPublished } = data;
+        if (!isPublished) {
+            // Unpublished posts never affect the feed
+            return false;
+        }
+        if (post.postType === PostType.Moment) {
+            // Moments are processed separately
+            return false;
+        }
+        return !this._feedPlayerData?.filter.categoryId || categories.includes(this._feedPlayerData.filter.categoryId);
+    };
     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) {
+        if (!this.feedBuffer) {
             return false;
         }
-        return buffer.tryActivateItemById(initialPostId);
+        return this.feedBuffer.tryActivateItemById(initialPostId);
     };
     makePostsPlayerProps = (data) => {
         const { dataProvider, on } = data;
         return {
             dataProvider: { type: 'buffer', buffer: initBufferFromProvider(dataProvider) },
-            socialInteractionsHandler: this._dataProvider.handlers?.socialInteractionsHandler,
+            socialInteractionsHandler: this._dataProvider.handlers?.postSocialInteractionsHandler,
+            sharingHandler: this._dataProvider.handlers?.postSharingHandler,
             analyticsHandler: this._dataProvider.handlers?.analyticsHandler,
             playerSettings: this._mediaCenterSettingsHandler.playerSettings,
             closeOrchestrator: this._closeOrchestrator,

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

@@ -1,8 +1,9 @@
 import type { IMediaCenterDataProvider } from '../../config/types';
 import type { MediaCenterState } from '../../navigation';
-import type { StreamsPlayerProps, IStreamsPlayerDataProvider } from '../../../streams/streams-player/types';
+import { StreamsPlayerBuffer } from '../../../streams/streams-player/streams-player-buffer.svelte';
+import type { StreamsPlayerProps, IStreamsPlayerDataProvider, StreamManagementActions, StreamPlayerModel } from '../../../streams/streams-player/types';
 import type { ICloseOrchestrator } from '../../../ui/player/close-orchestrator';
-import { MediaCenterSettingsHandler } from '../handlers';
+import { MediaCenterContentHandler, MediaCenterSettingsHandler } from '../handlers';
 import type { StreamsFeedFilter, StreamsFeedProviderInit } from './types';
 export declare class StreamsFeedHandler {
     private _state;
@@ -10,11 +11,13 @@ export declare class StreamsFeedHandler {
     private _feedPlayerData;
     private _dataProvider;
     private _mediaCenterSettingsHandler;
+    private _mediaCenterContentHandler;
     private _closeOrchestrator;
     private _callbacks;
     constructor(data: {
         dataProvider: IMediaCenterDataProvider;
         mediaCenterSettingsHandler: MediaCenterSettingsHandler;
+        mediaCenterContentHandler: MediaCenterContentHandler;
         closeOrchestrator: ICloseOrchestrator;
         on: Callbacks;
     });
@@ -22,8 +25,11 @@ export declare class StreamsFeedHandler {
     get active(): boolean;
     get loading(): boolean;
     get feedPlayerProps(): StreamsPlayerProps | null;
+    get feedBuffer(): StreamsPlayerBuffer | null;
+    get managementActions(): StreamManagementActions | undefined;
+    get canReload(): boolean;
     deactivate: () => void;
-    activateWithExistingProvider: (data: {
+    activateWithDataProvider: (data: {
         dataProvider: IStreamsPlayerDataProvider;
         onStreamActivated?: (data: {
             id: string;
@@ -34,7 +40,16 @@ export declare class StreamsFeedHandler {
     activate: (options: Partial<{
         filter: StreamsFeedFilter;
         init: StreamsFeedProviderInit;
+        tryRestoreState?: boolean;
     }>) => Promise<void>;
+    onStreamModified: (data: {
+        stream: StreamPlayerModel;
+        categories: string[];
+        isPublished: boolean;
+    }) => false | undefined;
+    onStreamPageDeleted: (data: {
+        id: string;
+    }) => false | undefined;
     private tryRestoreState;
     private makeStreamsPlayerProps;
 }