@streamscloud/kit 0.57.1 → 0.59.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

@@ -4,17 +4,21 @@ export declare class KeyedCursorDataLoader<T> {
     private _loaded;
     private _pending;
     private _loadPage;
-    private _loadAlongside;
+    private _loadWithFirstPage;
+    private _resumeAfterFailure;
     constructor(init: {
         loadPage: (key: string, continuationToken: ContinuationToken) => Promise<CursorResult<T> | null>;
-        /** Started with the key's first page and awaited by `ensureLoaded`; its outcome never reaches `isLoaded`. */
-        loadAlongside?: (key: string) => Promise<void>;
+        /** 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;
@@ -25,6 +29,6 @@ export declare class KeyedCursorDataLoader<T> {
     reload: (key?: string) => Promise<void>;
     private startLoad;
     private runLoad;
-    private runAlongside;
+    private runSideLoad;
     private loaderFor;
 }

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

@@ -5,17 +5,20 @@ export class KeyedCursorDataLoader {
     _loaded = $state.raw({});
     _pending = {};
     _loadPage;
-    _loadAlongside;
+    _loadWithFirstPage;
+    _resumeAfterFailure;
     constructor(init) {
         this._loadPage = init.loadPage;
-        this._loadAlongside = init.loadAlongside;
+        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. */
@@ -46,22 +49,25 @@ export class KeyedCursorDataLoader {
     };
     runLoad = async (key) => {
         const loader = this.loaderFor(key);
-        const alongside = this.runAlongside(key);
+        const sideLoad = this.runSideLoad(key);
         await loader.reset();
         this._loaded = { ...this._loaded, [key]: !loader.failed };
-        await alongside;
+        await sideLoad;
     };
-    runAlongside = async (key) => {
+    runSideLoad = async (key) => {
         try {
-            await this._loadAlongside?.(key);
+            await this._loadWithFirstPage?.(key);
         }
         catch (error) {
-            console.error('KeyedCursorDataLoader: failed to load alongside the page', error);
+            console.error('KeyedCursorDataLoader: failed to load with the first page', error);
         }
     };
     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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/kit",
-  "version": "0.57.1",
+  "version": "0.59.0",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",