@mindexec/cli 0.2.383 → 0.2.385

package/wwwroot/_content/MindExecution.Shared/js/native-drop-handler.js

@@ -0,0 +1,170 @@
+// Filename: native-drop-handler.js
+// JS-side handler for C# native drop processing
+// Bypasses the WebView2 drag-and-drop IPC bottleneck.
+
+(function () {
+    'use strict';
+
+    // ▼▼▼ [Core] Completely block document-level drag events in the native app ▼▼▼
+    // Prevent WebView2 from forwarding drag events into web content.
+    // This removes duplicate drag UI and IPC overhead.
+    if (window.__isNativeApp === true) {
+        const blockDragEvent = (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            e.stopImmediatePropagation();
+            return false;
+        };
+
+        // Block all drag events in the capture phase
+        document.addEventListener('dragenter', blockDragEvent, { capture: true });
+        document.addEventListener('dragover', blockDragEvent, { capture: true });
+        document.addEventListener('dragleave', blockDragEvent, { capture: true });
+        document.addEventListener('drop', blockDragEvent, { capture: true });
+
+        console.log('[NativeDropHandler] Document-level drag events BLOCKED (C# handles drop)');
+    }
+    // ▲▲▲ [Core] ▲▲▲
+
+    /**
+     * Drop handler called from C# NativeDropService.
+     * Files are already copied to the assets folder on the C# side, and we receive the processed metadata.
+     * @param {Array} processedFiles - Array of processed file descriptors
+     * @param {number} screenX - Drop position X (screen coordinates)
+     * @param {number} screenY - Drop position Y (screen coordinates)
+     */
+    async function handleProcessedFiles(processedFiles, screenX, screenY) {
+        console.log(`[NativeDropHandler] Received ${processedFiles.length} processed files at (${screenX}, ${screenY})`);
+
+        if (!window.mindMap) {
+            console.error('[NativeDropHandler] mindMap not initialized');
+            return;
+        }
+
+        // Screen coordinates -> world coordinates
+        const worldCoords = window.mindMap.screenToWorld(screenX, screenY);
+        const worldX = worldCoords[0];
+        const worldY = worldCoords[1];
+
+        console.log(`[NativeDropHandler] World coordinates: (${worldX.toFixed(0)}, ${worldY.toFixed(0)})`);
+
+        const nodesToAdd = [];
+        let index = 0;
+        let nextLeftX = null; // Track left edge so each node starts after the previous width + gap
+
+        for (const file of processedFiles) {
+            let width = 400;
+            let height = 300;
+
+            if (file.contentType === 'image') {
+                try {
+                    const size = await window.mindMap.measureImageSize(file.response);
+                    const fittedSize = window.mindMap.computeImageNodeSize(size[0], size[1], {
+                        gridSnap: 10,
+                        minWidth: 100,
+                        minHeight: 100,
+                        maxWidth: 4000,
+                        maxHeight: 4000,
+                        fallbackWidth: 470,
+                        fallbackHeight: 350
+                    });
+                    width = fittedSize.width;
+                    height = fittedSize.height;
+                } catch (e) {
+                    console.warn(`[NativeDropHandler] Failed to measure image: ${e}`);
+                }
+            } else if (file.contentType === 'pdf') {
+                height = 56; // Fixed height for PDF
+            } else if (file.contentType === 'video') {
+                width = 470;
+                height = 264;
+            } else if (file.contentType === 'text') {
+                // For large text, cap height to a fixed value
+                if (file.isChunkedText) {
+                    height = 400; // Chunk-loading nodes use the default height
+                } else {
+                    // For regular text, adjust height based on content length
+                    height = Math.min(600, 200 + (file.response?.length || 0) / 50);
+                }
+            } else if (file.contentType === 'directory') {
+                width = 200;
+                height = 100;
+            }
+
+            // ▼▼▼ [Fix] Use cumulative X offset for proper spacing ▼▼▼
+            if (nextLeftX === null) {
+                nextLeftX = Math.round((worldX - (width / 2)) / 10) * 10;
+            }
+
+            const nodeX = nextLeftX;
+            const nodeY = worldY + height / 2;
+            nextLeftX = nodeX + width + 30; // previous right edge + fixed gap
+            // ▲▲▲ [Fix] ▲▲▲
+
+            // Base node data
+            const nodeData = {
+                id: file.nodeId || crypto.randomUUID(), // Use nodeId provided by C# (for chunk loading)
+                contentType: file.contentType,
+                prompt: file.fileName,
+                response: file.response,
+                positionX: Math.round(nodeX / 10) * 10, // Grid snap
+                positionY: Math.round(nodeY / 10) * 10,
+                positionZ: 0,
+                width: width,
+                height: height,
+                isLoading: false,
+                metadata: file.metadata || file.Metadata || {},
+                // Chunk-loading related fields
+                isChunkedText: file.isChunkedText || false,
+                totalLineCount: file.totalLineCount || 0,
+                sourceFilePath: file.sourceFilePath || null // [New] Source file path
+            };
+
+            nodesToAdd.push(nodeData);
+            index++;
+        }
+
+        if (nodesToAdd.length > 0) {
+            console.log(`[NativeDropHandler] Adding ${nodesToAdd.length} nodes`);
+            await window.mindMap.addNodes(nodesToAdd);
+
+            // Sync nodes to C# StateService
+            console.log('[NativeDropHandler] Checking dotNetHelper availability...');
+            if (window.dotNetHelper) {
+                try {
+                    const fileNodes = nodesToAdd.map((n, i) => ({
+                        TempId: n.id,
+                        ContentType: n.contentType,
+                        FileName: n.prompt,
+                        Response: n.response,
+                        X: n.positionX,
+                        Y: n.positionY,
+                        Width: n.width,
+                        Height: n.height,
+                        IsLoading: false,
+                        FileIndex: i,
+                        // Pass chunk-loading fields
+                        IsChunkedText: n.isChunkedText || false,
+                        TotalLineCount: n.totalLineCount || 0,
+                        SourceFilePath: n.sourceFilePath || null, // [New] Source file path
+                        Metadata: n.metadata || {}
+                    }));
+
+                    console.log('[NativeDropHandler] Calling AddFileNodesFromJs with:', JSON.stringify(fileNodes.map(f => ({ TempId: f.TempId, ContentType: f.ContentType, IsChunkedText: f.IsChunkedText }))));
+                    const result = await window.dotNetHelper.invokeMethodAsync('AddFileNodesFromJs', fileNodes);
+                    console.log(`[NativeDropHandler] Nodes synced to C#, result:`, result);
+                } catch (ex) {
+                    console.error(`[NativeDropHandler] Failed to sync with C#: ${ex}`);
+                }
+            } else {
+                console.warn('[NativeDropHandler] dotNetHelper not available, nodes not synced to C#');
+            }
+        }
+    }
+
+    window.nativeDropHandler = {
+        handleProcessedFiles: handleProcessedFiles
+    };
+
+    console.log('✓ native-drop-handler.js loaded');
+})();