@fuzdev/fuz_app 0.1.0

package/dist/ui/app_settings_state.svelte.js

@@ -0,0 +1,44 @@
+/**
+ * Reactive state for admin app settings management.
+ *
+ * @module
+ */
+import { Loadable } from './loadable.svelte.js';
+import { parse_response_error, ui_fetch } from './ui_fetch.js';
+export class AppSettingsState extends Loadable {
+    settings = $state(null);
+    updating = $state(false);
+    async fetch() {
+        await this.run(async () => {
+            const response = await ui_fetch('/api/admin/settings');
+            if (!response.ok) {
+                throw new Error(await parse_response_error(response, 'Failed to fetch settings'));
+            }
+            const data = await response.json();
+            this.settings = data.settings ?? null;
+        });
+    }
+    async update_open_signup(value) {
+        this.updating = true;
+        this.error = null;
+        try {
+            const response = await ui_fetch('/api/admin/settings', {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ open_signup: value }),
+            });
+            if (!response.ok) {
+                this.error = await parse_response_error(response);
+                return;
+            }
+            const data = await response.json();
+            this.settings = data.settings ?? null;
+        }
+        catch (e) {
+            this.error = e instanceof Error ? e.message : 'Failed to update settings';
+        }
+        finally {
+            this.updating = false;
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Reactive state for the audit log viewer.
+ *
+ * Supports both fetch-based pagination and realtime SSE streaming.
+ * SSE events are prepended to the list; use `fetch()` for initial load and filters.
+ *
+ * @module
+ */
+import { Loadable } from './loadable.svelte.js';
+import type { AuditLogEventWithUsernamesJson, PermitHistoryEventJson } from '../auth/audit_log_schema.js';
+/** Options for fetching audit log events. */
+export interface AuditLogFetchOptions {
+    event_type?: string;
+    account_id?: string;
+    limit?: number;
+    offset?: number;
+}
+export declare class AuditLogState extends Loadable {
+    #private;
+    events: Array<AuditLogEventWithUsernamesJson>;
+    permit_history_events: Array<PermitHistoryEventJson>;
+    readonly count: number;
+    /** Whether the SSE stream is currently connected. */
+    connected: boolean;
+    constructor(stream_url?: string);
+    fetch(options?: AuditLogFetchOptions): Promise<void>;
+    fetch_permit_history(limit?: number, offset?: number): Promise<void>;
+    /**
+     * Connect to the SSE stream for realtime audit events.
+     *
+     * New events are prepended to `events`. EventSource auto-reconnects on
+     * transient errors; `since_seq` fills gaps on reconnection.
+     *
+     * @returns cleanup function that closes the connection
+     */
+    subscribe(): () => void;
+    /** Close the SSE connection. */
+    disconnect(): void;
+}
+//# sourceMappingURL=audit_log_state.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"audit_log_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/ui/audit_log_state.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAE9C,OAAO,KAAK,EAEX,8BAA8B,EAC9B,sBAAsB,EACtB,MAAM,6BAA6B,CAAC;AAGrC,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAc,SAAQ,QAAQ;;IAC1C,MAAM,EAAE,KAAK,CAAC,8BAA8B,CAAC,CAAc;IAC3D,qBAAqB,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAc;IAElE,QAAQ,CAAC,KAAK,SAAgC;IAE9C,qDAAqD;IACrD,SAAS,UAAiB;gBAWd,UAAU,SAAgC;IAKhD,KAAK,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBpD,oBAAoB,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB1E;;;;;;;OAOG;IACH,SAAS,IAAI,MAAM,IAAI;IA0CvB,gCAAgC;IAChC,UAAU,IAAI,IAAI;CAmClB"}

package/dist/ui/audit_log_state.svelte.js

@@ -0,0 +1,153 @@
+/**
+ * Reactive state for the audit log viewer.
+ *
+ * Supports both fetch-based pagination and realtime SSE streaming.
+ * SSE events are prepended to the list; use `fetch()` for initial load and filters.
+ *
+ * @module
+ */
+import { DEV } from 'esm-env';
+import { Loadable } from './loadable.svelte.js';
+import { parse_response_error, ui_fetch } from './ui_fetch.js';
+export class AuditLogState extends Loadable {
+    events = $state([]);
+    permit_history_events = $state([]);
+    count = $derived(this.events.length);
+    /** Whether the SSE stream is currently connected. */
+    connected = $state(false);
+    /** The highest `seq` seen — used for gap fill on reconnection. */
+    #last_seq = null;
+    /** Active EventSource instance. */
+    #event_source = null;
+    /** Path to the SSE stream endpoint. */
+    #stream_url;
+    constructor(stream_url = '/api/admin/audit-log/stream') {
+        super();
+        this.#stream_url = stream_url;
+    }
+    async fetch(options) {
+        await this.run(async () => {
+            const params = new URLSearchParams();
+            if (options?.event_type)
+                params.set('event_type', options.event_type);
+            if (options?.account_id)
+                params.set('account_id', options.account_id);
+            if (options?.limit != null)
+                params.set('limit', String(options.limit));
+            if (options?.offset != null)
+                params.set('offset', String(options.offset));
+            const qs = params.toString();
+            const url = `/api/admin/audit-log${qs ? `?${qs}` : ''}`;
+            const response = await ui_fetch(url);
+            if (!response.ok) {
+                throw new Error(await parse_response_error(response, 'Failed to fetch audit log'));
+            }
+            const data = await response.json();
+            this.events = data.events ?? [];
+            // track the highest seq for gap fill
+            this.#update_last_seq(this.events);
+        });
+    }
+    async fetch_permit_history(limit, offset) {
+        await this.run(async () => {
+            const params = new URLSearchParams();
+            if (limit != null)
+                params.set('limit', String(limit));
+            if (offset != null)
+                params.set('offset', String(offset));
+            const qs = params.toString();
+            const url = `/api/admin/audit-log/permit-history${qs ? `?${qs}` : ''}`;
+            const response = await ui_fetch(url);
+            if (!response.ok) {
+                throw new Error(await parse_response_error(response, 'Failed to fetch permit history'));
+            }
+            const data = await response.json();
+            this.permit_history_events = data.events ?? [];
+        });
+    }
+    /**
+     * Connect to the SSE stream for realtime audit events.
+     *
+     * New events are prepended to `events`. EventSource auto-reconnects on
+     * transient errors; `since_seq` fills gaps on reconnection.
+     *
+     * @returns cleanup function that closes the connection
+     */
+    subscribe() {
+        this.disconnect();
+        const source = new EventSource(this.#stream_url);
+        this.#event_source = source;
+        source.onopen = () => {
+            if (DEV)
+                console.log('[audit_log_sse] connected');
+            this.connected = true;
+            // fill any gap from reconnection
+            if (this.#last_seq != null) {
+                void this.#fill_gap(this.#last_seq);
+            }
+        };
+        source.onmessage = (e) => {
+            try {
+                const notification = JSON.parse(e.data);
+                const raw = notification.params;
+                if (DEV)
+                    console.log('[audit_log_sse]', notification.method, raw);
+                // normalize SSE events to include username fields
+                const event = {
+                    ...raw,
+                    username: null,
+                    target_username: null,
+                };
+                // prepend — newest first, matching the fetch sort order
+                this.events = [event, ...this.events];
+                this.#last_seq = Math.max(this.#last_seq ?? 0, event.seq);
+            }
+            catch {
+                // ignore malformed messages
+            }
+        };
+        source.onerror = () => {
+            if (DEV)
+                console.log('[audit_log_sse] error, readyState:', source.readyState);
+            this.connected = source.readyState === EventSource.OPEN;
+        };
+        return () => this.disconnect();
+    }
+    /** Close the SSE connection. */
+    disconnect() {
+        if (this.#event_source) {
+            this.#event_source.close();
+            this.#event_source = null;
+        }
+        this.connected = false;
+    }
+    /** Fetch events missed during disconnection, keyed by `since_seq`. */
+    async #fill_gap(since_seq) {
+        try {
+            const url = `/api/admin/audit-log?since_seq=${since_seq}&limit=200`;
+            const response = await ui_fetch(url);
+            if (!response.ok)
+                return;
+            const data = await response.json();
+            const gap_events = data.events ?? [];
+            if (gap_events.length === 0)
+                return;
+            // merge — deduplicate by id, keep newest-first order
+            const existing_ids = new Set(this.events.map((e) => e.id));
+            const new_events = gap_events.filter((e) => !existing_ids.has(e.id));
+            if (new_events.length > 0) {
+                this.events = [...new_events, ...this.events];
+                this.#update_last_seq(new_events);
+            }
+        }
+        catch {
+            // gap fill is best-effort
+        }
+    }
+    /** Update `#last_seq` from an array of events. */
+    #update_last_seq(events) {
+        for (const event of events) {
+            this.#last_seq = Math.max(this.#last_seq ?? 0, event.seq);
+        }
+    }
+}

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

