@streamscloud/embeddable 14.0.1 → 15.0.0-rc.0

package/dist/ui/player/{content-player → player}/overview-panel.svelte

@@ -59,7 +59,6 @@ const styles = $derived.by(() => {
   z-index: 0;
   border-radius: 0.5rem 0 0 0.5rem;
   background: var(--_overview-panel--background);
-  /* Set 'container-type: inline-size;' to reference container*/
 }
 .overview-panel__content {
   width: 100%;
@@ -71,6 +70,9 @@ const styles = $derived.by(() => {
   overflow: hidden;
   container-type: inline-size;
 }
+.overview-panel {
+  /* Set 'container-type: inline-size;' to reference container*/
+}
 @container (width < 576px) {
   .overview-panel {
     width: 100%;

package/dist/ui/player/{content-player → player}/overview-panel.svelte.d.ts

@@ -1,12 +1,12 @@
-import type { ContentPlayerConfig } from './content-player-config.svelte';
-import type { ContentPlayerUIManager } from './ui-manager.svelte';
+import type { PlayerConfig } from './player-config.svelte.js';
+import type { PlayerUIManager } from './ui-manager.svelte';
 import type { Snippet } from 'svelte';
-declare class __sveltets_Render<T extends {
+declare function $$render<T extends {
     id: string;
-}> {
-    props(): {
-        config: ContentPlayerConfig<T>;
-        uiManager: ContentPlayerUIManager;
+}>(): {
+    props: {
+        config: PlayerConfig<T>;
+        uiManager: PlayerUIManager;
         position: {
             top: number;
             bottom: number;
@@ -14,8 +14,17 @@ declare class __sveltets_Render<T extends {
         };
         children: Snippet;
     };
-    events(): {};
-    slots(): {};
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends {
+    id: string;
+}> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
     bindings(): "";
     exports(): {};
 }

package/dist/ui/player/player/player-config.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { ICloseOrchestrator } from '../close-orchestrator';
+import type { IPlayerBuffer } from '../providers';
+import type { PlayerSliderCallbacks } from '../slider/types';
+import { PlayerSettings } from './player-settings.svelte';
+import { PlayerUIManager } from './ui-manager.svelte';
+export declare class PlayerConfig<T extends {
+    id: string;
+}> {
+    playerBuffer: IPlayerBuffer<T> | null;
+    readonly settings: PlayerSettings;
+    readonly playerSliderCallbacks: PlayerSliderCallbacks | undefined;
+    readonly closeOrchestrator: ICloseOrchestrator;
+    readonly uiManager: PlayerUIManager;
+    constructor(init: {
+        playerBuffer: IPlayerBuffer<T> | null;
+        settings?: PlayerSettings;
+        playerSliderCallbacks?: PlayerSliderCallbacks;
+        closeOrchestrator: ICloseOrchestrator;
+    });
+    get playerColors(): import("../colors").PlayerColors;
+}

package/dist/ui/player/player/player-config.svelte.js

@@ -0,0 +1,19 @@
+import { PlayerSettings } from './player-settings.svelte';
+import { PlayerUIManager } from './ui-manager.svelte';
+export class PlayerConfig {
+    playerBuffer = $state.raw(null);
+    settings;
+    playerSliderCallbacks;
+    closeOrchestrator;
+    uiManager = new PlayerUIManager();
+    constructor(init) {
+        const { playerBuffer, settings, playerSliderCallbacks, closeOrchestrator } = init;
+        this.playerBuffer = playerBuffer;
+        this.settings = settings || new PlayerSettings();
+        this.playerSliderCallbacks = playerSliderCallbacks;
+        this.closeOrchestrator = closeOrchestrator;
+    }
+    get playerColors() {
+        return this.settings.playerColors;
+    }
+}

package/dist/ui/player/{content-player/content-player-settings.svelte.d.ts → player/player-settings.svelte.d.ts}

@@ -1,7 +1,7 @@
 import type { Locale } from '../../../core/locale';
 import { type ThemeValue } from '../../../core/theme';
 import { PlayerColors } from '../colors';
-export declare class ContentPlayerSettings {
+export declare class PlayerSettings {
     locale: Locale;
     showStreamsCloudWatermark: boolean;
     allPlayerColors: Record<ThemeValue, PlayerColors>;

package/dist/ui/player/{content-player/content-player-settings.svelte.js → player/player-settings.svelte.js}

@@ -1,6 +1,6 @@
 import { Theme } from '../../../core/theme';
 import { PlayerColors } from '../colors';
-export class ContentPlayerSettings {
+export class PlayerSettings {
     locale = $state('en');
     showStreamsCloudWatermark = $state(false);
     allPlayerColors = $state.raw({

package/dist/ui/player/{content-player → player}/ui-manager.svelte.d.ts

@@ -1,4 +1,4 @@
-export declare class ContentPlayerUIManager {
+export declare class PlayerUIManager {
     overviewCollapsed: boolean;
     readonly overviewCanBeShown: boolean;
     readonly overviewMaxWidth = 150;

package/dist/ui/player/{content-player → player}/ui-manager.svelte.js

@@ -1,7 +1,7 @@
 const ATTACHMENTS_MAX_WIDTH = 176;
 const OVERLAY_MAX_WIDTH = 150;
 const SAFE_AREA_SIZE = 70;
-export class ContentPlayerUIManager {
+export class PlayerUIManager {
     overviewCollapsed = $state(true);
     overviewCanBeShown = $derived.by(() => this.overviewMaxWidth <= this.sidePanelsMaxWidth);
     overviewMaxWidth = OVERLAY_MAX_WIDTH;

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

@@ -5,11 +5,9 @@ export declare class PlayerChunk<TItem extends WithId, TChunk extends WithId> {
     readonly items: TItem[];
     readonly chunkItems: PlayerChunkItem<TItem>[];
     readonly activeChunkItem: PlayerChunkItem<TItem>;
-    readonly isEmpty: boolean;
-    isFullyLoaded: boolean;
     private _chunkItems;
     private _activeItemIndex;
-    private _isLoading;
+    private _fetchDeferred;
     private _itemsLoader;
     constructor(data: {
         chunk: TChunk;
@@ -24,9 +22,9 @@ export declare class PlayerChunk<TItem extends WithId, TChunk extends WithId> {
         };
     });
     get isLoading(): boolean;
+    get canLoadMore(): boolean;
     get activeItemIndex(): number;
     loadMore: () => Promise<TItem[]>;
-    setActiveItemIndex: (index: number, warmUp?: boolean) => Promise<void>;
+    setActiveItemIndex: (index: number) => Promise<void>;
     mutateChunkItems: (items: PlayerChunkItem<TItem>[]) => void;
-    warmUp: () => Promise<void>;
 }

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

@@ -1,73 +1,73 @@
 import { ContinuationToken } from '../../../../core/continuation-token';
 import { CursorDataLoader } from '../../../../core/data-loaders';
+import { Deferred } from '../../../../core/deferred';
 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);
     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);
+    _fetchDeferred = $state.raw(null);
     _itemsLoader;
     constructor(data) {
         const { chunk, provider, callbacks } = data;
         this.model = chunk;
         this._itemsLoader = new CursorDataLoader({
             loadPage: async (continuationToken) => {
-                if (this.isFullyLoaded) {
+                if (this._fetchDeferred) {
+                    return await this._fetchDeferred.promise;
+                }
+                if (!this.canLoadMore) {
+                    return null;
+                }
+                try {
+                    this._fetchDeferred = new Deferred();
+                    const itemsResult = await provider.loadChunkItems(this.model.id, continuationToken.toNextChunkString());
+                    const newItems = itemsResult.items;
+                    this._chunkItems = [
+                        ...this._chunkItems,
+                        ...newItems.map((item) => new PlayerChunkItem({
+                            model: item,
+                            chunkId: this.model.id
+                        }))
+                    ];
+                    const continuationTokenResult = ContinuationToken.fromPayload(itemsResult.continuationToken);
+                    if (!continuationTokenResult.canLoadMore) {
+                        callbacks?.onChunkFullyLoaded(this);
+                    }
+                    const result = {
+                        items: newItems,
+                        continuationToken: continuationTokenResult
+                    };
+                    this._fetchDeferred.resolve(result);
+                    return result;
+                }
+                catch {
+                    this._fetchDeferred?.resolve(null);
                     return null;
                 }
-                const result = await provider.loadChunkItems(this.model.id, continuationToken.toNextChunkString());
-                const newItems = result.items;
-                this._chunkItems = [
-                    ...this._chunkItems,
-                    ...newItems.map((item) => new PlayerChunkItem({
-                        model: item,
-                        chunkId: this.model.id
-                    }))
-                ];
-                const continuationTokenResult = ContinuationToken.fromPayload(result.continuationToken);
-                if (!continuationTokenResult.canLoadMore) {
-                    this.isFullyLoaded = true;
-                    callbacks?.onChunkFullyLoaded(this);
+                finally {
+                    this._fetchDeferred = null;
                 }
-                return {
-                    items: newItems,
-                    continuationToken: continuationTokenResult
-                };
             }
         });
     }
     get isLoading() {
-        return this._isLoading;
+        return !!this._fetchDeferred;
+    }
+    get canLoadMore() {
+        return this._itemsLoader.continuationToken.canLoadMore;
     }
     get activeItemIndex() {
         return this._activeItemIndex;
     }
     loadMore = () => this._itemsLoader.loadMore();
-    setActiveItemIndex = async (index, warmUp = true) => {
+    setActiveItemIndex = async (index) => {
         this._activeItemIndex = index;
-        if (warmUp) {
-            await this.warmUp();
-        }
     };
     mutateChunkItems = (items) => {
         this._chunkItems = items;
     };
-    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

@@ -4,7 +4,7 @@ export declare class PlayerChunksManager<TItem extends WithId, TChunk extends Wi
     private provider;
     private _activeChunkIndex;
     private _loadedChunks;
-    private _fetchDeferred;
+    private _warmUpDeferred;
     constructor(provider: IChunksPlayerDataProvider<TItem, TChunk>);
     get activeChunk(): PlayerChunk<TItem, TChunk>;
     get loadedChunks(): PlayerChunk<TItem, TChunk>[];
@@ -15,9 +15,9 @@ export declare class PlayerChunksManager<TItem extends WithId, TChunk extends Wi
     removeItemById: (id: string) => boolean;
     removeChunkById: (id: string) => boolean | undefined;
     initialize: () => Promise<void>;
-    setActiveChunkIndex: (index: number) => Promise<void>;
+    setActiveChunkIndex: (index: number, chunkItemIndex: number) => Promise<void>;
     activateItemAtFlattenedIndex: (index: number) => Promise<void>;
     warmUp: () => Promise<void>;
-    reset: () => void;
-    private populateChunkAtIndex;
+    reset: () => Promise<void>;
+    private warmUpSequentially;
 }

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

@@ -1,12 +1,14 @@
 import { Deferred } from '../../../../core/deferred';
 import { PlayerChunk } from './player-chunk.svelte';
-const CHUNKS_BUFFER_SIZE = 5;
-const FIXED_START_INDEX = 0;
+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([]);
-    _fetchDeferred = $state.raw(null);
+    _warmUpDeferred = $state.raw(null);
     constructor(provider) {
         this.provider = provider;
     }
@@ -17,7 +19,7 @@ export class PlayerChunksManager {
         return this._loadedChunks;
     }
     get isLoading() {
-        return this._fetchDeferred !== null || this._loadedChunks.some((c) => c.isLoading);
+        return this._warmUpDeferred !== null || this._loadedChunks.some((c) => c.isLoading);
     }
     get flattenedChunkItems() {
         return this._loadedChunks.reduce((acc, chunk) => {
@@ -42,8 +44,7 @@ export class PlayerChunksManager {
             return false;
         }
         const itemIndex = chunkWithItem.items.findIndex((item) => item.id === id);
-        this.setActiveChunkIndex(chunkWithItemIndex);
-        this.activeChunk.setActiveItemIndex(itemIndex);
+        this.setActiveChunkIndex(chunkWithItemIndex, itemIndex);
         return true;
     };
     removeItemById = (id) => {
@@ -106,37 +107,27 @@ export class PlayerChunksManager {
         else if (this._activeChunkIndex > chunkIndex) {
             newActiveChunkIndex--;
         }
-        this.setActiveChunkIndex(newActiveChunkIndex);
+        this.setActiveChunkIndex(newActiveChunkIndex, 0);
         return true;
     };
     initialize = async () => {
-        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) {
-                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);
-            }
-        };
         this._loadedChunks = this.provider.initialData.prefetchedChunks.map((chunk) => new PlayerChunk({ chunk, provider: { loadChunkItems: this.provider.loadChunkItems } }));
-        const considerInitialized = this._loadedChunks.length !== 0;
-        if (considerInitialized) {
-            handleInitialized();
-        }
         await this.warmUp();
-        if (!considerInitialized) {
-            handleInitialized();
+        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);
+        // Start background warm-up after initialization
+        this.warmUp();
     };
-    setActiveChunkIndex = async (index) => {
+    setActiveChunkIndex = async (index, chunkItemIndex) => {
         this._activeChunkIndex = index;
-        this._loadedChunks.forEach((c) => c.setActiveItemIndex(0, false));
-        await this.populateChunkAtIndex(this._activeChunkIndex + 1, (currentIndex) => currentIndex + 1);
+        this.activeChunk.setActiveItemIndex(chunkItemIndex);
         // Don't wait for warm up to be finished, it runs in the background
         this.warmUp();
     };
@@ -148,56 +139,82 @@ export class PlayerChunksManager {
             return;
         }
         if (nextItem.chunkId !== activeChunkId) {
-            this.setActiveChunkIndex(this.loadedChunks.findIndex((c) => c.model.id === nextItem.chunkId));
-            this.activeChunk.warmUp();
+            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));
         }
     };
     warmUp = async () => {
-        // Early return if manager is sufficient or already loading
-        if (this._fetchDeferred) {
-            return this._fetchDeferred.promise;
-        }
-        if (this._loadedChunks.length >= this._activeChunkIndex + CHUNKS_BUFFER_SIZE) {
-            return;
+        if (this._warmUpDeferred) {
+            return this._warmUpDeferred.promise;
         }
-        this._fetchDeferred = new Deferred();
+        this._warmUpDeferred = new Deferred();
         try {
-            const result = await this.provider.loadMoreChunks();
-            this._loadedChunks = [
-                ...this._loadedChunks,
-                ...result.map((chunk) => new PlayerChunk({
-                    chunk,
-                    provider: { loadChunkItems: this.provider.loadChunkItems }
-                }))
-            ];
+            await this.warmUpSequentially();
         }
         finally {
-            this._fetchDeferred.resolve();
-            this._fetchDeferred = null;
+            this._warmUpDeferred.resolve();
+            this._warmUpDeferred = null;
         }
     };
-    reset = () => {
+    reset = async () => {
         this._activeChunkIndex = -1;
         this._loadedChunks = [];
-        this._fetchDeferred = null;
-        this.warmUp();
+        this._warmUpDeferred = null;
+        await 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();
+    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
             }
-            return await this.populateChunkAtIndex(nextIndexFn(index), nextIndexFn);
         }
-        return { closestReadyChunkIndex: index };
     };
 }

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

@@ -9,7 +9,11 @@ export class DefaultChunksPlayerBuffer {
         if (this.loaded.length && this.currentIndex < this.loaded.length - 1) {
             return true;
         }
-        return !this._playerChunksManager.isLoading && !!this._onEndReachedFn;
+        // 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);

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

@@ -1,9 +1,9 @@
 import type { PlayerSliderBuffer, PlayerSliderCallbacks } from './types';
 import { type Snippet } from 'svelte';
-declare class __sveltets_Render<T extends {
+declare function $$render<T extends {
     id: string;
-}> {
-    props(): {
+}>(): {
+    props: {
         buffer: PlayerSliderBuffer<T>;
         on?: PlayerSliderCallbacks;
         children: Snippet<[{
@@ -11,8 +11,17 @@ declare class __sveltets_Render<T extends {
             active?: boolean;
         }]>;
     };
-    events(): {};
-    slots(): {};
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends {
+    id: string;
+}> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
     bindings(): "";
     exports(): {};
 }

package/dist/ui/player/slider-horizontal/cmp.slider.svelte

@@ -284,7 +284,6 @@ const showClassicArrowsAndDots = $derived([SliderMode.ArrowsAndDots, SliderMode.
   width: 100%;
   height: 100%;
   overflow: hidden;
-  /* Set 'container-type: inline-size;' to reference container*/
 }
 .slider__slides {
   display: flex;
@@ -377,12 +376,14 @@ const showClassicArrowsAndDots = $derived([SliderMode.ArrowsAndDots, SliderMode.
   text-align: center;
   color: var(--sc-mc-color--text-white);
   visibility: hidden;
-  /* Set 'container-type: inline-size;' to reference container*/
 }
 .slider__counts-navigation-button:disabled {
   opacity: 0.5;
   cursor: default;
 }
+.slider__counts-navigation-button {
+  /* Set 'container-type: inline-size;' to reference container*/
+}
 @container (width < 576px) {
   .slider__counts-navigation-button {
     visibility: visible;
@@ -411,6 +412,9 @@ const showClassicArrowsAndDots = $derived([SliderMode.ArrowsAndDots, SliderMode.
   position: static;
   margin-top: 1rem;
 }
+.slider {
+  /* Set 'container-type: inline-size;' to reference container*/
+}
 @container (width < 576px) {
   .slider__navigation-button {
     visibility: visible;

package/dist/ui/player/slider-horizontal/cmp.slider.svelte.d.ts

@@ -1,8 +1,8 @@
 import type { Locale } from '../../../core/locale';
 import { type SliderDotsConfig, SliderMode } from './types';
 import { type Snippet } from 'svelte';
-declare class __sveltets_Render<T> {
-    props(): {
+declare function $$render<T>(): {
+    props: {
         items: T[];
         initialIndex: number;
         sliderMode?: SliderMode;
@@ -11,11 +11,18 @@ declare class __sveltets_Render<T> {
         locale: Locale;
         on?: {
             indexChanged: (index: number) => void;
-        } | undefined;
+        };
         children: Snippet<[T]>;
     };
-    events(): {};
-    slots(): {};
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
     bindings(): "";
     exports(): {};
 }

package/dist/ui/shadow-dom/cmp.shadow-root.svelte

@@ -51,7 +51,7 @@ const styles = $derived.by(() => {
   }
 }
 :host,
-:global([data-theme="default"]) {
+:global([data-theme='default']) {
   /* Backgrounds */
   --sc-mc-color--bg-button: #ffffff;
   --sc-mc-color--bg-card: #ffffff;
@@ -85,7 +85,7 @@ const styles = $derived.by(() => {
   --sc-mc-color--text-inactive: #e5e7eb;
 }
 
-:global([data-theme="dark"]) {
+:global([data-theme='dark']) {
   /* Backgrounds */
   --sc-mc-color--bg-button: #111827;
   --sc-mc-color--bg-card: #000000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/embeddable",
-  "version": "14.0.1",
+  "version": "15.0.0-rc.0",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",
@@ -135,7 +135,7 @@
   "peerDependencies": {
     "@fluentui/svg-icons": "^1.1.301",
     "@popperjs/core": "^2.11.8",
-    "@streamscloud/streams-analytics-collector": "^2.0.9",
+    "@streamscloud/streams-analytics-collector": "^3.0.0",
     "@urql/core": "^5.1.1",
     "dequal": "^2.0.3",
     "dompurify": "^3.2.6",

package/dist/core/analytics.profile-id.d.ts

@@ -1,5 +0,0 @@
-/**
- * Retrieves the profile ID from localStorage or generates a new one if it doesn't exist
- * @returns The profile ID to use for analytics tracking
- */
-export declare const getOrCreateProfileId: () => string;