@streamscloud/embeddable 8.3.0 → 10.0.0

package/dist/ui/player/providers/chunks-player-buffer/player-chunk.svelte.js

@@ -0,0 +1,67 @@
+import { ContinuationToken } from '../../../../core/continuation-token';
+import { CursorDataLoader } from '../../../../core/data-loaders';
+import { PlayerChunkItem } from './player-chunk-item.svelte';
+const CHUNK_ITEMS_BUFFER_SIZE = 5;
+export class PlayerChunk {
+    model;
+    items = $derived.by(() => this._chunkItems.map((i) => i.model));
+    chunkItems = $derived.by(() => this._chunkItems);
+    chunkIndex;
+    activeChunkItem = $derived.by(() => this._chunkItems[this._activeItemIndex] ?? null);
+    isEmpty = $derived.by(() => this.isFullyLoaded && this._chunkItems.length === 0);
+    isFullyLoaded = $state(false);
+    _chunkItems = $state.raw([]);
+    _activeItemIndex = $state(0);
+    _isLoading = $state(false);
+    _itemsLoader;
+    constructor(data) {
+        const { chunk, provider, chunkIndex, callbacks } = data;
+        this.model = chunk;
+        this.chunkIndex = chunkIndex;
+        this._itemsLoader = new CursorDataLoader({
+            loadPage: async (continuationToken) => {
+                if (this.isFullyLoaded) {
+                    return null;
+                }
+                const result = await provider.loadChunkItems(this.model.id, continuationToken.toNextChunkString());
+                const newItems = result.items;
+                this._chunkItems = [
+                    ...this._chunkItems,
+                    ...newItems.map((item, index) => new PlayerChunkItem({
+                        model: item,
+                        indexWithinChunk: this._chunkItems.length + index,
+                        chunkId: this.model.id
+                    }))
+                ];
+                const continuationTokenResult = ContinuationToken.fromPayload(result.continuationToken);
+                if (!continuationTokenResult.canLoadMore) {
+                    this.isFullyLoaded = true;
+                    callbacks?.onChunkFullyLoaded(this);
+                }
+                return {
+                    items: newItems,
+                    continuationToken: continuationTokenResult
+                };
+            }
+        });
+    }
+    loadMore = () => this._itemsLoader.loadMore();
+    setActiveItemIndex = async (index, warmUp = true) => {
+        this._activeItemIndex = index;
+        if (warmUp) {
+            await this.warmUp();
+        }
+    };
+    warmUp = async () => {
+        if (this._chunkItems.length >= this._activeItemIndex + CHUNK_ITEMS_BUFFER_SIZE || this._isLoading) {
+            return;
+        }
+        this._isLoading = true;
+        try {
+            await this.loadMore();
+        }
+        finally {
+            this._isLoading = false;
+        }
+    };
+}

package/dist/ui/player/providers/chunks-player-buffer/player-chunks-manager.svelte.d.ts

@@ -0,0 +1,23 @@
+import { PlayerChunk } from './player-chunk.svelte';
+import type { IChunksPlayerDataProvider, WithId } from '../types';
+export declare class PlayerChunksManager<TItem extends WithId, TChunk extends WithId> {
+    private provider;
+    private callabacks;
+    readonly activeChunk: PlayerChunk<TItem, TChunk>;
+    readonly loadedChunks: PlayerChunk<TItem, TChunk>[];
+    readonly flattenedChunkItems: TItem[];
+    readonly flattenedActiveChunkItemIndex: number;
+    private _activeChunkIndex;
+    private _loadedChunks;
+    private _isLoading;
+    constructor(provider: IChunksPlayerDataProvider<TItem, TChunk>, callabacks: {
+        onInitializationFinished: () => void;
+        onEndReached: () => void;
+    });
+    initialize: () => Promise<void>;
+    setActiveChunkIndex: (index: number) => Promise<void>;
+    activateItemAtFlattenedIndex: (index: number) => Promise<void>;
+    warmUp: () => Promise<void>;
+    reset: () => void;
+    private populateChunkAtIndex;
+}

package/dist/ui/player/providers/chunks-player-buffer/player-chunks-manager.svelte.js

