@epam/ai-dial-chat-shared 1.1.0-dev.99 → 1.2.0-dev.1

package/file-manager/useGridEditingScroll/useGridEditingScroll.js

@@ -0,0 +1,45 @@
+import { useCallback as e, useEffect as t, useRef as n } from "react";
+//#region src/file-manager/useGridEditingScroll/useGridEditingScroll.ts
+var r = (e) => {
+	if (e.id) {
+		let t = document.querySelector(`[row-id="${e.id}"]`);
+		if (t) return t;
+	}
+	return e.rowIndex == null ? null : document.querySelector(`[row-index="${e.rowIndex}"]`);
+}, i = (e, t) => {
+	requestAnimationFrame(() => {
+		requestAnimationFrame(() => {
+			!e.isDestroyed() && t.rowIndex != null && e.ensureNodeVisible(t, "middle"), r(t)?.scrollIntoView({
+				block: "center",
+				behavior: "auto"
+			});
+		});
+	});
+}, a = (e) => e.find((e) => e.data?.isTemporary) ?? e[0] ?? null, o = ({ resolveTargetNode: r = a } = {}) => {
+	let o = n(/* @__PURE__ */ new Set()), s = n(!1), c = n(null), l = e(() => {
+		o.current = /* @__PURE__ */ new Set(), s.current = !1;
+	}, []), u = e((e) => {
+		let { api: t } = e;
+		!t.isDestroyed() && e.rowIndex != null && t.ensureIndexVisible(e.rowIndex);
+	}, []), d = e((e) => {
+		let { api: t } = e, n = /* @__PURE__ */ new Set(), a = [];
+		t.forEachNode((e) => {
+			let t = e.data?.id;
+			t && (n.add(t), s.current && !o.current.has(t) && a.push(e));
+		}), o.current = n, s.current = !0;
+		let c = r(a);
+		c && i(t, c);
+	}, [r]), f = e((e) => {
+		let t = c.current;
+		t !== e && (t != null && (t.removeEventListener("cellEditingStarted", u), t.removeEventListener("rowDataUpdated", d)), e.addEventListener("cellEditingStarted", u), e.addEventListener("rowDataUpdated", d), c.current = e);
+	}, [u, d]);
+	return t(() => () => {
+		let e = c.current;
+		e != null && !e.isDestroyed() && (e.removeEventListener("cellEditingStarted", u), e.removeEventListener("rowDataUpdated", d)), c.current = null;
+	}, [u, d]), {
+		handleGridApiChange: f,
+		reset: l
+	};
+};
+//#endregion
+export { o as useGridEditingScroll };

package/file-manager.d.ts

