@wailsio/runtime 3.0.0-alpha.77 → 3.0.0-alpha.79

package/dist/event_types.js

@@ -254,6 +254,5 @@ export const Types = Object.freeze({
         WindowZoomIn: "common:WindowZoomIn",
         WindowZoomOut: "common:WindowZoomOut",
         WindowZoomReset: "common:WindowZoomReset",
-        WindowDropZoneFilesDropped: "common:WindowDropZoneFilesDropped",
     }),
 });

package/dist/index.js

@@ -23,7 +23,7 @@ import * as Flags from "./flags.js";
 import * as Screens from "./screens.js";
 import * as System from "./system.js";
 import * as IOS from "./ios.js";
-import Window from "./window.js";
+import Window, { handleDragEnter, handleDragLeave, handleDragOver } from "./window.js";
 import * as WML from "./wml.js";
 export { Application, Browser, Call, Clipboard, Dialogs, Events, Flags, Screens, System, IOS, Window, WML };
 /**
@@ -35,10 +35,34 @@ export { Create };
 export * from "./cancellable.js";
 // Export transport interfaces and utilities
 export { setTransport, getTransport, objectNames, clientId, } from "./runtime.js";
+import { clientId } from "./runtime.js";
 // Notify backend
 window._wails.invoke = System.invoke;
+window._wails.clientId = clientId;
 // Register platform handlers (internal API)
 // Note: Window is the thisWindow instance (default export from window.ts)
 // Binding ensures 'this' correctly refers to the current window instance
 window._wails.handlePlatformFileDrop = Window.HandlePlatformFileDrop.bind(Window);
+// Linux-specific drag handlers (GTK intercepts DOM drag events)
+window._wails.handleDragEnter = handleDragEnter;
+window._wails.handleDragLeave = handleDragLeave;
+window._wails.handleDragOver = handleDragOver;
 System.invoke("wails:runtime:ready");
+/**
+ * Loads a script from the given URL if it exists.
+ * Uses HEAD request to check existence, then injects a script tag.
+ * Silently ignores if the script doesn't exist.
+ */
+export function loadOptionalScript(url) {
+    return fetch(url, { method: 'HEAD' })
+        .then(response => {
+        if (response.ok) {
+            const script = document.createElement('script');
+            script.src = url;
+            document.head.appendChild(script);
+        }
+    })
+        .catch(() => { }); // Silently ignore - script is optional
+}
+// Load custom.js if available (used by server mode for WebSocket events, etc.)
+loadOptionalScript('/wails/custom.js');

package/dist/system.js

@@ -12,7 +12,6 @@ const call = newRuntimeCaller(objectNames.System);
 const SystemIsDarkMode = 0;
 const SystemEnvironment = 1;
 const SystemCapabilities = 2;