@@ -0,0 +1,119 @@
+import { PlayerChunk } from './player-chunk.svelte';
+const CHUNKS_BUFFER_SIZE = 5;
+const FIXED_START_INDEX = 0;
+export class PlayerChunksManager {
+    provider;
+    callabacks;
+    activeChunk = $derived.by(() => this._loadedChunks[this._activeChunkIndex] ?? null);
+    loadedChunks = $derived.by(() => this._loadedChunks);
+    flattenedChunkItems = $derived.by(() => this._loadedChunks.reduce((acc, chunk) => {
+        acc.push(...chunk.items);
+        return acc;
+    }, []));
+    flattenedActiveChunkItemIndex = $derived.by(() => {
+        if (!this.activeChunk || !this.activeChunk.activeChunkItem) {
+            return -1;
+        }
+        let itemsBeforeActiveChunk = 0;
+        for (let i = 0; i < this.activeChunk.chunkIndex; i++) {
+            itemsBeforeActiveChunk += this._loadedChunks[i].items.length;
+        }
+        return itemsBeforeActiveChunk + this.activeChunk.activeChunkItem.indexWithinChunk;
+    });
+    _activeChunkIndex = $state(-1);
+    _loadedChunks = $state.raw([]);
+    _isLoading = $state(false);
+    constructor(provider, callabacks) {
+        this.provider = provider;
+        this.callabacks = callabacks;
+    }
+    initialize = async () => {
+        const { onInitializationFinished, onEndReached } = this.callabacks;
+        const handleInitialized = async () => {
+            const startIndex = Math.min(FIXED_START_INDEX, this._loadedChunks.length - 1);
+            const populateChunkResult = await this.populateChunkAtIndex(startIndex, (currentIndex) => currentIndex + 1);
+            if (!populateChunkResult) {
+                onEndReached();
+                return;
+            }
+            this.setActiveChunkIndex(populateChunkResult.closestReadyChunkIndex);
+            if (populateChunkResult.closestReadyChunkIndex === FIXED_START_INDEX &&
+                this.provider.initialData.startItemIndex &&
+                this.provider.initialData.startItemIndex > 0) {
+                this.activeChunk.setActiveItemIndex(this.provider.initialData.startItemIndex);
+            }
+            onInitializationFinished();
+        };
+        this._loadedChunks = this.provider.initialData.prefetchedChunks.map((chunk, chunkIndex) => new PlayerChunk({ chunk, chunkIndex, provider: { loadChunkItems: this.provider.loadChunkItems } }));
+        const considerInitialized = this._loadedChunks.length !== 0;
+        if (considerInitialized) {
+            handleInitialized();
+        }
+        await this.warmUp();
+        if (!considerInitialized) {
+            handleInitialized();
+        }
+    };
+    setActiveChunkIndex = async (index) => {
+        this._activeChunkIndex = index;
+        this._loadedChunks.forEach((c) => c.setActiveItemIndex(0, false));
+        await this.populateChunkAtIndex(this._activeChunkIndex + 1, (currentIndex) => currentIndex + 1);
+    };
+    activateItemAtFlattenedIndex = async (index) => {
+        const activeChunkId = this.activeChunk?.model.id;
+        const flattenedItems = this.loadedChunks.flatMap((x) => x.chunkItems);
+        const nextItem = flattenedItems[index];
+        if (!nextItem) {
+            return;
+        }
+        if (nextItem.chunkId !== activeChunkId) {
+            this.setActiveChunkIndex(this.loadedChunks.findIndex((c) => c.model.id === nextItem.chunkId));
+            this.activeChunk.warmUp();
+        }
+        else {
+            this.activeChunk.setActiveItemIndex(nextItem.indexWithinChunk);
+        }
+    };
+    warmUp = async () => {
+        // Early return if manager is sufficient or already loading
+        if (this._loadedChunks.length >= this._activeChunkIndex + CHUNKS_BUFFER_SIZE || this._isLoading) {
+            return;
+        }
+        this._isLoading = true;
+        try {
+            const result = await this.provider.loadMoreChunks();
+            this._loadedChunks = [
+                ...this._loadedChunks,
+                ...result.map((chunk, index) => new PlayerChunk({
+                    chunk,
+                    chunkIndex: this._loadedChunks.length + index,
+                    provider: { loadChunkItems: this.provider.loadChunkItems }
+                }))
+            ];
+        }
+        finally {
+            this._isLoading = false;
+        }
+    };
+    reset = () => {
+        this._activeChunkIndex = -1;
+        this._loadedChunks = [];
+        this._isLoading = false;
+        this.warmUp();
+    };
+    populateChunkAtIndex = async (index, nextIndexFn) => {
+        const chunkAtIndex = this._loadedChunks[index];
+        if (!chunkAtIndex) {
+            return null;
+        }
+        await chunkAtIndex.warmUp();
+        if (chunkAtIndex.items.length === 0) {
+            const nextIndex = nextIndexFn(index);
+            if (nextIndex > index) {
+                await this.warmUp();
+            }
+            return await this.populateChunkAtIndex(nextIndexFn(index), nextIndexFn);
+        }
+        return { closestReadyChunkIndex: index };
+    };
+}