@@ -0,0 +1,491 @@
+import { ComponentProps } from 'react';
+import { DialCopiedItem } from '@epam/ai-dial-react-file-manager';
+import { DialDeletedItem } from '@epam/ai-dial-react-file-manager';
+import { DialFile } from '@epam/ai-dial-react-file-manager';
+import { DialFileAcceptType } from '@epam/ai-dial-react-file-manager';
+import { DialFileManager } from '@epam/ai-dial-react-file-manager';
+import { DialFileManagerActions } from '@epam/ai-dial-react-file-manager';
+import { DialFileManagerTabs } from '@epam/ai-dial-react-file-manager';
+import { DialFileNodeType } from '@epam/ai-dial-react-file-manager';
+import { DialUploadFileItem } from '@epam/ai-dial-react-file-manager';
+import { FC } from 'react';
+import { FileManagerColumnKey } from '@epam/ai-dial-react-file-manager';
+import { FileManagerGridRow } from '@epam/ai-dial-react-file-manager';
+import { ReactNode } from 'react';
+import { ToolbarOptions } from '@epam/ai-dial-react-file-manager';
+
+/** Result returned by the file-manager attach modal when the user confirms a selection. */
+declare interface AttachResult {
+    /** Selected files (individual items, not folders). */
+    files: DialFile[];
+    /** Virtual paths of selected folders. */
+    folderPaths: string[];
+}
+
+/** Options for the conflict-resolution popup shown during copy/move operations. */
+declare type ConflictResolutionPopupOptions = NonNullable<DialFileManagerComponentProps['conflictResolutionPopupOptions']>;
+
+/**
+ * Gates which actions `useDialFileManager` exposes per tab. `Attach` excludes
+ * Copy/Move/Duplicate (it is a file picker, not a management surface); `Browse`
+ * exposes the full #7503 action set. `Full` is reserved for
+ * `DialFileManagerVariant.FolderPicker` (#7503+).
+ */
+declare enum DialFileManagerActionProfile {
+    Attach = "attach",
+    Browse = "browse",
+    Full = "full"
+}
+
+declare type DialFileManagerComponentProps = ComponentProps<typeof DialFileManager>;
+
+/**
+ * Renders the DialFileManager grid/tree/toolbar and its operation overlays
+ * from a `FileManagerController`. Does not own popup chrome, an attach footer,
+ * or any attach-only selection constraints — those are host-owned.
+ */
+export declare const DialFileManagerShell: FC<DialFileManagerShellProps>;
+
+/**
+ * Pre-translated strings and resolved renderers the shell renders as-is.
+ * The shell never calls `useTranslation` — every host (the attach modal
+ * today; a future standalone page) resolves these via its own i18n.
+ */
+declare interface DialFileManagerShellLabels {
+    /** Error message shown when the current folder listing fails. */
+    errorMessage: string;
+    /** Label for the retry button shown alongside the error message. */
+    retryLabel: string;
+    /** Label for the hidden-files toggle in the toolbar. */
+    hiddenFilesLabel: string;
+    /** Label shown when hidden files are currently visible. */
+    showHiddenFilesLabel: string;
+    /** Label shown when hidden files are currently hidden. */
+    hideHiddenFilesLabel: string;
+    /** Returns a bulk-selection count label (e.g. "3 selected"). */
+    getSelectionLabel: (count: number) => string;
+    /** Label for the "Upload files" action in the New menu. */
+    uploadFilesLabel: string;
+    /** Label for the "Upload archive" action in the New menu. */
+    uploadArchiveAction: string;
+    /** Label for the "New folder" action in the New menu. */
+    newFolderLabel: string;
+    /** Label for the Download action. */
+    downloadLabel: string;
+    /** Overlay label shown while a download is in progress. */
+    downloadingLabel: string;
+    /** Label for the Delete action. */
+    deleteLabel: string;
+    /** Overlay label shown while a delete operation is in progress. */
+    deletingLabel: string;
+    /** Label for the Rename action. */
+    renameLabel: string;
+    /** Overlay label shown while a rename operation is in progress. */
+    renamingLabel: string;
+    /** Label for the Copy action. */
+    copyLabel: string;
+    /** Label for the Move action. */
+    moveLabel: string;
+    /** Label for the Duplicate action. */
+    duplicateLabel: string;
+    /** Label for the "Add folder" button in the destination picker. */
+    addFolderLabel: string;
+    /** Label for the hidden-files toggle in the destination-folder picker. */
+    hiddenFilesSwitcherLabel: string;
+    /** Returns the header for the copy destination popup. */
+    getCopyHeader: (count: number, name?: string) => string;
+    /** Returns the header for the move destination popup. */
+    getMoveHeader: (count: number, name?: string) => string;
+    /** Tooltip shown on the disabled source folder in the destination picker. */
+    moveSourceDisabledTooltip: string;
+    /** Tooltip shown when a destination folder is still loading. */
+    folderPickerLoadingTooltip: string;
+    /** Empty-state title in the destination-folder picker. */
+    folderPickerEmptyStateTitle: string;
+    /** Empty-state description in the destination-folder picker. */
+    folderPickerEmptyStateDescription: string;
+    /** Overlay text shown during a copy operation. */
+    copyingLabel: string;
+    /** Overlay text shown during a move operation. */
+    movingLabel: string;
+    /** Title for the copy operation loader modal. */
+    operationLoaderCopyTitle: string;
+    /** Title for the move operation loader modal. */
+    operationLoaderMoveTitle: string;
+    /** Cancel-button label in the operation loader modal. */
+    operationLoaderCancelLabel: string;
+    /** Returns the delete confirmation dialog title for the given item names. */
+    deleteConfirmTitle: (names: string[]) => ReactNode;
+    /** Returns the delete confirmation dialog body for the given item names. */
+    deleteConfirmBody: (names: string[]) => ReactNode;
+    /** Confirm-button label in the delete confirmation dialog. */
+    deleteConfirmLabel: string;
+    /** Cancel-button label in the delete confirmation dialog. */
+    deleteCancelLabel: string;
+    /** Title for the upload progress modal. */
+    uploadProgressTitle: string;
+    /** Cancel-button label in the upload progress modal. */
+    cancelLabel: string;
+    /** Returns upload progress text (e.g. "3 of 5 uploaded"). */
+    getUploadProgressText: (done: number, total: number) => string;
+    /** Empty-state title when a search yields no results. */
+    searchEmptyStateTitle: string;
+    /** Empty-state title for an empty subfolder. */
+    folderEmptyStateTitle: string;
+    /** Tooltip explaining which symbols are forbidden in file names. */
+    forbiddenSymbolsTooltip: string;
+    /** Per-tab empty-state title and description. */
+    emptyStateByTab: Record<DialFileManagerTabs, EmptyStateCopy>;
+    /** Per-tab tree header label. */
+    treeHeaderByTab: Record<DialFileManagerTabs, string>;
+    /** Messages for inline rename validation. */
+    renameValidationMessages: RenameValidationMessages;
+    /** Options for the conflict resolution popup. */
+    conflictResolutionPopupOptions: ConflictResolutionPopupOptions;
+    /** Label for the Unshare action. */
+    unshareLabel: string;
+    /** Overlay label shown while an unshare operation is in progress. */
+    unsharingLabel: string;
+    /** Label for the Remove Access action. */
+    removeAccessLabel: string;
+    /** Overlay label shown while a remove-access operation is in progress. */
+    removingAccessLabel: string;
+    /** Label for the Info action. */
+    infoLabel: string;
+    /** Header for the metadata popup. */
+    metadataHeader: string;
+    /** Label for the file name in the metadata popup. */
+    metadataNameLabel: string;
+    /** Label for the file path in the metadata popup. */
+    metadataPathLabel: string;
+    /** Label for the modified date in the metadata popup. */
+    metadataModifiedDateLabel: string;
+    /** Label for the file size in the metadata popup. */
+    metadataSizeLabel: string;
+    /** Label for the author in the metadata popup. */
+    metadataAuthorLabel: string;
+}
+
+/** Props for the shared file-manager shell component. */
+export declare interface DialFileManagerShellProps {
+    /** Structural view contract containing all controller state and callbacks. */
+    controller: FileManagerController;
+    /** Pre-translated labels the shell renders as-is. */
+    labels: DialFileManagerShellLabels;
+    /** Currently active tab. */
+    activeTab: DialFileManagerTabs;
+    /** Tab configuration for the toolbar. */
+    tabs: ToolbarOptions['tabs'];
+    /** Called when the user switches tabs. */
+    onTabChange: (tab: DialFileManagerTabs) => void;
+    /** Set of currently selected file/folder virtual paths. */
+    selectedPaths: Set<string>;
+    /** Called when the selection changes. */
+    onSelectedPathsChange: (paths: Set<string>) => void;
+    /** Host driving this shell instance — gates the upload-archive toolbar entry (standalone-only). */
+    variant: DialFileManagerVariant;
+    /** Action-set gate for the upload-archive toolbar entry (Full-only). */
+    actionProfile: DialFileManagerActionProfile;
+    /** Whether to auto-select items after upload completes. Defaults to `false`. */
+    autoSelectUploadedItems?: boolean;
+    /** MIME type filters for selectable files. */
+    allowedFileTypes?: DialFileAcceptType[];
+    /** Maximum file size in bytes for selectable files. */
+    maxSelectableFileSize?: number;
+    /** Custom row-selectability predicate, forwarded to the grid's row selection. */
+    isRowSelectable?: (node: {
+        data?: FileManagerSelectableNode | null;
+    }) => boolean;
+    /** Returns a tooltip for disabled rows, or undefined for enabled rows. */
+    getDisabledTooltip?: (row: FileManagerGridRow) => string | undefined;
+    /** Tooltip shown on files with an unsupported type. */
+    unsupportedFileTypeTooltip?: string;
+}
+
+/**
+ * Identifies which host is driving `useDialFileManager` / `DialFileManagerShell`.
+ * `FolderPicker` is a reserved value with no implemented UI yet (#7503+).
+ */
+declare enum DialFileManagerVariant {
+    Attach = "attach",
+    Standalone = "standalone",
+    FolderPicker = "folder-picker"
+}
+
+/** Title and description pair for an empty-state display. */
+declare interface EmptyStateCopy {
+    /** Primary empty-state heading. */
+    title: string;
+    /** Secondary empty-state description text. */
+    description: string;
+}
+
+/** File-manager modal with Popup chrome and an Attach footer. Selection and tab state are controlled by the host. */
+export declare const FileManagerAttachModal: FC<FileManagerAttachModalProps>;
+
+/**
+ * Labels for `FileManagerAttachModal`. Extends the shell labels with
+ * attach-specific strings.
+ *
+ * Declared here rather than beside the component so a host can type its label
+ * object from this package's root entry without reaching the `./file-manager`
+ * entry, which is the one that pulls in the grid.
+ */
+declare interface FileManagerAttachModalLabels extends DialFileManagerShellLabels {
+    /** Title displayed in the Popup header. */
+    title: string;
+    /** Label for the primary Attach button. */
+    attachLabel: string;
+    /** Optional subtitle shown below the title (e.g. allowed types / size). Pass `null` to hide. */
+    headerDescription?: string | null;
+}
+
+/** Props accepted by `FileManagerAttachModal`. */
+export declare interface FileManagerAttachModalProps {
+    /** Whether the modal is open. */
+    isOpen: boolean;
+    /** Called when the modal requests to be closed. */
+    onClose: () => void;
+    /** Called with the confirmed selection when the user presses Attach. */
+    onAttach: (result: AttachResult) => void;
+    /** Called when one or more selected files were filtered out due to an unsupported type. */
+    onSkippedUnsupportedFiles?: () => void;
+    /** Called when the total attachment count would exceed the limit. */
+    onCountLimitExceeded?: (totalCount: number, limit: number) => void;
+    /** Live file-manager state driving the grid. */
+    controller: FileManagerController;
+    /**
+     * True while any mutating operation is in progress (upload, delete, rename, etc.).
+     * Disables the Attach button alongside `isLoading`.
+     */
+    isAnyOperationInProgress: boolean;
+    /** Currently active tab. */
+    activeTab: DialFileManagerTabs;
+    /** Tab configuration for the toolbar. */
+    tabs: ToolbarOptions['tabs'];
+    /**
+     * Called when the user switches tabs.
+     * The host is responsible for resetting `selectedPaths` to an empty set.
+     */
+    onTabChange: (tab: DialFileManagerTabs) => void;
+    /** All user-visible strings. */
+    labels: FileManagerAttachModalLabels;
+    /** File-manager variant (controls which toolbar entries are shown). */
+    variant: DialFileManagerVariant;
+    /** Action profile controlling toolbar entry visibility. */
+    actionProfile: DialFileManagerActionProfile;
+    /**
+     * Current set of selected virtual paths, managed by the host.
+     * The host must reset this to an empty set when the active tab changes.
+     */
+    selectedPaths: Set<string>;
+    /** Called when the user changes the grid selection. */
+    onSelectedPathsChange: (paths: Set<string>) => void;
+    /**
+     * Resolves a folder `DialFile` to its DIAL Core path string for inclusion in
+     * `AttachResult.folderPaths`. Return `null` to skip the folder.
+     * Path normalization and bucket resolution are the host's responsibility.
+     */
+    resolveFolderPath: (file: DialFile) => string | null;
+    /**
+     * Returns `false` for file content-types that must be filtered out on attach.
+     * When absent, all content types are accepted.
+     */
+    isFileTypeAllowed?: (contentType: string) => boolean;
+    /** Maximum size in bytes a selectable file may have. */
+    maxSelectableFileSize?: number;
+    /** Maximum total attachments (already-attached plus newly selected). */
+    maximumAttachmentsAmount?: number;
+    /** Count of attachments already present before this modal opens. Defaults to `0`. */
+    existingAttachmentsAmount?: number;
+    /**
+     * Row selectability predicate forwarded to the grid and re-applied to every
+     * selection change, so items that were not clicked manually (e.g. the file
+     * manager's auto-select of newly created items) cannot enter selection
+     * unless manually selectable. Paths resolving to no listed node are dropped.
+     * When absent, selection changes are forwarded unfiltered.
+     */
+    isRowSelectable?: (node: {
+        data?: FileManagerSelectableNode | null;
+    }) => boolean;
+    /** Returns a tooltip for disabled rows; forwarded to the grid. */
+    getDisabledTooltip?: (row: FileManagerGridRow) => string | undefined;
+    /** Tooltip shown on files with an unsupported type; forwarded to the grid. */
+    unsupportedFileTypeTooltip?: string;
+    /** Accepted file types for the upload file input. */
+    allowedFileTypes?: DialFileAcceptType[];
+    /** Whether to auto-select items immediately after upload. Defaults to `false`. */
+    autoSelectUploadedItems?: boolean;
+}
+
+/**
+ * Structural view contract consumed by `DialFileManagerShell`. Contains exactly
+ * the fields of `UseDialFileManagerResult` that the shell reads, with the same
+ * names and types. Tabs, active tab, selection, destination-picker options, and
+ * host integration callbacks are explicit component props outside this contract.
+ *
+ * A `UseDialFileManagerResult` value is structurally assignable to this
+ * interface without a cast or adapter object.
+ */
+declare interface FileManagerController {
+    /** Hierarchical items for DialFileManager's `items` prop. */
+    items: DialFile[];
+    /** True while the current folder is loading. */
+    isLoading: boolean;
+    /** Non-null when the last fetch failed. */
+    error: string | null;
+    /** Current path in DialFileManager format (e.g. `"/My files"`, `"/My files/reports/"`). */
+    path: string;
+    /** Pass directly to DialFileManager's `onPathChange`. */
+    onPathChange: (nextPath?: string) => void;
+    /** Re-runs the fetch for the current `folderPath`. */
+    retry: () => void;
+    /** Search: called by DialFileManager when the user types in the search box. */
+    onSearchFiles: (folder: string, query: string) => void;
+    /** Search: true while a search request is in flight. */
+    isSearching: boolean;
+    /** Search: flat list of matching files, or null when search is not active. */
+    searchResults: DialFile[] | null;
+    /** Search: clears results and exits search mode. */
+    clearSearchResults: () => void;
+    /** Tree: controlled set of expanded folder virtual paths. */
+    expandedPaths: Set<string>;
+    /** Tree: virtual paths whose children are already in the cache (derived). */
+    loadedPaths: Set<string>;
+    /** Tree: called by DialFileManager when a folder is expanded/collapsed. */
+    onExpandedPathsChange: (paths: Set<string>) => void;
+    /** Destination folder popup: preloads the browsed folder without changing the outer grid path. */
+    onFolderPopupPathChange: (nextPath?: string) => void;
+    /** Destination folder popup: normalized virtual paths currently being preloaded. */
+    folderPopupLoadingPaths: Set<string>;
+    /** Upload: start a new batch. */
+    onUploadFiles: (files: DialUploadFileItem[], destinationFolder: string) => void;
+    /** Upload: extracts and uploads a ZIP archive's entries to the destination folder. */
+    onUploadArchive: (file: File, name: string, destinationFolder: string) => void;
+    /** Upload: validate file names before upload (called by DialFileManager). */
+    onValidateUpload: (files: DialUploadFileItem[], existingFiles: DialFile[], destinationFolder: string) => Promise<FileUploadValidationResult>;
+    /** Upload: current batch state (null when idle). */
+    uploadBatchState: FileUploadBatchState | null;
+    /** Upload: abort all in-flight and queued uploads. */
+    cancelUpload: () => void;
+    /** Upload: dismiss the progress modal after the batch has settled. */
+    clearUploadBatch: () => void;
+    /** Folder creation: called when user confirms a new folder name. */
+    onCreateFolder: (file: DialUploadFileItem, folderPath: string, fileId: string) => Promise<void>;
+    /** Folder creation: inline synchronous validation (returns error message or null). */
+    onCreateFolderValidate: (name: string, parentFolder: DialFile) => string | null;
+    /** Download: called when user triggers download on one or more items. */
+    onDownloadFiles: (dialFiles: DialFile[]) => void;
+    /** True while a download is in progress. */
+    isDownloading: boolean;
+    /** Delete: called when user confirms deletion of one or more items. */
+    onDeleteFiles: (items: DialDeletedItem[], sourceFolder: string) => void;
+    /** True while a delete request is in flight. */
+    isDeleting: boolean;
+    /** Rename: inline validation — returns error string or null. */
+    onRenameValidate: (value: string, item: DialFile) => string | null;
+    /** Rename: called when user confirms an inline rename. Also dispatches cross-folder move (see D3). */
+    onMoveToFiles: (items: DialCopiedItem[], sourceFolder: string, destinationFolder: string) => void;
+    /** True while a rename request is in flight. */
+    isRenaming: boolean;
+    /** Copy: called when user confirms a copy-paste. */
+    onCopyFiles: (items: DialCopiedItem[], destinationFolder: string) => void;
+    /** True while a copy request is in flight. */
+    isCopying: boolean;
+    /** True while the cross-folder-move branch of onMoveToFiles is in flight. */
+    isMoving: boolean;
+    /** Aborts whichever of copy/move is currently in flight. */
+    cancelCopyMove: () => void;
+    /** True when the current folder grants WRITE (upload + new folder). */
+    uploadEnabled: boolean;
+    /** True when Upload/New must be disabled. */
+    isNewButtonDisabled: boolean;
+    /** Tooltip for disabled New/Upload when `isNewButtonDisabled` is true. */
+    disabledNewButtonTooltip: string;
+    /** Columns to show in the grid — tab-dependent. */
+    visibleColumns: FileManagerColumnKey[];
+    /** BCP-47 locale string for date formatting, sourced from i18n.language. */
+    dateLocale: string;
+    /** Fixed date format options for the UpdatedAt column. */
+    dateOptions: Intl.DateTimeFormatOptions;
+    /** Action labels for grid/tree/bulk — Delete present only on my_files tab. */
+    actionLabels: Partial<Record<DialFileManagerActions, string>>;
+    /** Root-level shared item paths, populated only on the Shared tab. */
+    sharedWithMeIds: string[] | undefined;
+    /** Share: paths the user has shared with others, populated only on my_files tab. */
+    sharedByMePaths: Set<string>;
+    /** Unshare: called when user removes a shared-with-me item (Shared tab only). */
+    onUnshareFiles: (files: DialFile[]) => void;
+    /** True while an unshare request is in flight. */
+    isUnsharing: boolean;
+    /** Remove access: called when user revokes access to an owned shared item (my_files tab only). */
+    onRemoveFilesAccess: (files: DialFile[]) => void;
+    /** True while a remove-access request is in flight. */
+    isRemovingAccess: boolean;
+    /** Metadata: populated once onGetInfo resolves; passed to fileMetadataPopupOptions.fileMetadata. */
+    fileMetadata: DialFile | undefined;
+    /** True while a metadata request is in flight. */
+    isFileMetadataLoading: boolean;
+    /** Metadata: called by DialFileManager.onGetInfo to fetch and display a file's details. */
+    onGetInfo: (file: DialFile) => void;
+    /** Metadata: resets fileMetadata/isFileMetadataLoading; passed to fileMetadataPopupOptions.clearMetadata. */
+    clearMetadata: () => void;
+}
+
+/**
+ * Minimal node shape file-manager selection predicates are evaluated against.
+ * Satisfied by both grid rows and `DialFile` controller items, so one
+ * predicate can gate manual grid clicks and programmatic selection changes.
+ */
+declare interface FileManagerSelectableNode {
+    /** Virtual path of the node. */
+    path: string;
+    /** Distinguishes folders from files. */
+    nodeType: DialFileNodeType;
+    /** MIME type of a file node, when known. */
+    contentType?: string;
+    /** Size in bytes of a file node, when known. */
+    contentLength?: number;
+}
+
+/** State of an in-progress or just-settled upload batch, as returned by `useDialFileUploadBatch`. */
+declare interface FileUploadBatchState {
+    /** Individual file entries in this batch. */
+    files: FileUploadEntry[];
+    /** Whether the upload progress modal should be visible. */
+    isOpen: boolean;
+}
+
+/** Progress state for a single file within an upload batch. */
+declare interface FileUploadEntry {
+    /** Unique identifier of the file in the batch. */
+    id: string;
+    /** Display name of the file. */
+    name: string;
+    /** Current upload lifecycle status. */
+    status: FileUploadStatus;
+    /** 0–100 while uploading when the transport reports byte progress. */
+    percent?: number;
+}
+
+/** Lifecycle status of a single file within an upload batch. */
+declare enum FileUploadStatus {
+    Queued = "queued",
+    Uploading = "uploading",
+    Completed = "completed",
+    Failed = "failed",
+    Cancelled = "cancelled"
+}
+
+/** Result of validating files before upload. */
+declare interface FileUploadValidationResult {
+    /** Whether the files passed validation. */
+    valid: boolean;
+    /** Human-readable validation error message when `valid` is false. */
+    message?: string;
+}
+
+/** Validation messages shown during inline rename editing. */
+declare type RenameValidationMessages = NonNullable<DialFileManagerComponentProps['renameValidationMessages']>;
+
+export { }