-const ApplicationFilesDroppedWithContext = 100; // New method ID for enriched drop event
 const _invoke = (function () {
     var _a, _b, _c, _d, _e, _f;
     try {
@@ -123,32 +122,3 @@ export function IsDebug() {
     var _a, _b;
     return Boolean((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.Debug);
 }
-/**
- * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).
- * Gathers information about the drop target element and sends it back to the Go backend.
- *
- * @param filenames - An array of file paths (strings) that were dropped.
- * @param x - The x-coordinate of the drop event.
- * @param y - The y-coordinate of the drop event.
- */
-export function HandlePlatformFileDrop(filenames, x, y) {
-    const element = document.elementFromPoint(x, y);
-    const elementId = element ? element.id : '';
-    const classList = element ? Array.from(element.classList) : [];
-    const payload = {
-        filenames,
-        x,
-        y,
-        elementId,
-        classList,
-    };
-    call(ApplicationFilesDroppedWithContext, payload)
-        .then(() => {
-        // Optional: Log success or handle if needed
-        console.log("Platform file drop processed and sent to Go.");
-    })
-        .catch(err => {
-        // Optional: Log error
-        console.error("Error sending platform file drop to Go:", err);
-    });
-}

package/dist/window.js

@@ -8,10 +8,10 @@ The electron alternative for Go
 (c) Lea Anthony 2019-present
 */
 import { newRuntimeCaller, objectNames } from "./runtime.js";
-// NEW: Dropzone constants
-const DROPZONE_ATTRIBUTE = 'data-wails-dropzone';
-const DROPZONE_HOVER_CLASS = 'wails-dropzone-hover'; // User can style this class
-let currentHoveredDropzone = null;
+// Drop target constants
+const DROP_TARGET_ATTRIBUTE = 'data-file-drop-target';
+const DROP_TARGET_ACTIVE_CLASS = 'file-drop-target-active';
+let currentDropTarget = null;
 const PositionMethod = 0;
 const CenterMethod = 1;
 const CloseMethod = 2;
@@ -62,15 +62,98 @@ const ZoomInMethod = 46;
 const ZoomOutMethod = 47;
 const ZoomResetMethod = 48;
 const SnapAssistMethod = 49;
-const WindowDropZoneDropped = 50;
+const FilesDropped = 50;
 const PrintMethod = 51;
-function getDropzoneElement(element) {
+/**
+ * Finds the nearest drop target element by walking up the DOM tree.
+ */
+function getDropTargetElement(element) {
     if (!element) {
         return null;
     }
-    // Allow dropzone attribute to be on the element itself or any parent
-    return element.closest(`[${DROPZONE_ATTRIBUTE}]`);
+    return element.closest(`[${DROP_TARGET_ATTRIBUTE}]`);
+}
+/**
+ * Check if we can use WebView2's postMessageWithAdditionalObjects (Windows)
+ * Also checks that EnableFileDrop is true for this window.
+ */
+function canResolveFilePaths() {
+    var _a, _b, _c, _d;
+    // Must have WebView2's postMessageWithAdditionalObjects API (Windows only)
+    if (((_b = (_a = window.chrome) === null || _a === void 0 ? void 0 : _a.webview) === null || _b === void 0 ? void 0 : _b.postMessageWithAdditionalObjects) == null) {
+        return false;
+    }
+    // Must have EnableFileDrop set to true for this window
+    // This flag is set by the Go backend during runtime initialization
+    return ((_d = (_c = window._wails) === null || _c === void 0 ? void 0 : _c.flags) === null || _d === void 0 ? void 0 : _d.enableFileDrop) === true;
+}
+/**
+ * Send file drop to backend via WebView2 (Windows only)
+ */
+function resolveFilePaths(x, y, files) {
+    var _a, _b;
+    if ((_b = (_a = window.chrome) === null || _a === void 0 ? void 0 : _a.webview) === null || _b === void 0 ? void 0 : _b.postMessageWithAdditionalObjects) {
+        window.chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files);
+    }
+}
+// Native drag state (Linux/macOS intercept DOM drag events)
+let nativeDragActive = false;
+/**
+ * Cleans up native drag state and hover effects.
+ * Called on drop or when drag leaves the window.
+ */
+function cleanupNativeDrag() {
+    nativeDragActive = false;
+    if (currentDropTarget) {
+        currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);
+        currentDropTarget = null;
+    }
+}
+/**
+ * Called from Go when a file drag enters the window on Linux/macOS.
+ */
+function handleDragEnter() {
+    var _a, _b;
+    // Check if file drops are enabled for this window
+    if (((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.flags) === null || _b === void 0 ? void 0 : _b.enableFileDrop) === false) {
+        return; // File drops disabled, don't activate drag state
+    }
+    nativeDragActive = true;
+}
+/**
+ * Called from Go when a file drag leaves the window on Linux/macOS.
+ */
+function handleDragLeave() {
+    cleanupNativeDrag();
+}
+/**
+ * Called from Go during file drag to update hover state on Linux/macOS.
+ * @param x - X coordinate in CSS pixels
+ * @param y - Y coordinate in CSS pixels
+ */
+function handleDragOver(x, y) {
+    var _a, _b;
+    if (!nativeDragActive)
+        return;
+    // Check if file drops are enabled for this window
+    if (((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.flags) === null || _b === void 0 ? void 0 : _b.enableFileDrop) === false) {
+        return; // File drops disabled, don't show hover effects
+    }
+    const targetElement = document.elementFromPoint(x, y);
+    const dropTarget = getDropTargetElement(targetElement);
+    if (currentDropTarget && currentDropTarget !== dropTarget) {
+        currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);
+    }
+    if (dropTarget) {
+        dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);
+        currentDropTarget = dropTarget;
+    }
+    else {
+        currentDropTarget = null;
+    }
 }
+// Export the handlers for use by Go via index.ts
+export { handleDragEnter, handleDragLeave, handleDragOver };
 // Private field names.
 const callerSym = Symbol("caller");
 class Window {
@@ -452,30 +535,32 @@ class Window {
         return this[callerSym](ZoomResetMethod);
     }
     /**
-     * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).
+     * Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop).
      * Gathers information about the drop target element and sends it back to the Go backend.
      *
      * @param filenames - An array of file paths (strings) that were dropped.
-     * @param x - The x-coordinate of the drop event.
-     * @param y - The y-coordinate of the drop event.
+     * @param x - The x-coordinate of the drop event (CSS pixels).
+     * @param y - The y-coordinate of the drop event (CSS pixels).
      */
     HandlePlatformFileDrop(filenames, x, y) {
+        var _a, _b;
+        // Check if file drops are enabled for this window
+        if (((_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.flags) === null || _b === void 0 ? void 0 : _b.enableFileDrop) === false) {
+            return; // File drops disabled, ignore the drop
+        }
         const element = document.elementFromPoint(x, y);
-        // NEW: Check if the drop target is a valid dropzone
-        const dropzoneTarget = getDropzoneElement(element);
-        if (!dropzoneTarget) {
-            console.log(`Wails Runtime: Drop on element (or no element) at ${x},${y} which is not a designated dropzone. Ignoring. Element:`, element);
-            // No need to call backend if not a valid dropzone target
+        const dropTarget = getDropTargetElement(element);
+        if (!dropTarget) {
+            // Drop was not on a designated drop target - ignore
             return;
         }
-        console.log(`Wails Runtime: Drop on designated dropzone. Element at (${x}, ${y}):`, element, 'Effective dropzone:', dropzoneTarget);
         const elementDetails = {
-            id: dropzoneTarget.id,
-            classList: Array.from(dropzoneTarget.classList),
+            id: dropTarget.id,
+            classList: Array.from(dropTarget.classList),
             attributes: {},
         };
-        for (let i = 0; i < dropzoneTarget.attributes.length; i++) {
-            const attr = dropzoneTarget.attributes[i];
+        for (let i = 0; i < dropTarget.attributes.length; i++) {
+            const attr = dropTarget.attributes[i];
             elementDetails.attributes[attr.name] = attr.value;
         }
         const payload = {
@@ -484,7 +569,9 @@ class Window {
             y,
             elementDetails,
         };
-        this[callerSym](WindowDropZoneDropped, payload);
+        this[callerSym](FilesDropped, payload);
+        // Clean up native drag state after drop
+        cleanupNativeDrag();
     }
     /* Triggers Windows 11 Snap Assist feature (Windows only).
      * This is equivalent to pressing Win+Z and shows snap layout options.
@@ -503,75 +590,136 @@ class Window {
  * The window within which the script is running.
  */
 const thisWindow = new Window('');
-// NEW: Global Drag Event Listeners
-function setupGlobalDropzoneListeners() {
+/**
+ * Sets up global drag and drop event listeners for file drops.
+ * Handles visual feedback (hover state) and file drop processing.
+ */
+function setupDropTargetListeners() {
     const docElement = document.documentElement;
-    let dragEnterCounter = 0; // To handle dragenter/dragleave on child elements
+    let dragEnterCounter = 0;
     docElement.addEventListener('dragenter', (event) => {
-        event.preventDefault();
-        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {
-            dragEnterCounter++;
-            const targetElement = document.elementFromPoint(event.clientX, event.clientY);
-            const dropzone = getDropzoneElement(targetElement);
-            // Clear previous hover regardless, then apply new if valid
-            if (currentHoveredDropzone && currentHoveredDropzone !== dropzone) {
-                currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);
-            }
-            if (dropzone) {
-                dropzone.classList.add(DROPZONE_HOVER_CLASS);
-                event.dataTransfer.dropEffect = 'copy';
-                currentHoveredDropzone = dropzone;
-            }
-            else {
-                event.dataTransfer.dropEffect = 'none';
-                currentHoveredDropzone = null; // Ensure it's cleared if no dropzone found
-            }
+        var _a, _b, _c;
+        if (!((_a = event.dataTransfer) === null || _a === void 0 ? void 0 : _a.types.includes('Files'))) {
+            return; // Only handle file drags, let other drags pass through
+        }
+        event.preventDefault(); // Always prevent default to stop browser navigation
+        // On Windows, check if file drops are enabled for this window
+        if (((_c = (_b = window._wails) === null || _b === void 0 ? void 0 : _b.flags) === null || _c === void 0 ? void 0 : _c.enableFileDrop) === false) {
+            event.dataTransfer.dropEffect = 'none'; // Show "no drop" cursor
+            return; // File drops disabled, don't show hover effects
+        }
+        dragEnterCounter++;
+        const targetElement = document.elementFromPoint(event.clientX, event.clientY);
+        const dropTarget = getDropTargetElement(targetElement);
+        // Update hover state
+        if (currentDropTarget && currentDropTarget !== dropTarget) {
+            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);
+        }
+        if (dropTarget) {
+            dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);
+            event.dataTransfer.dropEffect = 'copy';
+            currentDropTarget = dropTarget;
+        }
+        else {
+            event.dataTransfer.dropEffect = 'none';
+            currentDropTarget = null;
         }
     }, false);
     docElement.addEventListener('dragover', (event) => {
-        event.preventDefault(); // Necessary to allow drop
-        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {
-            // No need to query elementFromPoint again if already handled by dragenter correctly
-            // Just ensure dropEffect is continuously set based on currentHoveredDropzone
-            if (currentHoveredDropzone) {
-                // Re-apply class just in case it was removed by some other JS
-                if (!currentHoveredDropzone.classList.contains(DROPZONE_HOVER_CLASS)) {
-                    currentHoveredDropzone.classList.add(DROPZONE_HOVER_CLASS);
-                }
-                event.dataTransfer.dropEffect = 'copy';
-            }
-            else {
-                event.dataTransfer.dropEffect = 'none';
+        var _a, _b, _c;
+        if (!((_a = event.dataTransfer) === null || _a === void 0 ? void 0 : _a.types.includes('Files'))) {
+            return; // Only handle file drags
+        }
+        event.preventDefault(); // Always prevent default to stop browser navigation
+        // On Windows, check if file drops are enabled for this window
+        if (((_c = (_b = window._wails) === null || _b === void 0 ? void 0 : _b.flags) === null || _c === void 0 ? void 0 : _c.enableFileDrop) === false) {
+            event.dataTransfer.dropEffect = 'none'; // Show "no drop" cursor
+            return; // File drops disabled, don't show hover effects
+        }
+        // Update drop target as cursor moves
+        const targetElement = document.elementFromPoint(event.clientX, event.clientY);
+        const dropTarget = getDropTargetElement(targetElement);
+        if (currentDropTarget && currentDropTarget !== dropTarget) {
+            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);
+        }
+        if (dropTarget) {
+            if (!dropTarget.classList.contains(DROP_TARGET_ACTIVE_CLASS)) {
+                dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);
             }
+            event.dataTransfer.dropEffect = 'copy';
+            currentDropTarget = dropTarget;
+        }
+        else {
+            event.dataTransfer.dropEffect = 'none';
+            currentDropTarget = null;
         }
     }, false);
     docElement.addEventListener('dragleave', (event) => {
-        event.preventDefault();
-        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {
-            dragEnterCounter--;
-            // Only remove hover if drag truly left the window or the last dropzone
-            if (dragEnterCounter === 0 || event.relatedTarget === null || (currentHoveredDropzone && !currentHoveredDropzone.contains(event.relatedTarget))) {
-                if (currentHoveredDropzone) {
-                    currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);
-                    currentHoveredDropzone = null;
-                }
-                dragEnterCounter = 0; // Reset counter if it went negative or left window
+        var _a, _b, _c;
+        if (!((_a = event.dataTransfer) === null || _a === void 0 ? void 0 : _a.types.includes('Files'))) {
+            return;
+        }
+        event.preventDefault(); // Always prevent default to stop browser navigation
+        // On Windows, check if file drops are enabled for this window
+        if (((_c = (_b = window._wails) === null || _b === void 0 ? void 0 : _b.flags) === null || _c === void 0 ? void 0 : _c.enableFileDrop) === false) {
+            return;
+        }
+        // On Linux/WebKitGTK and macOS, dragleave fires immediately with relatedTarget=null when native
+        // drag handling is involved. Ignore these spurious events - we'll clean up on drop instead.
+        if (event.relatedTarget === null) {
+            return;
+        }
+        dragEnterCounter--;
+        if (dragEnterCounter === 0 ||
+            (currentDropTarget && !currentDropTarget.contains(event.relatedTarget))) {
+            if (currentDropTarget) {
+                currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);
+                currentDropTarget = null;
             }
+            dragEnterCounter = 0;
         }
     }, false);
     docElement.addEventListener('drop', (event) => {
-        event.preventDefault(); // Prevent default browser file handling
-        dragEnterCounter = 0; // Reset counter
-        if (currentHoveredDropzone) {
-            currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);
-            currentHoveredDropzone = null;
+        var _a, _b, _c;
+        if (!((_a = event.dataTransfer) === null || _a === void 0 ? void 0 : _a.types.includes('Files'))) {
+            return; // Only handle file drops
+        }
+        event.preventDefault(); // Always prevent default to stop browser navigation
+        // On Windows, check if file drops are enabled for this window
+        if (((_c = (_b = window._wails) === null || _b === void 0 ? void 0 : _b.flags) === null || _c === void 0 ? void 0 : _c.enableFileDrop) === false) {
+            return;
+        }
+        dragEnterCounter = 0;
+        if (currentDropTarget) {
+            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);
+            currentDropTarget = null;
+        }
+        // On Windows, handle file drops via JavaScript
+        // On macOS/Linux, native code will call HandlePlatformFileDrop
+        if (canResolveFilePaths()) {
+            const files = [];
+            if (event.dataTransfer.items) {
+                for (const item of event.dataTransfer.items) {
+                    if (item.kind === 'file') {
+                        const file = item.getAsFile();
+                        if (file)
+                            files.push(file);
+                    }
+                }
+            }
+            else if (event.dataTransfer.files) {
+                for (const file of event.dataTransfer.files) {
+                    files.push(file);
+                }
+            }
+            if (files.length > 0) {
+                resolveFilePaths(event.clientX, event.clientY, files);
+            }
         }
-        // The actual drop processing is initiated by the native side calling HandlePlatformFileDrop
-        // HandlePlatformFileDrop will then check if the drop was on a valid zone.
     }, false);
 }
 // Initialize listeners when the script loads
 if (typeof window !== "undefined" && typeof document !== "undefined") {
-    setupGlobalDropzoneListeners();
+    setupDropTargetListeners();
 }
 export default thisWindow;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wailsio/runtime",
   "type": "module",
-  "version": "3.0.0-alpha.77",
+  "version": "3.0.0-alpha.79",
   "description": "Wails Runtime",
   "types": "types/index.d.ts",
   "exports": {

package/types/event_types.d.ts

@@ -243,6 +243,5 @@ export declare const Types: Readonly<{
         WindowZoomIn: "common:WindowZoomIn";
         WindowZoomOut: "common:WindowZoomOut";
         WindowZoomReset: "common:WindowZoomReset";
-        WindowDropZoneFilesDropped: "common:WindowDropZoneFilesDropped";
     }>;
 }>;

package/types/index.d.ts

@@ -22,3 +22,9 @@ export { Application, Browser, Call, Clipboard, Dialogs, Events, Flags, Screens,
 export { Create };
 export * from "./cancellable.js";
 export { setTransport, getTransport, type RuntimeTransport, objectNames, clientId, } from "./runtime.js";
+/**
+ * Loads a script from the given URL if it exists.
+ * Uses HEAD request to check existence, then injects a script tag.
+ * Silently ignores if the script doesn't exist.
+ */
+export declare function loadOptionalScript(url: string): Promise<void>;

package/types/system.d.ts

@@ -81,12 +81,3 @@ export declare function IsARM64(): boolean;
  * @returns True if the app is being run in debug mode.
  */
 export declare function IsDebug(): boolean;
-/**
- * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).
- * Gathers information about the drop target element and sends it back to the Go backend.
- *
- * @param filenames - An array of file paths (strings) that were dropped.
- * @param x - The x-coordinate of the drop event.
- * @param y - The y-coordinate of the drop event.
- */
-export declare function HandlePlatformFileDrop(filenames: string[], x: number, y: number): void;

package/types/window.d.ts

@@ -1,4 +1,19 @@
 import type { Screen } from "./screens.js";
+/**
+ * Called from Go when a file drag enters the window on Linux/macOS.
+ */
+declare function handleDragEnter(): void;
+/**
+ * Called from Go when a file drag leaves the window on Linux/macOS.
+ */
+declare function handleDragLeave(): void;
+/**
+ * Called from Go during file drag to update hover state on Linux/macOS.
+ * @param x - X coordinate in CSS pixels
+ * @param y - Y coordinate in CSS pixels
+ */
+declare function handleDragOver(x: number, y: number): void;
+export { handleDragEnter, handleDragLeave, handleDragOver };
 /**
  * A record describing the position of a window.
  */
@@ -289,12 +304,12 @@ declare class Window {
      */
     ZoomReset(): Promise<void>;
     /**
-     * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).
+     * Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop).
      * Gathers information about the drop target element and sends it back to the Go backend.
      *
      * @param filenames - An array of file paths (strings) that were dropped.
-     * @param x - The x-coordinate of the drop event.
-     * @param y - The y-coordinate of the drop event.
+     * @param x - The x-coordinate of the drop event (CSS pixels).
+     * @param y - The y-coordinate of the drop event (CSS pixels).
      */
     HandlePlatformFileDrop(filenames: string[], x: number, y: number): void;
     SnapAssist(): Promise<void>;