package/dist/ui/player/providers/default-chunks-player-buffer.svelte.d.ts

@@ -0,0 +1,20 @@
+import type { IChunksPlayerBuffer, IChunksPlayerDataProvider, WithId } from './types';
+export declare class DefaultChunksPlayerBuffer<TItem extends WithId, TChunk extends WithId> implements IChunksPlayerBuffer<TItem> {
+    readonly kind = "chunks";
+    readonly loaded: TItem[];
+    readonly currentIndex: number;
+    readonly current: TItem | null;
+    readonly canLoadNext: boolean;
+    readonly canLoadPrevious: boolean;
+    readonly navigationDisabled: boolean;
+    readonly animationDuration = 500;
+    private _playerChunksManager;
+    constructor(provider: IChunksPlayerDataProvider<TItem, TChunk>, on?: {
+        preloaded?: (self: DefaultChunksPlayerBuffer<TItem, TChunk>) => void;
+    });
+    get activeChunk(): import("./chunks-player-buffer").PlayerChunk<TItem, TChunk>;
+    setActiveChunkItemIndex: (index: number) => void;
+    loadNext: () => Promise<void>;
+    loadPrevious: () => Promise<void>;
+    reset: () => void;
+}

package/dist/ui/player/providers/default-chunks-player-buffer.svelte.js

@@ -0,0 +1,47 @@
+import { Utils } from '../../../core/utils';
+import { PlayerChunksManager } from './chunks-player-buffer';
+export class DefaultChunksPlayerBuffer {
+    kind = 'chunks';
+    loaded = $derived.by(() => this._playerChunksManager.flattenedChunkItems);
+    currentIndex = $derived.by(() => this._playerChunksManager.flattenedActiveChunkItemIndex);
+    current = $derived(this.currentIndex >= 0 ? this.loaded[this.currentIndex] : null);
+    canLoadNext = $derived(this.currentIndex < this.loaded.length - 1);
+    canLoadPrevious = $derived(this.currentIndex > 0);
+    navigationDisabled = $derived(!this.canLoadNext && !this.canLoadPrevious);
+    animationDuration = 500;
+    _playerChunksManager;
+    constructor(provider, on) {
+        // Throttle navigation methods
+        this.loadNext = Utils.throttle(this.loadNext, this.animationDuration);
+        this.loadPrevious = Utils.throttle(this.loadPrevious, this.animationDuration);
+        this._playerChunksManager = new PlayerChunksManager(provider, {
+            onInitializationFinished: () => on?.preloaded?.(this),
+            onEndReached: () => console.warn('end reached')
+        });
+        this._playerChunksManager.initialize();
+    }
+    get activeChunk() {
+        return this._playerChunksManager.activeChunk;
+    }
+    setActiveChunkItemIndex = (index) => {
+        if (!this.activeChunk) {
+            return;
+        }
+        this.activeChunk.setActiveItemIndex(index);
+    };
+    loadNext = async () => {
+        if (!this.canLoadNext) {
+            return;
+        }
+        this._playerChunksManager.activateItemAtFlattenedIndex(this.currentIndex + 1);
+    };
+    loadPrevious = async () => {
+        if (!this.canLoadPrevious) {
+            return;
+        }
+        this._playerChunksManager.activateItemAtFlattenedIndex(this.currentIndex - 1);
+    };
+    reset = () => {
+        this._playerChunksManager.reset();
+    };
+}

