@streamscloud/embeddable 14.0.0-rc.0 → 14.0.0

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;
 }

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

@@ -1,6 +1,6 @@
 import { Utils } from '../../../core/utils';
 import { StreamsPlayerBuffer } from '../../../streams/streams-player/streams-player-buffer.svelte';
-import { MediaCenterSettingsHandler } from '../handlers';
+import { MediaCenterContentHandler, MediaCenterSettingsHandler } from '../handlers';
 import { FeedProvidersGenerator } from './feed-providers-generator';
 export class StreamsFeedHandler {
     _state = $state('inactive');
@@ -8,12 +8,14 @@ export class StreamsFeedHandler {
     _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 +32,43 @@ export class StreamsFeedHandler {
     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 {
+            editStream: this._mediaCenterContentHandler.editStream,
+            deleteStreamPage: this._mediaCenterContentHandler.deleteStreamPage
+        };
+    }
+    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, onStreamActivated } = data;
         const on = {
             streamActivated: (data) => {
@@ -60,8 +94,8 @@ export class StreamsFeedHandler {
         }
     };
     activate = async (options) => {
-        const { filter, init } = options;
-        if (init?.initialStreamPageId && this.tryRestoreState(init.initialStreamPageId, filter)) {
+        const { filter, init, tryRestoreState } = options;
+        if (tryRestoreState && init?.initialStreamPageId && this.tryRestoreState(init.initialStreamPageId, filter)) {
             // Already active with the requested buffer
             return;
         }
@@ -83,22 +117,43 @@ export class StreamsFeedHandler {
             this._state = 'ready';
         }
     };
+    onStreamModified = (data) => {
+        if (this._state !== 'ready') {
+            return false;
+        }
+        const streamStillInTheFeed = data.isPublished && (!this._feedPlayerData?.filter.categoryId || data.categories.includes(this._feedPlayerData.filter.categoryId));
+        if (streamStillInTheFeed) {
+            this.activate({
+                filter: this._feedPlayerData?.filter,
+                init: { initialStreamId: data.stream.id, prefetchedStreams: [data.stream] }
+            });
+        }
+        else {
+            this.feedBuffer?.removeChunkById(data.stream.id);
+        }
+    };
+    onStreamPageDeleted = (data) => {
+        if (this._state !== 'ready') {
+            return false;
+        }
+        this.feedBuffer?.removeItemById(data.id);
+    };
     tryRestoreState = (initialStreamPageId, 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(initialStreamPageId);
+        return this.feedBuffer.tryActivateItemById(initialStreamPageId);
     };
     makeStreamsPlayerProps = (data) => {
         const { dataProvider, on } = data;
         return {
             dataProvider: { type: 'buffer', buffer: new StreamsPlayerBuffer(dataProvider) },
             analyticsHandler: this._dataProvider.handlers?.analyticsHandler,
-            postSocialInteractionsHandler: this._dataProvider.handlers?.socialInteractionsHandler,
+            postSocialInteractionsHandler: this._dataProvider.handlers?.postSocialInteractionsHandler,
+            sharingHandler: this._dataProvider.handlers?.streamSharingHandler,
             playerSettings: this._mediaCenterSettingsHandler.playerSettings,
             closeOrchestrator: this._closeOrchestrator,
             on: {

package/dist/media-center/media-center/streams-in-category/streams-in-category-panel.svelte

@@ -80,23 +80,19 @@ let { handler, on } = $props();
   gap: 2rem 1.25rem;
   grid-template-columns: repeat(5, minmax(0, 1fr));
   /* Set 'container-type: inline-size;' to reference container*/
+  /* Set 'container-type: inline-size;' to reference container*/
+  /* Set 'container-type: inline-size;' to reference container*/
 }
 @container (width < 992px) {
   .streams-in-category__section-content {
     grid-template-columns: repeat(4, minmax(0, 1fr));
   }
 }
-.streams-in-category__section-content {
-  /* Set 'container-type: inline-size;' to reference container*/
-}
 @container (width < 768px) {
   .streams-in-category__section-content {
     grid-template-columns: repeat(3, minmax(0, 1fr));
   }
 }
-.streams-in-category__section-content {
-  /* Set 'container-type: inline-size;' to reference container*/
-}
 @container (width < 576px) {
   .streams-in-category__section-content {
     grid-template-columns: repeat(2, minmax(0, 1fr));

package/dist/posts/controls/index.d.ts

@@ -1 +1,2 @@
-export { default as PostControls } from './cmp.controls.svelte';
+export { PostActionsGenerator } from './post-actions-generator.svelte';
+export { PostActionsHandler } from './post-actions-handler.svelte';

package/dist/posts/controls/index.js

@@ -1 +1,2 @@
-export { default as PostControls } from './cmp.controls.svelte';
+export { PostActionsGenerator } from './post-actions-generator.svelte';
+export { PostActionsHandler } from './post-actions-handler.svelte';

package/dist/posts/controls/post-actions-generator.svelte.d.ts

@@ -0,0 +1,20 @@
+import type { PostModel } from '../model';
+import type { IPostSharingHandler } from '../sharing';
+import type { IPostSocialInteractionsHandler } from '../social-interactions';
+import { PostActionsHandler } from './post-actions-handler.svelte';
+export declare class PostActionsGenerator {
+    private socialInteractionsHandler;
+    private sharingHandler;
+    private callbacks;
+    private handlers;
+    constructor(init: {
+        socialInteractionsHandler: IPostSocialInteractionsHandler | undefined;
+        sharingHandler: IPostSharingHandler | undefined;
+        on: PostActionCallbacks;
+    });
+    getPostActionsHandler: (model: PostModel) => PostActionsHandler;
+}
+type PostActionCallbacks = {
+    attachmentClicked: () => void;
+};
+export {};

package/dist/posts/controls/post-actions-generator.svelte.js

@@ -0,0 +1,27 @@
+import { PostActionsHandler } from './post-actions-handler.svelte';
+export class PostActionsGenerator {
+    socialInteractionsHandler;
+    sharingHandler;
+    callbacks;
+    handlers = new Map();
+    constructor(init) {
+        this.socialInteractionsHandler = init.socialInteractionsHandler ?? null;
+        this.sharingHandler = init.sharingHandler ?? null;
+        this.callbacks = init.on;
+    }
+    getPostActionsHandler = (model) => {
+        let handler = this.handlers.get(model.id);
+        if (!handler) {
+            handler = new PostActionsHandler({
+                post: model,
+                socialInteractionsHandler: this.socialInteractionsHandler,
+                callbacks: {
+                    attachmentClicked: this.callbacks.attachmentClicked,
+                    shareClicked: this.sharingHandler ? () => this.sharingHandler?.share(model.id) : undefined
+                }
+            });
+            this.handlers.set(model.id, handler);
+        }
+        return handler;
+    };
+}

package/dist/posts/controls/post-actions-handler.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { PostModel } from '../model';
+import type { IPostSocialInteractionsHandler } from '../social-interactions';
+import { IconColor } from '../../ui/icon';
+export declare class PostActionsHandler {
+    readonly actions: PostAction[];
+    private post;
+    private socialInteractionsHandler;
+    private callbacks;
+    private isLikedStore;
+    constructor(init: {
+        post: PostModel;
+        socialInteractionsHandler: IPostSocialInteractionsHandler | null;
+        callbacks: PostActionCallbacks;
+    });
+    private initIsLikedStore;
+}
+type PostAction = {
+    icon: string;
+    iconColor?: IconColor;
+    callback: () => void;
+};
+type PostActionCallbacks = {
+    attachmentClicked: () => void;
+    shareClicked?: () => void;
+};
+export {};