@@ -0,0 +1,85 @@
+/**
+ * Reactive state for cookie-based authentication.
+ *
+ * SPA auth pattern: prerendered static HTML served by Hono, no SvelteKit
+ * server for SSR sessions. On load, fetches `GET /api/account/status` which
+ * returns the current account (200) or 401 with optional `bootstrap_available`.
+ * Login sends username + password once, then a signed httpOnly cookie handles
+ * all subsequent requests.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * 	import {AuthState, auth_state_context} from '@fuzdev/fuz_app/ui/auth_state.svelte.js';
+ *
+ * 	const auth = new AuthState();
+ * 	auth_state_context.set(auth);
+ * 	auth.check_session();
+ * </script>
+ *
+ * {#if auth.verifying}
+ * 	<p>checking session…</p>
+ * {:else if auth.needs_bootstrap}
+ * 	<BootstrapForm />
+ * {:else if !auth.verified}
+ * 	<LoginForm />
+ * {:else}
+ * 	<p>logged in as {auth.account?.username}</p>
+ * 	<button onclick={() => auth.logout()}>logout</button>
+ * {/if}
+ * ```
+ *
+ * @module
+ */
+import { type Permit, type SessionAccount } from '../auth/account_schema.js';
+export declare class AuthState {
+    verifying: boolean;
+    verified: boolean;
+    verify_error: string | null;
+    account: SessionAccount | null;
+    permits: Array<Permit>;
+    readonly active_permits: Array<Permit>;
+    readonly roles: Array<string>;
+    /** True when bootstrap is available (no accounts exist yet). */
+    needs_bootstrap: boolean;
+    /**
+     * Check auth state and bootstrap availability.
+     *
+     * Fetches `GET /api/account/status` — returns account info (200) or
+     * 401 with optional `bootstrap_available` flag.
+     * Called on init, and after login/bootstrap to refresh state.
+     */
+    check_session(): Promise<void>;
+    /**
+     * Log in with username and password.
+     *
+     * @returns `true` if login succeeded, `false` otherwise
+     */
+    login(username: string, password: string): Promise<boolean>;
+    /**
+     * Bootstrap the first keeper account.
+     *
+     * @returns `true` if bootstrap succeeded, `false` otherwise
+     */
+    bootstrap(token: string, username: string, password: string): Promise<boolean>;
+    /**
+     * Sign up with an invite.
+     *
+     * @returns `true` if signup succeeded, `false` otherwise
+     */
+    signup(username: string, password: string, email?: string): Promise<boolean>;
+    /**
+     * Log out by clearing the session cookie.
+     */
+    logout(): Promise<void>;
+}
+/**
+ * Svelte context for `AuthState`.
+ * Use `auth_state_context.set(state)` in the provider and `auth_state_context.get()` to access.
+ */
+export declare const auth_state_context: {
+    get: (error_message?: string) => AuthState;
+    get_maybe: () => AuthState | undefined;
+    set: (value: AuthState) => AuthState;
+};
+//# sourceMappingURL=auth_state.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/ui/auth_state.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAMH,OAAO,EAAC,KAAK,MAAM,EAAoB,KAAK,cAAc,EAAC,MAAM,2BAA2B,CAAC;AAE7F,qBAAa,SAAS;IACrB,SAAS,UAAiB;IAC1B,QAAQ,UAAiB;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAgB;IAC3C,OAAO,EAAE,cAAc,GAAG,IAAI,CAAgB;IAC9C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAc;IACpC,QAAQ,CAAC,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC,CAEpC;IACF,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAoD;IAEjF,gEAAgE;IAChE,eAAe,UAAiB;IAEhC;;;;;;OAMG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IA4BpC;;;;OAIG;IACG,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAwCjE;;;;OAIG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiCpF;;;;OAIG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4ClF;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAU7B;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;CAA8B,CAAC"}