package/dist/ui/player/providers/default-feed-player-buffer.svelte.d.ts

@@ -0,0 +1,27 @@
+import type { IFeedPlayerBuffer, IFeedPlayerDataProvider, WithId } from './types';
+export declare class DefaultFeedPlayerBuffer<T extends WithId> implements IFeedPlayerBuffer<T> {
+    readonly kind = "feed";
+    readonly loaded: (T & {
+        mediaIndex?: number;
+    })[];
+    readonly currentIndex: number;
+    readonly current: (T & {
+        mediaIndex?: number;
+    }) | null;
+    readonly canLoadNext: boolean;
+    readonly canLoadPrevious: boolean;
+    readonly navigationDisabled: boolean;
+    readonly animationDuration = 500;
+    private _currentIndex;
+    private _loaded;
+    private _loadMoreFn;
+    private _isLoading;
+    constructor(provider: IFeedPlayerDataProvider<T>, on?: {
+        preloaded?: (self: DefaultFeedPlayerBuffer<T>) => void;
+    });
+    loadNext: () => Promise<void>;
+    loadPrevious: () => Promise<void>;
+    reset: () => void;
+    private initializeBuffer;
+    private warmUpBuffer;
+}

package/dist/ui/player/providers/default-feed-player-buffer.svelte.js

@@ -0,0 +1,78 @@
+import { Utils } from '../../../core/utils';
+const BUFFER_SIZE = 5;
+export class DefaultFeedPlayerBuffer {
+    kind = 'feed';
+    loaded = $derived.by(() => this._loaded);
+    currentIndex = $derived.by(() => this._currentIndex);
+    current = $derived(this.currentIndex >= 0 ? this.loaded[this.currentIndex] : null);
+    canLoadNext = $derived(this.currentIndex < this.loaded.length - 1);
+    canLoadPrevious = $derived(this.currentIndex > 0);
+    navigationDisabled = $derived(!this.canLoadNext && !this.canLoadPrevious);
+    animationDuration = 500;
+    _currentIndex = $state(-1);
+    _loaded = $state.raw([]);
+    _loadMoreFn;
+    _isLoading = $state(false);
+    constructor(provider, on) {
+        this._loadMoreFn = provider.loadMore;
+        // Throttle navigation methods
+        this.loadNext = Utils.throttle(this.loadNext, this.animationDuration);
+        this.loadPrevious = Utils.throttle(this.loadPrevious, this.animationDuration);
+        this.initializeBuffer({ initialData: provider.initialData, onPreloaded: on?.preloaded });
+    }
+    loadNext = async () => {
+        if (!this.canLoadNext) {
+            return;
+        }
+        ++this._currentIndex;
+        this.warmUpBuffer();
+    };
+    loadPrevious = async () => {
+        if (!this.canLoadPrevious) {
+            return;
+        }
+        --this._currentIndex;
+    };
+    reset = () => {
+        this._loaded = [];
+        this._currentIndex = -1;
+        this._isLoading = false;
+        this.warmUpBuffer();
+    };
+    initializeBuffer = async (options) => {
+        const { initialData, onPreloaded } = options;
+        const handleInitialized = () => {
+            const startIndex = initialData.startIndex >= 0 ? initialData.startIndex : 0;
+            this._currentIndex = Math.min(startIndex, this._loaded.length - 1);
+            const hasCustomMediaIndex = initialData.startMediaIndex && initialData.startMediaIndex > 0;
+            const activeItem = this._loaded[this._currentIndex];
+            if (activeItem && hasCustomMediaIndex) {
+                activeItem.mediaIndex = initialData.startMediaIndex;
+            }
+            onPreloaded?.(this);
+        };
+        this._loaded = initialData.prefetchedItems;
+        const considerInitialized = this._loaded.length > 0;
+        if (considerInitialized) {
+            handleInitialized();
+        }
+        await this.warmUpBuffer();
+        if (!considerInitialized) {
+            handleInitialized();
+        }
+    };
+    warmUpBuffer = async () => {
+        // Early return if buffer is sufficient or already loading
+        if (this._loaded.length >= this.currentIndex + BUFFER_SIZE || this._isLoading) {
+            return;
+        }
+        this._isLoading = true;
+        try {
+            const result = await this._loadMoreFn();
+            this._loaded = [...this._loaded, ...result];
+        }
+        finally {
+            this._isLoading = false;
+        }
+    };
+}

