@jini-ai/admin 0.3.10 → 0.4.1

package/dist/media/react/hooks/MediaGrid.hooks.js

@@ -0,0 +1,6 @@
+import { mediaRowHandles } from '../../rules.js';
+export function useMediaGrid(props, _optional = {}) {
+    const handles = mediaRowHandles({ media: props.actions.map(action => action.item) });
+    return { className: props.actions.length ? 'jini-media-grid' : 'jini-media-grid-empty', ...props, actions: props.actions.map((action, index) => ({ ...action, handleBase: handles[index] })) };
+}
+//# sourceMappingURL=MediaGrid.hooks.js.map

package/dist/media/react/hooks/MediaLightbox.hooks.d.ts

@@ -0,0 +1,27 @@
+import type { MediaAsset } from '../../models.js';
+import type { MediaApiPort } from '../../ports.js';
+export interface MediaLightboxProps {
+    readonly items: readonly MediaAsset[];
+    readonly api: MediaApiPort;
+    readonly activeIndex: number | null;
+    readonly onNavigate: (index: number) => void;
+    readonly onClose: () => void;
+}
+export declare function useMediaLightbox(props: MediaLightboxProps, _optional?: Record<string, never>): {
+    item: MediaAsset | null;
+    open: boolean;
+    hasPrev: boolean;
+    hasNext: boolean;
+    previous: () => void;
+    next: () => void;
+    items: readonly MediaAsset[];
+    api: MediaApiPort;
+    activeIndex: number | null;
+    onNavigate: (index: number) => void;
+    onClose: () => void;
+    dialogRef: import("react").RefObject<HTMLDialogElement | null>;
+    closeRef: import("react").RefObject<HTMLButtonElement | null>;
+    title: string;
+    position: string;
+};
+//# sourceMappingURL=MediaLightbox.hooks.d.ts.map

package/dist/media/react/hooks/MediaLightbox.hooks.js

@@ -0,0 +1,64 @@
+import { useEffect, useRef } from 'react';
+export function useMediaLightbox(props, _optional = {}) {
+    const item = props.activeIndex === null ? null : props.items[props.activeIndex] ?? null;
+    function go(index) {
+        // Clamps rather than wrapping: staying on the last asset is the less surprising
+        // default for an operator navigating a specific set of uploads, not a slideshow.
+        if (index >= 0 && index < props.items.length) {
+            const focusedPart = dialogRef.current?.ownerDocument.activeElement?.getAttribute('data-jini-part');
+            // Keep focus in the dialog when the focused arrow disappears at a boundary.
+            // Interior navigation leaves focus where the operator put it.
+            if ((index === 0 && focusedPart === 'media.lightbox.previous') ||
+                (index === props.items.length - 1 && focusedPart === 'media.lightbox.next'))
+                closeRef.current?.focus({ preventScroll: true });
+            props.onNavigate(index);
+        }
+    }
+    const closeRef = useRef(null);
+    const dialogRef = useRef(null);
+    const open = !!item;
+    useEffect(() => {
+        // Close exists at every position, so it is a stable initial focus target. Only
+        // opening focuses it; navigation must preserve the operator's current focus.
+        if (open)
+            closeRef.current?.focus();
+    }, [open]);
+    // Dialog owns open/close/focus, keyed on open rather than index: navigation must not
+    // reopen an already-open dialog or recapture its trigger from inside the lightbox.
+    useEffect(() => {
+        const dialog = dialogRef.current;
+        if (!dialog || !item)
+            return;
+        const onKey = (event) => {
+            if (event.key !== 'ArrowLeft' && event.key !== 'ArrowRight')
+                return;
+            event.preventDefault();
+            if (props.activeIndex !== null)
+                go(props.activeIndex + (event.key === 'ArrowRight' ? 1 : -1));
+            // Native video controls may also seek while focused, as in the legacy lightbox.
+            // Preview stage remains private, so do not silently infer it from contentType.
+        };
+        dialog.ownerDocument.addEventListener('keydown', onKey);
+        return () => dialog.ownerDocument.removeEventListener('keydown', onKey);
+    }, [props.activeIndex, props.items, props.onNavigate, !!item]);
+    return {
+        dialogRef,
+        closeRef,
+        title: item ? `Media preview: ${item.title}` : 'Media preview',
+        position: item && props.activeIndex !== null ? `${props.activeIndex + 1} / ${props.items.length}` : '',
+        ...props,
+        item,
+        open: !!item,
+        hasPrev: props.activeIndex !== null && props.activeIndex > 0,
+        hasNext: props.activeIndex !== null && props.activeIndex + 1 < props.items.length,
+        previous: () => {
+            if (props.activeIndex !== null)
+                go(props.activeIndex - 1);
+        },
+        next: () => {
+            if (props.activeIndex !== null)
+                go(props.activeIndex + 1);
+        },
+    };
+}
+//# sourceMappingURL=MediaLightbox.hooks.js.map