package/dist/ui/auth_state.svelte.js

@@ -0,0 +1,238 @@
+/**
+ * Reactive state for cookie-based authentication.
+ *
+ * SPA auth pattern: prerendered static HTML served by Hono, no SvelteKit
+ * server for SSR sessions. On load, fetches `GET /api/account/status` which
+ * returns the current account (200) or 401 with optional `bootstrap_available`.
+ * Login sends username + password once, then a signed httpOnly cookie handles
+ * all subsequent requests.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * 	import {AuthState, auth_state_context} from '@fuzdev/fuz_app/ui/auth_state.svelte.js';
+ *
+ * 	const auth = new AuthState();
+ * 	auth_state_context.set(auth);
+ * 	auth.check_session();
+ * </script>
+ *
+ * {#if auth.verifying}
+ * 	<p>checking session…</p>
+ * {:else if auth.needs_bootstrap}
+ * 	<BootstrapForm />
+ * {:else if !auth.verified}
+ * 	<LoginForm />
+ * {:else}
+ * 	<p>logged in as {auth.account?.username}</p>
+ * 	<button onclick={() => auth.logout()}>logout</button>
+ * {/if}
+ * ```
+ *
+ * @module
+ */
+import { create_context } from '@fuzdev/fuz_ui/context_helpers.js';
+import { ui_fetch } from './ui_fetch.js';
+import { is_permit_active } from '../auth/account_schema.js';
+export class AuthState {
+    verifying = $state(false);
+    verified = $state(false);
+    verify_error = $state(null);
+    account = $state(null);
+    permits = $state([]);
+    active_permits = $derived(this.permits.filter((p) => is_permit_active(p)));
+    roles = $derived(this.active_permits.map((p) => p.role));
+    /** True when bootstrap is available (no accounts exist yet). */
+    needs_bootstrap = $state(false);
+    /**
+     * Check auth state and bootstrap availability.
+     *
+     * Fetches `GET /api/account/status` — returns account info (200) or
+     * 401 with optional `bootstrap_available` flag.
+     * Called on init, and after login/bootstrap to refresh state.
+     */
+    async check_session() {
+        this.verifying = true;
+        try {
+            const response = await ui_fetch('/api/account/status');
+            if (response.ok) {
+                const data = await response.json();
+                this.verified = true;
+                this.account = data.account ?? null;
+                this.permits = data.permits ?? [];
+                this.needs_bootstrap = false;
+            }
+            else {
+                this.verified = false;
+                if (response.status === 401) {
+                    try {
+                        const data = await response.json();
+                        this.needs_bootstrap = data.bootstrap_available ?? false;
+                    }
+                    catch {
+                        // non-JSON error response
+                    }
+                }
+            }
+        }
+        catch {
+            this.verified = false;
+        }
+        finally {
+            this.verifying = false;
+        }
+    }
+    /**
+     * Log in with username and password.
+     *
+     * @returns `true` if login succeeded, `false` otherwise
+     */
+    async login(username, password) {
+        this.verifying = true;
+        this.verify_error = null;
+        try {
+            const response = await ui_fetch('/api/account/login', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ username, password }),
+            });
+            if (response.ok) {
+                this.verified = true;
+                // Fetch account info
+                await this.check_session();
+                return true;
+            }
+            if (response.status === 429) {
+                try {
+                    const data = await response.json();
+                    const minutes = Math.ceil((data.retry_after ?? 60) / 60);
+                    this.verify_error = `Too many attempts. Try again in ${minutes} minute${minutes === 1 ? '' : 's'}.`;
+                }
+                catch {
+                    this.verify_error = 'Too many attempts. Try again later.';
+                }
+            }
+            else if (response.status === 401) {
+                this.verify_error = 'Invalid credentials';
+            }
+            else {
+                this.verify_error = `Error: ${response.status}`;
+            }
+            return false;
+        }
+        catch (e) {
+            this.verify_error = e instanceof Error ? e.message : 'Connection failed';
+            return false;
+        }
+        finally {
+            this.verifying = false;
+        }
+    }
+    /**
+     * Bootstrap the first keeper account.
+     *
+     * @returns `true` if bootstrap succeeded, `false` otherwise
+     */
+    async bootstrap(token, username, password) {
+        this.verifying = true;
+        this.verify_error = null;
+        try {
+            const response = await ui_fetch('/api/account/bootstrap', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ token, username, password }),
+            });
+            if (response.ok) {
+                this.verified = true;
+                this.needs_bootstrap = false;
+                await this.check_session();
+                return true;
+            }
+            try {
+                const data = await response.json();
+                this.verify_error = data.error ?? `Error: ${response.status}`;
+            }
+            catch {
+                this.verify_error = `Error: ${response.status}`;
+            }
+            return false;
+        }
+        catch (e) {
+            this.verify_error = e instanceof Error ? e.message : 'Connection failed';
+            return false;
+        }
+        finally {
+            this.verifying = false;
+        }
+    }
+    /**
+     * Sign up with an invite.
+     *
+     * @returns `true` if signup succeeded, `false` otherwise
+     */
+    async signup(username, password, email) {
+        this.verifying = true;
+        this.verify_error = null;
+        try {
+            const body = { username, password };
+            if (email)
+                body.email = email;
+            const response = await ui_fetch('/api/account/signup', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+            if (response.ok) {
+                this.verified = true;
+                await this.check_session();
+                return true;
+            }
+            if (response.status === 429) {
+                try {
+                    const data = await response.json();
+                    const minutes = Math.ceil((data.retry_after ?? 60) / 60);
+                    this.verify_error = `Too many attempts. Try again in ${minutes} minute${minutes === 1 ? '' : 's'}.`;
+                }
+                catch {
+                    this.verify_error = 'Too many attempts. Try again later.';
+                }
+            }
+            else if (response.status === 403) {
+                this.verify_error = 'No matching invite found for these credentials.';
+            }
+            else if (response.status === 409) {
+                this.verify_error = 'Username or email is already in use.';
+            }
+            else {
+                this.verify_error = `Error: ${response.status}`;
+            }
+            return false;
+        }
+        catch (e) {
+            this.verify_error = e instanceof Error ? e.message : 'Connection failed';
+            return false;
+        }
+        finally {
+            this.verifying = false;
+        }
+    }
+    /**
+     * Log out by clearing the session cookie.
+     */
+    async logout() {
+        try {
+            await ui_fetch('/api/account/logout', { method: 'POST' });
+        }
+        catch {
+            // Best-effort — clear local state regardless
+        }
+        this.verified = false;
+        this.account = null;
+        this.permits = [];
+    }
+}
+/**
+ * Svelte context for `AuthState`.
+ * Use `auth_state_context.set(state)` in the provider and `auth_state_context.get()` to access.
+ */
+export const auth_state_context = create_context();