package/file-manager.js

@@ -0,0 +1,3 @@
+import { DialFileManagerShell as e } from "./file-manager/DialFileManagerShell/DialFileManagerShell.js";
+import { FileManagerAttachModal as t } from "./file-manager/FileManagerAttachModal/FileManagerAttachModal.js";
+export { e as DialFileManagerShell, t as FileManagerAttachModal };

package/hooks/useAvailableHeightCap.js

@@ -0,0 +1,36 @@
+import { RESIZABLE_FIELD_MAX_HEIGHT_CSS_VARIABLE as e } from "../constants/resizable-fields.js";
+import { useCallback as t, useLayoutEffect as n, useRef as r } from "react";
+//#region src/hooks/useAvailableHeightCap.ts
+var i = 16, a = 200, o = new Set([
+	"auto",
+	"scroll",
+	"overlay"
+]), s = (e) => {
+	for (let t = e.parentElement; t; t = t.parentElement) {
+		let { overflowY: e } = getComputedStyle(t);
+		if (o.has(e)) return t;
+	}
+	return document.documentElement;
+}, c = ({ bottomGap: o = i, minHeight: c = a, cssVariable: l = e } = {}) => {
+	let u = r(null), d = t(() => {
+		let e = u.current;
+		if (!e) return;
+		let t = s(e), n = t === document.documentElement, r = e.getBoundingClientRect().top, i = n ? r + t.scrollTop : r - t.getBoundingClientRect().top + t.scrollTop, a = t.clientHeight - i - o, d = `${Math.round(Math.max(a, c))}px`;
+		e.style.getPropertyValue(l) !== d && e.style.setProperty(l, d);
+	}, [
+		o,
+		c,
+		l
+	]);
+	return n(() => {
+		d();
+		let e = u.current;
+		if (!e) return;
+		let t = typeof ResizeObserver > "u" ? void 0 : new ResizeObserver(d);
+		return t?.observe(s(e)), e.addEventListener("pointerdown", d, !0), window.addEventListener("resize", d), () => {
+			t?.disconnect(), e.removeEventListener("pointerdown", d, !0), window.removeEventListener("resize", d);
+		};
+	}, [d]), u;
+};
+//#endregion
+export { c as useAvailableHeightCap };

