From 0dc0bbeb03073ad485a07fcaf4d5e408b7667287 Mon Sep 17 00:00:00 2001 From: Yiling-J Date: Thu, 5 Nov 2026 09:57:34 +0800 Subject: [PATCH] feat(file-browser): add context-aware copy submenu (#517) * feat(file-browser): add context-aware copy submenu * refactor(file-browser): address code review feedback for copy submenu * fix(webui): align submenu trigger text and widen file context menu * test(e2e): guard clipboard permissions in copy-menu spec for cross-browser support --- CHANGELOG.md | 2 + apps/web/e2e/README.md | 1 + apps/web/e2e/tests/project/copy-menu.spec.ts | 43 +++ packages/api/src/file.test.ts | 122 +++++++ packages/api/src/file.ts | 33 ++ packages/core/src/asset/asset.test.ts | 247 +++++++++++++- packages/core/src/asset/asset.ts | 139 +++++++- packages/core/src/s3/archive-storage.ts | 11 + packages/core/src/s3/s3.ts | 9 + packages/dtos/src/asset.ts | 19 ++ .../file-browser/context-menu.test.tsx | 15 + .../components/file-browser/context-menu.tsx | 57 ++-- .../file-browser/copy-options.test.ts | 282 ++++++++++++++++ .../components/file-browser/copy-options.ts | 212 ++++++++++++ .../components/file-browser/copy-submenu.tsx | 234 ++++++++++++++ .../components/file-browser/file-browser.tsx | 8 +- .../file-browser/file-card.test.tsx | 30 ++ .../components/file-browser/file-card.tsx | 16 + .../components/file-browser/folder-card.tsx | 16 + .../file-browser/mobile-file-browser.test.tsx | 13 + .../file-browser/mobile-file-browser.tsx | 5 + .../file-browser/use-copy-actions.test.ts | 306 ++++++++++++++++++ .../file-browser/use-copy-actions.ts | 223 +++++++++++++ .../file-browser/use-file-actions.ts | 42 +-- packages/webui/components/ui/context-menu.tsx | 2 +- .../components/viewers/image/image-viewer.tsx | 44 +-- packages/webui/lib/clipboard.test.ts | 92 +++++- packages/webui/lib/clipboard.ts | 116 +++++++ packages/webui/messages/en.json | 26 ++ packages/webui/messages/zh.json | 26 ++ 30 files changed, 2285 insertions(+), 106 deletions(-) create mode 100644 apps/web/e2e/tests/project/copy-menu.spec.ts create mode 100644 packages/webui/components/file-browser/copy-options.test.ts create mode 100644 packages/webui/components/file-browser/copy-options.ts create mode 100644 packages/webui/components/file-browser/copy-submenu.tsx create mode 100644 packages/webui/components/file-browser/use-copy-actions.test.ts create mode 100644 packages/webui/components/file-browser/use-copy-actions.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index f61208f5..406b63ca 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). ### Changed +- **file-browser**: Replace the legacy combined "Copy name and download link" action with a context-aware Copy submenu in file browser context menus and card action dropdowns, enabling users to copy image, asset names, in-app links, download links, IDs, Markdown links and storage paths(team-owner only) + ## [0.6.3] - 2026-11-01 ### Added diff --git a/apps/web/e2e/README.md b/apps/web/e2e/README.md index 178aae2e..89481c26 100644 --- a/apps/web/e2e/README.md +++ b/apps/web/e2e/README.md @@ -99,6 +99,7 @@ apps/web/e2e/ | Video share with watermark + download disabled: no download buttons on public list/detail pages, watermarked proxy served, download-url rejected | `tests/project/share-watermark-no-download.spec.ts` | | Owner views a file and it appears in recents | `tests/project/recents.spec.ts` | | Owner archives a file to archive storage and restores it back to main storage | `tests/project/archive-restore.spec.ts` | +| Owner opens Copy submenu in context menu and copies file name | `tests/project/copy-menu.spec.ts` | ### file | Test | File | diff --git a/apps/web/e2e/tests/project/copy-menu.spec.ts b/apps/web/e2e/tests/project/copy-menu.spec.ts new file mode 100644 index 00000000..076217f4 --- /dev/null +++ b/apps/web/e2e/tests/project/copy-menu.spec.ts @@ -0,0 +1,43 @@ +import { expect, test } from '../../fixtures' +import { fileCard } from '../../helpers/files' + +test('owner sees Copy submenu in context menu and copies file name', async ({ + file, + browserName, +}) => { + const { page, projectId, fileName } = file + + if (browserName === 'chromium') { + await page.context().grantPermissions(['clipboard-read', 'clipboard-write']) + } + await page.goto(`/projects/${projectId}`) + await expect(fileCard(page, fileName)).toBeVisible() + + // Right-click context menu + await fileCard(page, fileName).click({ button: 'right' }) + const copySubTrigger = page.getByRole('menuitem', { name: /^Copy$|^复制$/i }) + await expect(copySubTrigger).toBeVisible() + await copySubTrigger.click() + + // Verify submenu items are visible + await expect(page.getByRole('menuitem', { name: /^Name$|^名称$/i })).toBeVisible() + await expect(page.getByRole('menuitem', { name: /^Link$|^链接$/i })).toBeVisible() + await expect(page.getByRole('menuitem', { name: /^Download link$|^下载链接$/i })).toBeVisible() + await expect(page.getByRole('menuitem', { name: /^ID$/i })).toBeVisible() + await expect( + page.getByRole('menuitem', { name: /^Markdown link$|^Markdown 链接$/i }), + ).toBeVisible() + await expect(page.getByRole('menuitem', { name: /^Storage path$|^存储路径$/i })).toBeVisible() + + // Click "Name" + await page.getByRole('menuitem', { name: /^Name$|^名称$/i }).click() + const toast = page.locator('[data-sonner-toast]').filter({ + hasText: /Copied name to clipboard|已复制名称到剪贴板/i, + }) + await expect(toast).toBeVisible() + + if (browserName === 'chromium') { + const clipboardText = await page.evaluate(() => navigator.clipboard.readText()) + expect(clipboardText).toBe(fileName) + } +}) diff --git a/packages/api/src/file.test.ts b/packages/api/src/file.test.ts index 05fb5dad..f6e2cd08 100644 --- a/packages/api/src/file.test.ts +++ b/packages/api/src/file.test.ts @@ -3,6 +3,7 @@ import { Hono, type Context, type Next } from 'hono' import { HTTPException } from 'hono/http-exception' import fileRoute from './file' import { assetService } from '@shumai/core/src/asset/asset' +import { projectService } from '@shumai/core/src/project/project' import { metadataService } from '@shumai/core/src/metadata/metadata' import { notificationService } from '@shumai/core/src/notification/notification' import { s3Service } from '@shumai/core/src/s3/s3' @@ -871,6 +872,127 @@ describe('file api', () => { mockGetProjectIds.mockRestore() }) + describe('POST /files/storage-paths', () => { + it('returns empty paths if ids are empty', async () => { + const app = new Hono().use('*', authMiddleware).route('/', fileRoute) + const res = await app.request('/files/storage-paths', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ ids: [] }), + }) + + expect(res.status).toBe(200) + const json = await res.json() + expect(json).toEqual({ paths: [] }) + }) + + it('rejects if assets belong to multiple projects', async () => { + const mockGetProjectIds = vi + .spyOn(assetService, 'getProjectIds') + .mockResolvedValue(['proj-1', 'proj-2']) + + const app = new Hono().use('*', authMiddleware).route('/', fileRoute) + const res = await app.request('/files/storage-paths', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ ids: ['asset-1', 'asset-2'] }), + }) + + expect(res.status).toBe(400) + const json = await res.json() + expect(json.error).toBe('All selected items must belong to the same project') + + mockGetProjectIds.mockRestore() + }) + + it('denies access if user is not a team owner (admin)', async () => { + const mockGetProjectIds = vi + .spyOn(assetService, 'getProjectIds') + .mockResolvedValue(['proj-1']) + const mockGetProjectTeam = vi + .spyOn(projectService, 'getProjectTeam') + .mockResolvedValue('team-1') + vi.mocked(authzService.hasPermission).mockRejectedValueOnce( + new HTTPException(403, { message: 'Permission denied' }), + ) + + const app = new Hono().use('*', authMiddleware).route('/', fileRoute) + const res = await app.request('/files/storage-paths', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ ids: ['asset-1'] }), + }) + + expect(res.status).toBe(403) + expect(authzService.hasPermission).toHaveBeenCalledWith({ + user: { id: 'user1', name: 'Test User' }, + permission: Permission.Admin, + type: ResourceType.Team, + id: 'team-1', + }) + + mockGetProjectIds.mockRestore() + mockGetProjectTeam.mockRestore() + }) + + it('returns storage paths if user has team admin permission', async () => { + const mockGetProjectIds = vi + .spyOn(assetService, 'getProjectIds') + .mockResolvedValue(['proj-1']) + const mockGetProjectTeam = vi + .spyOn(projectService, 'getProjectTeam') + .mockResolvedValue('team-1') + const mockGetStoragePaths = vi.spyOn(assetService, 'getStoragePaths').mockResolvedValue({ + paths: [ + { + id: 'asset-1', + name: 'clip.mp4', + path: 's3://shumai/files/1/clip.mp4', + backend: 's3', + isArchived: false, + }, + ], + }) + + const app = new Hono().use('*', authMiddleware).route('/', fileRoute) + const res = await app.request('/files/storage-paths', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ ids: ['asset-1'] }), + }) + + expect(res.status).toBe(200) + const json = await res.json() + expect(json.paths).toHaveLength(1) + expect(json.paths[0].name).toBe('clip.mp4') + expect(json.paths[0].path).toBe('s3://shumai/files/1/clip.mp4') + + expect(authzService.hasPermission).toHaveBeenCalledWith({ + user: { id: 'user1', name: 'Test User' }, + permission: Permission.Admin, + type: ResourceType.Team, + id: 'team-1', + }) + expect(assetService.getStoragePaths).toHaveBeenCalledWith(['asset-1']) + + mockGetProjectIds.mockRestore() + mockGetProjectTeam.mockRestore() + mockGetStoragePaths.mockRestore() + }) + + it('rejects if more than 100 ids are provided', async () => { + const app = new Hono().use('*', authMiddleware).route('/', fileRoute) + const ids = Array.from({ length: 101 }, (_, i) => `asset-${i}`) + const res = await app.request('/files/storage-paths', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ ids }), + }) + + expect(res.status).toBe(400) + }) + }) + describe('GET /files/:fileId/m3u8 routes', () => { it('returns master playlist with correct content-type', async () => { const mockMaster = vi diff --git a/packages/api/src/file.ts b/packages/api/src/file.ts index 76c6e84b..a1cb26f3 100644 --- a/packages/api/src/file.ts +++ b/packages/api/src/file.ts @@ -1,5 +1,6 @@ import { zValidator } from '@hono/zod-validator' import { assetService } from '@shumai/core/src/asset/asset' +import { projectService } from '@shumai/core/src/project/project' import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz' import { commentService } from '@shumai/core/src/comment/comment' import { s3Service } from '@shumai/core/src/s3/s3' @@ -26,6 +27,7 @@ import { updateFileRequestSchema, uploadFileRequestSchema, getDownloadLinksRequestSchema, + getStoragePathsRequestSchema, completeCommentRequestSchema, exportCommentsRequestSchema, addCommentReactionRequestSchema, @@ -456,6 +458,37 @@ const route = new Hono<{ Variables: { user: User } }>() ...(skippedArchivedCount > 0 ? { skippedArchivedCount } : {}), }) }) + .post('/files/storage-paths', zValidator('json', getStoragePathsRequestSchema), async (c) => { + const user = c.get('user') + const req = c.req.valid('json') + + if (req.ids.length === 0) { + return c.json({ paths: [] }) + } + + const projectIds = await assetService.getProjectIds(req.ids) + if (projectIds.length === 0) { + return c.json({ paths: [] }) + } + + if (projectIds.length !== 1) { + return c.json({ error: 'All selected items must belong to the same project' }, 400) + } + + const projectId = projectIds[0] + const teamId = await projectService.getProjectTeam(projectId) + + // Verify user has Admin (owner) permission on the team + await authzService.hasPermission({ + user, + permission: Permission.Admin, + type: ResourceType.Team, + id: teamId, + }) + + const result = await assetService.getStoragePaths(req.ids) + return c.json(result) + }) .post( '/files/download-url', zValidator('json', z.object({ key: z.string().min(1), assetId: z.string().min(1) })), diff --git a/packages/core/src/asset/asset.test.ts b/packages/core/src/asset/asset.test.ts index bfbd9716..1aeca14c 100644 --- a/packages/core/src/asset/asset.test.ts +++ b/packages/core/src/asset/asset.test.ts @@ -4,7 +4,8 @@ import { setupTestDbHooks } from '@shumai/db/test' import { HTTPException } from 'hono/http-exception' import { AssetType, AssetStatus, Prisma, WorkflowTaskType, WorkflowTaskStatus } from '@shumai/db' -import { s3Service } from '@shumai/core/src/s3/s3' +import { s3Service, getStorageBackend } from '@shumai/core/src/s3/s3' +import * as archiveStorageModule from '@shumai/core/src/s3/archive-storage' import { uploadService } from '@shumai/core/src/upload/upload' import { metadataService } from '@shumai/core/src/metadata/metadata' import { AssetService } from './asset' @@ -20,7 +21,9 @@ vi.mock('@shumai/core/src/s3/s3', () => ({ deleteObject: vi.fn().mockResolvedValue(1), deletePrefix: vi.fn().mockResolvedValue(1), copyObject: vi.fn().mockResolvedValue(undefined), + getStoragePath: vi.fn((bucket: string, key: string) => `/mock/data/${bucket}/${key}`), }, + getStorageBackend: vi.fn().mockReturnValue('local'), })) vi.mock('@shumai/core/src/s3/preview-converter', async (importOriginal) => { @@ -3076,6 +3079,248 @@ describe('AssetService — natural sort by name', () => { }) }) + describe('getStoragePaths', () => { + it('returns empty array for empty inputs', async () => { + const result = await assetService.getStoragePaths([]) + expect(result).toEqual({ paths: [] }) + }) + + it('resolves files, symlinks, and version stacks while skipping folders', async () => { + const user = await prisma.user.create({ + data: { + name: 'StoragePathUser', + email: `storage-path-${Date.now()}@example.com`, + }, + }) + const team = await prisma.team.create({ data: { name: 'StoragePathTeam' } }) + const project = await prisma.project.create({ + data: { name: 'StoragePathProject', teamId: team.id }, + }) + + const folder = await prisma.asset.create({ + data: { + name: 'MyFolder', + type: AssetType.folder, + project: { connect: { id: project.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.processed, + }, + }) + + const file = await prisma.asset.create({ + data: { + name: 'clip.mp4', + type: AssetType.file, + project: { connect: { id: project.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.processed, + storageKey: { create: { key: 'files/ulid1/clip.mp4' } }, + }, + }) + + const symlink = await prisma.asset.create({ + data: { + name: 'clip-symlink', + type: AssetType.symlink, + project: { connect: { id: project.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.uploaded, + target: { connect: { id: file.id } }, + }, + }) + + const stack = await prisma.asset.create({ + data: { + name: 'stack.png', + type: AssetType.version_stack, + project: { connect: { id: project.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.processed, + }, + }) + + await prisma.asset.create({ + data: { + name: 'stack_v1.png', + type: AssetType.file, + project: { connect: { id: project.id } }, + parent: { connect: { id: stack.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.processed, + sortIndex: 'b', + storageKey: { create: { key: 'files/ulid2/stack_v1.png' } }, + }, + }) + + const latestChild = await prisma.asset.create({ + data: { + name: 'stack_v2.png', + type: AssetType.file, + project: { connect: { id: project.id } }, + parent: { connect: { id: stack.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.processed, + sortIndex: 'a', + storageKey: { create: { key: 'files/ulid3/stack_v2.png' } }, + }, + }) + + const result = await assetService.getStoragePaths([folder.id, file.id, symlink.id, stack.id]) + + // folder should be skipped, symlink deduplicated to file, stack resolved to latest child + expect(result.paths).toHaveLength(2) + const names = result.paths.map((p) => p.name) + expect(names).toContain('clip.mp4') + expect(names).toContain('stack_v2.png') + + const clipPath = result.paths.find((p) => p.name === 'clip.mp4')! + expect(clipPath.path).toContain('files/ulid1/clip.mp4') + expect(clipPath.isArchived).toBe(false) + + const stackPath = result.paths.find((p) => p.name === 'stack_v2.png')! + expect(stackPath.id).toBe(latestChild.id) + expect(stackPath.path).toContain('files/ulid3/stack_v2.png') + }) + + it('returns S3 path when main storage backend is s3', async () => { + vi.mocked(getStorageBackend).mockReturnValueOnce('s3') + vi.mocked(s3Service.getStoragePath).mockReturnValueOnce('s3://shumai/files/test/s3-file.mp4') + + const project = await prisma.project.create({ + data: { name: 'P-S3', team: { create: { name: 'T-S3' } } }, + }) + const user = await prisma.user.create({ + data: { name: 'U-S3', email: `s3-${Date.now()}@example.com` }, + }) + const file = await prisma.asset.create({ + data: { + name: 's3-file.mp4', + type: AssetType.file, + project: { connect: { id: project.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.processed, + storageKey: { create: { key: 'files/test/s3-file.mp4' } }, + }, + }) + + const res = await assetService.getStoragePaths([file.id]) + expect(res.paths).toEqual([ + { + id: file.id, + name: 's3-file.mp4', + path: 's3://shumai/files/test/s3-file.mp4', + backend: 's3', + isArchived: false, + }, + ]) + }) + + it('returns archive S3 path when asset is archived and archive backend is s3', async () => { + vi.spyOn(archiveStorageModule, 'getArchiveStoragePath').mockReturnValueOnce({ + path: 's3://my-archive-bucket/files/archived/clip.mp4', + backend: 's3', + }) + + const project = await prisma.project.create({ + data: { name: 'P-Archive-S3', team: { create: { name: 'T-Archive-S3' } } }, + }) + const user = await prisma.user.create({ + data: { name: 'U-Arch', email: `arch-${Date.now()}@example.com` }, + }) + const file = await prisma.asset.create({ + data: { + name: 'clip.mp4', + type: AssetType.file, + project: { connect: { id: project.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.archived, + storageKey: { create: { key: 'files/archived/clip.mp4', isArchived: true } }, + }, + }) + + const res = await assetService.getStoragePaths([file.id]) + expect(res.paths).toEqual([ + { + id: file.id, + name: 'clip.mp4', + path: 's3://my-archive-bucket/files/archived/clip.mp4', + backend: 's3', + isArchived: true, + }, + ]) + }) + + it('returns archive local path when asset is archived and archive backend is local', async () => { + vi.spyOn(archiveStorageModule, 'getArchiveStoragePath').mockReturnValueOnce({ + path: '/mnt/archive/files/archived/clip.mp4', + backend: 'local', + }) + + const project = await prisma.project.create({ + data: { name: 'P-Archive-Local', team: { create: { name: 'T-Archive-Local' } } }, + }) + const user = await prisma.user.create({ + data: { name: 'U-ArchLocal', email: `archloc-${Date.now()}@example.com` }, + }) + const file = await prisma.asset.create({ + data: { + name: 'clip.mp4', + type: AssetType.file, + project: { connect: { id: project.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.archived, + storageKey: { create: { key: 'files/archived/clip.mp4', isArchived: true } }, + }, + }) + + const res = await assetService.getStoragePaths([file.id]) + expect(res.paths).toEqual([ + { + id: file.id, + name: 'clip.mp4', + path: '/mnt/archive/files/archived/clip.mp4', + backend: 'local', + isArchived: true, + }, + ]) + }) + + it('marks isArchived: true with main storage path when archive storage is disabled', async () => { + vi.spyOn(archiveStorageModule, 'getArchiveStoragePath').mockReturnValueOnce(null) + vi.mocked(s3Service.getStoragePath).mockReturnValueOnce( + '/mock/data/shumai/files/archived/clip.mp4', + ) + + const project = await prisma.project.create({ + data: { name: 'P-DisabledArchive', team: { create: { name: 'T-DisabledArchive' } } }, + }) + const user = await prisma.user.create({ + data: { name: 'U-DisArch', email: `disarch-${Date.now()}@example.com` }, + }) + const file = await prisma.asset.create({ + data: { + name: 'clip.mp4', + type: AssetType.file, + project: { connect: { id: project.id } }, + creator: { connect: { id: user.id } }, + status: AssetStatus.archived, + storageKey: { create: { key: 'files/archived/clip.mp4', isArchived: true } }, + }, + }) + + const res = await assetService.getStoragePaths([file.id]) + expect(res.paths).toEqual([ + { + id: file.id, + name: 'clip.mp4', + path: '/mock/data/shumai/files/archived/clip.mp4', + backend: 'local', + isArchived: true, + }, + ]) + }) + }) + describe('getProjectIds', () => { it('returns empty lists for empty inputs', async () => { const result = await assetService.getProjectIds([]) diff --git a/packages/core/src/asset/asset.ts b/packages/core/src/asset/asset.ts index d23773d0..45c8d600 100644 --- a/packages/core/src/asset/asset.ts +++ b/packages/core/src/asset/asset.ts @@ -23,6 +23,8 @@ import { CommentExportFormat, PreviewFormat, TRASH_RETENTION_DAYS, + GetStoragePathsResponse, + StoragePathItem, } from '@shumai/dtos' import { exportCommentsToFormat, @@ -43,10 +45,11 @@ import { import { HTTPException } from 'hono/http-exception' import { logger } from '@shumai/core/src/logger' import { PaginatedData, paginateQuery, PaginationParams } from '@shumai/core/src/pagination' -import { s3Service } from '@shumai/core/src/s3/s3' +import { s3Service, getStorageBackend } from '@shumai/core/src/s3/s3' import { getArchiveStorageService, isArchiveStorageEnabled, + getArchiveStoragePath, } from '@shumai/core/src/s3/archive-storage' import { assetArchiveService } from './asset-archive' import { @@ -1248,6 +1251,75 @@ export class AssetService { return currentId } + async resolveLatestVersionIds(assetIds: string[]): Promise { + if (assetIds.length === 0) return [] + + const initialAssets = await this.prismaClient.asset.findMany({ + where: { id: { in: assetIds }, isDeleted: false }, + select: { id: true, type: true, targetId: true }, + }) + const assetMap = new Map(initialAssets.map((a) => [a.id, a])) + + // Find symlinks to resolve + const symlinks = initialAssets.filter((a) => a.type === AssetType.symlink && a.targetId) + const targetIds = Array.from(new Set(symlinks.map((s) => s.targetId!))) + + const symlinkTargetMap = new Map() + if (targetIds.length > 0) { + const targets = await this.prismaClient.asset.findMany({ + where: { id: { in: targetIds }, isDeleted: false }, + select: { id: true, type: true }, + }) + for (const t of targets) { + symlinkTargetMap.set(t.id, t) + } + } + + // Determine current ID and type for each input ID + const intermediate = assetIds.map((id) => { + const asset = assetMap.get(id) + if (!asset) return { originalId: id, currentId: id, type: null } + if (asset.type === AssetType.symlink && asset.targetId) { + const target = symlinkTargetMap.get(asset.targetId) + if (target) { + return { originalId: id, currentId: target.id, type: target.type } + } + } + return { originalId: id, currentId: asset.id, type: asset.type } + }) + + // Find version stacks to resolve to their latest child + const versionStackIds = Array.from( + new Set( + intermediate + .filter((item) => item.type === AssetType.version_stack) + .map((item) => item.currentId), + ), + ) + + const latestChildByParent = new Map() + if (versionStackIds.length > 0) { + const children = await this.prismaClient.asset.findMany({ + where: { parentId: { in: versionStackIds }, isDeleted: false }, + select: { id: true, parentId: true, sortIndex: true }, + orderBy: { sortIndex: 'asc' }, + }) + for (const child of children) { + if (child.parentId && !latestChildByParent.has(child.parentId)) { + latestChildByParent.set(child.parentId, child.id) + } + } + } + + return intermediate.map((item) => { + if (item.type === AssetType.version_stack) { + const childId = latestChildByParent.get(item.currentId) + if (childId) return childId + } + return item.currentId + }) + } + async updateAssetName(req: UpdateAssetNameRequest): Promise { const existing = await this.prismaClient.asset.findUnique({ where: { id: req.id }, @@ -2886,6 +2958,71 @@ export class AssetService { } } + async getStoragePaths(ids: string[]): Promise { + if (ids.length === 0) return { paths: [] } + + const targetAssetIds = await this.resolveLatestVersionIds(ids) + const uniqueTargetIds = Array.from(new Set(targetAssetIds)) + + const assets = await this.prismaClient.asset.findMany({ + where: { + id: { in: uniqueTargetIds }, + isDeleted: false, + type: { + notIn: [AssetType.folder, AssetType.root, AssetType.share_root, AssetType.share], + }, + }, + select: { + id: true, + name: true, + status: true, + storageKey: { + select: { + key: true, + isArchived: true, + }, + }, + }, + }) + + const defaultBackend = getStorageBackend() + const mainBucket = process.env.S3_BUCKET || 'shumai' + const paths: StoragePathItem[] = [] + + for (const asset of assets) { + const sk = asset.storageKey + if (!sk?.key) continue + + const isArchived = + asset.status === AssetStatus.archived || + asset.status === AssetStatus.archiving || + asset.status === AssetStatus.restoring || + sk.isArchived + + const archivePathInfo = isArchived ? getArchiveStoragePath(sk.key) : null + if (archivePathInfo) { + paths.push({ + id: asset.id, + name: asset.name, + path: archivePathInfo.path, + backend: archivePathInfo.backend, + isArchived: true, + }) + } else { + const storagePath = s3Service.getStoragePath(mainBucket, sk.key) + paths.push({ + id: asset.id, + name: asset.name, + path: storagePath, + backend: defaultBackend, + isArchived, + }) + } + } + + return { paths } + } + /** * Generate a presigned download URL for a given key, verifying it belongs to the asset's * storage directory. This ensures users can only download files (original, transcodes, etc.) diff --git a/packages/core/src/s3/archive-storage.ts b/packages/core/src/s3/archive-storage.ts index 035d9362..52edc79f 100644 --- a/packages/core/src/s3/archive-storage.ts +++ b/packages/core/src/s3/archive-storage.ts @@ -303,6 +303,17 @@ export function validateArchiveStorageConfig(): ArchiveStorageConfig { return getArchiveStorageConfig() } +export function getArchiveStoragePath( + key: string, +): { path: string; backend: 's3' | 'local' } | null { + const config = getArchiveStorageConfig() + if (!config.enabled) return null + if (config.backend === 's3') { + return { path: `s3://${config.bucket}/${key}`, backend: 's3' } + } + return { path: path.join(config.localRoot, key), backend: 'local' } +} + export class LocalArchiveStorageService implements ArchiveStorageService { readonly backend = 'local' as const readonly isSameS3Target = false diff --git a/packages/core/src/s3/s3.ts b/packages/core/src/s3/s3.ts index 62e8e0a9..26783165 100644 --- a/packages/core/src/s3/s3.ts +++ b/packages/core/src/s3/s3.ts @@ -360,6 +360,7 @@ export interface S3Service { ) => Promise<{ url: string }> abortMultipartUpload: (bucket: string, key: string, uploadId: string) => Promise resolveInput: (bucket: string, key: string) => Promise + getStoragePath: (bucket: string, key: string) => string } export class S3StorageService implements S3Service { @@ -760,6 +761,10 @@ export class S3StorageService implements S3Service { async resolveInput(bucket: string, key: string): Promise { return this.presign(bucket, key, 'GET', false, undefined, true) } + + getStoragePath(bucket: string, key: string): string { + return `s3://${bucket}/${key}` + } } export class LocalStorageService implements S3Service { @@ -1049,6 +1054,10 @@ export class LocalStorageService implements S3Service { } return this.presign(bucket, key, 'GET') } + + getStoragePath(bucket: string, key: string): string { + return this.getFilePath(bucket, key) + } } export function getStorageBackend(): 's3' | 'local' { diff --git a/packages/dtos/src/asset.ts b/packages/dtos/src/asset.ts index 09564993..5277bec3 100644 --- a/packages/dtos/src/asset.ts +++ b/packages/dtos/src/asset.ts @@ -400,6 +400,25 @@ export const getDownloadLinksResponseSchema = z.object({ }) export type GetDownloadLinksResponse = z.infer +export const getStoragePathsRequestSchema = z.object({ + ids: z.array(z.string()).max(100), +}) +export type GetStoragePathsRequest = z.infer + +export const storagePathItemSchema = z.object({ + id: z.string(), + name: z.string(), + path: z.string(), + backend: z.enum(['s3', 'local']), + isArchived: z.boolean(), +}) +export type StoragePathItem = z.infer + +export const getStoragePathsResponseSchema = z.object({ + paths: z.array(storagePathItemSchema), +}) +export type GetStoragePathsResponse = z.infer + export const archiveAssetsRequestSchema = z.object({ ids: z.array(z.string().min(1)).min(1), }) diff --git a/packages/webui/components/file-browser/context-menu.test.tsx b/packages/webui/components/file-browser/context-menu.test.tsx index 6b065884..17519fad 100644 --- a/packages/webui/components/file-browser/context-menu.test.tsx +++ b/packages/webui/components/file-browser/context-menu.test.tsx @@ -80,4 +80,19 @@ describe('FileBrowserContextMenu', () => { expect(screen.queryByText(/Manage versions|管理版本/i)).toBeNull() }) + + it('renders Copy submenu trigger for regular file item with aligned gap-2 and w-52 menu width', () => { + renderWithMenu(fileItem) + + fireEvent.contextMenu(screen.getByTestId('context-trigger')) + + const copyOption = screen.getByText(/^Copy$|^复制$/i) + expect(copyOption).toBeTruthy() + + const trigger = copyOption.closest('[data-slot="context-menu-sub-trigger"]') + expect(trigger?.className).toContain('gap-2') + + const menuContent = copyOption.closest('[data-slot="context-menu-content"]') + expect(menuContent?.className).toContain('w-52') + }) }) diff --git a/packages/webui/components/file-browser/context-menu.tsx b/packages/webui/components/file-browser/context-menu.tsx index 669b5e9a..0b344d1c 100644 --- a/packages/webui/components/file-browser/context-menu.tsx +++ b/packages/webui/components/file-browser/context-menu.tsx @@ -26,6 +26,8 @@ import { Copy, Layers, } from 'lucide-react' +import { CopyContextMenuSub } from './copy-submenu' +import type { CopyKind } from './copy-options' interface FileBrowserContextMenuProps { item: AssetInfo | null @@ -33,11 +35,13 @@ interface FileBrowserContextMenuProps { onRename: (item: AssetInfo) => void onDelete: (items: AssetInfo[]) => void onDownload: (items: AssetInfo[]) => void - onCopyNameAndDownloadLink?: (items: AssetInfo[]) => void + onCopy?: (kind: CopyKind, items: AssetInfo[]) => void onRestore: (items: AssetInfo[]) => void onArchive?: (items: AssetInfo[]) => void onRestoreArchive?: (items: AssetInfo[]) => void archiveStorageEnabled?: boolean + isTeamOwner?: boolean + allowDownload?: boolean onNewFolder: (name: string) => void onUploadFile: () => void onUploadFolder: () => void @@ -64,11 +68,13 @@ export function FileBrowserContextMenu({ onRename, onDelete, onDownload, - onCopyNameAndDownloadLink, + onCopy, onRestore, onArchive, onRestoreArchive, archiveStorageEnabled = false, + isTeamOwner = false, + allowDownload = true, onNewFolder, onUploadFile, onUploadFolder, @@ -113,14 +119,6 @@ export function FileBrowserContextMenu({ } } - const handleCopyNameAndDownloadLink = () => { - if (isItemSelected) { - onCopyNameAndDownloadLink?.(selectedItems) - } else if (item) { - onCopyNameAndDownloadLink?.([item]) - } - } - const handleRestore = () => { onRestore(itemsToRestore) } @@ -162,15 +160,11 @@ export function FileBrowserContextMenu({ if (isShareView) { if (!item) return null return ( - + {m.download()} - - - {m.copy_name_and_download_link()} - {canEdit && ( onRemoveFromShare?.(itemsToModify)} @@ -189,7 +183,7 @@ export function FileBrowserContextMenu({ return null } return ( - + {m.restore()} @@ -203,6 +197,7 @@ export function FileBrowserContextMenu({ // Right-click on empty area return ( { e.preventDefault() }} @@ -230,6 +225,7 @@ export function FileBrowserContextMenu({ const contextMenuContent = isItemSelected && selectedIds.size > 1 ? ( { e.preventDefault() }} @@ -238,10 +234,14 @@ export function FileBrowserContextMenu({ {m.download()} - - - {m.copy_name_and_download_link()} - + onCopy?.(kind, targetItems)} + /> {canEdit && ( onMoveTo(itemsToModify)}> @@ -294,7 +294,7 @@ export function FileBrowserContextMenu({ {m.add_to_share_links()} - + {shareLinks.map((share) => ( ) : ( { e.preventDefault() }} @@ -330,10 +331,14 @@ export function FileBrowserContextMenu({ {m.download()} - - - {m.copy_name_and_download_link()} - + onCopy?.(kind, targetItems)} + /> {canEdit && ( onMoveTo(itemsToModify)}> @@ -409,7 +414,7 @@ export function FileBrowserContextMenu({ {m.add_to_share_links()} - + {shareLinks.map((share) => ( { + const dummyFile: AssetInfo = { + id: 'file-1', + name: 'document.pdf', + type: 'file', + status: 'processed', + sizeByte: 1024 * 1024, + fileCount: 0, + createdAt: '2026-01-01', + updatedAt: '2026-01-01', + } + + const dummyImage: AssetInfo = { + id: 'image-1', + name: 'photo.jpg', + type: 'file', + proxyType: 'image', + status: 'processed', + sizeByte: 2 * 1024 * 1024, + fileCount: 0, + createdAt: '2026-01-01', + updatedAt: '2026-01-01', + media: { + imageTranscodes: [ + { id: 't1', key: 'k1', url: 'https://cdn/1080.webp', width: 1920, height: 1080, size: 200 }, + { id: 't2', key: 'k2', url: 'https://cdn/3000.webp', width: 3000, height: 2000, size: 500 }, + ], + }, + } + + const dummyFolder: AssetInfo = { + id: 'folder-1', + name: 'Assets', + type: 'folder', + status: 'processed', + sizeByte: 0, + fileCount: 5, + createdAt: '2026-01-01', + updatedAt: '2026-01-01', + } + + const dummyVersionStack: AssetInfo = { + id: 'stack-1', + name: 'render.png', + type: 'version_stack', + proxyType: 'image', + status: 'processed', + sizeByte: 5 * 1024 * 1024, + fileCount: 0, + createdAt: '2026-01-01', + updatedAt: '2026-01-01', + versionStack: { + id: 'stack-1', + versions: [ + { version: 2, current: true, id: 'child-2' }, + { version: 1, current: false, id: 'child-1' }, + ], + }, + media: { + imageTranscodes: [ + { + id: 't1', + key: 'k1', + url: 'https://cdn/render-1080.webp', + width: 1920, + height: 1080, + size: 200, + }, + ], + }, + } + + describe('isImageItem', () => { + it('detects images by proxyType and extension', () => { + expect(isImageItem(dummyImage)).toBe(true) + expect(isImageItem({ ...dummyFile, name: 'graphic.png' })).toBe(true) + expect(isImageItem(dummyVersionStack)).toBe(true) + expect(isImageItem(dummyFile)).toBe(false) + expect(isImageItem(dummyFolder)).toBe(false) + }) + }) + + describe('pickClipboardTranscode', () => { + it('picks largest transcode <= 2048px on long edge', () => { + const transcode = pickClipboardTranscode(dummyImage.media?.imageTranscodes) + expect(transcode?.url).toBe('https://cdn/1080.webp') + }) + + it('falls back to smallest available if all > 2048px', () => { + const transcode = pickClipboardTranscode([ + { url: 'https://cdn/4000.webp', width: 4000, height: 3000 }, + { url: 'https://cdn/2500.webp', width: 2500, height: 2000 }, + ]) + expect(transcode?.url).toBe('https://cdn/2500.webp') + }) + + it('picks transcode by key even without presigned url', () => { + const transcode = pickClipboardTranscode([ + { key: 'files/asset-768p.webp', width: 768, height: 1376 }, + ]) + expect(transcode?.key).toBe('files/asset-768p.webp') + }) + + it('returns null if empty or missing', () => { + expect(pickClipboardTranscode([])).toBeNull() + expect(pickClipboardTranscode(undefined)).toBeNull() + }) + }) + + describe('getCopyOptions', () => { + it('returns options for single image file with team owner', () => { + const options = getCopyOptions([dummyImage], { isTeamOwner: true }) + const kinds = options.map((o) => o.kind) + expect(kinds).toEqual([ + 'image', + 'name', + 'link', + 'download-link', + 'id', + 'markdown', + 'storage-path', + ]) + expect(options.find((o) => o.kind === 'image')?.disabled).toBe(false) + expect(options.find((o) => o.kind === 'download-link')?.disabled).toBe(false) + }) + + it('enables image option for processed image file with only transcode key and no url', () => { + const imageWithoutUrls: AssetInfo = { + ...dummyImage, + media: { + imageTranscodes: [ + { + id: 't1', + key: 'files/asset-768p.webp', + url: '', + width: 768, + height: 1376, + size: 200, + }, + ], + }, + } + const options = getCopyOptions([imageWithoutUrls]) + expect(options.find((o) => o.kind === 'image')?.disabled).toBe(false) + }) + + it('hides image option for non-image files', () => { + const options = getCopyOptions([dummyFile], { isTeamOwner: true }) + const kinds = options.map((o) => o.kind) + expect(kinds).not.toContain('image') + expect(kinds).toContain('download-link') + expect(kinds).toContain('storage-path') + }) + + it('hides download-link and storage-path for single folder', () => { + const options = getCopyOptions([dummyFolder], { isTeamOwner: true }) + const kinds = options.map((o) => o.kind) + expect(kinds).toEqual(['name', 'link', 'id', 'markdown']) + expect(kinds).not.toContain('download-link') + expect(kinds).not.toContain('storage-path') + }) + + it('handles multi-select with only files', () => { + const options = getCopyOptions([dummyFile, dummyImage], { isTeamOwner: true }) + const kinds = options.map((o) => o.kind) + expect(kinds).toEqual([ + 'name', + 'link', + 'download-link', + 'id', + 'markdown', + 'tsv', + 'storage-path', + ]) + expect(kinds).not.toContain('image') + }) + + it('hides download-link and storage-path when all items in multi-select are folders', () => { + const folder2 = { ...dummyFolder, id: 'folder-2', name: 'Folder 2' } + const options = getCopyOptions([dummyFolder, folder2], { isTeamOwner: true }) + const kinds = options.map((o) => o.kind) + expect(kinds).toEqual(['name', 'link', 'id', 'markdown', 'tsv']) + expect(kinds).not.toContain('download-link') + expect(kinds).not.toContain('storage-path') + }) + + it('disables download-link if all files in selection are archived', () => { + const archivedFile: AssetInfo = { ...dummyFile, status: 'archived' } + const options = getCopyOptions([archivedFile]) + expect(options.find((o) => o.kind === 'download-link')?.disabled).toBe(true) + }) + + it('hides id and storage-path in public share mode', () => { + const options = getCopyOptions([dummyFile], { isPublicShare: true, isTeamOwner: true }) + const kinds = options.map((o) => o.kind) + expect(kinds).not.toContain('id') + expect(kinds).not.toContain('storage-path') + }) + }) + + describe('getItemInAppUrl', () => { + it('formats URL for file and folder', () => { + expect(getItemInAppUrl(dummyFile, 'https://shumai.app', 'proj-1')).toBe( + 'https://shumai.app/projects/proj-1/files/file-1', + ) + expect(getItemInAppUrl(dummyFolder, 'https://shumai.app', 'proj-1')).toBe( + 'https://shumai.app/projects/proj-1/folders/folder-1', + ) + expect(getItemInAppUrl(dummyVersionStack, 'https://shumai.app', 'proj-1')).toBe( + 'https://shumai.app/projects/proj-1/files/stack-1', + ) + }) + }) + + describe('formatCopyText', () => { + const ctx = { origin: 'https://shumai.app', projectId: 'proj-1' } + + it('formats name for single and multi-select', () => { + expect(formatCopyText('name', [dummyFile], ctx)).toBe('document.pdf') + expect(formatCopyText('name', [dummyFile, dummyFolder], ctx)).toBe('document.pdf\nAssets') + }) + + it('formats link for single and multi-select', () => { + expect(formatCopyText('link', [dummyFile], ctx)).toBe( + 'https://shumai.app/projects/proj-1/files/file-1', + ) + expect(formatCopyText('link', [dummyFile, dummyFolder], ctx)).toBe( + 'https://shumai.app/projects/proj-1/files/file-1\nhttps://shumai.app/projects/proj-1/folders/folder-1', + ) + }) + + it('formats id for single and multi-select', () => { + expect(formatCopyText('id', [dummyFile], ctx)).toBe('file-1') + expect(formatCopyText('id', [dummyVersionStack], ctx)).toBe('stack-1') + expect(formatCopyText('id', [dummyFile, dummyFolder], ctx)).toBe('file-1\nfolder-1') + }) + + it('formats markdown link for single and bullet list for multi-select', () => { + expect(formatCopyText('markdown', [dummyFile], ctx)).toBe( + '[document.pdf](https://shumai.app/projects/proj-1/files/file-1)', + ) + expect(formatCopyText('markdown', [dummyFile, dummyFolder], ctx)).toBe( + '- [document.pdf](https://shumai.app/projects/proj-1/files/file-1)\n- [Assets](https://shumai.app/projects/proj-1/folders/folder-1)', + ) + }) + + it('formats TSV table with header and sizes for multi-select', () => { + const tsv = formatCopyText('tsv', [dummyFile, dummyFolder], ctx) + const lines = tsv.split('\n') + expect(lines[0]).toBe('Name\tType\tSize\tLink\tID') + expect(lines[1]).toContain( + 'document.pdf\tfile\t1.05 MB\thttps://shumai.app/projects/proj-1/files/file-1\tfile-1', + ) + expect(lines[2]).toContain( + 'Assets\tfolder\t—\thttps://shumai.app/projects/proj-1/folders/folder-1\tfolder-1', + ) + }) + + it('escapes brackets in markdown links', () => { + const fileWithBrackets = { ...dummyFile, name: 'Report [Final] (v1).pdf' } + expect(formatCopyText('markdown', [fileWithBrackets], ctx)).toBe( + '[Report \\[Final\\] (v1).pdf](https://shumai.app/projects/proj-1/files/file-1)', + ) + }) + + it('sanitizes tabs and newlines in TSV file names', () => { + const fileWithTabs = { ...dummyFile, name: 'test\tfile\nname.pdf' } + const tsv = formatCopyText('tsv', [fileWithTabs], ctx) + expect(tsv).toContain('test file name.pdf\tfile\t1.05 MB') + }) + }) +}) diff --git a/packages/webui/components/file-browser/copy-options.ts b/packages/webui/components/file-browser/copy-options.ts new file mode 100644 index 00000000..e07bc806 --- /dev/null +++ b/packages/webui/components/file-browser/copy-options.ts @@ -0,0 +1,212 @@ +import type { AssetInfo } from '@shumai/dtos' +import { formatSize } from '@/ui/lib/format' + +export type CopyKind = + 'image' | 'name' | 'link' | 'download-link' | 'id' | 'markdown' | 'tsv' | 'storage-path' + +export interface CopyOption { + kind: CopyKind + disabled: boolean + hint?: string +} + +export interface CopyOptionsContext { + isPublicShare?: boolean + isTeamOwner?: boolean + allowDownload?: boolean +} + +export interface CopyFormatContext { + origin: string + projectId?: string +} + +const IMAGE_EXTENSIONS = new Set([ + 'jpg', + 'jpeg', + 'png', + 'webp', + 'gif', + 'svg', + 'bmp', + 'tiff', + 'avif', + 'heic', +]) + +export function isImageItem(item: AssetInfo): boolean { + if (item.type === 'folder' || item.type === 'root' || item.type === 'share_root') return false + if (item.proxyType === 'image') return true + const ext = item.name?.split('.').pop()?.toLowerCase() + return IMAGE_EXTENSIONS.has(ext || '') +} + +export function isArchivedStatus(status?: string | null): boolean { + return status === 'archived' || status === 'archiving' || status === 'restoring' +} + +export interface TranscodeCandidate { + url?: string + key?: string + width?: number + height?: number +} + +export function pickClipboardTranscode( + transcodes?: TranscodeCandidate[], +): TranscodeCandidate | null { + if (!transcodes || transcodes.length === 0) return null + const valid = transcodes.filter((t) => !!t.url || !!t.key) + if (valid.length === 0) return null + + // Prefer largest transcode <= 2048px on long edge + const suitable = valid.filter((t) => { + const maxDim = Math.max(t.width || 0, t.height || 0) + return maxDim <= 2048 + }) + + if (suitable.length > 0) { + suitable.sort((a, b) => { + const dimA = Math.max(a.width || 0, a.height || 0) + const dimB = Math.max(b.width || 0, b.height || 0) + return dimB - dimA + }) + return suitable[0] + } + + // Fallback to smallest available if all > 2048px + valid.sort((a, b) => { + const dimA = Math.max(a.width || 0, a.height || 0) + const dimB = Math.max(b.width || 0, b.height || 0) + return dimA - dimB + }) + return valid[0] +} + +export function getItemInAppUrl(item: AssetInfo, origin: string, projectId?: string): string { + const base = origin.replace(/\/$/, '') + if (item.type === 'folder') { + return projectId + ? `${base}/projects/${projectId}/folders/${item.id}` + : `${base}/folders/${item.id}` + } + const targetId = item.versionStack ? item.versionStack.id : item.id + return projectId ? `${base}/projects/${projectId}/files/${targetId}` : `${base}/files/${targetId}` +} + +export function getCopyOptions(items: AssetInfo[], context: CopyOptionsContext = {}): CopyOption[] { + if (items.length === 0) return [] + + const { isPublicShare = false, isTeamOwner = false, allowDownload = true } = context + + const options: CopyOption[] = [] + + if (items.length === 1) { + const item = items[0] + const isImage = isImageItem(item) + + if (isImage) { + const isArchived = isArchivedStatus(item.status) + const transcode = pickClipboardTranscode(item.media?.imageTranscodes) + const hasTranscode = + !!transcode || item.status === 'processed' || !!item.preview?.thumbnailUrl + const disabled = isArchived || !hasTranscode || (isPublicShare && !allowDownload) + options.push({ kind: 'image', disabled }) + } + + options.push({ kind: 'name', disabled: false }) + options.push({ kind: 'link', disabled: false }) + + if (item.type !== 'folder') { + const isArchived = isArchivedStatus(item.status) + const disabled = isArchived || (isPublicShare && !allowDownload) + options.push({ kind: 'download-link', disabled }) + } + + if (!isPublicShare) { + options.push({ kind: 'id', disabled: false }) + } + + options.push({ kind: 'markdown', disabled: false }) + + if (isTeamOwner && !isPublicShare && item.type !== 'folder') { + options.push({ kind: 'storage-path', disabled: false }) + } + + return options + } + + // Multi-selection + options.push({ kind: 'name', disabled: false }) + options.push({ kind: 'link', disabled: false }) + + const files = items.filter((i) => i.type !== 'folder') + if (files.length > 0) { + const allArchived = files.every((f) => isArchivedStatus(f.status)) + const disabled = allArchived || (isPublicShare && !allowDownload) + options.push({ kind: 'download-link', disabled }) + } + + if (!isPublicShare) { + options.push({ kind: 'id', disabled: false }) + } + + options.push({ kind: 'markdown', disabled: false }) + options.push({ kind: 'tsv', disabled: false }) + + if (isTeamOwner && !isPublicShare && files.length > 0) { + options.push({ kind: 'storage-path', disabled: false }) + } + + return options +} + +export function formatCopyText( + kind: CopyKind, + items: AssetInfo[], + context: CopyFormatContext, +): string { + if (items.length === 0) return '' + + switch (kind) { + case 'name': + return items.map((i) => i.name).join('\n') + + case 'link': + return items.map((i) => getItemInAppUrl(i, context.origin, context.projectId)).join('\n') + + case 'id': + return items.map((i) => (i.versionStack ? i.versionStack.id : i.id)).join('\n') + + case 'markdown': + if (items.length === 1) { + const item = items[0] + const safeName = item.name.replace(/\[/g, '\\[').replace(/\]/g, '\\]') + const url = getItemInAppUrl(item, context.origin, context.projectId) + return `[${safeName}](${url})` + } + return items + .map((i) => { + const safeName = i.name.replace(/\[/g, '\\[').replace(/\]/g, '\\]') + const url = getItemInAppUrl(i, context.origin, context.projectId) + return `- [${safeName}](${url})` + }) + .join('\n') + + case 'tsv': { + const header = 'Name\tType\tSize\tLink\tID' + const rows = items.map((i) => { + const type = i.type === 'folder' ? 'folder' : 'file' + const size = i.type === 'folder' ? '—' : formatSize(i.sizeByte || 0) + const link = getItemInAppUrl(i, context.origin, context.projectId) + const id = i.versionStack ? i.versionStack.id : i.id + const safeName = i.name.replace(/[\t\r\n]+/g, ' ') + return `${safeName}\t${type}\t${size}\t${link}\t${id}` + }) + return [header, ...rows].join('\n') + } + + default: + return '' + } +} diff --git a/packages/webui/components/file-browser/copy-submenu.tsx b/packages/webui/components/file-browser/copy-submenu.tsx new file mode 100644 index 00000000..52ac4213 --- /dev/null +++ b/packages/webui/components/file-browser/copy-submenu.tsx @@ -0,0 +1,234 @@ +import type { AssetInfo } from '@shumai/dtos' +import { m } from '@/ui/paraglide/messages.js' +import { + ContextMenuSub, + ContextMenuSubContent, + ContextMenuSubTrigger, + ContextMenuItem, + ContextMenuSeparator, + ContextMenuPortal, +} from '@/ui/components/ui/context-menu' +import { + DropdownMenuSub, + DropdownMenuSubContent, + DropdownMenuSubTrigger, + DropdownMenuItem, + DropdownMenuSeparator, +} from '@/ui/components/ui/dropdown-menu' +import { + Copy, + Image as ImageIcon, + FileText, + Link, + Download, + Hash, + Code, + Table, + HardDrive, +} from 'lucide-react' +import { type CopyKind, type CopyOptionsContext, getCopyOptions } from './copy-options' + +interface CopyMenuProps { + items: AssetInfo[] + context: CopyOptionsContext + onCopy: (kind: CopyKind, items: AssetInfo[]) => void +} + +function renderCopyIcon(kind: CopyKind) { + switch (kind) { + case 'image': + return + case 'name': + return + case 'link': + return + case 'download-link': + return + case 'id': + return + case 'markdown': + return + case 'tsv': + return + case 'storage-path': + return + } +} + +function renderCopyLabel(kind: CopyKind) { + switch (kind) { + case 'image': + return m.copy_image() + case 'name': + return m.copy_name() + case 'link': + return m.copy_app_link() + case 'download-link': + return m.copy_download_link() + case 'id': + return m.copy_id() + case 'markdown': + return m.copy_markdown_link() + case 'tsv': + return m.copy_as_table() + case 'storage-path': + return m.copy_storage_path() + } +} + +export function CopyContextMenuSub({ items, context, onCopy }: CopyMenuProps) { + const options = getCopyOptions(items, context) + if (options.length === 0) return null + + const imageOpt = options.find((o) => o.kind === 'image') + const coreOpts = options.filter((o) => ['name', 'link', 'download-link', 'id'].includes(o.kind)) + const docOpts = options.filter((o) => ['markdown', 'tsv'].includes(o.kind)) + const storageOpt = options.find((o) => o.kind === 'storage-path') + + return ( + + + + {m.copy()} + + + + {imageOpt && ( + <> + onCopy('image', items)}> + {renderCopyIcon('image')} + {renderCopyLabel('image')} + + + + )} + + {coreOpts.map((opt) => ( + onCopy(opt.kind, items)} + > + {renderCopyIcon(opt.kind)} + {renderCopyLabel(opt.kind)} + + ))} + + {docOpts.length > 0 && ( + <> + + {docOpts.map((opt) => ( + onCopy(opt.kind, items)} + > + {renderCopyIcon(opt.kind)} + {renderCopyLabel(opt.kind)} + + ))} + + )} + + {storageOpt && ( + <> + + onCopy('storage-path', items)} + > + {renderCopyIcon('storage-path')} + {renderCopyLabel('storage-path')} + + + )} + + + + ) +} + +export function CopyDropdownMenuSub({ items, context, onCopy }: CopyMenuProps) { + const options = getCopyOptions(items, context) + if (options.length === 0) return null + + const imageOpt = options.find((o) => o.kind === 'image') + const coreOpts = options.filter((o) => ['name', 'link', 'download-link', 'id'].includes(o.kind)) + const docOpts = options.filter((o) => ['markdown', 'tsv'].includes(o.kind)) + const storageOpt = options.find((o) => o.kind === 'storage-path') + + return ( + + + + {m.copy()} + + + {imageOpt && ( + <> + { + e.stopPropagation() + onCopy('image', items) + }} + > + {renderCopyIcon('image')} + {renderCopyLabel('image')} + + + + )} + + {coreOpts.map((opt) => ( + { + e.stopPropagation() + onCopy(opt.kind, items) + }} + > + {renderCopyIcon(opt.kind)} + {renderCopyLabel(opt.kind)} + + ))} + + {docOpts.length > 0 && ( + <> + + {docOpts.map((opt) => ( + { + e.stopPropagation() + onCopy(opt.kind, items) + }} + > + {renderCopyIcon(opt.kind)} + {renderCopyLabel(opt.kind)} + + ))} + + )} + + {storageOpt && ( + <> + + { + e.stopPropagation() + onCopy('storage-path', items) + }} + > + {renderCopyIcon('storage-path')} + {renderCopyLabel('storage-path')} + + + )} + + + ) +} diff --git a/packages/webui/components/file-browser/file-browser.tsx b/packages/webui/components/file-browser/file-browser.tsx index e68fddcd..f3f7349f 100644 --- a/packages/webui/components/file-browser/file-browser.tsx +++ b/packages/webui/components/file-browser/file-browser.tsx @@ -485,7 +485,7 @@ export function FileBrowser({ handleRename, handleRestore, handleDownload, - handleCopyNameAndDownloadLink, + handleCopy, handleArchive, handleRestoreArchive, handleAction, @@ -781,6 +781,8 @@ export function FileBrowser({ allowDownload, fields: displayedFields, canEdit, + isTeamOwner: canAdmin, + onCopy: handleCopy, archiveStorageEnabled, isExternalDragging, externalOverFolderId, @@ -1172,7 +1174,7 @@ export function FileBrowser({ onRename={handleRename} onDelete={handleDelete} onDownload={handleDownload} - onCopyNameAndDownloadLink={handleCopyNameAndDownloadLink} + onCopy={handleCopy} onNewFolder={handleNewFolder} onUploadFile={handleUploadFilesClick} onUploadFolder={handleUploadFolderClick} @@ -1190,6 +1192,8 @@ export function FileBrowser({ onArchive={handleArchive} onRestoreArchive={handleRestoreArchive} archiveStorageEnabled={archiveStorageEnabled} + isTeamOwner={canAdmin} + allowDownload={allowDownload} isRecentlyDeleted={isRecentlyDeleted} isRecents={isRecents} shareLinks={shareLinksData?.data ?? []} diff --git a/packages/webui/components/file-browser/file-card.test.tsx b/packages/webui/components/file-browser/file-card.test.tsx index d1e7c515..79cc7722 100644 --- a/packages/webui/components/file-browser/file-card.test.tsx +++ b/packages/webui/components/file-browser/file-card.test.tsx @@ -772,4 +772,34 @@ describe('FileCard', () => { ) expect(screen.getByTestId('file-card-restoring-badge')).toBeTruthy() }) + + it('renders Copy submenu in dropdown menu', () => { + render( + + + , + ) + + const moreBtn = screen.getByRole('button', { name: '' }) + fireEvent.keyDown(moreBtn, { key: 'ArrowDown', code: 'ArrowDown' }) + + const copyOption = screen.getByText(/^Copy$|^复制$/i) + expect(copyOption).toBeTruthy() + }) }) diff --git a/packages/webui/components/file-browser/file-card.tsx b/packages/webui/components/file-browser/file-card.tsx index 0b69c10a..f6eb0003 100644 --- a/packages/webui/components/file-browser/file-card.tsx +++ b/packages/webui/components/file-browser/file-card.tsx @@ -1,5 +1,7 @@ import { client } from '@/ui/api/client' import { m } from '@/ui/paraglide/messages.js' +import { CopyDropdownMenuSub } from './copy-submenu' +import type { CopyKind } from './copy-options' import type { AssetInfo, FieldValueInfo } from '@shumai/dtos' import { useQuery } from '@tanstack/react-query' @@ -89,6 +91,8 @@ interface FileCardProps { allowDownload?: boolean hideCheckbox?: boolean hideActions?: boolean + isTeamOwner?: boolean + onCopy?: (kind: CopyKind, items: AssetInfo[]) => void } export function FileCard({ @@ -110,6 +114,8 @@ export function FileCard({ dragState, disabled, onAction, + onCopy, + isTeamOwner = false, isRecentlyDeleted, isRecents, selectedCount, @@ -693,6 +699,16 @@ export function FileCard({ {m.download()} )} + {!isRecentlyDeleted && !isShareView && ( + onCopy?.(kind, targetItems)} + /> + )} {canEdit && archiveStorageEnabled && canArchiveItem && ( void } const FolderPreviewGrid = ({ items }: { items: ChildPreview[] }) => { @@ -140,6 +144,8 @@ export function FolderCard({ dragState, disabled, onAction, + onCopy, + isTeamOwner = false, isRecentlyDeleted, isRecents, selectedCount, @@ -473,6 +479,16 @@ export function FolderCard({ {m.download()} )} + {!isRecentlyDeleted && !isShareView && ( + onCopy?.(kind, targetItems)} + /> + )} {canEdit && archiveStorageEnabled && ( <> { expect(screen.queryByRole('button', { name: /actions/i })).toBeNull() }) + + it('renders Copy submenu in file card dropdown menu on mobile', async () => { + const { container } = renderComponent() + + const dropdownTrigger = container.querySelector( + '[data-slot="dropdown-menu-trigger"]', + ) as HTMLElement + expect(dropdownTrigger).toBeTruthy() + fireEvent.keyDown(dropdownTrigger, { key: 'ArrowDown', code: 'ArrowDown' }) + + const copyOption = await screen.findByText(/^Copy$|^复制$/i) + expect(copyOption).toBeTruthy() + }) }) diff --git a/packages/webui/components/file-browser/mobile-file-browser.tsx b/packages/webui/components/file-browser/mobile-file-browser.tsx index 16216cfc..c439f5f7 100644 --- a/packages/webui/components/file-browser/mobile-file-browser.tsx +++ b/packages/webui/components/file-browser/mobile-file-browser.tsx @@ -176,6 +176,7 @@ export function MobileFileBrowser({ confirmArchiveOrRestore, isArchiving, isRestoringArchive, + handleCopy, } = useFileActions({ teamId, projectId, @@ -537,6 +538,8 @@ export function MobileFileBrowser({ archiveStorageEnabled={archiveStorageEnabled} isShareView={isShareView} allowDownload={allowDownload} + onCopy={handleCopy} + isTeamOwner={canAdmin} /> ))} @@ -600,6 +603,8 @@ export function MobileFileBrowser({ archiveStorageEnabled={archiveStorageEnabled} isShareView={isShareView} allowDownload={allowDownload} + onCopy={handleCopy} + isTeamOwner={canAdmin} /> ))} diff --git a/packages/webui/components/file-browser/use-copy-actions.test.ts b/packages/webui/components/file-browser/use-copy-actions.test.ts new file mode 100644 index 00000000..66f4378b --- /dev/null +++ b/packages/webui/components/file-browser/use-copy-actions.test.ts @@ -0,0 +1,306 @@ +// @vitest-environment happy-dom +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest' +import { renderHook, act } from '@testing-library/react' +import { useCopyActions } from './use-copy-actions' +import type { AssetInfo } from '@shumai/dtos' +import { toast } from 'sonner' +import * as clipboardModule from '@/ui/lib/clipboard' + +vi.mock('sonner', () => ({ + toast: { + success: vi.fn(), + error: vi.fn(), + }, +})) + +const mockDownloadUrlPost = vi.fn() +const mockStoragePathsPost = vi.fn() + +vi.mock('@/ui/api/client', () => ({ + client: { + api: { + files: { + 'download-url': { + $post: (...args: unknown[]) => mockDownloadUrlPost(...args), + }, + 'storage-paths': { + $post: (...args: unknown[]) => mockStoragePathsPost(...args), + }, + }, + }, + }, +})) + +describe('useCopyActions', () => { + const dummyFile: AssetInfo = { + id: 'f1', + name: 'document.pdf', + type: 'file', + status: 'processed', + sizeByte: 1024, + fileCount: 0, + createdAt: '2026-01-01', + updatedAt: '2026-01-01', + } + + const dummyFolder: AssetInfo = { + id: 'd1', + name: 'Folder1', + type: 'folder', + status: 'processed', + sizeByte: 0, + fileCount: 2, + createdAt: '2026-01-01', + updatedAt: '2026-01-01', + } + + const dummyImage: AssetInfo = { + id: 'img1', + name: 'photo.jpg', + type: 'file', + proxyType: 'image', + status: 'processed', + sizeByte: 2048, + fileCount: 0, + createdAt: '2026-01-01', + updatedAt: '2026-01-01', + media: { + imageTranscodes: [ + { + id: 't1', + url: '', + key: 'files/img1/proxy-768p.webp', + width: 768, + height: 1024, + size: 500, + }, + ], + }, + } + + beforeEach(() => { + vi.restoreAllMocks() + vi.clearAllMocks() + }) + + afterEach(() => { + vi.restoreAllMocks() + }) + + describe('R2 Regression: Empty download links or storage paths', () => { + it('does not touch clipboard and does not toast success when all files are archived', async () => { + const getDownloadLinks = vi.fn().mockResolvedValue({ + files: [], + skippedArchivedCount: 2, + }) + + const copyDeferredSpy = vi.spyOn(clipboardModule, 'copyToClipboardDeferred') + const copyTextSpy = vi.spyOn(clipboardModule, 'copyToClipboard') + + const { result } = renderHook(() => + useCopyActions({ + projectId: 'p1', + getDownloadLinks, + }), + ) + + await act(async () => { + await result.current.handleCopy('download-link', [dummyFile, { ...dummyFile, id: 'f2' }]) + }) + + // Must show error toast + expect(toast.error).toHaveBeenCalled() + // Must NOT show success toast + expect(toast.success).not.toHaveBeenCalled() + // Must NOT have copied empty string with copyToClipboard + expect(copyTextSpy).not.toHaveBeenCalled() + // If deferred was called, it should have returned false and avoided success + if (copyDeferredSpy.mock.results.length > 0) { + expect(await copyDeferredSpy.mock.results[0].value).toBe(false) + } + }) + + it('does not toast success and shows error toast when storage paths return empty array', async () => { + mockStoragePathsPost.mockResolvedValueOnce({ + ok: true, + json: async () => ({ paths: [] }), + }) + + const copyDeferredSpy = vi.spyOn(clipboardModule, 'copyToClipboardDeferred') + + const { result } = renderHook(() => + useCopyActions({ + projectId: 'p1', + getDownloadLinks: vi.fn(), + }), + ) + + await act(async () => { + await result.current.handleCopy('storage-path', [dummyFile]) + }) + + expect(toast.error).toHaveBeenCalled() + expect(toast.success).not.toHaveBeenCalled() + if (copyDeferredSpy.mock.results.length > 0) { + expect(await copyDeferredSpy.mock.results[0].value).toBe(false) + } + }) + }) + + describe('image copying', () => { + it('resolves download URL on demand for transcode key and copies image to clipboard', async () => { + mockDownloadUrlPost.mockResolvedValueOnce({ + ok: true, + json: async () => ({ url: 'https://cdn/proxy-768p.webp' }), + }) + + const copyImageSpy = vi.spyOn(clipboardModule, 'copyImageToClipboard').mockResolvedValue(true) + + const { result } = renderHook(() => + useCopyActions({ + projectId: 'p1', + getDownloadLinks: vi.fn(), + }), + ) + + await act(async () => { + await result.current.handleCopy('image', [dummyImage]) + }) + + expect(mockDownloadUrlPost).toHaveBeenCalledWith({ + json: { key: 'files/img1/proxy-768p.webp', assetId: 'img1' }, + }) + expect(copyImageSpy).toHaveBeenCalled() + expect(toast.success).toHaveBeenCalled() + }) + + it('falls back to thumbnail URL if no transcodes are present', async () => { + const imageWithThumb: AssetInfo = { + ...dummyImage, + media: undefined, + preview: { + thumbnailUrl: 'https://cdn/thumb.webp', + }, + } + + const copyImageSpy = vi.spyOn(clipboardModule, 'copyImageToClipboard').mockResolvedValue(true) + + const { result } = renderHook(() => + useCopyActions({ + projectId: 'p1', + getDownloadLinks: vi.fn(), + }), + ) + + await act(async () => { + await result.current.handleCopy('image', [imageWithThumb]) + }) + + expect(copyImageSpy).toHaveBeenCalled() + expect(toast.success).toHaveBeenCalled() + }) + + it('toasts error if copying image fails or is unsupported', async () => { + vi.spyOn(clipboardModule, 'copyImageToClipboard').mockResolvedValue(false) + mockDownloadUrlPost.mockResolvedValueOnce({ + ok: true, + json: async () => ({ url: 'https://cdn/proxy-768p.webp' }), + }) + + const { result } = renderHook(() => + useCopyActions({ + projectId: 'p1', + getDownloadLinks: vi.fn(), + }), + ) + + await act(async () => { + await result.current.handleCopy('image', [dummyImage]) + }) + + expect(toast.error).toHaveBeenCalled() + expect(toast.success).not.toHaveBeenCalled() + }) + }) + + describe('download links copying', () => { + it('copies download links and shows skipped folders suffix when folders are included', async () => { + const getDownloadLinks = vi.fn().mockResolvedValue({ + files: [{ id: 'f1', name: 'document.pdf', url: 'https://cdn/download-1' }], + }) + + vi.spyOn(clipboardModule, 'copyToClipboardDeferred').mockResolvedValue(true) + + const { result } = renderHook(() => + useCopyActions({ + projectId: 'p1', + getDownloadLinks, + }), + ) + + await act(async () => { + await result.current.handleCopy('download-link', [dummyFile, dummyFolder]) + }) + + expect(getDownloadLinks).toHaveBeenCalledWith({ json: { ids: ['f1'] } }) + expect(toast.success).toHaveBeenCalled() + }) + }) + + describe('storage paths copying', () => { + it('fetches storage paths and copies via deferred clipboard', async () => { + mockStoragePathsPost.mockResolvedValueOnce({ + ok: true, + json: async () => ({ + paths: [ + { + id: 'f1', + name: 'document.pdf', + path: '/data/shumai/files/1', + backend: 'local', + isArchived: false, + }, + ], + }), + }) + + vi.spyOn(clipboardModule, 'copyToClipboardDeferred').mockResolvedValue(true) + + const { result } = renderHook(() => + useCopyActions({ + projectId: 'p1', + getDownloadLinks: vi.fn(), + }), + ) + + await act(async () => { + await result.current.handleCopy('storage-path', [dummyFile]) + }) + + expect(mockStoragePathsPost).toHaveBeenCalledWith({ json: { ids: ['f1'] } }) + expect(toast.success).toHaveBeenCalled() + }) + }) + + describe('text copying formats', () => { + it('copies name, link, id, markdown, and tsv with success toasts', async () => { + vi.spyOn(clipboardModule, 'copyToClipboard').mockResolvedValue(true) + + const { result } = renderHook(() => + useCopyActions({ + projectId: 'p1', + getDownloadLinks: vi.fn(), + }), + ) + + for (const kind of ['name', 'link', 'id', 'markdown', 'tsv'] as const) { + vi.clearAllMocks() + await act(async () => { + await result.current.handleCopy(kind, [dummyFile, dummyFolder]) + }) + expect(clipboardModule.copyToClipboard).toHaveBeenCalled() + expect(toast.success).toHaveBeenCalled() + } + }) + }) +}) diff --git a/packages/webui/components/file-browser/use-copy-actions.ts b/packages/webui/components/file-browser/use-copy-actions.ts new file mode 100644 index 00000000..1af27855 --- /dev/null +++ b/packages/webui/components/file-browser/use-copy-actions.ts @@ -0,0 +1,223 @@ +'use client' + +import { client } from '@/ui/api/client' +import type { AssetInfo } from '@shumai/dtos' +import { toast } from 'sonner' +import { copyToClipboard, copyToClipboardDeferred, copyImageToClipboard } from '@/ui/lib/clipboard' +import { type CopyKind, formatCopyText, pickClipboardTranscode } from './copy-options' +import { m } from '@/ui/paraglide/messages.js' + +export interface UseCopyActionsProps { + projectId?: string + isPublic?: boolean + shareId?: string + getDownloadLinks: (args: { json: { ids: string[] } }) => Promise<{ + files: Array<{ id: string; name: string; url: string }> + skippedArchivedCount?: number + }> +} + +export function useCopyActions({ + projectId, + isPublic, + shareId, + getDownloadLinks, +}: UseCopyActionsProps) { + const handleCopy = async (kind: CopyKind, items: AssetInfo[]) => { + if (items.length === 0) return + + if (kind === 'image') { + const item = items[0] + const transcode = pickClipboardTranscode(item.media?.imageTranscodes) + + if (!transcode && !item.preview?.thumbnailUrl && item.status !== 'processed') { + toast.error(m.copy_image_failed()) + return + } + + const fetchImageUrl = async (): Promise => { + if (transcode?.url) return transcode.url + if (transcode?.key && item.id) { + if (isPublic && shareId) { + const password = localStorage.getItem(`share_pwd_${shareId}`) || '' + const res = await client.api.shares[':shareId'].files[':fileId']['download-url'].$post( + { + param: { shareId, fileId: item.id }, + json: { key: transcode.key }, + }, + { + headers: { + 'x-share-password': password, + }, + }, + ) + if (res.ok) { + const { url } = await res.json() + return url + } + } else { + const res = await client.api.files['download-url'].$post({ + json: { key: transcode.key, assetId: item.id }, + }) + if (res.ok) { + const { url } = await res.json() + return url + } + } + } + if (item.preview?.thumbnailUrl) { + return item.preview.thumbnailUrl + } + throw new Error('No image URL available') + } + + try { + const ok = await copyImageToClipboard(fetchImageUrl()) + if (ok) { + toast.success(m.copied_image_toast()) + } else { + toast.error(m.copy_image_failed()) + } + } catch { + toast.error(m.copy_image_failed()) + } + return + } + + if (kind === 'download-link') { + const targetFiles = items.filter((i) => i.type !== 'folder') + if (targetFiles.length === 0) return + + let hasShownEmptyError = false + try { + const fetchDownloadLinksPromise = (async () => { + const res = await getDownloadLinks({ + json: { ids: targetFiles.map((i) => i.id!) }, + }) + const files = res.files + if (files.length === 0) { + hasShownEmptyError = true + if ((res.skippedArchivedCount ?? 0) > 0) { + toast.error(m.download_all_archived_error()) + } else { + toast.error(m.copy_failed()) + } + throw new Error('NO_FILES_TO_COPY') + } + return files.map((f) => f.url).join('\n') + })() + + const ok = await copyToClipboardDeferred(fetchDownloadLinksPromise) + if (ok) { + const skippedFolders = items.length - targetFiles.length + if (targetFiles.length === 1 && skippedFolders === 0) { + toast.success(m.copied_download_link_toast()) + } else { + const baseToast = m.copied_download_links_toast({ count: targetFiles.length }) + const msg = + skippedFolders > 0 + ? `${baseToast} ${m.copied_skipped_folders_suffix({ count: skippedFolders })}` + : baseToast + toast.success(msg) + } + } else if (!hasShownEmptyError) { + toast.error(m.copy_failed()) + } + } catch (err) { + if (!hasShownEmptyError) { + console.error('Failed to copy download links:', err) + toast.error(m.copy_failed()) + } + } + return + } + + if (kind === 'storage-path') { + const targetFiles = items.filter((i) => i.type !== 'folder') + if (targetFiles.length === 0) return + + let hasShownEmptyError = false + try { + const fetchStoragePathsPromise = (async () => { + const res = await client.api.files['storage-paths'].$post({ + json: { ids: targetFiles.map((i) => i.id!) }, + }) + if (!res.ok) throw new Error('Failed to fetch storage paths') + const data = await res.json() + if (!data.paths || data.paths.length === 0) { + hasShownEmptyError = true + toast.error(m.copy_failed()) + throw new Error('NO_PATHS_TO_COPY') + } + return data.paths.map((p) => p.path).join('\n') + })() + + const ok = await copyToClipboardDeferred(fetchStoragePathsPromise) + if (ok) { + const skippedFolders = items.length - targetFiles.length + if (targetFiles.length === 1 && skippedFolders === 0) { + toast.success(m.copied_storage_path_toast()) + } else { + const baseToast = m.copied_storage_paths_toast({ count: targetFiles.length }) + const msg = + skippedFolders > 0 + ? `${baseToast} ${m.copied_skipped_folders_suffix({ count: skippedFolders })}` + : baseToast + toast.success(msg) + } + } else if (!hasShownEmptyError) { + toast.error(m.copy_failed()) + } + } catch (err) { + if (!hasShownEmptyError) { + console.error('Failed to copy storage paths:', err) + toast.error(m.copy_failed()) + } + } + return + } + + // Synchronous text copy + const origin = typeof window !== 'undefined' ? window.location.origin : '' + const text = formatCopyText(kind, items, { origin, projectId }) + const ok = await copyToClipboard(text) + + if (ok) { + switch (kind) { + case 'name': + toast.success( + items.length === 1 + ? m.copied_name_toast() + : m.copied_names_toast({ count: items.length }), + ) + break + case 'link': + toast.success( + items.length === 1 + ? m.copied_link_toast() + : m.copied_links_toast({ count: items.length }), + ) + break + case 'id': + toast.success( + items.length === 1 ? m.copied_id_toast() : m.copied_ids_toast({ count: items.length }), + ) + break + case 'markdown': + toast.success( + items.length === 1 + ? m.copied_markdown_link_toast() + : m.copied_markdown_links_toast({ count: items.length }), + ) + break + case 'tsv': + toast.success(m.copied_table_toast({ count: items.length })) + break + } + } else { + toast.error(m.copy_failed()) + } + } + + return { handleCopy } +} diff --git a/packages/webui/components/file-browser/use-file-actions.ts b/packages/webui/components/file-browser/use-file-actions.ts index 21da4c78..c65d2ffd 100644 --- a/packages/webui/components/file-browser/use-file-actions.ts +++ b/packages/webui/components/file-browser/use-file-actions.ts @@ -6,7 +6,7 @@ import { useMutation, useQueryClient } from '@tanstack/react-query' import type { InferRequestType, InferResponseType } from 'hono/client' import { useState } from 'react' import { toast } from 'sonner' -import { copyToClipboard } from '@/ui/lib/clipboard' +import { useCopyActions } from './use-copy-actions' import { m } from '@/ui/paraglide/messages.js' interface UseFileActionsProps { @@ -316,36 +316,12 @@ export function useFileActions({ } } - const handleCopyNameAndDownloadLink = async (items: AssetInfo[]) => { - if (items.length === 0) return - try { - const res = await getDownloadLinks({ - json: { ids: items.map((i) => i.id!) }, - }) - const files = res.files - if (files.length === 0) { - if ((res.skippedArchivedCount ?? 0) > 0) { - toast.error(m.download_all_archived_error()) - } - return - } - - let text = '' - if (files.length === 1) { - text = `Name: ${files[0].name}\nPath: ${files[0].url}` - } else { - text = files.map((f) => `${f.name}\t${f.url}`).join('\n') - } - - const ok = await copyToClipboard(text) - if (ok) { - toast.success(m.copied_name_and_download_link_to_clipboard()) - } - } catch (error) { - toast.error('Failed to copy name and download link') - console.error(error) - } - } + const { handleCopy } = useCopyActions({ + projectId, + isPublic, + shareId, + getDownloadLinks: (args) => getDownloadLinks(args), + }) const handleArchive = (items: AssetInfo[]) => { if (items.length === 0) return @@ -543,7 +519,7 @@ export function useFileActions({ handleRestore(targetItems) break case 'copy-name-and-download-link': - handleCopyNameAndDownloadLink(targetItems) + handleCopy('download-link', targetItems) break case 'archive': handleArchive(targetItems) @@ -561,7 +537,7 @@ export function useFileActions({ handleDelete, handleRestore, handleDownload, - handleCopyNameAndDownloadLink, + handleCopy, handleArchive, handleRestoreArchive, handleNewFolder, diff --git a/packages/webui/components/ui/context-menu.tsx b/packages/webui/components/ui/context-menu.tsx index 9f7f96dc..d18df00b 100644 --- a/packages/webui/components/ui/context-menu.tsx +++ b/packages/webui/components/ui/context-menu.tsx @@ -47,7 +47,7 @@ function ContextMenuSubTrigger({ data-slot="context-menu-sub-trigger" data-inset={inset} className={cn( - "flex cursor-default items-center rounded-sm px-2 py-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-[inset]:pl-8 data-[state=open]:bg-accent data-[state=open]:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 [&_svg:not([class*='text-'])]:text-muted-foreground", + "flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-[inset]:pl-8 data-[state=open]:bg-accent data-[state=open]:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 [&_svg:not([class*='text-'])]:text-muted-foreground", className, )} {...props} diff --git a/packages/webui/components/viewers/image/image-viewer.tsx b/packages/webui/components/viewers/image/image-viewer.tsx index 9cceaec9..abb96328 100644 --- a/packages/webui/components/viewers/image/image-viewer.tsx +++ b/packages/webui/components/viewers/image/image-viewer.tsx @@ -1,6 +1,7 @@ import { useScreenSize } from '@/ui/hooks/useScreenSize' import { client } from '@/ui/api/client' import { getBestTranscode } from '@/ui/lib/media' +import { copyImageToClipboard } from '@/ui/lib/clipboard' import React, { useEffect, useRef, useState, useImperativeHandle } from 'react' import DrawingCanvas from '@/ui/components/drawing-canvas' import { ImageControlBar } from './image-control-bar' @@ -128,49 +129,10 @@ export const ImageViewer = React.forwardRef( const handleCopy = async () => { const webpUrl = bestUrl if (!webpUrl) return - try { - const copyPromise = (async () => { - const response = await fetch(webpUrl) - const blob = await response.blob() - - const img = new Image() - img.crossOrigin = 'anonymous' - const objectUrl = URL.createObjectURL(blob) - img.src = objectUrl - - try { - await new Promise((resolve, reject) => { - img.onload = resolve - img.onerror = (e) => reject(new Error('Failed to load image: ' + String(e))) - }) - - const canvas = document.createElement('canvas') - canvas.width = img.width - canvas.height = img.height - const ctx = canvas.getContext('2d') - if (!ctx) throw new Error('Could not get canvas context') - ctx.drawImage(img, 0, 0) - - const pngBlob = await new Promise((resolve) => { - canvas.toBlob(resolve, 'image/png') - }) - - if (!pngBlob) throw new Error('Failed to convert image to PNG') - return pngBlob - } finally { - URL.revokeObjectURL(objectUrl) - } - })() - - await navigator.clipboard.write([ - new ClipboardItem({ - 'image/png': copyPromise, - }), - ]) + const ok = await copyImageToClipboard(webpUrl) + if (ok) { setCopied(true) setTimeout(() => setCopied(false), 2000) - } catch (err) { - console.error('Failed to copy image to clipboard:', err) } } diff --git a/packages/webui/lib/clipboard.test.ts b/packages/webui/lib/clipboard.test.ts index d9856789..72e6293d 100644 --- a/packages/webui/lib/clipboard.test.ts +++ b/packages/webui/lib/clipboard.test.ts @@ -1,6 +1,6 @@ // @vitest-environment happy-dom import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest' -import { copyToClipboard } from './clipboard' +import { copyToClipboard, copyToClipboardDeferred, copyImageToClipboard } from './clipboard' describe('copyToClipboard', () => { const originalClipboard = navigator.clipboard @@ -49,3 +49,93 @@ describe('copyToClipboard', () => { expect(execCommandFn).toHaveBeenCalledWith('copy') }) }) + +describe('copyToClipboardDeferred', () => { + it('uses navigator.clipboard.write with ClipboardItem when available', async () => { + const mockWrite = vi.fn().mockResolvedValue(undefined) + class MockClipboardItem { + types: Record + constructor(types: Record) { + this.types = types + } + } + + Object.defineProperty(globalThis, 'ClipboardItem', { + value: MockClipboardItem, + configurable: true, + writable: true, + }) + + Object.defineProperty(navigator, 'clipboard', { + value: { write: mockWrite }, + configurable: true, + writable: true, + }) + + const success = await copyToClipboardDeferred(Promise.resolve('deferred text')) + expect(success).toBe(true) + expect(mockWrite).toHaveBeenCalledTimes(1) + }) + + it('falls back to copyToClipboard when ClipboardItem is unavailable', async () => { + const mockWriteText = vi.fn().mockResolvedValue(undefined) + Object.defineProperty(globalThis, 'ClipboardItem', { + value: undefined, + configurable: true, + writable: true, + }) + Object.defineProperty(navigator, 'clipboard', { + value: { writeText: mockWriteText }, + configurable: true, + writable: true, + }) + + const success = await copyToClipboardDeferred(Promise.resolve('fallback deferred text')) + expect(success).toBe(true) + expect(mockWriteText).toHaveBeenCalledWith('fallback deferred text') + }) +}) + +describe('copyImageToClipboard', () => { + it('returns false when clipboard API is unavailable', async () => { + Object.defineProperty(navigator, 'clipboard', { + value: undefined, + configurable: true, + writable: true, + }) + + const success = await copyImageToClipboard('http://example.com/image.png') + expect(success).toBe(false) + }) + + it('accepts a Promise resolving to a URL and writes to clipboard', async () => { + const mockWrite = vi.fn().mockResolvedValue(undefined) + class MockClipboardItem { + types: Record + constructor(types: Record) { + this.types = types + } + } + + Object.defineProperty(globalThis, 'ClipboardItem', { + value: MockClipboardItem, + configurable: true, + writable: true, + }) + + Object.defineProperty(navigator, 'clipboard', { + value: { write: mockWrite }, + configurable: true, + writable: true, + }) + + const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(async () => { + return new Response(new Blob(['fake-image-bytes'], { type: 'image/webp' })) + }) + + const success = await copyImageToClipboard(Promise.resolve('http://example.com/image.png')) + expect(success).toBe(true) + expect(mockWrite).toHaveBeenCalledTimes(1) + fetchSpy.mockRestore() + }) +}) diff --git a/packages/webui/lib/clipboard.ts b/packages/webui/lib/clipboard.ts index c6e74f5e..9418363e 100644 --- a/packages/webui/lib/clipboard.ts +++ b/packages/webui/lib/clipboard.ts @@ -41,3 +41,119 @@ export async function copyToClipboard(text: string): Promise { return false } } + +/** + * Copies text resolved asynchronously to clipboard, using ClipboardItem to preserve + * Safari's transient user activation when fetching links. + */ +export async function copyToClipboardDeferred(textPromise: Promise): Promise { + if ( + typeof navigator !== 'undefined' && + navigator.clipboard && + typeof navigator.clipboard.write === 'function' && + typeof ClipboardItem !== 'undefined' + ) { + try { + const blobPromise = textPromise.then((text) => { + if (!text) throw new Error('EMPTY_TEXT') + return new Blob([text], { type: 'text/plain' }) + }) + blobPromise.catch(() => {}) + + await navigator.clipboard.write([ + new ClipboardItem({ + 'text/plain': blobPromise, + }), + ]) + await textPromise + return true + } catch { + // Fall back if deferred writing fails or is rejected + } + } + + try { + const text = await textPromise + if (!text) return false + return await copyToClipboard(text) + } catch (err) { + console.error('Failed to copy deferred text to clipboard:', err) + return false + } +} + +/** + * Copies an image at a given URL (or promise resolving to URL) to the clipboard as PNG. + */ +export async function copyImageToClipboard( + imageUrlOrPromise: string | Promise, +): Promise { + if ( + typeof navigator === 'undefined' || + !navigator.clipboard || + typeof navigator.clipboard.write !== 'function' || + typeof ClipboardItem === 'undefined' + ) { + return false + } + + const renderPngBlob = async (): Promise => { + const imageUrl = await imageUrlOrPromise + const response = await fetch(imageUrl) + const blob = await response.blob() + + const img = new Image() + img.crossOrigin = 'anonymous' + const objectUrl = URL.createObjectURL(blob) + img.src = objectUrl + + try { + await new Promise((resolve, reject) => { + img.onload = resolve + img.onerror = (e) => reject(new Error('Failed to load image: ' + String(e))) + }) + + const canvas = document.createElement('canvas') + canvas.width = img.width + canvas.height = img.height + const ctx = canvas.getContext('2d') + if (!ctx) throw new Error('Could not get canvas context') + ctx.drawImage(img, 0, 0) + + const pngBlob = await new Promise((resolve) => { + canvas.toBlob(resolve, 'image/png') + }) + + if (!pngBlob) throw new Error('Failed to convert image to PNG') + return pngBlob + } finally { + URL.revokeObjectURL(objectUrl) + } + } + + try { + const blobPromise = renderPngBlob() + + // Try passing promise to ClipboardItem (Safari / Chrome 86+) to preserve user activation + try { + await navigator.clipboard.write([ + new ClipboardItem({ + 'image/png': blobPromise, + }), + ]) + return true + } catch { + // Fallback for environments requiring a concrete Blob in ClipboardItem + const blob = await blobPromise + await navigator.clipboard.write([ + new ClipboardItem({ + 'image/png': blob, + }), + ]) + return true + } + } catch (err) { + console.error('Failed to copy image to clipboard:', err) + return false + } +} diff --git a/packages/webui/messages/en.json b/packages/webui/messages/en.json index e749479f..70111cad 100644 --- a/packages/webui/messages/en.json +++ b/packages/webui/messages/en.json @@ -428,6 +428,32 @@ "api_token_hidden_hint": "Tokens can only be viewed when they are created.", "copy_name_and_download_link": "Copy name and download link", "copied_name_and_download_link_to_clipboard": "Copied name and download link to clipboard", + "copy_image": "Image", + "copy_name": "Name", + "copy_app_link": "Link", + "copy_download_link": "Download link", + "copy_id": "ID", + "copy_markdown_link": "Markdown link", + "copy_as_table": "As table (TSV)", + "copy_storage_path": "Storage path", + "copied_image_toast": "Copied image to clipboard", + "copied_name_toast": "Copied name to clipboard", + "copied_names_toast": "Copied {count} names to clipboard", + "copied_link_toast": "Copied link to clipboard", + "copied_links_toast": "Copied {count} links to clipboard", + "copied_download_link_toast": "Copied download link (expires soon)", + "copied_download_links_toast": "Copied {count} download links (expires soon)", + "copied_id_toast": "Copied ID to clipboard", + "copied_ids_toast": "Copied {count} IDs to clipboard", + "copied_markdown_link_toast": "Copied Markdown link to clipboard", + "copied_markdown_links_toast": "Copied {count} Markdown links to clipboard", + "copied_table_toast": "Copied {count} items as table", + "copied_storage_path_toast": "Copied storage path to clipboard", + "copied_storage_paths_toast": "Copied {count} storage paths to clipboard", + "copy_failed": "Failed to copy to clipboard", + "copy_image_failed": "Failed to copy image", + "copied_skipped_archived_suffix": "({count} archived skipped)", + "copied_skipped_folders_suffix": "({count} folders skipped)", "ai": "AI", "providers": "Providers", diff --git a/packages/webui/messages/zh.json b/packages/webui/messages/zh.json index 998c277f..c9f522e1 100644 --- a/packages/webui/messages/zh.json +++ b/packages/webui/messages/zh.json @@ -428,6 +428,32 @@ "api_token_hidden_hint": "令牌仅在创建时可见。", "copy_name_and_download_link": "复制名称和下载链接", "copied_name_and_download_link_to_clipboard": "已复制名称和下载链接到剪贴板", + "copy_image": "图片", + "copy_name": "名称", + "copy_app_link": "链接", + "copy_download_link": "下载链接", + "copy_id": "ID", + "copy_markdown_link": "Markdown 链接", + "copy_as_table": "表格格式 (TSV)", + "copy_storage_path": "存储路径", + "copied_image_toast": "已复制图片到剪贴板", + "copied_name_toast": "已复制名称到剪贴板", + "copied_names_toast": "已复制 {count} 个名称到剪贴板", + "copied_link_toast": "已复制链接到剪贴板", + "copied_links_toast": "已复制 {count} 个链接到剪贴板", + "copied_download_link_toast": "已复制下载链接(即将过期)", + "copied_download_links_toast": "已复制 {count} 个下载链接(即将过期)", + "copied_id_toast": "已复制 ID 到剪贴板", + "copied_ids_toast": "已复制 {count} 个 ID 到剪贴板", + "copied_markdown_link_toast": "已复制 Markdown 链接到剪贴板", + "copied_markdown_links_toast": "已复制 {count} 个 Markdown 链接到剪贴板", + "copied_table_toast": "已复制 {count} 项为表格", + "copied_storage_path_toast": "已复制存储路径到剪贴板", + "copied_storage_paths_toast": "已复制 {count} 个存储路径到剪贴板", + "copy_failed": "复制到剪贴板失败", + "copy_image_failed": "复制图片失败", + "copied_skipped_archived_suffix": "(已跳过 {count} 个已归档项)", + "copied_skipped_folders_suffix": "(已跳过 {count} 个文件夹)", "ai": "AI", "providers": "提供商",