package/dist/ui/datatable.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Types and constants for the `Datatable` component.
+ *
+ * @module
+ */
+/** Default minimum column width in pixels. */
+export declare const DATATABLE_MIN_COLUMN_WIDTH = 50;
+/** Default initial column width in pixels. */
+export declare const DATATABLE_COLUMN_WIDTH_DEFAULT = 120;
+/**
+ * Column definition for a `Datatable`.
+ */
+export interface DatatableColumn<T = unknown> {
+    /** Row data accessor key. */
+    key: string & keyof T;
+    /** Header label text. */
+    label: string;
+    /** Initial column width in pixels. */
+    width?: number;
+    /** Minimum column width in pixels. */
+    min_width?: number;
+    /** Format a cell value for display. Falls back to `format_value` when absent. */
+    format?: (value: T[keyof T], row: T) => string;
+}
+//# sourceMappingURL=datatable.d.ts.map

package/dist/ui/datatable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datatable.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/ui/datatable.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,8CAA8C;AAC9C,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C,8CAA8C;AAC9C,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC3C,6BAA6B;IAC7B,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IACtB,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,MAAM,CAAC;CAC/C"}

package/dist/ui/datatable.js

@@ -0,0 +1,9 @@
+/**
+ * Types and constants for the `Datatable` component.
+ *
+ * @module
+ */
+/** Default minimum column width in pixels. */
+export const DATATABLE_MIN_COLUMN_WIDTH = 50;
+/** Default initial column width in pixels. */
+export const DATATABLE_COLUMN_WIDTH_DEFAULT = 120;