package/dist/ui/player/providers/index.d.ts

@@ -0,0 +1,3 @@
+export type { IPlayerBuffer, IPlayerDataProvider, IFeedPlayerDataProvider, IChunksPlayerDataProvider } from './types';
+export { DefaultFeedPlayerBuffer } from './default-feed-player-buffer.svelte';
+export { DefaultChunksPlayerBuffer } from './default-chunks-player-buffer.svelte';

package/dist/ui/player/providers/index.js

@@ -0,0 +1,2 @@
+export { DefaultFeedPlayerBuffer } from './default-feed-player-buffer.svelte';
+export { DefaultChunksPlayerBuffer } from './default-chunks-player-buffer.svelte';

package/dist/ui/player/providers/types.d.ts

@@ -0,0 +1,49 @@
+export type IPlayerDataProvider<T extends WithId> = IFeedPlayerDataProvider<T> | IChunksPlayerDataProvider<T>;
+export interface IFeedPlayerDataProvider<T extends WithId> {
+    kind: 'feed';
+    initialData: {
+        prefetchedItems: T[];
+        startIndex: number;
+        startMediaIndex?: number;
+    };
+    loadMore(): Promise<T[]>;
+}
+export interface IChunksPlayerDataProvider<TItem extends WithId, TChunk extends WithId = WithId> {
+    kind: 'chunks';
+    initialData: {
+        prefetchedChunks: TChunk[];
+        startItemIndex?: number;
+    };
+    loadMoreChunks: () => Promise<TChunk[]>;
+    loadChunkItems: (chunkId: string, continuationToken: string | null | undefined) => Promise<{
+        items: TItem[];
+        continuationToken: string | null;
+    }>;
+}
+export type IPlayerBuffer<T extends WithId> = IFeedPlayerBuffer<T> | IChunksPlayerBuffer<T>;
+export interface IPlayerBufferBase<T extends WithId> {
+    readonly kind: 'feed' | 'chunks';
+    readonly current: TExtended<T> | null;
+    readonly loaded: TExtended<T>[];
+    readonly currentIndex: number;
+    readonly canLoadNext: boolean;
+    readonly canLoadPrevious: boolean;
+    readonly navigationDisabled: boolean;
+    readonly animationDuration: number;
+    loadNext: () => void;
+    loadPrevious: () => void;
+    reset: () => void;
+}
+type TExtended<T> = T & {
+    mediaIndex?: number;
+};
+export interface IFeedPlayerBuffer<T extends WithId> extends IPlayerBufferBase<T> {
+    readonly kind: 'feed';
+}
+export interface IChunksPlayerBuffer<T extends WithId> extends IPlayerBufferBase<T> {
+    readonly kind: 'chunks';
+}
+export type WithId = {
+    id: string;
+};
+export {};

package/dist/ui/{player-slider → player/slider}/cmp.player-slider.svelte

@@ -6,8 +6,8 @@ let sliderHeight = $state(0);
 let swipeTransition = $state(0);
 let cssAnimationDuration = $state(buffer.animationDuration * 0.55);
 let resizeObserver;
