@wailsio/runtime 3.0.0-alpha.9 → 3.0.0-alpha.94

package/dist/window.js

@@ -0,0 +1,734 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { newRuntimeCaller, objectNames } from "./runtime.js";
+// 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;
+const DisableSizeConstraintsMethod = 3;
+const EnableSizeConstraintsMethod = 4;
+const FocusMethod = 5;
+const ForceReloadMethod = 6;
+const FullscreenMethod = 7;
+const GetScreenMethod = 8;
+const GetZoomMethod = 9;
+const HeightMethod = 10;
+const HideMethod = 11;
+const IsFocusedMethod = 12;
+const IsFullscreenMethod = 13;
+const IsMaximisedMethod = 14;
+const IsMinimisedMethod = 15;
+const MaximiseMethod = 16;
+const MinimiseMethod = 17;
+const NameMethod = 18;
+const OpenDevToolsMethod = 19;
+const RelativePositionMethod = 20;
+const ReloadMethod = 21;
+const ResizableMethod = 22;
+const RestoreMethod = 23;
+const SetPositionMethod = 24;
+const SetAlwaysOnTopMethod = 25;
+const SetBackgroundColourMethod = 26;
+const SetFramelessMethod = 27;
+const SetFullscreenButtonEnabledMethod = 28;
+const SetMaxSizeMethod = 29;
+const SetMinSizeMethod = 30;
+const SetRelativePositionMethod = 31;
+const SetResizableMethod = 32;
+const SetSizeMethod = 33;
+const SetTitleMethod = 34;
+const SetZoomMethod = 35;
+const ShowMethod = 36;
+const SizeMethod = 37;
+const ToggleFullscreenMethod = 38;
+const ToggleMaximiseMethod = 39;
+const ToggleFramelessMethod = 40;
+const UnFullscreenMethod = 41;
+const UnMaximiseMethod = 42;
+const UnMinimiseMethod = 43;
+const WidthMethod = 44;
+const ZoomMethod = 45;
+const ZoomInMethod = 46;
+const ZoomOutMethod = 47;
+const ZoomResetMethod = 48;
+const SnapAssistMethod = 49;
+const FilesDropped = 50;
+const PrintMethod = 51;
+const SetScreenMethod = 52;
+/**
+ * Finds the nearest drop target element by walking up the DOM tree.
+ */
+function getDropTargetElement(element) {
+    if (!element) {
+        return null;
+    }
+    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 {
+    /**
+     * Initialises a window object with the specified name.
+     *
+     * @private
+     * @param name - The name of the target window.
+     */
+    constructor(name = '') {
+        this[callerSym] = newRuntimeCaller(objectNames.Window, name);
+        // bind instance method to make them easily usable in event handlers
+        for (const method of Object.getOwnPropertyNames(Window.prototype)) {
+            if (method !== "constructor"
+                && typeof this[method] === "function") {
+                this[method] = this[method].bind(this);
+            }
+        }
+    }
+    /**
+     * Gets the specified window.
+     *
+     * @param name - The name of the window to get.
+     * @returns The corresponding window object.
+     */
+    Get(name) {
+        return new Window(name);
+    }
+    /**
+     * Returns the absolute position of the window.
+     *
+     * @returns The current absolute position of the window.
+     */
+    Position() {
+        return this[callerSym](PositionMethod);
+    }
+    /**
+     * Centers the window on the screen.
+     */
+    Center() {
+        return this[callerSym](CenterMethod);
+    }
+    /**
+     * Closes the window.
+     */
+    Close() {
+        return this[callerSym](CloseMethod);
+    }
+    /**
+     * Disables min/max size constraints.
+     */
+    DisableSizeConstraints() {
+        return this[callerSym](DisableSizeConstraintsMethod);
+    }
+    /**
+     * Enables min/max size constraints.
+     */
+    EnableSizeConstraints() {
+        return this[callerSym](EnableSizeConstraintsMethod);
+    }
+    /**
+     * Focuses the window.
+     */
+    Focus() {
+        return this[callerSym](FocusMethod);
+    }
+    /**
+     * Forces the window to reload the page assets.
+     */
+    ForceReload() {
+        return this[callerSym](ForceReloadMethod);
+    }
+    /**
+     * Switches the window to fullscreen mode.
+     */
+    Fullscreen() {
+        return this[callerSym](FullscreenMethod);
+    }
+    /**
+     * Returns the screen that the window is on.
+     *
+     * @returns The screen the window is currently on.
+     */
+    GetScreen() {
+        return this[callerSym](GetScreenMethod);
+    }
+    /**
+     * Returns the current zoom level of the window.
+     *
+     * @returns The current zoom level.
+     */
+    GetZoom() {
+        return this[callerSym](GetZoomMethod);
+    }
+    /**
+     * Returns the height of the window.
+     *
+     * @returns The current height of the window.
+     */
+    Height() {
+        return this[callerSym](HeightMethod);
+    }
+    /**
+     * Hides the window.
+     */
+    Hide() {
+        return this[callerSym](HideMethod);
+    }
+    /**
+     * Returns true if the window is focused.
+     *
+     * @returns Whether the window is currently focused.
+     */
+    IsFocused() {
+        return this[callerSym](IsFocusedMethod);
+    }
+    /**
+     * Returns true if the window is fullscreen.
+     *
+     * @returns Whether the window is currently fullscreen.
+     */
+    IsFullscreen() {
+        return this[callerSym](IsFullscreenMethod);
+    }
+    /**
+     * Returns true if the window is maximised.
+     *
+     * @returns Whether the window is currently maximised.
+     */
+    IsMaximised() {
+        return this[callerSym](IsMaximisedMethod);
+    }
+    /**
+     * Returns true if the window is minimised.
+     *
+     * @returns Whether the window is currently minimised.
+     */
+    IsMinimised() {
+        return this[callerSym](IsMinimisedMethod);
+    }
+    /**
+     * Maximises the window.
+     */
+    Maximise() {
+        return this[callerSym](MaximiseMethod);
+    }
+    /**
+     * Minimises the window.
+     */
+    Minimise() {
+        return this[callerSym](MinimiseMethod);
+    }
+    /**
+     * Returns the name of the window.
+     *
+     * @returns The name of the window.
+     */
+    Name() {
+        return this[callerSym](NameMethod);
+    }
+    /**
+     * Opens the development tools pane.
+     */
+    OpenDevTools() {
+        return this[callerSym](OpenDevToolsMethod);
+    }
+    /**
+     * Returns the relative position of the window to the screen.
+     *
+     * @returns The current relative position of the window.
+     */
+    RelativePosition() {
+        return this[callerSym](RelativePositionMethod);
+    }
+    /**
+     * Reloads the page assets.
+     */
+    Reload() {
+        return this[callerSym](ReloadMethod);
+    }
+    /**
+     * Returns true if the window is resizable.
+     *
+     * @returns Whether the window is currently resizable.
+     */
+    Resizable() {
+        return this[callerSym](ResizableMethod);
+    }
+    /**
+     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.
+     */
+    Restore() {
+        return this[callerSym](RestoreMethod);
+    }
+    /**
+     * Sets the absolute position of the window.
+     *
+     * @param x - The desired horizontal absolute position of the window.
+     * @param y - The desired vertical absolute position of the window.
+     */
+    SetPosition(x, y) {
+        return this[callerSym](SetPositionMethod, { x, y });
+    }
+    /**
+     * Sets the window to be always on top.
+     *
+     * @param alwaysOnTop - Whether the window should stay on top.
+     */
+    SetAlwaysOnTop(alwaysOnTop) {
+        return this[callerSym](SetAlwaysOnTopMethod, { alwaysOnTop });
+    }
+    /**
+     * Sets the background colour of the window.
+     *
+     * @param r - The desired red component of the window background.
+     * @param g - The desired green component of the window background.
+     * @param b - The desired blue component of the window background.
+     * @param a - The desired alpha component of the window background.
+     */
+    SetBackgroundColour(r, g, b, a) {
+        return this[callerSym](SetBackgroundColourMethod, { r, g, b, a });
+    }
+    /**
+     * Removes the window frame and title bar.
+     *
+     * @param frameless - Whether the window should be frameless.
+     */
+    SetFrameless(frameless) {
+        return this[callerSym](SetFramelessMethod, { frameless });
+    }
+    /**
+     * Disables the system fullscreen button.
+     *
+     * @param enabled - Whether the fullscreen button should be enabled.
+     */
+    SetFullscreenButtonEnabled(enabled) {
+        return this[callerSym](SetFullscreenButtonEnabledMethod, { enabled });
+    }
+    /**
+     * Sets the maximum size of the window.
+     *
+     * @param width - The desired maximum width of the window.
+     * @param height - The desired maximum height of the window.
+     */
+    SetMaxSize(width, height) {
+        return this[callerSym](SetMaxSizeMethod, { width, height });
+    }
+    /**
+     * Sets the minimum size of the window.
+     *
+     * @param width - The desired minimum width of the window.
+     * @param height - The desired minimum height of the window.
+     */
+    SetMinSize(width, height) {
+        return this[callerSym](SetMinSizeMethod, { width, height });
+    }
+    /**
+     * Sets the relative position of the window to the screen.
+     *
+     * @param x - The desired horizontal relative position of the window.
+     * @param y - The desired vertical relative position of the window.
+     */
+    SetRelativePosition(x, y) {
+        return this[callerSym](SetRelativePositionMethod, { x, y });
+    }
+    /**
+     * Sets whether the window is resizable.
+     *
+     * @param resizable - Whether the window should be resizable.
+     */
+    SetResizable(resizable) {
+        return this[callerSym](SetResizableMethod, { resizable });
+    }
+    /**
+     * Sets the size of the window.
+     *
+     * @param width - The desired width of the window.
+     * @param height - The desired height of the window.
+     */
+    SetSize(width, height) {
+        return this[callerSym](SetSizeMethod, { width, height });
+    }
+    /**
+     * Sets the title of the window.
+     *
+     * @param title - The desired title of the window.
+     */
+    SetTitle(title) {
+        return this[callerSym](SetTitleMethod, { title });
+    }
+    /**
+     * Sets the zoom level of the window.
+     *
+     * @param zoom - The desired zoom level.
+     */
+    SetZoom(zoom) {
+        return this[callerSym](SetZoomMethod, { zoom });
+    }
+    /**
+     * Shows the window.
+     */
+    Show() {
+        return this[callerSym](ShowMethod);
+    }
+    /**
+     * Returns the size of the window.
+     *
+     * @returns The current size of the window.
+     */
+    Size() {
+        return this[callerSym](SizeMethod);
+    }
+    /**
+     * Toggles the window between fullscreen and normal.
+     */
+    ToggleFullscreen() {
+        return this[callerSym](ToggleFullscreenMethod);
+    }
+    /**
+     * Toggles the window between maximised and normal.
+     */
+    ToggleMaximise() {
+        return this[callerSym](ToggleMaximiseMethod);
+    }
+    /**
+     * Toggles the window between frameless and normal.
+     */
+    ToggleFrameless() {
+        return this[callerSym](ToggleFramelessMethod);
+    }
+    /**
+     * Un-fullscreens the window.
+     */
+    UnFullscreen() {
+        return this[callerSym](UnFullscreenMethod);
+    }
+    /**
+     * Un-maximises the window.
+     */
+    UnMaximise() {
+        return this[callerSym](UnMaximiseMethod);
+    }
+    /**
+     * Un-minimises the window.
+     */
+    UnMinimise() {
+        return this[callerSym](UnMinimiseMethod);
+    }
+    /**
+     * Returns the width of the window.
+     *
+     * @returns The current width of the window.
+     */
+    Width() {
+        return this[callerSym](WidthMethod);
+    }
+    /**
+     * Zooms the window.
+     */
+    Zoom() {
+        return this[callerSym](ZoomMethod);
+    }
+    /**
+     * Increases the zoom level of the webview content.
+     */
+    ZoomIn() {
+        return this[callerSym](ZoomInMethod);
+    }
+    /**
+     * Decreases the zoom level of the webview content.
+     */
+    ZoomOut() {
+        return this[callerSym](ZoomOutMethod);
+    }
+    /**
+     * Resets the zoom level of the webview content.
+     */
+    ZoomReset() {
+        return this[callerSym](ZoomResetMethod);
+    }
+    /**
+     * 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 (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);
+        const dropTarget = getDropTargetElement(element);
+        if (!dropTarget) {
+            // Drop was not on a designated drop target - ignore
+            return;
+        }
+        const elementDetails = {
+            id: dropTarget.id,
+            classList: Array.from(dropTarget.classList),
+            attributes: {},
+        };
+        for (let i = 0; i < dropTarget.attributes.length; i++) {
+            const attr = dropTarget.attributes[i];
+            elementDetails.attributes[attr.name] = attr.value;
+        }
+        const payload = {
+            filenames,
+            x,
+            y,
+            elementDetails,
+        };
+        this[callerSym](FilesDropped, payload);
+        // Clean up native drag state after drop
+        cleanupNativeDrag();
+    }
+    /**
+     * Moves the window to the center of the specified screen's work area.
+     *
+     * @param screenID - The ID of the target screen.
+     */
+    SetScreen(screenID) {
+        return this[callerSym](SetScreenMethod, { screenID });
+    }
+    /* Triggers Windows 11 Snap Assist feature (Windows only).
+     * This is equivalent to pressing Win+Z and shows snap layout options.
+     */
+    SnapAssist() {
+        return this[callerSym](SnapAssistMethod);
+    }
+    /**
+     * Opens the print dialog for the window.
+     */
+    Print() {
+        return this[callerSym](PrintMethod);
+    }
+}
+/**
+ * The window within which the script is running.
+ */
+const thisWindow = new Window('');
+/**
+ * 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;
+    docElement.addEventListener('dragenter', (event) => {
+        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) => {
+        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) => {
+        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) => {
+        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);
+            }
+        }
+    }, false);
+}
+// Initialize listeners when the script loads
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+    setupDropTargetListeners();
+}
+export default thisWindow;