@parallelworks/ui 0.2.0 → 0.3.1

package/dist/components/Provider.d.ts

@@ -1,8 +1,31 @@
 import type { ReactNode } from 'react';
+export type UIToastId = string | number;
+export interface UIToastOptions {
+    toastId?: UIToastId;
+    /** false hides the default icon. */
+    icon?: false;
+    closeButton?: boolean;
+    autoClose?: number | false;
+}
+export interface UIToastUpdate {
+    render?: ReactNode;
+    type?: 'info' | 'success' | 'warning' | 'error';
+    /** false or null hides the icon. */
+    icon?: false | null;
+    isLoading?: boolean;
+    closeButton?: boolean | null;
+    autoClose?: number | false | null;
+}
 export interface UINotify {
     info: (message: string) => void;
     success: (message: string) => void;
+    warning: (message: string) => void;
     error: (message: string) => void;
+    /** Persistent spinner toast; drive it with update/dismiss via the returned id. */
+    loading: (content: ReactNode, options?: UIToastOptions) => UIToastId;
+    update: (id: UIToastId, update: UIToastUpdate) => void;
+    /** Without an id, dismisses every open toast. */
+    dismiss: (id?: UIToastId) => void;
 }
 export interface UIStrings {
     loading: string;
@@ -47,6 +70,210 @@ export interface UIStrings {
         openOriginalWorkflow: string;
         openInNewGraph: string;
     };
+    fileExplorer: {
+        preview: {
+            shareFile: string;
+            open: string;
+            userType: string;
+            select: (name: string) => string;
+            viewDetails: string;
+            openFolder: string;
+            delete: string;
+            detailsTab: string;
+            previewTab: string;
+            preview: string;
+            openFullPreview: string;
+            quickLook: string;
+            fullWindow: string;
+            streamed: string;
+            streamedTooltip: string;
+            loading: string;
+            linkError: string;
+            errorTitle: string;
+            previewError: string;
+            tooLarge: string;
+            downloadInstead: string;
+            archiveTitle: string;
+            archiveMessage: string;
+            unsupportedTitle: string;
+            unsupportedMessage: string;
+            notebookParseError: string;
+            copyUri: string;
+            download: string;
+            close: string;
+            zoomIn: string;
+            zoomOut: string;
+            previousFile: string;
+            nextFile: string;
+            csvRows: (count: number, columns: number) => string;
+            csvFirstRows: (count: number, columns: number) => string;
+            head: string;
+            tail: string;
+            firstLines: (count: number) => string;
+            lastLines: (count: number) => string;
+            notebookOutput: string;
+        };
+        createFolder: {
+            action: string;
+            submit: string;
+            creating: string;
+            folder: string;
+            namePlaceholder: string;
+            success: (name: string) => string;
+            error: (message: string) => string;
+            invalidTarget: string;
+            noWriteAccess: string;
+            unsupported: string;
+            validation: {
+                reserved: string;
+                separator: string;
+                exists: string;
+            };
+        };
+        readOnly: string;
+        cors: {
+            explanation: {
+                title: string;
+                description: string;
+                action: string;
+                note: string;
+            };
+            actions: {
+                retry: string;
+                addRules: string;
+            };
+            propagating: {
+                title: string;
+                description: string;
+                stages: {
+                    submitted: string;
+                    propagating: string;
+                    verified: string;
+                };
+                telemetry: {
+                    probing: string;
+                };
+            };
+        };
+        selectedCount: (count: number) => string;
+        loadingMore: string;
+        loadMore: string;
+        retry: string;
+        partialCount: (count: number) => string;
+        notFound: {
+            title: (name: string) => string;
+            description: string;
+            retry: string;
+        };
+        treeMoreCount: (count: number) => string;
+        treeMoreCountPartial: (count: number) => string;
+        messages: {
+            noWriteAccess: string;
+            uploadsUnsupported: string;
+            noFilesForDownload: string;
+            downloadLinkFailed: string;
+            fileLinkFailed: string;
+            fileLinkCopied: string;
+            noUri: string;
+            uriCopied: string;
+            uriCopyFailed: string;
+            storageUnavailable: string;
+            waitForCurrentUpload: string;
+            waitForUpload: string;
+            downloadUnsupported: string;
+            sharingUnsupported: string;
+            deleteUnsupported: string;
+            uploadUnsupported: string;
+            noItemsForDeletion: string;
+            deleting: string;
+            deleteSomeFailed: string;
+            deleteSuccess: string;
+            deleteFailed: (message: string) => string;
+            noFilesToUpload: string;
+            invalidUploadTarget: string;
+            uploadInitFailed: string;
+            uploadQueuedInfo: string;
+            connectFailed: string;
+            corsNoStorage: string;
+            corsAdded: string;
+            corsPropagating: string;
+        };
+        chrome: {
+            explorer: string;
+            refresh: string;
+            collapse: string;
+            upload: string;
+            download: string;
+            access: string;
+            manageAccess: string;
+            delete: string;
+            copyToClipboard: string;
+            selectAll: string;
+            name: string;
+            size: string;
+            created: string;
+            hash: string;
+            storageIconAlt: string;
+        };
+        confirmUpload: {
+            title: string;
+            text: (path: string) => string;
+            defaultPath: string;
+            noPath: string;
+            confirm: string;
+            target: string;
+            totalSize: string;
+            sizeLimitTitle: string;
+            sizeLimitBody: (total: string, max: string) => string;
+            sizeLimitHint: string;
+        };
+        confirmDelete: {
+            title: string;
+            text: string;
+            action: string;
+        };
+        empty: {
+            nothingSelected: string;
+            nothingSelectedHint: string;
+            folderEmpty: string;
+            dropHint: string;
+            readOnlyHint: string;
+            connectionIssue: string;
+            tryAgain: string;
+            shareThisFile: string;
+        };
+        upload: {
+            inQueue: (position: number, total: number) => string;
+            queuedShort: (position: number, total: number) => string;
+            destination: string;
+            eta: string;
+            uploading: string;
+            completeTitle: string;
+            completeShort: string;
+            failedTitle: string;
+            failedShort: string;
+            unknownTitle: string;
+            unknownShort: string;
+            cancelled: string;
+            completed: string;
+            failed: string;
+            totalSize: string;
+            size: string;
+            calculating: string;
+            expandDetails: string;
+            minimizeDetails: string;
+            sessionNotQueued: (id: string, status: string) => string;
+            allCancelled: (count: number) => string;
+            someUploaded: (count: number) => string;
+            someCancelled: (count: number) => string;
+            allUploaded: string;
+            failedSummary: (failed: number, total: number) => string;
+            failReasonGeneric: string;
+            refreshFailed: (name: string, message: string) => string;
+            unknownError: string;
+            overallProgress: string;
+        };
+    };
     form: {
         invalidDuration: string;
         durationOutOfRange: (min: string, max: string) => string;
@@ -56,6 +283,19 @@ export interface UIStrings {
         readOnlyDescription: string;
         readOnlyForced: string;
     };
+    list: {
+        copy: (label: string) => string;
+        copied: (label: string) => string;
+        couldntCopy: (label: string) => string;
+        moreActions: string;
+        labelName: string;
+        labelEmail: string;
+        labelUsername: string;
+        labelUid: string;
+        labelId: string;
+        labelUrl: string;
+        couldNotLoad: (noun: string) => string;
+    };
 }
 export interface UINavigation {
     toWorkflow: (name: string) => void;
@@ -89,9 +329,32 @@ export interface UIData {
      * editor's input completion. Absent, that completion silently no-ops.
      */
     resolveWorkflowJson?: (ref: WorkflowJsonRef) => Promise<unknown>;
+    /**
+     * Provisions browser-access CORS rules on a storage. Absent, the storage
+     * explorer hides its "add CORS rules" affordance.
+     */
+    provisionCorsRules?: (args: {
+        csp: string;
+        type?: string;
+        username: string;
+        storageName: string;
+    }) => Promise<{
+        error?: string;
+    }>;
 }
 import type { FieldComponent } from '../form/fieldRegistry.js';
+/** Renders internal navigation; hosts bind their router's Link. */
+export type UILinkComponent = React.ComponentType<{
+    to: string;
+    onClick?: () => void;
+    className?: string;
+    children: ReactNode;
+}>;
+/** The provider's link slot, with a plain anchor fallback. */
+export declare function useLink(): UILinkComponent;
 export interface UISlots {
+    /** Internal navigation links; absent falls back to a plain anchor. */
+    link?: UILinkComponent;
     /**
      * Host-supplied form field components, merged over the form engine's core
      * registry by field type. Lazy components are supported — the registry
@@ -117,6 +380,35 @@ export interface UISlots {
         type?: string;
         className?: string;
     }) => ReactNode;
+    /** Icon URL for a storage type; absent falls back to a generic disk icon.
+     * Scheme-dependent variants are the host's concern — bind with the host's
+     * own theme state. */
+    storageIconUrl?: (args: {
+        type: string;
+    }) => string | undefined;
+    /**
+     * The storage explorer's access-management drawer; absent hides the
+     * affordance. `storage` and `groups` are the host's own objects passed back
+     * through the explorer opaquely.
+     */
+    accessDrawer?: (args: {
+        open: boolean;
+        setOpen: (open: boolean) => void;
+        storage: unknown;
+        groups?: unknown;
+    }) => ReactNode;
+    /** The storage explorer's create-folder dialog; absent hides the affordance. */
+    createFolderDialog?: (args: {
+        open: boolean;
+        onClose: () => void;
+        typeIcon?: ReactNode;
+        typeLabel: string;
+        namePlaceholder: string;
+        submitLabel: string;
+        submittingLabel: string;
+        validateName: (name: string) => string | null;
+        onSubmit: (name: string) => Promise<boolean>;
+    }) => ReactNode;
 }
 export interface UIProviderValue {
     notify: UINotify;
@@ -130,6 +422,7 @@ export declare function useStrings(): UIStrings;
 export declare function useNavigation(): UINavigation;
 export declare function useSlots(): UISlots;
 export declare function useWorkflowJsonResolver(): ((ref: WorkflowJsonRef) => Promise<unknown>) | undefined;
+export declare function useProvisionCorsRules(): UIData['provisionCorsRules'];
 export declare function useRunFile(slug: string, path: string | null, options?: {
     refreshInterval?: number;
 }): RunFileResult;

package/dist/editor/index.d.ts

@@ -4,3 +4,4 @@ export { default as FormCodePanel } from './FormCodePanel.js';
 export type { EditorMarketplaceItem, EditorWorkflowItem, IEditorProps, ISchemaError, } from './Monaco.js';
 export { defineEditorThemes, getThemeName } from './themes.js';
 export { setupMonacoWorkers } from './workers.js';
+export { useCssIsDark } from './useCssIsDark.js';

package/dist/editor/index.js

@@ -1,219 +1,2 @@
-import { CheckIcon, CopyIcon, EyeIcon, EyeOffIcon } from "../icons.js";
-import { o as useStrings, r as useNotify } from "../chunks/Provider-C2VtPnh5.js";
-import { t as Loader } from "../chunks/Loader-DQiZ75fa.js";
-import { t as SwitchToggleSmall } from "../chunks/SwitchToggleSmall-FcsaYSTs.js";
-import { c as FieldWrapper, n as flattenGroups, r as impureSetValueFromPath } from "../chunks/lib-DTgL8klR.js";
-import { n as defineEditorThemes, r as getThemeName, t as setupMonacoWorkers } from "../chunks/workers-Cjfjb8E7.js";
-import cx from "classnames";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { Suspense, lazy, useMemo, useRef, useState } from "react";
-import { convertToDynamicForm, parseStringsOfObj, parseStringsOfObjReady } from "@parallelworks/workflow-parser";
-import { useField, useFormikContext } from "formik";
-//#region src/editor/Editor.tsx
-var MonacoEditor = lazy(() => import("../chunks/Monaco-CP_cL9gp.js"));
-function Editor({ ...props }) {
-	return /* @__PURE__ */ jsx(Suspense, {
-		fallback: /* @__PURE__ */ jsx(Loader, { text: "Loading editor..." }),
-		children: /* @__PURE__ */ jsx(MonacoEditor, { ...props })
-	});
-}
-//#endregion
-//#region src/editor/EditorField.tsx
-function hasResetKeys(obj) {
-	return obj.editorKeyPostfix !== void 0;
-}
-function EditorField(props) {
-	const { field, label, labelPosition, disabled, onChange, tooltipComponent, spaceCompact, setFormDirty } = props;
-	const [fieldState] = useField(field.name);
-	const { setFieldValue, setFieldTouched, values } = useFormikContext();
-	const debounceRef = useRef(null);
-	const touchedRef = useRef(false);
-	const handleChange = (val) => {
-		touchedRef.current = true;
-		if (debounceRef.current) clearTimeout(debounceRef.current);
-		debounceRef.current = setTimeout(() => {
-			if (onChange) onChange(val);
-			setFieldTouched(field.name, true);
-			setFieldValue(field.name, val);
-			setFormDirty(true);
-		}, 500);
-	};
-	let editorKeyPostfix = "";
-	if (hasResetKeys(values)) editorKeyPostfix = values.editorKeyPostfix;
-	const postfixKey = useMemo(() => {
-		const randomKey = Math.random().toString(36).substring(7);
-		return editorKeyPostfix || randomKey;
-	}, [editorKeyPostfix]);
-	const value = fieldState.value;
-	return /* @__PURE__ */ jsx(FieldWrapper, {
-		optional: field.optional,
-		label,
-		tooltipComponent,
-		labelPosition,
-		spaceCompact,
-		children: /* @__PURE__ */ jsx(Editor, {
-			height: "200px",
-			path: field.name,
-			value: touchedRef.current ? void 0 : value,
-			className: cx("bg-(--theme-input-bg) w-11 border focus:border rounded text-[10px] leading-4 pl-[6px]", disabled && "opacity-75"),
-			readOnly: disabled,
-			onChange: handleChange,
-			language: field.options?.language || "shell"
-		}, field.name + postfixKey)
-	});
-}
-//#endregion
-//#region src/editor/FormCodePanel.tsx
-var shouldIgnoreField = (fieldSchema, inputs, arrayIndex) => {
-	if (!fieldSchema?.ignore || !fieldSchema?.hidden) return false;
-	if (!parseStringsOfObjReady) return false;
-	return parseStringsOfObj({
-		inputs,
-		obj: convertToDynamicForm(fieldSchema),
-		index: arrayIndex ?? -1
-	}).hidden === true;
-};
-var filterFields = (formJSON, data, prefix, rootData, arrayIndex) => {
-	const filteredFields = [];
-	return {
-		filteredFields,
-		filtered: Object.keys(data).reduce((acc, key) => {
-			if (data[key] !== null && Array.isArray(data[key])) {
-				acc[key] = [];
-				if (!formJSON[key]) return acc;
-				for (let i = 0; i < data[key].length; i++) {
-					let filteredFieldsNested = [];
-					let filteredNested = {};
-					if (typeof data[key][i] === "object") {
-						const result = filterFields(formJSON[key].options, data[key][i], key + `[${i}].`, rootData || data, i);
-						filteredNested = result.filtered;
-						filteredFieldsNested = result.filteredFields;
-					} else filteredNested = data[key][i];
-					filteredFields.push(...filteredFieldsNested);
-					acc[key][i] = filteredNested;
-				}
-				return acc;
-			}
-			if (data[key] !== null && formJSON && formJSON[key] && typeof data[key] === "object") {
-				const { filteredFields: filteredFieldsNested, filtered: filteredNested } = filterFields(formJSON[key], data[key], key + ".", rootData || data, arrayIndex);
-				filteredFields.push(...filteredFieldsNested);
-				acc[key] = filteredNested;
-				return acc;
-			}
-			if (formJSON?.[key]?.sensitive) {
-				const name = prefix ? prefix + key : key;
-				filteredFields.push({
-					key: name,
-					value: data[key]
-				});
-				return acc;
-			}
-			const contextData = rootData || data;
-			if (formJSON && shouldIgnoreField(formJSON[key], contextData, arrayIndex)) return acc;
-			acc[key] = data[key];
-			return acc;
-		}, {})
-	};
-};
-var populateFiltered = (filteredFields, data) => {
-	filteredFields.forEach((element) => {
-		impureSetValueFromPath(data, element.key, element.value);
-	});
-	return data;
-};
-function FormCodePanel({ formJSON, data, mutate, height = "600px", disabled = false }) {
-	const notify = useNotify();
-	const { common: t } = useStrings();
-	const [jsonHasErrors, setJsonHasErrors] = useState(false);
-	const [showHidden, setShowHidden] = useState(false);
-	const [copied, setCopied] = useState(false);
-	const copyResetRef = useRef(void 0);
-	const isValidJson = (errors) => {
-		setJsonHasErrors(errors.length > 0);
-	};
-	const { filteredFields, filtered } = filterFields(flattenGroups(formJSON), data || {});
-	const hasHiddenFields = filteredFields.length > 0;
-	const displayObj = showHidden && hasHiddenFields ? populateFiltered(filteredFields, structuredClone(filtered)) : filtered;
-	const showHiddenRef = useRef(showHidden);
-	showHiddenRef.current = showHidden;
-	const filteredFieldsRef = useRef(filteredFields);
-	filteredFieldsRef.current = filteredFields;
-	const json = JSON.stringify(displayObj, null, 2);
-	const handleCopy = async () => {
-		try {
-			await navigator.clipboard.writeText(json);
-			setCopied(true);
-			clearTimeout(copyResetRef.current);
-			copyResetRef.current = setTimeout(() => setCopied(false), 2e3);
-		} catch {
-			notify.error(t.copyFailed);
-		}
-	};
-	return /* @__PURE__ */ jsxs("div", {
-		style: { height },
-		className: "flex w-full flex-col gap-2",
-		children: [/* @__PURE__ */ jsxs("div", {
-			className: cx("flex min-h-0 flex-1 flex-col overflow-hidden rounded-md border", jsonHasErrors ? "border-red-500" : "border-(--theme-border)"),
-			children: [/* @__PURE__ */ jsxs("div", {
-				className: "bg-(--theme-muted-panel-bg) text-(--theme-muted-panel-color) flex shrink-0 items-center gap-3 border-b border-(--theme-border) px-3 py-2",
-				children: [hasHiddenFields && /* @__PURE__ */ jsxs("label", {
-					title: t.showHiddenFieldsHint,
-					className: "flex cursor-pointer select-none items-center gap-2 text-sm text-(--theme-app)",
-					children: [/* @__PURE__ */ jsx(SwitchToggleSmall, {
-						value: showHidden,
-						"aria-label": t.showHiddenFields,
-						onClick: () => setShowHidden((prev) => !prev)
-					}), /* @__PURE__ */ jsxs("span", {
-						className: "flex items-center gap-1.5",
-						children: [showHidden ? /* @__PURE__ */ jsx(EyeIcon, {}) : /* @__PURE__ */ jsx(EyeOffIcon, {}), t.showHiddenFields]
-					})]
-				}), /* @__PURE__ */ jsxs("button", {
-					type: "button",
-					onClick: handleCopy,
-					"aria-label": copied ? t.copied : t.copy,
-					className: "ml-auto flex shrink-0 items-center gap-1.5 rounded-md border border-(--theme-border) px-2.5 py-1.5 text-sm text-(--theme-app) transition-colors duration-150 hover:bg-(--theme-hover) focus:outline-none focus-visible:ring-2 focus-visible:ring-(--theme-link)",
-					children: [copied ? /* @__PURE__ */ jsx(CheckIcon, { className: "text-green-500" }) : /* @__PURE__ */ jsx(CopyIcon, { className: "text-(--theme-muted-text-color)" }), copied ? t.copied : t.copy]
-				})]
-			}), /* @__PURE__ */ jsx("div", {
-				className: "min-h-0 flex-1",
-				children: /* @__PURE__ */ jsx(Editor, {
-					height: "100%",
-					value: json,
-					onValidate: isValidJson,
-					className: "!rounded-none !border-0",
-					minimap: { enabled: false },
-					scrollBeyondLastLine: false,
-					overviewRulerLanes: 0,
-					overviewRulerBorder: false,
-					lineNumbersMinChars: 3,
-					lineDecorationsWidth: 8,
-					renderLineHighlight: "none",
-					padding: {
-						top: 12,
-						bottom: 12
-					},
-					fontSize: 13,
-					scrollbar: {
-						verticalScrollbarSize: 10,
-						horizontalScrollbarSize: 10
-					},
-					onChange: (e) => {
-						try {
-							const parsed = JSON.parse(e);
-							mutate(showHiddenRef.current ? parsed : populateFiltered(filteredFieldsRef.current, parsed));
-						} catch {
-							console.log("JSON.parse error in slurm editor");
-						}
-					},
-					language: "json",
-					disabled
-				})
-			})]
-		}), jsonHasErrors && /* @__PURE__ */ jsx("p", {
-			className: "shrink-0 text-sm text-red-500",
-			children: t.jsonHasErrors
-		})]
-	});
-}
-//#endregion
-export { Editor, EditorField, FormCodePanel, defineEditorThemes, getThemeName, setupMonacoWorkers };
+import { a as FormCodePanel, i as getThemeName, n as setupMonacoWorkers, o as EditorField, r as defineEditorThemes, s as Editor, t as useCssIsDark } from "../chunks/editor-D55tumuZ.js";
+export { Editor, EditorField, FormCodePanel, defineEditorThemes, getThemeName, setupMonacoWorkers, useCssIsDark };

package/dist/editor/useCssIsDark.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Follows the host's CSS color-scheme, the same signal the log viewer's
+ * light-dark() palette uses — no provider API involved. For the rare concrete
+ * pick (editor themes, image variants) the tokens cannot express.
+ */
+export declare function useCssIsDark(): boolean;

package/dist/file-explorer/FileExplorer.d.ts

@@ -0,0 +1,23 @@
+import type { IFileExplorerClient, IFileExplorerProvider } from './lib/fileExplorer.js';
+import type { TStorage } from './lib/types.js';
+interface IFileExplorerProps {
+    storages: TStorage[];
+    /** Resolves the storage's injected provider pair; the host owns caching. */
+    getProviderAndClient: (storage: TStorage) => Promise<{
+        provider: IFileExplorerProvider | null;
+        client: IFileExplorerClient | null;
+    }>;
+    onRefresh?: () => void;
+    showUserHierarchy?: boolean;
+    groups?: {
+        name: string;
+        id?: string;
+    }[];
+    groupsLoading?: boolean;
+    selectedPath: string;
+    onPathChange: (path: string) => void;
+    /** The modern layout drops the sidebar heading and adds the toolbar row. */
+    variant?: 'classic' | 'modern';
+}
+export default function FileExplorer({ storages, onRefresh, showUserHierarchy, groups, groupsLoading, selectedPath, onPathChange, getProviderAndClient, variant, }: IFileExplorerProps): import("react").JSX.Element;
+export {};

package/dist/file-explorer/FileExplorerContext.d.ts

@@ -0,0 +1,17 @@
+import type { TreeNode, UploadFileProgress, UploadNode, UploadSession } from './lib/types.js';
+import type { IFileExplorerClient, IFileExplorerProvider } from './lib/fileExplorer.js';
+interface IFileExplorerContextValue {
+    uploadSessionMap: Map<string, UploadSession>;
+    uploadQueue: string[];
+    addUploadSession: (storageName: string, targetPath: string, uploadNodes: UploadNode[], client: IFileExplorerClient, provider: IFileExplorerProvider, targetNode: TreeNode, refreshTargetNode: (targetNode: TreeNode) => Promise<unknown>) => string;
+    getUploadSessionById: (sessionId: string) => UploadSession | undefined;
+    getUploadQueueIndex: (sessionId: string) => number;
+    startUploadSession: (sessionId: string) => Promise<void>;
+    updateFileUploadProgress?: (sessionId: string, fileKey: string, progress: UploadFileProgress) => void;
+}
+interface IFileExplorerProviderProps {
+    children: React.ReactNode;
+}
+export declare function FileExplorerProvider({ children }: IFileExplorerProviderProps): import("react").JSX.Element;
+export declare function useFileExplorer(): IFileExplorerContextValue;
+export {};

package/dist/file-explorer/FilePreview/CodePreviewEditor.d.ts

@@ -0,0 +1,6 @@
+interface CodePreviewEditorProps {
+    value: string;
+    language: string;
+}
+export default function CodePreviewEditor({ value, language, }: CodePreviewEditorProps): import("react").JSX.Element;
+export {};

package/dist/file-explorer/FilePreview/Inline.d.ts

@@ -0,0 +1,13 @@
+import type { TreeNode, TStorage } from '../lib/types.js';
+interface FilePreviewInlineProps {
+    node: TreeNode;
+    storage: TStorage | null;
+    getPresignedUrl: (node: TreeNode) => Promise<[string | null, Error | null]>;
+    onOpenFull: (node: TreeNode) => void;
+    onDownload: (node: TreeNode) => void;
+    /** When false, skip fetching and release any held preview blob. */
+    active?: boolean;
+    showSecurityIndicator?: boolean;
+}
+export declare function FilePreviewInline({ node, storage, getPresignedUrl, onOpenFull, onDownload, active, showSecurityIndicator, }: FilePreviewInlineProps): import("react").JSX.Element;
+export {};

package/dist/file-explorer/FilePreview/StreamedBadge.d.ts

@@ -0,0 +1 @@
+export declare function StreamedBadge(): import("react").JSX.Element;

package/dist/file-explorer/FilePreview/Viewer.d.ts

@@ -0,0 +1,15 @@
+import type { TreeNode, TStorage } from '../lib/types.js';
+import { type PreviewKind } from './previewType.js';
+interface FilePreviewViewerProps {
+    node: TreeNode;
+    kind: PreviewKind;
+    url: string | null;
+    urlLoading: boolean;
+    urlError: string | null;
+    /** Image zoom percentage; 100 fits the stage. */
+    zoom?: number;
+    onDownload?: (() => void) | undefined;
+    storage?: TStorage | null;
+}
+export declare function FilePreviewViewer({ node, kind, url, urlLoading, urlError, zoom, onDownload, storage, }: FilePreviewViewerProps): import("react").JSX.Element | null;
+export {};

package/dist/file-explorer/FilePreview/index.d.ts

@@ -0,0 +1,15 @@
+import type { TreeNode, TStorage } from '../lib/types.js';
+interface FilePreviewProps {
+    open: boolean;
+    node: TreeNode | null;
+    siblings: TreeNode[];
+    storage: TStorage | null;
+    getPresignedUrl: (node: TreeNode) => Promise<[string | null, Error | null]>;
+    onNavigate: (node: TreeNode) => void;
+    onClose: () => void;
+    onDownload: (node: TreeNode) => void;
+    onCopyUri: (node: TreeNode) => void;
+    showSecurityIndicator?: boolean;
+}
+export declare function FilePreview({ open, node, siblings, storage, getPresignedUrl, onNavigate, onClose, onDownload, onCopyUri, showSecurityIndicator, }: FilePreviewProps): import("react").ReactPortal | null;
+export {};