package/hooks/useCodeCopy.js

@@ -0,0 +1,20 @@
+import { copyToClipboard as e } from "../utils/copy-to-clipboard.js";
+import { useCallback as t, useEffect as n, useRef as r, useState as i } from "react";
+//#region src/hooks/useCodeCopy.ts
+var a = 2e3, o = (o, s = a) => {
+	let [c, l] = i(!1), u = r(null);
+	return n(() => () => {
+		u.current != null && clearTimeout(u.current);
+	}, []), {
+		isCopied: c,
+		copy: t(() => {
+			e(o).then((e) => {
+				e && (u.current != null && clearTimeout(u.current), l(!0), u.current = setTimeout(() => {
+					l(!1);
+				}, s));
+			});
+		}, [o, s])
+	};
+};
+//#endregion
+export { o as useCodeCopy };

package/hooks/useCollapsedText.js

@@ -0,0 +1,38 @@
+import { useCallback as e, useEffect as t, useState as n } from "react";
+//#region src/hooks/useCollapsedText.ts
+var r = 24, i = 1, a = ({ text: a, collapsedLineCount: o }) => {
+	let s = Math.max(1, o), [c, l] = n(null), [u, d] = n(!0), [f, p] = n(!1), [m, h] = n(r * s), [g, _] = n(0), v = e((e) => {
+		l(e);
+	}, []), y = e(() => {
+		if (!c) return;
+		let e = window.getComputedStyle(c), t = Number.parseFloat(e.fontSize), n = Number.isNaN(t) ? 16 : t, r = Number.parseFloat(e.lineHeight), a = n * 1.5;
+		e.lineHeight !== "normal" && !Number.isNaN(r) && (a = e.lineHeight.endsWith("px") ? r : r * n);
+		let o = a * s;
+		h(o), _(c.scrollHeight), p(c.scrollHeight - o > i);
+	}, [c, s]);
+	t(() => {
+		d(!0);
+	}, [s, a]), t(() => {
+		if (y(), !c || typeof ResizeObserver > "u") return;
+		let e = new ResizeObserver(y);
+		return e.observe(c), () => e.disconnect();
+	}, [
+		y,
+		c,
+		a
+	]);
+	let b = e(() => {
+		d((e) => !e);
+	}, []);
+	return {
+		textRef: v,
+		isTextCollapsed: u && f,
+		isOverflowing: f,
+		collapsedMaxHeight: m,
+		expandedMaxHeight: g,
+		isCollapsed: u,
+		toggleCollapsed: b
+	};
+};
+//#endregion
+export { a as useCollapsedText };

