@streamscloud/kit 0.58.0 → 0.60.0

package/dist/core/data-loaders/cursor-data-loader-with-search.svelte.d.ts

@@ -5,6 +5,7 @@ export declare class CursorDataLoaderWithSearch<T> implements IDataLoader<T> {
     private _continuationToken;
     private _searchString;
     private _loadPage;
+    private _resumeAfterFailure;
     private _pending;
     private _generation;
     private _searchStringMinLength;
@@ -13,14 +14,18 @@ export declare class CursorDataLoaderWithSearch<T> implements IDataLoader<T> {
     constructor(init: {
         loadPage: (continuationToken: ContinuationToken, searchString: string) => Promise<CursorResult<T> | null>;
         searchStringMinLength?: number;
+        /** Keep the cursor when a page fails, so the next `loadMore` retries it instead of ending the list for good. @default false */
+        resumeAfterFailure?: boolean;
     });
     get searchString(): string;
     get loading(): boolean;
     get initialLoading(): boolean;
     get failed(): boolean;
+    get canLoadMore(): boolean;
     loadMore: () => Promise<T[]>;
     reset(): Promise<void>;
     updateSearchString: (searchString: string | null) => void;
     private runLoad;
+    private markFailed;
     private isSearchStringEffective;
 }

package/dist/core/data-loaders/cursor-data-loader-with-search.svelte.js

@@ -5,6 +5,7 @@ export class CursorDataLoaderWithSearch {
     _continuationToken = $state.raw(ContinuationToken.init());
     _searchString = $state.raw('');
     _loadPage;
+    _resumeAfterFailure;
     _pending = null;
     _generation = 0;
     _searchStringMinLength = 1;
@@ -12,6 +13,7 @@ export class CursorDataLoaderWithSearch {
     _failed = $state(false);
     constructor(init) {
         this._loadPage = init.loadPage;
+        this._resumeAfterFailure = init.resumeAfterFailure ?? false;
         if (init.searchStringMinLength !== undefined) {
             this._searchStringMinLength = init.searchStringMinLength;
         }
@@ -29,6 +31,9 @@ export class CursorDataLoaderWithSearch {
     get failed() {
         return this._failed;
     }
+    get canLoadMore() {
+        return this._continuationToken.canLoadMore;
+    }
     loadMore = async () => {
         if (this._pending) {
             return this._pending;
@@ -80,19 +85,27 @@ export class CursorDataLoaderWithSearch {
             if (generation !== this._generation) {
                 return [];
             }
-            const result = page ?? { items: [], continuationToken: ContinuationToken.preventLoading() };
-            this._failed = page === null;
-            this._continuationToken = result.continuationToken;
-            this.items = [...this.items, ...result.items];
-            return result.items;
+            if (page === null) {
+                this.markFailed();
+                return [];
+            }
+            this._continuationToken = page.continuationToken;
+            this.items = [...this.items, ...page.items];
+            return page.items;
         }
         catch (error) {
             console.error('CursorDataLoaderWithSearch: failed to load page', error);
             if (generation === this._generation) {
-                this._failed = true;
+                this.markFailed();
             }
             return [];
         }
     };
+    markFailed = () => {
+        this._failed = true;
+        if (!this._resumeAfterFailure) {
+            this._continuationToken = ContinuationToken.preventLoading();
+        }
+    };
     isSearchStringEffective = (searchString) => searchString && searchString.length >= this._searchStringMinLength;
 }

package/dist/core/data-loaders/cursor-data-loader.svelte.d.ts

@@ -4,17 +4,22 @@ export declare class CursorDataLoader<T> implements IDataLoader<T> {
     items: T[];
     continuationToken: ContinuationToken;
     private _loadPage;
+    private _resumeAfterFailure;
     private _pending;
     private _generation;
     private _loading;
     private _failed;
     constructor(init: {
         loadPage: (continuationToken: ContinuationToken) => Promise<CursorResult<T> | null>;
+        /** Keep the cursor when a page fails, so the next `loadMore` retries it instead of ending the list for good. @default false */
+        resumeAfterFailure?: boolean;
     });
     get loading(): boolean;
     get initialLoading(): boolean;
     get failed(): boolean;
+    get canLoadMore(): boolean;
     loadMore: () => Promise<T[]>;
     reset(): Promise<void>;
     private runLoad;
+    private markFailed;
 }

package/dist/core/data-loaders/cursor-data-loader.svelte.js

@@ -3,12 +3,14 @@ export class CursorDataLoader {
     items = $state.raw([]);
     continuationToken = $state.raw(ContinuationToken.init());
     _loadPage;
+    _resumeAfterFailure;
     _pending = null;
     _generation = 0;
     _loading = $state(false);
     _failed = $state(false);
     constructor(init) {
         this._loadPage = init.loadPage;
+        this._resumeAfterFailure = init.resumeAfterFailure ?? false;
     }
     get loading() {
         return this._loading;
@@ -19,6 +21,9 @@ export class CursorDataLoader {
     get failed() {
         return this._failed;
     }
+    get canLoadMore() {
+        return this.continuationToken.canLoadMore;
+    }
     loadMore = async () => {
         if (this._pending) {
             return this._pending;
@@ -57,18 +62,26 @@ export class CursorDataLoader {
             if (generation !== this._generation) {
                 return [];
             }
-            const result = page ?? { items: [], continuationToken: ContinuationToken.preventLoading() };
-            this._failed = page === null;
-            this.continuationToken = result.continuationToken;
-            this.items = [...this.items, ...result.items];
-            return result.items;
+            if (page === null) {
+                this.markFailed();
+                return [];
+            }
+            this.continuationToken = page.continuationToken;
+            this.items = [...this.items, ...page.items];
+            return page.items;
         }
         catch (error) {
             console.error('CursorDataLoader: failed to load page', error);
             if (generation === this._generation) {
-                this._failed = true;
+                this.markFailed();
             }
             return [];
         }
     };
+    markFailed = () => {
+        this._failed = true;
+        if (!this._resumeAfterFailure) {
+            this.continuationToken = ContinuationToken.preventLoading();
+        }
+    };
 }

package/dist/core/data-loaders/data-loader.d.ts

@@ -5,5 +5,7 @@ export interface IDataLoader<T> {
     initialLoading: boolean;
     /** The last attempt did not deliver a page, whether it returned nothing or threw; cleared when the next attempt starts. */
     failed: boolean;
+    /** More pages are reachable. Goes false at the end of the list, and on a failure unless the loader was built with `resumeAfterFailure`. */
+    canLoadMore: boolean;
     loadMore: () => Promise<T[]>;
 }

package/dist/core/data-loaders/keyed-cursor-data-loader.svelte.d.ts

@@ -5,16 +5,20 @@ export declare class KeyedCursorDataLoader<T> {
     private _pending;
     private _loadPage;
     private _loadWithFirstPage;
+    private _resumeAfterFailure;
     constructor(init: {
         loadPage: (key: string, continuationToken: ContinuationToken) => Promise<CursorResult<T> | null>;
         /** Started with the key's first page — never with `loadMore` — and awaited by `ensureLoaded`; its outcome never reaches `isLoaded`. */
         loadWithFirstPage?: (key: string) => Promise<void>;
+        /** Keep a key's cursor when its page fails, so the next `loadMore` for it retries instead of ending that key's list for good. @default false */
+        resumeAfterFailure?: boolean;
     });
     items: (key?: string) => T[];
     loading: (key?: string) => boolean;
     initialLoading: (key?: string) => boolean;
     /** The key's last attempt did not deliver a page, whether it returned nothing or threw; cleared when the next attempt for that key starts. */
     failed: (key?: string) => boolean;
+    /** More pages are reachable for the key. Goes false on a failed page unless the loader was built with `resumeAfterFailure`. */
     canLoadMore: (key?: string) => boolean;
     /** False until the key's first page loaded without failing, so a failed load can be retried; a later failed page never clears it. */
     isLoaded: (key?: string) => boolean;

package/dist/core/data-loaders/keyed-cursor-data-loader.svelte.js

@@ -6,16 +6,19 @@ export class KeyedCursorDataLoader {
     _pending = {};
     _loadPage;
     _loadWithFirstPage;
+    _resumeAfterFailure;
     constructor(init) {
         this._loadPage = init.loadPage;
         this._loadWithFirstPage = init.loadWithFirstPage;
+        this._resumeAfterFailure = init.resumeAfterFailure ?? false;
     }
     items = (key = '') => this.loaderFor(key).items;
     loading = (key = '') => this.loaderFor(key).loading;
     initialLoading = (key = '') => this.loaderFor(key).initialLoading;
     /** The key's last attempt did not deliver a page, whether it returned nothing or threw; cleared when the next attempt for that key starts. */
     failed = (key = '') => this.loaderFor(key).failed;
-    canLoadMore = (key = '') => this.loaderFor(key).continuationToken.canLoadMore;
+    /** More pages are reachable for the key. Goes false on a failed page unless the loader was built with `resumeAfterFailure`. */
+    canLoadMore = (key = '') => this.loaderFor(key).canLoadMore;
     /** False until the key's first page loaded without failing, so a failed load can be retried; a later failed page never clears it. */
     isLoaded = (key = '') => this._loaded[key] === true;
     /** Loads the key's first page once; concurrent and repeat calls share that load's promise. */
@@ -61,7 +64,10 @@ export class KeyedCursorDataLoader {
     };
     loaderFor = (key) => {
         if (!this._loaders[key]) {
-            this._loaders[key] = new CursorDataLoader({ loadPage: (continuationToken) => this._loadPage(key, continuationToken) });
+            this._loaders[key] = new CursorDataLoader({
+                loadPage: (continuationToken) => this._loadPage(key, continuationToken),
+                resumeAfterFailure: this._resumeAfterFailure
+            });
         }
         return this._loaders[key];
     };

package/dist/core/data-loaders/page-data-loader.svelte.d.ts

@@ -6,16 +6,21 @@ export declare class PageDataLoader<T> implements IDataLoader<T> {
     private _canLoadMore;
     private _perPage;
     private _loadPage;
+    private _resumeAfterFailure;
     private _pageNumber;
     private _generation;
     constructor(init: {
         loadPage: (page: number, perPage: number) => Promise<T[]>;
         perPage?: number;
+        /** Keep the page number when a page fails, so the next `loadMore` retries it instead of ending the list for good. @default false */
+        resumeAfterFailure?: boolean;
     });
     get items(): T[];
     get loading(): boolean;
     get initialLoading(): boolean;
     get failed(): boolean;
+    get canLoadMore(): boolean;
     loadMore: () => Promise<T[]>;
     reset: () => Promise<void>;
+    private markFailed;
 }

package/dist/core/data-loaders/page-data-loader.svelte.js

@@ -5,10 +5,12 @@ export class PageDataLoader {
     _canLoadMore = $state(true);
     _perPage = 20;
     _loadPage;
+    _resumeAfterFailure;
     _pageNumber = 1;
     _generation = 0;
     constructor(init) {
         this._loadPage = init.loadPage;
+        this._resumeAfterFailure = init.resumeAfterFailure ?? false;
         if (init.perPage) {
             this._perPage = init.perPage;
         }
@@ -25,6 +27,9 @@ export class PageDataLoader {
     get failed() {
         return this._failed;
     }
+    get canLoadMore() {
+        return this._canLoadMore;
+    }
     loadMore = async () => {
         if (this._loading || !this._canLoadMore) {
             return [];
@@ -46,7 +51,7 @@ export class PageDataLoader {
         catch (error) {
             console.error('PageDataLoader: failed to load page', error);
             if (generation === this._generation) {
-                this._failed = true;
+                this.markFailed();
             }
             return [];
         }
@@ -64,4 +69,10 @@ export class PageDataLoader {
         this._canLoadMore = true;
         await this.loadMore();
     };
+    markFailed = () => {
+        this._failed = true;
+        if (!this._resumeAfterFailure) {
+            this._canLoadMore = false;
+        }
+    };
 }

package/dist/ui/cropper/img-cropper/cropperjs-elements.d.ts

@@ -9,15 +9,17 @@ type CamelToKebab<S extends string> = S extends `${infer F}${infer R}`
   : S;
 
 type CropperElementProps<T extends HTMLElement> = {
-  [K in keyof T as K extends keyof HTMLElement
-    ? never
-    : K extends `$${string}`
+  [
+    K in keyof T as K extends keyof HTMLElement
       ? never
-      : T[K] extends (...args: never[]) => unknown
+      : K extends `$${string}`
         ? never
-        : K extends string
-          ? CamelToKebab<K>
-          : never]?: (T[K] extends boolean ? boolean : T[K] extends number ? number | string : string) | null;
+        : T[K] extends (...args: never[]) => unknown
+          ? never
+          : K extends string
+            ? CamelToKebab<K>
+            : never
+  ]?: (T[K] extends boolean ? boolean : T[K] extends number ? number | string : string) | null;
 } & import('svelte/elements').HTMLAttributes<HTMLElement>;
 
 declare namespace svelteHTML {

package/dist/ui/dynamic-component/cmp.dynamic-component.svelte

@@ -12,19 +12,5 @@ Use when the component to render is decided at runtime (e.g. dispatched by id, f
 renders many heterogeneous nodes). `DynamicComponentModel` keeps `props` reactive — calling
 `model.updateProps(...)` updates the rendered component without re-mounting.
 
-```svelte
-<script lang="ts">
-  import { DynamicComponent, DynamicComponentModel } from '@streamscloud/kit/dynamic-component';
-  import { Button } from '@streamscloud/kit/button';
-
-  const model = new DynamicComponentModel({
-    component: Button,
-    props: { type: 'button', children: () => 'Click' }
-  });
-</script>
-
-<DynamicComponent {model} />
-```
-
 This component has no styles or visual surface of its own.
 -->

package/dist/ui/dynamic-component/cmp.dynamic-component.svelte.d.ts

@@ -10,20 +10,6 @@ type Props = {
  * renders many heterogeneous nodes). `DynamicComponentModel` keeps `props` reactive — calling
  * `model.updateProps(...)` updates the rendered component without re-mounting.
  *
- * ```svelte
- * <script lang="ts">
- * import { DynamicComponent, DynamicComponentModel } from '@streamscloud/kit/dynamic-component';
- * import { Button } from '@streamscloud/kit/button';
- *
- * const model = new DynamicComponentModel({
- *   component: Button,
- *   props: { type: 'button', children: () => 'Click' }
- * });
- * </script>
- *
- * <DynamicComponent {model} />
- * ```
- *
  * This component has no styles or visual surface of its own.
  */
 declare const Cmp: import("svelte").Component<Props, {}, "">;

package/dist/ui/grid-card/fields/cmp.grid-card-progress-field.svelte

@@ -9,6 +9,5 @@ const { label, stage, stages } = $props();
 
 <!--
 @component
-Grid-card field pairing a field label with a multi-stage `ProgressBar`. See `ProgressBar`
-(`@streamscloud/kit/ui/progress-bar`) for the bar's own CSS Custom Properties.
+Grid-card field pairing a field label with a multi-stage `ProgressBar`. See `ProgressBar` for the bar's own CSS Custom Properties.
 -->

package/dist/ui/grid-card/fields/cmp.grid-card-progress-field.svelte.d.ts

@@ -9,10 +9,7 @@ type Props = {
      */
     stages: ProgressBarStage[];
 };
-/**
- * Grid-card field pairing a field label with a multi-stage `ProgressBar`. See `ProgressBar`
- * (`@streamscloud/kit/ui/progress-bar`) for the bar's own CSS Custom Properties.
- */
+/** Grid-card field pairing a field label with a multi-stage `ProgressBar`. See `ProgressBar` for the bar's own CSS Custom Properties. */
 declare const Cmp: import("svelte").Component<Props, {}, "">;
 type Cmp = ReturnType<typeof Cmp>;
 export default Cmp;

package/dist/ui/infinite-scroll/cmp.infinite-scroll.svelte

@@ -1,5 +1,9 @@
-<script lang="ts">import { Spinner } from '../spinner';
-let { loadMore, container = null, rootMargin = '200px', children, loading } = $props();
+<script lang="ts">import { Button } from '../button';
+import { Spinner } from '../spinner';
+import { InfiniteScrollLocalization } from './infinite-scroll-localization';
+let { loadMore, container = null, rootMargin = '200px', children, loading, retry } = $props();
+const localization = new InfiniteScrollLocalization();
+const source = $derived(typeof loadMore === 'function' ? { loadMore, failed: false, canLoadMore: true } : loadMore);
 let isLoading = $state(false);
 let paginationTrigger = $state(null);
 let itemsContainer = $state(null);
@@ -11,7 +15,8 @@ $effect(() => {
     const items = itemsContainer;
     const intersectionObserver = new IntersectionObserver((e) => {
         const [entries] = e;
-        if (entries.isIntersecting) {
+        // an armed sentinel over a failing backend retries in a loop — the manual control is the only way on from here
+        if (entries.isIntersecting && !source.failed) {
             void onLoadMore();
         }
     }, {
@@ -36,12 +41,15 @@ const onLoadMore = async () => {
     }
     isLoading = true;
     try {
-        await loadMore();
+        await source.loadMore();
     }
     finally {
         isLoading = false;
     }
 };
+const onRetry = () => {
+    void onLoadMore();
+};
 </script>
 
 <div class="infinite-scroll">
@@ -58,6 +66,14 @@ const onLoadMore = async () => {
         <Spinner timeout={500} />
       </div>
     {/if}
+  {:else if source.failed && source.canLoadMore}
+    {#if retry}
+      {@render retry(onRetry)}
+    {:else}
+      <div class="infinite-scroll__retry">
+        <Button type="button" variant="secondary" size="sm" on={{ click: onRetry }}>{localization.loadMore}</Button>
+      </div>
+    {/if}
   {/if}
 </div>
 
@@ -67,6 +83,8 @@ Triggers an async `loadMore` callback when a sentinel element scrolls into view,
 
 Pairs with `core/data-loaders` (`CursorDataLoader`, `PageDataLoader`, `CursorDataLoaderWithSearch`) — wire `loadMore={loader.loadMore}` and `{#each loader.items as item}` directly.
 
+Passing the loader itself — `loadMore={loader}` instead of `loadMore={loader.loadMore}` — disarms the sentinel while the loader reports `failed`, so a failing backend is not asked again on its own and the already-loaded list is kept. The manual continue appears only when the loader can still continue (`resumeAfterFailure`); a loader that closed its list on the failure ends silently, as it does at the natural end. A successful retry re-arms the sentinel on its own.
+
 ### CSS Custom Properties
 | Property | Description | Default |
 |---|---|---|
@@ -100,4 +118,9 @@ Pairs with `core/data-loaders` (`CursorDataLoader`, `PageDataLoader`, `CursorDat
   bottom: 0.3125em;
   left: 50%;
   transform: translateX(-50%);
+}
+.infinite-scroll__retry {
+  display: flex;
+  justify-content: center;
+  padding: var(--sc-kit--space--3) 0;
 }</style>

package/dist/ui/infinite-scroll/cmp.infinite-scroll.svelte.d.ts

@@ -1,7 +1,16 @@
+import type { LoadMoreSource } from './types';
 import type { Snippet } from 'svelte';
 type Props = {
-    /** Async callback invoked when the sentinel becomes visible. Should resolve when the next batch is appended (or no-op when there are no more items — `CursorDataLoader.loadMore` already returns `[]` in that case). */
-    loadMore: () => Promise<unknown>;
+    /**
+     * Where the next batch comes from. Either an async callback invoked when the sentinel becomes visible — it should resolve once the batch is appended
+     * (or no-op when there are no more items — `CursorDataLoader.loadMore` already returns `[]` in that case) — or a data loader, whose `failed` then also
+     * stops the sentinel from firing on its own and offers a manual continue instead.
+     *
+     * The object form must report `failed` and `canLoadMore` reactively: pass the loader itself, or an object literal rebuilt by the surrounding reactive
+     * scope (`{ loadMore: () => l.loadMore(key), failed: l.failed(key), canLoadMore: l.canLoadMore(key) }`). A plain object holding fixed values type-checks
+     * and leaves the sentinel armed through every failure.
+     */
+    loadMore: LoadMoreSource;
     /** Scroll ancestor used as the IntersectionObserver root. Required when the viewport differs from the scrolling container. */
     container?: HTMLElement | null;
     /** IntersectionObserver `rootMargin`. Default `'200px'` — fires the load a viewport-screen before reaching the bottom. */
@@ -9,12 +18,16 @@ type Props = {
     children: Snippet;
     /** Custom loading indicator snippet. Defaults to the kit `Spinner`. */
     loading?: Snippet;
+    /** Manual continue shown while `failed`, taking the callback that retries the failed page. Defaults to a kit `Button`. */
+    retry?: Snippet<[() => void]>;
 };
 /**
  * Triggers an async `loadMore` callback when a sentinel element scrolls into view, using IntersectionObserver. Re-observes the sentinel on container resize so layout shifts inside the parent re-evaluate visibility (a known IntersectionObserver gotcha). Internal `isLoading` guard prevents overlapping fires while a load is in flight.
  *
  * Pairs with `core/data-loaders` (`CursorDataLoader`, `PageDataLoader`, `CursorDataLoaderWithSearch`) — wire `loadMore={loader.loadMore}` and `{#each loader.items as item}` directly.
  *
+ * Passing the loader itself — `loadMore={loader}` instead of `loadMore={loader.loadMore}` — disarms the sentinel while the loader reports `failed`, so a failing backend is not asked again on its own and the already-loaded list is kept. The manual continue appears only when the loader can still continue (`resumeAfterFailure`); a loader that closed its list on the failure ends silently, as it does at the natural end. A successful retry re-arms the sentinel on its own.
+ *
  * ### CSS Custom Properties
  * | Property | Description | Default |
  * |---|---|---|

package/dist/ui/infinite-scroll/index.d.ts

@@ -1 +1,2 @@
 export { default as InfiniteScroll } from './cmp.infinite-scroll.svelte';
+export type { LoadMoreSource } from './types';

package/dist/ui/infinite-scroll/infinite-scroll-localization.d.ts

@@ -0,0 +1,3 @@
+export declare class InfiniteScrollLocalization {
+    get loadMore(): string;
+}

package/dist/ui/infinite-scroll/infinite-scroll-localization.js

@@ -0,0 +1,12 @@
+import { AppLocale } from '../../core/locale';
+const loc = {
+    loadMore: {
+        en: 'Load more',
+        no: 'Last inn mer'
+    }
+};
+export class InfiniteScrollLocalization {
+    get loadMore() {
+        return loc.loadMore[AppLocale.current];
+    }
+}

package/dist/ui/infinite-scroll/types.d.ts

@@ -0,0 +1,5 @@
+export type LoadMoreSource = (() => Promise<unknown>) | {
+    loadMore: () => Promise<unknown>;
+    failed: boolean;
+    canLoadMore: boolean;
+};

package/dist/ui/infinite-scroll/types.js

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

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

@@ -18,6 +18,5 @@ export declare class PlayerChunksManager<TItem extends WithId, TChunk extends Wi
     setActiveChunkIndex: (index: number, chunkItemIndex: number) => Promise<void>;
     activateItemAtFlattenedIndex: (index: number) => Promise<void>;
     warmUp: () => Promise<void>;
-    reset: () => Promise<void>;
     private warmUpSequentially;
 }

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

@@ -163,14 +163,7 @@ export class PlayerChunksManager {
             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;
@@ -179,6 +172,7 @@ export class PlayerChunksManager {
         };
         while (getItemsAhead() < ITEMS_BUFFER_SIZE) {
             // Find first non-fully-loaded chunk starting from active
+            const startChunkIndex = Math.max(0, this._activeChunkIndex);
             let targetChunkIndex = -1;
             for (let i = startChunkIndex; i < this._loadedChunks.length; i++) {
                 if (this._loadedChunks[i].canLoadMore) {

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

@@ -18,6 +18,5 @@ export declare class DefaultChunksPlayerBuffer<TItem extends WithId, TChunk exte
     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

@@ -62,9 +62,6 @@ export class DefaultChunksPlayerBuffer {
         }
         this._playerChunksManager.activateItemAtFlattenedIndex(this.currentIndex - 1);
     };
-    reset = () => {
-        this._playerChunksManager.reset();
-    };
     ensureWarmedUp = async () => {
         await this._playerChunksManager.warmUp();
     };

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

@@ -34,7 +34,6 @@ export interface IPlayerBufferBase<T extends WithId> {
     readonly animationDuration: number;
     loadNext: () => void;
     loadPrevious: () => void;
-    reset: () => void;
     ensureWarmedUp: () => Promise<void>;
     tryActivateItemById: (id: string) => boolean;
     removeItemById: (id: string) => void;
@@ -44,6 +43,8 @@ type TExtended<T> = T & {
 };
 export interface IFeedPlayerBuffer<T extends WithId> extends IPlayerBufferBase<T> {
     readonly kind: 'feed';
+    /** Drops the buffered feed and loads it again from the start. */
+    reset: () => void;
 }
 export interface IChunksPlayerBuffer<T extends WithId> extends IPlayerBufferBase<T> {
     readonly kind: 'chunks';

package/dist/ui/popover/cmp.hover-popover.svelte

@@ -48,15 +48,6 @@ to content stays "inside" the hover zone (no close fires). The `closeDelay` cove
 small visual gap between trigger and content.
 
 `bind:this` on HoverPopover forwards `open() / close() / toggle()` from the inner Popover.
-
-```svelte
-import { HoverPopover, PopoverItem } from '@streamscloud/kit/ui/popover';
-
-<HoverPopover>
-  {#snippet trigger()}<Button type="presentational">Hover me</Button>{/snippet}
-  <PopoverItem>Action</PopoverItem>
-</HoverPopover>
-```
 -->
 
 <style>.hover-popover {

package/dist/ui/popover/cmp.hover-popover.svelte.d.ts

@@ -33,15 +33,6 @@ type Props = {
  * small visual gap between trigger and content.
  *
  * `bind:this` on HoverPopover forwards `open() / close() / toggle()` from the inner Popover.
- *
- * ```svelte
- * import { HoverPopover, PopoverItem } from '@streamscloud/kit/ui/popover';
- *
- * <HoverPopover>
- * {#snippet trigger()}<Button type="presentational">Hover me</Button>{/snippet}
- * <PopoverItem>Action</PopoverItem>
- * </HoverPopover>
- * ```
  */
 declare const Cmp: import("svelte").Component<Props, {
     /** Imperative API — bind:this on HoverPopover to access. */ open: () => void;

package/dist/ui/popover/cmp.popover.svelte

@@ -226,15 +226,7 @@ the same state can be reached by keyboard through another control (as in `UrlInp
 protocol into the field does what the picker does). Never reach for it just to shorten a tab sequence.
 
 Imperative control via `bind:this` — the component exports `open()`, `close()`, `toggle()`
-methods. Import `PopoverInstance` type from the barrel for typing the ref.
-
-```svelte
-import { Popover, type PopoverInstance } from '@streamscloud/kit/ui/popover';
-let dd: PopoverInstance | undefined = $state.raw(undefined);
-
-<Popover bind:this={dd}>...</Popover>
-<button onclick={() => dd?.open()}>Open externally</button>
-```
+methods; type the ref with the exported `PopoverInstance` type.
 
 With `panel` on, content sizes to `max-content` and, above the `min-width` floor, never exceeds the room Floating UI measures around the trigger: the `size()` middleware feeds the space left after
 `flip` / `shift` into the max-width / max-height defaults. So the panel always has a definite width — which is what makes a consumer's own

package/dist/ui/popover/cmp.popover.svelte.d.ts

@@ -51,15 +51,7 @@ type Props = {
  * protocol into the field does what the picker does). Never reach for it just to shorten a tab sequence.
  *
  * Imperative control via `bind:this` — the component exports `open()`, `close()`, `toggle()`
- * methods. Import `PopoverInstance` type from the barrel for typing the ref.
- *
- * ```svelte
- * import { Popover, type PopoverInstance } from '@streamscloud/kit/ui/popover';
- * let dd: PopoverInstance | undefined = $state.raw(undefined);
- *
- * <Popover bind:this={dd}>...</Popover>
- * <button onclick={() => dd?.open()}>Open externally</button>
- * ```
+ * methods; type the ref with the exported `PopoverInstance` type.
  *
  * With `panel` on, content sizes to `max-content` and, above the `min-width` floor, never exceeds the room Floating UI measures around the trigger: the `size()` middleware feeds the space left after
  * `flip` / `shift` into the max-width / max-height defaults. So the panel always has a definite width — which is what makes a consumer's own

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/kit",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",
@@ -482,11 +482,11 @@
   },
   "peerDependencies": {
     "@floating-ui/dom": "^1.7.6",
-    "@fluentui/svg-icons": "^1.1.326",
+    "@fluentui/svg-icons": "^1.1.341",
     "@fontsource/inter": "^5.2.8",
     "@fontsource/jetbrains-mono": "^5.2.8",
     "@fontsource/source-sans-pro": "^5.2.5",
-    "@urql/core": "^5.2.0 || ^6.0.0",
+    "@urql/core": "^6.0.1",
     "cleave-zen": "^0.0.17",
     "colord": "^2.9.3",
     "cropperjs": "^2.1.1",
@@ -498,7 +498,7 @@
     "nanoid": "^5.1.11",
     "p-limit": "^7.3.0",
     "rfdc": "^1.4.1",
-    "svelte": "^5.55.7",
+    "svelte": "^5.57.0",
     "svelte-awesome-color-picker": "^4.1.2",
     "svelte-dnd-action": "^0.9.69",
     "wheel-gestures": "^2.2.48",
@@ -507,50 +507,50 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@floating-ui/dom": "^1.7.6",
-    "@fluentui/svg-icons": "^1.1.326",
+    "@fluentui/svg-icons": "^1.1.341",
     "@fontsource/inter": "^5.2.8",
     "@fontsource/jetbrains-mono": "^5.2.8",
     "@fontsource/source-sans-pro": "^5.2.5",
-    "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "^7.1.2",
+    "@sveltejs/package": "^2.5.8",
+    "@sveltejs/vite-plugin-svelte": "^7.3.0",
     "@tsconfig/svelte": "^5.0.8",
-    "@types/node": "^25.8.0",
+    "@types/node": "^26.6.1",
     "@urql/core": "^6.0.1",
-    "autoprefixer": "^10.5.0",
+    "autoprefixer": "^10.6.1",
     "cleave-zen": "^0.0.17",
     "colord": "^2.9.3",
     "cropperjs": "^2.1.1",
     "dequal": "^2.0.3",
     "dompurify": "^3.4.5",
-    "eslint": "^10.4.0",
+    "eslint": "^10.10.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-formatter-codeframe": "^7.32.2",
     "eslint-formatter-visualstudio": "^9.0.1",
-    "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsonc": "^3.1.2",
+    "eslint-plugin-import-x": "^4.17.1",
+    "eslint-plugin-jsonc": "^3.4.2",
     "eslint-plugin-only-warn": "^1.2.1",
     "eslint-plugin-promise": "^7.3.0",
-    "eslint-plugin-svelte": "^3.17.1",
+    "eslint-plugin-svelte": "^3.23.0",
     "eslint-plugin-unused-imports": "^4.4.1",
     "fuse.js": "^7.3.0",
-    "globals": "^17.6.0",
+    "globals": "^17.12.0",
     "hugerte": "^1.0.10",
     "mime": "^4.1.0",
     "nanoid": "^5.1.11",
     "p-limit": "^7.3.0",
-    "prettier": "^3.8.3",
-    "prettier-plugin-svelte": "^4.1.0",
-    "publint": "^0.3.21",
+    "prettier": "^3.9.7",
+    "prettier-plugin-svelte": "^4.1.1",
+    "publint": "^0.3.24",
     "rfdc": "^1.4.1",
-    "sass": "^1.99.0",
-    "svelte": "^5.55.7",
+    "sass": "^1.104.1",
+    "svelte": "^5.57.0",
     "svelte-awesome-color-picker": "^4.1.2",
-    "svelte-check": "^4.4.8",
+    "svelte-check": "^4.7.6",
     "svelte-dnd-action": "^0.9.69",
-    "svelte-preprocess": "^6.0.3",
+    "svelte-preprocess": "^6.0.5",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.3",
-    "vite": "^8.0.13",
+    "typescript-eslint": "^8.70.0",
+    "vite": "^8.3.0",
     "vite-tsconfig-paths": "^6.1.1",
     "wheel-gestures": "^2.2.48",
     "yup": "^1.7.1"