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

package/dist/clipboard.js

@@ -0,0 +1,30 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { newRuntimeCaller, objectNames } from "./runtime.js";
+const call = newRuntimeCaller(objectNames.Clipboard);
+const ClipboardSetText = 0;
+const ClipboardText = 1;
+/**
+ * Sets the text to the Clipboard.
+ *
+ * @param text - The text to be set to the Clipboard.
+ * @return A Promise that resolves when the operation is successful.
+ */
+export function SetText(text) {
+    return call(ClipboardSetText, { text });
+}
+/**
+ * Get the Clipboard text
+ *
+ * @returns A promise that resolves with the text from the Clipboard.
+ */
+export function Text() {
+    return call(ClipboardText);
+}

package/dist/contextmenu.js

@@ -0,0 +1,83 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { newRuntimeCaller, objectNames } from "./runtime.js";
+import { IsDebug } from "./system.js";
+import { eventTarget } from "./utils.js";
+// setup
+import { hasDOM } from "./environment.js";
+if (hasDOM) {
+    window.addEventListener('contextmenu', contextMenuHandler);
+}
+const call = newRuntimeCaller(objectNames.ContextMenu);
+const ContextMenuOpen = 0;
+function openContextMenu(id, x, y, data) {
+    void call(ContextMenuOpen, { id, x, y, data });
+}
+function contextMenuHandler(event) {
+    const target = eventTarget(event);
+    // Check for custom context menu
+    const customContextMenu = window.getComputedStyle(target).getPropertyValue("--custom-contextmenu").trim();
+    if (customContextMenu) {
+        event.preventDefault();
+        const data = window.getComputedStyle(target).getPropertyValue("--custom-contextmenu-data");
+        openContextMenu(customContextMenu, event.clientX, event.clientY, data);
+    }
+    else {
+        processDefaultContextMenu(event, target);
+    }
+}
+/*
+--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea
+--default-contextmenu: show; will always show the default context menu
+--default-contextmenu: hide; will always hide the default context menu
+
+This rule is inherited like normal CSS rules, so nesting works as expected
+*/
+function processDefaultContextMenu(event, target) {
+    // Debug builds always show the menu
+    if (IsDebug()) {
+        return;
+    }
+    // Process default context menu
+    switch (window.getComputedStyle(target).getPropertyValue("--default-contextmenu").trim()) {
+        case 'show':
+            return;
+        case 'hide':
+            event.preventDefault();
+            return;
+    }
+    // Check if contentEditable is true
+    if (target.isContentEditable) {
+        return;
+    }
+    // Check if text has been selected
+    const selection = window.getSelection();
+    const hasSelection = selection && selection.toString().length > 0;
+    if (hasSelection) {
+        for (let i = 0; i < selection.rangeCount; i++) {
+            const range = selection.getRangeAt(i);
+            const rects = range.getClientRects();
+            for (let j = 0; j < rects.length; j++) {
+                const rect = rects[j];
+                if (document.elementFromPoint(rect.left, rect.top) === target) {
+                    return;
+                }
+            }
+        }
+    }
+    // Check if tag is input or textarea.
+    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
+        if (hasSelection || (!target.readOnly && !target.disabled)) {
+            return;
+        }
+    }
+    // hide default context menu
+    event.preventDefault();
+}

package/dist/create.js

@@ -0,0 +1,99 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+/**
+ * Any is a dummy creation function for simple or unknown types.
+ */
+export function Any(source) {
+    return source;
+}
+/**
+ * ByteSlice is a creation function that replaces
+ * null strings with empty strings.
+ */
+export function ByteSlice(source) {
+    return ((source == null) ? "" : source);
+}
+/**
+ * Array takes a creation function for an arbitrary type
+ * and returns an in-place creation function for an array
+ * whose elements are of that type.
+ */
+export function Array(element) {
+    if (element === Any) {
+        return (source) => (source === null ? [] : source);
+    }
+    return (source) => {
+        if (source === null) {
+            return [];
+        }
+        for (let i = 0; i < source.length; i++) {
+            source[i] = element(source[i]);
+        }
+        return source;
+    };
+}
+/**
+ * Map takes creation functions for two arbitrary types
+ * and returns an in-place creation function for an object
+ * whose keys and values are of those types.
+ */
+export function Map(key, value) {
+    if (value === Any) {
+        return (source) => (source === null ? {} : source);
+    }
+    return (source) => {
+        if (source === null) {
+            return {};
+        }
+        for (const key in source) {
+            source[key] = value(source[key]);
+        }
+        return source;
+    };
+}
+/**
+ * Nullable takes a creation function for an arbitrary type
+ * and returns a creation function for a nullable value of that type.
+ */
+export function Nullable(element) {
+    if (element === Any) {
+        return Any;
+    }
+    return (source) => (source === null ? null : element(source));
+}
+/**
+ * Struct takes an object mapping field names to creation functions
+ * and returns an in-place creation function for a struct.
+ */
+export function Struct(createField) {
+    let allAny = true;
+    for (const name in createField) {
+        if (createField[name] !== Any) {
+            allAny = false;
+            break;
+        }
+    }
+    if (allAny) {
+        return Any;
+    }
+    return (source) => {
+        for (const name in createField) {
+            if (name in source) {
+                source[name] = createField[name](source[name]);
+            }
+        }
+        return source;
+    };
+}
+/**
+ * Maps known event names to creation functions for their data types.
+ * Will be monkey-patched by the binding generator.
+ */
+export const Events = {};