package/dist/media/react/hooks/MediaPage.hooks.d.ts

@@ -0,0 +1,68 @@
+import type { ReactNode } from 'react';
+import type { ModulePageProps } from '../../../react/bind-react.js';
+import { createLibraryController } from '../../controllers/library.controller.js';
+import type { LibraryState } from '../../controllers/library.controller.js';
+export declare const MediaLibraryContext: import("react").Context<{
+    controller: ReturnType<typeof createLibraryController> | null;
+    snapshot: LibraryState | null;
+} | null>;
+export declare function useSharedMediaLibrary(_required?: Record<string, never>, _optional?: Record<string, never>): {
+    controller: ReturnType<typeof createLibraryController> | null;
+    snapshot: LibraryState | null;
+} | null;
+export interface MediaPageProps extends ModulePageProps {
+    readonly headerActions?: ReactNode;
+}
+export declare function useMediaPage(props: MediaPageProps, _optional?: Record<string, never>): {
+    library: {
+        controller: {
+            getSnapshot: () => Readonly<LibraryState>;
+            subscribe: ({ listener }: {
+                listener: () => void;
+            }) => () => void;
+            load: (_required?: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+            setQuery({ query }: {
+                query: import("../../models.js").MediaQuery;
+            }, _optional?: Record<string, never>): Promise<void>;
+            upload({ input, alt }: {
+                input: import("../../models.js").UploadInput;
+                alt?: string;
+            }, _optional?: Record<string, never>): Promise<boolean>;
+            trash({ id }: {
+                id: string;
+            }, _optional?: Record<string, never>): Promise<boolean>;
+            restore({ id }: {
+                id: string;
+            }, _optional?: Record<string, never>): Promise<boolean>;
+            requestPurge({ item }: {
+                item: import("../../models.js").MediaAsset;
+            }, _optional?: Record<string, never>): void;
+            cancelPurge(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+            confirmPurge({ confirmed }: {
+                confirmed: boolean;
+            }, _optional?: Record<string, never>): Promise<boolean>;
+            dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+        } | null;
+        snapshot: Readonly<LibraryState> | null;
+    };
+    headerActions: ReactNode;
+    activeId: string | undefined;
+    tabs: {
+        id: string;
+        handle: string;
+        icon: import("react").FunctionComponentElement<Record<string, never>>;
+        count: number | null | undefined;
+        selected: boolean;
+        onPress: () => void;
+        label: string;
+        visible: boolean;
+        reason: string | null;
+        params: Readonly<Record<string, unknown>>;
+        agentReachable: boolean;
+    }[];
+    ActiveTab: import("react").LazyExoticComponent<import("react").ComponentType<import("../../../react/bind-react.js").TabViewProps>> | undefined;
+    params: Readonly<Record<string, unknown>>;
+    permissions: readonly string[];
+    denied: boolean;
+};
+//# sourceMappingURL=MediaPage.hooks.d.ts.map

package/dist/media/react/hooks/MediaPage.hooks.js

@@ -0,0 +1,68 @@
+import { createElement, createContext, useContext, useEffect, useState } from 'react';
+import { useController } from '../../../react/use-controller.js';
+import { createLibraryController } from '../../controllers/library.controller.js';
+import { useMediaPorts } from './MediaPorts.hooks.js';
+import { AllIcon, ImageIcon, VideoIcon, CloudIcon } from '../components/MediaIcons.js';
+import { resolveActiveTab } from '../../rules.js';
+export const MediaLibraryContext = createContext(null);
+export function useSharedMediaLibrary(_required = {}, _optional = {}) {
+    return useContext(MediaLibraryContext);
+}
+export function useMediaPage(props, _optional = {}) {
+    const [localTab, setLocalTab] = useState('all');
+    const { mediaApi, mediaEvents, mediaProviders } = useMediaPorts();
+    const library = useController({ create: () => createLibraryController({ api: mediaApi }, { query: { filter: requestedFilter({ tabId: props.requestedTab ?? localTab }) } }), dependencies: [mediaApi] }, { start: ({ controller }) => { if (props.description.visible)
+            void controller.load(); } });
+    useEffect(() => props.description.visible ? mediaEvents?.subscribe({ onRefresh: () => { void library.controller?.load(); } }) : undefined, [props.description.visible, mediaEvents, library.controller]);
+    const [providerCount, setProviderCount] = useState(null);
+    useEffect(() => {
+        if (!props.description.visible || !mediaProviders || !props.description.grants.includes('media.providers'))
+            return;
+        const abort = new AbortController();
+        void mediaProviders.list({}, { signal: abort.signal }).then(items => {
+            if (!abort.signal.aborted && items)
+                setProviderCount(items.length);
+        }).catch(() => { });
+        return () => abort.abort();
+    }, [mediaProviders, props.description.grants, props.description.visible]);
+    const visible = props.description.visible
+        ? props.description.tabs.filter((tab) => tab.visible)
+        : [];
+    const requested = resolveActiveTab({ tabId: props.requestedTab ?? localTab });
+    const active = visible.find((tab) => tab.id.endsWith(`.${requested}`)) ?? visible[0];
+    const tabs = visible.map((tab) => {
+        const id = tab.id.slice(tab.id.lastIndexOf('.') + 1);
+        return {
+            ...tab,
+            id,
+            handle: `media-tab-${id}`,
+            icon: createElement(id === 'images' ? ImageIcon : id === 'videos' ? VideoIcon : id === 'external-providers' ? CloudIcon : AllIcon, {}),
+            count: id === 'external-providers' ? providerCount : library.snapshot?.counts?.[id],
+            selected: active?.id === tab.id,
+            onPress: () => {
+                setLocalTab(id);
+                props.onTabChange?.({ tab: id });
+            },
+        };
+    });
+    const id = active?.id.slice(active.id.lastIndexOf('.') + 1);
+    useEffect(() => {
+        if (props.description.visible && (id === 'all' || id === 'images' || id === 'videos') && library.controller?.getSnapshot().query.filter !== id)
+            void library.controller?.setQuery({ query: { ...library.controller.getSnapshot().query, filter: id } });
+    }, [id, library.controller, props.description.visible]);
+    return {
+        library,
+        headerActions: props.headerActions,
+        activeId: id,
+        tabs,
+        ActiveTab: id ? props.tabs[id] : undefined,
+        params: active?.params ?? {},
+        permissions: props.description.grants,
+        denied: !props.description.visible,
+    };
+}
+function requestedFilter({ tabId }) {
+    const tab = resolveActiveTab({ tabId });
+    return tab === 'external-providers' ? 'all' : tab;
+}
+//# sourceMappingURL=MediaPage.hooks.js.map

package/dist/media/react/hooks/MediaPicker.hooks.d.ts

@@ -0,0 +1,26 @@
+import type { MediaAsset } from '../../models.js';
+import type { MediaApiPort } from '../../ports.js';
+export interface MediaPickerProps {
+    readonly api: MediaApiPort;
+    readonly accept: readonly string[];
+    readonly onChoose: (asset: MediaAsset | null) => void;
+    readonly onClose: () => void;
+}
+export declare function useMediaPicker(props: MediaPickerProps, _optional?: Record<string, never>): {
+    snapshot: Readonly<import("../../index.js").LibraryState> | null;
+    actions: {
+        item: MediaAsset;
+        onChoose: () => void;
+    }[];
+    loading: boolean;
+    onRetry: () => void;
+    onSearch: ({ value: search }: {
+        value: string;
+    }) => void;
+    search: string;
+    api: MediaApiPort;
+    accept: readonly string[];
+    onChoose: (asset: MediaAsset | null) => void;
+    onClose: () => void;
+};
+//# sourceMappingURL=MediaPicker.hooks.d.ts.map

package/dist/media/react/hooks/MediaPicker.hooks.js

@@ -0,0 +1,25 @@
+import { useController } from '../../../react/use-controller.js';
+import { createLibraryController } from '../../controllers/library.controller.js';
+import { acceptsMedia } from '../../rules.js';
+export function useMediaPicker(props, _optional = {}) {
+    const { controller, snapshot } = useController({ create: () => createLibraryController({ api: props.api }), dependencies: [props.api] }, {
+        start: ({ controller }) => {
+            void controller.load();
+        },
+    });
+    const actions = (snapshot?.items ?? [])
+        .filter((item) => item.status === 'active' && acceptsMedia({ item, accept: props.accept }))
+        .map((item) => ({ item, onChoose: () => props.onChoose(item) }));
+    return {
+        ...props,
+        snapshot,
+        actions,
+        loading: !snapshot || (snapshot.loading && !snapshot.error),
+        onRetry: () => { void controller?.load(); },
+        onSearch: ({ value: search }) => {
+            void controller?.setQuery({ query: { search } });
+        },
+        search: snapshot?.query.search ?? '',
+    };
+}
+//# sourceMappingURL=MediaPicker.hooks.js.map

package/dist/media/react/hooks/MediaPorts.hooks.d.ts

@@ -0,0 +1,9 @@
+import type { MediaApiPort, MediaProvidersPort, MediaEventsPort } from '../../ports.js';
+export interface MediaPorts {
+    readonly mediaApi: MediaApiPort;
+    readonly mediaProviders?: MediaProvidersPort;
+    readonly mediaEvents?: MediaEventsPort;
+}
+export declare const MediaPortsContext: import("react").Context<MediaPorts | null>;
+export declare function useMediaPorts(_required?: Record<string, never>, _optional?: Record<string, never>): MediaPorts;
+//# sourceMappingURL=MediaPorts.hooks.d.ts.map

package/dist/media/react/hooks/MediaPorts.hooks.js

@@ -0,0 +1,10 @@
+import { createContext, useContext } from 'react';
+import { AdminConfigError } from '../../../core/module/index.js';
+export const MediaPortsContext = createContext(null);
+export function useMediaPorts(_required = {}, _optional = {}) {
+    const ports = useContext(MediaPortsContext);
+    if (!ports)
+        throw new AdminConfigError({ issues: ['React scope unavailable: media'] });
+    return ports;
+}
+//# sourceMappingURL=MediaPorts.hooks.js.map

package/dist/media/react/hooks/MediaPurgeDialog.hooks.d.ts

@@ -0,0 +1,22 @@
+/** Confirmation safety moved to ui-kit's framework-free controller. Cancel-first focus,
+ * pending dismissal/activation and trigger restoration remain enforced for every view. */
+export interface MediaPurgeDialogProps {
+    readonly filename?: string;
+    readonly open: boolean;
+    readonly pending: boolean;
+    readonly onCancel: () => void;
+    readonly onConfirm: () => void | Promise<void>;
+}
+export declare function useMediaPurgeDialog(props: MediaPurgeDialogProps, _optional?: Record<string, never>): {
+    actionAccessibleNames: {
+        cancel: string;
+        confirm: string;
+    };
+    consequence: string;
+    filename?: string;
+    open: boolean;
+    pending: boolean;
+    onCancel: () => void;
+    onConfirm: () => void | Promise<void>;
+};
+//# sourceMappingURL=MediaPurgeDialog.hooks.d.ts.map

package/dist/media/react/hooks/MediaPurgeDialog.hooks.js

@@ -0,0 +1,6 @@
+export function useMediaPurgeDialog(props, _optional = {}) {
+    return { ...props, actionAccessibleNames: { cancel: 'Cancel', confirm: 'Delete permanently' }, consequence: props.filename
+            ? `Permanently delete "${props.filename}"? This cannot be undone.`
+            : 'This permanently deletes the file. This cannot be undone.' };
+}
+//# sourceMappingURL=MediaPurgeDialog.hooks.js.map

package/dist/media/react/hooks/ProvidersTab.hooks.d.ts

@@ -0,0 +1,55 @@
+import type { ChangeEvent } from 'react';
+export declare function useProvidersTab(_required?: Record<string, never>, _optional?: Record<string, never>): {
+    rows: {
+        divider: boolean;
+        statusLabel: string | null;
+        statusClassName: string;
+        credential: string;
+        credentialType: "text" | "password";
+        credentialPlaceholder: string;
+        credentialAttrs: {
+            'data-jini-part': string;
+            'data-agent-private': boolean;
+            'data-agent-element': string;
+            'aria-label': string;
+        };
+        toggleLabel: string;
+        visible: boolean;
+        toggle(): void;
+        onCredential: (event: ChangeEvent<HTMLInputElement>) => void;
+        baseUrl: string;
+        baseUrlPlaceholder: string;
+        baseUrlLabel: string;
+        onBaseUrl: (event: ChangeEvent<HTMLInputElement>) => void;
+        model: string;
+        modelLabel: string;
+        modelsId: string;
+        hasModels: boolean;
+        onModel: (event: ChangeEvent<HTMLInputElement>) => void;
+        clearLabel: string;
+        clearDisabled: boolean;
+        clear: () => void;
+        invalid: boolean;
+        hint: string | null;
+        hintClassName: string;
+        hintRole: "alert" | undefined;
+        ariaInvalid: true | undefined;
+        id: string;
+        label: string;
+        defaultBaseUrl?: string;
+        models?: readonly string[];
+    }[];
+    reload: () => void;
+    reloadDisabled: boolean;
+    reloadLabel: string;
+    unreachable: boolean;
+    empty: boolean;
+    save: () => void;
+    saveLabel: string;
+    saveDisabled: boolean;
+    saved: boolean;
+    saveError: boolean;
+    disabled: boolean;
+    settingsDisabled: boolean;
+};
+//# sourceMappingURL=ProvidersTab.hooks.d.ts.map

package/dist/media/react/hooks/ProvidersTab.hooks.js

@@ -0,0 +1,124 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useMediaProvidersTab, sortProvidersByConfigured, isEntryPresent, isMarkerOnlyEntry, maskedKeyLabel, isProviderBaseUrlInvalid, invalidBaseUrlProviderIds } from '@jini-ai/ui';
+import { useMediaPorts } from './MediaPorts.hooks.js';
+function configuration({ items }, _optional = {}) {
+    return Object.fromEntries(items.filter(item => item.configured || item.apiKeyTail || item.baseUrl?.trim() || item.model?.trim())
+        .map(item => [item.id, { apiKeyConfigured: item.configured,
+            ...(item.apiKeyTail === undefined ? {} : { apiKeyTail: item.apiKeyTail }),
+            ...(item.baseUrl === undefined ? {} : { baseUrl: item.baseUrl }),
+            ...(item.model === undefined ? {} : { model: item.model }) }]));
+}
+export function useProvidersTab(_required = {}, _optional = {}) {
+    const { mediaProviders } = useMediaPorts();
+    const [discoveredCatalog, setDiscoveredCatalog] = useState([]);
+    const [visibleKeys, setVisibleKeys] = useState(() => new Set());
+    const lifetime = useRef(null);
+    useEffect(() => {
+        const abort = new AbortController();
+        lifetime.current = abort;
+        return () => abort.abort();
+    }, [mediaProviders]);
+    // Always invoke the hook. An unavailable optional port uses an inert, scoped fallback.
+    // Reuse the established editor's send-time serialization, reload merge and clear rollback.
+    const editorPort = useMemo(() => {
+        let lastRead = [];
+        return {
+            async fetchMediaProviders() {
+                try {
+                    const signal = lifetime.current.signal;
+                    const items = await mediaProviders?.list({}, { signal });
+                    if (!items || signal.aborted)
+                        return null;
+                    lastRead = items;
+                    setDiscoveredCatalog(items.map(({ id, label }) => ({ id, label })));
+                    return configuration({ items });
+                }
+                catch {
+                    return null;
+                }
+            },
+            async saveMediaProviders(providers) {
+                if (!mediaProviders)
+                    throw new Error('Provider service unavailable');
+                const signal = lifetime.current.signal;
+                if (mediaProviders.saveChanges) {
+                    const items = await mediaProviders.saveChanges({ providers }, { signal });
+                    lastRead = items;
+                    return configuration({ items });
+                }
+                // Older hosts retain the one-button editor; writes remain sequential and failures
+                // retain local edits. Atomic whole-set hosts should implement saveChanges instead.
+                for (const item of lastRead) {
+                    const entry = providers[item.id];
+                    if (!entry) {
+                        if (item.configured || item.baseUrl || item.model)
+                            await mediaProviders.removeCredential({ id: item.id }, { signal });
+                        continue;
+                    }
+                    if ((entry.baseUrl ?? '') !== (item.baseUrl ?? '') || (entry.model ?? '') !== (item.model ?? '')) {
+                        if (!mediaProviders.saveSettings)
+                            throw new Error('Provider settings unavailable');
+                        await mediaProviders.saveSettings({ id: item.id, baseUrl: entry.baseUrl ?? '', model: entry.model ?? '' }, { signal });
+                    }
+                    if (entry.apiKey?.trim())
+                        await mediaProviders.saveCredential({ id: item.id, credential: entry.apiKey }, { signal });
+                }
+                const items = await mediaProviders.list({}, { signal });
+                if (!items)
+                    throw new Error('Provider service unavailable');
+                lastRead = items;
+                return configuration({ items });
+            },
+        };
+    }, [mediaProviders]);
+    const editor = useMediaProvidersTab({ port: editorPort });
+    const catalog = mediaProviders?.catalog ?? discoveredCatalog;
+    const pinnedIds = mediaProviders?.pinnedProviderIds ?? [];
+    const ordered = sortProvidersByConfigured(catalog, editor.providers, pinnedIds);
+    const rows = ordered.map((item, index) => {
+        const entry = editor.providers[item.id] ?? {};
+        const saved = isMarkerOnlyEntry(entry);
+        const mask = saved ? maskedKeyLabel(entry) : null;
+        const visible = visibleKeys.has(item.id);
+        const invalid = isProviderBaseUrlInvalid(entry);
+        const modelsId = `jini-media-provider-models-${item.id}`;
+        return {
+            ...item,
+            divider: index > 0 && !pinnedIds.includes(item.id) && pinnedIds.includes(ordered[index - 1].id),
+            statusLabel: saved ? `Saved (${mask})` : editor.pendingProviderIds.has(item.id) ? 'Unsaved' : null,
+            statusClassName: saved ? 'jini-field-status-badge jini-field-status-badge-success' : 'jini-field-status-badge',
+            credential: entry.apiKey ?? '', credentialType: visible ? 'text' : 'password',
+            credentialPlaceholder: mask ?? 'Paste your API key',
+            credentialAttrs: { 'data-jini-part': 'media.provider.credential', 'data-agent-private': true,
+                'data-agent-element': `media-provider-${item.id}-api-key`, 'aria-label': `${item.label} credential` },
+            toggleLabel: `${item.label} ${visible ? 'Hide' : 'Show'}`, visible,
+            toggle() { setVisibleKeys(current => { const next = new Set(current); if (next.has(item.id))
+                next.delete(item.id);
+            else
+                next.add(item.id); return next; }); },
+            onCredential: (event) => editor.updateProvider(item.id, { apiKey: event.currentTarget.value }),
+            baseUrl: entry.baseUrl ?? '', baseUrlPlaceholder: item.defaultBaseUrl || 'https://api.example.com',
+            baseUrlLabel: `${item.label} base URL`,
+            onBaseUrl: (event) => editor.updateProvider(item.id, { baseUrl: event.currentTarget.value }),
+            model: entry.model ?? '', modelLabel: `${item.label} model`, modelsId, hasModels: !!item.models?.length,
+            onModel: (event) => editor.updateProvider(item.id, { model: event.currentTarget.value }),
+            clearLabel: `${item.label} Clear`, clearDisabled: !isEntryPresent(entry) || !mediaProviders,
+            clear: () => editor.clearProvider(item.id),
+            invalid, hint: invalid ? 'Enter an absolute http:// or https:// URL that is not a private or internal address.'
+                : !entry.baseUrl?.trim() && item.defaultBaseUrl ? `Uses ${item.defaultBaseUrl} by default.` : null,
+            hintClassName: invalid ? 'jini-field-hint jini-hint-error' : 'jini-field-hint',
+            hintRole: invalid ? 'alert' : undefined,
+            ariaInvalid: invalid || undefined,
+        };
+    });
+    return { rows, reload: editor.reload, reloadDisabled: editor.load.status === 'loading',
+        reloadLabel: editor.load.status === 'loading' ? 'Reloading…' : 'Reload',
+        unreachable: editor.load.status === 'unreachable', empty: !editor.hasAnyConfigured,
+        save: editor.saveChanges, saveLabel: editor.save.status === 'saving' ? 'Saving…' : 'Save changes',
+        saveDisabled: !mediaProviders || editor.save.status === 'saving' || !editor.pendingProviderIds.size || !!invalidBaseUrlProviderIds(editor.providers).length,
+        saved: editor.save.status === 'saved', saveError: editor.save.status === 'save-error', disabled: !mediaProviders,
+        // Fail closed: a host that can persist neither the whole set nor per-provider settings
+        // must not accept endpoint/model edits that would only surface as a failed save.
+        settingsDisabled: !mediaProviders || (!mediaProviders.saveChanges && !mediaProviders.saveSettings) };
+}
+//# sourceMappingURL=ProvidersTab.hooks.js.map

package/dist/media/react/hooks/UploadButton.hooks.d.ts

@@ -0,0 +1,48 @@
+import type { ChangeEvent, DragEvent } from 'react';
+import type { UploadInput } from '../../models.js';
+export interface UploadButtonProps {
+    readonly upload: (required: {
+        input: UploadInput;
+        alt?: string;
+    }, optional?: Record<string, never>) => Promise<boolean>;
+    readonly disabled?: boolean;
+    readonly label?: string;
+    readonly multiple?: boolean;
+    /** Replacement keeps the asset's metadata, so its toolbar has no alt input to fill. */
+    readonly withAlt?: boolean;
+}
+/** Reads a browser File at the React boundary; headless controllers only receive bytes. */
+export declare function readMediaFile({ file }: {
+    file: File;
+}, { signal }?: {
+    signal?: AbortSignal;
+}): Promise<UploadInput>;
+export declare function useUploadButton(props: UploadButtonProps, _optional?: Record<string, never>): {
+    alt: string;
+    withAlt: boolean;
+    multiple: boolean;
+    chooseLabel: string;
+    altLabel: string;
+    handles: {
+        toolbar: string;
+        file: string;
+        alt: string;
+        submit: string;
+    };
+    selectedFileName: string;
+    onUpload: () => void;
+    onDragOver: (event: DragEvent) => void;
+    onDrop: (event: DragEvent) => void;
+    uploadDisabled: boolean;
+    setAlt: ({ value }: {
+        value: string;
+    }) => void;
+    inputRef: import("react").RefObject<HTMLInputElement | null>;
+    onFile: (event: ChangeEvent<HTMLInputElement>) => void;
+    error: string | null;
+    success: string | null;
+    disabled: boolean;
+    onPress: () => void | undefined;
+    label: string;
+};
+//# sourceMappingURL=UploadButton.hooks.d.ts.map