package/dist/ui/enter_advance.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Svelte action that makes Enter advance to the next focusable form element
+ * (inputs and buttons), or activate the element if it's already the last one.
+ *
+ * @example
+ * ```svelte
+ * <form {@attach enter_advance()}>
+ * ```
+ *
+ * @module
+ */
+export declare const enter_advance: () => ((form: HTMLFormElement) => () => void);
+//# sourceMappingURL=enter_advance.d.ts.map

package/dist/ui/enter_advance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enter_advance.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/ui/enter_advance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,eAAO,MAAM,aAAa,QAAO,CAAC,CAAC,IAAI,EAAE,eAAe,KAAK,MAAM,IAAI,CAiBtE,CAAC"}

package/dist/ui/enter_advance.js

@@ -0,0 +1,30 @@
+/**
+ * Svelte action that makes Enter advance to the next focusable form element
+ * (inputs and buttons), or activate the element if it's already the last one.
+ *
+ * @example
+ * ```svelte
+ * <form {@attach enter_advance()}>
+ * ```
+ *
+ * @module
+ */
+const FOCUSABLE_SELECTOR = 'input:not(:disabled), button:not(:disabled)';
+export const enter_advance = () => {
+    return (form) => {
+        const handle_keydown = (e) => {
+            if (e.key !== 'Enter')
+                return;
+            if (!(e.target instanceof HTMLInputElement))
+                return;
+            const elements = Array.from(form.querySelectorAll(FOCUSABLE_SELECTOR));
+            const index = elements.indexOf(e.target);
+            if (index < 0)
+                return;
+            e.preventDefault();
+            elements[(index + 1) % elements.length].focus();
+        };
+        form.addEventListener('keydown', handle_keydown);
+        return () => form.removeEventListener('keydown', handle_keydown);
+    };
+};