@streamscloud/embeddable 15.1.0 → 16.0.0

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

@@ -1,220 +0,0 @@
-import { Deferred } from '../../../../core/deferred';
-import { PlayerChunk } from './player-chunk.svelte';
-const ITEMS_BUFFER_SIZE = 10;
-// Configuration: if true, always start from first item when switching chunks
-// if false, activate the exact item at its position in the new chunk
-const START_FROM_FIRST_ITEM_ON_CHUNK_SWITCH = true;
-export class PlayerChunksManager {
-    provider;
-    _activeChunkIndex = $state(-1);
-    _loadedChunks = $state.raw([]);
-    _warmUpDeferred = $state.raw(null);
-    constructor(provider) {
-        this.provider = provider;
-    }
-    get activeChunk() {
-        return this._loadedChunks[this._activeChunkIndex] ?? null;
-    }
-    get loadedChunks() {
-        return this._loadedChunks;
-    }
-    get isLoading() {
-        return this._warmUpDeferred !== null || this._loadedChunks.some((c) => c.isLoading);
-    }
-    get flattenedChunkItems() {
-        return this._loadedChunks.reduce((acc, chunk) => {
-            acc.push(...chunk.items);
-            return acc;
-        }, []);
-    }
-    get flattenedActiveChunkItemIndex() {
-        if (!this.activeChunk || !this.activeChunk.activeChunkItem) {
-            return -1;
-        }
-        let itemsBeforeActiveChunk = 0;
-        for (let i = 0; i < this._activeChunkIndex; i++) {
-            itemsBeforeActiveChunk += this._loadedChunks[i].items.length;
-        }
-        return itemsBeforeActiveChunk + this.activeChunk.activeItemIndex;
-    }
-    tryActivateItemById = (id) => {
-        const chunkWithItemIndex = this._loadedChunks.findIndex((chunk) => chunk.items.some((item) => item.id === id));
-        const chunkWithItem = this._loadedChunks[chunkWithItemIndex];
-        if (!chunkWithItem) {
-            return false;
-        }
-        const itemIndex = chunkWithItem.items.findIndex((item) => item.id === id);
-        this.setActiveChunkIndex(chunkWithItemIndex, itemIndex);
-        return true;
-    };
-    removeItemById = (id) => {
-        const itemIndex = this.flattenedChunkItems.findIndex((item) => item.id === id);
-        if (itemIndex === -1) {
-            return false;
-        }
-        const currentItem = this.flattenedChunkItems[this.flattenedActiveChunkItemIndex];
-        // Find next item to activate BEFORE removing (if removing current item)
-        let nextItemId = currentItem?.id;
-        if (this.flattenedActiveChunkItemIndex === itemIndex) {
-            // Try next item
-            if (itemIndex + 1 < this.flattenedChunkItems.length) {
-                nextItemId = this.flattenedChunkItems[itemIndex + 1].id;
-            }
-            // Try previous item
-            else if (itemIndex > 0) {
-                nextItemId = this.flattenedChunkItems[itemIndex - 1].id;
-            }
-            else {
-                // No items left
-                nextItemId = null;
-            }
-        }
-        // Remove item from chunks
-        this._loadedChunks.forEach((chunk) => {
-            if (chunk.chunkItems.some((i) => i.model.id === id)) {
-                chunk.mutateChunkItems(chunk.chunkItems.filter((i) => i.model.id !== id));
-            }
-        });
-        if (nextItemId) {
-            this.tryActivateItemById(nextItemId);
-        }
-        else {
-            this._activeChunkIndex = -1;
-        }
-        return true;
-    };
-    removeChunkById = (id) => {
-        const chunkIndex = this._loadedChunks.findIndex((chunk) => chunk.model.id === id);
-        if (chunkIndex === -1) {
-            return false;
-        }
-        const isActiveChunk = this._activeChunkIndex === chunkIndex;
-        let newActiveChunkIndex = this._activeChunkIndex;
-        this._loadedChunks.splice(chunkIndex, 1);
-        if (this._loadedChunks.length === 0) {
-            this._activeChunkIndex = -1;
-            this.provider.onEndReached?.();
-            return;
-        }
-        if (isActiveChunk) {
-            if (chunkIndex < this._loadedChunks.length) {
-                newActiveChunkIndex = chunkIndex;
-            }
-            else {
-                newActiveChunkIndex = this._loadedChunks.length - 1;
-            }
-        }
-        else if (this._activeChunkIndex > chunkIndex) {
-            newActiveChunkIndex--;
-        }
-        this.setActiveChunkIndex(newActiveChunkIndex, 0);
-        return true;
-    };
-    initialize = async () => {
-        this._loadedChunks = this.provider.initialData.prefetchedChunks.map((chunk) => new PlayerChunk({ chunk, provider: { loadChunkItems: this.provider.loadChunkItems } }));
-        await this.warmUp();
-        if (this._loadedChunks.length === 0 || this.flattenedChunkItems.length === 0) {
-            this.provider.onEndReached?.();
-            return;
-        }
-        const firstFilledChunkIndex = this._loadedChunks.findIndex((c) => c.items.length > 0);
-        const initialStartItemIndex = firstFilledChunkIndex === 0 && this.provider.initialData.startItemIndex && this.provider.initialData.startItemIndex > 0
-            ? this.provider.initialData.startItemIndex
-            : 0;
-        this.setActiveChunkIndex(firstFilledChunkIndex, initialStartItemIndex);
-    };
-    setActiveChunkIndex = async (index, chunkItemIndex) => {
-        this._activeChunkIndex = index;
-        this.activeChunk.setActiveItemIndex(chunkItemIndex);
-        // Don't wait for warm up to be finished, it runs in the background
-        this.warmUp();
-    };
-    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) {
-            const nextChunkIndex = this.loadedChunks.findIndex((c) => c.model.id === nextItem.chunkId);
-            if (nextChunkIndex === -1) {
-                return;
-            }
-            const itemIndexInChunk = START_FROM_FIRST_ITEM_ON_CHUNK_SWITCH ? 0 : this.loadedChunks[nextChunkIndex].chunkItems.indexOf(nextItem);
-            this.setActiveChunkIndex(nextChunkIndex, itemIndexInChunk);
-        }
-        else {
-            this.activeChunk.setActiveItemIndex(this.activeChunk.chunkItems.indexOf(nextItem));
-            // Don't wait for warm up to be finished, it runs in the background
-            this.warmUp();
-        }
-    };
-    warmUp = async () => {
-        if (this._warmUpDeferred) {
-            return this._warmUpDeferred.promise;
-        }
-        this._warmUpDeferred = new Deferred();
-        try {
-            await this.warmUpSequentially();
-        }
-        finally {
-            this._warmUpDeferred.resolve();
-            this._warmUpDeferred = null;
-        }
-    };
-    reset = async () => {
-        this._activeChunkIndex = -1;
-        this._loadedChunks = [];
-        this._warmUpDeferred = null;
-        await this.warmUp();
-    };
-    warmUpSequentially = async () => {
-        const startChunkIndex = Math.max(0, this._activeChunkIndex);
-        // Calculate how many items we need ahead of current position
-        const getItemsAhead = () => {
-            const currentFlatIndex = this.flattenedActiveChunkItemIndex;
-            const totalItems = this.flattenedChunkItems.length;
-            return totalItems - currentFlatIndex - 1; // -1 because current item doesn't count
-        };
-        while (getItemsAhead() < ITEMS_BUFFER_SIZE) {
-            // Find first non-fully-loaded chunk starting from active
-            let targetChunkIndex = -1;
-            for (let i = startChunkIndex; i < this._loadedChunks.length; i++) {
-                if (this._loadedChunks[i].canLoadMore) {
-                    targetChunkIndex = i;
-                    break;
-                }
-            }
-            // If all chunks are fully loaded, load more chunks
-            if (targetChunkIndex === -1) {
-                const result = await this.provider.loadMoreChunks();
-                if (result.length === 0) {
-                    // No more chunks available
-                    break;
-                }
-                this._loadedChunks = [
-                    ...this._loadedChunks,
-                    ...result.map((chunk) => new PlayerChunk({
-                        chunk,
-                        provider: { loadChunkItems: this.provider.loadChunkItems }
-                    }))
-                ];
-                continue; // Re-check for chunks to fill
-            }
-            // Load one page from target chunk
-            const chunk = this._loadedChunks[targetChunkIndex];
-            const itemsBefore = chunk.items.length;
-            await chunk.loadMore();
-            const itemsAfter = chunk.items.length;
-            // If chunk became fully loaded but added no items, continue to next chunk
-            if (itemsAfter === itemsBefore && !chunk.canLoadMore) {
-                continue;
-            }
-            // If no progress made and chunk is not fully loaded, something went wrong
-            if (itemsAfter === itemsBefore && chunk.canLoadMore) {
-                break; // Avoid infinite loop
-            }
-        }
-    };
-}

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

