@eclipse-docks/core 0.7.139 → 0.7.140

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-docks/core",
-  "version": "0.7.139",
+  "version": "0.7.140",
   "description": "Eclipse Docks platform core: registries, services, parts, widgets, and API",
   "type": "module",
   "license": "EPL-2.0",
@@ -77,7 +77,7 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "dompurify": "^3.2.7",
+    "dompurify": "^3.4.16",
     "@awesome.me/webawesome": "^3.12.0",
     "@fortawesome/fontawesome-free": "^7.2.0",
     "@fortawesome/fontawesome-svg-core": "^7.2.0",

package/src/components/filebrowser.de.json

@@ -10,5 +10,10 @@
   "DROP_FILES_HERE": "📁 Dateien hier ablegen",
   "OPEN_WITH": "Öffnen mit...",
   "FOLDER_LOAD_FAILED": "Ordner konnte nicht geladen werden: {detail}",
-  "FOLDER_UNAVAILABLE": "Dieser Arbeitsbereichsordner ist nicht verfügbar: {detail}"
+  "FOLDER_UNAVAILABLE": "Dieser Arbeitsbereichsordner ist nicht verfügbar: {detail}",
+  "UNKNOWN_BACKEND": "unbekannt",
+  "DND_CROSS_CONNECTION_CONFIRM": "{count} Element(e) von \"{srcBackend}\" nach \"{destBackend}\" kopieren?",
+  "DROP_UPLOAD_TASK": "Abgelegte Dateien werden hochgeladen",
+  "DROP_SCANNING": "Wird durchsucht... {count} Datei(en) gefunden",
+  "DROP_COPY_TASK": "Abgelegte Elemente werden kopiert"
 }

package/src/components/filebrowser.en.json

@@ -10,5 +10,10 @@
   "DROP_FILES_HERE": "📁 Drop files here",
   "OPEN_WITH": "Open with...",
   "FOLDER_LOAD_FAILED": "Failed to load folder: {detail}",
-  "FOLDER_UNAVAILABLE": "This workspace folder is unavailable: {detail}"
+  "FOLDER_UNAVAILABLE": "This workspace folder is unavailable: {detail}",
+  "UNKNOWN_BACKEND": "unknown",
+  "DND_CROSS_CONNECTION_CONFIRM": "Copy {count} item(s) from \"{srcBackend}\" to \"{destBackend}\"?",
+  "DROP_UPLOAD_TASK": "Uploading dropped files",
+  "DROP_SCANNING": "Scanning... {count} file(s) found",
+  "DROP_COPY_TASK": "Copying dropped items"
 }

package/src/components/filebrowser.ts

@@ -25,6 +25,7 @@ import { icon } from '../core/icon-utils';
 import { renderDropdownItem, renderDropdownSubmenu } from '../core/dropdown-item';
 import { i18n } from '../core/i18n';
 import { createLogger } from '../core/logger';
+import { taskService, type ProgressMonitor } from '../core/taskservice';
 
 const logger = createLogger('DocksFileBrowser');
 const t = await i18n(import.meta.glob('./filebrowser*.json'));
@@ -34,6 +35,94 @@ const WORKSPACE_CHANGED_DEBOUNCE_MS = 250;
 /** `wa-tree-item` exposes `.model` for the bound {@link TreeNode} (not in generated element types). */
 type WaTreeItemElement = HTMLElement & { model?: TreeNode };
 
