@tutti-os/workspace-file-manager 0.0.1

package/dist/fileKinds-MpDaZhVB.d.ts

@@ -0,0 +1,392 @@
+import { a as WorkspaceFileManagerI18nRuntime } from './index-6L2biT8M.js';
+
+type WorkspaceFileManagerHostActionMessageStatus = "cancelled" | "completed" | "started";
+interface WorkspaceFileManagerHostActionMessage {
+    actionKind: "export" | "import";
+    entry?: WorkspaceFileEntry | null;
+    message: string;
+    status: WorkspaceFileManagerHostActionMessageStatus;
+}
+interface WorkspaceFileManagerHostImportResult {
+    cancelledMessage?: string | null;
+    completedMessage?: string | null;
+    startedMessage?: string | null;
+    summary?: WorkspaceFileImportSummary | null;
+    message?: string | null;
+    supported: boolean;
+    title?: string | null;
+    importConflict?: WorkspaceFileManagerHostImportConflict | null;
+}
+interface WorkspaceFileManagerHostExportResult {
+    cancelledMessage?: string | null;
+    completedMessage?: string | null;
+    message?: string | null;
+    startedMessage?: string | null;
+    supported: boolean;
+    title?: string | null;
+    importConflict?: null;
+}
+type WorkspaceFileManagerHostActionResult = WorkspaceFileManagerHostExportResult | WorkspaceFileManagerHostImportResult;
+interface WorkspaceFileManagerHostImportConflict {
+    conflicts: WorkspaceFileImportConflict[];
+    summary?: WorkspaceFileImportSummary | null;
+    onConfirm?: () => Promise<WorkspaceFileManagerHostImportResult | void>;
+}
+interface WorkspaceFileManagerFileActivationRequest {
+    entry: WorkspaceFileEntry;
+    target: WorkspaceFileActivationTarget | null;
+}
+type WorkspaceFileManagerHostFallbackActionKind = "download" | "none" | "open";
+type WorkspaceFileManagerHostFallbackAction = {
+    kind: "download" | "open";
+    label?: string | null;
+    onSelect: () => Promise<WorkspaceFileManagerHostFileActivationResult | void>;
+} | {
+    kind: "none";
+    label?: string | null;
+};
+type WorkspaceFileManagerHostFileActivationResult = {
+    disposition: "handled";
+} | {
+    actions?: WorkspaceFileManagerHostFallbackAction[] | null;
+    disposition: "fallback" | "unsupported";
+    message?: string | null;
+    title?: string | null;
+};
+
+type WorkspaceFileEntryKind = "file" | "directory" | "unknown";
+type WorkspaceFileSearchMatchTarget = "basename" | "path";
+type WorkspaceFileImportConflictKind = "replaceable" | "type_mismatch";
+type WorkspaceFilePreviewKind = "image" | "text";
+declare const workspaceFileManagerPersistedStateSchemaVersion: 2;
+interface WorkspaceFileEntry {
+    hasChildren: boolean;
+    kind: WorkspaceFileEntryKind;
+    mtimeMs: number | null;
+    name: string;
+    path: string;
+    sizeBytes: number | null;
+}
+interface WorkspaceFileActivationTarget {
+    fileKind: WorkspaceFilePreviewKind;
+    mtimeMs: number | null;
+    name: string;
+    path: string;
+    sizeBytes: number | null;
+}
+type WorkspaceFilePreviewState = {
+    status: "empty";
+} | {
+    entry: WorkspaceFileEntry;
+    status: "directory";
+} | {
+    entry: WorkspaceFileActivationTarget;
+    status: "loading";
+} | {
+    content: string;
+    entry: WorkspaceFileActivationTarget;
+    status: "text";
+} | {
+    entry: WorkspaceFileActivationTarget;
+    objectUrl: string;
+    status: "image";
+} | {
+    entry: WorkspaceFileEntry;
+    message: string;
+    status: "unsupported";
+} | {
+    entry: WorkspaceFileEntry;
+    message: string;
+    status: "readonly";
+} | {
+    entry: WorkspaceFileEntry;
+    message: string;
+    status: "error";
+};
+interface WorkspaceFileDirectoryListing {
+    directoryPath: string;
+    entries: WorkspaceFileEntry[];
+    root: string;
+    workspaceID: string;
+}
+interface WorkspaceFileSearchEntry {
+    directoryPath: string;
+    kind: WorkspaceFileEntryKind;
+    matchIndices: number[];
+    matchTarget: WorkspaceFileSearchMatchTarget;
+    name: string;
+    path: string;
+    score: number;
+}
+interface WorkspaceFileSearchResult {
+    entries: WorkspaceFileSearchEntry[];
+    root: string;
+    workspaceID: string;
+}
+interface WorkspaceFileImportConflict {
+    conflictKind: WorkspaceFileImportConflictKind;
+    destinationKind: WorkspaceFileEntryKind;
+    destinationPath: string;
+    name: string;
+    sourcePath: string;
+}
+type WorkspaceFileImportSummaryReason = "ignored" | "symlink" | "system_metadata";
+interface WorkspaceFileImportSummaryReasonCount {
+    count: number;
+    reason: WorkspaceFileImportSummaryReason;
+}
+interface WorkspaceFileImportSummary {
+    filteredCount?: number;
+    ignoredCount?: number;
+    reasonBreakdown?: WorkspaceFileImportSummaryReasonCount[];
+    selectedCount?: number;
+}
+interface WorkspaceFileManagerPersistedState {
+    currentDirectoryPath: string;
+    navigationBackStack: string[];
+    navigationForwardStack: string[];
+    schemaVersion: typeof workspaceFileManagerPersistedStateSchemaVersion;
+}
+interface WorkspaceFileSearchInput {
+    includeKinds?: Extract<WorkspaceFileEntryKind, "file" | "directory">[];
+    limit?: number;
+    query: string;
+}
+interface WorkspaceFileOpenWithApplication {
+    applicationPath: string;
+    iconDataUrl?: string | null;
+    name: string;
+}
+interface WorkspaceFileManagerCapabilities {
+    canCopy: boolean;
+    canCreateDirectory: boolean;
+    canCreateFile: boolean;
+    canDelete: boolean;
+    canExport: boolean;
+    canImportFromDrop: boolean;
+    canImportFromPicker: boolean;
+    canMove: boolean;
+    canOpenInAppBrowser: boolean;
+    canOpenInDefaultBrowser: boolean;
+    canOpenWith: boolean;
+    canPickOtherOpenWithApplication: boolean;
+    canRevealInFolder: boolean;
+    canRename: boolean;
+    canSearch: boolean;
+}
+type WorkspaceFileManagerBusyAction = "create" | "delete" | "export" | "import" | "move" | "rename" | "view";
+interface WorkspaceFileManagerCreateDialogState {
+    errorMessage: string | null;
+    kind: "directory" | "file";
+    name: string;
+}
+type WorkspaceFileManagerInlineRenameValidation = "invalid" | "required";
+interface WorkspaceFileManagerDeleteDialogState {
+    entryPath: string;
+}
+interface WorkspaceFileManagerContextMenuState {
+    entryPath: string | null;
+    x: number;
+    y: number;
+}
+interface WorkspaceFileManagerUnsupportedDialogState {
+    actions?: WorkspaceFileManagerHostFallbackAction[] | null;
+    entryPath?: string | null;
+    kind: "import" | "view";
+    message?: string | null;
+    title?: string | null;
+}
+interface WorkspaceFileManagerState {
+    busyAction: WorkspaceFileManagerBusyAction | null;
+    capabilities: WorkspaceFileManagerCapabilities;
+    contextMenu: WorkspaceFileManagerContextMenuState | null;
+    contextMenuEntryPath: string | null;
+    createDialog: WorkspaceFileManagerCreateDialogState | null;
+    currentDirectoryPath: string;
+    deleteDialog: WorkspaceFileManagerDeleteDialogState | null;
+    inlineRenameEntryPath: string | null;
+    inlineRenameValidation: WorkspaceFileManagerInlineRenameValidation | null;
+    dragDepth: number;
+    entries: WorkspaceFileEntry[];
+    error: string | null;
+    isLoading: boolean;
+    isMutating: boolean;
+    isSearching: boolean;
+    navigationBackStack: string[];
+    navigationForwardStack: string[];
+    pendingDirectoryPath: string | null;
+    previewState: WorkspaceFilePreviewState;
+    root: string;
+    searchEntries: WorkspaceFileSearchEntry[];
+    searchError: string | null;
+    searchQuery: string;
+    selectedPath: string | null;
+    unsupportedDialog: WorkspaceFileManagerUnsupportedDialogState | null;
+    importConflictDialog: WorkspaceFileManagerHostImportConflict | null;
+    workspaceID: string;
+}
+
+interface WorkspaceFileManagerMutationErrorMessage {
+    actionKind: "create" | "delete" | "move" | "rename";
+    error: unknown;
+    message: string;
+}
+interface WorkspaceFileManagerHost {
+    listDirectory(input: {
+        includeHidden?: boolean;
+        path: string;
+        workspaceID: string;
+    }): Promise<WorkspaceFileDirectoryListing>;
+    search?(input: WorkspaceFileSearchInput & {
+        workspaceID: string;
+    }): Promise<WorkspaceFileSearchResult>;
+    createDirectory?(input: {
+        path: string;
+        workspaceID: string;
+    }): Promise<WorkspaceFileEntry>;
+    createFile?(input: {
+        path: string;
+        workspaceID: string;
+    }): Promise<WorkspaceFileEntry>;
+    deleteEntry?(input: {
+        kind?: Extract<WorkspaceFileEntryKind, "file" | "directory"> | null;
+        path: string;
+        workspaceID: string;
+    }): Promise<void>;
+    moveEntry?(input: {
+        kind: Extract<WorkspaceFileEntryKind, "file" | "directory">;
+        path: string;
+        targetDirectoryPath: string;
+        workspaceID: string;
+    }): Promise<WorkspaceFileEntry>;
+    renameEntry?(input: {
+        path: string;
+        newName: string;
+        workspaceID: string;
+    }): Promise<WorkspaceFileEntry>;
+    copyEntriesToClipboard?(input: {
+        paths: string[];
+        workspaceID: string;
+    }): Promise<void>;
+    listOpenWithApplications?(input: {
+        path: string;
+        workspaceID: string;
+    }): Promise<WorkspaceFileOpenWithApplication[]>;
+    openFileWithApplication?(input: {
+        applicationPath: string;
+        path: string;
+        workspaceID: string;
+    }): Promise<void>;
+    openFileWithOtherApplication?(input: {
+        applicationPickerPrompt?: string;
+        path: string;
+        workspaceID: string;
+    }): Promise<void>;
+    openFileInAppBrowser?(input: {
+        path: string;
+        workspaceID: string;
+    }): Promise<void>;
+    openFileInDefaultBrowser?(input: {
+        path: string;
+        workspaceID: string;
+    }): Promise<void>;
+    revealEntry?(input: {
+        path: string;
+        workspaceID: string;
+    }): Promise<void>;
+    activateFile?(request: WorkspaceFileManagerFileActivationRequest, workspaceID: string): Promise<WorkspaceFileManagerHostFileActivationResult>;
+    exportEntry?(input: {
+        entry: WorkspaceFileEntry;
+        workspaceID: string;
+    }): Promise<WorkspaceFileManagerHostExportResult>;
+    readPreviewFile?(workspaceID: string, path: string): Promise<Uint8Array | ArrayBuffer>;
+    resolveErrorMessage?(error: unknown, overrides?: Record<string, string>): string;
+    resolveDroppedPaths?(dataTransfer: Pick<DataTransfer, "files" | "items">): string[];
+    importFiles?(workspaceID: string, targetDirectoryPath: string): Promise<WorkspaceFileManagerHostActionResult>;
+    importPaths?(workspaceID: string, targetDirectoryPath: string, sourcePaths: string[]): Promise<WorkspaceFileManagerHostActionResult>;
+}
+interface CreateWorkspaceFileManagerSessionInput {
+    i18n: WorkspaceFileManagerI18nRuntime;
+    host: WorkspaceFileManagerHost;
+    initialDirectoryPath?: string;
+    onHostActionMessage?: (message: WorkspaceFileManagerHostActionMessage) => void;
+    onMutationErrorMessage?: (message: WorkspaceFileManagerMutationErrorMessage) => boolean | void;
+    persistedState?: WorkspaceFileManagerPersistedState | null;
+    persistence?: {
+        load?(): WorkspaceFileManagerPersistedState | null | undefined;
+        save(state: WorkspaceFileManagerPersistedState): void;
+    };
+    workspaceID: string;
+}
+
+interface WorkspaceFileManagerCommands {
+    applyRevealIntent(intent: {
+        path: string;
+        requestID: string;
+    } | null): Promise<void>;
+    closeContextMenu(): void;
+    closeCreateDialog(): void;
+    closeDeleteDialog(): void;
+    cancelInlineRename(): void;
+    closeTransientUi(): void;
+    closeUnsupportedDialog(): void;
+    closeImportConflictDialog(): void;
+    confirmCreateDialog(): Promise<void>;
+    confirmDeleteDialog(): Promise<void>;
+    clearInlineRenameValidation(): void;
+    confirmInlineRename(newName: string): Promise<boolean>;
+    copyToClipboard(entry: WorkspaceFileEntry): Promise<void>;
+    confirmImportConflict(): Promise<void>;
+    createDirectory(path: string): Promise<void>;
+    createFile(path: string): Promise<void>;
+    deleteSelected(): Promise<void>;
+    decrementDragDepth(): void;
+    goBack(): Promise<void>;
+    goForward(): Promise<void>;
+    getPersistedState(): WorkspaceFileManagerPersistedState;
+    handleActivationFallbackAction(action: WorkspaceFileManagerHostFallbackAction): Promise<void>;
+    incrementDragDepth(): void;
+    initialize(): Promise<void>;
+    loadDirectory(path?: string): Promise<void>;
+    openContextMenu(input: WorkspaceFileManagerContextMenuState): void;
+    openCreateDirectoryDialog(): void;
+    openCreateFileDialog(): void;
+    openDeleteDialog(entry: WorkspaceFileEntry): void;
+    startInlineRename(entry: WorkspaceFileEntry): void;
+    getCachedOpenWithApplications(entry: WorkspaceFileEntry): WorkspaceFileOpenWithApplication[] | null;
+    listOpenWithApplications(entry: WorkspaceFileEntry): Promise<WorkspaceFileOpenWithApplication[]>;
+    openEntry(entry: WorkspaceFileEntry): Promise<void>;
+    openFileWithApplication(entry: WorkspaceFileEntry, applicationPath: string): Promise<void>;
+    openFileInAppBrowser(entry: WorkspaceFileEntry): Promise<void>;
+    openFileInDefaultBrowser(entry: WorkspaceFileEntry): Promise<void>;
+    openFileWithOtherApplication(entry: WorkspaceFileEntry): Promise<void>;
+    revealEntry(entry: WorkspaceFileEntry): Promise<void>;
+    exportEntry(entry: WorkspaceFileEntry): Promise<WorkspaceFileManagerHostActionResult>;
+    importDroppedFiles(dataTransfer: Pick<DataTransfer, "files" | "items">, targetDirectoryPath: string): Promise<WorkspaceFileManagerHostActionResult>;
+    importFiles(targetDirectoryPath: string): Promise<WorkspaceFileManagerHostActionResult>;
+    moveEntry(entry: WorkspaceFileEntry, targetDirectoryPath: string): Promise<void>;
+    refresh(): Promise<void>;
+    revealPath(path: string): Promise<void>;
+    resetDragDepth(): void;
+    search(query: string): Promise<void>;
+    select(path: string | null): void;
+    setActive(active: boolean): void;
+    setI18nRuntime(copy: WorkspaceFileManagerI18nRuntime): void;
+    updateCreateDialogName(name: string): void;
+}
+
+interface WorkspaceFileManagerSession extends WorkspaceFileManagerCommands {
+    activateFile(request: WorkspaceFileManagerFileActivationRequest): Promise<WorkspaceFileManagerHostFileActivationResult>;
+    dispose(): void;
+    readonly store: WorkspaceFileManagerState;
+}
+interface WorkspaceFileManagerService {
+    createSession(input: CreateWorkspaceFileManagerSessionInput): WorkspaceFileManagerSession;
+}
+
+declare function createWorkspaceFileManagerService(): WorkspaceFileManagerService;
+
+declare function classifyWorkspaceFilePreviewKind(entry: WorkspaceFileEntry): WorkspaceFilePreviewKind | null;
+declare function resolveWorkspaceFileActivationTarget(entry: WorkspaceFileEntry): WorkspaceFileActivationTarget | null;
+
+export { type WorkspaceFilePreviewState as A, type WorkspaceFileSearchEntry as B, type CreateWorkspaceFileManagerSessionInput as C, type WorkspaceFileSearchResult as D, classifyWorkspaceFilePreviewKind as E, createWorkspaceFileManagerService as F, resolveWorkspaceFileActivationTarget as G, type WorkspaceFileActivationTarget as W, type WorkspaceFileDirectoryListing as a, type WorkspaceFileEntry as b, type WorkspaceFileEntryKind as c, type WorkspaceFileImportConflict as d, type WorkspaceFileImportSummary as e, type WorkspaceFileImportSummaryReason as f, type WorkspaceFileImportSummaryReasonCount as g, type WorkspaceFileManagerCapabilities as h, type WorkspaceFileManagerFileActivationRequest as i, type WorkspaceFileManagerHost as j, type WorkspaceFileManagerHostActionMessage as k, type WorkspaceFileManagerHostActionMessageStatus as l, type WorkspaceFileManagerHostActionResult as m, type WorkspaceFileManagerHostExportResult as n, type WorkspaceFileManagerHostFallbackAction as o, type WorkspaceFileManagerHostFallbackActionKind as p, type WorkspaceFileManagerHostFileActivationResult as q, type WorkspaceFileManagerHostImportConflict as r, type WorkspaceFileManagerHostImportResult as s, type WorkspaceFileManagerMutationErrorMessage as t, type WorkspaceFileManagerPersistedState as u, type WorkspaceFileManagerService as v, type WorkspaceFileManagerSession as w, type WorkspaceFileManagerState as x, type WorkspaceFileOpenWithApplication as y, type WorkspaceFilePreviewKind as z };

