@streamscloud/kit 0.0.1-1771006476137 → 0.0.1-1771075495185

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

@@ -0,0 +1,220 @@
+import { Deferred } from '../../../../core';
+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 = [...this._loadedChunks.slice(0, chunkIndex), ...this._loadedChunks.slice(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

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

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

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

@@ -0,0 +1,121 @@
+import { Deferred } from '../../../core';
+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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export { TouchSynchronizer } from './touch-synchronizer';

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

@@ -0,0 +1 @@
+export { TouchSynchronizer } from './touch-synchronizer';

package/dist/ui/player/utils/touch-synchronizer.d.ts

@@ -0,0 +1,7 @@
+export declare class TouchSynchronizer {
+    private static listeners;
+    static touchStarted: (ref: HTMLElement) => void;
+    static touchMovePropagationBlocked: (ref: HTMLElement) => void;
+    static touchEndPropatationBlocked: (ref: HTMLElement) => void;
+    static touchEnded: (ref: HTMLElement) => void;
+}

package/dist/ui/player/utils/touch-synchronizer.js

@@ -0,0 +1,21 @@
+export class TouchSynchronizer {
+    static listeners = [];
+    static touchStarted = (ref) => {
+        TouchSynchronizer.listeners.push(ref);
+    };
+    static touchMovePropagationBlocked = (ref) => {
+        const otherListeners = TouchSynchronizer.listeners.filter((r) => r !== ref);
+        otherListeners.forEach((r) => {
+            r.dispatchEvent(new TouchEvent('touchend', { cancelable: false }));
+        });
+    };
+    static touchEndPropatationBlocked = (ref) => {
+        const otherListeners = TouchSynchronizer.listeners.filter((r) => r !== ref);
+        otherListeners.forEach((r) => {
+            r.dispatchEvent(new TouchEvent('touchend', { cancelable: false }));
+        });
+    };
+    static touchEnded = (ref) => {
+        TouchSynchronizer.listeners = TouchSynchronizer.listeners.filter((r) => r !== ref);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/kit",
-  "version": "0.0.1-1771006476137",
+  "version": "0.0.1-1771075495185",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",
@@ -128,6 +128,22 @@
       "types": "./dist/ui/media-playback/index.d.ts",
       "svelte": "./dist/ui/media-playback/index.js"
     },
+    "./ui/player/buttons": {
+      "types": "./dist/ui/player/buttons/index.d.ts",
+      "svelte": "./dist/ui/player/buttons/index.js"
+    },
+    "./ui/player/carousel": {
+      "types": "./dist/ui/player/carousel/index.d.ts",
+      "svelte": "./dist/ui/player/carousel/index.js"
+    },
+    "./ui/player/feed-slider": {
+      "types": "./dist/ui/player/feed-slider/index.d.ts",
+      "svelte": "./dist/ui/player/feed-slider/index.js"
+    },
+    "./ui/player/providers": {
+      "types": "./dist/ui/player/providers/index.d.ts",
+      "svelte": "./dist/ui/player/providers/index.js"
+    },
     "./ui/progress": {
       "types": "./dist/ui/progress/index.d.ts",
       "svelte": "./dist/ui/progress/index.js"
@@ -184,12 +200,13 @@
     "rfdc": "^1.4.1",
     "svelte": "^5.50.0",
     "svelte-sonner": "^1.0.7",
+    "wheel-gestures": "^2.2.48",
     "yup": "^1.7.1"
   },
   "devDependencies": {
     "@eslint/compat": "^2.0.2",
     "@eslint/js": "^9.39.2",
-    "@fluentui/svg-icons": "^1.1.318",
+    "@fluentui/svg-icons": "^1.1.319",
     "@popperjs/core": "^2.11.8",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
@@ -217,14 +234,15 @@
     "publint": "^0.3.17",
     "rfdc": "^1.4.1",
     "sass": "^1.97.3",
-    "svelte": "^5.50.1",
-    "svelte-check": "^4.3.6",
+    "svelte": "^5.51.0",
+    "svelte-check": "^4.4.0",
     "svelte-preprocess": "^6.0.3",
     "svelte-sonner": "^1.0.7",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.55.0",
     "vite": "^7.3.1",
-    "vite-tsconfig-paths": "^6.1.0",
+    "vite-tsconfig-paths": "^6.1.1",
+    "wheel-gestures": "^2.2.48",
     "yup": "^1.7.1"
   }
 }