package/hooks/useHorizontalOverflow.js

@@ -0,0 +1,25 @@
+import { useCallback as e, useLayoutEffect as t, useRef as n, useState as r } from "react";
+//#region src/hooks/useHorizontalOverflow.ts
+var i = 1, a = () => {
+	let a = n(null), o = n(null), [s, c] = r(!1), [l, u] = r(!1), d = e(() => {
+		let e = a.current, t = o.current;
+		if (!e || !t) return;
+		let n = e.scrollWidth - e.clientWidth > i, r = e.getBoundingClientRect(), s = t.getBoundingClientRect(), l = getComputedStyle(e).direction === "rtl", d = l ? s.right > r.right + i : s.left < r.left - i, f = l ? s.left < r.left - i : s.right > r.right + i;
+		c(n && d), u(n && f);
+	}, []);
+	return t(() => {
+		d();
+		let e = a.current, t = o.current;
+		if (!e || !t || typeof ResizeObserver > "u") return;
+		let n = new ResizeObserver(d);
+		return n.observe(e), n.observe(t), () => n.disconnect();
+	}, [d]), {
+		scrollContainerRef: a,
+		contentRef: o,
+		hasContentBeyondStart: s,
+		hasContentBeyondEnd: l,
+		handleScroll: d
+	};
+};
+//#endregion
+export { a as useHorizontalOverflow };