@fuzdev/fuz_app 0.60.0 → 0.61.0

package/dist/ui/table_state.svelte.js

@@ -1,8 +1,10 @@
 /**
  * Reactive state for database table pagination and data fetching.
  *
- * Extends `Loadable` to manage paginated table data with column metadata,
- * row deletion, and derived pagination controls.
+ * Holds one `AsyncSlot` — `list` (the paginated row fetch). Per-row delete
+ * uses plain try/catch + scalar `deleting` / `delete_error` fields (no slot
+ * — `delete_error` must persist past `list.run()` retries so the failure
+ * message stays visible while the user refetches).
  *
  * @example
  * ```ts
@@ -26,10 +28,10 @@
  * 	table.fetch('accounts');
  * </script>
  *
- * {#if table.loading}
+ * {#if table.list.loading}
  * 	<p>loading…</p>
- * {:else if table.error}
- * 	<p>{table.error}</p>
+ * {:else if table.list.error}
+ * 	<p>{table.list.error}</p>
  * {:else}
  * 	<p>showing {table.showing_start}–{table.showing_end} of {table.total}</p>
  * {/if}
@@ -37,12 +39,13 @@
  *
  * @module
  */
-import { Loadable } from './loadable.svelte.js';
+import { AsyncSlot } from './async_slot.svelte.js';
 import { parse_response_error, ui_fetch } from './ui_fetch.js';
 import { format_value } from './ui_format.js';
 /** Maximum number of rows that can be fetched in a single page. */
 export const TABLE_LIMIT_MAX = 1000;
-export class TableState extends Loadable {
+export class TableState {
+    list = new AsyncSlot();
     table_name = $state.raw('');
     columns = $state.raw([]);
     rows = $state.raw([]);
@@ -67,7 +70,7 @@ export class TableState extends Loadable {
         this.table_name = table_name;
         this.offset = offset;
         this.limit = Math.max(1, Math.min(TABLE_LIMIT_MAX, limit));
-        await this.run(async () => {
+        await this.list.run(async () => {
             const response = await ui_fetch(`/api/db/tables/${table_name}?offset=${this.offset}&limit=${this.limit}`);
             if (!response.ok) {
                 throw new Error(await parse_response_error(response, 'Failed to fetch table'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.60.0",
+  "version": "0.61.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",

package/dist/ui/loadable.svelte.d.ts

@@ -1,60 +0,0 @@
-/**
- * Base reactive state class with loading/error management.
- *
- * Provides the common loading/error pattern shared by all state classes.
- * Subclasses add domain-specific `$state` fields and methods that call
- * the protected `run` helper for async operations.
- *
- * @example
- * ```ts
- * class ItemsState extends Loadable {
- * 	items: Array<Item> = $state.raw([]);
- *
- * 	async fetch(): Promise<void> {
- * 		await this.run(async () => {
- * 			const response = await fetch('/api/items');
- * 			if (!response.ok) throw new Error('failed to fetch');
- * 			this.items = await response.json();
- * 		});
- * 	}
- * }
- * ```
- *
- * @example
- * ```ts
- * // structured errors via map_error
- * class FormState extends Loadable<{field: string; message: string}> {
- * 	async submit(data: FormData): Promise<void> {
- * 		await this.run(
- * 			() => post_form(data),
- * 			(e) => ({field: 'form', message: e instanceof Error ? e.message : 'unknown'}),
- * 		);
- * 	}
- * }
- * ```
- *
- * @module
- */
-export declare class Loadable<TError = string> {
-    loading: boolean;
-    error: TError | null;
-    /** The raw caught value from the last failed `run()`, for programmatic inspection. */
-    error_data: unknown;
-    /**
-     * Run an async operation with loading/error handling.
-     *
-     * Sets `loading` to `true`, clears `error` and `error_data`, runs `fn`, catches errors.
-     * Pass `map_error` to produce structured errors instead of strings.
-     *
-     * @returns the result or `undefined` if the operation failed
-     * @mutates `this`
-     */
-    protected run<T>(fn: () => Promise<T>, map_error?: (e: unknown) => TError): Promise<T | undefined>;
-    /**
-     * Reset loading and error state. Subclasses override to clear data.
-     *
-     * @mutates `this`
-     */
-    reset(): void;
-}
-//# sourceMappingURL=loadable.svelte.d.ts.map

package/dist/ui/loadable.svelte.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadable.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/ui/loadable.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,qBAAa,QAAQ,CAAC,MAAM,GAAG,MAAM;IACpC,OAAO,UAAqB;IAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAoB;IAExC,sFAAsF;IACtF,UAAU,EAAE,OAAO,CAAoB;IAEvC;;;;;;;;OAQG;cACa,GAAG,CAAC,CAAC,EACpB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,GAChC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAiBzB;;;;OAIG;IACH,KAAK,IAAI,IAAI;CAKb"}

package/dist/ui/loadable.svelte.js

@@ -1,80 +0,0 @@
-/**
- * Base reactive state class with loading/error management.
- *
- * Provides the common loading/error pattern shared by all state classes.
- * Subclasses add domain-specific `$state` fields and methods that call
- * the protected `run` helper for async operations.
- *
- * @example
- * ```ts
- * class ItemsState extends Loadable {
- * 	items: Array<Item> = $state.raw([]);
- *
- * 	async fetch(): Promise<void> {
- * 		await this.run(async () => {
- * 			const response = await fetch('/api/items');
- * 			if (!response.ok) throw new Error('failed to fetch');
- * 			this.items = await response.json();
- * 		});
- * 	}
- * }
- * ```
- *
- * @example
- * ```ts
- * // structured errors via map_error
- * class FormState extends Loadable<{field: string; message: string}> {
- * 	async submit(data: FormData): Promise<void> {
- * 		await this.run(
- * 			() => post_form(data),
- * 			(e) => ({field: 'form', message: e instanceof Error ? e.message : 'unknown'}),
- * 		);
- * 	}
- * }
- * ```
- *
- * @module
- */
-export class Loadable {
-    loading = $state.raw(false);
-    error = $state.raw(null);
-    /** The raw caught value from the last failed `run()`, for programmatic inspection. */
-    error_data = $state.raw(null);
-    /**
-     * Run an async operation with loading/error handling.
-     *
-     * Sets `loading` to `true`, clears `error` and `error_data`, runs `fn`, catches errors.
-     * Pass `map_error` to produce structured errors instead of strings.
-     *
-     * @returns the result or `undefined` if the operation failed
-     * @mutates `this`
-     */
-    async run(fn, map_error) {
-        this.loading = true;
-        this.error = null;
-        this.error_data = null;
-        try {
-            return await fn();
-        }
-        catch (e) {
-            this.error = map_error
-                ? map_error(e)
-                : (e instanceof Error ? e.message : 'Request failed');
-            this.error_data = e;
-            return undefined;
-        }
-        finally {
-            this.loading = false;
-        }
-    }
-    /**
-     * Reset loading and error state. Subclasses override to clear data.
-     *
-     * @mutates `this`
-     */
-    reset() {
-        this.loading = false;
-        this.error = null;
-        this.error_data = null;
-    }
-}