package/dist/dialogs.js

@@ -0,0 +1,69 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { newRuntimeCaller, objectNames } from "./runtime.js";
+// setup
+import { hasDOM } from "./environment.js";
+if (hasDOM) {
+    window._wails = window._wails || {};
+}
+const call = newRuntimeCaller(objectNames.Dialog);
+// Define constants from the `methods` object in Title Case
+const DialogInfo = 0;
+const DialogWarning = 1;
+const DialogError = 2;
+const DialogQuestion = 3;
+const DialogOpenFile = 4;
+const DialogSaveFile = 5;
+/**
+ * Presents a dialog of specified type with the given options.
+ *
+ * @param type - Dialog type.
+ * @param options - Options for the dialog.
+ * @returns A promise that resolves with result of dialog.
+ */
+function dialog(type, options = {}) {
+    return call(type, options);
+}
+/**
+ * Presents an info dialog.
+ *
+ * @param options - Dialog options
+ * @returns A promise that resolves with the label of the chosen button.
+ */
+export function Info(options) { return dialog(DialogInfo, options); }
+/**
+ * Presents a warning dialog.
+ *
+ * @param options - Dialog options.
+ * @returns A promise that resolves with the label of the chosen button.
+ */
+export function Warning(options) { return dialog(DialogWarning, options); }
+/**
+ * Presents an error dialog.
+ *
+ * @param options - Dialog options.
+ * @returns A promise that resolves with the label of the chosen button.
+ */
+export function Error(options) { return dialog(DialogError, options); }
+/**
+ * Presents a question dialog.
+ *
+ * @param options - Dialog options.
+ * @returns A promise that resolves with the label of the chosen button.
+ */
+export function Question(options) { return dialog(DialogQuestion, options); }
+export function OpenFile(options) { var _a; return (_a = dialog(DialogOpenFile, options)) !== null && _a !== void 0 ? _a : []; }
+/**
+ * Presents a file selection dialog to pick a file to save.
+ *
+ * @param options - Dialog options.
+ * @returns Selected file, or a blank string if no file has been selected.
+ */
+export function SaveFile(options) { return dialog(DialogSaveFile, options); }

package/dist/drag.js