+type DroppedUpload = {
+    relativePath: string;
+    file: globalThis.File;
+};
+
+function readFileEntry(entry: FileSystemFileEntry): Promise<globalThis.File> {
+    return new Promise((resolve, reject) => entry.file(resolve, reject));
+}
+
+/** `readEntries` returns at most 100 entries and must be called until an empty batch. */
+function readAllDirectoryEntries(reader: FileSystemDirectoryReader): Promise<FileSystemEntry[]> {
+    return new Promise((resolve, reject) => {
+        const all: FileSystemEntry[] = [];
+        const readBatch = () => {
+            reader.readEntries(batch => {
+                if (batch.length === 0) {
+                    resolve(all);
+                    return;
+                }
+                all.push(...batch);
+                readBatch();
+            }, reject);
+        };
+        readBatch();
+    });
+}
+
+type DroppedFileFound = (count: number) => void;
+
+async function appendDroppedEntry(
+    entry: FileSystemEntry,
+    uploads: DroppedUpload[],
+    onFileFound?: DroppedFileFound,
+    parentPath = ''
+): Promise<void> {
+    const relativePath = parentPath ? `${parentPath}/${entry.name}` : entry.name;
+
+    if (entry.isFile) {
+        try {
+            uploads.push({ relativePath, file: await readFileEntry(entry as FileSystemFileEntry) });
+            onFileFound?.(uploads.length);
+        } catch (error) {
+            logger.error(`Failed to read dropped file "${relativePath}":`, error);
+        }
+        return;
+    }
+
+    if (!entry.isDirectory) return;
+
+    let children: FileSystemEntry[];
+    try {
+        children = await readAllDirectoryEntries((entry as FileSystemDirectoryEntry).createReader());
+    } catch (error) {
+        logger.error(`Failed to read dropped folder "${relativePath}":`, error);
+        return;
+    }
+
+    for (const child of children) {
+        await appendDroppedEntry(child, uploads, onFileFound, relativePath);
+    }
+}
+
+/**
+ * Folder structure is only exposed through `webkitGetAsEntry()`; `dataTransfer.files` lists a dropped
+ * folder as a single unreadable file. Entries must be captured before the first `await`, because the
+ * drag data store becomes inaccessible once the drop handler yields.
+ */
+export async function collectDroppedUploads(
+    dataTransfer: DataTransfer,
+    onFileFound?: DroppedFileFound
+): Promise<DroppedUpload[]> {
+    const entries = Array.from(dataTransfer.items ?? [])
+        .filter(item => item.kind === 'file')
+        .map(item => item.webkitGetAsEntry?.() ?? null)
+        .filter((entry): entry is FileSystemEntry => entry !== null);
+    const files = Array.from(dataTransfer.files ?? []);
+
+    if (entries.length === 0) {
+        return files.map(file => ({ relativePath: file.webkitRelativePath || file.name, file }));
+    }
+
+    const uploads: DroppedUpload[] = [];
+    for (const entry of entries) {
+        await appendDroppedEntry(entry, uploads, onFileFound);
+    }
+    return uploads;
+}
+
 @customElement('docks-filebrowser')
 export class DocksFileBrowser extends DocksPart {
 
@@ -648,15 +737,19 @@ export class DocksFileBrowser extends DocksPart {
             const types = e.dataTransfer.types;
 
             if (types.includes('Files')) {
-                const files = Array.from(e.dataTransfer.files);
-                if (files.length === 0) return;
-                await this.handleFilesDrop(files, targetDir);
+                const dataTransfer = e.dataTransfer;
+                await taskService.runAsync(t.DROP_UPLOAD_TASK, async progress => {
+                    const uploads = await collectDroppedUploads(dataTransfer, count => {
+                        progress.message = t.DROP_SCANNING({ count: String(count) });
+                    });
+                    if (uploads.length === 0) return;
+                    await this.handleFilesDrop(uploads, targetDir, progress);
+                });
                 return;
             }
 
             if (types.includes('application/x-workspace-file')) {
                 await this.handleWorkspaceDrop(e, targetDir);
-                return;
             }
         };
 
@@ -767,16 +860,19 @@ export class DocksFileBrowser extends DocksPart {
             }
         }
 