@@ -1,23 +0,0 @@
-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;
-    private _onEndReachedFn;
-    constructor(provider: IChunksPlayerDataProvider<TItem, TChunk>);
-    get activeChunk(): import("./chunks-player-buffer").PlayerChunk<TItem, TChunk>;
-    setActiveChunkItemIndex: (index: number) => void;
-    tryActivateItemById: (id: string) => boolean;
-    removeChunkById: (id: string) => boolean | undefined;
-    removeItemById: (id: string) => boolean;
-    loadNext: () => Promise<void>;
-    loadPrevious: () => Promise<void>;
-    reset: () => void;
-    ensureWarmedUp: () => Promise<void>;
-}

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

@@ -1,71 +0,0 @@
-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.by(() => {
-        if (this.loaded.length && this.currentIndex < this.loaded.length - 1) {
-            return true;
-        }
-        // Check if manager is still loading
-        if (this._playerChunksManager.isLoading) {
-            return false; // Don't trigger onEndReached while loading
-        }
-        return !!this._onEndReachedFn;
-    });
-    canLoadPrevious = $derived(this.currentIndex > 0);
-    navigationDisabled = $derived(!this.canLoadNext && !this.canLoadPrevious);
-    animationDuration = 500;
-    _playerChunksManager;
-    _onEndReachedFn;
-    constructor(provider) {
-        this._onEndReachedFn = provider.onEndReached;
-        // Throttle navigation methods
-        this.loadNext = Utils.throttle(this.loadNext, this.animationDuration);
-        this.loadPrevious = Utils.throttle(this.loadPrevious, this.animationDuration);
-        this._playerChunksManager = new PlayerChunksManager(provider);
-        this._playerChunksManager.initialize();
-    }
-    get activeChunk() {
-        return this._playerChunksManager.activeChunk;
-    }
-    setActiveChunkItemIndex = (index) => {
-        if (!this.activeChunk) {
-            return;
-        }
-        this.activeChunk.setActiveItemIndex(index);
-    };
-    tryActivateItemById = (id) => {
-        return this._playerChunksManager.tryActivateItemById(id);
-    };
-    removeChunkById = (id) => {
-        return this._playerChunksManager.removeChunkById(id);
-    };
-    removeItemById = (id) => {
-        return this._playerChunksManager.removeItemById(id);
-    };
-    loadNext = async () => {
-        if (!this.canLoadNext) {
-            return;
-        }
-        if (this.currentIndex < this.loaded.length - 1) {
-            this._playerChunksManager.activateItemAtFlattenedIndex(this.currentIndex + 1);
-            return;
-        }
-        this._onEndReachedFn?.();
-    };
-    loadPrevious = async () => {
-        if (!this.canLoadPrevious) {
-            return;
-        }
-        this._playerChunksManager.activateItemAtFlattenedIndex(this.currentIndex - 1);
-    };
-    reset = () => {
-        this._playerChunksManager.reset();
-    };
-    ensureWarmedUp = async () => {
-        await this._playerChunksManager.warmUp();
-    };
-}

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

