@wailsio/runtime 3.0.0-alpha.7 → 3.0.0-alpha.71

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,80 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+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
+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,94 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+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;
+    };
+}

package/dist/dialogs.js

@@ -0,0 +1,134 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { newRuntimeCaller, objectNames } from "./runtime.js";
+import { nanoid } from './nanoid.js';
+// setup
+window._wails = window._wails || {};
+window._wails.dialogErrorCallback = dialogErrorCallback;
+window._wails.dialogResultCallback = dialogResultCallback;
+const call = newRuntimeCaller(objectNames.Dialog);
+const dialogResponses = new Map();
+// 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;
+/**
+ * Handles the result of a dialog request.
+ *
+ * @param id - The id of the request to handle the result for.
+ * @param data - The result data of the request.
+ * @param isJSON - Indicates whether the data is JSON or not.
+ */
+function dialogResultCallback(id, data, isJSON) {
+    let resolvers = getAndDeleteResponse(id);
+    if (!resolvers) {
+        return;
+    }
+    if (isJSON) {
+        try {
+            resolvers.resolve(JSON.parse(data));
+        }
+        catch (err) {
+            resolvers.reject(new TypeError("could not parse result: " + err.message, { cause: err }));
+        }
+    }
+    else {
+        resolvers.resolve(data);
+    }
+}
+/**
+ * Handles the error from a dialog request.
+ *
+ * @param id - The id of the promise handler.
+ * @param message - An error message.
+ */
+function dialogErrorCallback(id, message) {
+    var _a;
+    (_a = getAndDeleteResponse(id)) === null || _a === void 0 ? void 0 : _a.reject(new window.Error(message));
+}
+/**
+ * Retrieves and removes the response associated with the given ID from the dialogResponses map.
+ *
+ * @param id - The ID of the response to be retrieved and removed.
+ * @returns The response object associated with the given ID, if any.
+ */
+function getAndDeleteResponse(id) {
+    const response = dialogResponses.get(id);
+    dialogResponses.delete(id);
+    return response;
+}
+/**
+ * Generates a unique ID using the nanoid library.
+ *
+ * @returns A unique ID that does not exist in the dialogResponses set.
+ */
+function generateID() {
+    let result;
+    do {
+        result = nanoid();
+    } while (dialogResponses.has(result));
+    return result;
+}
+/**
+ * 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 = {}) {
+    const id = generateID();
+    return new Promise((resolve, reject) => {
+        dialogResponses.set(id, { resolve, reject });
+        call(type, Object.assign({ "dialog-id": id }, options)).catch((err) => {
+            dialogResponses.delete(id);
+            reject(err);
+        });
+    });
+}
+/**
+ * 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,222 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { invoke, IsWindows } 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;
+const buttonsTracked = canTrackButtons();
+window._wails = window._wails || {};
+window._wails.setResizable = (value) => {
+    resizable = value;
+    if (!resizable) {
+        // Stop resizing if in progress.
+        canResize = resizing = false;
+        setResize();
+    }
+};
+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 });
+}
+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()) {
+        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;
+    const rightBorder = (window.outerWidth - event.clientX) < resizeHandleWidth;
+    const leftBorder = event.clientX < resizeHandleWidth;
+    const topBorder = event.clientY < resizeHandleHeight;
+    const bottomBorder = (window.outerHeight - event.clientY) < resizeHandleHeight;
+    // Adjust for corner areas.
+    const rightCorner = (window.outerWidth - event.clientX) < (resizeHandleWidth + cornerExtra);
+    const leftCorner = event.clientX < (resizeHandleWidth + cornerExtra);
+    const topCorner = event.clientY < (resizeHandleHeight + cornerExtra);
+    const bottomCorner = (window.outerHeight - 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();
+}