package/dist/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { W as WorkspaceFileManagerI18nKey, a as WorkspaceFileManagerI18nRuntime, c as createWorkspaceFileManagerI18nRuntime, w as workspaceFileManagerI18nNamespace, b as workspaceFileManagerI18nResources } from '../index-6L2biT8M.js';
+import '@tutti-os/ui-i18n-runtime';

package/dist/i18n/index.js

@@ -0,0 +1,11 @@
+import {
+  createWorkspaceFileManagerI18nRuntime,
+  workspaceFileManagerI18nNamespace,
+  workspaceFileManagerI18nResources
+} from "../chunk-2AG4ND4D.js";
+export {
+  createWorkspaceFileManagerI18nRuntime,
+  workspaceFileManagerI18nNamespace,
+  workspaceFileManagerI18nResources
+};
+//# sourceMappingURL=index.js.map

package/dist/i18n/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index-6L2biT8M.d.ts

@@ -0,0 +1,90 @@
+import { I18nRuntime, I18nDictionary } from '@tutti-os/ui-i18n-runtime';
+
+type WorkspaceFileManagerI18nLocale = "en" | "zh-CN";
+declare const workspaceFileManagerI18nNamespace = "workspaceFileManager";
+declare const workspaceFileManagerEn: {
+    readonly backLabel: "Back";
+    readonly breadcrumbRootLabel: "workspace";
+    readonly cancelLabel: "Cancel";
+    readonly closeLabel: "Close";
+    readonly copyLabel: "Copy";
+    readonly copyPathLabel: "Copy path";
+    readonly copyPathSuccessTitle: "Path copied";
+    readonly copySuccessTitle: "Copied to clipboard";
+    readonly createActionLabel: "Create";
+    readonly createDirectoryLabel: "New folder";
+    readonly createDirectoryPlaceholder: "Folder name";
+    readonly createFileLabel: "New file";
+    readonly createFilePlaceholder: "File name";
+    readonly createNameInvalid: "Use a valid name without path separators";
+    readonly createNameRequired: "Enter a name to continue";
+    readonly deleteConfirmDescription: "Delete {{name}} from this workspace?";
+    readonly deleteLabel: "Delete";
+    readonly deletingLabel: "Deleting...";
+    readonly downloadFailedTitle: "Download failed";
+    readonly downloadLabel: "Download";
+    readonly dropToImportLabel: "Drop files here to import to the current folder";
+    readonly emptyDirectory: "No visible files in this folder";
+    readonly forwardLabel: "Forward";
+    readonly loading: "Loading";
+    readonly modifiedLabel: "Modified";
+    readonly nameLabel: "Name";
+    readonly noSearchResults: "No files matched your search";
+    readonly openFailedTitle: "Open failed";
+    readonly openLabel: "Open";
+    readonly openInAppBrowserLabel: "Nextop built-in browser";
+    readonly openInDefaultBrowserLabel: "Default Browser";
+    readonly openWithLabel: "Open With";
+    readonly openWithLoadingLabel: "Loading apps...";
+    readonly openWithOtherLabel: "Other...";
+    readonly openWithOtherPickerPrompt: "Choose an application to open this file:";
+    readonly revealInFileExplorerLabel: "Reveal in File Explorer";
+    readonly revealInFileManagerLabel: "Reveal in File Manager";
+    readonly revealInFinderLabel: "Reveal in Finder";
+    readonly unknownErrorMessage: "Something went wrong. Please try again.";
+    readonly previewBinary: "This file looks binary, so the preview stays read-only for now.";
+    readonly previewDecodeFailed: "We couldn't decode this file as UTF-8 text for preview.";
+    readonly previewDirectoryLabel: "Folder";
+    readonly previewEmptyLabel: "Select a file or folder to view details";
+    readonly previewFileTooLarge: "This file is larger than {{maxSize}}, so inline preview is disabled.";
+    readonly previewLoadingLabel: "Loading preview...";
+    readonly previewTooLarge: "This text file is larger than {{maxSize}}, so inline preview is disabled.";
+    readonly previewUnavailableDownloadBody: "Download {{name}} to open it in another environment.";
+    readonly previewUnavailableOpenBody: "Open {{name}} in your local app instead.";
+    readonly previewUnavailableTitle: "Can't preview this file";
+    readonly previewUnsupported: "Inline preview isn't available for this file type yet.";
+    readonly revealFailedTitle: "Could not reveal in file manager";
+    readonly renameActionLabel: "Rename";
+    readonly renameLabel: "Rename";
+    readonly renamePlaceholder: "New name";
+    readonly refreshLabel: "Refresh";
+    readonly retryLabel: "Retry";
+    readonly searchPlaceholder: "Search files";
+    readonly searchResultsLabel: "Search results";
+    readonly sizeLabel: "Size";
+    readonly unsupportedImportBody: "Importing local files into the workspace is not wired up in this desktop build yet.";
+    readonly unsupportedImportTitle: "Import not available yet";
+    readonly unsupportedViewBody: "Opening {{name}} from the file manager is not supported in this desktop build yet.";
+    readonly unsupportedViewTitle: "Open not available yet";
+    readonly importConflictDescription: "{{count}} file from this import already exists in this folder tree. Replace it?";
+    readonly importConflictReplaceLabel: "Replace files";
+    readonly importConflictReviewLabel: "Existing path";
+    readonly importConflictSummaryFiltered: "Filtered: {{count}}";
+    readonly importConflictSummaryIgnored: "Ignored: {{count}}";
+    readonly importConflictSummaryReasonIgnored: "Ignored by rules: {{count}}";
+    readonly importConflictSummaryReasonSymlink: "Skipped symlinks: {{count}}";
+    readonly importConflictSummaryReasonSystemMetadata: "Skipped system metadata: {{count}}";
+    readonly importConflictSummarySelected: "Selected: {{count}}";
+    readonly importConflictTitle: "Replace existing file?";
+    readonly importFailedTitle: "Import failed";
+    readonly importLabel: "Import";
+    readonly importTypeConflictDescription: "{{count}} import path conflicts with an existing file or folder using an incompatible type. Resolve it before retrying.";
+    readonly importTypeConflictTitle: "Import path conflict";
+};
+type WorkspaceFileManagerI18nKey = keyof typeof workspaceFileManagerEn;
+type WorkspaceFileManagerI18nRuntime = I18nRuntime<WorkspaceFileManagerI18nKey>;
+declare const workspaceFileManagerI18nResources: Record<WorkspaceFileManagerI18nLocale, I18nDictionary>;
+declare function createWorkspaceFileManagerI18nRuntime(runtime: I18nRuntime<string>): WorkspaceFileManagerI18nRuntime;
+declare function resolveRevealInFolderLabel(copy: WorkspaceFileManagerI18nRuntime, platform: NodeJS.Platform): string;
+
+export { type WorkspaceFileManagerI18nKey as W, type WorkspaceFileManagerI18nRuntime as a, workspaceFileManagerI18nResources as b, createWorkspaceFileManagerI18nRuntime as c, resolveRevealInFolderLabel as r, workspaceFileManagerI18nNamespace as w };

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { y as WorkspaceFileOpenWithApplication, b as WorkspaceFileEntry, w as WorkspaceFileManagerSession } from './fileKinds-MpDaZhVB.js';
+export { C as CreateWorkspaceFileManagerSessionInput, W as WorkspaceFileActivationTarget, a as WorkspaceFileDirectoryListing, c as WorkspaceFileEntryKind, d as WorkspaceFileImportConflict, e as WorkspaceFileImportSummary, f as WorkspaceFileImportSummaryReason, g as WorkspaceFileImportSummaryReasonCount, h as WorkspaceFileManagerCapabilities, i as WorkspaceFileManagerFileActivationRequest, j as WorkspaceFileManagerHost, k as WorkspaceFileManagerHostActionMessage, l as WorkspaceFileManagerHostActionMessageStatus, m as WorkspaceFileManagerHostActionResult, n as WorkspaceFileManagerHostExportResult, o as WorkspaceFileManagerHostFallbackAction, p as WorkspaceFileManagerHostFallbackActionKind, q as WorkspaceFileManagerHostFileActivationResult, r as WorkspaceFileManagerHostImportConflict, s as WorkspaceFileManagerHostImportResult, t as WorkspaceFileManagerMutationErrorMessage, u as WorkspaceFileManagerPersistedState, v as WorkspaceFileManagerService, x as WorkspaceFileManagerState, z as WorkspaceFilePreviewKind, A as WorkspaceFilePreviewState, B as WorkspaceFileSearchEntry, D as WorkspaceFileSearchResult, E as classifyWorkspaceFilePreviewKind, F as createWorkspaceFileManagerService, G as resolveWorkspaceFileActivationTarget } from './fileKinds-MpDaZhVB.js';
+import { a as WorkspaceFileManagerI18nRuntime } from './index-6L2biT8M.js';
+export { W as WorkspaceFileManagerI18nKey, c as createWorkspaceFileManagerI18nRuntime, w as workspaceFileManagerI18nNamespace, b as workspaceFileManagerI18nResources } from './index-6L2biT8M.js';
+import { ReactElement } from 'react';
+import { NextopDateLocale } from '@tutti-os/ui-system/date-format';
+export { decodeWorkspaceTextFile, isWorkspaceTextFileTooLarge, looksLikeBinaryText, resolveWorkspaceFileExtension, resolveWorkspaceImageMimeType, workspaceFilePreviewMaxBytes, workspaceFileTextMaxBytes } from '@tutti-os/workspace-file-preview';
+import '@tutti-os/ui-i18n-runtime';
+
+type WorkspaceFileManagerEntryDragMode = "external" | "internal-move";
+
+interface WorkspaceFileManagerProps {
+    className?: string;
+    dateLocale?: NextopDateLocale;
+    entryDragMode?: WorkspaceFileManagerEntryDragMode;
+    openInAppBrowserIcon?: ReactElement;
+    resolveOpenWithApplicationIcon?: (application: WorkspaceFileOpenWithApplication) => ReactElement | null;
+    onCopyEntry?: () => Promise<void> | void;
+    onCopyPath?: (path: string) => Promise<void> | void;
+    onDirectoryExpanded?: (path: string) => void;
+    onEntryDragStart?: (entry: WorkspaceFileEntry, dataTransfer: DataTransfer) => void;
+    hostOs?: NodeJS.Platform;
+    i18n: WorkspaceFileManagerI18nRuntime;
+    session: WorkspaceFileManagerSession;
+    surface?: "card" | "embedded";
+}
+declare function WorkspaceFileManager({ className, dateLocale, entryDragMode, i18n, onCopyEntry, onCopyPath, onDirectoryExpanded, onEntryDragStart, openInAppBrowserIcon, resolveOpenWithApplicationIcon, hostOs, session, surface }: WorkspaceFileManagerProps): ReactElement;
+
+export { WorkspaceFileEntry, WorkspaceFileManager, type WorkspaceFileManagerEntryDragMode, WorkspaceFileManagerI18nRuntime, type WorkspaceFileManagerProps, WorkspaceFileManagerSession };