@@ -1,29 +0,0 @@
-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 _fetchDeferred;
-    private _onEndReachedFn;
-    constructor(provider: IFeedPlayerDataProvider<T>);
-    tryActivateItemById: (id: string) => boolean;
-    removeItemById: (id: string) => boolean;
-    loadNext: () => Promise<void>;
-    loadPrevious: () => Promise<void>;
-    reset: () => void;
-    ensureWarmedUp: () => Promise<void>;
-    private initializeBuffer;
-    private warmUpBuffer;
-}

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

@@ -1,121 +0,0 @@
-import { Deferred } from '../../../core/deferred';
-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.by(() => {
-        if (this.loaded.length && this.currentIndex < this.loaded.length - 1) {
-            return true;
-        }
-        return !this._fetchDeferred && !!this._onEndReachedFn;
-    });
-    canLoadPrevious = $derived(this.currentIndex > 0);
-    navigationDisabled = $derived(!this.canLoadNext && !this.canLoadPrevious);
-    animationDuration = 500;
-    _currentIndex = $state(-1);
-    _loaded = $state.raw([]);
-    _loadMoreFn;
-    _fetchDeferred = $state.raw(null);
-    _onEndReachedFn;
-    constructor(provider) {
-        this._onEndReachedFn = provider.onEndReached;
-        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 });
-    }
-    tryActivateItemById = (id) => {
-        const itemIndex = this._loaded.findIndex((item) => item.id === id);
-        if (itemIndex === -1) {
-            return false;
-        }
-        this._currentIndex = itemIndex;
-        return true;
-    };
-    removeItemById = (id) => {
-        const itemIndex = this._loaded.findIndex((item) => item.id === id);
-        if (itemIndex === -1) {
-            return false;
-        }
-        this._loaded = this._loaded.filter((item) => item.id !== id);
-        if (itemIndex < this._currentIndex) {
-            this._currentIndex--;
-        }
-        else if (itemIndex === this._currentIndex) {
-            if (this._currentIndex >= this._loaded.length) {
-                this._currentIndex = this._loaded.length - 1;
-            }
-            // Otherwise keep the same index (activates next item)
-        }
-        return true;
-    };
-    loadNext = async () => {
-        if (!this.canLoadNext) {
-            return;
-        }
-        if (this.currentIndex < this.loaded.length - 1) {
-            ++this._currentIndex;
-            await this.warmUpBuffer();
-            return;
-        }
-        this._onEndReachedFn?.();
-    };
-    loadPrevious = async () => {
-        if (!this.canLoadPrevious) {
-            return;
-        }
-        --this._currentIndex;
-    };
-    reset = () => {
-        this._loaded = [];
-        this._currentIndex = -1;
-        this._fetchDeferred = null;
-        this.warmUpBuffer();
-    };
-    ensureWarmedUp = async () => {
-        await this.warmUpBuffer();
-    };
-    initializeBuffer = async (options) => {
-        const { initialData } = 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;
-            }
-        };
-        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._fetchDeferred) {
-            return this._fetchDeferred.promise;
-        }
-        if (this._loaded.length >= this.currentIndex + BUFFER_SIZE) {
-            return;
-        }
-        this._fetchDeferred = new Deferred();
-        try {
-            const result = await this._loadMoreFn();
-            this._loaded = [...this._loaded, ...result];
-        }
-        finally {
-            this._fetchDeferred.resolve();
-            this._fetchDeferred = null;
-        }
-    };
-}

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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,2 +0,0 @@
-import type { IPlayerBuffer, IPlayerDataProvider, WithId } from './types';
-export declare const initBufferFromProvider: <T extends WithId>(provider: IPlayerDataProvider<T>) => IPlayerBuffer<T>;

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

@@ -1,13 +0,0 @@
-import { Utils } from '../../../core/utils';
-import { DefaultChunksPlayerBuffer } from './default-chunks-player-buffer.svelte';
-import { DefaultFeedPlayerBuffer } from './default-feed-player-buffer.svelte';
-export const initBufferFromProvider = (provider) => {
-    switch (provider.kind) {
-        case 'feed':
-            return new DefaultFeedPlayerBuffer(provider);
-        case 'chunks':
-            return new DefaultChunksPlayerBuffer(provider);
-        default:
-            Utils.assertUnreachable(provider);
-    }
-};

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

@@ -1,54 +0,0 @@
-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[]>;
-    onEndReached?: () => void;
-}
-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;
-    }>;
-    onEndReached?: () => void;
-}
-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;
-    ensureWarmedUp: () => Promise<void>;
-    tryActivateItemById: (id: string) => boolean;
-    removeItemById: (id: string) => 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/providers/types.js

@@ -1 +0,0 @@
-export {};