-        for (const { path, resource } of sources) {
-            try {
-                const move = await moveWithinSameBackend(resource);
-                await workspaceService.copyResource(resource, targetDir, { move });
-                processed++;
-            } catch (error) {
-                logger.error(`Failed to handle workspace drop for "${path}":`, error);
-                failed++;
+        await taskService.runAsync(t.DROP_COPY_TASK, async progress => {
+            const onFile = (targetPath: string) => { progress.message = targetPath; };
+            for (const { path, resource } of sources) {
+                try {
+                    const move = await moveWithinSameBackend(resource);
+                    await workspaceService.copyResource(resource, targetDir, { move, onFile });
+                    processed++;
+                } catch (error) {
+                    logger.error(`Failed to handle workspace drop for "${path}":`, error);
+                    failed++;
+                }
             }
-        }
+        });
 
         logger.info(
             `Workspace drop completed: ${processed}/${sources.length} items ${failed > 0 ? `, ${failed} failed` : ''}`
@@ -785,27 +881,28 @@ export class DocksFileBrowser extends DocksPart {
         await this.loadWorkspace(this.workspaceDir, true);
     }
 
-    private async handleFilesDrop(files: globalThis.File[], targetDir: Directory) {
-        const total = files.length;
+    private async handleFilesDrop(uploads: DroppedUpload[], targetDir: Directory, progress: ProgressMonitor) {
+        const total = uploads.length;
         let processed = 0;
         let failed = 0;
         let skipped = 0;
 
-            for (const file of files) {
+        progress.totalSteps = total;
+        for (const [index, { relativePath, file }] of uploads.entries()) {
+            progress.currentStep = index + 1;
+            progress.message = relativePath;
             try {
-                const targetPath = this.buildTargetPath(targetDir, file.name);
-
-                const existingFile = await this.workspaceDir!.getResource(targetPath);
+                const existingFile = await targetDir.getResource(relativePath);
                 if (existingFile) {
-                    const overwrite = await confirmDialog(t.FILE_EXISTS_OVERWRITE({ fileName: file.name }));
+                    const overwrite = await confirmDialog(t.FILE_EXISTS_OVERWRITE({ fileName: relativePath }));
                     if (!overwrite) {
                         skipped++;
                         continue;
                     }
                 }
 
-                const workspaceFile = await this.workspaceDir!.getResource(
-                    targetPath,
+                const workspaceFile = await targetDir.getResource(
+                    relativePath,
                     { create: true }
                 ) as File;
 
@@ -813,7 +910,7 @@ export class DocksFileBrowser extends DocksPart {
 
                 processed++;
             } catch (error) {
-                logger.error(`Failed to upload ${file.name}:`, error);
+                logger.error(`Failed to upload ${relativePath}:`, error);
                 failed++;
             }
         }
@@ -823,11 +920,6 @@ export class DocksFileBrowser extends DocksPart {
         await this.loadWorkspace(this.workspaceDir);
     }
 
-    private buildTargetPath(targetDir: Directory, fileName: string): string {
-        const dirPath = targetDir.getWorkspacePath();
-        return dirPath ? `${dirPath}/${fileName}` : fileName;
-    }
-
     protected renderContent() {
         return html`
             <div class="tree" ${ref(this.treeRef)} style="--drop-files-text: '${t.DROP_FILES_HERE}'">

package/src/components/tasks.ts

@@ -19,6 +19,19 @@ contributionRegistry.registerContribution(TOOLBAR_BOTTOM_CENTER, {
 // Singleton dialog container for progress dialog
 let progressDialogContainer: HTMLElement | null = null;
 
+/** Percentage (0-100) of a task, or `undefined` when its progress is indefinite. */
+function taskPercent(task: ProgressMonitor): number | undefined {
+    if (task.progress >= 0) return task.progress;
+    if (task.totalSteps > 0) return Math.round((task.currentStep / task.totalSteps) * 100);
+    return undefined;
+}
+
+function renderProgressBar(task: ProgressMonitor | undefined, label = '') {
+    const percent = task && taskPercent(task);
+    if (percent === undefined) return html`<wa-progress-bar indeterminate></wa-progress-bar>`;
+    return html`<wa-progress-bar value="${percent}">${label}</wa-progress-bar>`;
+}
+
 function getProgressDialogContainer(): HTMLElement {
     if (!progressDialogContainer) {
         progressDialogContainer = document.createElement('div');
@@ -153,14 +166,8 @@ function updateProgressDialog(forceOpen = false) {
             
             <div class="progress-dialog-content">
                 ${tasks.map((taskProgress: ProgressMonitor) => {
-                    const hasProgress = taskProgress.progress >= 0 || taskProgress.totalSteps > 0
-                    const progress = taskProgress.progress >= 0
-                        ? taskProgress.progress
-                        : (taskProgress.totalSteps > 0 
-                            ? Math.round((taskProgress.currentStep / taskProgress.totalSteps) * 100)
-                            : 0)
-                    
                     const showSteps = taskProgress.progress < 0 && taskProgress.totalSteps > 0
+                    const steps = showSteps ? `${taskProgress.currentStep}/${taskProgress.totalSteps} - ` : ''
                     
                     return html`
                         <div class="tasitem">
@@ -174,13 +181,7 @@ function updateProgressDialog(forceOpen = false) {
                                 </div>
                             </div>
                             <div class="tasprogress">
-                                ${hasProgress ? html`
-                                    <wa-progress-bar value="${progress}">
-                                        ${showSteps ? `${taskProgress.currentStep}/${taskProgress.totalSteps} - ` : ''}${progress}%
-                                    </wa-progress-bar>
-                                ` : html`
-                                    <wa-progress-bar indeterminate></wa-progress-bar>
-                                `}
+                                ${renderProgressBar(taskProgress, `${steps}${taskPercent(taskProgress)}%`)}
                             </div>
                         </div>
                     `
@@ -264,7 +265,7 @@ export class DocksTasks extends DocksElement {
                     label="${t.ACTIVE_TASKS}"
                 ></wa-spinner>
                 <wa-badge appearance="outlined" variant="neutral" pill>${taskCount}</wa-badge>
-                <div class="tasbar-wrap"><wa-progress-bar indeterminate></wa-progress-bar></div>
+                <div class="tasbar-wrap">${renderProgressBar(taskCount === 1 ? tasks[0] : undefined)}</div>
             </div>
         `;
     }

package/src/core/filesys/common.ts

@@ -784,7 +784,7 @@ export class WorkspaceService {
     public async copyResource(
         src: Resource,
         destDir: Directory,
-        options?: { move?: boolean; newName?: string }
+        options?: { move?: boolean; newName?: string; onFile?: (targetPath: string) => void }
     ): Promise<void> {
         await this.initPromise;
         const workspace = this._currentWorkspace;
@@ -797,6 +797,7 @@ export class WorkspaceService {
         const targetBasePath = destDirPath ? `${destDirPath}/${targetName}` : targetName;
 
         const copyFileToPath = async (file: File, targetPath: string): Promise<void> => {
+            options?.onFile?.(targetPath);
             const contents = await file.getContents({ blob: true });
             const targetFile = await workspace.getResource(targetPath, { create: true }) as File | null;
             if (!targetFile) {