@streamscloud/kit 0.0.1-1771006476137 → 0.0.1-1771075495185

package/dist/ui/player/carousel/cmp.carousel.svelte.d.ts

@@ -0,0 +1,38 @@
+import type { CarouselMode } from './types';
+import { type Snippet } from 'svelte';
+declare function $$render<T>(): {
+    props: {
+        items: T[];
+        initialIndex: number;
+        mode?: CarouselMode;
+        autoSlideMs?: number;
+        on?: {
+            indexChanged: (index: number) => void;
+        };
+        children: Snippet<[T]>;
+        dot?: Snippet<[{
+            active: boolean;
+        }]>;
+    };
+    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(): {};
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Cmp: $$IsomorphicComponent;
+type Cmp<T> = InstanceType<typeof Cmp<T>>;
+export default Cmp;

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

@@ -0,0 +1,2 @@
+export { default as Carousel } from './cmp.carousel.svelte';
+export type { CarouselMode } from './types';

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

@@ -0,0 +1 @@
+export { default as Carousel } from './cmp.carousel.svelte';

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

@@ -0,0 +1 @@
+export type CarouselMode = 'arrows-and-dots' | 'arrows-only' | 'dots-only' | 'dots-only-below' | 'arrows-with-counts';

package/dist/ui/player/carousel/types.js

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

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

@@ -0,0 +1,206 @@
+<script lang="ts" generics="T extends { id: string }">import { TouchSynchronizer } from '../utils';
+import { createWheelAdapter } from './wheel-gestures-adapter';
+import { onDestroy, onMount, untrack } from 'svelte';
+let { buffer, on, children } = $props();
+let slidesRef;
+let sliderHeight = $state(0);
+let swipeTransition = $state(0);
+let cssAnimationDuration = $derived(buffer.animationDuration * 0.55);
+let resizeObserver;
+let sliderIndex = $state.raw(untrack(() => buffer.currentIndex));
+const actualTransition = $derived(-sliderHeight * sliderIndex);
+const onKeyPress = (e) => {
+    if (e.key === 'ArrowUp' || e.key === 'PageUp') {
+        buffer.loadPrevious();
+    }
+    if (e.key === 'ArrowDown' || e.key === 'PageDown') {
+        buffer.loadNext();
+    }
+};
+$effect(() => {
+    if (buffer.currentIndex >= 0 && sliderIndex >= 0 && Math.abs(sliderIndex - buffer.currentIndex) === 1) {
+        slidesRef.classList.toggle('animate', true);
+    }
+    else if (buffer.currentIndex >= 0 && (Math.abs(sliderIndex - buffer.currentIndex) !== 0 || !active)) {
+        untrack(() => notifyOnItemChanged());
+    }
+});
+let active = null;
+$effect(() => {
+    sliderIndex = buffer.currentIndex;
+});
+const notifyOnItemChanged = () => {
+    if (active && buffer.current?.id !== active.id) {
+        on?.itemDeactivated?.(active.id);
+    }
+    active = buffer.current;
+    if (active) {
+        on?.itemActivated?.(active.id);
+    }
+};
+onMount(() => {
+    let touchStartX = 0;
+    let touchStartY = 0;
+    let touchMoveY = 0;
+    let touchStartTime = 0;
+    let swipeState = 'not-initialized';
+    window.addEventListener(`keydown`, onKeyPress);
+    slidesRef.addEventListener('touchstart', (e) => {
+        TouchSynchronizer.touchStarted(slidesRef);
+        // The movement gets all janky if there's a transition on the elements.
+        slidesRef.classList.toggle('animate', false);
+        touchStartX = e.changedTouches[0].screenX;
+        touchStartY = e.changedTouches[0].screenY;
+        touchStartTime = Date.now();
+        swipeState = 'not-initialized';
+    }, { passive: true });
+    slidesRef.addEventListener('touchmove', (e) => {
+        if (swipeState === 'vertical') {
+            // Already determined this is a vertical swipe
+            e.preventDefault();
+            e.stopPropagation();
+            TouchSynchronizer.touchMovePropagationBlocked(slidesRef);
+        }
+        else if (swipeState === 'horizontal') {
+            // Already determined this is a horizontal swipe
+            return;
+        }
+        const touchCurrentX = e.changedTouches[0].screenX;
+        const touchCurrentY = e.changedTouches[0].screenY;
+        const diffX = Math.abs(touchCurrentX - touchStartX);
+        const diffY = Math.abs(touchCurrentY - touchStartY);
+        // Determine direction on first significant movement
+        if (diffX > 10 || diffY > 10) {
+            if (diffY > diffX) {
+                // Vertical swipe - handle it
+                swipeState = 'vertical';
+                e.preventDefault();
+                e.stopPropagation();
+                TouchSynchronizer.touchMovePropagationBlocked(slidesRef);
+                const newPosition = touchCurrentY;
+                const diff = newPosition - touchStartY;
+                if ((diff > 0 && buffer.canLoadPrevious) || (diff < 0 && buffer.canLoadNext)) {
+                    touchMoveY = diff;
+                    swipeTransition = diff + actualTransition;
+                }
+            }
+            else {
+                // Horizontal swipe - allow child to handle
+                swipeState = 'horizontal';
+                return;
+            }
+        }
+    }, { passive: false });
+    slidesRef.addEventListener('touchend', (e) => {
+        const reset = () => {
+            swipeTransition = 0;
+            touchMoveY = 0;
+        };
+        // Check if this is a vertical swipe
+        if (swipeState !== 'vertical') {
+            // Horizontal swipe - don't handle and don't block
+            reset();
+            return;
+        }
+        // This is a vertical swipe - block propagation
+        e.stopPropagation();
+        TouchSynchronizer.touchEndPropatationBlocked(slidesRef);
+        TouchSynchronizer.touchEnded(slidesRef);
+        slidesRef.classList.toggle('animate', true);
+        const isFastSwipe = Date.now() - touchStartTime < 300;
+        if (!touchMoveY || (!isFastSwipe && Math.abs(touchMoveY) < sliderHeight / 6)) {
+            return reset();
+        }
+        if (touchMoveY > 0) {
+            buffer.loadPrevious();
+        }
+        else {
+            buffer.loadNext();
+        }
+        reset();
+    });
+    slidesRef.addEventListener('transitionend', (e) => {
+        if (e.target !== slidesRef) {
+            return;
+        }
+        slidesRef.classList.toggle('animate', false);
+        notifyOnItemChanged();
+    });
+    sliderHeight = slidesRef.clientHeight;
+    resizeObserver = new ResizeObserver(() => {
+        sliderHeight = slidesRef.clientHeight;
+    });
+    resizeObserver.observe(slidesRef);
+});
+onDestroy(() => {
+    if (resizeObserver) {
+        resizeObserver.disconnect();
+    }
+    window.removeEventListener('keydown', onKeyPress);
+});
+const wheelCallbacks = {
+    canLoadNext: () => buffer.canLoadNext,
+    canLoadPrevious: () => buffer.canLoadPrevious,
+    onTrigger: (direction) => {
+        // direction: 1 -> next, -1 -> previous
+        if (direction > 0) {
+            buffer.loadNext();
+        }
+        else if (direction < 0) {
+            buffer.loadPrevious();
+        }
+    },
+    getAnimationDurationMs: () => buffer.animationDuration
+};
+</script>
+
+<div class="feed-slider">
+  <div
+    class="feed-slider__slides"
+    bind:this={slidesRef}
+    use:createWheelAdapter={{ cbs: wheelCallbacks }}
+    style:transform="translateY({swipeTransition || actualTransition}px)"
+    style:--feed-slider--animation="{cssAnimationDuration}ms ease-out transform">
+    {#each buffer.loaded as item, index (item)}
+      <div class="feed-slider__slide">
+        {#if index >= sliderIndex - 1 && index <= sliderIndex + 1}
+          <!-- Only render the active slide and its immediate neighbors for performance -->
+          {@render children({ item, active: index === sliderIndex })}
+        {/if}
+      </div>
+    {/each}
+  </div>
+</div>
+
+<style>.feed-slider {
+  position: relative;
+  overflow: clip;
+  height: 100%;
+  width: 100%;
+  min-width: 100%;
+  max-width: 100%;
+}
+.feed-slider__slides {
+  --_feed-slider--animation: var(--feed-slider--animation);
+  height: 100%;
+  min-height: 100%;
+  max-height: 100%;
+  width: 100%;
+  min-width: 100%;
+  max-width: 100%;
+}
+.feed-slider__slides:global(.animate) {
+  transition: var(--_feed-slider--animation);
+}
+.feed-slider__slide {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  position: relative;
+  height: 100%;
+  min-height: 100%;
+  max-height: 100%;
+  width: 100%;
+  min-width: 100%;
+  max-width: 100%;
+}</style>

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

@@ -0,0 +1,43 @@
+import type { FeedSliderBuffer, FeedSliderCallbacks } from './types';
+import { type Snippet } from 'svelte';
+declare function $$render<T extends {
+    id: string;
+}>(): {
+    props: {
+        buffer: FeedSliderBuffer<T>;
+        on?: FeedSliderCallbacks;
+        children: Snippet<[{
+            item: T;
+            active?: boolean;
+        }]>;
+    };
+    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(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends {
+        id: string;
+    }>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends {
+        id: string;
+    }>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Cmp: $$IsomorphicComponent;
+type Cmp<T extends {
+    id: string;
+}> = InstanceType<typeof Cmp<T>>;
+export default Cmp;

package/dist/ui/player/feed-slider/index.d.ts

@@ -0,0 +1,3 @@
+export { default as FeedSlider } from './cmp.feed-slider.svelte';
+export { preventFeedScroll } from './prevent-feed-scroll';
+export type { FeedSliderBuffer, FeedSliderCallbacks } from './types';

package/dist/ui/player/feed-slider/index.js

@@ -0,0 +1,2 @@
+export { default as FeedSlider } from './cmp.feed-slider.svelte';
+export { preventFeedScroll } from './prevent-feed-scroll';

package/dist/ui/player/feed-slider/prevent-feed-scroll.d.ts

@@ -0,0 +1,5 @@
+/** @type {import('svelte/action').Action}  */
+export declare const preventFeedScroll: (node: HTMLElement, value?: boolean) => {
+    destroy(): void;
+};
+export declare const isScrollingPrevented: (node: HTMLElement) => boolean;

package/dist/ui/player/feed-slider/prevent-feed-scroll.js

@@ -0,0 +1,11 @@
+/** @type {import('svelte/action').Action}  */
+export const preventFeedScroll = (node, value = true) => {
+    node.dataset[preventFeedScrollingAttribute] = value.toString();
+    return {
+        destroy() {
+            // the node has been removed from the DOM
+        }
+    };
+};
+export const isScrollingPrevented = (node) => node.dataset[preventFeedScrollingAttribute] === 'true';
+const preventFeedScrollingAttribute = 'preventFeedScrolling';

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

@@ -0,0 +1,16 @@
+export type FeedSliderCallbacks = {
+    itemActivated?: (e: string) => void;
+    itemDeactivated?: (e: string) => void;
+};
+export interface FeedSliderBuffer<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/player/feed-slider/types.js

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

package/dist/ui/player/feed-slider/wheel-gestures-adapter.d.ts

@@ -0,0 +1,17 @@
+export type WheelAdapterCallbacks = {
+    canLoadNext: () => boolean;
+    canLoadPrevious: () => boolean;
+    onTrigger: (direction: number) => void;
+    getAnimationDurationMs: () => number;
+};
+/**
+ * Minimal, robust wheel adapter:
+ * - EMA over axisVelocity[1] to smooth noisy streams (esp. on Windows)
+ * - Cooldown blocks triggers while animation runs
+ * - Mouse fallback: if velocity is near zero but delta is large, treat as a discrete "kick"
+ */
+export declare const createWheelAdapter: (target: HTMLElement, params: {
+    cbs: WheelAdapterCallbacks;
+}) => {
+    destroy(): void;
+};

package/dist/ui/player/feed-slider/wheel-gestures-adapter.js

@@ -0,0 +1,79 @@
+// wheel-gestures-adapter.ts
+import { WheelGestures } from 'wheel-gestures';
+/**
+ * Minimal, robust wheel adapter:
+ * - EMA over axisVelocity[1] to smooth noisy streams (esp. on Windows)
+ * - Cooldown blocks triggers while animation runs
+ * - Mouse fallback: if velocity is near zero but delta is large, treat as a discrete "kick"
+ */
+export const createWheelAdapter = (target, params) => {
+    const { cbs } = params;
+    // Tunables
+    const PEAK_THRESHOLD = 0.4; // EMA magnitude threshold to consider as a "peak"
+    const ACCEL_THRESHOLD = 0.02; // minimal directional EMA rise to count as real acceleration
+    const EMA_ALPHA = 0.35; // EMA smoothing factor (0..1); higher = snappier, noisier
+    const MOUSE_DELTA_KICK = 12; // mouse: large delta step (≈12 mac / ≈100 win)
+    const MOUSE_STEP_RATIO_KICK = 350; // dimensionless; tune 200–500 if needed
+    const wheelGestures = WheelGestures({ preventWheelAction: true, reverseSign: false });
+    wheelGestures.observe(target);
+    let isAnimating = false;
+    let cooldownTimer = null;
+    // EMA state
+    let emaVelocity = 0;
+    let previousEmaVelocity = 0;
+    const startCooldown = () => {
+        if (cooldownTimer) {
+            clearTimeout(cooldownTimer);
+        }
+        cooldownTimer = window.setTimeout(() => {
+            isAnimating = false;
+        }, cbs.getAnimationDurationMs() + 100);
+    };
+    const fire = (direction) => {
+        // Respect external guards (e.g., paging boundaries)
+        if ((direction > 0 && !cbs.canLoadNext()) || (direction < 0 && !cbs.canLoadPrevious())) {
+            return;
+        }
+        isAnimating = true;
+        cbs.onTrigger(direction);
+        startCooldown();
+    };
+    wheelGestures.on('wheel', ({ axisDelta: [, axisDeltaY], axisVelocity: [, axisVelocityY] }) => {
+        const velocityY = axisVelocityY || 0;
+        const deltaY = axisDeltaY || 0;
+        // Tracking only: always update EMA and compute signs/acceleration
+        previousEmaVelocity = emaVelocity;
+        emaVelocity += (velocityY - emaVelocity) * EMA_ALPHA;
+        const emaMagnitude = Math.abs(emaVelocity);
+        const velocitySign = Math.sign(emaVelocity) || Math.sign(velocityY);
+        const emaAcceleration = emaVelocity - previousEmaVelocity;
+        // During animation we only track; no arming, no triggering
+        if (isAnimating) {
+            return;
+        }
+        // Path 1: mouse-like discrete kick (platform-agnostic via delta/velocity ratio)
+        const absDelta = Math.abs(deltaY);
+        const absVel = Math.abs(velocityY);
+        const stepRatio = absDelta / Math.max(1e-6, absVel);
+        const isMouseLikeKick = absDelta >= MOUSE_DELTA_KICK && stepRatio >= MOUSE_STEP_RATIO_KICK;
+        if (isMouseLikeKick) {
+            const direction = deltaY > 0 ? 1 : -1; // 1 = next/down, -1 = previous/up
+            fire(direction);
+            return;
+        }
+        // Path 2: trackpad/inertia via EMA acceleration and peak gating
+        const isAcceleratingInDirection = velocitySign !== 0 && emaAcceleration * velocitySign > ACCEL_THRESHOLD;
+        if (isAcceleratingInDirection && emaMagnitude > PEAK_THRESHOLD) {
+            const direction = velocitySign > 0 ? 1 : -1; // 1 = next/down, -1 = previous/up
+            fire(direction);
+        }
+    });
+    return {
+        destroy() {
+            wheelGestures.unobserve(target);
+            if (cooldownTimer) {
+                clearTimeout(cooldownTimer);
+            }
+        }
+    };
+};

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

@@ -0,0 +1,2 @@
+export { PlayerChunk } from './player-chunk.svelte';
+export { PlayerChunksManager } from './player-chunks-manager.svelte';

package/dist/ui/player/providers/chunks-player-buffer/index.js

@@ -0,0 +1,2 @@
+export { PlayerChunk } from './player-chunk.svelte';
+export { PlayerChunksManager } from './player-chunks-manager.svelte';

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

@@ -0,0 +1,9 @@
+import type { WithId } from '../types';
+export declare class PlayerChunkItem<T extends WithId> {
+    model: T;
+    chunkId: string;
+    constructor(init: {
+        model: T;
+        chunkId: string;
+    });
+}

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

@@ -0,0 +1,9 @@
+export class PlayerChunkItem {
+    model;
+    chunkId;
+    constructor(init) {
+        const { model, chunkId } = init;
+        this.model = model;
+        this.chunkId = chunkId;
+    }
+}

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

@@ -0,0 +1,30 @@
+import { PlayerChunkItem } from './player-chunk-item.svelte';
+import type { WithId } from '../types';
+export declare class PlayerChunk<TItem extends WithId, TChunk extends WithId> {
+    readonly model: TChunk;
+    readonly items: TItem[];
+    readonly chunkItems: PlayerChunkItem<TItem>[];
+    readonly activeChunkItem: PlayerChunkItem<TItem>;
+    private _chunkItems;
+    private _activeItemIndex;
+    private _fetchDeferred;
+    private _itemsLoader;
+    constructor(data: {
+        chunk: TChunk;
+        provider: {
+            loadChunkItems: (chunkId: string, continuationToken: string | null | undefined) => Promise<{
+                items: TItem[];
+                continuationToken: string | null;
+            }>;
+        };
+        callbacks?: {
+            onChunkFullyLoaded: (chunk: PlayerChunk<TItem, TChunk>) => void;
+        };
+    });
+    get isLoading(): boolean;
+    get canLoadMore(): boolean;
+    get activeItemIndex(): number;
+    loadMore: () => Promise<TItem[]>;
+    setActiveItemIndex: (index: number) => Promise<void>;
+    mutateChunkItems: (items: PlayerChunkItem<TItem>[]) => void;
+}

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

@@ -0,0 +1,72 @@
+import { ContinuationToken, Deferred } from '../../../../core';
+import { CursorDataLoader } from '../../../../core/data-loaders';
+import { PlayerChunkItem } from './player-chunk-item.svelte';
+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);
+    _chunkItems = $state.raw([]);
+    _activeItemIndex = $state(0);
+    _fetchDeferred = $state.raw(null);
+    _itemsLoader;
+    constructor(data) {
+        const { chunk, provider, callbacks } = data;
+        this.model = chunk;
+        this._itemsLoader = new CursorDataLoader({
+            loadPage: async (continuationToken) => {
+                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;
+                }
+                finally {
+                    this._fetchDeferred = null;
+                }
+            }
+        });
+    }
+    get isLoading() {
+        return !!this._fetchDeferred;
+    }
+    get canLoadMore() {
+        return this._itemsLoader.continuationToken.canLoadMore;
+    }
+    get activeItemIndex() {
+        return this._activeItemIndex;
+    }
+    loadMore = () => this._itemsLoader.loadMore();
+    setActiveItemIndex = async (index) => {
+        this._activeItemIndex = index;
+    };
+    mutateChunkItems = (items) => {
+        this._chunkItems = items;
+    };
+}

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 _activeChunkIndex;
+    private _loadedChunks;
+    private _warmUpDeferred;
+    constructor(provider: IChunksPlayerDataProvider<TItem, TChunk>);
+    get activeChunk(): PlayerChunk<TItem, TChunk>;
+    get loadedChunks(): PlayerChunk<TItem, TChunk>[];
+    get isLoading(): boolean;
+    get flattenedChunkItems(): TItem[];
+    get flattenedActiveChunkItemIndex(): number;
+    tryActivateItemById: (id: string) => boolean;
+    removeItemById: (id: string) => boolean;
+    removeChunkById: (id: string) => boolean | undefined;
+    initialize: () => Promise<void>;
+    setActiveChunkIndex: (index: number, chunkItemIndex: number) => Promise<void>;
+    activateItemAtFlattenedIndex: (index: number) => Promise<void>;
+    warmUp: () => Promise<void>;
+    reset: () => Promise<void>;
+    private warmUpSequentially;
+}