-let activeIndex = $state.raw(buffer.currentIndex);
-const actualTransition = $derived(-sliderHeight * activeIndex);
+let sliderIndex = $state.raw(buffer.currentIndex);
+const actualTransition = $derived(-sliderHeight * sliderIndex);
 const onKeyPress = (e) => {
     if (e.key === 'ArrowUp' || e.key === 'PageUp') {
         buffer.loadPrevious();
@@ -17,29 +17,16 @@ const onKeyPress = (e) => {
     }
 };
 $effect(() => {
-    if (buffer.currentIndex >= 0 && activeIndex >= 0 && Math.abs(activeIndex - buffer.currentIndex) === 1) {
+    if (buffer.currentIndex >= 0 && sliderIndex >= 0 && Math.abs(sliderIndex - buffer.currentIndex) === 1) {
         slidesRef.classList.toggle('animate', true);
     }
-    else if (buffer.currentIndex >= 0 && (Math.abs(activeIndex - buffer.currentIndex) !== 0 || !active)) {
+    else if (buffer.currentIndex >= 0 && (Math.abs(sliderIndex - buffer.currentIndex) !== 0 || !active)) {
         untrack(() => notifyOnItemChanged());
     }
 });
-// Notify the parent component that the active item is about to change.
 let active = null;
 $effect(() => {
-    if (buffer.currentIndex >= 0 && activeIndex >= 0 && activeIndex !== buffer.currentIndex && on) {
-        untrack(() => {
-            var _a, _b, _c;
-            if (active && ((_a = buffer.current) === null || _a === void 0 ? void 0 : _a.id) !== active.id) {
-                (_b = on === null || on === void 0 ? void 0 : on.itemPreDeactivated) === null || _b === void 0 ? void 0 : _b.call(on, { itemId: active.id, loadingNext: buffer.currentIndex > activeIndex });
-            }
-            const nextItem = buffer.loaded[buffer.currentIndex];
-            if (nextItem) {
-                (_c = on === null || on === void 0 ? void 0 : on.itemPreActivated) === null || _c === void 0 ? void 0 : _c.call(on, nextItem);
-            }
-        });
-    }
-    activeIndex = buffer.currentIndex;
+    sliderIndex = buffer.currentIndex;
 });
 const notifyOnItemChanged = () => {
     var _a, _b, _c;
@@ -172,9 +159,9 @@ const wheelCallbacks = {
   <div class="player-slider__slides" bind:this={slidesRef} use:createWheelAdapter={{ cbs: wheelCallbacks }} style={styles}>
     {#each buffer.loaded as item, index (item)}
       <div class="player-slider__slide">
-        {#if index >= activeIndex - 1 && index <= activeIndex + 1}
+        {#if index >= sliderIndex - 1 && index <= sliderIndex + 1}
           <!-- Only render the active slide and its immediate neighbors for performance -->
-          {@render children({ item, active: index === activeIndex })}
+          {@render children({ item, active: index === sliderIndex })}
         {/if}
       </div>
     {/each}

package/dist/ui/{player-slider → player/slider}/cmp.player-slider.svelte.d.ts

@@ -1,13 +1,13 @@
-import type { IPlayerBuffer, PlayerSliderCallbacks, TExtended } from './types';
+import type { PlayerSliderBuffer, PlayerSliderCallbacks } from './types';
 import { type Snippet } from 'svelte';
 declare class __sveltets_Render<T extends {
     id: string;
 }> {
     props(): {
-        buffer: IPlayerBuffer<T>;
-        on?: PlayerSliderCallbacks<T> | undefined;
+        buffer: PlayerSliderBuffer<T>;
+        on?: PlayerSliderCallbacks;
         children: Snippet<[{
-            item: TExtended<T>;
+            item: T;
             active?: boolean;
         }]>;
     };

package/dist/ui/{player-slider → player/slider}/index.d.ts

@@ -1,4 +1,2 @@
-export type { IPlayerBuffer } from './types';
-export { PlayerBuffer, type IPlayerItemsProvider } from './player-buffer.svelte';
 export { default as PlayerSlider } from './cmp.player-slider.svelte';
 export { preventSliderScroll } from './prevent-slider-scroll';

package/dist/ui/{player-slider → player/slider}/index.js

@@ -1,3 +1,2 @@
-export { PlayerBuffer } from './player-buffer.svelte';
 export { default as PlayerSlider } from './cmp.player-slider.svelte';
 export { preventSliderScroll } from './prevent-slider-scroll';

package/dist/ui/player/slider/types.d.ts

@@ -0,0 +1,16 @@
+export type PlayerSliderCallbacks = {
+    itemActivated?: (e: string) => void;
+    itemDeactivated?: (e: string) => void;
+};
+export interface PlayerSliderBuffer<T extends {
+    id: string;
+}> {
+    readonly current: T | null;
+    readonly loaded: T[];
+    readonly currentIndex: number;
+    readonly canLoadNext: boolean;
+    readonly canLoadPrevious: boolean;
+    readonly animationDuration: number;
+    loadNext: () => void;
+    loadPrevious: () => void;
+}

package/dist/ui/swipe-indicator/cmp.swipe-indicator.svelte

@@ -27,8 +27,7 @@ const indicatorMounted = (_) => {
   </div>
 </div>
 
-<style>@charset "UTF-8";
-@keyframes fadeIn {
+<style>@keyframes fadeIn {
   0% {
     opacity: 1;
   }
@@ -87,37 +86,37 @@ const indicatorMounted = (_) => {
     transform: translateY(0);
   }
   10% {
-    transform: translateY(-24px); /* основной прыжок */
+    transform: translateY(-24px);
   }
   18% {
     transform: translateY(0);
   }
   26% {
-    transform: translateY(-12px); /* первый малый отскок */
+    transform: translateY(-12px);
   }
   34% {
     transform: translateY(0);
   }
   41% {
-    transform: translateY(-8px); /* второй малый отскок */
+    transform: translateY(-8px);
   }
   48% {
     transform: translateY(0);
   }
   54% {
-    transform: translateY(-4px); /* третий малый отскок */
+    transform: translateY(-4px);
   }
   60% {
     transform: translateY(0);
   }
   65% {
-    transform: translateY(-2px); /* почти затух */
+    transform: translateY(-2px);
   }
   70% {
     transform: translateY(0);
   }
   75% {
-    transform: translateY(-1px); /* совсем маленький */
+    transform: translateY(-1px);
   }
   80% {
     transform: translateY(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/embeddable",
-  "version": "8.3.0",
+  "version": "10.0.0",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",
@@ -49,9 +49,9 @@
       "types": "./dist/posts/post-viewer/index.d.ts",
       "svelte": "./dist/posts/post-viewer/index.js"
     },
-    "./stream-player": {
-      "types": "./dist/streams/stream-player/index.d.ts",
-      "svelte": "./dist/streams/stream-player/index.js"
+    "./streams-player": {
+      "types": "./dist/streams/streams-player/index.d.ts",
+      "svelte": "./dist/streams/streams-player/index.js"
     },
     "./short-videos-player": {
       "types": "./dist/short-videos/short-videos-player/index.d.ts",

package/dist/media-center/media-center/short-video-resources-generator.d.ts

@@ -1,8 +0,0 @@
-import type { ShortVideoPlayerModel } from '../../short-videos/short-videos-player';
-import type { IPlayerItemsProvider } from '../../ui/player-slider';
-import type { IMediaCenterConfig } from '../config/types';
-export declare const makeShortVideosProvider: (data: {
-    config: IMediaCenterConfig;
-    categoryId?: string;
-    prefetchedItems?: ShortVideoPlayerModel[];
-}) => IPlayerItemsProvider<ShortVideoPlayerModel>;

package/dist/short-videos/short-videos-player/cmp.short-videos-player.svelte.d.ts

@@ -1,4 +0,0 @@
-import type { ShortVideoPlayerProps } from './types';
-declare const Cmp: import("svelte").Component<ShortVideoPlayerProps, {}, "">;
-type Cmp = ReturnType<typeof Cmp>;
-export default Cmp;

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

@@ -1,18 +0,0 @@
-import type { IPlayerItemsProvider } from '../../ui/player-slider';
-import type { ShortVideoPlayerModel } from './types';
-export declare class InternalShortVideoPlayerProvider implements IPlayerItemsProvider<ShortVideoPlayerModel> {
-    initialData: IPlayerItemsProvider<ShortVideoPlayerModel>['initialData'];
-    private ids;
-    private idOrder;
-    private initialId?;
-    private graphql;
-    private dataLoader;
-    constructor(input: {
-        ids: string[];
-        initiator?: string;
-        graphqlOrigin?: string;
-        initialId?: string;
-    });
-    loadMore: () => Promise<ShortVideoPlayerModel[]>;
-    prefetch: () => Promise<void>;
-}

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

@@ -1,3 +0,0 @@
-import type { GetShortVideosQuery } from './operations.generated';
-import type { ShortVideoPlayerModel } from './types';
-export declare const mapToShortVideoPlayerModel: (payload: GetShortVideosQuery["shortVideos"]["items"][0]) => ShortVideoPlayerModel;