@@ -0,0 +1,268 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { invoke, IsWindows, IsLinux } from "./system.js";
+import { GetFlag } from "./flags.js";
+import { canTrackButtons, eventTarget } from "./utils.js";
+// Setup
+let canDrag = false;
+let dragging = false;
+let resizable = false;
+let canResize = false;
+let resizing = false;
+let resizeEdge = "";
+let defaultCursor = "auto";
+let buttons = 0;
+import { hasDOM } from "./environment.js";
+let buttonsTracked = false;
+if (hasDOM) {
+    buttonsTracked = canTrackButtons();
+    window._wails = window._wails || {};
+    window._wails.setResizable = (value) => {
+        resizable = value;
+        if (!resizable) {
+            // Stop resizing if in progress.
+            canResize = resizing = false;
+            setResize();
+        }
+    };
+}
+// Defer attaching mouse listeners until we know we're not on mobile.
+let dragInitDone = false;
+function isMobile() {
+    var _a, _b;
+    const os = (_b = (_a = window._wails) === null || _a === void 0 ? void 0 : _a.environment) === null || _b === void 0 ? void 0 : _b.OS;
+    if (os === "ios" || os === "android")
+        return true;
+    // Fallback heuristic if environment not yet set
+    const ua = navigator.userAgent || navigator.vendor || window.opera || "";
+    return /android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(ua);
+}
+function tryInitDragHandlers() {
+    if (dragInitDone)
+        return;
+    if (isMobile())
+        return;
+    window.addEventListener('mousedown', update, { capture: true });
+    window.addEventListener('mousemove', update, { capture: true });
+    window.addEventListener('mouseup', update, { capture: true });
+    for (const ev of ['click', 'contextmenu', 'dblclick']) {
+        window.addEventListener(ev, suppressEvent, { capture: true });
+    }
+    dragInitDone = true;
+}
+if (hasDOM) {
+    // Attempt immediate init (in case environment already present)
+    tryInitDragHandlers();
+    // Also attempt on DOM ready
+    document.addEventListener('DOMContentLoaded', tryInitDragHandlers, { once: true });
+    // As a last resort, poll for environment for a short period
+    let dragEnvPolls = 0;
+    const dragEnvPoll = window.setInterval(() => {
+        if (dragInitDone) {
+            window.clearInterval(dragEnvPoll);
+            return;
+        }
+        tryInitDragHandlers();
+        if (++dragEnvPolls > 100) {
+            window.clearInterval(dragEnvPoll);
+        }
+    }, 50);
+}
+function suppressEvent(event) {
+    // Suppress click events while resizing or dragging.
+    if (dragging || resizing) {
+        event.stopImmediatePropagation();
+        event.stopPropagation();
+        event.preventDefault();
+    }
+}
+// Use constants to avoid comparing strings multiple times.
+const MouseDown = 0;
+const MouseUp = 1;
+const MouseMove = 2;
+function update(event) {
+    // Windows suppresses mouse events at the end of dragging or resizing,
+    // so we need to be smart and synthesize button events.
+    let eventType, eventButtons = event.buttons;
+    switch (event.type) {
+        case 'mousedown':
+            eventType = MouseDown;
+            if (!buttonsTracked) {
+                eventButtons = buttons | (1 << event.button);
+            }
+            break;
+        case 'mouseup':
+            eventType = MouseUp;
+            if (!buttonsTracked) {
+                eventButtons = buttons & ~(1 << event.button);
+            }
+            break;
+        default:
+            eventType = MouseMove;
+            if (!buttonsTracked) {
+                eventButtons = buttons;
+            }
+            break;
+    }
+    let released = buttons & ~eventButtons;
+    let pressed = eventButtons & ~buttons;
+    buttons = eventButtons;
+    // Synthesize a release-press sequence if we detect a press of an already pressed button.
+    if (eventType === MouseDown && !(pressed & event.button)) {
+        released |= (1 << event.button);
+        pressed |= (1 << event.button);
+    }
+    // Suppress all button events during dragging and resizing,
+    // unless this is a mouseup event that is ending a drag action.
+    if (eventType !== MouseMove // Fast path for mousemove
+        && resizing
+        || (dragging
+            && (eventType === MouseDown
+                || event.button !== 0))) {
+        event.stopImmediatePropagation();
+        event.stopPropagation();
+        event.preventDefault();
+    }
+    // Handle releases
+    if (released & 1) {
+        primaryUp(event);
+    }
+    // Handle presses
+    if (pressed & 1) {
+        primaryDown(event);
+    }
+    // Handle mousemove
+    if (eventType === MouseMove) {
+        onMouseMove(event);
+    }
+    ;
+}
+function primaryDown(event) {
+    // Reset readiness state.
+    canDrag = false;
+    canResize = false;
+    // Ignore repeated clicks on macOS and Linux.
+    if (!IsWindows()) {
+        if (event.type === 'mousedown' && event.button === 0 && event.detail !== 1) {
+            return;
+        }
+    }
+    if (resizeEdge) {
+        // Ready to resize if the primary button was pressed for the first time.
+        canResize = true;
+        // Do not start drag operations when on resize edges.
+        return;
+    }
+    // Retrieve target element
+    const target = eventTarget(event);
+    // Ready to drag if the primary button was pressed for the first time on a draggable element.
+    // Ignore clicks on the scrollbar.
+    const style = window.getComputedStyle(target);
+    canDrag = (style.getPropertyValue("--wails-draggable").trim() === "drag"
+        && (event.offsetX - parseFloat(style.paddingLeft) < target.clientWidth
+            && event.offsetY - parseFloat(style.paddingTop) < target.clientHeight));
+}
+function primaryUp(event) {
+    // Stop dragging and resizing.
+    canDrag = false;
+    dragging = false;
+    canResize = false;
+    resizing = false;
+}
+const cursorForEdge = Object.freeze({
+    "se-resize": "nwse-resize",
+    "sw-resize": "nesw-resize",
+    "nw-resize": "nwse-resize",
+    "ne-resize": "nesw-resize",
+    "w-resize": "ew-resize",
+    "n-resize": "ns-resize",
+    "s-resize": "ns-resize",
+    "e-resize": "ew-resize",
+});
+function setResize(edge) {
+    if (edge) {
+        if (!resizeEdge) {
+            defaultCursor = document.body.style.cursor;
+        }
+        document.body.style.cursor = cursorForEdge[edge];
+    }
+    else if (!edge && resizeEdge) {
+        document.body.style.cursor = defaultCursor;
+    }
+    resizeEdge = edge || "";
+}
+function onMouseMove(event) {
+    if (canResize && resizeEdge) {
+        // Start resizing.
+        resizing = true;
+        invoke("wails:resize:" + resizeEdge);
+    }
+    else if (canDrag) {
+        // Start dragging.
+        dragging = true;
+        invoke("wails:drag");
+    }
+    if (dragging || resizing) {
+        // Either drag or resize is ongoing,
+        // reset readiness and stop processing.
+        canDrag = canResize = false;
+        return;
+    }
+    if (!resizable || (!IsWindows() && !(IsLinux() && GetFlag("frameless")))) {
+        if (resizeEdge) {
+            setResize();
+        }
+        return;
+    }
+    const resizeHandleHeight = GetFlag("system.resizeHandleHeight") || 5;
+    const resizeHandleWidth = GetFlag("system.resizeHandleWidth") || 5;
+    // Extra pixels for the corner areas.
+    const cornerExtra = GetFlag("resizeCornerExtra") || 10;
+    // When a scrollbar is present at the window edge it consumes mouse events in that strip.
+    // Shift the effective content edge inward so the resize zone sits just before the scrollbar.
+    const scrollbarWidth = Math.max(0, window.innerWidth - document.documentElement.clientWidth);
+    const scrollbarHeight = Math.max(0, window.innerHeight - document.documentElement.clientHeight);
+    const rightContentEdge = window.innerWidth - scrollbarWidth;
+    const bottomContentEdge = window.innerHeight - scrollbarHeight;
+    const rightBorder = event.clientX < rightContentEdge && (rightContentEdge - event.clientX) < resizeHandleWidth;
+    const leftBorder = event.clientX < resizeHandleWidth;
+    const topBorder = event.clientY < resizeHandleHeight;
+    const bottomBorder = event.clientY < bottomContentEdge && (bottomContentEdge - event.clientY) < resizeHandleHeight;
+    // Adjust for corner areas.
+    const rightCorner = event.clientX < rightContentEdge && (rightContentEdge - event.clientX) < (resizeHandleWidth + cornerExtra);
+    const leftCorner = event.clientX < (resizeHandleWidth + cornerExtra);
+    const topCorner = event.clientY < (resizeHandleHeight + cornerExtra);
+    const bottomCorner = event.clientY < bottomContentEdge && (bottomContentEdge - event.clientY) < (resizeHandleHeight + cornerExtra);
+    if (!leftCorner && !topCorner && !bottomCorner && !rightCorner) {
+        // Optimisation: out of all corner areas implies out of borders.
+        setResize();
+    }
+    // Detect corners.
+    else if (rightCorner && bottomCorner)
+        setResize("se-resize");
+    else if (leftCorner && bottomCorner)
+        setResize("sw-resize");
+    else if (leftCorner && topCorner)
+        setResize("nw-resize");
+    else if (topCorner && rightCorner)
+        setResize("ne-resize");
+    // Detect borders.
+    else if (leftBorder)
+        setResize("w-resize");
+    else if (topBorder)
+        setResize("n-resize");
+    else if (bottomBorder)
+        setResize("s-resize");
+    else if (rightBorder)
+        setResize("e-resize");
+    // Out of border area.
+    else
+        setResize();
+}

package/dist/environment.js

@@ -0,0 +1,17 @@
+/*
+ _     __     _ __
+| |  / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+/**
+ * True when running inside a browser/webview with a DOM available.
+ * False under server-side rendering (e.g. `next build` prerendering),
+ * where application code may import the runtime module even though no
+ * Wails APIs can actually be used (#4679). Modules must not touch
+ * `window`/`document` at import time except behind this guard.
+ */
+export const hasDOM = typeof window !== "undefined" && typeof document !== "undefined";