From b08126d745633e06454d25f5ffdb7dfb54c606f8 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Thu, 28 Dec 2023 18:54:30 +1100 Subject: [PATCH] Radical JS runtime overhaul. New @wailsio/runtime package --- v3/internal/runtime/README.md | 2 +- v3/internal/runtime/Taskfile.yaml | 72 +- v3/internal/runtime/assets.go | 5 + v3/internal/runtime/assets_dev.go | 5 + .../desktop/@wailsio/runtime/application.js | 46 + .../desktop/{ => @wailsio/runtime}/browser.js | 9 +- .../runtime/desktop/@wailsio/runtime/calls.js | 123 +++ .../desktop/@wailsio/runtime/clipboard.js | 35 + .../{ => @wailsio/runtime}/contextmenu.js | 17 +- .../desktop/@wailsio/runtime/dialogs.js | 138 +++ .../desktop/{ => @wailsio/runtime}/drag.js | 86 +- .../desktop/@wailsio/runtime/events.js | 134 +++ .../{ => @wailsio/runtime}/events.test.js | 2 + .../desktop/{ => @wailsio/runtime}/flags.js | 6 + .../runtime/desktop/@wailsio/runtime/index.js | 56 ++ .../{api => @wailsio/runtime}/package.json | 4 +- .../desktop/{ => @wailsio/runtime}/runtime.js | 40 +- .../desktop/{ => @wailsio/runtime}/screens.js | 25 +- .../desktop/@wailsio/runtime/system.js | 118 +++ .../{api => @wailsio/runtime}/types.d.ts | 0 .../desktop/@wailsio/runtime/window.js | 122 +++ .../desktop/{ => @wailsio/runtime}/wml.js | 54 +- v3/internal/runtime/desktop/README.md | 7 +- v3/internal/runtime/desktop/api/README.md | 363 ------- .../runtime/desktop/api/application.js | 35 - v3/internal/runtime/desktop/api/browser.js | 24 - v3/internal/runtime/desktop/api/clipboard.js | 31 - v3/internal/runtime/desktop/api/dialogs.js | 75 -- .../runtime/desktop/api/event_types.js | 178 ---- v3/internal/runtime/desktop/api/events.js | 74 -- v3/internal/runtime/desktop/api/index.js | 32 - v3/internal/runtime/desktop/api/screens.js | 38 - v3/internal/runtime/desktop/api/window.js | 159 --- v3/internal/runtime/desktop/application.js | 43 - v3/internal/runtime/desktop/calls.js | 107 -- v3/internal/runtime/desktop/clipboard.js | 33 - v3/internal/runtime/desktop/dialogs.js | 129 --- v3/internal/runtime/desktop/events.js | 194 ---- v3/internal/runtime/desktop/invoke.js | 20 - v3/internal/runtime/desktop/main.js | 58 +- v3/internal/runtime/desktop/system.js | 25 - v3/internal/runtime/desktop/window.js | 228 ----- v3/internal/runtime/runtime.js | 1 + v3/internal/runtime/runtime_debug.js | 814 +++++++++++++++ v3/internal/runtime/runtime_debug_darwin.go | 8 - .../runtime/runtime_debug_desktop_darwin.js | 873 ---------------- .../runtime/runtime_debug_desktop_linux.js | 873 ---------------- .../runtime/runtime_debug_desktop_windows.js | 935 ------------------ v3/internal/runtime/runtime_debug_linux.go | 8 - v3/internal/runtime/runtime_debug_windows.go | 8 - .../runtime/runtime_production_darwin.go | 8 - .../runtime_production_desktop_darwin.js | 1 - .../runtime_production_desktop_linux.js | 1 - .../runtime_production_desktop_windows.js | 1 - .../runtime/runtime_production_linux.go | 8 - .../runtime/runtime_production_windows.go | 8 - v3/pkg/application/application.go | 7 + v3/pkg/application/environment.go | 6 + v3/pkg/application/messageprocessor.go | 16 +- v3/pkg/application/messageprocessor_system.go | 3 + v3/pkg/application/webview_window.go | 4 +- 61 files changed, 1809 insertions(+), 4726 deletions(-) create mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/application.js rename v3/internal/runtime/desktop/{ => @wailsio/runtime}/browser.js (71%) create mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/calls.js create mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/clipboard.js rename v3/internal/runtime/desktop/{ => @wailsio/runtime}/contextmenu.js (90%) create mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/dialogs.js rename v3/internal/runtime/desktop/{ => @wailsio/runtime}/drag.js (73%) create mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/events.js rename v3/internal/runtime/desktop/{ => @wailsio/runtime}/events.test.js (99%) rename v3/internal/runtime/desktop/{ => @wailsio/runtime}/flags.js (84%) create mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/index.js rename v3/internal/runtime/desktop/{api => @wailsio/runtime}/package.json (82%) rename v3/internal/runtime/desktop/{ => @wailsio/runtime}/runtime.js (81%) rename v3/internal/runtime/desktop/{ => @wailsio/runtime}/screens.js (53%) create mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/system.js rename v3/internal/runtime/desktop/{api => @wailsio/runtime}/types.d.ts (100%) create mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/window.js rename v3/internal/runtime/desktop/{ => @wailsio/runtime}/wml.js (70%) delete mode 100644 v3/internal/runtime/desktop/api/README.md delete mode 100644 v3/internal/runtime/desktop/api/application.js delete mode 100644 v3/internal/runtime/desktop/api/browser.js delete mode 100644 v3/internal/runtime/desktop/api/clipboard.js delete mode 100644 v3/internal/runtime/desktop/api/dialogs.js delete mode 100644 v3/internal/runtime/desktop/api/event_types.js delete mode 100644 v3/internal/runtime/desktop/api/events.js delete mode 100644 v3/internal/runtime/desktop/api/index.js delete mode 100644 v3/internal/runtime/desktop/api/screens.js delete mode 100644 v3/internal/runtime/desktop/api/window.js delete mode 100644 v3/internal/runtime/desktop/application.js delete mode 100644 v3/internal/runtime/desktop/calls.js delete mode 100644 v3/internal/runtime/desktop/clipboard.js delete mode 100644 v3/internal/runtime/desktop/dialogs.js delete mode 100644 v3/internal/runtime/desktop/events.js delete mode 100644 v3/internal/runtime/desktop/invoke.js delete mode 100644 v3/internal/runtime/desktop/system.js delete mode 100644 v3/internal/runtime/desktop/window.js create mode 100644 v3/internal/runtime/runtime.js create mode 100644 v3/internal/runtime/runtime_debug.js delete mode 100644 v3/internal/runtime/runtime_debug_darwin.go delete mode 100644 v3/internal/runtime/runtime_debug_desktop_darwin.js delete mode 100644 v3/internal/runtime/runtime_debug_desktop_linux.js delete mode 100644 v3/internal/runtime/runtime_debug_desktop_windows.js delete mode 100644 v3/internal/runtime/runtime_debug_linux.go delete mode 100644 v3/internal/runtime/runtime_debug_windows.go delete mode 100644 v3/internal/runtime/runtime_production_darwin.go delete mode 100644 v3/internal/runtime/runtime_production_desktop_darwin.js delete mode 100644 v3/internal/runtime/runtime_production_desktop_linux.js delete mode 100644 v3/internal/runtime/runtime_production_desktop_windows.js delete mode 100644 v3/internal/runtime/runtime_production_linux.go delete mode 100644 v3/internal/runtime/runtime_production_windows.go create mode 100644 v3/pkg/application/environment.go diff --git a/v3/internal/runtime/README.md b/v3/internal/runtime/README.md index f6c2f249b34..50d5d5e6327 100644 --- a/v3/internal/runtime/README.md +++ b/v3/internal/runtime/README.md @@ -1,3 +1,3 @@ # Runtime -To rebuild the runtime run `task build-runtime` or if you have Wails v3 CLI, you can use `wails task build-runtime`. +To rebuild the runtime run `task build-runtime` or if you have Wails v3 CLI, you can use `wails3 task build-runtime`. diff --git a/v3/internal/runtime/Taskfile.yaml b/v3/internal/runtime/Taskfile.yaml index 0e0f7c2b622..2fd53fbb9b5 100644 --- a/v3/internal/runtime/Taskfile.yaml +++ b/v3/internal/runtime/Taskfile.yaml @@ -21,82 +21,18 @@ tasks: build:debug: internal: true cmds: - - npx esbuild desktop/main.js --bundle --tree-shaking=true --sourcemap=inline --outfile=runtime_debug_desktop_{{.PLATFORM}}.js --define:DEBUG=true --define:WINDOWS={{.WINDOWS}} --define:DARWIN={{.DARWIN}} --define:LINUX={{.LINUX}} --define:PLATFORM={{.PLATFORM}} --define:INVOKE={{.INVOKE}} - - build:debug:windows: - cmds: - - task: build:debug - vars: - WINDOWS: true - DARWIN: false - LINUX: false - PLATFORM: windows - INVOKE: "chrome.webview.postMessage" - - build:debug:linux: - cmds: - - task: build:debug - vars: - WINDOWS: false - DARWIN: false - LINUX: true - PLATFORM: linux - INVOKE: "webkit.messageHandlers.external.postMessage" - - build:debug:darwin: - cmds: - - task: build:debug - vars: - WINDOWS: false - DARWIN: true - LINUX: false - PLATFORM: darwin - INVOKE: "webkit.messageHandlers.external.postMessage" + - npx esbuild@latest desktop/main.js --bundle --tree-shaking=true --sourcemap=inline --outfile=runtime_debug.js --define:DEBUG=true build:production: internal: true cmds: - - npx esbuild desktop/main.js --bundle --tree-shaking=true --minify --outfile=runtime_production_desktop_{{.PLATFORM}}.js --define:DEBUG=false --define:WINDOWS={{.WINDOWS}} --define:DARWIN={{.DARWIN}} --define:LINUX={{.LINUX}} --define:PLATFORM={{.PLATFORM}} --define:INVOKE={{.INVOKE}} - - build:production:windows: - cmds: - - task: build:production - vars: - WINDOWS: true - DARWIN: false - LINUX: false - PLATFORM: windows - INVOKE: "chrome.webview.postMessage" - - build:production:linux: - cmds: - - task: build:production - vars: - WINDOWS: false - DARWIN: false - LINUX: true - PLATFORM: linux - INVOKE: "webkit.messageHandlers.external.postMessage" - - build:production:darwin: - cmds: - - task: build:production - vars: - WINDOWS: false - DARWIN: true - LINUX: false - PLATFORM: darwin - INVOKE: "webkit.messageHandlers.external.postMessage" + - npx esbuild@latest desktop/main.js --bundle --tree-shaking=true --minify --outfile=runtime.js --drop:console build:all: internal: true deps: - - build:debug:windows - - build:debug:linux - - build:debug:darwin - - build:production:windows - - build:production:linux - - build:production:darwin + - build:debug + - build:production cmds: - cmd: echo "Build Complete." diff --git a/v3/internal/runtime/assets.go b/v3/internal/runtime/assets.go index fb3f09ebe66..5d63f2c4410 100644 --- a/v3/internal/runtime/assets.go +++ b/v3/internal/runtime/assets.go @@ -2,6 +2,11 @@ package runtime +import _ "embed" + +//go:embed runtime.js +var DesktopRuntime []byte + var RuntimeAssetsBundle = &RuntimeAssets{ runtimeDesktopJS: DesktopRuntime, } diff --git a/v3/internal/runtime/assets_dev.go b/v3/internal/runtime/assets_dev.go index c5e5ffe7d5c..ef12f467f98 100644 --- a/v3/internal/runtime/assets_dev.go +++ b/v3/internal/runtime/assets_dev.go @@ -2,6 +2,11 @@ package runtime +import _ "embed" + +//go:embed runtime_debug.js +var DesktopRuntime []byte + var RuntimeAssetsBundle = &RuntimeAssets{ runtimeDesktopJS: DesktopRuntime, } diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/application.js b/v3/internal/runtime/desktop/@wailsio/runtime/application.js new file mode 100644 index 00000000000..88028862cbb --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/application.js @@ -0,0 +1,46 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +/* jshint esversion: 9 */ + +import { newRuntimeCallerWithID, objectNames } from "./runtime"; +const call = newRuntimeCallerWithID(objectNames.Application); + +const HideMethod = 0; +const ShowMethod = 1; +const QuitMethod = 2; + +/** + * Hides a certain method by calling the HideMethod function. + * + * @return {Promise} + * + */ +export function Hide() { + return call(HideMethod); +} + +/** + * Calls the ShowMethod and returns the result. + * + * @return {Promise} + */ +export function Show() { + return call(ShowMethod); +} + +/** + * Calls the QuitMethod to terminate the program. + * + * @return {Promise} + */ +export function Quit() { + return call(QuitMethod); +} diff --git a/v3/internal/runtime/desktop/browser.js b/v3/internal/runtime/desktop/@wailsio/runtime/browser.js similarity index 71% rename from v3/internal/runtime/desktop/browser.js rename to v3/internal/runtime/desktop/@wailsio/runtime/browser.js index 4fa8b66a87b..64d80c9861a 100644 --- a/v3/internal/runtime/desktop/browser.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/browser.js @@ -9,17 +9,16 @@ The electron alternative for Go */ /* jshint esversion: 9 */ - import {newRuntimeCallerWithID, objectNames} from "./runtime"; -let call = newRuntimeCallerWithID(objectNames.Browser); - -let BrowserOpenURL = 0; +const call = newRuntimeCallerWithID(objectNames.Browser, ''); +const BrowserOpenURL = 0; /** * Open a browser window to the given URL * @param {string} url - The URL to open + * @returns {Promise} */ export function OpenURL(url) { - void call(BrowserOpenURL, {url}); + return call(BrowserOpenURL, {url}); } diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/calls.js b/v3/internal/runtime/desktop/@wailsio/runtime/calls.js new file mode 100644 index 00000000000..a4add6bc4f8 --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/calls.js @@ -0,0 +1,123 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +/* jshint esversion: 9 */ +import { newRuntimeCallerWithID, objectNames } from "./runtime"; +import { nanoid } from 'nanoid/non-secure'; + +const CallBinding = 0; +const call = newRuntimeCallerWithID(objectNames.Call, ''); +let callResponses = new Map(); + +window._wails = window._wails || {}; +window._wails.callCallback = resultHandler; +window._wails.callErrorCallback = errorHandler; + +function generateID() { + let result; + do { + result = nanoid(); + } while (callResponses.has(result)); + return result; +} + +export function resultHandler(id, data, isJSON) { + const promiseHandler = getAndDeleteResponse(id); + if (promiseHandler) { + promiseHandler.resolve(isJSON ? JSON.parse(data) : data); + } +} + +export function errorHandler(id, message) { + const promiseHandler = getAndDeleteResponse(id); + if (promiseHandler) { + promiseHandler.reject(message); + } +} + +function getAndDeleteResponse(id) { + const response = callResponses.get(id); + callResponses.delete(id); + return response; +} + +function callBinding(type, options = {}) { + return new Promise((resolve, reject) => { + const id = generateID(); + options["call-id"] = id; + callResponses.set(id, { resolve, reject }); + call(type, options).catch((error) => { + reject(error); + callResponses.delete(id); + }); + }); +} + +/** + * Call method. + * + * @param {Object} options - The options for the method. + * @returns {Object} - The result of the call. + */ +export function Call(options) { + return callBinding(CallBinding, options); +} + +/** + * Executes a method by name. + * + * @param {string} name - The name of the method in the format 'package.struct.method'. + * @param {...*} args - The arguments to pass to the method. + * @throws {Error} If the name is not a string or is not in the correct format. + * @returns {*} The result of the method execution. + */ +export function ByName(name, ...args) { + if (typeof name !== "string" || name.split(".").length !== 3) { + throw new Error("CallByName requires a string in the format 'package.struct.method'"); + } + let [packageName, structName, methodName] = name.split("."); + return callBinding(CallBinding, { + packageName, + structName, + methodName, + args + }); +} + +/** + * Calls a method by its ID with the specified arguments. + * + * @param {string} methodID - The ID of the method to call. + * @param {...*} args - The arguments to pass to the method. + * @return {*} - The result of the method call. + */ +export function ByID(methodID, ...args) { + return callBinding(CallBinding, { + methodID, + args + }); +} + +/** + * Calls a method on a plugin. + * + * @param {string} pluginName - The name of the plugin. + * @param {string} methodName - The name of the method to call. + * @param {...*} args - The arguments to pass to the method. + * @returns {*} - The result of the method call. + */ +export function Plugin(pluginName, methodName, ...args) { + return callBinding(CallBinding, { + packageName: "wails-plugins", + structName: pluginName, + methodName, + args + }); +} diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/clipboard.js b/v3/internal/runtime/desktop/@wailsio/runtime/clipboard.js new file mode 100644 index 00000000000..15cfc518a46 --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/clipboard.js @@ -0,0 +1,35 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +/* jshint esversion: 9 */ + +import {newRuntimeCallerWithID, objectNames} from "./runtime"; + +const call = newRuntimeCallerWithID(objectNames.Clipboard, ''); +const ClipboardSetText = 0; +const ClipboardText = 1; + +/** + * Sets the text to the Clipboard. + * + * @param {string} text - The text to be set to the Clipboard. + * @return {Promise} - A Promise that resolves when the operation is successful. + */ +export function SetText(text) { + return call(ClipboardSetText, {text}); +} + +/** + * Get the Clipboard text + * @returns {Promise} A promise that resolves with the text from the Clipboard. + */ +export function Text() { + return call(ClipboardText); +} diff --git a/v3/internal/runtime/desktop/contextmenu.js b/v3/internal/runtime/desktop/@wailsio/runtime/contextmenu.js similarity index 90% rename from v3/internal/runtime/desktop/contextmenu.js rename to v3/internal/runtime/desktop/@wailsio/runtime/contextmenu.js index 9788a211820..93516543599 100644 --- a/v3/internal/runtime/desktop/contextmenu.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/contextmenu.js @@ -1,8 +1,19 @@ -import {newRuntimeCallerWithID, objectNames} from "./runtime"; +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ -let call = newRuntimeCallerWithID(objectNames.ContextMenu); +/* jshint esversion: 9 */ + +import {newRuntimeCallerWithID, objectNames} from "./runtime"; -let ContextMenuOpen = 0; +const call = newRuntimeCallerWithID(objectNames.ContextMenu, ''); +const ContextMenuOpen = 0; function openContextMenu(id, x, y, data) { void call(ContextMenuOpen, {id, x, y, data}); diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/dialogs.js b/v3/internal/runtime/desktop/@wailsio/runtime/dialogs.js new file mode 100644 index 00000000000..6158484ed9b --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/dialogs.js @@ -0,0 +1,138 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +/* jshint esversion: 9 */ + +/** + * @typedef {import("./types").MessageDialogOptions} MessageDialogOptions + * @typedef {import("./types").OpenDialogOptions} OpenDialogOptions + * @typedef {import("./types").SaveDialogOptions} SaveDialogOptions + */ + +import {newRuntimeCallerWithID, objectNames} from "./runtime"; + +import { nanoid } from 'nanoid/non-secure'; + +// 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; + +const call = newRuntimeCallerWithID(objectNames.Dialog, ''); +const dialogResponses = new Map(); + +/** + * Generates a unique id that is not present in dialogResponses. + * @returns {string} unique id + */ +function generateID() { + let result; + do { + result = nanoid(); + } while (dialogResponses.has(result)); + return result; +} + +/** + * Shows a dialog of specified type with the given options. + * @param {number} type - type of dialog + * @param {object} options - options for the dialog + * @returns {Promise} promise that resolves with result of dialog + */ +function dialog(type, options = {}) { + const id = generateID(); + options["dialog-id"] = id; + return new Promise((resolve, reject) => { + dialogResponses.set(id, {resolve, reject}); + call(type, options).catch((error) => { + reject(error); + dialogResponses.delete(id); + }); + }); +} + +/** + * Handles the callback from a dialog. + * + * @param {string} id - The ID of the dialog response. + * @param {string} data - The data received from the dialog. + * @param {boolean} isJSON - Flag indicating whether the data is in JSON format. + * + * @return {undefined} + */ +export function dialogCallback(id, data, isJSON) { + let p = dialogResponses.get(id); + if (p) { + if (isJSON) { + p.resolve(JSON.parse(data)); + } else { + p.resolve(data); + } + dialogResponses.delete(id); + } +} + +/** + * Callback function for handling errors in dialog. + * + * @param {string} id - The id of the dialog response. + * @param {string} message - The error message. + * + * @return {void} + */ +export function dialogErrorCallback(id, message) { + let p = dialogResponses.get(id); + if (p) { + p.reject(message); + dialogResponses.delete(id); + } +} + + +// Replace `methods` with constants in Title Case + +/** + * @param {MessageDialogOptions} options - Dialog options + * @returns {Promise} - The label of the button pressed + */ +export const Info = (options) => dialog(DialogInfo, options); + +/** + * @param {MessageDialogOptions} options - Dialog options + * @returns {Promise} - The label of the button pressed + */ +export const Warning = (options) => dialog(DialogWarning, options); + +/** + * @param {MessageDialogOptions} options - Dialog options + * @returns {Promise} - The label of the button pressed + */ +export const Error = (options) => dialog(DialogError, options); + +/** + * @param {MessageDialogOptions} options - Dialog options + * @returns {Promise} - The label of the button pressed + */ +export const Question = (options) => dialog(DialogQuestion, options); + +/** + * @param {OpenDialogOptions} options - Dialog options + * @returns {Promise} Returns selected file or list of files. Returns blank string if no file is selected. + */ +export const OpenFile = (options) => dialog(DialogOpenFile, options); + +/** + * @param {SaveDialogOptions} options - Dialog options + * @returns {Promise} Returns the selected file. Returns blank string if no file is selected. + */ +export const SaveFile = (options) => dialog(DialogSaveFile, options); diff --git a/v3/internal/runtime/desktop/drag.js b/v3/internal/runtime/desktop/@wailsio/runtime/drag.js similarity index 73% rename from v3/internal/runtime/desktop/drag.js rename to v3/internal/runtime/desktop/@wailsio/runtime/drag.js index b5dff066672..9a16318f755 100644 --- a/v3/internal/runtime/desktop/drag.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/drag.js @@ -10,26 +10,22 @@ The electron alternative for Go /* jshint esversion: 9 */ -import {invoke} from "./invoke"; +import {invoke, IsWindows} from "./system"; import {GetFlag} from "./flags"; let shouldDrag = false; +let resizeEdge = null; +let resizable = false; +let defaultCursor = "auto"; +window._wails = window._wails || {}; +window._wails.setResizable = setResizable; +window._wails.endDrag = endDrag; export function dragTest(e) { let val = window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region"); - if (val) { - val = val.trim(); - } - - if (val !== "drag") { - return false; - } - - // Only process the primary button - if (e.buttons !== 1) { + if (val && val.trim() !== "drag" || e.buttons !== 1) { return false; } - return e.detail === 1; } @@ -39,40 +35,34 @@ export function setupDrag() { window.addEventListener('mouseup', onMouseUp); } -let resizeEdge = null; -let resizable = false; - export function setResizable(value) { resizable = value; } -function testResize(e) { +export function endDrag() { + document.body.style.cursor = 'default'; + shouldDrag = false; +} + +function testResize() { if( resizeEdge ) { - invoke("resize:" + resizeEdge); + invoke(`resize:${resizeEdge}`); return true } return false; } function onMouseDown(e) { - - // Check for resizing on Windows - if( WINDOWS ) { - if (testResize()) { - return; - } - } - if (dragTest(e)) { - // Ignore drag on scrollbars - if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) { - return; - } - shouldDrag = true; - } else { - shouldDrag = false; + if(IsWindows() && testResize() || dragTest(e)) { + shouldDrag = !!isValidDrag(e); } } +function isValidDrag(e) { + // Ignore drag on scrollbars + return !(e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight); +} + function onMouseUp(e) { let mousePressed = e.buttons !== undefined ? e.buttons : e.which; if (mousePressed > 0) { @@ -80,35 +70,27 @@ function onMouseUp(e) { } } -export function endDrag() { - document.body.style.cursor = 'default'; - shouldDrag = false; -} - -function setResize(cursor) { - document.documentElement.style.cursor = cursor || defaultCursor; +function setResize(cursor = defaultCursor) { + document.documentElement.style.cursor = cursor; resizeEdge = cursor; } function onMouseMove(e) { - if (shouldDrag) { - shouldDrag = false; - let mousePressed = e.buttons !== undefined ? e.buttons : e.which; - if (mousePressed > 0) { - invoke("drag"); - } - return; + shouldDrag = checkDrag(e); + if (IsWindows() && resizable) { + handleResize(e); } +} - if (WINDOWS) { - if (resizable) { - handleResize(e); - } +function checkDrag(e) { + let mousePressed = e.buttons !== undefined ? e.buttons : e.which; + if(shouldDrag && mousePressed > 0) { + invoke("drag"); + return false; } + return shouldDrag; } -let defaultCursor = "auto"; - function handleResize(e) { let resizeHandleHeight = GetFlag("system.resizeHandleHeight") || 5; let resizeHandleWidth = GetFlag("system.resizeHandleWidth") || 5; diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/events.js b/v3/internal/runtime/desktop/@wailsio/runtime/events.js new file mode 100644 index 00000000000..f76d2347949 --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/events.js @@ -0,0 +1,134 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +/* jshint esversion: 9 */ + +/** + * @typedef {import("./types").WailsEvent} WailsEvent + */ +import {newRuntimeCallerWithID, objectNames} from "./runtime"; + +const call = newRuntimeCallerWithID(objectNames.Events, ''); +const EmitMethod = 0; +const eventListeners = new Map(); + +class Listener { + constructor(eventName, callback, maxCallbacks) { + this.eventName = eventName; + this.maxCallbacks = maxCallbacks || -1; + this.Callback = (data) => { + callback(data); + if (this.maxCallbacks === -1) return false; + this.maxCallbacks -= 1; + return this.maxCallbacks === 0; + }; + } +} + +export class WailsEvent { + constructor(name, data = null) { + this.name = name; + this.data = data; + } +} + + +window._wails = window._wails || {}; +window._wails.dispatchWailsEvent = dispatchWailsEvent; + +export function dispatchWailsEvent(event) { + let listeners = eventListeners.get(event.name); + if (listeners) { + let toRemove = listeners.filter(listener => { + let remove = listener.Callback(event); + if (remove) return true; + }); + if (toRemove.length > 0) { + listeners = listeners.filter(l => !toRemove.includes(l)); + if (listeners.length === 0) eventListeners.delete(event.name); + else eventListeners.set(event.name, listeners); + } + } +} + +/** + * Register a callback function to be called multiple times for a specific event. + * + * @param {string} eventName - The name of the event to register the callback for. + * @param {function} callback - The callback function to be called when the event is triggered. + * @param {number} maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called. + * + @return {function} - A function that, when called, will unregister the callback from the event. + */ +export function OnMultiple(eventName, callback, maxCallbacks) { + let listeners = eventListeners.get(eventName) || []; + const thisListener = new Listener(eventName, callback, maxCallbacks); + listeners.push(thisListener); + eventListeners.set(eventName, listeners); + return () => listenerOff(thisListener); +} + +/** + * Registers a callback function to be executed when the specified event occurs. + * + * @param {string} eventName - The name of the event. + * @param {function} callback - The callback function to be executed. It takes no parameters. + * @return {function} - A function that, when called, will unregister the callback from the event. */ +export function On(eventName, callback) { return OnMultiple(eventName, callback, -1); } + +/** + * Registers a callback function to be executed only once for the specified event. + * + * @param {string} eventName - The name of the event. + * @param {function} callback - The function to be executed when the event occurs. + * @return {void@return {function} - A function that, when called, will unregister the callback from the event. + */ +export function Once(eventName, callback) { return OnMultiple(eventName, callback, 1); } + +/** + * Removes the specified listener from the event listeners collection. + * If all listeners for the event are removed, the event key is deleted from the collection. + * + * @param {Object} listener - The listener to be removed. + */ +function listenerOff(listener) { + const eventName = listener.eventName; + let listeners = eventListeners.get(eventName).filter(l => l !== listener); + if (listeners.length === 0) eventListeners.delete(eventName); + else eventListeners.set(eventName, listeners); +} + + +/** + * Removes event listeners for the specified event names. + * + * @param {string} eventName - The name of the event to remove listeners for. + * @param {...string} additionalEventNames - Additional event names to remove listeners for. + * @return {undefined} + */ +export function Off(eventName, ...additionalEventNames) { + let eventsToRemove = [eventName, ...additionalEventNames]; + eventsToRemove.forEach(eventName => eventListeners.delete(eventName)); +} +/** + * Removes all event listeners. + * + * @function OffAll + * @returns {void} + */ +export function OffAll() { eventListeners.clear(); } + +/** + * Emits an event using the given event name. + * + * @param {WailsEvent} event - The name of the event to emit. + * @returns {any} - The result of the emitted event. + */ +export function Emit(event) { return call(EmitMethod, event); } diff --git a/v3/internal/runtime/desktop/events.test.js b/v3/internal/runtime/desktop/@wailsio/runtime/events.test.js similarity index 99% rename from v3/internal/runtime/desktop/events.test.js rename to v3/internal/runtime/desktop/@wailsio/runtime/events.test.js index a9b67965718..ed11c33ed40 100644 --- a/v3/internal/runtime/desktop/events.test.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/events.test.js @@ -1,4 +1,6 @@ + import { On, Off, OffAll, OnMultiple, WailsEvent, dispatchWailsEvent, eventListeners, Once } from './events'; + import { expect, describe, it, vi, afterEach, beforeEach } from 'vitest'; afterEach(() => { diff --git a/v3/internal/runtime/desktop/flags.js b/v3/internal/runtime/desktop/@wailsio/runtime/flags.js similarity index 84% rename from v3/internal/runtime/desktop/flags.js rename to v3/internal/runtime/desktop/@wailsio/runtime/flags.js index 4157115d3fa..153373f534a 100644 --- a/v3/internal/runtime/desktop/flags.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/flags.js @@ -52,6 +52,12 @@ function getValueFromMap(keyString) { return value; } +/** + * Retrieves the value associated with the specified key from the flag map. + * + * @param {string} keyString - The key to retrieve the value for. + * @return {*} - The value associated with the specified key. + */ export function GetFlag(keyString) { return getValueFromMap(keyString); } diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/index.js b/v3/internal/runtime/desktop/@wailsio/runtime/index.js new file mode 100644 index 00000000000..f2f9825a73e --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/index.js @@ -0,0 +1,56 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +import {setupContextMenus} from "./contextmenu"; +import {setupDrag} from "./drag"; +import {reloadWML} from "./wml"; +import {Emit, Off, OffAll, On, Once, OnMultiple, WailsEvent} from './events'; +import {ByID, ByName, Plugin} from "./calls"; +import {Error, Info, OpenFile, Question, SaveFile, Warning} from "./dialogs"; + +export * as Application from "./application"; +export * as Browser from "./browser"; +export * as Clipboard from "./clipboard"; +export * as ContextMenu from "./contextmenu"; +export * as Flags from "./flags"; +export * as Runtime from "./runtime"; +export * as Screens from "./screens"; +export * as System from "./system"; +export * as Window from "./window"; + +export const Events = { + On, + Off, + OnMultiple, + WailsEvent, + OffAll, + Emit, + Once + +} + +export const Call = { + Plugin, + ByID, + ByName +} + +export const Dialogs = { + Info, + Error, + OpenFile, Question, Warning, SaveFile +} + +setupContextMenus(); +setupDrag(); + +document.addEventListener("DOMContentLoaded", function () { + reloadWML(); +}); diff --git a/v3/internal/runtime/desktop/api/package.json b/v3/internal/runtime/desktop/@wailsio/runtime/package.json similarity index 82% rename from v3/internal/runtime/desktop/api/package.json rename to v3/internal/runtime/desktop/@wailsio/runtime/package.json index 7335f6b13e0..85b60557cdd 100644 --- a/v3/internal/runtime/desktop/api/package.json +++ b/v3/internal/runtime/desktop/@wailsio/runtime/package.json @@ -1,7 +1,7 @@ { - "name": "@wailsapp/api", + "name": "@wailsio/runtime", "version": "3.0.0-alpha.4", - "description": "Wails Runtime API", + "description": "Wails Runtime", "main": "index.js", "repository": { "type": "git", diff --git a/v3/internal/runtime/desktop/runtime.js b/v3/internal/runtime/desktop/@wailsio/runtime/runtime.js similarity index 81% rename from v3/internal/runtime/desktop/runtime.js rename to v3/internal/runtime/desktop/@wailsio/runtime/runtime.js index 5ebb4e8c47f..6d05d1ab965 100644 --- a/v3/internal/runtime/desktop/runtime.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/runtime.js @@ -12,6 +12,7 @@ The electron alternative for Go import { nanoid } from 'nanoid/non-secure'; const runtimeURL = window.location.origin + "/wails/runtime"; + // Object Names export const objectNames = { Call: 0, @@ -27,6 +28,33 @@ export const objectNames = { } export let clientId = nanoid(); +/** + * Creates a runtime caller function that invokes a specified method on a given object within a specified window context. + * + * @param {Object} object - The object on which the method is to be invoked. + * @param {string} windowName - The name of the window context in which the method should be called. + * @returns {Function} A runtime caller function that takes the method name and optionally arguments and invokes the method within the specified window context. + */ +export function newRuntimeCaller(object, windowName) { + return function (method, args=null) { + return runtimeCall(object + "." + method, windowName, args); + }; +} + +/** + * Creates a new runtime caller with specified ID. + * + * @param {object} object - The object to invoke the method on. + * @param {string} windowName - The name of the window. + * @return {Function} - The new runtime caller function. + */ +export function newRuntimeCallerWithID(object, windowName) { + return function (method, args=null) { + return runtimeCallWithID(object, method, windowName, args); + }; +} + + function runtimeCall(method, windowName, args) { let url = new URL(runtimeURL); if( method ) { @@ -61,12 +89,6 @@ function runtimeCall(method, windowName, args) { }); } -export function newRuntimeCaller(object, windowName) { - return function (method, args=null) { - return runtimeCall(object + "." + method, windowName, args); - }; -} - function runtimeCallWithID(objectID, method, windowName, args) { let url = new URL(runtimeURL); url.searchParams.append("object", objectID); @@ -98,9 +120,3 @@ function runtimeCallWithID(objectID, method, windowName, args) { .catch(error => reject(error)); }); } - -export function newRuntimeCallerWithID(object, windowName) { - return function (method, args=null) { - return runtimeCallWithID(object, method, windowName, args); - }; -} diff --git a/v3/internal/runtime/desktop/screens.js b/v3/internal/runtime/desktop/@wailsio/runtime/screens.js similarity index 53% rename from v3/internal/runtime/desktop/screens.js rename to v3/internal/runtime/desktop/@wailsio/runtime/screens.js index 07b28a2efd2..1abcb76d503 100644 --- a/v3/internal/runtime/desktop/screens.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/screens.js @@ -15,34 +15,31 @@ The electron alternative for Go */ import {newRuntimeCallerWithID, objectNames} from "./runtime"; +const call = newRuntimeCallerWithID(objectNames.Screens, ''); -let call = newRuntimeCallerWithID(objectNames.Screens); - -let ScreensGetAll = 0; -let ScreensGetPrimary = 1; -let ScreensGetCurrent = 2; +const getAll = 0; +const getPrimary = 1; +const getCurrent = 2; /** * Gets all screens. - * @returns {Promise} + * @returns {Promise} A promise that resolves to an array of Screen objects. */ export function GetAll() { - return call(ScreensGetAll); + return call(getAll); } - /** * Gets the primary screen. - * @returns {Promise} + * @returns {Promise} A promise that resolves to the primary screen. */ export function GetPrimary() { - return call(ScreensGetPrimary); + return call(getPrimary); } - /** * Gets the current active screen. - * @returns {Promise} - * @constructor + * + * @returns {Promise} A promise that resolves with the current active screen. */ export function GetCurrent() { - return call(ScreensGetCurrent); + return call(getCurrent); } \ No newline at end of file diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/system.js b/v3/internal/runtime/desktop/@wailsio/runtime/system.js new file mode 100644 index 00000000000..73fd5281b1a --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/system.js @@ -0,0 +1,118 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +/* jshint esversion: 9 */ + +import {newRuntimeCallerWithID, objectNames} from "./runtime"; +let call = newRuntimeCallerWithID(objectNames.System, ''); +const systemIsDarkMode = 0; +const environment = 1; + +/** + * @function + * Retrieves the system dark mode status. + * @returns {Promise} - A promise that resolves to a boolean value indicating if the system is in dark mode. + */ +export function IsDarkMode() { + return call(systemIsDarkMode); +} + + +/** + * Fetches the capabilities of the application from the server. + * + * @async + * @function Capabilities + * @returns {Promise} A promise that resolves to an object containing the capabilities. + */ +export async function Capabilities() { + let response = fetch("/wails/capabilities"); + return response.json(); +} + +/** + * @typedef {object} EnvironmentInfo + * @property {string} OS - The operating system in use. + * @property {string} Arch - The architecture of the system. + */ + +/** + * @function + * Retrieves environment details. + * @returns {Promise} - A promise that resolves to an object containing OS and system architecture. + */ +export function Environment() { + return call(environment); +} + +export let invoke = null; +let environmentCache = null; + +Environment() + .then(result => { + environmentCache = result; + invoke = IsWindows() ? window.chrome.webview.postMessage : window.webkit.messageHandlers.external.postMessage; + }) + .catch(error => { + console.error(`Error getting Environment: ${error}`); + }); + +/** + * Checks if the current operating system is Windows. + * + * @return {boolean} True if the operating system is Windows, otherwise false. + */ +export function IsWindows() { + return environmentCache.OS === "windows"; +} + +/** + * Checks if the current operating system is Linux. + * + * @returns {boolean} Returns true if the current operating system is Linux, false otherwise. + */ +export function IsLinux() { + return environmentCache.OS === "linux"; +} + +/** + * Checks if the current environment is a macOS operating system. + * + * @returns {boolean} True if the environment is macOS, false otherwise. + */ +export function IsMac() { + return environmentCache.OS === "darwin"; +} + +/** + * Checks if the current environment architecture is AMD64. + * @returns {boolean} True if the current environment architecture is AMD64, false otherwise. + */ +export function IsAMD64() { + return environmentCache.Arch === "amd64"; +} + +/** + * Checks if the current architecture is ARM. + * + * @returns {boolean} True if the current architecture is ARM, false otherwise. + */ +export function IsARM() { + return environmentCache.Arch === "arm"; +} + +/** + * Checks if the current environment is ARM64 architecture. + * + * @returns {boolean} - Returns true if the environment is ARM64 architecture, otherwise returns false. + */ +export function IsARM64() { + return environmentCache.Arch === "arm64"; +} diff --git a/v3/internal/runtime/desktop/api/types.d.ts b/v3/internal/runtime/desktop/@wailsio/runtime/types.d.ts similarity index 100% rename from v3/internal/runtime/desktop/api/types.d.ts rename to v3/internal/runtime/desktop/@wailsio/runtime/types.d.ts diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/window.js b/v3/internal/runtime/desktop/@wailsio/runtime/window.js new file mode 100644 index 00000000000..e125c057d95 --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/window.js @@ -0,0 +1,122 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +/* jshint esversion: 9 */ + +/** + * @typedef {import("../api/types").Size} Size + * @typedef {import("../api/types").Position} Position + * @typedef {import("../api/types").Screen} Screen + */ + +import {newRuntimeCallerWithID, objectNames} from "./runtime"; + +const center = 0; +const setTitle = 1; +const fullscreen = 2; +const unFullscreen = 3; +const setSize = 4; +const size = 5; +const setMaxSize = 6; +const setMinSize = 7; +const setAlwaysOnTop = 8; +const setRelativePosition = 9; +const relativePosition = 10; +const screen = 11; +const hide = 12; +const maximise = 13; +const unMaximise = 14; +const toggleMaximise = 15; +const minimise = 16; +const unMinimise = 17; +const restore = 18; +const show = 19; +const close = 20; +const setBackgroundColour = 21; +const setResizable = 22; +const width = 23; +const height = 24; +const zoomIn = 25; +const zoomOut = 26; +const zoomReset = 27; +const getZoomLevel = 28; +const setZoomLevel = 29; + +const thisWindow = newRuntimeCallerWithID(objectNames.Window, ''); + +function createWindow(call) { + return { + Get: (windowName) => createWindow(newRuntimeCallerWithID(objectNames.Window, windowName)), + Center: () => call(center), + SetTitle: (title) => call(setTitle, {title}), + Fullscreen: () => call(fullscreen), + UnFullscreen: () => call(unFullscreen), + SetSize: (width, height) => call(setSize, {width, height}), + Size: () => call(size), + SetMaxSize: (width, height) => call(setMaxSize, {width, height}), + SetMinSize: (width, height) => call(setMinSize, {width, height}), + SetAlwaysOnTop: (onTop) => call(setAlwaysOnTop, {alwaysOnTop: onTop}), + SetRelativePosition: (x, y) => call(setRelativePosition, {x, y}), + RelativePosition: () => call(relativePosition), + Screen: () => call(screen), + Hide: () => call(hide), + Maximise: () => call(maximise), + UnMaximise: () => call(unMaximise), + ToggleMaximise: () => call(toggleMaximise), + Minimise: () => call(minimise), + UnMinimise: () => call(unMinimise), + Restore: () => call(restore), + Show: () => call(show), + Close: () => call(close), + SetBackgroundColour: (r, g, b, a) => call(setBackgroundColour, {r, g, b, a}), + SetResizable: (resizable) => call(setResizable, {resizable}), + Width: () => call(width), + Height: () => call(height), + ZoomIn: () => call(zoomIn), + ZoomOut: () => call(zoomOut), + ZoomReset: () => call(zoomReset), + GetZoomLevel: () => call(getZoomLevel), + SetZoomLevel: (zoomLevel) => call(setZoomLevel, {zoomLevel}), + }; +} + +/** + * Gets the specified window. + * + * @param {string} windowName - The name of the window to get. + * @return {Object} - The specified window object. + */ +export function Get(windowName) { + return createWindow(newRuntimeCallerWithID(objectNames.Window, windowName)); +} + +/** + * Returns a map of all methods in the current window. + * @returns {Map} - A map of window methods. + */ +export function WindowMethods(targetWindow) { + // Create a new map to store methods + let result = new Map(); + + // Iterate over all properties of the window object + for (let method in targetWindow) { + // Check if the property is indeed a method (function) + if(typeof targetWindow[method] === 'function') { + // Add the method to the map + result.set(method, targetWindow[method]); + } + + } + // Return the map of window methods + return result; +} +export default { + ...Get('') +} diff --git a/v3/internal/runtime/desktop/wml.js b/v3/internal/runtime/desktop/@wailsio/runtime/wml.js similarity index 70% rename from v3/internal/runtime/desktop/wml.js rename to v3/internal/runtime/desktop/@wailsio/runtime/wml.js index 32b7bc36f0a..c8c2e715d03 100644 --- a/v3/internal/runtime/desktop/wml.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/wml.js @@ -1,12 +1,26 @@ import {Emit, WailsEvent} from "./events"; import {Question} from "./dialogs"; - +import {WindowMethods, Get} from "./window"; + +/** + * Sends an event with the given name and optional data. + * + * @param {string} eventName - The name of the event to send. + * @param {any} [data=null] - Optional data to send along with the event. + * + * @return {void} + */ function sendEvent(eventName, data=null) { let event = new WailsEvent(eventName, data); Emit(event); } +/** + * Adds event listeners to elements with `wml-event` attribute. + * + * @return {void} + */ function addWMLEventListeners() { const elements = document.querySelectorAll('[wml-event]'); elements.forEach(function (element) { @@ -25,8 +39,8 @@ function addWMLEventListeners() { } sendEvent(eventType); }; - // Remove existing listeners + // Remove existing listeners element.removeEventListener(trigger, callback); // Add new listener @@ -34,13 +48,30 @@ function addWMLEventListeners() { }); } +/** + * Calls a method on the window object. + * + * @param {string} method - The name of the method to call on the window object. + * + * @return {void} + */ function callWindowMethod(method) { - if (wails.Window[method] === undefined) { + // TODO: Make this a parameter! + let windowName = ''; + let targetWindow = Get(''); + let methodMap = WindowMethods(targetWindow); + if (!methodMap.has(method)) { console.log("Window method " + method + " not found"); } - wails.Window[method](); + methodMap.get(method)(); } +/** + * Adds window listeners for elements with the 'wml-window' attribute. + * Removes any existing listeners before adding new ones. + * + * @return {void} + */ function addWMLWindowListeners() { const elements = document.querySelectorAll('[wml-window]'); elements.forEach(function (element) { @@ -68,6 +99,15 @@ function addWMLWindowListeners() { }); } +/** + * Adds a listener to elements with the 'wml-openurl' attribute. + * When the specified trigger event is fired on any of these elements, + * the listener will open the URL specified by the 'wml-openurl' attribute. + * If a 'wml-confirm' attribute is provided, a confirmation dialog will be displayed, + * and the URL will only be opened if the user confirms. + * + * @return {void} + */ function addWMLOpenBrowserListener() { const elements = document.querySelectorAll('[wml-openurl]'); elements.forEach(function (element) { @@ -95,7 +135,13 @@ function addWMLOpenBrowserListener() { }); } +/** + * Reloads the WML page by adding necessary event listeners and browser listeners. + * + * @return {void} + */ export function reloadWML() { + console.log("Reloading WML"); addWMLEventListeners(); addWMLWindowListeners(); addWMLOpenBrowserListener(); diff --git a/v3/internal/runtime/desktop/README.md b/v3/internal/runtime/desktop/README.md index 78ef387e4b7..3da6938c409 100644 --- a/v3/internal/runtime/desktop/README.md +++ b/v3/internal/runtime/desktop/README.md @@ -1,3 +1,8 @@ # README -After updating any files in this directory, you must run `wails task build:runtime` to regenerate the compiled JS. \ No newline at end of file +The `main.js` file in this directory is the entrypoint for the `runtime.js` file that may be +loaded at runtime. This will add `window.wails` and `window._wails` to the global scope. + +NOTE: It is preferable to use the `@wailsio/runtime` package to use the runtime. + +After updating any files in this directory, you must run `wails3 task build:runtime` to regenerate the compiled JS. \ No newline at end of file diff --git a/v3/internal/runtime/desktop/api/README.md b/v3/internal/runtime/desktop/api/README.md deleted file mode 100644 index 0cb344e83a0..00000000000 --- a/v3/internal/runtime/desktop/api/README.md +++ /dev/null @@ -1,363 +0,0 @@ -# Wails API - -This package provides a typed Javascript API for Wails applications. - -It provides methods for the following components: - -- [Dialog](#dialog) -- [Events](#events) -- [Window](#window) -- [Plugin](#plugin) -- [Screens](#screens) -- [Application](#application) - -## Installation - -In your Wails application, run the following command in the frontend project directory: - -```bash -npm install -D @wailsapp/api -``` - -## Usage - -Import the API into your application: - -```javascript -import * as Wails from "@wailsapp/api"; -``` - -Then use the API components: - -```javascript -function showDialog() { - Wails.Dialog.Info({ - Title: "Hello", - }).then((result) => { - console.log("Result: " + result); - }); -} -``` - -Individual components of the API can also be imported directly. - - - -## API - -### Dialog - -The Dialog API provides access to the native system dialogs. - -```javascript -import { Dialog } from "@wailsapp/api"; - -function example() { - Dialog.Info({ - Title: "Hello", - }).then((result) => { - console.log("Result: " + result); - }); -} -``` - -#### Message Dialogs - -Message dialogs are used to display a message to the user. -They can be used to display information, errors, warnings and questions. -Each method returns the button that was pressed by the user. - -- `Info(options: MessageDialogOptions): Promise` -- `Error(options: MessageDialogOptions): Promise` -- `Warning(options: MessageDialogOptions): Promise` -- `Question(options: MessageDialogOptions): Promise` - -#### Open Dialog - -The Open Dialog is used to open a file or directory. It returns the path of the selected file or directory. -If the `AllowsMultipleFiles` option is set, multiple files or directories can be selected and are returned -as an array of file paths. - -- `Open(options: OpenDialogOptions): Promise` - -#### Save Dialog - -The Save Dialog is used to save a file. It returns the path of the selected file. - -- `Save(options: SaveDialogOptions): Promise` - -### Events - -The Events API provides access to the Wails event system. This is a global event system -that can be used to send events between the Go and Javascript. -Events are available to every window in a multi-window application. -These API methods are specific to the window in which they are called in. - -```javascript -import { Events } from "@wailsapp/api"; - -function example() { - // Emit an event - Events.Emit("myevent", { message: "Hello" }); - - // Subscribe to an event - let unsub = Events.On("otherEvent", (data) => { - console.log("Received event: " + data); - }); - - // Unsubscribe from the event - unsub(); -} -``` - -#### Emit - -Emit an event with optional data. - -- `Emit(eventName: string, data?: any): void` - -#### Subscribe - -Three methods are provided to subscribe to an event: - - `On(eventName: string, callback: (data: any) => void): () => void` - Subscribe to all events of the given name - - `Once(eventName: string, callback: (data: any) => void): () => void` - Subscribe to one event of the given name - - `OnMultiple(eventName: string, callback: (data: any) => void, count: number): () => void` - Subscribe to multiple events of the given name - -The callback will be called when the event is emitted. -The returned function can be called to unsubscribe from the event. - -#### Unsubscribe - -As well as unsubscribing from a single event, you can unsubscribe from events of a given name or all events. - - `Off(eventName: string, additionalEventNames: ...string): void` - Unsubscribe from all events of the given name(s) - - `OffAll(): void` - Unsubscribe all events - -### Window - -The Window API provides a number of methods that interact with the window in which the API is called. - -- `Center: (void) => void` - Center the window -- `SetTitle: (title) => void` - Set the window title -- `Fullscreen: () => void` - Set the window to fullscreen -- `UnFullscreen: () => void` - Restore a fullscreen window -- `SetSize: (width: number, height: number) => void` - Set the window size -- `Size: () => Size` - Get the window size -- `SetMaxSize: (width, height) => void` - Set the window maximum size -- `SetMinSize: (width, height) => void` - Set the window minimum size -- `SetAlwaysOnTop: (onTop) => void` - Set window to be always on top -- `SetPosition: (x, y) => void` - Set the window position -- `Position: () => Position` - Get the window position -- `SetResizable: (resizable) => void` - Set whether the window is resizable -- `Screen: () => Screen` - Get information about the screen the window is on -- `Hide: () => void` - Hide the window -- `Show: () => void` - Show the window -- `Maximise: () => void` - Maximise the window -- `Close: () => void` - Close the window -- `ToggleMaximise: () => void` - Toggle the window maximise state -- `UnMaximise: () => void` - UnMaximise the window -- `Minimise: () => void` - Minimise the window -- `UnMinimise: () => void` - UnMinimise the window -- `SetBackgroundColour: (r, g, b, a) => void` - Set the background colour of the window - -### Plugin - -The Plugin API provides access to the Wails plugin system. -This method provides the ability to call a plugin method from the frontend. - -```javascript - -import { Plugin } from "@wailsapp/api"; - -function example() { - // Call a plugin method - Plugin.Call("myplugin", "MyMethod", { message: "Hello" }).then((result) => { - console.log("Result: " + result); - }); -} -``` - -### Screens - -The Screens API provides access to the Wails screen system. - -```javascript -import { Screens } from "@wailsapp/api"; - -function example() { - // Get all attatched screens - Screens.GetAll().then((screens) => { - console.log("Screens: " + screens); - }); - - // Get the primary screen - Screens.GetPrimary().then((screen) => { - console.log("Primary screen: " + screen); - }); - - // Get the screen the window is on - Screens.GetCurrent().then((screen) => { - console.log("Window screen: " + screen); - }); -} -``` - -- `GetAll: () => Promise` - Get all screens -- `GetPrimary: () => Promise` - Get the primary screen -- `GetCurrent: () => Promise` - Get the screen the window is on - -### Application - -The Application API provides access to the Wails application system. - -```javascript -import { Application } from "@wailsapp/api"; - -function example() { - - // Hide the application - Application.Hide(); - - // Shopw the application - Application.Show(); - - // Quit the application - Application.Quit(); - -} -``` - -- `Hide: () => void` - Hide the application -- `Show: () => void` - Show the application -- `Quit: () => void` - Quit the application - -## Types - -This is a comprehensive list of types used by the Wails API. - -```typescript - -export interface Button { - // The label of the button - Label?: string; - // True if this button is the cancel button (selected when pressing escape) - IsCancel?: boolean; - // True if this button is the default button (selected when pressing enter) - IsDefault?: boolean; -} - -interface MessageDialogOptions { - // The title for the dialog - Title?: string; - // The message to display - Message?: string; - // The buttons to use on the dialog - Buttons?: Button[]; -} - -export interface OpenFileDialogOptions { - // Allows the user to be able to select directories - CanChooseDirectories?: boolean; - // Allows the user to be able to select files - CanChooseFiles?: boolean; - // Provide an option to create directories in the dialog - CanCreateDirectories?: boolean; - // Makes the dialog show hidden files - ShowHiddenFiles?: boolean; - // Whether the dialog should follow filesystem aliases - ResolvesAliases?: boolean; - // Allow the user to select multiple files or directories - AllowsMultipleSelection?: boolean; - // Hide the extension when showing the filename - HideExtension?: boolean; - // Allow the user to select files where the system hides their extensions - CanSelectHiddenExtension?: boolean; - // Treats file packages as directories, e.g. .app on macOS - TreatsFilePackagesAsDirectories?: boolean; - // Allows selection of filetypes not specified in the filters - AllowsOtherFiletypes?: boolean; - // The file filters to use in the dialog - Filters?: FileFilter[]; - // The title of the dialog - Title?: string; - // The message to display - Message?: string; - // The label for the select button - ButtonText?: string; - // The default directory to open the dialog in - Directory?: string; -} -export interface FileFilter { - // The display name for the filter, e.g. "Text Files" - DisplayName?: string; - // The pattern to use for the filter, e.g. "*.txt;*.md" - Pattern?: string; -} -export interface SaveFileDialogOptions { - // Provide an option to create directories in the dialog - CanCreateDirectories?: boolean; - // Makes the dialog show hidden files - ShowHiddenFiles?: boolean; - // Allow the user to select files where the system hides their extensions - CanSelectHiddenExtension?: boolean; - // Allows selection of filetypes not specified in the filters - AllowOtherFiletypes?: boolean; - // Hide the extension when showing the filename - HideExtension?: boolean; - // Treats file packages as directories, e.g. .app on macOS - TreatsFilePackagesAsDirectories?: boolean; - // The message to show in the dialog - Message?: string; - // The default directory to open the dialog in - Directory?: string; - // The default filename to use in the dialog - Filename?: string; - // The label for the select button - ButtonText?: string; -} - -export interface Screen { - // The screen ID - Id: string; - // The screen name - Name: string; - // The screen scale. 1 = standard resolution, 2: 2x retina, etc. - Scale: number; - // The X position of the screen - X: number; - // The Y position of the screen - Y: number; - // The width and height of the screen - Size: Size; - // The bounds of the screen - Bounds: Rect; - // The work area of the screen - WorkArea: Rect; - // True if this is the primary screen - IsPrimary: boolean; - // The rotation of the screen - Rotation: number; -} -export interface Rect { - X: number; - Y: number; - Width: number; - Height: number; -} - -export interface WailsEvent { - // The name of the event - Name: string; - // The data associated with the event - Data?: any; -} - -export interface Size { - Width: number; - Height: number; -} -export interface Position { - X: number; - Y: number; -} - -``` \ No newline at end of file diff --git a/v3/internal/runtime/desktop/api/application.js b/v3/internal/runtime/desktop/api/application.js deleted file mode 100644 index 9ae7ba915f8..00000000000 --- a/v3/internal/runtime/desktop/api/application.js +++ /dev/null @@ -1,35 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -/** - * The Application API provides methods to interact with the application. - */ -export const Application = { - /** - * Hides the application - */ - Hide: () => { - return wails.Application.Hide(); - }, - /** - * Shows the application - */ - Show: () => { - return wails.Application.Show(); - }, - /** - * Quits the application - */ - Quit: () => { - return wails.Application.Quit(); - }, -}; diff --git a/v3/internal/runtime/desktop/api/browser.js b/v3/internal/runtime/desktop/api/browser.js deleted file mode 100644 index 3807ad640b6..00000000000 --- a/v3/internal/runtime/desktop/api/browser.js +++ /dev/null @@ -1,24 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -/** - * The Browser API provides methods to interact with the system browser. - */ -export const Browser = { - /** - * Opens a browser window to the given URL - * @returns {Promise} - */ - OpenURL: (url) => { - return wails.Browser.OpenURL(url); - }, -}; diff --git a/v3/internal/runtime/desktop/api/clipboard.js b/v3/internal/runtime/desktop/api/clipboard.js deleted file mode 100644 index c18dcbe1869..00000000000 --- a/v3/internal/runtime/desktop/api/clipboard.js +++ /dev/null @@ -1,31 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -/** - * The Clipboard API provides methods to interact with the system clipboard. - */ -export const Clipboard = { - /** - * Gets the text from the clipboard - * @returns {Promise} - */ - Text: () => { - return wails.Clipboard.Text(); - }, - /** - * Sets the text on the clipboard - * @param {string} text - text to set in the clipboard - */ - SetText: (text) => { - return wails.Clipboard.SetText(text); - }, -}; diff --git a/v3/internal/runtime/desktop/api/dialogs.js b/v3/internal/runtime/desktop/api/dialogs.js deleted file mode 100644 index e129c31dab1..00000000000 --- a/v3/internal/runtime/desktop/api/dialogs.js +++ /dev/null @@ -1,75 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -/** - * @typedef {import("./types").MessageDialogOptions} MessageDialogOptions - * @typedef {import("./types").OpenDialogOptions} OpenDialogOptions - * @typedef {import("./types").SaveDialogOptions} SaveDialogOptions - */ -/** - * The Dialog API provides methods to interact with system dialogs. - */ -export const Dialog = { - /** - * Shows an info dialog - * @param {MessageDialogOptions} options - options for the dialog - * @returns {Promise} - */ - Info: (options) => { - return wails.Dialog.Info(options); - }, - /** - * Shows a warning dialog - * @param {MessageDialogOptions} options - options for the dialog - * @returns {Promise} - */ - Warning: (options) => { - return wails.Dialog.Warning(options); - }, - /** - * Shows an error dialog - * @param {MessageDialogOptions} options - options for the dialog - * @returns {Promise} - */ - Error: (options) => { - return wails.Dialog.Error(options); - }, - - /** - * Shows a question dialog - * @param {MessageDialogOptions} options - options for the dialog - * @returns {Promise} - */ - Question: (options) => { - return wails.Dialog.Question(options); - }, - - /** - * Shows a file open dialog and returns the files selected by the user. - * A blank string indicates that the dialog was cancelled. - * @param {OpenDialogOptions} options - options for the dialog - * @returns {Promise|Promise} - */ - OpenFile: (options) => { - return wails.Dialog.OpenFile(options); - }, - - /** - * Shows a file save dialog and returns the filename given by the user. - * A blank string indicates that the dialog was cancelled. - * @param {SaveDialogOptions} options - options for the dialog - * @returns {Promise} - */ - SaveFile: (options) => { - return wails.Dialog.SaveFile(options); - }, -}; \ No newline at end of file diff --git a/v3/internal/runtime/desktop/api/event_types.js b/v3/internal/runtime/desktop/api/event_types.js deleted file mode 100644 index 6ba09269b1b..00000000000 --- a/v3/internal/runtime/desktop/api/event_types.js +++ /dev/null @@ -1,178 +0,0 @@ - -export const EventTypes = { - Windows: { - SystemThemeChanged: "windows:SystemThemeChanged", - APMPowerStatusChange: "windows:APMPowerStatusChange", - APMSuspend: "windows:APMSuspend", - APMResumeAutomatic: "windows:APMResumeAutomatic", - APMResumeSuspend: "windows:APMResumeSuspend", - APMPowerSettingChange: "windows:APMPowerSettingChange", - ApplicationStarted: "windows:ApplicationStarted", - WebViewNavigationCompleted: "windows:WebViewNavigationCompleted", - WindowInactive: "windows:WindowInactive", - WindowActive: "windows:WindowActive", - WindowClickActive: "windows:WindowClickActive", - WindowMaximise: "windows:WindowMaximise", - WindowUnMaximise: "windows:WindowUnMaximise", - WindowFullscreen: "windows:WindowFullscreen", - WindowUnFullscreen: "windows:WindowUnFullscreen", - WindowRestore: "windows:WindowRestore", - WindowMinimise: "windows:WindowMinimise", - WindowUnMinimise: "windows:WindowUnMinimise", - WindowClose: "windows:WindowClose", - WindowSetFocus: "windows:WindowSetFocus", - WindowKillFocus: "windows:WindowKillFocus", - WindowDragDrop: "windows:WindowDragDrop", - WindowDragEnter: "windows:WindowDragEnter", - WindowDragLeave: "windows:WindowDragLeave", - WindowDragOver: "windows:WindowDragOver", - }, - Mac: { - ApplicationDidBecomeActive: "mac:ApplicationDidBecomeActive", - ApplicationDidChangeBackingProperties: "mac:ApplicationDidChangeBackingProperties", - ApplicationDidChangeEffectiveAppearance: "mac:ApplicationDidChangeEffectiveAppearance", - ApplicationDidChangeIcon: "mac:ApplicationDidChangeIcon", - ApplicationDidChangeOcclusionState: "mac:ApplicationDidChangeOcclusionState", - ApplicationDidChangeScreenParameters: "mac:ApplicationDidChangeScreenParameters", - ApplicationDidChangeStatusBarFrame: "mac:ApplicationDidChangeStatusBarFrame", - ApplicationDidChangeStatusBarOrientation: "mac:ApplicationDidChangeStatusBarOrientation", - ApplicationDidFinishLaunching: "mac:ApplicationDidFinishLaunching", - ApplicationDidHide: "mac:ApplicationDidHide", - ApplicationDidResignActiveNotification: "mac:ApplicationDidResignActiveNotification", - ApplicationDidUnhide: "mac:ApplicationDidUnhide", - ApplicationDidUpdate: "mac:ApplicationDidUpdate", - ApplicationWillBecomeActive: "mac:ApplicationWillBecomeActive", - ApplicationWillFinishLaunching: "mac:ApplicationWillFinishLaunching", - ApplicationWillHide: "mac:ApplicationWillHide", - ApplicationWillResignActive: "mac:ApplicationWillResignActive", - ApplicationWillTerminate: "mac:ApplicationWillTerminate", - ApplicationWillUnhide: "mac:ApplicationWillUnhide", - ApplicationWillUpdate: "mac:ApplicationWillUpdate", - ApplicationDidChangeTheme: "mac:ApplicationDidChangeTheme!", - ApplicationShouldHandleReopen: "mac:ApplicationShouldHandleReopen!", - WindowDidBecomeKey: "mac:WindowDidBecomeKey", - WindowDidBecomeMain: "mac:WindowDidBecomeMain", - WindowDidBeginSheet: "mac:WindowDidBeginSheet", - WindowDidChangeAlpha: "mac:WindowDidChangeAlpha", - WindowDidChangeBackingLocation: "mac:WindowDidChangeBackingLocation", - WindowDidChangeBackingProperties: "mac:WindowDidChangeBackingProperties", - WindowDidChangeCollectionBehavior: "mac:WindowDidChangeCollectionBehavior", - WindowDidChangeEffectiveAppearance: "mac:WindowDidChangeEffectiveAppearance", - WindowDidChangeOcclusionState: "mac:WindowDidChangeOcclusionState", - WindowDidChangeOrderingMode: "mac:WindowDidChangeOrderingMode", - WindowDidChangeScreen: "mac:WindowDidChangeScreen", - WindowDidChangeScreenParameters: "mac:WindowDidChangeScreenParameters", - WindowDidChangeScreenProfile: "mac:WindowDidChangeScreenProfile", - WindowDidChangeScreenSpace: "mac:WindowDidChangeScreenSpace", - WindowDidChangeScreenSpaceProperties: "mac:WindowDidChangeScreenSpaceProperties", - WindowDidChangeSharingType: "mac:WindowDidChangeSharingType", - WindowDidChangeSpace: "mac:WindowDidChangeSpace", - WindowDidChangeSpaceOrderingMode: "mac:WindowDidChangeSpaceOrderingMode", - WindowDidChangeTitle: "mac:WindowDidChangeTitle", - WindowDidChangeToolbar: "mac:WindowDidChangeToolbar", - WindowDidChangeVisibility: "mac:WindowDidChangeVisibility", - WindowDidDeminiaturize: "mac:WindowDidDeminiaturize", - WindowDidEndSheet: "mac:WindowDidEndSheet", - WindowDidEnterFullScreen: "mac:WindowDidEnterFullScreen", - WindowDidEnterVersionBrowser: "mac:WindowDidEnterVersionBrowser", - WindowDidExitFullScreen: "mac:WindowDidExitFullScreen", - WindowDidExitVersionBrowser: "mac:WindowDidExitVersionBrowser", - WindowDidExpose: "mac:WindowDidExpose", - WindowDidFocus: "mac:WindowDidFocus", - WindowDidMiniaturize: "mac:WindowDidMiniaturize", - WindowDidMove: "mac:WindowDidMove", - WindowDidOrderOffScreen: "mac:WindowDidOrderOffScreen", - WindowDidOrderOnScreen: "mac:WindowDidOrderOnScreen", - WindowDidResignKey: "mac:WindowDidResignKey", - WindowDidResignMain: "mac:WindowDidResignMain", - WindowDidResize: "mac:WindowDidResize", - WindowDidUpdate: "mac:WindowDidUpdate", - WindowDidUpdateAlpha: "mac:WindowDidUpdateAlpha", - WindowDidUpdateCollectionBehavior: "mac:WindowDidUpdateCollectionBehavior", - WindowDidUpdateCollectionProperties: "mac:WindowDidUpdateCollectionProperties", - WindowDidUpdateShadow: "mac:WindowDidUpdateShadow", - WindowDidUpdateTitle: "mac:WindowDidUpdateTitle", - WindowDidUpdateToolbar: "mac:WindowDidUpdateToolbar", - WindowDidUpdateVisibility: "mac:WindowDidUpdateVisibility", - WindowShouldClose: "mac:WindowShouldClose!", - WindowWillBecomeKey: "mac:WindowWillBecomeKey", - WindowWillBecomeMain: "mac:WindowWillBecomeMain", - WindowWillBeginSheet: "mac:WindowWillBeginSheet", - WindowWillChangeOrderingMode: "mac:WindowWillChangeOrderingMode", - WindowWillClose: "mac:WindowWillClose", - WindowWillDeminiaturize: "mac:WindowWillDeminiaturize", - WindowWillEnterFullScreen: "mac:WindowWillEnterFullScreen", - WindowWillEnterVersionBrowser: "mac:WindowWillEnterVersionBrowser", - WindowWillExitFullScreen: "mac:WindowWillExitFullScreen", - WindowWillExitVersionBrowser: "mac:WindowWillExitVersionBrowser", - WindowWillFocus: "mac:WindowWillFocus", - WindowWillMiniaturize: "mac:WindowWillMiniaturize", - WindowWillMove: "mac:WindowWillMove", - WindowWillOrderOffScreen: "mac:WindowWillOrderOffScreen", - WindowWillOrderOnScreen: "mac:WindowWillOrderOnScreen", - WindowWillResignMain: "mac:WindowWillResignMain", - WindowWillResize: "mac:WindowWillResize", - WindowWillUnfocus: "mac:WindowWillUnfocus", - WindowWillUpdate: "mac:WindowWillUpdate", - WindowWillUpdateAlpha: "mac:WindowWillUpdateAlpha", - WindowWillUpdateCollectionBehavior: "mac:WindowWillUpdateCollectionBehavior", - WindowWillUpdateCollectionProperties: "mac:WindowWillUpdateCollectionProperties", - WindowWillUpdateShadow: "mac:WindowWillUpdateShadow", - WindowWillUpdateTitle: "mac:WindowWillUpdateTitle", - WindowWillUpdateToolbar: "mac:WindowWillUpdateToolbar", - WindowWillUpdateVisibility: "mac:WindowWillUpdateVisibility", - WindowWillUseStandardFrame: "mac:WindowWillUseStandardFrame", - MenuWillOpen: "mac:MenuWillOpen", - MenuDidOpen: "mac:MenuDidOpen", - MenuDidClose: "mac:MenuDidClose", - MenuWillSendAction: "mac:MenuWillSendAction", - MenuDidSendAction: "mac:MenuDidSendAction", - MenuWillHighlightItem: "mac:MenuWillHighlightItem", - MenuDidHighlightItem: "mac:MenuDidHighlightItem", - MenuWillDisplayItem: "mac:MenuWillDisplayItem", - MenuDidDisplayItem: "mac:MenuDidDisplayItem", - MenuWillAddItem: "mac:MenuWillAddItem", - MenuDidAddItem: "mac:MenuDidAddItem", - MenuWillRemoveItem: "mac:MenuWillRemoveItem", - MenuDidRemoveItem: "mac:MenuDidRemoveItem", - MenuWillBeginTracking: "mac:MenuWillBeginTracking", - MenuDidBeginTracking: "mac:MenuDidBeginTracking", - MenuWillEndTracking: "mac:MenuWillEndTracking", - MenuDidEndTracking: "mac:MenuDidEndTracking", - MenuWillUpdate: "mac:MenuWillUpdate", - MenuDidUpdate: "mac:MenuDidUpdate", - MenuWillPopUp: "mac:MenuWillPopUp", - MenuDidPopUp: "mac:MenuDidPopUp", - MenuWillSendActionToItem: "mac:MenuWillSendActionToItem", - MenuDidSendActionToItem: "mac:MenuDidSendActionToItem", - WebViewDidStartProvisionalNavigation: "mac:WebViewDidStartProvisionalNavigation", - WebViewDidReceiveServerRedirectForProvisionalNavigation: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation", - WebViewDidFinishNavigation: "mac:WebViewDidFinishNavigation", - WebViewDidCommitNavigation: "mac:WebViewDidCommitNavigation", - WindowFileDraggingEntered: "mac:WindowFileDraggingEntered", - WindowFileDraggingPerformed: "mac:WindowFileDraggingPerformed", - WindowFileDraggingExited: "mac:WindowFileDraggingExited", - }, - Common: { - ApplicationStarted: "common:ApplicationStarted", - WindowMaximise: "common:WindowMaximise", - WindowUnMaximise: "common:WindowUnMaximise", - WindowFullscreen: "common:WindowFullscreen", - WindowUnFullscreen: "common:WindowUnFullscreen", - WindowRestore: "common:WindowRestore", - WindowMinimise: "common:WindowMinimise", - WindowUnMinimise: "common:WindowUnMinimise", - WindowClosing: "common:WindowClosing", - WindowZoom: "common:WindowZoom", - WindowZoomIn: "common:WindowZoomIn", - WindowZoomOut: "common:WindowZoomOut", - WindowZoomReset: "common:WindowZoomReset", - WindowFocus: "common:WindowFocus", - WindowLostFocus: "common:WindowLostFocus", - WindowShow: "common:WindowShow", - WindowHide: "common:WindowHide", - WindowDPIChanged: "common:WindowDPIChanged", - WindowFilesDropped: "common:WindowFilesDropped", - ThemeChanged: "common:ThemeChanged", - }, -}; diff --git a/v3/internal/runtime/desktop/api/events.js b/v3/internal/runtime/desktop/api/events.js deleted file mode 100644 index 208177978c9..00000000000 --- a/v3/internal/runtime/desktop/api/events.js +++ /dev/null @@ -1,74 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -import {EventTypes} from './event_types'; - -/** - * The Events API provides methods to interact with the event system. - */ -export const Events = { - /** - * Emit an event - * @param {string} name - * @param {any=} data - */ - Emit: (name, data) => { - return wails.Events.Emit(name, data); - }, - /** - * Subscribe to an event - * @param {string} name - name of the event - * @param {(any) => void} callback - callback to call when the event is emitted - @returns {function()} unsubscribeMethod - method to unsubscribe from the event - */ - On: (name, callback) => { - return wails.Events.On(name, callback); - }, - /** - * Subscribe to an event once - * @param {string} name - name of the event - * @param {(any) => void} callback - callback to call when the event is emitted - * @returns {function()} unsubscribeMethod - method to unsubscribe from the event - */ - Once: (name, callback) => { - return wails.Events.Once(name, callback); - }, - /** - * Subscribe to an event multiple times - * @param {string} name - name of the event - * @param {(any) => void} callback - callback to call when the event is emitted - * @param {number} count - number of times to call the callback - * @returns {Promise} unsubscribeMethod - method to unsubscribe from the event - */ - OnMultiple: (name, callback, count) => { - return wails.Events.OnMultiple(name, callback, count); - }, - /** - * Unsubscribe from an event - * @param {string} name - name of the event to unsubscribe from - * @param {...string} additionalNames - additional names of events to unsubscribe from - */ - Off: (name, ...additionalNames) => { - wails.Events.Off(name, additionalNames); - }, - /** - * Unsubscribe all listeners from all events - */ - OffAll: () => { - wails.Events.OffAll(); - }, - - Windows: EventTypes.Windows, - Mac: EventTypes.Mac, - Common: EventTypes.Common, - -}; diff --git a/v3/internal/runtime/desktop/api/index.js b/v3/internal/runtime/desktop/api/index.js deleted file mode 100644 index 46a46b4b226..00000000000 --- a/v3/internal/runtime/desktop/api/index.js +++ /dev/null @@ -1,32 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ -/* jshint esversion: 9 */ - -import * as Clipboard from "./clipboard"; -import * as Application from "./application"; -import * as Screens from "./screens"; -import * as Dialogs from "./dialogs"; -import * as Events from "./events"; -import * as Window from "./window"; - -export { Clipboard, Application, Screens, Dialogs, Events, Window }; - -/** - * Call a plugin method - * @param {string} pluginName - name of the plugin - * @param {string} methodName - name of the method - * @param {...any} args - arguments to pass to the method - * @returns {Promise} - promise that resolves with the result - */ -export const Plugin = (pluginName, methodName, ...args) => { - return wails.Plugin(pluginName, methodName, ...args); -}; - - diff --git a/v3/internal/runtime/desktop/api/screens.js b/v3/internal/runtime/desktop/api/screens.js deleted file mode 100644 index f1e518d1579..00000000000 --- a/v3/internal/runtime/desktop/api/screens.js +++ /dev/null @@ -1,38 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -/** - * The Screens API provides methods to interact with the system screens/monitors. - */ -export const Screens = { - /** - * Get the primary screen - * @returns {Promise} - */ - GetPrimary: () => { - return wails.Screens.GetPrimary(); - }, - /** - * Get all screens - * @returns {Promise} - */ - GetAll: () => { - return wails.Screens.GetAll(); - }, - /** - * Get the current screen - * @returns {Promise} - */ - GetCurrent: () => { - return wails.Screens.GetCurrent(); - }, -}; \ No newline at end of file diff --git a/v3/internal/runtime/desktop/api/window.js b/v3/internal/runtime/desktop/api/window.js deleted file mode 100644 index f6f97aee791..00000000000 --- a/v3/internal/runtime/desktop/api/window.js +++ /dev/null @@ -1,159 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - - -/** - * The Window API provides methods to interact with the window. - */ -export const Window = { - /** - * Center the window. - */ - Center: () => void wails.Window.Center(), - /** - * Set the window title. - * @param title - */ - SetTitle: (title) => void wails.Window.SetTitle(title), - - /** - * Makes the window fullscreen. - */ - Fullscreen: () => void wails.Window.Fullscreen(), - - /** - * Unfullscreen the window. - */ - UnFullscreen: () => void wails.Window.UnFullscreen(), - - /** - * Set the window size. - * @param {number} width The window width - * @param {number} height The window height - */ - SetSize: (width, height) => void wails.Window.SetSize(width, height), - - /** - * Get the window size. - * @returns {Promise} The window size - */ - Size: () => { - return wails.Window.Size(); - }, - - /** - * Set the window maximum size. - * @param {number} width - * @param {number} height - */ - SetMaxSize: (width, height) => void wails.Window.SetMaxSize(width, height), - - /** - * Set the window minimum size. - * @param {number} width - * @param {number} height - */ - SetMinSize: (width, height) => void wails.Window.SetMinSize(width, height), - - /** - * Set window to be always on top. - * @param {boolean} onTop Whether the window should be always on top - */ - SetAlwaysOnTop: (onTop) => void wails.Window.SetAlwaysOnTop(onTop), - - /** - * Set the window position relative to the current monitor. - * @param {number} x - * @param {number} y - */ - SetRelativePosition: (x, y) => void wails.Window.SetRelativePosition(x, y), - - /** - * Get the window position relative to the current monitor. - * @returns {Promise} The window position - */ - RelativePosition: () => { - return wails.Window.RelativePosition(); - }, - - /** - * Set the absolute window position. - * @param {number} x - * @param {number} y - */ - SetAbsolutePosition: (x, y) => void wails.Window.SetAbsolutePosition(x, y), - - /** - * Get the absolute window position. - * @returns {Promise} The window position - */ - AbsolutePosition: () => { - return wails.Window.AbsolutePosition(); - }, - - /** - * Get the screen the window is on. - * @returns {Promise} - */ - Screen: () => { - return wails.Window.Screen(); - }, - - /** - * Hide the window - */ - Hide: () => void wails.Window.Hide(), - - /** - * Maximise the window - */ - Maximise: () => void wails.Window.Maximise(), - - /** - * Show the window - */ - Show: () => void wails.Window.Show(), - - /** - * Close the window - */ - Close: () => void wails.Window.Close(), - - /** - * Toggle the window maximise state - */ - ToggleMaximise: () => void wails.Window.ToggleMaximise(), - - /** - * Unmaximise the window - */ - UnMaximise: () => void wails.Window.UnMaximise(), - - /** - * Minimise the window - */ - Minimise: () => void wails.Window.Minimise(), - - /** - * Unminimise the window - */ - UnMinimise: () => void wails.Window.UnMinimise(), - - /** - * Set the background colour of the window. - * @param {number} r - The red value between 0 and 255 - * @param {number} g - The green value between 0 and 255 - * @param {number} b - The blue value between 0 and 255 - * @param {number} a - The alpha value between 0 and 255 - */ - SetBackgroundColour: (r, g, b, a) => void wails.Window.SetBackgroundColour(r, g, b, a), -}; diff --git a/v3/internal/runtime/desktop/application.js b/v3/internal/runtime/desktop/application.js deleted file mode 100644 index 097f322e915..00000000000 --- a/v3/internal/runtime/desktop/application.js +++ /dev/null @@ -1,43 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -import {newRuntimeCallerWithID, objectNames} from "./runtime"; - -let call = newRuntimeCallerWithID(objectNames.Application); - -let methods = { - Hide: 0, - Show: 1, - Quit: 2, -} - -/** - * Hide the application - */ -export function Hide() { - void call(methods.Hide); -} - -/** - * Show the application - */ -export function Show() { - void call(methods.Show); -} - - -/** - * Quit the application - */ -export function Quit() { - void call(methods.Quit); -} \ No newline at end of file diff --git a/v3/internal/runtime/desktop/calls.js b/v3/internal/runtime/desktop/calls.js deleted file mode 100644 index a9e60b716cf..00000000000 --- a/v3/internal/runtime/desktop/calls.js +++ /dev/null @@ -1,107 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -import {newRuntimeCallerWithID, objectNames} from "./runtime"; - -import { nanoid } from 'nanoid/non-secure'; - -let call = newRuntimeCallerWithID(objectNames.Call); - -let CallBinding = 0; - -let callResponses = new Map(); - -function generateID() { - let result; - do { - result = nanoid(); - } while (callResponses.has(result)); - return result; -} - -export function callCallback(id, data, isJSON) { - let p = callResponses.get(id); - if (p) { - if (isJSON) { - p.resolve(JSON.parse(data)); - } else { - p.resolve(data); - } - callResponses.delete(id); - } -} - -export function callErrorCallback(id, message) { - let p = callResponses.get(id); - if (p) { - p.reject(message); - callResponses.delete(id); - } -} - -function callBinding(type, options) { - return new Promise((resolve, reject) => { - let id = generateID(); - options = options || {}; - options["call-id"] = id; - - callResponses.set(id, {resolve, reject}); - call(type, options).catch((error) => { - reject(error); - callResponses.delete(id); - }); - }); -} - -export function Call(options) { - return callBinding(CallBinding, options); -} - -export function CallByName(name, ...args) { - - // Ensure first argument is a string and has 2 dots - if (typeof name !== "string" || name.split(".").length !== 3) { - throw new Error("CallByName requires a string in the format 'package.struct.method'"); - } - // Split inputs - let parts = name.split("."); - - return callBinding(CallBinding, { - packageName: parts[0], - structName: parts[1], - methodName: parts[2], - args: args, - }); -} - -export function CallByID(methodID, ...args) { - return callBinding(CallBinding, { - methodID: methodID, - args: args, - }); -} - -/** - * Call a plugin method - * @param {string} pluginName - name of the plugin - * @param {string} methodName - name of the method - * @param {...any} args - arguments to pass to the method - * @returns {Promise} - promise that resolves with the result - */ -export function Plugin(pluginName, methodName, ...args) { - return callBinding(CallBinding, { - packageName: "wails-plugins", - structName: pluginName, - methodName: methodName, - args: args, - }); -} \ No newline at end of file diff --git a/v3/internal/runtime/desktop/clipboard.js b/v3/internal/runtime/desktop/clipboard.js deleted file mode 100644 index cc9eb0373d7..00000000000 --- a/v3/internal/runtime/desktop/clipboard.js +++ /dev/null @@ -1,33 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -import {newRuntimeCallerWithID, objectNames} from "./runtime"; - -let call = newRuntimeCallerWithID(objectNames.Clipboard); - -let ClipboardSetText = 0; -let ClipboardText = 1; - -/** - * Set the Clipboard text - */ -export function SetText(text) { - void call(ClipboardSetText, {text}); -} - -/** - * Get the Clipboard text - * @returns {Promise} - */ -export function Text() { - return call(ClipboardText); -} \ No newline at end of file diff --git a/v3/internal/runtime/desktop/dialogs.js b/v3/internal/runtime/desktop/dialogs.js deleted file mode 100644 index 2865b7d844b..00000000000 --- a/v3/internal/runtime/desktop/dialogs.js +++ /dev/null @@ -1,129 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -/** - * @typedef {import("./api/types").MessageDialogOptions} MessageDialogOptions - * @typedef {import("./api/types").OpenDialogOptions} OpenDialogOptions - * @typedef {import("./api/types").SaveDialogOptions} SaveDialogOptions - */ - -import {newRuntimeCallerWithID, objectNames} from "./runtime"; - -import { nanoid } from 'nanoid/non-secure'; - -let call = newRuntimeCallerWithID(objectNames.Dialog); - -let DialogInfo = 0; -let DialogWarning = 1; -let DialogError = 2; -let DialogQuestion = 3; -let DialogOpenFile = 4; -let DialogSaveFile = 5; - - -let dialogResponses = new Map(); - -function generateID() { - let result; - do { - result = nanoid(); - } while (dialogResponses.has(result)); - return result; -} - -export function dialogCallback(id, data, isJSON) { - let p = dialogResponses.get(id); - if (p) { - if (isJSON) { - p.resolve(JSON.parse(data)); - } else { - p.resolve(data); - } - dialogResponses.delete(id); - } -} -export function dialogErrorCallback(id, message) { - let p = dialogResponses.get(id); - if (p) { - p.reject(message); - dialogResponses.delete(id); - } -} - -function dialog(type, options) { - return new Promise((resolve, reject) => { - let id = generateID(); - options = options || {}; - options["dialog-id"] = id; - dialogResponses.set(id, {resolve, reject}); - call(type, options).catch((error) => { - reject(error); - dialogResponses.delete(id); - }); - }); -} - - -/** - * Shows an Info dialog with the given options. - * @param {MessageDialogOptions} options - * @returns {Promise} The label of the button pressed - */ -export function Info(options) { - return dialog(DialogInfo, options); -} - -/** - * Shows a Warning dialog with the given options. - * @param {MessageDialogOptions} options - * @returns {Promise} The label of the button pressed - */ -export function Warning(options) { - return dialog(DialogWarning, options); -} - -/** - * Shows an Error dialog with the given options. - * @param {MessageDialogOptions} options - * @returns {Promise} The label of the button pressed - */ -export function Error(options) { - return dialog(DialogError, options); -} - -/** - * Shows a Question dialog with the given options. - * @param {MessageDialogOptions} options - * @returns {Promise} The label of the button pressed - */ -export function Question(options) { - return dialog(DialogQuestion, options); -} - -/** - * Shows an Open dialog with the given options. - * @param {OpenDialogOptions} options - * @returns {Promise} Returns the selected file or an array of selected files if AllowsMultipleSelection is true. A blank string is returned if no file was selected. - */ -export function OpenFile(options) { - return dialog(DialogOpenFile, options); -} - -/** - * Shows a Save dialog with the given options. - * @param {SaveDialogOptions} options - * @returns {Promise} Returns the selected file. A blank string is returned if no file was selected. - */ -export function SaveFile(options) { - return dialog(DialogSaveFile, options); -} - diff --git a/v3/internal/runtime/desktop/events.js b/v3/internal/runtime/desktop/events.js deleted file mode 100644 index 40e40ebd740..00000000000 --- a/v3/internal/runtime/desktop/events.js +++ /dev/null @@ -1,194 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -/** - * @typedef {import("./api/types").WailsEvent} WailsEvent - */ - -import {newRuntimeCallerWithID, objectNames} from "./runtime"; - -let call = newRuntimeCallerWithID(objectNames.Events); -let EventEmit = 0; - -/** - * The Listener class defines a listener! :-) - * - * @class Listener - */ -class Listener { - /** - * Creates an instance of Listener. - * @param {string} eventName - * @param {function} callback - * @param {number} maxCallbacks - * @memberof Listener - */ - constructor(eventName, callback, maxCallbacks) { - this.eventName = eventName; - // Default of -1 means infinite - this.maxCallbacks = maxCallbacks || -1; - // Callback invokes the callback with the given data - // Returns true if this listener should be destroyed - this.Callback = (data) => { - callback(data); - // If maxCallbacks is infinite, return false (do not destroy) - if (this.maxCallbacks === -1) { - return false; - } - // Decrement maxCallbacks. Return true if now 0, otherwise false - this.maxCallbacks -= 1; - return this.maxCallbacks === 0; - }; - } -} - - -/** - * WailsEvent defines a custom event. It is passed to event listeners. - * - * @class WailsEvent - * @property {string} name - Name of the event - * @property {any} data - Data associated with the event - */ -export class WailsEvent { - /** - * Creates an instance of WailsEvent. - * @param {string} name - Name of the event - * @param {any=null} data - Data associated with the event - * @memberof WailsEvent - */ - constructor(name, data = null) { - this.name = name; - this.data = data; - } -} - -export const eventListeners = new Map(); - -/** - * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed - * - * @export - * @param {string} eventName - * @param {function(WailsEvent): void} callback - * @param {number} maxCallbacks - * @returns {function} A function to cancel the listener - */ -export function OnMultiple(eventName, callback, maxCallbacks) { - let listeners = eventListeners.get(eventName) || []; - const thisListener = new Listener(eventName, callback, maxCallbacks); - listeners.push(thisListener); - eventListeners.set(eventName, listeners); - return () => listenerOff(thisListener); -} - -/** - * Registers an event listener that will be invoked every time the event is emitted - * - * @export - * @param {string} eventName - * @param {function(WailsEvent): void} callback - * @returns {function} A function to cancel the listener - */ -export function On(eventName, callback) { - return OnMultiple(eventName, callback, -1); -} - -/** - * Registers an event listener that will be invoked once then destroyed - * - * @export - * @param {string} eventName - * @param {function(WailsEvent): void} callback - @returns {function} A function to cancel the listener - */ -export function Once(eventName, callback) { - return OnMultiple(eventName, callback, 1); -} - -/** - * listenerOff unregisters a listener previously registered with On - * - * @param {Listener} listener - */ -function listenerOff(listener) { - const eventName = listener.eventName; - // Remove local listener - let listeners = eventListeners.get(eventName).filter(l => l !== listener); - if (listeners.length === 0) { - eventListeners.delete(eventName); - } else { - eventListeners.set(eventName, listeners); - } -} - -/** - * dispatches an event to all listeners - * - * @export - * @param {WailsEvent} event - */ -export function dispatchWailsEvent(event) { - let listeners = eventListeners.get(event.name); - if (listeners) { - // iterate listeners and call callback. If callback returns true, remove listener - let toRemove = []; - listeners.forEach(listener => { - let remove = listener.Callback(event); - if (remove) { - toRemove.push(listener); - } - }); - // remove listeners - if (toRemove.length > 0) { - listeners = listeners.filter(l => !toRemove.includes(l)); - if (listeners.length === 0) { - eventListeners.delete(event.name); - } else { - eventListeners.set(event.name, listeners); - } - } - } -} - -/** - * Off unregisters a listener previously registered with On, - * optionally multiple listeners can be unregistered via `additionalEventNames` - * - [v3 CHANGE] Off only unregisters listeners within the current window - * - * @param {string} eventName - * @param {...string} additionalEventNames - */ -export function Off(eventName, ...additionalEventNames) { - let eventsToRemove = [eventName, ...additionalEventNames]; - eventsToRemove.forEach(eventName => { - eventListeners.delete(eventName); - }); -} - -/** - * OffAll unregisters all listeners - * [v3 CHANGE] OffAll only unregisters listeners within the current window - * - */ -export function OffAll() { - eventListeners.clear(); -} - -/** - * Emit an event - * @param {WailsEvent} event The event to emit - */ -export function Emit(event) { - void call(EventEmit, event); -} \ No newline at end of file diff --git a/v3/internal/runtime/desktop/invoke.js b/v3/internal/runtime/desktop/invoke.js deleted file mode 100644 index b8a2daa1b8b..00000000000 --- a/v3/internal/runtime/desktop/invoke.js +++ /dev/null @@ -1,20 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -// defined in the Taskfile -export let invoke = function(input) { - if(WINDOWS) { - chrome.webview.postMessage(input); - } else { - webkit.messageHandlers.external.postMessage(input); - } -} diff --git a/v3/internal/runtime/desktop/main.js b/v3/internal/runtime/desktop/main.js index 66709a490b4..3546a81538c 100644 --- a/v3/internal/runtime/desktop/main.js +++ b/v3/internal/runtime/desktop/main.js @@ -10,39 +10,32 @@ The electron alternative for Go /* jshint esversion: 9 */ -import * as Clipboard from './clipboard'; -import * as Application from './application'; -import * as Screens from './screens'; -import * as System from './system'; -import * as Browser from './browser'; -import {Plugin, Call, callErrorCallback, callCallback, CallByID, CallByName} from "./calls"; -import {clientId} from './runtime'; -import {newWindow} from "./window"; -import {dispatchWailsEvent, Emit, Off, OffAll, On, Once, OnMultiple} from "./events"; -import {dialogCallback, dialogErrorCallback, Error, Info, OpenFile, Question, SaveFile, Warning,} from "./dialogs"; -import {setupContextMenus} from "./contextmenu"; -import {reloadWML} from "./wml"; -import {setupDrag, endDrag, setResizable} from "./drag"; +import * as Clipboard from './@wailsio/runtime/clipboard'; +import * as Application from './@wailsio/runtime/application'; +import * as Screens from './@wailsio/runtime/screens'; +import * as System from './@wailsio/runtime/system'; +import * as Browser from './@wailsio/runtime/browser'; +import * as Window from './@wailsio/runtime/window'; +import {Plugin, Call, errorHandler as callErrorHandler, resultHandler as callResultHandler, ByID, ByName} from "./@wailsio/runtime/calls"; +import {clientId} from './@wailsio/runtime/runtime'; +import {dispatchWailsEvent, Emit, Off, OffAll, On, Once, OnMultiple} from "./@wailsio/runtime/events"; +import {dialogCallback, dialogErrorCallback, Error, Info, OpenFile, Question, SaveFile, Warning} from "./@wailsio/runtime/dialogs"; +import {setupContextMenus} from './@wailsio/runtime/contextmenu'; +import {reloadWML} from './@wailsio/runtime/wml'; +import {setupDrag, endDrag, setResizable} from './@wailsio/runtime/drag'; window.wails = { ...newRuntime(null), - Capabilities: {}, clientId: clientId, }; -fetch("/wails/capabilities").then((response) => { - response.json().then((data) => { - window.wails.Capabilities = data; - }); -}); - // Internal wails endpoints window._wails = { dialogCallback, dialogErrorCallback, dispatchWailsEvent, - callCallback, - callErrorCallback, + callErrorHandler, + callResultHandler, endDrag, setResizable, }; @@ -54,17 +47,16 @@ export function newRuntime(windowName) { }, Application: { ...Application, - GetWindowByName(windowName) { - return newRuntime(windowName); - } }, System, Screens, Browser, - Call, - CallByID, - CallByName, - Plugin, + Call: { + Call, + ByID, + ByName, + Plugin, + }, WML: { Reload: reloadWML, }, @@ -84,14 +76,12 @@ export function newRuntime(windowName) { Off, OffAll, }, - Window: newWindow(windowName), + Window: { + ...Window.Get('') + }, }; } -if (DEBUG) { - console.log("Wails v3.0.0 Debug Mode Enabled"); -} - setupContextMenus(); setupDrag(); diff --git a/v3/internal/runtime/desktop/system.js b/v3/internal/runtime/desktop/system.js deleted file mode 100644 index d1f29e4035a..00000000000 --- a/v3/internal/runtime/desktop/system.js +++ /dev/null @@ -1,25 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -import {newRuntimeCallerWithID, objectNames} from "./runtime"; - -let call = newRuntimeCallerWithID(objectNames.System); - -let SystemIsDarkMode = 0; - -/** - * Determines if the system is currently using dark mode - * @returns {Promise} - */ -export function IsDarkMode() { - return call(SystemIsDarkMode); -} \ No newline at end of file diff --git a/v3/internal/runtime/desktop/window.js b/v3/internal/runtime/desktop/window.js deleted file mode 100644 index f255ae42ea1..00000000000 --- a/v3/internal/runtime/desktop/window.js +++ /dev/null @@ -1,228 +0,0 @@ -/* - _ __ _ __ -| | / /___ _(_) /____ -| | /| / / __ `/ / / ___/ -| |/ |/ / /_/ / / (__ ) -|__/|__/\__,_/_/_/____/ -The electron alternative for Go -(c) Lea Anthony 2019-present -*/ - -/* jshint esversion: 9 */ - -/** - * @typedef {import("../api/types").Size} Size - * @typedef {import("../api/types").Position} Position - * @typedef {import("../api/types").Screen} Screen - */ - -import {newRuntimeCallerWithID, objectNames} from "./runtime"; - -let WindowCenter = 0; -let WindowSetTitle = 1; -let WindowFullscreen = 2; -let WindowUnFullscreen = 3; -let WindowSetSize = 4; -let WindowSize = 5; -let WindowSetMaxSize = 6; -let WindowSetMinSize = 7; -let WindowSetAlwaysOnTop = 8; -let WindowSetRelativePosition = 9; -let WindowRelativePosition = 10; -let WindowScreen = 11; -let WindowHide = 12; -let WindowMaximise = 13; -let WindowUnMaximise = 14; -let WindowToggleMaximise = 15; -let WindowMinimise = 16; -let WindowUnMinimise = 17; -let WindowRestore = 18; -let WindowShow = 19; -let WindowClose = 20; -let WindowSetBackgroundColour = 21; -let WindowSetResizable = 22; -let WindowWidth = 23; -let WindowHeight = 24; -let WindowZoomIn = 25; -let WindowZoomOut = 26; -let WindowZoomReset = 27; -let WindowGetZoomLevel = 28; -let WindowSetZoomLevel = 29; - -export function newWindow(windowName) { - let call = newRuntimeCallerWithID(objectNames.Window, windowName); - return { - - /** - * Centers the window. - */ - Center: () => void call(WindowCenter), - - /** - * Set the window title. - * @param title - */ - SetTitle: (title) => void call(WindowSetTitle, {title}), - - /** - * Makes the window fullscreen. - */ - Fullscreen: () => void call(WindowFullscreen), - - /** - * Unfullscreen the window. - */ - UnFullscreen: () => void call(WindowUnFullscreen), - - /** - * Set the window size. - * @param {number} width The window width - * @param {number} height The window height - */ - SetSize: (width, height) => call(WindowSetSize, {width,height}), - - /** - * Get the window size. - * @returns {Promise} The window size - */ - Size: () => { return call(WindowSize); }, - - /** - * Set the window maximum size. - * @param {number} width - * @param {number} height - */ - SetMaxSize: (width, height) => void call(WindowSetMaxSize, {width,height}), - - /** - * Set the window minimum size. - * @param {number} width - * @param {number} height - */ - SetMinSize: (width, height) => void call(WindowSetMinSize, {width,height}), - - /** - * Set window to be always on top. - * @param {boolean} onTop Whether the window should be always on top - */ - SetAlwaysOnTop: (onTop) => void call(WindowSetAlwaysOnTop, {alwaysOnTop:onTop}), - - /** - * Set the window relative position. - * @param {number} x - * @param {number} y - */ - SetRelativePosition: (x, y) => call(WindowSetRelativePosition, {x,y}), - - /** - * Get the window position. - * @returns {Promise} The window position - */ - RelativePosition: () => { return call(WindowRelativePosition); }, - - /** - * Get the screen the window is on. - * @returns {Promise} - */ - Screen: () => { return call(WindowScreen); }, - - /** - * Hide the window - */ - Hide: () => void call(WindowHide), - - /** - * Maximise the window - */ - Maximise: () => void call(WindowMaximise), - - /** - * Show the window - */ - Show: () => void call(WindowShow), - - /** - * Close the window - */ - Close: () => void call(WindowClose), - - /** - * Toggle the window maximise state - */ - ToggleMaximise: () => void call(WindowToggleMaximise), - - /** - * Unmaximise the window - */ - UnMaximise: () => void call(WindowUnMaximise), - - /** - * Minimise the window - */ - Minimise: () => void call(WindowMinimise), - - /** - * Unminimise the window - */ - UnMinimise: () => void call(WindowUnMinimise), - - /** - * Restore the window - */ - Restore: () => void call(WindowRestore), - - /** - * Set the background colour of the window. - * @param {number} r - A value between 0 and 255 - * @param {number} g - A value between 0 and 255 - * @param {number} b - A value between 0 and 255 - * @param {number} a - A value between 0 and 255 - */ - SetBackgroundColour: (r, g, b, a) => void call(WindowSetBackgroundColour, {r, g, b, a}), - - /** - * Set whether the window can be resized or not - * @param {boolean} resizable - */ - SetResizable: (resizable) => void call(WindowSetResizable, {resizable}), - - /** - * Get the window width - * @returns {Promise} - */ - Width: () => { return call(WindowWidth); }, - - /** - * Get the window height - * @returns {Promise} - */ - Height: () => { return call(WindowHeight); }, - - /** - * Zoom in the window - */ - ZoomIn: () => void call(WindowZoomIn), - - /** - * Zoom out the window - */ - ZoomOut: () => void call(WindowZoomOut), - - /** - * Reset the window zoom - */ - ZoomReset: () => void call(WindowZoomReset), - - /** - * Get the window zoom - * @returns {Promise} - */ - GetZoomLevel: () => { return call(WindowGetZoomLevel); }, - - /** - * Set the window zoom level - * @param {number} zoomLevel - */ - SetZoomLevel: (zoomLevel) => void call(WindowSetZoomLevel, {zoomLevel}), - }; -} diff --git a/v3/internal/runtime/runtime.js b/v3/internal/runtime/runtime.js new file mode 100644 index 00000000000..01fae4e203a --- /dev/null +++ b/v3/internal/runtime/runtime.js @@ -0,0 +1 @@ +(()=>{var Se=Object.defineProperty;var b=(e,t)=>{for(var n in t)Se(e,n,{get:t[n],enumerable:!0})};var N={};b(N,{SetText:()=>Le,Text:()=>Oe});var De="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";var g=(e=21)=>{let t="",n=e;for(;n--;)t+=De[Math.random()*64|0];return t};var Ee=window.location.origin+"/wails/runtime",s={Call:0,Clipboard:1,Application:2,Events:3,ContextMenu:4,Dialog:5,Window:6,Screens:7,System:8,Browser:9},z=g();function l(e,t){return function(n,o=null){return Re(e,n,t,o)}}function Re(e,t,n,o){let r=new URL(Ee);r.searchParams.append("object",e),r.searchParams.append("method",t);let i={headers:{}};return n&&(i.headers["x-wails-window-name"]=n),o&&r.searchParams.append("args",JSON.stringify(o)),i.headers["x-wails-client-id"]=z,new Promise((c,p)=>{fetch(r,i).then(a=>{if(a.ok)return a.headers.get("Content-Type")&&a.headers.get("Content-Type").indexOf("application/json")!==-1?a.json():a.text();p(Error(a.statusText))}).then(a=>c(a)).catch(a=>p(a))})}var V=l(s.Clipboard,""),ye=0,We=1;function Le(e){return V(ye,{text:e})}function Oe(){return V(We)}var P={};b(P,{Hide:()=>ze,Quit:()=>Te,Show:()=>Ne});var T=l(s.Application),Ie=0,ke=1,Ae=2;function ze(){return T(Ie)}function Ne(){return T(ke)}function Te(){return T(Ae)}var H={};b(H,{GetAll:()=>je,GetCurrent:()=>Ue,GetPrimary:()=>Fe});var B=l(s.Screens,""),Pe=0,Be=1,He=2;function je(){return B(Pe)}function Fe(){return B(Be)}function Ue(){return B(He)}var j={};b(j,{Capabilities:()=>Xe,Environment:()=>J,IsAMD64:()=>Ve,IsARM:()=>qe,IsARM64:()=>Je,IsDarkMode:()=>Ye,IsLinux:()=>Ze,IsMac:()=>Qe,IsWindows:()=>v,invoke:()=>M});var q=l(s.System,""),_e=0,Ge=1;function Ye(){return q(_e)}async function Xe(){return fetch("/wails/capabilities").json()}function J(){return q(Ge)}var M=null,d=null;J().then(e=>{d=e,M=v()?window.chrome.webview.postMessage:window.webkit.messageHandlers.external.postMessage}).catch(e=>{});function v(){return d.OS==="windows"}function Ze(){return d.OS==="linux"}function Qe(){return d.OS==="darwin"}function Ve(){return d.Arch==="amd64"}function qe(){return d.Arch==="arm"}function Je(){return d.Arch==="arm64"}var F={};b(F,{OpenURL:()=>et});var $e=l(s.Browser,""),Ke=0;function et(e){return $e(Ke,{url:e})}var tt=0,nt=1,ot=2,rt=3,it=4,st=5,lt=6,at=7,ct=8,ut=9,ft=10,dt=11,mt=12,pt=13,wt=14,gt=15,ht=16,xt=17,Ct=18,bt=19,Mt=20,vt=21,St=22,Dt=23,Et=24,Rt=25,yt=26,Wt=27,Lt=28,Ot=29,Mn=l(s.Window,"");function $(e){return{Get:t=>$(l(s.Window,t)),Center:()=>e(tt),SetTitle:t=>e(nt,{title:t}),Fullscreen:()=>e(ot),UnFullscreen:()=>e(rt),SetSize:(t,n)=>e(it,{width:t,height:n}),Size:()=>e(st),SetMaxSize:(t,n)=>e(lt,{width:t,height:n}),SetMinSize:(t,n)=>e(at,{width:t,height:n}),SetAlwaysOnTop:t=>e(ct,{alwaysOnTop:t}),SetRelativePosition:(t,n)=>e(ut,{x:t,y:n}),RelativePosition:()=>e(ft),Screen:()=>e(dt),Hide:()=>e(mt),Maximise:()=>e(pt),UnMaximise:()=>e(wt),ToggleMaximise:()=>e(gt),Minimise:()=>e(ht),UnMinimise:()=>e(xt),Restore:()=>e(Ct),Show:()=>e(bt),Close:()=>e(Mt),SetBackgroundColour:(t,n,o,r)=>e(vt,{r:t,g:n,b:o,a:r}),SetResizable:t=>e(St,{resizable:t}),Width:()=>e(Dt),Height:()=>e(Et),ZoomIn:()=>e(Rt),ZoomOut:()=>e(yt),ZoomReset:()=>e(Wt),GetZoomLevel:()=>e(Lt),SetZoomLevel:t=>e(Ot,{zoomLevel:t})}}function S(e){return $(l(s.Window,e))}function K(e){let t=new Map;for(let n in e)typeof e[n]=="function"&&t.set(n,e[n]);return t}var vn={...S("")};var R=0,kt=l(s.Call,""),D=new Map;window._wails=window._wails||{};window._wails.callCallback=U;window._wails.callErrorCallback=_;function At(){let e;do e=g();while(D.has(e));return e}function U(e,t,n){let o=ee(e);o&&o.resolve(n?JSON.parse(t):t)}function _(e,t){let n=ee(e);n&&n.reject(t)}function ee(e){let t=D.get(e);return D.delete(e),t}function y(e,t={}){return new Promise((n,o)=>{let r=At();t["call-id"]=r,D.set(r,{resolve:n,reject:o}),kt(e,t).catch(i=>{o(i),D.delete(r)})})}function te(e){return y(R,e)}function ne(e,...t){if(typeof e!="string"||e.split(".").length!==3)throw new Error("CallByName requires a string in the format 'package.struct.method'");let[n,o,r]=e.split(".");return y(R,{packageName:n,structName:o,methodName:r,args:t})}function oe(e,...t){return y(R,{methodID:e,args:t})}function re(e,t,...n){return y(R,{packageName:"wails-plugins",structName:e,methodName:t,args:n})}var zt=l(s.Events,""),Nt=0,u=new Map,G=class{constructor(t,n,o){this.eventName=t,this.maxCallbacks=o||-1,this.Callback=r=>(n(r),this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0))}},W=class{constructor(t,n=null){this.name=t,this.data=n}};window._wails=window._wails||{};window._wails.dispatchWailsEvent=Y;function Y(e){let t=u.get(e.name);if(t){let n=t.filter(o=>{if(o.Callback(e))return!0});n.length>0&&(t=t.filter(o=>!n.includes(o)),t.length===0?u.delete(e.name):u.set(e.name,t))}}function L(e,t,n){let o=u.get(e)||[],r=new G(e,t,n);return o.push(r),u.set(e,o),()=>Tt(r)}function ie(e,t){return L(e,t,-1)}function se(e,t){return L(e,t,1)}function Tt(e){let t=e.eventName,n=u.get(t).filter(o=>o!==e);n.length===0?u.delete(t):u.set(t,n)}function le(e,...t){[e,...t].forEach(o=>u.delete(o))}function ae(){u.clear()}function O(e){return zt(Nt,e)}var Pt=0,Bt=1,Ht=2,jt=3,Ft=4,Ut=5,_t=l(s.Dialog,""),m=new Map;function Gt(){let e;do e=g();while(m.has(e));return e}function h(e,t={}){let n=Gt();return t["dialog-id"]=n,new Promise((o,r)=>{m.set(n,{resolve:o,reject:r}),_t(e,t).catch(i=>{r(i),m.delete(n)})})}function ce(e,t,n){let o=m.get(e);o&&(n?o.resolve(JSON.parse(t)):o.resolve(t),m.delete(e))}function ue(e,t){let n=m.get(e);n&&(n.reject(t),m.delete(e))}var fe=e=>h(Pt,e),de=e=>h(Bt,e),me=e=>h(Ht,e),x=e=>h(jt,e),pe=e=>h(Ft,e),we=e=>h(Ut,e);var Yt=l(s.ContextMenu,""),Xt=0;function Zt(e,t,n,o){Yt(Xt,{id:e,x:t,y:n,data:o})}function ge(){window.addEventListener("contextmenu",Qt)}function Qt(e){let t=e.target,n=window.getComputedStyle(t).getPropertyValue("--custom-contextmenu");if(n=n?n.trim():"",n){e.preventDefault();let o=window.getComputedStyle(t).getPropertyValue("--custom-contextmenu-data");Zt(n,e.clientX,e.clientY,o);return}Vt(e)}function Vt(e){if(DEBUG)return;let t=e.target;switch(window.getComputedStyle(t).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":e.preventDefault();return;default:if(t.isContentEditable)return;let r=window.getSelection(),i=r.toString().length>0;if(i)for(let c=0;c{e.json().then(t=>{Ce=be(t)})});function Kt(e){let t=e.split("."),n=Ce;for(let o of t)if(n instanceof Map?n=n.get(o):n=n[o],n===void 0)break;return n}function I(e){return Kt(e)}var E=!1,k=null,Me=!1,en="auto";window._wails=window._wails||{};window._wails.setResizable=Z;window._wails.endDrag=A;function tn(e){let t=window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region");return t&&t.trim()!=="drag"||e.buttons!==1?!1:e.detail===1}function ve(){window.addEventListener("mousedown",on),window.addEventListener("mousemove",ln),window.addEventListener("mouseup",sn)}function Z(e){Me=e}function A(){document.body.style.cursor="default",E=!1}function nn(){return k?(M(`resize:${k}`),!0):!1}function on(e){(v()&&nn()||tn(e))&&(E=!!rn(e))}function rn(e){return!(e.offsetX>e.target.clientWidth||e.offsetY>e.target.clientHeight)}function sn(e){(e.buttons!==void 0?e.buttons:e.which)>0&&A()}function f(e=en){document.documentElement.style.cursor=e,k=e}function ln(e){E=an(e),v()&&Me&&cn(e)}function an(e){let t=e.buttons!==void 0?e.buttons:e.which;return E&&t>0?(M("drag"),!1):E}function cn(e){let t=I("system.resizeHandleHeight")||5,n=I("system.resizeHandleWidth")||5,o=I("resizeCornerExtra")||10,r=window.outerWidth-e.clientX { + var __defProp = Object.defineProperty; + var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); + }; + + // desktop/@wailsio/runtime/clipboard.js + var clipboard_exports = {}; + __export(clipboard_exports, { + SetText: () => SetText, + Text: () => Text + }); + + // node_modules/nanoid/non-secure/index.js + var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict"; + var nanoid = (size2 = 21) => { + let id = ""; + let i = size2; + while (i--) { + id += urlAlphabet[Math.random() * 64 | 0]; + } + return id; + }; + + // desktop/@wailsio/runtime/runtime.js + var runtimeURL = window.location.origin + "/wails/runtime"; + var objectNames = { + Call: 0, + Clipboard: 1, + Application: 2, + Events: 3, + ContextMenu: 4, + Dialog: 5, + Window: 6, + Screens: 7, + System: 8, + Browser: 9 + }; + var clientId = nanoid(); + function newRuntimeCallerWithID(object, windowName) { + return function(method, args = null) { + return runtimeCallWithID(object, method, windowName, args); + }; + } + function runtimeCallWithID(objectID, method, windowName, args) { + let url = new URL(runtimeURL); + url.searchParams.append("object", objectID); + url.searchParams.append("method", method); + let fetchOptions = { + headers: {} + }; + if (windowName) { + fetchOptions.headers["x-wails-window-name"] = windowName; + } + if (args) { + url.searchParams.append("args", JSON.stringify(args)); + } + fetchOptions.headers["x-wails-client-id"] = clientId; + return new Promise((resolve, reject) => { + fetch(url, fetchOptions).then((response) => { + if (response.ok) { + if (response.headers.get("Content-Type") && response.headers.get("Content-Type").indexOf("application/json") !== -1) { + return response.json(); + } else { + return response.text(); + } + } + reject(Error(response.statusText)); + }).then((data) => resolve(data)).catch((error) => reject(error)); + }); + } + + // desktop/@wailsio/runtime/clipboard.js + var call = newRuntimeCallerWithID(objectNames.Clipboard, ""); + var ClipboardSetText = 0; + var ClipboardText = 1; + function SetText(text) { + return call(ClipboardSetText, { text }); + } + function Text() { + return call(ClipboardText); + } + + // desktop/@wailsio/runtime/application.js + var application_exports = {}; + __export(application_exports, { + Hide: () => Hide, + Quit: () => Quit, + Show: () => Show + }); + var call2 = newRuntimeCallerWithID(objectNames.Application); + var HideMethod = 0; + var ShowMethod = 1; + var QuitMethod = 2; + function Hide() { + return call2(HideMethod); + } + function Show() { + return call2(ShowMethod); + } + function Quit() { + return call2(QuitMethod); + } + + // desktop/@wailsio/runtime/screens.js + var screens_exports = {}; + __export(screens_exports, { + GetAll: () => GetAll, + GetCurrent: () => GetCurrent, + GetPrimary: () => GetPrimary + }); + var call3 = newRuntimeCallerWithID(objectNames.Screens, ""); + var getAll = 0; + var getPrimary = 1; + var getCurrent = 2; + function GetAll() { + return call3(getAll); + } + function GetPrimary() { + return call3(getPrimary); + } + function GetCurrent() { + return call3(getCurrent); + } + + // desktop/@wailsio/runtime/system.js + var system_exports = {}; + __export(system_exports, { + Capabilities: () => Capabilities, + Environment: () => Environment, + IsAMD64: () => IsAMD64, + IsARM: () => IsARM, + IsARM64: () => IsARM64, + IsDarkMode: () => IsDarkMode, + IsLinux: () => IsLinux, + IsMac: () => IsMac, + IsWindows: () => IsWindows, + invoke: () => invoke + }); + var call4 = newRuntimeCallerWithID(objectNames.System, ""); + var systemIsDarkMode = 0; + var environment = 1; + function IsDarkMode() { + return call4(systemIsDarkMode); + } + async function Capabilities() { + let response = fetch("/wails/capabilities"); + return response.json(); + } + function Environment() { + return call4(environment); + } + var invoke = null; + var environmentCache = null; + Environment().then((result) => { + environmentCache = result; + invoke = IsWindows() ? window.chrome.webview.postMessage : window.webkit.messageHandlers.external.postMessage; + }).catch((error) => { + console.error(`Error getting Environment: ${error}`); + }); + function IsWindows() { + return environmentCache.OS === "windows"; + } + function IsLinux() { + return environmentCache.OS === "linux"; + } + function IsMac() { + return environmentCache.OS === "darwin"; + } + function IsAMD64() { + return environmentCache.Arch === "amd64"; + } + function IsARM() { + return environmentCache.Arch === "arm"; + } + function IsARM64() { + return environmentCache.Arch === "arm64"; + } + + // desktop/@wailsio/runtime/browser.js + var browser_exports = {}; + __export(browser_exports, { + OpenURL: () => OpenURL + }); + var call5 = newRuntimeCallerWithID(objectNames.Browser, ""); + var BrowserOpenURL = 0; + function OpenURL(url) { + return call5(BrowserOpenURL, { url }); + } + + // desktop/@wailsio/runtime/window.js + var center = 0; + var setTitle = 1; + var fullscreen = 2; + var unFullscreen = 3; + var setSize = 4; + var size = 5; + var setMaxSize = 6; + var setMinSize = 7; + var setAlwaysOnTop = 8; + var setRelativePosition = 9; + var relativePosition = 10; + var screen = 11; + var hide = 12; + var maximise = 13; + var unMaximise = 14; + var toggleMaximise = 15; + var minimise = 16; + var unMinimise = 17; + var restore = 18; + var show = 19; + var close = 20; + var setBackgroundColour = 21; + var setResizable = 22; + var width = 23; + var height = 24; + var zoomIn = 25; + var zoomOut = 26; + var zoomReset = 27; + var getZoomLevel = 28; + var setZoomLevel = 29; + var thisWindow = newRuntimeCallerWithID(objectNames.Window, ""); + function createWindow(call10) { + return { + Get: (windowName) => createWindow(newRuntimeCallerWithID(objectNames.Window, windowName)), + Center: () => call10(center), + SetTitle: (title) => call10(setTitle, { title }), + Fullscreen: () => call10(fullscreen), + UnFullscreen: () => call10(unFullscreen), + SetSize: (width2, height2) => call10(setSize, { width: width2, height: height2 }), + Size: () => call10(size), + SetMaxSize: (width2, height2) => call10(setMaxSize, { width: width2, height: height2 }), + SetMinSize: (width2, height2) => call10(setMinSize, { width: width2, height: height2 }), + SetAlwaysOnTop: (onTop) => call10(setAlwaysOnTop, { alwaysOnTop: onTop }), + SetRelativePosition: (x, y) => call10(setRelativePosition, { x, y }), + RelativePosition: () => call10(relativePosition), + Screen: () => call10(screen), + Hide: () => call10(hide), + Maximise: () => call10(maximise), + UnMaximise: () => call10(unMaximise), + ToggleMaximise: () => call10(toggleMaximise), + Minimise: () => call10(minimise), + UnMinimise: () => call10(unMinimise), + Restore: () => call10(restore), + Show: () => call10(show), + Close: () => call10(close), + SetBackgroundColour: (r, g, b, a) => call10(setBackgroundColour, { r, g, b, a }), + SetResizable: (resizable2) => call10(setResizable, { resizable: resizable2 }), + Width: () => call10(width), + Height: () => call10(height), + ZoomIn: () => call10(zoomIn), + ZoomOut: () => call10(zoomOut), + ZoomReset: () => call10(zoomReset), + GetZoomLevel: () => call10(getZoomLevel), + SetZoomLevel: (zoomLevel) => call10(setZoomLevel, { zoomLevel }) + }; + } + function Get(windowName) { + return createWindow(newRuntimeCallerWithID(objectNames.Window, windowName)); + } + function WindowMethods(targetWindow) { + let result = /* @__PURE__ */ new Map(); + for (let method in targetWindow) { + if (typeof targetWindow[method] === "function") { + result.set(method, targetWindow[method]); + } + } + return result; + } + var window_default = { + ...Get("") + }; + + // desktop/@wailsio/runtime/calls.js + var CallBinding = 0; + var call6 = newRuntimeCallerWithID(objectNames.Call, ""); + var callResponses = /* @__PURE__ */ new Map(); + window._wails = window._wails || {}; + window._wails.callCallback = resultHandler; + window._wails.callErrorCallback = errorHandler; + function generateID() { + let result; + do { + result = nanoid(); + } while (callResponses.has(result)); + return result; + } + function resultHandler(id, data, isJSON) { + const promiseHandler = getAndDeleteResponse(id); + if (promiseHandler) { + promiseHandler.resolve(isJSON ? JSON.parse(data) : data); + } + } + function errorHandler(id, message) { + const promiseHandler = getAndDeleteResponse(id); + if (promiseHandler) { + promiseHandler.reject(message); + } + } + function getAndDeleteResponse(id) { + const response = callResponses.get(id); + callResponses.delete(id); + return response; + } + function callBinding(type, options = {}) { + return new Promise((resolve, reject) => { + const id = generateID(); + options["call-id"] = id; + callResponses.set(id, { resolve, reject }); + call6(type, options).catch((error) => { + reject(error); + callResponses.delete(id); + }); + }); + } + function Call(options) { + return callBinding(CallBinding, options); + } + function ByName(name, ...args) { + if (typeof name !== "string" || name.split(".").length !== 3) { + throw new Error("CallByName requires a string in the format 'package.struct.method'"); + } + let [packageName, structName, methodName] = name.split("."); + return callBinding(CallBinding, { + packageName, + structName, + methodName, + args + }); + } + function ByID(methodID, ...args) { + return callBinding(CallBinding, { + methodID, + args + }); + } + function Plugin(pluginName, methodName, ...args) { + return callBinding(CallBinding, { + packageName: "wails-plugins", + structName: pluginName, + methodName, + args + }); + } + + // desktop/@wailsio/runtime/events.js + var call7 = newRuntimeCallerWithID(objectNames.Events, ""); + var EmitMethod = 0; + var eventListeners = /* @__PURE__ */ new Map(); + var Listener = class { + constructor(eventName, callback, maxCallbacks) { + this.eventName = eventName; + this.maxCallbacks = maxCallbacks || -1; + this.Callback = (data) => { + callback(data); + if (this.maxCallbacks === -1) + return false; + this.maxCallbacks -= 1; + return this.maxCallbacks === 0; + }; + } + }; + var WailsEvent = class { + constructor(name, data = null) { + this.name = name; + this.data = data; + } + }; + window._wails = window._wails || {}; + window._wails.dispatchWailsEvent = dispatchWailsEvent; + function dispatchWailsEvent(event) { + let listeners = eventListeners.get(event.name); + if (listeners) { + let toRemove = listeners.filter((listener) => { + let remove = listener.Callback(event); + if (remove) + return true; + }); + if (toRemove.length > 0) { + listeners = listeners.filter((l) => !toRemove.includes(l)); + if (listeners.length === 0) + eventListeners.delete(event.name); + else + eventListeners.set(event.name, listeners); + } + } + } + function OnMultiple(eventName, callback, maxCallbacks) { + let listeners = eventListeners.get(eventName) || []; + const thisListener = new Listener(eventName, callback, maxCallbacks); + listeners.push(thisListener); + eventListeners.set(eventName, listeners); + return () => listenerOff(thisListener); + } + function On(eventName, callback) { + return OnMultiple(eventName, callback, -1); + } + function Once(eventName, callback) { + return OnMultiple(eventName, callback, 1); + } + function listenerOff(listener) { + const eventName = listener.eventName; + let listeners = eventListeners.get(eventName).filter((l) => l !== listener); + if (listeners.length === 0) + eventListeners.delete(eventName); + else + eventListeners.set(eventName, listeners); + } + function Off(eventName, ...additionalEventNames) { + let eventsToRemove = [eventName, ...additionalEventNames]; + eventsToRemove.forEach((eventName2) => eventListeners.delete(eventName2)); + } + function OffAll() { + eventListeners.clear(); + } + function Emit(event) { + return call7(EmitMethod, event); + } + + // desktop/@wailsio/runtime/dialogs.js + var DialogInfo = 0; + var DialogWarning = 1; + var DialogError = 2; + var DialogQuestion = 3; + var DialogOpenFile = 4; + var DialogSaveFile = 5; + var call8 = newRuntimeCallerWithID(objectNames.Dialog, ""); + var dialogResponses = /* @__PURE__ */ new Map(); + function generateID2() { + let result; + do { + result = nanoid(); + } while (dialogResponses.has(result)); + return result; + } + function dialog(type, options = {}) { + const id = generateID2(); + options["dialog-id"] = id; + return new Promise((resolve, reject) => { + dialogResponses.set(id, { resolve, reject }); + call8(type, options).catch((error) => { + reject(error); + dialogResponses.delete(id); + }); + }); + } + function dialogCallback(id, data, isJSON) { + let p = dialogResponses.get(id); + if (p) { + if (isJSON) { + p.resolve(JSON.parse(data)); + } else { + p.resolve(data); + } + dialogResponses.delete(id); + } + } + function dialogErrorCallback(id, message) { + let p = dialogResponses.get(id); + if (p) { + p.reject(message); + dialogResponses.delete(id); + } + } + var Info = (options) => dialog(DialogInfo, options); + var Warning = (options) => dialog(DialogWarning, options); + var Error2 = (options) => dialog(DialogError, options); + var Question = (options) => dialog(DialogQuestion, options); + var OpenFile = (options) => dialog(DialogOpenFile, options); + var SaveFile = (options) => dialog(DialogSaveFile, options); + + // desktop/@wailsio/runtime/contextmenu.js + var call9 = newRuntimeCallerWithID(objectNames.ContextMenu, ""); + var ContextMenuOpen = 0; + function openContextMenu(id, x, y, data) { + void call9(ContextMenuOpen, { id, x, y, data }); + } + function setupContextMenus() { + window.addEventListener("contextmenu", contextMenuHandler); + } + function contextMenuHandler(event) { + let element = event.target; + let customContextMenu = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu"); + customContextMenu = customContextMenu ? customContextMenu.trim() : ""; + if (customContextMenu) { + event.preventDefault(); + let customContextMenuData = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu-data"); + openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData); + return; + } + processDefaultContextMenu(event); + } + function processDefaultContextMenu(event) { + if (true) { + return; + } + const element = event.target; + const computedStyle = window.getComputedStyle(element); + const defaultContextMenuAction = computedStyle.getPropertyValue("--default-contextmenu").trim(); + switch (defaultContextMenuAction) { + case "show": + return; + case "hide": + event.preventDefault(); + return; + default: + if (element.isContentEditable) { + return; + } + const selection = window.getSelection(); + const hasSelection = 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) === element) { + return; + } + } + } + } + if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") { + if (hasSelection || !element.readOnly && !element.disabled) { + return; + } + } + event.preventDefault(); + } + } + + // desktop/@wailsio/runtime/wml.js + function sendEvent(eventName, data = null) { + let event = new WailsEvent(eventName, data); + Emit(event); + } + function addWMLEventListeners() { + const elements = document.querySelectorAll("[wml-event]"); + elements.forEach(function(element) { + const eventType = element.getAttribute("wml-event"); + const confirm = element.getAttribute("wml-confirm"); + const trigger = element.getAttribute("wml-trigger") || "click"; + let callback = function() { + if (confirm) { + Question({ Title: "Confirm", Message: confirm, Detached: false, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { + if (result !== "No") { + sendEvent(eventType); + } + }); + return; + } + sendEvent(eventType); + }; + element.removeEventListener(trigger, callback); + element.addEventListener(trigger, callback); + }); + } + function callWindowMethod(method) { + let windowName = ""; + let targetWindow = Get(""); + let methodMap = WindowMethods(targetWindow); + if (!methodMap.has(method)) { + console.log("Window method " + method + " not found"); + } + methodMap.get(method)(); + } + function addWMLWindowListeners() { + const elements = document.querySelectorAll("[wml-window]"); + elements.forEach(function(element) { + const windowMethod = element.getAttribute("wml-window"); + const confirm = element.getAttribute("wml-confirm"); + const trigger = element.getAttribute("wml-trigger") || "click"; + let callback = function() { + if (confirm) { + Question({ Title: "Confirm", Message: confirm, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { + if (result !== "No") { + callWindowMethod(windowMethod); + } + }); + return; + } + callWindowMethod(windowMethod); + }; + element.removeEventListener(trigger, callback); + element.addEventListener(trigger, callback); + }); + } + function addWMLOpenBrowserListener() { + const elements = document.querySelectorAll("[wml-openurl]"); + elements.forEach(function(element) { + const url = element.getAttribute("wml-openurl"); + const confirm = element.getAttribute("wml-confirm"); + const trigger = element.getAttribute("wml-trigger") || "click"; + let callback = function() { + if (confirm) { + Question({ Title: "Confirm", Message: confirm, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { + if (result !== "No") { + void wails.Browser.OpenURL(url); + } + }); + return; + } + void wails.Browser.OpenURL(url); + }; + element.removeEventListener(trigger, callback); + element.addEventListener(trigger, callback); + }); + } + function reloadWML() { + console.log("Reloading WML"); + addWMLEventListeners(); + addWMLWindowListeners(); + addWMLOpenBrowserListener(); + } + + // desktop/@wailsio/runtime/flags.js + var flags = /* @__PURE__ */ new Map(); + function convertToMap(obj) { + const map = /* @__PURE__ */ new Map(); + for (const [key, value] of Object.entries(obj)) { + if (typeof value === "object" && value !== null) { + map.set(key, convertToMap(value)); + } else { + map.set(key, value); + } + } + return map; + } + fetch("/wails/flags").then((response) => { + response.json().then((data) => { + flags = convertToMap(data); + }); + }); + function getValueFromMap(keyString) { + const keys = keyString.split("."); + let value = flags; + for (const key of keys) { + if (value instanceof Map) { + value = value.get(key); + } else { + value = value[key]; + } + if (value === void 0) { + break; + } + } + return value; + } + function GetFlag(keyString) { + return getValueFromMap(keyString); + } + + // desktop/@wailsio/runtime/drag.js + var shouldDrag = false; + var resizeEdge = null; + var resizable = false; + var defaultCursor = "auto"; + window._wails = window._wails || {}; + window._wails.setResizable = setResizable2; + window._wails.endDrag = endDrag; + function dragTest(e) { + let val = window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region"); + if (val && val.trim() !== "drag" || e.buttons !== 1) { + return false; + } + return e.detail === 1; + } + function setupDrag() { + window.addEventListener("mousedown", onMouseDown); + window.addEventListener("mousemove", onMouseMove); + window.addEventListener("mouseup", onMouseUp); + } + function setResizable2(value) { + resizable = value; + } + function endDrag() { + document.body.style.cursor = "default"; + shouldDrag = false; + } + function testResize() { + if (resizeEdge) { + invoke(`resize:${resizeEdge}`); + return true; + } + return false; + } + function onMouseDown(e) { + if (IsWindows() && testResize() || dragTest(e)) { + shouldDrag = !!isValidDrag(e); + } + } + function isValidDrag(e) { + return !(e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight); + } + function onMouseUp(e) { + let mousePressed = e.buttons !== void 0 ? e.buttons : e.which; + if (mousePressed > 0) { + endDrag(); + } + } + function setResize(cursor = defaultCursor) { + document.documentElement.style.cursor = cursor; + resizeEdge = cursor; + } + function onMouseMove(e) { + shouldDrag = checkDrag(e); + if (IsWindows() && resizable) { + handleResize(e); + } + } + function checkDrag(e) { + let mousePressed = e.buttons !== void 0 ? e.buttons : e.which; + if (shouldDrag && mousePressed > 0) { + invoke("drag"); + return false; + } + return shouldDrag; + } + function handleResize(e) { + let resizeHandleHeight = GetFlag("system.resizeHandleHeight") || 5; + let resizeHandleWidth = GetFlag("system.resizeHandleWidth") || 5; + let cornerExtra = GetFlag("resizeCornerExtra") || 10; + let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth; + let leftBorder = e.clientX < resizeHandleWidth; + let topBorder = e.clientY < resizeHandleHeight; + let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight; + let rightCorner = window.outerWidth - e.clientX < resizeHandleWidth + cornerExtra; + let leftCorner = e.clientX < resizeHandleWidth + cornerExtra; + let topCorner = e.clientY < resizeHandleHeight + cornerExtra; + let bottomCorner = window.outerHeight - e.clientY < resizeHandleHeight + cornerExtra; + if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== void 0) { + setResize(); + } 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"); + else if (leftBorder) + setResize("w-resize"); + else if (topBorder) + setResize("n-resize"); + else if (bottomBorder) + setResize("s-resize"); + else if (rightBorder) + setResize("e-resize"); + } + + // desktop/main.js + window.wails = { + ...newRuntime(null), + clientId + }; + window._wails = { + dialogCallback, + dialogErrorCallback, + dispatchWailsEvent, + callErrorHandler: errorHandler, + callResultHandler: resultHandler, + endDrag, + setResizable: setResizable2 + }; + function newRuntime(windowName) { + return { + Clipboard: { + ...clipboard_exports + }, + Application: { + ...application_exports + }, + System: system_exports, + Screens: screens_exports, + Browser: browser_exports, + Call: { + Call, + ByID, + ByName, + Plugin + }, + WML: { + Reload: reloadWML + }, + Dialog: { + Info, + Warning, + Error: Error2, + Question, + OpenFile, + SaveFile + }, + Events: { + Emit, + On, + Once, + OnMultiple, + Off, + OffAll + }, + Window: { + ...Get("") + } + }; + } + setupContextMenus(); + setupDrag(); + document.addEventListener("DOMContentLoaded", function() { + reloadWML(); + }); +})(); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/@wailsio/runtime/clipboard.js", "node_modules/nanoid/non-secure/index.js", "desktop/@wailsio/runtime/runtime.js", "desktop/@wailsio/runtime/application.js", "desktop/@wailsio/runtime/screens.js", "desktop/@wailsio/runtime/system.js", "desktop/@wailsio/runtime/browser.js", "desktop/@wailsio/runtime/window.js", "desktop/@wailsio/runtime/calls.js", "desktop/@wailsio/runtime/events.js", "desktop/@wailsio/runtime/dialogs.js", "desktop/@wailsio/runtime/contextmenu.js", "desktop/@wailsio/runtime/wml.js", "desktop/@wailsio/runtime/flags.js", "desktop/@wailsio/runtime/drag.js", "desktop/main.js"],
  "sourcesContent": ["/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nconst call = newRuntimeCallerWithID(objectNames.Clipboard, '');\r\nconst ClipboardSetText = 0;\r\nconst ClipboardText = 1;\r\n\r\n/**\r\n * Sets the text to the Clipboard.\r\n *\r\n * @param {string} text - The text to be set to the Clipboard.\r\n * @return {Promise} - A Promise that resolves when the operation is successful.\r\n */\r\nexport function SetText(text) {\r\n    return call(ClipboardSetText, {text});\r\n}\r\n\r\n/**\r\n * Get the Clipboard text\r\n * @returns {Promise<string>} A promise that resolves with the text from the Clipboard.\r\n */\r\nexport function Text() {\r\n    return call(ClipboardText);\r\n}\r\n", "let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nexport let customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\r\n\r\n// Object Names\r\nexport const objectNames = {\r\n    Call: 0,\r\n    Clipboard: 1,\r\n    Application: 2,\r\n    Events: 3,\r\n    ContextMenu: 4,\r\n    Dialog: 5,\r\n    Window: 6,\r\n    Screens: 7,\r\n    System: 8,\r\n    Browser: 9,\r\n}\r\nexport let clientId = nanoid();\r\n\r\n/**\r\n * Creates a runtime caller function that invokes a specified method on a given object within a specified window context.\r\n *\r\n * @param {Object} object - The object on which the method is to be invoked.\r\n * @param {string} windowName - The name of the window context in which the method should be called.\r\n * @returns {Function} A runtime caller function that takes the method name and optionally arguments and invokes the method within the specified window context.\r\n */\r\nexport function newRuntimeCaller(object, windowName) {\r\n    return function (method, args=null) {\r\n        return runtimeCall(object + \".\" + method, windowName, args);\r\n    };\r\n}\r\n\r\n/**\r\n * Creates a new runtime caller with specified ID.\r\n *\r\n * @param {object} object - The object to invoke the method on.\r\n * @param {string} windowName - The name of the window.\r\n * @return {Function} - The new runtime caller function.\r\n */\r\nexport function newRuntimeCallerWithID(object, windowName) {\r\n    return function (method, args=null) {\r\n        return runtimeCallWithID(object, method, windowName, args);\r\n    };\r\n}\r\n\r\n\r\nfunction runtimeCall(method, windowName, args) {\r\n    let url = new URL(runtimeURL);\r\n    if( method ) {\r\n        url.searchParams.append(\"method\", method);\r\n    }\r\n    let fetchOptions = {\r\n        headers: {},\r\n    };\r\n    if (windowName) {\r\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n    if (args) {\r\n        url.searchParams.append(\"args\", JSON.stringify(args));\r\n    }\r\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\r\n\r\n    return new Promise((resolve, reject) => {\r\n        fetch(url, fetchOptions)\r\n            .then(response => {\r\n                if (response.ok) {\r\n                    // check content type\r\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\r\n                        return response.json();\r\n                    } else {\r\n                        return response.text();\r\n                    }\r\n                }\r\n                reject(Error(response.statusText));\r\n            })\r\n            .then(data => resolve(data))\r\n            .catch(error => reject(error));\r\n    });\r\n}\r\n\r\nfunction runtimeCallWithID(objectID, method, windowName, args) {\r\n    let url = new URL(runtimeURL);\r\n    url.searchParams.append(\"object\", objectID);\r\n    url.searchParams.append(\"method\", method);\r\n    let fetchOptions = {\r\n        headers: {},\r\n    };\r\n    if (windowName) {\r\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n    if (args) {\r\n        url.searchParams.append(\"args\", JSON.stringify(args));\r\n    }\r\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\r\n    return new Promise((resolve, reject) => {\r\n        fetch(url, fetchOptions)\r\n            .then(response => {\r\n                if (response.ok) {\r\n                    // check content type\r\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\r\n                        return response.json();\r\n                    } else {\r\n                        return response.text();\r\n                    }\r\n                }\r\n                reject(Error(response.statusText));\r\n            })\r\n            .then(data => resolve(data))\r\n            .catch(error => reject(error));\r\n    });\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport { newRuntimeCallerWithID, objectNames } from \"./runtime\";\r\nconst call = newRuntimeCallerWithID(objectNames.Application);\r\n\r\nconst HideMethod = 0;\r\nconst ShowMethod = 1;\r\nconst QuitMethod = 2;\r\n\r\n/**\r\n * Hides a certain method by calling the HideMethod function.\r\n *\r\n * @return {Promise<void>}\r\n *\r\n */\r\nexport function Hide() {\r\n    return call(HideMethod);\r\n}\r\n\r\n/**\r\n * Calls the ShowMethod and returns the result.\r\n *\r\n * @return {Promise<void>}\r\n */\r\nexport function Show() {\r\n    return call(ShowMethod);\r\n}\r\n\r\n/**\r\n * Calls the QuitMethod to terminate the program.\r\n *\r\n * @return {Promise<void>}\r\n */\r\nexport function Quit() {\r\n    return call(QuitMethod);\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").Screen} Screen\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\nconst call = newRuntimeCallerWithID(objectNames.Screens, '');\r\n\r\nconst getAll = 0;\r\nconst getPrimary = 1;\r\nconst getCurrent = 2;\r\n\r\n/**\r\n * Gets all screens.\r\n * @returns {Promise<Screen[]>} A promise that resolves to an array of Screen objects.\r\n */\r\nexport function GetAll() {\r\n    return call(getAll);\r\n}\r\n/**\r\n * Gets the primary screen.\r\n * @returns {Promise<Screen>} A promise that resolves to the primary screen.\r\n */\r\nexport function GetPrimary() {\r\n    return call(getPrimary);\r\n}\r\n/**\r\n * Gets the current active screen.\r\n *\r\n * @returns {Promise<Screen>} A promise that resolves with the current active screen.\r\n */\r\nexport function GetCurrent() {\r\n    return call(getCurrent);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\nlet call = newRuntimeCallerWithID(objectNames.System, '');\r\nconst systemIsDarkMode = 0;\r\nconst environment = 1;\r\n\r\n/**\r\n * @function\r\n * Retrieves the system dark mode status.\r\n * @returns {Promise<boolean>} - A promise that resolves to a boolean value indicating if the system is in dark mode.\r\n */\r\nexport function IsDarkMode() {\r\n    return call(systemIsDarkMode);\r\n}\r\n\r\n\r\n/**\r\n * Fetches the capabilities of the application from the server.\r\n *\r\n * @async\r\n * @function Capabilities\r\n * @returns {Promise<Object>} A promise that resolves to an object containing the capabilities.\r\n */\r\nexport async function Capabilities() {\r\n    let response = fetch(\"/wails/capabilities\");\r\n    return response.json();\r\n}\r\n\r\n/**\r\n * @typedef {object} EnvironmentInfo\r\n * @property {string} OS - The operating system in use.\r\n * @property {string} Arch - The architecture of the system.\r\n */\r\n\r\n/**\r\n * @function\r\n * Retrieves environment details.\r\n * @returns {Promise<EnvironmentInfo>} - A promise that resolves to an object containing OS and system architecture.\r\n */\r\nexport function Environment() {\r\n    return call(environment);\r\n}\r\n\r\nexport let invoke = null;\r\nlet environmentCache = null;\r\n\r\nEnvironment()\r\n    .then(result => {\r\n        environmentCache = result;\r\n        invoke = IsWindows() ? window.chrome.webview.postMessage : window.webkit.messageHandlers.external.postMessage;\r\n    })\r\n    .catch(error => {\r\n        console.error(`Error getting Environment: ${error}`);\r\n    });\r\n\r\n/**\r\n * Checks if the current operating system is Windows.\r\n *\r\n * @return {boolean} True if the operating system is Windows, otherwise false.\r\n */\r\nexport function IsWindows() {\r\n    return environmentCache.OS === \"windows\";\r\n}\r\n\r\n/**\r\n * Checks if the current operating system is Linux.\r\n *\r\n * @returns {boolean} Returns true if the current operating system is Linux, false otherwise.\r\n */\r\nexport function IsLinux() {\r\n    return environmentCache.OS === \"linux\";\r\n}\r\n\r\n/**\r\n * Checks if the current environment is a macOS operating system.\r\n *\r\n * @returns {boolean} True if the environment is macOS, false otherwise.\r\n */\r\nexport function IsMac() {\r\n    return environmentCache.OS === \"darwin\";\r\n}\r\n\r\n/**\r\n * Checks if the current environment architecture is AMD64.\r\n * @returns {boolean} True if the current environment architecture is AMD64, false otherwise.\r\n */\r\nexport function IsAMD64() {\r\n    return environmentCache.Arch === \"amd64\";\r\n}\r\n\r\n/**\r\n * Checks if the current architecture is ARM.\r\n *\r\n * @returns {boolean} True if the current architecture is ARM, false otherwise.\r\n */\r\nexport function IsARM() {\r\n    return environmentCache.Arch === \"arm\";\r\n}\r\n\r\n/**\r\n * Checks if the current environment is ARM64 architecture.\r\n *\r\n * @returns {boolean} - Returns true if the environment is ARM64 architecture, otherwise returns false.\r\n */\r\nexport function IsARM64() {\r\n    return environmentCache.Arch === \"arm64\";\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nconst call = newRuntimeCallerWithID(objectNames.Browser, '');\r\nconst BrowserOpenURL = 0;\r\n\r\n/**\r\n * Open a browser window to the given URL\r\n * @param {string} url - The URL to open\r\n * @returns {Promise<string>}\r\n */\r\nexport function OpenURL(url) {\r\n    return call(BrowserOpenURL, {url});\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"../api/types\").Size} Size\r\n * @typedef {import(\"../api/types\").Position} Position\r\n * @typedef {import(\"../api/types\").Screen} Screen\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nconst center = 0;\r\nconst setTitle = 1;\r\nconst fullscreen = 2;\r\nconst unFullscreen = 3;\r\nconst setSize = 4;\r\nconst size = 5;\r\nconst setMaxSize = 6;\r\nconst setMinSize = 7;\r\nconst setAlwaysOnTop = 8;\r\nconst setRelativePosition = 9;\r\nconst relativePosition = 10;\r\nconst screen = 11;\r\nconst hide = 12;\r\nconst maximise = 13;\r\nconst unMaximise = 14;\r\nconst toggleMaximise = 15;\r\nconst minimise = 16;\r\nconst unMinimise = 17;\r\nconst restore = 18;\r\nconst show = 19;\r\nconst close = 20;\r\nconst setBackgroundColour = 21;\r\nconst setResizable = 22;\r\nconst width = 23;\r\nconst height = 24;\r\nconst zoomIn = 25;\r\nconst zoomOut = 26;\r\nconst zoomReset = 27;\r\nconst getZoomLevel = 28;\r\nconst setZoomLevel = 29;\r\n\r\nconst thisWindow = newRuntimeCallerWithID(objectNames.Window, '');\r\n\r\nfunction createWindow(call) {\r\n    return {\r\n        Get: (windowName) => createWindow(newRuntimeCallerWithID(objectNames.Window, windowName)),\r\n        Center: () => call(center),\r\n        SetTitle: (title) => call(setTitle, {title}),\r\n        Fullscreen: () => call(fullscreen),\r\n        UnFullscreen: () => call(unFullscreen),\r\n        SetSize: (width, height) => call(setSize, {width, height}),\r\n        Size: () => call(size),\r\n        SetMaxSize: (width, height) => call(setMaxSize, {width, height}),\r\n        SetMinSize: (width, height) => call(setMinSize, {width, height}),\r\n        SetAlwaysOnTop: (onTop) => call(setAlwaysOnTop, {alwaysOnTop: onTop}),\r\n        SetRelativePosition: (x, y) => call(setRelativePosition, {x, y}),\r\n        RelativePosition: () => call(relativePosition),\r\n        Screen: () => call(screen),\r\n        Hide: () => call(hide),\r\n        Maximise: () => call(maximise),\r\n        UnMaximise: () => call(unMaximise),\r\n        ToggleMaximise: () => call(toggleMaximise),\r\n        Minimise: () => call(minimise),\r\n        UnMinimise: () => call(unMinimise),\r\n        Restore: () => call(restore),\r\n        Show: () => call(show),\r\n        Close: () => call(close),\r\n        SetBackgroundColour: (r, g, b, a) => call(setBackgroundColour, {r, g, b, a}),\r\n        SetResizable: (resizable) => call(setResizable, {resizable}),\r\n        Width: () => call(width),\r\n        Height: () => call(height),\r\n        ZoomIn: () => call(zoomIn),\r\n        ZoomOut: () => call(zoomOut),\r\n        ZoomReset: () => call(zoomReset),\r\n        GetZoomLevel: () => call(getZoomLevel),\r\n        SetZoomLevel: (zoomLevel) => call(setZoomLevel, {zoomLevel}),\r\n    };\r\n}\r\n\r\n/**\r\n * Gets the specified window.\r\n *\r\n * @param {string} windowName - The name of the window to get.\r\n * @return {Object} - The specified window object.\r\n */\r\nexport function Get(windowName) {\r\n    return createWindow(newRuntimeCallerWithID(objectNames.Window, windowName));\r\n}\r\n\r\n/**\r\n * Returns a map of all methods in the current window.\r\n * @returns {Map} - A map of window methods.\r\n */\r\nexport function WindowMethods(targetWindow) {\r\n    // Create a new map to store methods\r\n    let result = new Map();\r\n\r\n    // Iterate over all properties of the window object\r\n    for (let method in targetWindow) {\r\n        // Check if the property is indeed a method (function)\r\n        if(typeof targetWindow[method] === 'function') {\r\n            // Add the method to the map\r\n            result.set(method, targetWindow[method]);\r\n        }\r\n\r\n    }\r\n    // Return the map of window methods\r\n    return result;\r\n}\r\nexport default {\r\n    ...Get('')\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\nimport { newRuntimeCallerWithID, objectNames } from \"./runtime\";\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nconst CallBinding = 0;\r\nconst call = newRuntimeCallerWithID(objectNames.Call, '');\r\nlet callResponses = new Map();\r\n\r\nwindow._wails = window._wails || {};\r\nwindow._wails.callCallback = resultHandler;\r\nwindow._wails.callErrorCallback = errorHandler;\r\n\r\nfunction generateID() {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (callResponses.has(result));\r\n    return result;\r\n}\r\n\r\nexport function resultHandler(id, data, isJSON) {\r\n    const promiseHandler = getAndDeleteResponse(id);\r\n    if (promiseHandler) {\r\n        promiseHandler.resolve(isJSON ? JSON.parse(data) : data);\r\n    }\r\n}\r\n\r\nexport function errorHandler(id, message) {\r\n    const promiseHandler = getAndDeleteResponse(id);\r\n    if (promiseHandler) {\r\n        promiseHandler.reject(message);\r\n    }\r\n}\r\n\r\nfunction getAndDeleteResponse(id) {\r\n    const response = callResponses.get(id);\r\n    callResponses.delete(id);\r\n    return response;\r\n}\r\n\r\nfunction callBinding(type, options = {}) {\r\n    return new Promise((resolve, reject) => {\r\n        const id = generateID();\r\n        options[\"call-id\"] = id;\r\n        callResponses.set(id, { resolve, reject });\r\n        call(type, options).catch((error) => {\r\n            reject(error);\r\n            callResponses.delete(id);\r\n        });\r\n    });\r\n}\r\n\r\n/**\r\n * Call method.\r\n *\r\n * @param {Object} options - The options for the method.\r\n * @returns {Object} - The result of the call.\r\n */\r\nexport function Call(options) {\r\n    return callBinding(CallBinding, options);\r\n}\r\n\r\n/**\r\n * Executes a method by name.\r\n *\r\n * @param {string} name - The name of the method in the format 'package.struct.method'.\r\n * @param {...*} args - The arguments to pass to the method.\r\n * @throws {Error} If the name is not a string or is not in the correct format.\r\n * @returns {*} The result of the method execution.\r\n */\r\nexport function ByName(name, ...args) {\r\n    if (typeof name !== \"string\" || name.split(\".\").length !== 3) {\r\n        throw new Error(\"CallByName requires a string in the format 'package.struct.method'\");\r\n    }\r\n    let [packageName, structName, methodName] = name.split(\".\");\r\n    return callBinding(CallBinding, {\r\n        packageName,\r\n        structName,\r\n        methodName,\r\n        args\r\n    });\r\n}\r\n\r\n/**\r\n * Calls a method by its ID with the specified arguments.\r\n *\r\n * @param {string} methodID - The ID of the method to call.\r\n * @param {...*} args - The arguments to pass to the method.\r\n * @return {*} - The result of the method call.\r\n */\r\nexport function ByID(methodID, ...args) {\r\n    return callBinding(CallBinding, {\r\n        methodID,\r\n        args\r\n    });\r\n}\r\n\r\n/**\r\n * Calls a method on a plugin.\r\n *\r\n * @param {string} pluginName - The name of the plugin.\r\n * @param {string} methodName - The name of the method to call.\r\n * @param {...*} args - The arguments to pass to the method.\r\n * @returns {*} - The result of the method call.\r\n */\r\nexport function Plugin(pluginName, methodName, ...args) {\r\n    return callBinding(CallBinding, {\r\n        packageName: \"wails-plugins\",\r\n        structName: pluginName,\r\n        methodName,\r\n        args\r\n    });\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./types\").WailsEvent} WailsEvent\r\n */\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nconst call = newRuntimeCallerWithID(objectNames.Events, '');\r\nconst EmitMethod = 0;\r\nconst eventListeners = new Map();\r\n\r\nclass Listener {\r\n    constructor(eventName, callback, maxCallbacks) {\r\n        this.eventName = eventName;\r\n        this.maxCallbacks = maxCallbacks || -1;\r\n        this.Callback = (data) => {\r\n            callback(data);\r\n            if (this.maxCallbacks === -1) return false;\r\n            this.maxCallbacks -= 1;\r\n            return this.maxCallbacks === 0;\r\n        };\r\n    }\r\n}\r\n\r\nexport class WailsEvent {\r\n    constructor(name, data = null) {\r\n        this.name = name;\r\n        this.data = data;\r\n    }\r\n}\r\n\r\n\r\nwindow._wails = window._wails || {};\r\nwindow._wails.dispatchWailsEvent = dispatchWailsEvent;\r\n\r\nexport function dispatchWailsEvent(event) {\r\n    let listeners = eventListeners.get(event.name);\r\n    if (listeners) {\r\n        let toRemove = listeners.filter(listener => {\r\n            let remove = listener.Callback(event);\r\n            if (remove) return true;\r\n        });\r\n        if (toRemove.length > 0) {\r\n            listeners = listeners.filter(l => !toRemove.includes(l));\r\n            if (listeners.length === 0) eventListeners.delete(event.name);\r\n            else eventListeners.set(event.name, listeners);\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Register a callback function to be called multiple times for a specific event.\r\n *\r\n * @param {string} eventName - The name of the event to register the callback for.\r\n * @param {function} callback - The callback function to be called when the event is triggered.\r\n * @param {number} maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.\r\n *\r\n @return {function} - A function that, when called, will unregister the callback from the event.\r\n */\r\nexport function OnMultiple(eventName, callback, maxCallbacks) {\r\n    let listeners = eventListeners.get(eventName) || [];\r\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\r\n    listeners.push(thisListener);\r\n    eventListeners.set(eventName, listeners);\r\n    return () => listenerOff(thisListener);\r\n}\r\n\r\n/**\r\n * Registers a callback function to be executed when the specified event occurs.\r\n *\r\n * @param {string} eventName - The name of the event.\r\n * @param {function} callback - The callback function to be executed. It takes no parameters.\r\n * @return {function} - A function that, when called, will unregister the callback from the event. */\r\nexport function On(eventName, callback) { return OnMultiple(eventName, callback, -1); }\r\n\r\n/**\r\n * Registers a callback function to be executed only once for the specified event.\r\n *\r\n * @param {string} eventName - The name of the event.\r\n * @param {function} callback - The function to be executed when the event occurs.\r\n * @return {void@return {function} - A function that, when called, will unregister the callback from the event.\r\n */\r\nexport function Once(eventName, callback) { return OnMultiple(eventName, callback, 1); }\r\n\r\n/**\r\n * Removes the specified listener from the event listeners collection.\r\n * If all listeners for the event are removed, the event key is deleted from the collection.\r\n *\r\n * @param {Object} listener - The listener to be removed.\r\n */\r\nfunction listenerOff(listener) {\r\n    const eventName = listener.eventName;\r\n    let listeners = eventListeners.get(eventName).filter(l => l !== listener);\r\n    if (listeners.length === 0) eventListeners.delete(eventName);\r\n    else eventListeners.set(eventName, listeners);\r\n}\r\n\r\n\r\n/**\r\n * Removes event listeners for the specified event names.\r\n *\r\n * @param {string} eventName - The name of the event to remove listeners for.\r\n * @param {...string} additionalEventNames - Additional event names to remove listeners for.\r\n * @return {undefined}\r\n */\r\nexport function Off(eventName, ...additionalEventNames) {\r\n    let eventsToRemove = [eventName, ...additionalEventNames];\r\n    eventsToRemove.forEach(eventName => eventListeners.delete(eventName));\r\n}\r\n/**\r\n * Removes all event listeners.\r\n *\r\n * @function OffAll\r\n * @returns {void}\r\n */\r\nexport function OffAll() { eventListeners.clear(); }\r\n\r\n/**\r\n * Emits an event using the given event name.\r\n *\r\n * @param {WailsEvent} event - The name of the event to emit.\r\n * @returns {any} - The result of the emitted event.\r\n */\r\nexport function Emit(event) { return call(EmitMethod, event); }\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./types\").MessageDialogOptions} MessageDialogOptions\r\n * @typedef {import(\"./types\").OpenDialogOptions} OpenDialogOptions\r\n * @typedef {import(\"./types\").SaveDialogOptions} SaveDialogOptions\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\n// Define constants from the `methods` object in Title Case\r\nconst DialogInfo = 0;\r\nconst DialogWarning = 1;\r\nconst DialogError = 2;\r\nconst DialogQuestion = 3;\r\nconst DialogOpenFile = 4;\r\nconst DialogSaveFile = 5;\r\n\r\nconst call = newRuntimeCallerWithID(objectNames.Dialog, '');\r\nconst dialogResponses = new Map();\r\n\r\n/**\r\n * Generates a unique id that is not present in dialogResponses.\r\n * @returns {string} unique id\r\n */\r\nfunction generateID() {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (dialogResponses.has(result));\r\n    return result;\r\n}\r\n\r\n/**\r\n * Shows a dialog of specified type with the given options.\r\n * @param {number} type - type of dialog\r\n * @param {object} options - options for the dialog\r\n * @returns {Promise} promise that resolves with result of dialog\r\n */\r\nfunction dialog(type, options = {}) {\r\n    const id = generateID();\r\n    options[\"dialog-id\"] = id;\r\n    return new Promise((resolve, reject) => {\r\n        dialogResponses.set(id, {resolve, reject});\r\n        call(type, options).catch((error) => {\r\n            reject(error);\r\n            dialogResponses.delete(id);\r\n        });\r\n    });\r\n}\r\n\r\n/**\r\n * Handles the callback from a dialog.\r\n *\r\n * @param {string} id - The ID of the dialog response.\r\n * @param {string} data - The data received from the dialog.\r\n * @param {boolean} isJSON - Flag indicating whether the data is in JSON format.\r\n *\r\n * @return {undefined}\r\n */\r\nexport function dialogCallback(id, data, isJSON) {\r\n    let p = dialogResponses.get(id);\r\n    if (p) {\r\n        if (isJSON) {\r\n            p.resolve(JSON.parse(data));\r\n        } else {\r\n            p.resolve(data);\r\n        }\r\n        dialogResponses.delete(id);\r\n    }\r\n}\r\n\r\n/**\r\n * Callback function for handling errors in dialog.\r\n *\r\n * @param {string} id - The id of the dialog response.\r\n * @param {string} message - The error message.\r\n *\r\n * @return {void}\r\n */\r\nexport function dialogErrorCallback(id, message) {\r\n    let p = dialogResponses.get(id);\r\n    if (p) {\r\n        p.reject(message);\r\n        dialogResponses.delete(id);\r\n    }\r\n}\r\n\r\n\r\n// Replace `methods` with constants in Title Case\r\n\r\n/**\r\n * @param {MessageDialogOptions} options - Dialog options\r\n * @returns {Promise<string>} - The label of the button pressed\r\n */\r\nexport const Info = (options) => dialog(DialogInfo, options);\r\n\r\n/**\r\n * @param {MessageDialogOptions} options - Dialog options\r\n * @returns {Promise<string>} - The label of the button pressed\r\n */\r\nexport const Warning = (options) => dialog(DialogWarning, options);\r\n\r\n/**\r\n * @param {MessageDialogOptions} options - Dialog options\r\n * @returns {Promise<string>} - The label of the button pressed\r\n */\r\nexport const Error = (options) => dialog(DialogError, options);\r\n\r\n/**\r\n * @param {MessageDialogOptions} options - Dialog options\r\n * @returns {Promise<string>} - The label of the button pressed\r\n */\r\nexport const Question = (options) => dialog(DialogQuestion, options);\r\n\r\n/**\r\n * @param {OpenDialogOptions} options - Dialog options\r\n * @returns {Promise<string[]|string>} Returns selected file or list of files. Returns blank string if no file is selected.\r\n */\r\nexport const OpenFile = (options) => dialog(DialogOpenFile, options);\r\n\r\n/**\r\n * @param {SaveDialogOptions} options - Dialog options\r\n * @returns {Promise<string>} Returns the selected file. Returns blank string if no file is selected.\r\n */\r\nexport const SaveFile = (options) => dialog(DialogSaveFile, options);\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nconst call = newRuntimeCallerWithID(objectNames.ContextMenu, '');\r\nconst ContextMenuOpen = 0;\r\n\r\nfunction openContextMenu(id, x, y, data) {\r\n    void call(ContextMenuOpen, {id, x, y, data});\r\n}\r\n\r\nexport function setupContextMenus() {\r\n    window.addEventListener('contextmenu', contextMenuHandler);\r\n}\r\n\r\nfunction contextMenuHandler(event) {\r\n    // Check for custom context menu\r\n    let element = event.target;\r\n    let customContextMenu = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu\");\r\n    customContextMenu = customContextMenu ? customContextMenu.trim() : \"\";\r\n    if (customContextMenu) {\r\n        event.preventDefault();\r\n        let customContextMenuData = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu-data\");\r\n        openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);\r\n        return\r\n    }\r\n\r\n    processDefaultContextMenu(event);\r\n}\r\n\r\n\r\n/*\r\n--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\r\n--default-contextmenu: show; will always show the default context menu\r\n--default-contextmenu: hide; will always hide the default context menu\r\n\r\nThis rule is inherited like normal CSS rules, so nesting works as expected\r\n*/\r\nfunction processDefaultContextMenu(event) {\r\n    // Debug builds always show the menu\r\n    if (DEBUG) {\r\n        return;\r\n    }\r\n\r\n    // Process default context menu\r\n    const element = event.target;\r\n    const computedStyle = window.getComputedStyle(element);\r\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\r\n    switch (defaultContextMenuAction) {\r\n        case \"show\":\r\n            return;\r\n        case \"hide\":\r\n            event.preventDefault();\r\n            return;\r\n        default:\r\n            // Check if contentEditable is true\r\n            if (element.isContentEditable) {\r\n                return;\r\n            }\r\n\r\n            // Check if text has been selected\r\n            const selection = window.getSelection();\r\n            const hasSelection = (selection.toString().length > 0)\r\n            if (hasSelection) {\r\n                for (let i = 0; i < selection.rangeCount; i++) {\r\n                    const range = selection.getRangeAt(i);\r\n                    const rects = range.getClientRects();\r\n                    for (let j = 0; j < rects.length; j++) {\r\n                        const rect = rects[j];\r\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\r\n                            return;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // Check if tagname is input or textarea\r\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\r\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\r\n                    return;\r\n                }\r\n            }\r\n\r\n            // hide default context menu\r\n            event.preventDefault();\r\n    }\r\n}\r\n", "\r\nimport {Emit, WailsEvent} from \"./events\";\r\nimport {Question} from \"./dialogs\";\r\nimport {WindowMethods, Get} from \"./window\";\r\n\r\n/**\r\n * Sends an event with the given name and optional data.\r\n *\r\n * @param {string} eventName - The name of the event to send.\r\n * @param {any} [data=null] - Optional data to send along with the event.\r\n *\r\n * @return {void}\r\n */\r\nfunction sendEvent(eventName, data=null) {\r\n    let event = new WailsEvent(eventName, data);\r\n    Emit(event);\r\n}\r\n\r\n/**\r\n * Adds event listeners to elements with `wml-event` attribute.\r\n *\r\n * @return {void}\r\n */\r\nfunction addWMLEventListeners() {\r\n    const elements = document.querySelectorAll('[wml-event]');\r\n    elements.forEach(function (element) {\r\n        const eventType = element.getAttribute('wml-event');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Detached: false, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        sendEvent(eventType);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            sendEvent(eventType);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\n/**\r\n * Calls a method on the window object.\r\n *\r\n * @param {string} method - The name of the method to call on the window object.\r\n *\r\n * @return {void}\r\n */\r\nfunction callWindowMethod(method) {\r\n    // TODO: Make this a parameter!\r\n    let windowName = '';\r\n    let targetWindow = Get('');\r\n    let methodMap = WindowMethods(targetWindow);\r\n    if (!methodMap.has(method)) {\r\n        console.log(\"Window method \" + method + \" not found\");\r\n    }\r\n    methodMap.get(method)();\r\n}\r\n\r\n/**\r\n * Adds window listeners for elements with the 'wml-window' attribute.\r\n * Removes any existing listeners before adding new ones.\r\n *\r\n * @return {void}\r\n */\r\nfunction addWMLWindowListeners() {\r\n    const elements = document.querySelectorAll('[wml-window]');\r\n    elements.forEach(function (element) {\r\n        const windowMethod = element.getAttribute('wml-window');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        callWindowMethod(windowMethod);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            callWindowMethod(windowMethod);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\n/**\r\n * Adds a listener to elements with the 'wml-openurl' attribute.\r\n * When the specified trigger event is fired on any of these elements,\r\n * the listener will open the URL specified by the 'wml-openurl' attribute.\r\n * If a 'wml-confirm' attribute is provided, a confirmation dialog will be displayed,\r\n * and the URL will only be opened if the user confirms.\r\n *\r\n * @return {void}\r\n */\r\nfunction addWMLOpenBrowserListener() {\r\n    const elements = document.querySelectorAll('[wml-openurl]');\r\n    elements.forEach(function (element) {\r\n        const url = element.getAttribute('wml-openurl');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        void wails.Browser.OpenURL(url);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            void wails.Browser.OpenURL(url);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\n/**\r\n * Reloads the WML page by adding necessary event listeners and browser listeners.\r\n *\r\n * @return {void}\r\n */\r\nexport function reloadWML() {\r\n    console.log(\"Reloading WML\");\r\n    addWMLEventListeners();\r\n    addWMLWindowListeners();\r\n    addWMLOpenBrowserListener();\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nlet flags = new Map();\r\n\r\nfunction convertToMap(obj) {\r\n    const map = new Map();\r\n\r\n    for (const [key, value] of Object.entries(obj)) {\r\n        if (typeof value === 'object' && value !== null) {\r\n            map.set(key, convertToMap(value)); // Recursively convert nested object\r\n        } else {\r\n            map.set(key, value);\r\n        }\r\n    }\r\n\r\n    return map;\r\n}\r\n\r\nfetch(\"/wails/flags\").then((response) => {\r\n    response.json().then((data) => {\r\n        flags = convertToMap(data);\r\n    });\r\n});\r\n\r\n\r\nfunction getValueFromMap(keyString) {\r\n    const keys = keyString.split('.');\r\n    let value = flags;\r\n\r\n    for (const key of keys) {\r\n        if (value instanceof Map) {\r\n            value = value.get(key);\r\n        } else {\r\n            value = value[key];\r\n        }\r\n\r\n        if (value === undefined) {\r\n            break;\r\n        }\r\n    }\r\n\r\n    return value;\r\n}\r\n\r\n/**\r\n * Retrieves the value associated with the specified key from the flag map.\r\n *\r\n * @param {string} keyString - The key to retrieve the value for.\r\n * @return {*} - The value associated with the specified key.\r\n */\r\nexport function GetFlag(keyString) {\r\n    return getValueFromMap(keyString);\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {invoke, IsWindows} from \"./system\";\r\nimport {GetFlag} from \"./flags\";\r\n\r\nlet shouldDrag = false;\r\nlet resizeEdge = null;\r\nlet resizable = false;\r\nlet defaultCursor = \"auto\";\r\nwindow._wails = window._wails || {};\r\nwindow._wails.setResizable = setResizable;\r\nwindow._wails.endDrag = endDrag;\r\n\r\nexport function dragTest(e) {\r\n    let val = window.getComputedStyle(e.target).getPropertyValue(\"--webkit-app-region\");\r\n    if (val && val.trim() !== \"drag\" || e.buttons !== 1) {\r\n        return false;\r\n    }\r\n    return e.detail === 1;\r\n}\r\n\r\nexport function setupDrag() {\r\n    window.addEventListener('mousedown', onMouseDown);\r\n    window.addEventListener('mousemove', onMouseMove);\r\n    window.addEventListener('mouseup', onMouseUp);\r\n}\r\n\r\nexport function setResizable(value) {\r\n    resizable = value;\r\n}\r\n\r\nexport function endDrag() {\r\n    document.body.style.cursor = 'default';\r\n    shouldDrag = false;\r\n}\r\n\r\nfunction testResize() {\r\n    if( resizeEdge ) {\r\n        invoke(`resize:${resizeEdge}`);\r\n        return true\r\n    }\r\n    return false;\r\n}\r\n\r\nfunction onMouseDown(e) {\r\n    if(IsWindows() && testResize() || dragTest(e)) {\r\n        shouldDrag = !!isValidDrag(e);\r\n    }\r\n}\r\n\r\nfunction isValidDrag(e) {\r\n    // Ignore drag on scrollbars\r\n    return !(e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight);\r\n}\r\n\r\nfunction onMouseUp(e) {\r\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n    if (mousePressed > 0) {\r\n        endDrag();\r\n    }\r\n}\r\n\r\nfunction setResize(cursor = defaultCursor) {\r\n    document.documentElement.style.cursor = cursor;\r\n    resizeEdge = cursor;\r\n}\r\n\r\nfunction onMouseMove(e) {\r\n    shouldDrag = checkDrag(e);\r\n    if (IsWindows() && resizable) {\r\n        handleResize(e);\r\n    }\r\n}\r\n\r\nfunction checkDrag(e) {\r\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n    if(shouldDrag && mousePressed > 0) {\r\n        invoke(\"drag\");\r\n        return false;\r\n    }\r\n    return shouldDrag;\r\n}\r\n\r\nfunction handleResize(e) {\r\n    let resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\r\n    let resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\r\n\r\n    // Extra pixels for the corner areas\r\n    let cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\r\n\r\n    let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;\r\n    let leftBorder = e.clientX < resizeHandleWidth;\r\n    let topBorder = e.clientY < resizeHandleHeight;\r\n    let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;\r\n\r\n    // Adjust for corners\r\n    let rightCorner = window.outerWidth - e.clientX < (resizeHandleWidth + cornerExtra);\r\n    let leftCorner = e.clientX < (resizeHandleWidth + cornerExtra);\r\n    let topCorner = e.clientY < (resizeHandleHeight + cornerExtra);\r\n    let bottomCorner = window.outerHeight - e.clientY < (resizeHandleHeight + cornerExtra);\r\n\r\n    // If we aren't on an edge, but were, reset the cursor to default\r\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== undefined) {\r\n        setResize();\r\n    }\r\n    // Adjusted for corner areas\r\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\r\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\r\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\r\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\r\n    else if (leftBorder) setResize(\"w-resize\");\r\n    else if (topBorder) setResize(\"n-resize\");\r\n    else if (bottomBorder) setResize(\"s-resize\");\r\n    else if (rightBorder) setResize(\"e-resize\");\r\n}\r\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 9 */\r\n\r\n\r\nimport * as Clipboard from './@wailsio/runtime/clipboard';\r\nimport * as Application from './@wailsio/runtime/application';\r\nimport * as Screens from './@wailsio/runtime/screens';\r\nimport * as System from './@wailsio/runtime/system';\r\nimport * as Browser from './@wailsio/runtime/browser';\r\nimport * as Window from './@wailsio/runtime/window';\r\nimport {Plugin, Call, errorHandler as callErrorHandler, resultHandler as callResultHandler, ByID, ByName} from \"./@wailsio/runtime/calls\";\r\nimport {clientId} from './@wailsio/runtime/runtime';\r\nimport {dispatchWailsEvent, Emit, Off, OffAll, On, Once, OnMultiple} from \"./@wailsio/runtime/events\";\r\nimport {dialogCallback, dialogErrorCallback, Error, Info, OpenFile, Question, SaveFile, Warning} from \"./@wailsio/runtime/dialogs\";\r\nimport {setupContextMenus} from './@wailsio/runtime/contextmenu';\r\nimport {reloadWML} from './@wailsio/runtime/wml';\r\nimport {setupDrag, endDrag, setResizable} from './@wailsio/runtime/drag';\r\n\r\nwindow.wails = {\r\n    ...newRuntime(null),\r\n    clientId: clientId,\r\n};\r\n\r\n// Internal wails endpoints\r\nwindow._wails = {\r\n    dialogCallback,\r\n    dialogErrorCallback,\r\n    dispatchWailsEvent,\r\n    callErrorHandler,\r\n    callResultHandler,\r\n    endDrag,\r\n    setResizable,\r\n};\r\n\r\nexport function newRuntime(windowName) {\r\n    return {\r\n        Clipboard: {\r\n            ...Clipboard\r\n        },\r\n        Application: {\r\n            ...Application,\r\n        },\r\n        System,\r\n        Screens,\r\n        Browser,\r\n        Call: {\r\n            Call,\r\n            ByID,\r\n            ByName,\r\n            Plugin,\r\n        },\r\n        WML: {\r\n            Reload: reloadWML,\r\n        },\r\n        Dialog: {\r\n            Info,\r\n            Warning,\r\n            Error,\r\n            Question,\r\n            OpenFile,\r\n            SaveFile,\r\n        },\r\n        Events: {\r\n            Emit,\r\n            On,\r\n            Once,\r\n            OnMultiple,\r\n            Off,\r\n            OffAll,\r\n        },\r\n        Window: {\r\n            ...Window.Get('')\r\n        },\r\n    };\r\n}\r\n\r\nsetupContextMenus();\r\nsetupDrag();\r\n\r\ndocument.addEventListener(\"DOMContentLoaded\", function() {\r\n    reloadWML();\r\n});\r\n"],
  "mappings": "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",
  "names": ["size", "call", "call", "call", "call", "call", "width", "height", "resizable", "call", "call", "eventName", "call", "generateID", "Error", "call", "setResizable", "setResizable", "Error"]
}
 diff --git a/v3/internal/runtime/runtime_debug_darwin.go b/v3/internal/runtime/runtime_debug_darwin.go deleted file mode 100644 index 14656126ffc..00000000000 --- a/v3/internal/runtime/runtime_debug_darwin.go +++ /dev/null @@ -1,8 +0,0 @@ -//go:build darwin && !production - -package runtime - -import _ "embed" - -//go:embed runtime_debug_desktop_darwin.js -var DesktopRuntime []byte diff --git a/v3/internal/runtime/runtime_debug_desktop_darwin.js b/v3/internal/runtime/runtime_debug_desktop_darwin.js deleted file mode 100644 index 3e0861b89b2..00000000000 --- a/v3/internal/runtime/runtime_debug_desktop_darwin.js +++ /dev/null @@ -1,873 +0,0 @@ -(() => { - var __defProp = Object.defineProperty; - var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); - }; - - // desktop/clipboard.js - var clipboard_exports = {}; - __export(clipboard_exports, { - SetText: () => SetText, - Text: () => Text - }); - - // node_modules/nanoid/non-secure/index.js - var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict"; - var nanoid = (size = 21) => { - let id = ""; - let i = size; - while (i--) { - id += urlAlphabet[Math.random() * 64 | 0]; - } - return id; - }; - - // desktop/runtime.js - var runtimeURL = window.location.origin + "/wails/runtime"; - var objectNames = { - Call: 0, - Clipboard: 1, - Application: 2, - Events: 3, - ContextMenu: 4, - Dialog: 5, - Window: 6, - Screens: 7, - System: 8, - Browser: 9 - }; - var clientId = nanoid(); - function runtimeCallWithID(objectID, method, windowName, args) { - let url = new URL(runtimeURL); - url.searchParams.append("object", objectID); - url.searchParams.append("method", method); - let fetchOptions = { - headers: {} - }; - if (windowName) { - fetchOptions.headers["x-wails-window-name"] = windowName; - } - if (args) { - url.searchParams.append("args", JSON.stringify(args)); - } - fetchOptions.headers["x-wails-client-id"] = clientId; - return new Promise((resolve, reject) => { - fetch(url, fetchOptions).then((response) => { - if (response.ok) { - if (response.headers.get("Content-Type") && response.headers.get("Content-Type").indexOf("application/json") !== -1) { - return response.json(); - } else { - return response.text(); - } - } - reject(Error(response.statusText)); - }).then((data) => resolve(data)).catch((error) => reject(error)); - }); - } - function newRuntimeCallerWithID(object, windowName) { - return function(method, args = null) { - return runtimeCallWithID(object, method, windowName, args); - }; - } - - // desktop/clipboard.js - var call = newRuntimeCallerWithID(objectNames.Clipboard); - var ClipboardSetText = 0; - var ClipboardText = 1; - function SetText(text) { - void call(ClipboardSetText, { text }); - } - function Text() { - return call(ClipboardText); - } - - // desktop/application.js - var application_exports = {}; - __export(application_exports, { - Hide: () => Hide, - Quit: () => Quit, - Show: () => Show - }); - var call2 = newRuntimeCallerWithID(objectNames.Application); - var methods = { - Hide: 0, - Show: 1, - Quit: 2 - }; - function Hide() { - void call2(methods.Hide); - } - function Show() { - void call2(methods.Show); - } - function Quit() { - void call2(methods.Quit); - } - - // desktop/screens.js - var screens_exports = {}; - __export(screens_exports, { - GetAll: () => GetAll, - GetCurrent: () => GetCurrent, - GetPrimary: () => GetPrimary - }); - var call3 = newRuntimeCallerWithID(objectNames.Screens); - var ScreensGetAll = 0; - var ScreensGetPrimary = 1; - var ScreensGetCurrent = 2; - function GetAll() { - return call3(ScreensGetAll); - } - function GetPrimary() { - return call3(ScreensGetPrimary); - } - function GetCurrent() { - return call3(ScreensGetCurrent); - } - - // desktop/system.js - var system_exports = {}; - __export(system_exports, { - IsDarkMode: () => IsDarkMode - }); - var call4 = newRuntimeCallerWithID(objectNames.System); - var SystemIsDarkMode = 0; - function IsDarkMode() { - return call4(SystemIsDarkMode); - } - - // desktop/browser.js - var browser_exports = {}; - __export(browser_exports, { - OpenURL: () => OpenURL - }); - var call5 = newRuntimeCallerWithID(objectNames.Browser); - var BrowserOpenURL = 0; - function OpenURL(url) { - void call5(BrowserOpenURL, { url }); - } - - // desktop/calls.js - var call6 = newRuntimeCallerWithID(objectNames.Call); - var CallBinding = 0; - var callResponses = /* @__PURE__ */ new Map(); - function generateID() { - let result; - do { - result = nanoid(); - } while (callResponses.has(result)); - return result; - } - function callCallback(id, data, isJSON) { - let p = callResponses.get(id); - if (p) { - if (isJSON) { - p.resolve(JSON.parse(data)); - } else { - p.resolve(data); - } - callResponses.delete(id); - } - } - function callErrorCallback(id, message) { - let p = callResponses.get(id); - if (p) { - p.reject(message); - callResponses.delete(id); - } - } - function callBinding(type, options) { - return new Promise((resolve, reject) => { - let id = generateID(); - options = options || {}; - options["call-id"] = id; - callResponses.set(id, { resolve, reject }); - call6(type, options).catch((error) => { - reject(error); - callResponses.delete(id); - }); - }); - } - function Call(options) { - return callBinding(CallBinding, options); - } - function CallByName(name, ...args) { - if (typeof name !== "string" || name.split(".").length !== 3) { - throw new Error("CallByName requires a string in the format 'package.struct.method'"); - } - let parts = name.split("."); - return callBinding(CallBinding, { - packageName: parts[0], - structName: parts[1], - methodName: parts[2], - args - }); - } - function CallByID(methodID, ...args) { - return callBinding(CallBinding, { - methodID, - args - }); - } - function Plugin(pluginName, methodName, ...args) { - return callBinding(CallBinding, { - packageName: "wails-plugins", - structName: pluginName, - methodName, - args - }); - } - - // desktop/window.js - var WindowCenter = 0; - var WindowSetTitle = 1; - var WindowFullscreen = 2; - var WindowUnFullscreen = 3; - var WindowSetSize = 4; - var WindowSize = 5; - var WindowSetMaxSize = 6; - var WindowSetMinSize = 7; - var WindowSetAlwaysOnTop = 8; - var WindowSetRelativePosition = 9; - var WindowRelativePosition = 10; - var WindowScreen = 11; - var WindowHide = 12; - var WindowMaximise = 13; - var WindowUnMaximise = 14; - var WindowToggleMaximise = 15; - var WindowMinimise = 16; - var WindowUnMinimise = 17; - var WindowRestore = 18; - var WindowShow = 19; - var WindowClose = 20; - var WindowSetBackgroundColour = 21; - var WindowSetResizable = 22; - var WindowWidth = 23; - var WindowHeight = 24; - var WindowZoomIn = 25; - var WindowZoomOut = 26; - var WindowZoomReset = 27; - var WindowGetZoomLevel = 28; - var WindowSetZoomLevel = 29; - function newWindow(windowName) { - let call10 = newRuntimeCallerWithID(objectNames.Window, windowName); - return { - /** - * Centers the window. - */ - Center: () => void call10(WindowCenter), - /** - * Set the window title. - * @param title - */ - SetTitle: (title) => void call10(WindowSetTitle, { title }), - /** - * Makes the window fullscreen. - */ - Fullscreen: () => void call10(WindowFullscreen), - /** - * Unfullscreen the window. - */ - UnFullscreen: () => void call10(WindowUnFullscreen), - /** - * Set the window size. - * @param {number} width The window width - * @param {number} height The window height - */ - SetSize: (width, height) => call10(WindowSetSize, { width, height }), - /** - * Get the window size. - * @returns {Promise} The window size - */ - Size: () => { - return call10(WindowSize); - }, - /** - * Set the window maximum size. - * @param {number} width - * @param {number} height - */ - SetMaxSize: (width, height) => void call10(WindowSetMaxSize, { width, height }), - /** - * Set the window minimum size. - * @param {number} width - * @param {number} height - */ - SetMinSize: (width, height) => void call10(WindowSetMinSize, { width, height }), - /** - * Set window to be always on top. - * @param {boolean} onTop Whether the window should be always on top - */ - SetAlwaysOnTop: (onTop) => void call10(WindowSetAlwaysOnTop, { alwaysOnTop: onTop }), - /** - * Set the window relative position. - * @param {number} x - * @param {number} y - */ - SetRelativePosition: (x, y) => call10(WindowSetRelativePosition, { x, y }), - /** - * Get the window position. - * @returns {Promise} The window position - */ - RelativePosition: () => { - return call10(WindowRelativePosition); - }, - /** - * Get the screen the window is on. - * @returns {Promise} - */ - Screen: () => { - return call10(WindowScreen); - }, - /** - * Hide the window - */ - Hide: () => void call10(WindowHide), - /** - * Maximise the window - */ - Maximise: () => void call10(WindowMaximise), - /** - * Show the window - */ - Show: () => void call10(WindowShow), - /** - * Close the window - */ - Close: () => void call10(WindowClose), - /** - * Toggle the window maximise state - */ - ToggleMaximise: () => void call10(WindowToggleMaximise), - /** - * Unmaximise the window - */ - UnMaximise: () => void call10(WindowUnMaximise), - /** - * Minimise the window - */ - Minimise: () => void call10(WindowMinimise), - /** - * Unminimise the window - */ - UnMinimise: () => void call10(WindowUnMinimise), - /** - * Restore the window - */ - Restore: () => void call10(WindowRestore), - /** - * Set the background colour of the window. - * @param {number} r - A value between 0 and 255 - * @param {number} g - A value between 0 and 255 - * @param {number} b - A value between 0 and 255 - * @param {number} a - A value between 0 and 255 - */ - SetBackgroundColour: (r, g, b, a) => void call10(WindowSetBackgroundColour, { r, g, b, a }), - /** - * Set whether the window can be resized or not - * @param {boolean} resizable - */ - SetResizable: (resizable2) => void call10(WindowSetResizable, { resizable: resizable2 }), - /** - * Get the window width - * @returns {Promise} - */ - Width: () => { - return call10(WindowWidth); - }, - /** - * Get the window height - * @returns {Promise} - */ - Height: () => { - return call10(WindowHeight); - }, - /** - * Zoom in the window - */ - ZoomIn: () => void call10(WindowZoomIn), - /** - * Zoom out the window - */ - ZoomOut: () => void call10(WindowZoomOut), - /** - * Reset the window zoom - */ - ZoomReset: () => void call10(WindowZoomReset), - /** - * Get the window zoom - * @returns {Promise} - */ - GetZoomLevel: () => { - return call10(WindowGetZoomLevel); - }, - /** - * Set the window zoom level - * @param {number} zoomLevel - */ - SetZoomLevel: (zoomLevel) => void call10(WindowSetZoomLevel, { zoomLevel }) - }; - } - - // desktop/events.js - var call7 = newRuntimeCallerWithID(objectNames.Events); - var EventEmit = 0; - var Listener = class { - /** - * Creates an instance of Listener. - * @param {string} eventName - * @param {function} callback - * @param {number} maxCallbacks - * @memberof Listener - */ - constructor(eventName, callback, maxCallbacks) { - this.eventName = eventName; - this.maxCallbacks = maxCallbacks || -1; - this.Callback = (data) => { - callback(data); - if (this.maxCallbacks === -1) { - return false; - } - this.maxCallbacks -= 1; - return this.maxCallbacks === 0; - }; - } - }; - var WailsEvent = class { - /** - * Creates an instance of WailsEvent. - * @param {string} name - Name of the event - * @param {any=null} data - Data associated with the event - * @memberof WailsEvent - */ - constructor(name, data = null) { - this.name = name; - this.data = data; - } - }; - var eventListeners = /* @__PURE__ */ new Map(); - function OnMultiple(eventName, callback, maxCallbacks) { - let listeners = eventListeners.get(eventName) || []; - const thisListener = new Listener(eventName, callback, maxCallbacks); - listeners.push(thisListener); - eventListeners.set(eventName, listeners); - return () => listenerOff(thisListener); - } - function On(eventName, callback) { - return OnMultiple(eventName, callback, -1); - } - function Once(eventName, callback) { - return OnMultiple(eventName, callback, 1); - } - function listenerOff(listener) { - const eventName = listener.eventName; - let listeners = eventListeners.get(eventName).filter((l) => l !== listener); - if (listeners.length === 0) { - eventListeners.delete(eventName); - } else { - eventListeners.set(eventName, listeners); - } - } - function dispatchWailsEvent(event) { - let listeners = eventListeners.get(event.name); - if (listeners) { - let toRemove = []; - listeners.forEach((listener) => { - let remove = listener.Callback(event); - if (remove) { - toRemove.push(listener); - } - }); - if (toRemove.length > 0) { - listeners = listeners.filter((l) => !toRemove.includes(l)); - if (listeners.length === 0) { - eventListeners.delete(event.name); - } else { - eventListeners.set(event.name, listeners); - } - } - } - } - function Off(eventName, ...additionalEventNames) { - let eventsToRemove = [eventName, ...additionalEventNames]; - eventsToRemove.forEach((eventName2) => { - eventListeners.delete(eventName2); - }); - } - function OffAll() { - eventListeners.clear(); - } - function Emit(event) { - void call7(EventEmit, event); - } - - // desktop/dialogs.js - var call8 = newRuntimeCallerWithID(objectNames.Dialog); - var DialogInfo = 0; - var DialogWarning = 1; - var DialogError = 2; - var DialogQuestion = 3; - var DialogOpenFile = 4; - var DialogSaveFile = 5; - var dialogResponses = /* @__PURE__ */ new Map(); - function generateID2() { - let result; - do { - result = nanoid(); - } while (dialogResponses.has(result)); - return result; - } - function dialogCallback(id, data, isJSON) { - let p = dialogResponses.get(id); - if (p) { - if (isJSON) { - p.resolve(JSON.parse(data)); - } else { - p.resolve(data); - } - dialogResponses.delete(id); - } - } - function dialogErrorCallback(id, message) { - let p = dialogResponses.get(id); - if (p) { - p.reject(message); - dialogResponses.delete(id); - } - } - function dialog(type, options) { - return new Promise((resolve, reject) => { - let id = generateID2(); - options = options || {}; - options["dialog-id"] = id; - dialogResponses.set(id, { resolve, reject }); - call8(type, options).catch((error) => { - reject(error); - dialogResponses.delete(id); - }); - }); - } - function Info(options) { - return dialog(DialogInfo, options); - } - function Warning(options) { - return dialog(DialogWarning, options); - } - function Error2(options) { - return dialog(DialogError, options); - } - function Question(options) { - return dialog(DialogQuestion, options); - } - function OpenFile(options) { - return dialog(DialogOpenFile, options); - } - function SaveFile(options) { - return dialog(DialogSaveFile, options); - } - - // desktop/contextmenu.js - var call9 = newRuntimeCallerWithID(objectNames.ContextMenu); - var ContextMenuOpen = 0; - function openContextMenu(id, x, y, data) { - void call9(ContextMenuOpen, { id, x, y, data }); - } - function setupContextMenus() { - window.addEventListener("contextmenu", contextMenuHandler); - } - function contextMenuHandler(event) { - let element = event.target; - let customContextMenu = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu"); - customContextMenu = customContextMenu ? customContextMenu.trim() : ""; - if (customContextMenu) { - event.preventDefault(); - let customContextMenuData = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu-data"); - openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData); - return; - } - processDefaultContextMenu(event); - } - function processDefaultContextMenu(event) { - if (true) { - return; - } - const element = event.target; - const computedStyle = window.getComputedStyle(element); - const defaultContextMenuAction = computedStyle.getPropertyValue("--default-contextmenu").trim(); - switch (defaultContextMenuAction) { - case "show": - return; - case "hide": - event.preventDefault(); - return; - default: - if (element.isContentEditable) { - return; - } - const selection = window.getSelection(); - const hasSelection = 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) === element) { - return; - } - } - } - } - if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") { - if (hasSelection || !element.readOnly && !element.disabled) { - return; - } - } - event.preventDefault(); - } - } - - // desktop/wml.js - function sendEvent(eventName, data = null) { - let event = new WailsEvent(eventName, data); - Emit(event); - } - function addWMLEventListeners() { - const elements = document.querySelectorAll("[wml-event]"); - elements.forEach(function(element) { - const eventType = element.getAttribute("wml-event"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Detached: false, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - sendEvent(eventType); - } - }); - return; - } - sendEvent(eventType); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function callWindowMethod(method) { - if (wails.Window[method] === void 0) { - console.log("Window method " + method + " not found"); - } - wails.Window[method](); - } - function addWMLWindowListeners() { - const elements = document.querySelectorAll("[wml-window]"); - elements.forEach(function(element) { - const windowMethod = element.getAttribute("wml-window"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - callWindowMethod(windowMethod); - } - }); - return; - } - callWindowMethod(windowMethod); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function addWMLOpenBrowserListener() { - const elements = document.querySelectorAll("[wml-openurl]"); - elements.forEach(function(element) { - const url = element.getAttribute("wml-openurl"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - void wails.Browser.OpenURL(url); - } - }); - return; - } - void wails.Browser.OpenURL(url); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function reloadWML() { - addWMLEventListeners(); - addWMLWindowListeners(); - addWMLOpenBrowserListener(); - } - - // desktop/invoke.js - var invoke = function(input) { - if (false) { - chrome.webview.postMessage(input); - } else { - webkit.messageHandlers.external.postMessage(input); - } - }; - - // desktop/flags.js - var flags = /* @__PURE__ */ new Map(); - function convertToMap(obj) { - const map = /* @__PURE__ */ new Map(); - for (const [key, value] of Object.entries(obj)) { - if (typeof value === "object" && value !== null) { - map.set(key, convertToMap(value)); - } else { - map.set(key, value); - } - } - return map; - } - fetch("/wails/flags").then((response) => { - response.json().then((data) => { - flags = convertToMap(data); - }); - }); - - // desktop/drag.js - var shouldDrag = false; - function dragTest(e) { - let val = window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region"); - if (val) { - val = val.trim(); - } - if (val !== "drag") { - return false; - } - if (e.buttons !== 1) { - return false; - } - return e.detail === 1; - } - function setupDrag() { - window.addEventListener("mousedown", onMouseDown); - window.addEventListener("mousemove", onMouseMove); - window.addEventListener("mouseup", onMouseUp); - } - var resizable = false; - function setResizable(value) { - resizable = value; - } - function onMouseDown(e) { - if (false) { - if (testResize()) { - return; - } - } - if (dragTest(e)) { - if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) { - return; - } - shouldDrag = true; - } else { - shouldDrag = false; - } - } - function onMouseUp(e) { - let mousePressed = e.buttons !== void 0 ? e.buttons : e.which; - if (mousePressed > 0) { - endDrag(); - } - } - function endDrag() { - document.body.style.cursor = "default"; - shouldDrag = false; - } - function onMouseMove(e) { - if (shouldDrag) { - shouldDrag = false; - let mousePressed = e.buttons !== void 0 ? e.buttons : e.which; - if (mousePressed > 0) { - invoke("drag"); - } - return; - } - if (false) { - if (resizable) { - handleResize(e); - } - } - } - - // desktop/main.js - window.wails = { - ...newRuntime(null), - Capabilities: {}, - clientId - }; - fetch("/wails/capabilities").then((response) => { - response.json().then((data) => { - window.wails.Capabilities = data; - }); - }); - window._wails = { - dialogCallback, - dialogErrorCallback, - dispatchWailsEvent, - callCallback, - callErrorCallback, - endDrag, - setResizable - }; - function newRuntime(windowName) { - return { - Clipboard: { - ...clipboard_exports - }, - Application: { - ...application_exports, - GetWindowByName(windowName2) { - return newRuntime(windowName2); - } - }, - System: system_exports, - Screens: screens_exports, - Browser: browser_exports, - Call, - CallByID, - CallByName, - Plugin, - WML: { - Reload: reloadWML - }, - Dialog: { - Info, - Warning, - Error: Error2, - Question, - OpenFile, - SaveFile - }, - Events: { - Emit, - On, - Once, - OnMultiple, - Off, - OffAll - }, - Window: newWindow(windowName) - }; - } - if (true) { - console.log("Wails v3.0.0 Debug Mode Enabled"); - } - setupContextMenus(); - setupDrag(); - document.addEventListener("DOMContentLoaded", function() { - reloadWML(); - }); -})(); -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/clipboard.js", "node_modules/nanoid/non-secure/index.js", "desktop/runtime.js", "desktop/application.js", "desktop/screens.js", "desktop/system.js", "desktop/browser.js", "desktop/calls.js", "desktop/window.js", "desktop/events.js", "desktop/dialogs.js", "desktop/contextmenu.js", "desktop/wml.js", "desktop/invoke.js", "desktop/flags.js", "desktop/drag.js", "desktop/main.js"],
  "sourcesContent": ["/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Clipboard);\r\n\r\nlet ClipboardSetText = 0;\r\nlet ClipboardText = 1;\r\n\r\n/**\r\n * Set the Clipboard text\r\n */\r\nexport function SetText(text) {\r\n    void call(ClipboardSetText, {text});\r\n}\r\n\r\n/**\r\n * Get the Clipboard text\r\n * @returns {Promise<string>}\r\n */\r\nexport function Text() {\r\n    return call(ClipboardText);\r\n}", "let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nexport let customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\r\n// Object Names\r\nexport const objectNames = {\r\n    Call: 0,\r\n    Clipboard: 1,\r\n    Application: 2,\r\n    Events: 3,\r\n    ContextMenu: 4,\r\n    Dialog: 5,\r\n    Window: 6,\r\n    Screens: 7,\r\n    System: 8,\r\n    Browser: 9,\r\n}\r\nexport let clientId = nanoid();\r\n\r\nfunction runtimeCall(method, windowName, args) {\r\n    let url = new URL(runtimeURL);\r\n    if( method ) {\r\n        url.searchParams.append(\"method\", method);\r\n    }\r\n    let fetchOptions = {\r\n        headers: {},\r\n    };\r\n    if (windowName) {\r\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n    if (args) {\r\n        url.searchParams.append(\"args\", JSON.stringify(args));\r\n    }\r\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\r\n\r\n    return new Promise((resolve, reject) => {\r\n        fetch(url, fetchOptions)\r\n            .then(response => {\r\n                if (response.ok) {\r\n                    // check content type\r\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\r\n                        return response.json();\r\n                    } else {\r\n                        return response.text();\r\n                    }\r\n                }\r\n                reject(Error(response.statusText));\r\n            })\r\n            .then(data => resolve(data))\r\n            .catch(error => reject(error));\r\n    });\r\n}\r\n\r\nexport function newRuntimeCaller(object, windowName) {\r\n    return function (method, args=null) {\r\n        return runtimeCall(object + \".\" + method, windowName, args);\r\n    };\r\n}\r\n\r\nfunction runtimeCallWithID(objectID, method, windowName, args) {\r\n    let url = new URL(runtimeURL);\r\n    url.searchParams.append(\"object\", objectID);\r\n    url.searchParams.append(\"method\", method);\r\n    let fetchOptions = {\r\n        headers: {},\r\n    };\r\n    if (windowName) {\r\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n    if (args) {\r\n        url.searchParams.append(\"args\", JSON.stringify(args));\r\n    }\r\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\r\n    return new Promise((resolve, reject) => {\r\n        fetch(url, fetchOptions)\r\n            .then(response => {\r\n                if (response.ok) {\r\n                    // check content type\r\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\r\n                        return response.json();\r\n                    } else {\r\n                        return response.text();\r\n                    }\r\n                }\r\n                reject(Error(response.statusText));\r\n            })\r\n            .then(data => resolve(data))\r\n            .catch(error => reject(error));\r\n    });\r\n}\r\n\r\nexport function newRuntimeCallerWithID(object, windowName) {\r\n    return function (method, args=null) {\r\n        return runtimeCallWithID(object, method, windowName, args);\r\n    };\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Application);\r\n\r\nlet methods = {\r\n    Hide: 0,\r\n    Show: 1,\r\n    Quit: 2,\r\n}\r\n\r\n/**\r\n * Hide the application\r\n */\r\nexport function Hide() {\r\n    void call(methods.Hide);\r\n}\r\n\r\n/**\r\n * Show the application\r\n */\r\nexport function Show() {\r\n    void call(methods.Show);\r\n}\r\n\r\n\r\n/**\r\n * Quit the application\r\n */\r\nexport function Quit() {\r\n    void call(methods.Quit);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").Screen} Screen\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Screens);\r\n\r\nlet ScreensGetAll = 0;\r\nlet ScreensGetPrimary = 1;\r\nlet ScreensGetCurrent = 2;\r\n\r\n/**\r\n * Gets all screens.\r\n * @returns {Promise<Screen[]>}\r\n */\r\nexport function GetAll() {\r\n    return call(ScreensGetAll);\r\n}\r\n\r\n/**\r\n * Gets the primary screen.\r\n * @returns {Promise<Screen>}\r\n */\r\nexport function GetPrimary() {\r\n    return call(ScreensGetPrimary);\r\n}\r\n\r\n/**\r\n * Gets the current active screen.\r\n * @returns {Promise<Screen>}\r\n * @constructor\r\n */\r\nexport function GetCurrent() {\r\n    return call(ScreensGetCurrent);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.System);\r\n\r\nlet SystemIsDarkMode = 0;\r\n\r\n/**\r\n * Determines if the system is currently using dark mode\r\n * @returns {Promise<boolean>}\r\n */\r\nexport function IsDarkMode() {\r\n    return call(SystemIsDarkMode);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Browser);\r\n\r\nlet BrowserOpenURL = 0;\r\n\r\n/**\r\n * Open a browser window to the given URL\r\n * @param {string} url - The URL to open\r\n */\r\nexport function OpenURL(url) {\r\n    void call(BrowserOpenURL, {url});\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Call);\r\n\r\nlet CallBinding = 0;\r\n\r\nlet callResponses = new Map();\r\n\r\nfunction generateID() {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (callResponses.has(result));\r\n    return result;\r\n}\r\n\r\nexport function callCallback(id, data, isJSON) {\r\n    let p = callResponses.get(id);\r\n    if (p) {\r\n        if (isJSON) {\r\n            p.resolve(JSON.parse(data));\r\n        } else {\r\n            p.resolve(data);\r\n        }\r\n        callResponses.delete(id);\r\n    }\r\n}\r\n\r\nexport function callErrorCallback(id, message) {\r\n    let p = callResponses.get(id);\r\n    if (p) {\r\n        p.reject(message);\r\n        callResponses.delete(id);\r\n    }\r\n}\r\n\r\nfunction callBinding(type, options) {\r\n    return new Promise((resolve, reject) => {\r\n        let id = generateID();\r\n        options = options || {};\r\n        options[\"call-id\"] = id;\r\n\r\n        callResponses.set(id, {resolve, reject});\r\n        call(type, options).catch((error) => {\r\n            reject(error);\r\n            callResponses.delete(id);\r\n        });\r\n    });\r\n}\r\n\r\nexport function Call(options) {\r\n    return callBinding(CallBinding, options);\r\n}\r\n\r\nexport function CallByName(name, ...args) {\r\n\r\n    // Ensure first argument is a string and has 2 dots\r\n    if (typeof name !== \"string\" || name.split(\".\").length !== 3) {\r\n        throw new Error(\"CallByName requires a string in the format 'package.struct.method'\");\r\n    }\r\n    // Split inputs\r\n    let parts = name.split(\".\");\r\n\r\n    return callBinding(CallBinding, {\r\n        packageName: parts[0],\r\n        structName: parts[1],\r\n        methodName: parts[2],\r\n        args: args,\r\n    });\r\n}\r\n\r\nexport function CallByID(methodID, ...args) {\r\n    return callBinding(CallBinding, {\r\n        methodID: methodID,\r\n        args: args,\r\n    });\r\n}\r\n\r\n/**\r\n * Call a plugin method\r\n * @param {string} pluginName - name of the plugin\r\n * @param {string} methodName - name of the method\r\n * @param {...any} args - arguments to pass to the method\r\n * @returns {Promise<any>} - promise that resolves with the result\r\n */\r\nexport function Plugin(pluginName, methodName, ...args) {\r\n    return callBinding(CallBinding, {\r\n        packageName: \"wails-plugins\",\r\n        structName: pluginName,\r\n        methodName: methodName,\r\n        args: args,\r\n    });\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"../api/types\").Size} Size\r\n * @typedef {import(\"../api/types\").Position} Position\r\n * @typedef {import(\"../api/types\").Screen} Screen\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet WindowCenter = 0;\r\nlet WindowSetTitle = 1;\r\nlet WindowFullscreen = 2;\r\nlet WindowUnFullscreen = 3;\r\nlet WindowSetSize = 4;\r\nlet WindowSize = 5;\r\nlet WindowSetMaxSize = 6;\r\nlet WindowSetMinSize = 7;\r\nlet WindowSetAlwaysOnTop = 8;\r\nlet WindowSetRelativePosition = 9;\r\nlet WindowRelativePosition = 10;\r\nlet WindowScreen = 11;\r\nlet WindowHide = 12;\r\nlet WindowMaximise = 13;\r\nlet WindowUnMaximise = 14;\r\nlet WindowToggleMaximise = 15;\r\nlet WindowMinimise = 16;\r\nlet WindowUnMinimise = 17;\r\nlet WindowRestore = 18;\r\nlet WindowShow = 19;\r\nlet WindowClose = 20;\r\nlet WindowSetBackgroundColour = 21;\r\nlet WindowSetResizable = 22;\r\nlet WindowWidth = 23;\r\nlet WindowHeight = 24;\r\nlet WindowZoomIn = 25;\r\nlet WindowZoomOut = 26;\r\nlet WindowZoomReset = 27;\r\nlet WindowGetZoomLevel = 28;\r\nlet WindowSetZoomLevel = 29;\r\n\r\nexport function newWindow(windowName) {\r\n    let call = newRuntimeCallerWithID(objectNames.Window, windowName);\r\n    return {\r\n\r\n        /**\r\n         * Centers the window.\r\n         */\r\n        Center: () => void call(WindowCenter),\r\n\r\n        /**\r\n         * Set the window title.\r\n         * @param title\r\n         */\r\n        SetTitle: (title) => void call(WindowSetTitle, {title}),\r\n\r\n        /**\r\n         * Makes the window fullscreen.\r\n         */\r\n        Fullscreen: () => void call(WindowFullscreen),\r\n\r\n        /**\r\n         * Unfullscreen the window.\r\n         */\r\n        UnFullscreen: () => void call(WindowUnFullscreen),\r\n\r\n        /**\r\n         * Set the window size.\r\n         * @param {number} width The window width\r\n         * @param {number} height The window height\r\n         */\r\n        SetSize: (width, height) => call(WindowSetSize, {width,height}),\r\n\r\n        /**\r\n         * Get the window size.\r\n         * @returns {Promise<Size>} The window size\r\n         */\r\n        Size: () => { return call(WindowSize); },\r\n\r\n        /**\r\n         * Set the window maximum size.\r\n         * @param {number} width\r\n         * @param {number} height\r\n         */\r\n        SetMaxSize: (width, height) => void call(WindowSetMaxSize, {width,height}),\r\n\r\n        /**\r\n         * Set the window minimum size.\r\n         * @param {number} width\r\n         * @param {number} height\r\n         */\r\n        SetMinSize: (width, height) => void call(WindowSetMinSize, {width,height}),\r\n\r\n        /**\r\n         * Set window to be always on top.\r\n         * @param {boolean} onTop Whether the window should be always on top\r\n         */\r\n        SetAlwaysOnTop: (onTop) => void call(WindowSetAlwaysOnTop, {alwaysOnTop:onTop}),\r\n\r\n        /**\r\n         * Set the window relative position.\r\n         * @param {number} x\r\n         * @param {number} y\r\n         */\r\n        SetRelativePosition: (x, y) => call(WindowSetRelativePosition, {x,y}),\r\n\r\n        /**\r\n         * Get the window position.\r\n         * @returns {Promise<Position>} The window position\r\n         */\r\n        RelativePosition: () => { return call(WindowRelativePosition); },\r\n\r\n        /**\r\n         * Get the screen the window is on.\r\n         * @returns {Promise<Screen>}\r\n         */\r\n        Screen: () => { return call(WindowScreen); },\r\n\r\n        /**\r\n         * Hide the window\r\n         */\r\n        Hide: () => void call(WindowHide),\r\n\r\n        /**\r\n         * Maximise the window\r\n         */\r\n        Maximise: () => void call(WindowMaximise),\r\n\r\n        /**\r\n         * Show the window\r\n         */\r\n        Show: () => void call(WindowShow),\r\n\r\n        /**\r\n         * Close the window\r\n         */\r\n        Close: () => void call(WindowClose),\r\n\r\n        /**\r\n         * Toggle the window maximise state\r\n         */\r\n        ToggleMaximise: () => void call(WindowToggleMaximise),\r\n\r\n        /**\r\n         * Unmaximise the window\r\n         */\r\n        UnMaximise: () => void call(WindowUnMaximise),\r\n\r\n        /**\r\n         * Minimise the window\r\n         */\r\n        Minimise: () => void call(WindowMinimise),\r\n\r\n        /**\r\n         * Unminimise the window\r\n         */\r\n        UnMinimise: () => void call(WindowUnMinimise),\r\n\r\n        /**\r\n         * Restore the window\r\n         */\r\n        Restore: () => void call(WindowRestore),\r\n\r\n        /**\r\n         * Set the background colour of the window.\r\n         * @param {number} r - A value between 0 and 255\r\n         * @param {number} g - A value between 0 and 255\r\n         * @param {number} b - A value between 0 and 255\r\n         * @param {number} a - A value between 0 and 255\r\n         */\r\n        SetBackgroundColour: (r, g, b, a) => void call(WindowSetBackgroundColour, {r, g, b, a}),\r\n\r\n        /**\r\n         * Set whether the window can be resized or not\r\n         * @param {boolean} resizable\r\n         */\r\n        SetResizable: (resizable) => void call(WindowSetResizable, {resizable}),\r\n\r\n        /**\r\n         * Get the window width\r\n         * @returns {Promise<number>}\r\n         */\r\n        Width: () => { return call(WindowWidth); },\r\n\r\n        /**\r\n         * Get the window height\r\n         * @returns {Promise<number>}\r\n         */\r\n        Height: () => { return call(WindowHeight); },\r\n\r\n        /**\r\n         * Zoom in the window\r\n         */\r\n        ZoomIn: () => void call(WindowZoomIn),\r\n\r\n        /**\r\n         * Zoom out the window\r\n         */\r\n        ZoomOut: () => void call(WindowZoomOut),\r\n\r\n        /**\r\n         * Reset the window zoom\r\n         */\r\n        ZoomReset: () => void call(WindowZoomReset),\r\n\r\n        /**\r\n         * Get the window zoom\r\n         * @returns {Promise<number>}\r\n         */\r\n        GetZoomLevel: () => { return call(WindowGetZoomLevel); },\r\n\r\n        /**\r\n         * Set the window zoom level\r\n         * @param {number} zoomLevel\r\n         */\r\n        SetZoomLevel: (zoomLevel) => void call(WindowSetZoomLevel, {zoomLevel}),\r\n    };\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").WailsEvent} WailsEvent\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Events);\r\nlet EventEmit = 0;\r\n\r\n/**\r\n * The Listener class defines a listener! :-)\r\n *\r\n * @class Listener\r\n */\r\nclass Listener {\r\n    /**\r\n     * Creates an instance of Listener.\r\n     * @param {string} eventName\r\n     * @param {function} callback\r\n     * @param {number} maxCallbacks\r\n     * @memberof Listener\r\n     */\r\n    constructor(eventName, callback, maxCallbacks) {\r\n        this.eventName = eventName;\r\n        // Default of -1 means infinite\r\n        this.maxCallbacks = maxCallbacks || -1;\r\n        // Callback invokes the callback with the given data\r\n        // Returns true if this listener should be destroyed\r\n        this.Callback = (data) => {\r\n            callback(data);\r\n            // If maxCallbacks is infinite, return false (do not destroy)\r\n            if (this.maxCallbacks === -1) {\r\n                return false;\r\n            }\r\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\r\n            this.maxCallbacks -= 1;\r\n            return this.maxCallbacks === 0;\r\n        };\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * WailsEvent defines a custom event. It is passed to event listeners.\r\n *\r\n * @class WailsEvent\r\n * @property {string} name - Name of the event\r\n * @property {any} data - Data associated with the event\r\n */\r\nexport class WailsEvent {\r\n    /**\r\n     * Creates an instance of WailsEvent.\r\n     * @param {string} name - Name of the event\r\n     * @param {any=null} data - Data associated with the event\r\n     * @memberof WailsEvent\r\n     */\r\n    constructor(name, data = null) {\r\n        this.name = name;\r\n        this.data = data;\r\n    }\r\n}\r\n\r\nexport const eventListeners = new Map();\r\n\r\n/**\r\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n * @param {number} maxCallbacks\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function OnMultiple(eventName, callback, maxCallbacks) {\r\n    let listeners = eventListeners.get(eventName) || [];\r\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\r\n    listeners.push(thisListener);\r\n    eventListeners.set(eventName, listeners);\r\n    return () => listenerOff(thisListener);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked every time the event is emitted\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function On(eventName, callback) {\r\n    return OnMultiple(eventName, callback, -1);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked once then destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n @returns {function} A function to cancel the listener\r\n */\r\nexport function Once(eventName, callback) {\r\n    return OnMultiple(eventName, callback, 1);\r\n}\r\n\r\n/**\r\n * listenerOff unregisters a listener previously registered with On\r\n *\r\n * @param {Listener} listener\r\n */\r\nfunction listenerOff(listener) {\r\n    const eventName = listener.eventName;\r\n    // Remove local listener\r\n    let listeners = eventListeners.get(eventName).filter(l => l !== listener);\r\n    if (listeners.length === 0) {\r\n        eventListeners.delete(eventName);\r\n    } else {\r\n        eventListeners.set(eventName, listeners);\r\n    }\r\n}\r\n\r\n/**\r\n * dispatches an event to all listeners\r\n *\r\n * @export\r\n * @param {WailsEvent} event\r\n */\r\nexport function dispatchWailsEvent(event) {\r\n    let listeners = eventListeners.get(event.name);\r\n    if (listeners) {\r\n        // iterate listeners and call callback. If callback returns true, remove listener\r\n        let toRemove = [];\r\n        listeners.forEach(listener => {\r\n            let remove = listener.Callback(event);\r\n            if (remove) {\r\n                toRemove.push(listener);\r\n            }\r\n        });\r\n        // remove listeners\r\n        if (toRemove.length > 0) {\r\n            listeners = listeners.filter(l => !toRemove.includes(l));\r\n            if (listeners.length === 0) {\r\n                eventListeners.delete(event.name);\r\n            } else {\r\n                eventListeners.set(event.name, listeners);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Off unregisters a listener previously registered with On,\r\n * optionally multiple listeners can be unregistered via `additionalEventNames`\r\n *\r\n [v3 CHANGE] Off only unregisters listeners within the current window\r\n *\r\n * @param {string} eventName\r\n * @param  {...string} additionalEventNames\r\n */\r\nexport function Off(eventName, ...additionalEventNames) {\r\n    let eventsToRemove = [eventName, ...additionalEventNames];\r\n    eventsToRemove.forEach(eventName => {\r\n        eventListeners.delete(eventName);\r\n    });\r\n}\r\n\r\n/**\r\n * OffAll unregisters all listeners\r\n * [v3 CHANGE] OffAll only unregisters listeners within the current window\r\n *\r\n */\r\nexport function OffAll() {\r\n    eventListeners.clear();\r\n}\r\n\r\n/**\r\n * Emit an event\r\n * @param {WailsEvent} event The event to emit\r\n */\r\nexport function Emit(event) {\r\n    void call(EventEmit, event);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").MessageDialogOptions} MessageDialogOptions\r\n * @typedef {import(\"./api/types\").OpenDialogOptions} OpenDialogOptions\r\n * @typedef {import(\"./api/types\").SaveDialogOptions} SaveDialogOptions\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Dialog);\r\n\r\nlet DialogInfo = 0;\r\nlet DialogWarning = 1;\r\nlet DialogError = 2;\r\nlet DialogQuestion = 3;\r\nlet DialogOpenFile = 4;\r\nlet DialogSaveFile = 5;\r\n\r\n\r\nlet dialogResponses = new Map();\r\n\r\nfunction generateID() {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (dialogResponses.has(result));\r\n    return result;\r\n}\r\n\r\nexport function dialogCallback(id, data, isJSON) {\r\n    let p = dialogResponses.get(id);\r\n    if (p) {\r\n        if (isJSON) {\r\n            p.resolve(JSON.parse(data));\r\n        } else {\r\n            p.resolve(data);\r\n        }\r\n        dialogResponses.delete(id);\r\n    }\r\n}\r\nexport function dialogErrorCallback(id, message) {\r\n    let p = dialogResponses.get(id);\r\n    if (p) {\r\n        p.reject(message);\r\n        dialogResponses.delete(id);\r\n    }\r\n}\r\n\r\nfunction dialog(type, options) {\r\n    return new Promise((resolve, reject) => {\r\n        let id = generateID();\r\n        options = options || {};\r\n        options[\"dialog-id\"] = id;\r\n        dialogResponses.set(id, {resolve, reject});\r\n        call(type, options).catch((error) => {\r\n            reject(error);\r\n            dialogResponses.delete(id);\r\n        });\r\n    });\r\n}\r\n\r\n\r\n/**\r\n * Shows an Info dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Info(options) {\r\n    return dialog(DialogInfo, options);\r\n}\r\n\r\n/**\r\n * Shows a Warning dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Warning(options) {\r\n    return dialog(DialogWarning, options);\r\n}\r\n\r\n/**\r\n * Shows an Error dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Error(options) {\r\n    return dialog(DialogError, options);\r\n}\r\n\r\n/**\r\n * Shows a Question dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Question(options) {\r\n    return dialog(DialogQuestion, options);\r\n}\r\n\r\n/**\r\n * Shows an Open dialog with the given options.\r\n * @param {OpenDialogOptions} options\r\n * @returns {Promise<string[]|string>} Returns the selected file or an array of selected files if AllowsMultipleSelection is true. A blank string is returned if no file was selected.\r\n */\r\nexport function OpenFile(options) {\r\n    return dialog(DialogOpenFile, options);\r\n}\r\n\r\n/**\r\n * Shows a Save dialog with the given options.\r\n * @param {SaveDialogOptions} options\r\n * @returns {Promise<string>} Returns the selected file. A blank string is returned if no file was selected.\r\n */\r\nexport function SaveFile(options) {\r\n    return dialog(DialogSaveFile, options);\r\n}\r\n\r\n", "import {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.ContextMenu);\r\n\r\nlet ContextMenuOpen = 0;\r\n\r\nfunction openContextMenu(id, x, y, data) {\r\n    void call(ContextMenuOpen, {id, x, y, data});\r\n}\r\n\r\nexport function setupContextMenus() {\r\n    window.addEventListener('contextmenu', contextMenuHandler);\r\n}\r\n\r\nfunction contextMenuHandler(event) {\r\n    // Check for custom context menu\r\n    let element = event.target;\r\n    let customContextMenu = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu\");\r\n    customContextMenu = customContextMenu ? customContextMenu.trim() : \"\";\r\n    if (customContextMenu) {\r\n        event.preventDefault();\r\n        let customContextMenuData = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu-data\");\r\n        openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);\r\n        return\r\n    }\r\n\r\n    processDefaultContextMenu(event);\r\n}\r\n\r\n\r\n/*\r\n--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\r\n--default-contextmenu: show; will always show the default context menu\r\n--default-contextmenu: hide; will always hide the default context menu\r\n\r\nThis rule is inherited like normal CSS rules, so nesting works as expected\r\n*/\r\nfunction processDefaultContextMenu(event) {\r\n    // Debug builds always show the menu\r\n    if (DEBUG) {\r\n        return;\r\n    }\r\n\r\n    // Process default context menu\r\n    const element = event.target;\r\n    const computedStyle = window.getComputedStyle(element);\r\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\r\n    switch (defaultContextMenuAction) {\r\n        case \"show\":\r\n            return;\r\n        case \"hide\":\r\n            event.preventDefault();\r\n            return;\r\n        default:\r\n            // Check if contentEditable is true\r\n            if (element.isContentEditable) {\r\n                return;\r\n            }\r\n\r\n            // Check if text has been selected\r\n            const selection = window.getSelection();\r\n            const hasSelection = (selection.toString().length > 0)\r\n            if (hasSelection) {\r\n                for (let i = 0; i < selection.rangeCount; i++) {\r\n                    const range = selection.getRangeAt(i);\r\n                    const rects = range.getClientRects();\r\n                    for (let j = 0; j < rects.length; j++) {\r\n                        const rect = rects[j];\r\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\r\n                            return;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // Check if tagname is input or textarea\r\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\r\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\r\n                    return;\r\n                }\r\n            }\r\n\r\n            // hide default context menu\r\n            event.preventDefault();\r\n    }\r\n}\r\n", "\r\nimport {Emit, WailsEvent} from \"./events\";\r\nimport {Question} from \"./dialogs\";\r\n\r\nfunction sendEvent(eventName, data=null) {\r\n    let event = new WailsEvent(eventName, data);\r\n    Emit(event);\r\n}\r\n\r\nfunction addWMLEventListeners() {\r\n    const elements = document.querySelectorAll('[wml-event]');\r\n    elements.forEach(function (element) {\r\n        const eventType = element.getAttribute('wml-event');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Detached: false, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        sendEvent(eventType);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            sendEvent(eventType);\r\n        };\r\n        // Remove existing listeners\r\n\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nfunction callWindowMethod(method) {\r\n    if (wails.Window[method] === undefined) {\r\n        console.log(\"Window method \" + method + \" not found\");\r\n    }\r\n    wails.Window[method]();\r\n}\r\n\r\nfunction addWMLWindowListeners() {\r\n    const elements = document.querySelectorAll('[wml-window]');\r\n    elements.forEach(function (element) {\r\n        const windowMethod = element.getAttribute('wml-window');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        callWindowMethod(windowMethod);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            callWindowMethod(windowMethod);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nfunction addWMLOpenBrowserListener() {\r\n    const elements = document.querySelectorAll('[wml-openurl]');\r\n    elements.forEach(function (element) {\r\n        const url = element.getAttribute('wml-openurl');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        void wails.Browser.OpenURL(url);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            void wails.Browser.OpenURL(url);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nexport function reloadWML() {\r\n    addWMLEventListeners();\r\n    addWMLWindowListeners();\r\n    addWMLOpenBrowserListener();\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n// defined in the Taskfile\r\nexport let invoke = function(input) {\r\n    if(WINDOWS) {\r\n        chrome.webview.postMessage(input);\r\n    } else {\r\n        webkit.messageHandlers.external.postMessage(input);\r\n    }\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nlet flags = new Map();\r\n\r\nfunction convertToMap(obj) {\r\n    const map = new Map();\r\n\r\n    for (const [key, value] of Object.entries(obj)) {\r\n        if (typeof value === 'object' && value !== null) {\r\n            map.set(key, convertToMap(value)); // Recursively convert nested object\r\n        } else {\r\n            map.set(key, value);\r\n        }\r\n    }\r\n\r\n    return map;\r\n}\r\n\r\nfetch(\"/wails/flags\").then((response) => {\r\n    response.json().then((data) => {\r\n        flags = convertToMap(data);\r\n    });\r\n});\r\n\r\n\r\nfunction getValueFromMap(keyString) {\r\n    const keys = keyString.split('.');\r\n    let value = flags;\r\n\r\n    for (const key of keys) {\r\n        if (value instanceof Map) {\r\n            value = value.get(key);\r\n        } else {\r\n            value = value[key];\r\n        }\r\n\r\n        if (value === undefined) {\r\n            break;\r\n        }\r\n    }\r\n\r\n    return value;\r\n}\r\n\r\nexport function GetFlag(keyString) {\r\n    return getValueFromMap(keyString);\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {invoke} from \"./invoke\";\r\nimport {GetFlag} from \"./flags\";\r\n\r\nlet shouldDrag = false;\r\n\r\nexport function dragTest(e) {\r\n    let val = window.getComputedStyle(e.target).getPropertyValue(\"--webkit-app-region\");\r\n    if (val) {\r\n        val = val.trim();\r\n    }\r\n\r\n    if (val !== \"drag\") {\r\n        return false;\r\n    }\r\n\r\n    // Only process the primary button\r\n    if (e.buttons !== 1) {\r\n        return false;\r\n    }\r\n\r\n    return e.detail === 1;\r\n}\r\n\r\nexport function setupDrag() {\r\n    window.addEventListener('mousedown', onMouseDown);\r\n    window.addEventListener('mousemove', onMouseMove);\r\n    window.addEventListener('mouseup', onMouseUp);\r\n}\r\n\r\nlet resizeEdge = null;\r\nlet resizable = false;\r\n\r\nexport function setResizable(value) {\r\n    resizable = value;\r\n}\r\n\r\nfunction testResize(e) {\r\n    if( resizeEdge ) {\r\n        invoke(\"resize:\" + resizeEdge);\r\n        return true\r\n    }\r\n    return false;\r\n}\r\n\r\nfunction onMouseDown(e) {\r\n\r\n    // Check for resizing on Windows\r\n    if( WINDOWS ) {\r\n        if (testResize()) {\r\n            return;\r\n        }\r\n    }\r\n    if (dragTest(e)) {\r\n        // Ignore drag on scrollbars\r\n        if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\r\n            return;\r\n        }\r\n        shouldDrag = true;\r\n    } else {\r\n        shouldDrag = false;\r\n    }\r\n}\r\n\r\nfunction onMouseUp(e) {\r\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n    if (mousePressed > 0) {\r\n        endDrag();\r\n    }\r\n}\r\n\r\nexport function endDrag() {\r\n    document.body.style.cursor = 'default';\r\n    shouldDrag = false;\r\n}\r\n\r\nfunction setResize(cursor) {\r\n    document.documentElement.style.cursor = cursor || defaultCursor;\r\n    resizeEdge = cursor;\r\n}\r\n\r\nfunction onMouseMove(e) {\r\n    if (shouldDrag) {\r\n        shouldDrag = false;\r\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n        if (mousePressed > 0) {\r\n            invoke(\"drag\");\r\n        }\r\n        return;\r\n    }\r\n\r\n    if (WINDOWS) {\r\n        if (resizable) {\r\n            handleResize(e);\r\n        }\r\n    }\r\n}\r\n\r\nlet defaultCursor = \"auto\";\r\n\r\nfunction handleResize(e) {\r\n    let resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\r\n    let resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\r\n\r\n    // Extra pixels for the corner areas\r\n    let cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\r\n\r\n    let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;\r\n    let leftBorder = e.clientX < resizeHandleWidth;\r\n    let topBorder = e.clientY < resizeHandleHeight;\r\n    let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;\r\n\r\n    // Adjust for corners\r\n    let rightCorner = window.outerWidth - e.clientX < (resizeHandleWidth + cornerExtra);\r\n    let leftCorner = e.clientX < (resizeHandleWidth + cornerExtra);\r\n    let topCorner = e.clientY < (resizeHandleHeight + cornerExtra);\r\n    let bottomCorner = window.outerHeight - e.clientY < (resizeHandleHeight + cornerExtra);\r\n\r\n    // If we aren't on an edge, but were, reset the cursor to default\r\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== undefined) {\r\n        setResize();\r\n    }\r\n    // Adjusted for corner areas\r\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\r\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\r\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\r\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\r\n    else if (leftBorder) setResize(\"w-resize\");\r\n    else if (topBorder) setResize(\"n-resize\");\r\n    else if (bottomBorder) setResize(\"s-resize\");\r\n    else if (rightBorder) setResize(\"e-resize\");\r\n}\r\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 9 */\r\n\r\n\r\nimport * as Clipboard from './clipboard';\r\nimport * as Application from './application';\r\nimport * as Screens from './screens';\r\nimport * as System from './system';\r\nimport * as Browser from './browser';\r\nimport {Plugin, Call, callErrorCallback, callCallback, CallByID, CallByName} from \"./calls\";\r\nimport {clientId} from './runtime';\r\nimport {newWindow} from \"./window\";\r\nimport {dispatchWailsEvent, Emit, Off, OffAll, On, Once, OnMultiple} from \"./events\";\r\nimport {dialogCallback, dialogErrorCallback, Error, Info, OpenFile, Question, SaveFile, Warning,} from \"./dialogs\";\r\nimport {setupContextMenus} from \"./contextmenu\";\r\nimport {reloadWML} from \"./wml\";\r\nimport {setupDrag, endDrag, setResizable} from \"./drag\";\r\n\r\nwindow.wails = {\r\n    ...newRuntime(null),\r\n    Capabilities: {},\r\n    clientId: clientId,\r\n};\r\n\r\nfetch(\"/wails/capabilities\").then((response) => {\r\n    response.json().then((data) => {\r\n        window.wails.Capabilities = data;\r\n    });\r\n});\r\n\r\n// Internal wails endpoints\r\nwindow._wails = {\r\n    dialogCallback,\r\n    dialogErrorCallback,\r\n    dispatchWailsEvent,\r\n    callCallback,\r\n    callErrorCallback,\r\n    endDrag,\r\n    setResizable,\r\n};\r\n\r\nexport function newRuntime(windowName) {\r\n    return {\r\n        Clipboard: {\r\n            ...Clipboard\r\n        },\r\n        Application: {\r\n            ...Application,\r\n            GetWindowByName(windowName) {\r\n                return newRuntime(windowName);\r\n            }\r\n        },\r\n        System,\r\n        Screens,\r\n        Browser,\r\n        Call,\r\n        CallByID,\r\n        CallByName,\r\n        Plugin,\r\n        WML: {\r\n            Reload: reloadWML,\r\n        },\r\n        Dialog: {\r\n            Info,\r\n            Warning,\r\n            Error,\r\n            Question,\r\n            OpenFile,\r\n            SaveFile,\r\n        },\r\n        Events: {\r\n            Emit,\r\n            On,\r\n            Once,\r\n            OnMultiple,\r\n            Off,\r\n            OffAll,\r\n        },\r\n        Window: newWindow(windowName),\r\n    };\r\n}\r\n\r\nif (DEBUG) {\r\n    console.log(\"Wails v3.0.0 Debug Mode Enabled\");\r\n}\r\n\r\nsetupContextMenus();\r\nsetupDrag();\r\n\r\ndocument.addEventListener(\"DOMContentLoaded\", function() {\r\n    reloadWML();\r\n});\r\n"],
  "mappings": "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",
  "names": ["call", "call", "call", "call", "call", "call", "resizable", "call", "eventName", "call", "generateID", "Error", "call", "windowName", "Error"]
}
 diff --git a/v3/internal/runtime/runtime_debug_desktop_linux.js b/v3/internal/runtime/runtime_debug_desktop_linux.js deleted file mode 100644 index 3e0861b89b2..00000000000 --- a/v3/internal/runtime/runtime_debug_desktop_linux.js +++ /dev/null @@ -1,873 +0,0 @@ -(() => { - var __defProp = Object.defineProperty; - var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); - }; - - // desktop/clipboard.js - var clipboard_exports = {}; - __export(clipboard_exports, { - SetText: () => SetText, - Text: () => Text - }); - - // node_modules/nanoid/non-secure/index.js - var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict"; - var nanoid = (size = 21) => { - let id = ""; - let i = size; - while (i--) { - id += urlAlphabet[Math.random() * 64 | 0]; - } - return id; - }; - - // desktop/runtime.js - var runtimeURL = window.location.origin + "/wails/runtime"; - var objectNames = { - Call: 0, - Clipboard: 1, - Application: 2, - Events: 3, - ContextMenu: 4, - Dialog: 5, - Window: 6, - Screens: 7, - System: 8, - Browser: 9 - }; - var clientId = nanoid(); - function runtimeCallWithID(objectID, method, windowName, args) { - let url = new URL(runtimeURL); - url.searchParams.append("object", objectID); - url.searchParams.append("method", method); - let fetchOptions = { - headers: {} - }; - if (windowName) { - fetchOptions.headers["x-wails-window-name"] = windowName; - } - if (args) { - url.searchParams.append("args", JSON.stringify(args)); - } - fetchOptions.headers["x-wails-client-id"] = clientId; - return new Promise((resolve, reject) => { - fetch(url, fetchOptions).then((response) => { - if (response.ok) { - if (response.headers.get("Content-Type") && response.headers.get("Content-Type").indexOf("application/json") !== -1) { - return response.json(); - } else { - return response.text(); - } - } - reject(Error(response.statusText)); - }).then((data) => resolve(data)).catch((error) => reject(error)); - }); - } - function newRuntimeCallerWithID(object, windowName) { - return function(method, args = null) { - return runtimeCallWithID(object, method, windowName, args); - }; - } - - // desktop/clipboard.js - var call = newRuntimeCallerWithID(objectNames.Clipboard); - var ClipboardSetText = 0; - var ClipboardText = 1; - function SetText(text) { - void call(ClipboardSetText, { text }); - } - function Text() { - return call(ClipboardText); - } - - // desktop/application.js - var application_exports = {}; - __export(application_exports, { - Hide: () => Hide, - Quit: () => Quit, - Show: () => Show - }); - var call2 = newRuntimeCallerWithID(objectNames.Application); - var methods = { - Hide: 0, - Show: 1, - Quit: 2 - }; - function Hide() { - void call2(methods.Hide); - } - function Show() { - void call2(methods.Show); - } - function Quit() { - void call2(methods.Quit); - } - - // desktop/screens.js - var screens_exports = {}; - __export(screens_exports, { - GetAll: () => GetAll, - GetCurrent: () => GetCurrent, - GetPrimary: () => GetPrimary - }); - var call3 = newRuntimeCallerWithID(objectNames.Screens); - var ScreensGetAll = 0; - var ScreensGetPrimary = 1; - var ScreensGetCurrent = 2; - function GetAll() { - return call3(ScreensGetAll); - } - function GetPrimary() { - return call3(ScreensGetPrimary); - } - function GetCurrent() { - return call3(ScreensGetCurrent); - } - - // desktop/system.js - var system_exports = {}; - __export(system_exports, { - IsDarkMode: () => IsDarkMode - }); - var call4 = newRuntimeCallerWithID(objectNames.System); - var SystemIsDarkMode = 0; - function IsDarkMode() { - return call4(SystemIsDarkMode); - } - - // desktop/browser.js - var browser_exports = {}; - __export(browser_exports, { - OpenURL: () => OpenURL - }); - var call5 = newRuntimeCallerWithID(objectNames.Browser); - var BrowserOpenURL = 0; - function OpenURL(url) { - void call5(BrowserOpenURL, { url }); - } - - // desktop/calls.js - var call6 = newRuntimeCallerWithID(objectNames.Call); - var CallBinding = 0; - var callResponses = /* @__PURE__ */ new Map(); - function generateID() { - let result; - do { - result = nanoid(); - } while (callResponses.has(result)); - return result; - } - function callCallback(id, data, isJSON) { - let p = callResponses.get(id); - if (p) { - if (isJSON) { - p.resolve(JSON.parse(data)); - } else { - p.resolve(data); - } - callResponses.delete(id); - } - } - function callErrorCallback(id, message) { - let p = callResponses.get(id); - if (p) { - p.reject(message); - callResponses.delete(id); - } - } - function callBinding(type, options) { - return new Promise((resolve, reject) => { - let id = generateID(); - options = options || {}; - options["call-id"] = id; - callResponses.set(id, { resolve, reject }); - call6(type, options).catch((error) => { - reject(error); - callResponses.delete(id); - }); - }); - } - function Call(options) { - return callBinding(CallBinding, options); - } - function CallByName(name, ...args) { - if (typeof name !== "string" || name.split(".").length !== 3) { - throw new Error("CallByName requires a string in the format 'package.struct.method'"); - } - let parts = name.split("."); - return callBinding(CallBinding, { - packageName: parts[0], - structName: parts[1], - methodName: parts[2], - args - }); - } - function CallByID(methodID, ...args) { - return callBinding(CallBinding, { - methodID, - args - }); - } - function Plugin(pluginName, methodName, ...args) { - return callBinding(CallBinding, { - packageName: "wails-plugins", - structName: pluginName, - methodName, - args - }); - } - - // desktop/window.js - var WindowCenter = 0; - var WindowSetTitle = 1; - var WindowFullscreen = 2; - var WindowUnFullscreen = 3; - var WindowSetSize = 4; - var WindowSize = 5; - var WindowSetMaxSize = 6; - var WindowSetMinSize = 7; - var WindowSetAlwaysOnTop = 8; - var WindowSetRelativePosition = 9; - var WindowRelativePosition = 10; - var WindowScreen = 11; - var WindowHide = 12; - var WindowMaximise = 13; - var WindowUnMaximise = 14; - var WindowToggleMaximise = 15; - var WindowMinimise = 16; - var WindowUnMinimise = 17; - var WindowRestore = 18; - var WindowShow = 19; - var WindowClose = 20; - var WindowSetBackgroundColour = 21; - var WindowSetResizable = 22; - var WindowWidth = 23; - var WindowHeight = 24; - var WindowZoomIn = 25; - var WindowZoomOut = 26; - var WindowZoomReset = 27; - var WindowGetZoomLevel = 28; - var WindowSetZoomLevel = 29; - function newWindow(windowName) { - let call10 = newRuntimeCallerWithID(objectNames.Window, windowName); - return { - /** - * Centers the window. - */ - Center: () => void call10(WindowCenter), - /** - * Set the window title. - * @param title - */ - SetTitle: (title) => void call10(WindowSetTitle, { title }), - /** - * Makes the window fullscreen. - */ - Fullscreen: () => void call10(WindowFullscreen), - /** - * Unfullscreen the window. - */ - UnFullscreen: () => void call10(WindowUnFullscreen), - /** - * Set the window size. - * @param {number} width The window width - * @param {number} height The window height - */ - SetSize: (width, height) => call10(WindowSetSize, { width, height }), - /** - * Get the window size. - * @returns {Promise} The window size - */ - Size: () => { - return call10(WindowSize); - }, - /** - * Set the window maximum size. - * @param {number} width - * @param {number} height - */ - SetMaxSize: (width, height) => void call10(WindowSetMaxSize, { width, height }), - /** - * Set the window minimum size. - * @param {number} width - * @param {number} height - */ - SetMinSize: (width, height) => void call10(WindowSetMinSize, { width, height }), - /** - * Set window to be always on top. - * @param {boolean} onTop Whether the window should be always on top - */ - SetAlwaysOnTop: (onTop) => void call10(WindowSetAlwaysOnTop, { alwaysOnTop: onTop }), - /** - * Set the window relative position. - * @param {number} x - * @param {number} y - */ - SetRelativePosition: (x, y) => call10(WindowSetRelativePosition, { x, y }), - /** - * Get the window position. - * @returns {Promise} The window position - */ - RelativePosition: () => { - return call10(WindowRelativePosition); - }, - /** - * Get the screen the window is on. - * @returns {Promise} - */ - Screen: () => { - return call10(WindowScreen); - }, - /** - * Hide the window - */ - Hide: () => void call10(WindowHide), - /** - * Maximise the window - */ - Maximise: () => void call10(WindowMaximise), - /** - * Show the window - */ - Show: () => void call10(WindowShow), - /** - * Close the window - */ - Close: () => void call10(WindowClose), - /** - * Toggle the window maximise state - */ - ToggleMaximise: () => void call10(WindowToggleMaximise), - /** - * Unmaximise the window - */ - UnMaximise: () => void call10(WindowUnMaximise), - /** - * Minimise the window - */ - Minimise: () => void call10(WindowMinimise), - /** - * Unminimise the window - */ - UnMinimise: () => void call10(WindowUnMinimise), - /** - * Restore the window - */ - Restore: () => void call10(WindowRestore), - /** - * Set the background colour of the window. - * @param {number} r - A value between 0 and 255 - * @param {number} g - A value between 0 and 255 - * @param {number} b - A value between 0 and 255 - * @param {number} a - A value between 0 and 255 - */ - SetBackgroundColour: (r, g, b, a) => void call10(WindowSetBackgroundColour, { r, g, b, a }), - /** - * Set whether the window can be resized or not - * @param {boolean} resizable - */ - SetResizable: (resizable2) => void call10(WindowSetResizable, { resizable: resizable2 }), - /** - * Get the window width - * @returns {Promise} - */ - Width: () => { - return call10(WindowWidth); - }, - /** - * Get the window height - * @returns {Promise} - */ - Height: () => { - return call10(WindowHeight); - }, - /** - * Zoom in the window - */ - ZoomIn: () => void call10(WindowZoomIn), - /** - * Zoom out the window - */ - ZoomOut: () => void call10(WindowZoomOut), - /** - * Reset the window zoom - */ - ZoomReset: () => void call10(WindowZoomReset), - /** - * Get the window zoom - * @returns {Promise} - */ - GetZoomLevel: () => { - return call10(WindowGetZoomLevel); - }, - /** - * Set the window zoom level - * @param {number} zoomLevel - */ - SetZoomLevel: (zoomLevel) => void call10(WindowSetZoomLevel, { zoomLevel }) - }; - } - - // desktop/events.js - var call7 = newRuntimeCallerWithID(objectNames.Events); - var EventEmit = 0; - var Listener = class { - /** - * Creates an instance of Listener. - * @param {string} eventName - * @param {function} callback - * @param {number} maxCallbacks - * @memberof Listener - */ - constructor(eventName, callback, maxCallbacks) { - this.eventName = eventName; - this.maxCallbacks = maxCallbacks || -1; - this.Callback = (data) => { - callback(data); - if (this.maxCallbacks === -1) { - return false; - } - this.maxCallbacks -= 1; - return this.maxCallbacks === 0; - }; - } - }; - var WailsEvent = class { - /** - * Creates an instance of WailsEvent. - * @param {string} name - Name of the event - * @param {any=null} data - Data associated with the event - * @memberof WailsEvent - */ - constructor(name, data = null) { - this.name = name; - this.data = data; - } - }; - var eventListeners = /* @__PURE__ */ new Map(); - function OnMultiple(eventName, callback, maxCallbacks) { - let listeners = eventListeners.get(eventName) || []; - const thisListener = new Listener(eventName, callback, maxCallbacks); - listeners.push(thisListener); - eventListeners.set(eventName, listeners); - return () => listenerOff(thisListener); - } - function On(eventName, callback) { - return OnMultiple(eventName, callback, -1); - } - function Once(eventName, callback) { - return OnMultiple(eventName, callback, 1); - } - function listenerOff(listener) { - const eventName = listener.eventName; - let listeners = eventListeners.get(eventName).filter((l) => l !== listener); - if (listeners.length === 0) { - eventListeners.delete(eventName); - } else { - eventListeners.set(eventName, listeners); - } - } - function dispatchWailsEvent(event) { - let listeners = eventListeners.get(event.name); - if (listeners) { - let toRemove = []; - listeners.forEach((listener) => { - let remove = listener.Callback(event); - if (remove) { - toRemove.push(listener); - } - }); - if (toRemove.length > 0) { - listeners = listeners.filter((l) => !toRemove.includes(l)); - if (listeners.length === 0) { - eventListeners.delete(event.name); - } else { - eventListeners.set(event.name, listeners); - } - } - } - } - function Off(eventName, ...additionalEventNames) { - let eventsToRemove = [eventName, ...additionalEventNames]; - eventsToRemove.forEach((eventName2) => { - eventListeners.delete(eventName2); - }); - } - function OffAll() { - eventListeners.clear(); - } - function Emit(event) { - void call7(EventEmit, event); - } - - // desktop/dialogs.js - var call8 = newRuntimeCallerWithID(objectNames.Dialog); - var DialogInfo = 0; - var DialogWarning = 1; - var DialogError = 2; - var DialogQuestion = 3; - var DialogOpenFile = 4; - var DialogSaveFile = 5; - var dialogResponses = /* @__PURE__ */ new Map(); - function generateID2() { - let result; - do { - result = nanoid(); - } while (dialogResponses.has(result)); - return result; - } - function dialogCallback(id, data, isJSON) { - let p = dialogResponses.get(id); - if (p) { - if (isJSON) { - p.resolve(JSON.parse(data)); - } else { - p.resolve(data); - } - dialogResponses.delete(id); - } - } - function dialogErrorCallback(id, message) { - let p = dialogResponses.get(id); - if (p) { - p.reject(message); - dialogResponses.delete(id); - } - } - function dialog(type, options) { - return new Promise((resolve, reject) => { - let id = generateID2(); - options = options || {}; - options["dialog-id"] = id; - dialogResponses.set(id, { resolve, reject }); - call8(type, options).catch((error) => { - reject(error); - dialogResponses.delete(id); - }); - }); - } - function Info(options) { - return dialog(DialogInfo, options); - } - function Warning(options) { - return dialog(DialogWarning, options); - } - function Error2(options) { - return dialog(DialogError, options); - } - function Question(options) { - return dialog(DialogQuestion, options); - } - function OpenFile(options) { - return dialog(DialogOpenFile, options); - } - function SaveFile(options) { - return dialog(DialogSaveFile, options); - } - - // desktop/contextmenu.js - var call9 = newRuntimeCallerWithID(objectNames.ContextMenu); - var ContextMenuOpen = 0; - function openContextMenu(id, x, y, data) { - void call9(ContextMenuOpen, { id, x, y, data }); - } - function setupContextMenus() { - window.addEventListener("contextmenu", contextMenuHandler); - } - function contextMenuHandler(event) { - let element = event.target; - let customContextMenu = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu"); - customContextMenu = customContextMenu ? customContextMenu.trim() : ""; - if (customContextMenu) { - event.preventDefault(); - let customContextMenuData = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu-data"); - openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData); - return; - } - processDefaultContextMenu(event); - } - function processDefaultContextMenu(event) { - if (true) { - return; - } - const element = event.target; - const computedStyle = window.getComputedStyle(element); - const defaultContextMenuAction = computedStyle.getPropertyValue("--default-contextmenu").trim(); - switch (defaultContextMenuAction) { - case "show": - return; - case "hide": - event.preventDefault(); - return; - default: - if (element.isContentEditable) { - return; - } - const selection = window.getSelection(); - const hasSelection = 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) === element) { - return; - } - } - } - } - if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") { - if (hasSelection || !element.readOnly && !element.disabled) { - return; - } - } - event.preventDefault(); - } - } - - // desktop/wml.js - function sendEvent(eventName, data = null) { - let event = new WailsEvent(eventName, data); - Emit(event); - } - function addWMLEventListeners() { - const elements = document.querySelectorAll("[wml-event]"); - elements.forEach(function(element) { - const eventType = element.getAttribute("wml-event"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Detached: false, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - sendEvent(eventType); - } - }); - return; - } - sendEvent(eventType); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function callWindowMethod(method) { - if (wails.Window[method] === void 0) { - console.log("Window method " + method + " not found"); - } - wails.Window[method](); - } - function addWMLWindowListeners() { - const elements = document.querySelectorAll("[wml-window]"); - elements.forEach(function(element) { - const windowMethod = element.getAttribute("wml-window"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - callWindowMethod(windowMethod); - } - }); - return; - } - callWindowMethod(windowMethod); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function addWMLOpenBrowserListener() { - const elements = document.querySelectorAll("[wml-openurl]"); - elements.forEach(function(element) { - const url = element.getAttribute("wml-openurl"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - void wails.Browser.OpenURL(url); - } - }); - return; - } - void wails.Browser.OpenURL(url); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function reloadWML() { - addWMLEventListeners(); - addWMLWindowListeners(); - addWMLOpenBrowserListener(); - } - - // desktop/invoke.js - var invoke = function(input) { - if (false) { - chrome.webview.postMessage(input); - } else { - webkit.messageHandlers.external.postMessage(input); - } - }; - - // desktop/flags.js - var flags = /* @__PURE__ */ new Map(); - function convertToMap(obj) { - const map = /* @__PURE__ */ new Map(); - for (const [key, value] of Object.entries(obj)) { - if (typeof value === "object" && value !== null) { - map.set(key, convertToMap(value)); - } else { - map.set(key, value); - } - } - return map; - } - fetch("/wails/flags").then((response) => { - response.json().then((data) => { - flags = convertToMap(data); - }); - }); - - // desktop/drag.js - var shouldDrag = false; - function dragTest(e) { - let val = window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region"); - if (val) { - val = val.trim(); - } - if (val !== "drag") { - return false; - } - if (e.buttons !== 1) { - return false; - } - return e.detail === 1; - } - function setupDrag() { - window.addEventListener("mousedown", onMouseDown); - window.addEventListener("mousemove", onMouseMove); - window.addEventListener("mouseup", onMouseUp); - } - var resizable = false; - function setResizable(value) { - resizable = value; - } - function onMouseDown(e) { - if (false) { - if (testResize()) { - return; - } - } - if (dragTest(e)) { - if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) { - return; - } - shouldDrag = true; - } else { - shouldDrag = false; - } - } - function onMouseUp(e) { - let mousePressed = e.buttons !== void 0 ? e.buttons : e.which; - if (mousePressed > 0) { - endDrag(); - } - } - function endDrag() { - document.body.style.cursor = "default"; - shouldDrag = false; - } - function onMouseMove(e) { - if (shouldDrag) { - shouldDrag = false; - let mousePressed = e.buttons !== void 0 ? e.buttons : e.which; - if (mousePressed > 0) { - invoke("drag"); - } - return; - } - if (false) { - if (resizable) { - handleResize(e); - } - } - } - - // desktop/main.js - window.wails = { - ...newRuntime(null), - Capabilities: {}, - clientId - }; - fetch("/wails/capabilities").then((response) => { - response.json().then((data) => { - window.wails.Capabilities = data; - }); - }); - window._wails = { - dialogCallback, - dialogErrorCallback, - dispatchWailsEvent, - callCallback, - callErrorCallback, - endDrag, - setResizable - }; - function newRuntime(windowName) { - return { - Clipboard: { - ...clipboard_exports - }, - Application: { - ...application_exports, - GetWindowByName(windowName2) { - return newRuntime(windowName2); - } - }, - System: system_exports, - Screens: screens_exports, - Browser: browser_exports, - Call, - CallByID, - CallByName, - Plugin, - WML: { - Reload: reloadWML - }, - Dialog: { - Info, - Warning, - Error: Error2, - Question, - OpenFile, - SaveFile - }, - Events: { - Emit, - On, - Once, - OnMultiple, - Off, - OffAll - }, - Window: newWindow(windowName) - }; - } - if (true) { - console.log("Wails v3.0.0 Debug Mode Enabled"); - } - setupContextMenus(); - setupDrag(); - document.addEventListener("DOMContentLoaded", function() { - reloadWML(); - }); -})(); -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/clipboard.js", "node_modules/nanoid/non-secure/index.js", "desktop/runtime.js", "desktop/application.js", "desktop/screens.js", "desktop/system.js", "desktop/browser.js", "desktop/calls.js", "desktop/window.js", "desktop/events.js", "desktop/dialogs.js", "desktop/contextmenu.js", "desktop/wml.js", "desktop/invoke.js", "desktop/flags.js", "desktop/drag.js", "desktop/main.js"],
  "sourcesContent": ["/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Clipboard);\r\n\r\nlet ClipboardSetText = 0;\r\nlet ClipboardText = 1;\r\n\r\n/**\r\n * Set the Clipboard text\r\n */\r\nexport function SetText(text) {\r\n    void call(ClipboardSetText, {text});\r\n}\r\n\r\n/**\r\n * Get the Clipboard text\r\n * @returns {Promise<string>}\r\n */\r\nexport function Text() {\r\n    return call(ClipboardText);\r\n}", "let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nexport let customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\r\n// Object Names\r\nexport const objectNames = {\r\n    Call: 0,\r\n    Clipboard: 1,\r\n    Application: 2,\r\n    Events: 3,\r\n    ContextMenu: 4,\r\n    Dialog: 5,\r\n    Window: 6,\r\n    Screens: 7,\r\n    System: 8,\r\n    Browser: 9,\r\n}\r\nexport let clientId = nanoid();\r\n\r\nfunction runtimeCall(method, windowName, args) {\r\n    let url = new URL(runtimeURL);\r\n    if( method ) {\r\n        url.searchParams.append(\"method\", method);\r\n    }\r\n    let fetchOptions = {\r\n        headers: {},\r\n    };\r\n    if (windowName) {\r\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n    if (args) {\r\n        url.searchParams.append(\"args\", JSON.stringify(args));\r\n    }\r\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\r\n\r\n    return new Promise((resolve, reject) => {\r\n        fetch(url, fetchOptions)\r\n            .then(response => {\r\n                if (response.ok) {\r\n                    // check content type\r\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\r\n                        return response.json();\r\n                    } else {\r\n                        return response.text();\r\n                    }\r\n                }\r\n                reject(Error(response.statusText));\r\n            })\r\n            .then(data => resolve(data))\r\n            .catch(error => reject(error));\r\n    });\r\n}\r\n\r\nexport function newRuntimeCaller(object, windowName) {\r\n    return function (method, args=null) {\r\n        return runtimeCall(object + \".\" + method, windowName, args);\r\n    };\r\n}\r\n\r\nfunction runtimeCallWithID(objectID, method, windowName, args) {\r\n    let url = new URL(runtimeURL);\r\n    url.searchParams.append(\"object\", objectID);\r\n    url.searchParams.append(\"method\", method);\r\n    let fetchOptions = {\r\n        headers: {},\r\n    };\r\n    if (windowName) {\r\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n    if (args) {\r\n        url.searchParams.append(\"args\", JSON.stringify(args));\r\n    }\r\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\r\n    return new Promise((resolve, reject) => {\r\n        fetch(url, fetchOptions)\r\n            .then(response => {\r\n                if (response.ok) {\r\n                    // check content type\r\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\r\n                        return response.json();\r\n                    } else {\r\n                        return response.text();\r\n                    }\r\n                }\r\n                reject(Error(response.statusText));\r\n            })\r\n            .then(data => resolve(data))\r\n            .catch(error => reject(error));\r\n    });\r\n}\r\n\r\nexport function newRuntimeCallerWithID(object, windowName) {\r\n    return function (method, args=null) {\r\n        return runtimeCallWithID(object, method, windowName, args);\r\n    };\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Application);\r\n\r\nlet methods = {\r\n    Hide: 0,\r\n    Show: 1,\r\n    Quit: 2,\r\n}\r\n\r\n/**\r\n * Hide the application\r\n */\r\nexport function Hide() {\r\n    void call(methods.Hide);\r\n}\r\n\r\n/**\r\n * Show the application\r\n */\r\nexport function Show() {\r\n    void call(methods.Show);\r\n}\r\n\r\n\r\n/**\r\n * Quit the application\r\n */\r\nexport function Quit() {\r\n    void call(methods.Quit);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").Screen} Screen\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Screens);\r\n\r\nlet ScreensGetAll = 0;\r\nlet ScreensGetPrimary = 1;\r\nlet ScreensGetCurrent = 2;\r\n\r\n/**\r\n * Gets all screens.\r\n * @returns {Promise<Screen[]>}\r\n */\r\nexport function GetAll() {\r\n    return call(ScreensGetAll);\r\n}\r\n\r\n/**\r\n * Gets the primary screen.\r\n * @returns {Promise<Screen>}\r\n */\r\nexport function GetPrimary() {\r\n    return call(ScreensGetPrimary);\r\n}\r\n\r\n/**\r\n * Gets the current active screen.\r\n * @returns {Promise<Screen>}\r\n * @constructor\r\n */\r\nexport function GetCurrent() {\r\n    return call(ScreensGetCurrent);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.System);\r\n\r\nlet SystemIsDarkMode = 0;\r\n\r\n/**\r\n * Determines if the system is currently using dark mode\r\n * @returns {Promise<boolean>}\r\n */\r\nexport function IsDarkMode() {\r\n    return call(SystemIsDarkMode);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Browser);\r\n\r\nlet BrowserOpenURL = 0;\r\n\r\n/**\r\n * Open a browser window to the given URL\r\n * @param {string} url - The URL to open\r\n */\r\nexport function OpenURL(url) {\r\n    void call(BrowserOpenURL, {url});\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Call);\r\n\r\nlet CallBinding = 0;\r\n\r\nlet callResponses = new Map();\r\n\r\nfunction generateID() {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (callResponses.has(result));\r\n    return result;\r\n}\r\n\r\nexport function callCallback(id, data, isJSON) {\r\n    let p = callResponses.get(id);\r\n    if (p) {\r\n        if (isJSON) {\r\n            p.resolve(JSON.parse(data));\r\n        } else {\r\n            p.resolve(data);\r\n        }\r\n        callResponses.delete(id);\r\n    }\r\n}\r\n\r\nexport function callErrorCallback(id, message) {\r\n    let p = callResponses.get(id);\r\n    if (p) {\r\n        p.reject(message);\r\n        callResponses.delete(id);\r\n    }\r\n}\r\n\r\nfunction callBinding(type, options) {\r\n    return new Promise((resolve, reject) => {\r\n        let id = generateID();\r\n        options = options || {};\r\n        options[\"call-id\"] = id;\r\n\r\n        callResponses.set(id, {resolve, reject});\r\n        call(type, options).catch((error) => {\r\n            reject(error);\r\n            callResponses.delete(id);\r\n        });\r\n    });\r\n}\r\n\r\nexport function Call(options) {\r\n    return callBinding(CallBinding, options);\r\n}\r\n\r\nexport function CallByName(name, ...args) {\r\n\r\n    // Ensure first argument is a string and has 2 dots\r\n    if (typeof name !== \"string\" || name.split(\".\").length !== 3) {\r\n        throw new Error(\"CallByName requires a string in the format 'package.struct.method'\");\r\n    }\r\n    // Split inputs\r\n    let parts = name.split(\".\");\r\n\r\n    return callBinding(CallBinding, {\r\n        packageName: parts[0],\r\n        structName: parts[1],\r\n        methodName: parts[2],\r\n        args: args,\r\n    });\r\n}\r\n\r\nexport function CallByID(methodID, ...args) {\r\n    return callBinding(CallBinding, {\r\n        methodID: methodID,\r\n        args: args,\r\n    });\r\n}\r\n\r\n/**\r\n * Call a plugin method\r\n * @param {string} pluginName - name of the plugin\r\n * @param {string} methodName - name of the method\r\n * @param {...any} args - arguments to pass to the method\r\n * @returns {Promise<any>} - promise that resolves with the result\r\n */\r\nexport function Plugin(pluginName, methodName, ...args) {\r\n    return callBinding(CallBinding, {\r\n        packageName: \"wails-plugins\",\r\n        structName: pluginName,\r\n        methodName: methodName,\r\n        args: args,\r\n    });\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"../api/types\").Size} Size\r\n * @typedef {import(\"../api/types\").Position} Position\r\n * @typedef {import(\"../api/types\").Screen} Screen\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet WindowCenter = 0;\r\nlet WindowSetTitle = 1;\r\nlet WindowFullscreen = 2;\r\nlet WindowUnFullscreen = 3;\r\nlet WindowSetSize = 4;\r\nlet WindowSize = 5;\r\nlet WindowSetMaxSize = 6;\r\nlet WindowSetMinSize = 7;\r\nlet WindowSetAlwaysOnTop = 8;\r\nlet WindowSetRelativePosition = 9;\r\nlet WindowRelativePosition = 10;\r\nlet WindowScreen = 11;\r\nlet WindowHide = 12;\r\nlet WindowMaximise = 13;\r\nlet WindowUnMaximise = 14;\r\nlet WindowToggleMaximise = 15;\r\nlet WindowMinimise = 16;\r\nlet WindowUnMinimise = 17;\r\nlet WindowRestore = 18;\r\nlet WindowShow = 19;\r\nlet WindowClose = 20;\r\nlet WindowSetBackgroundColour = 21;\r\nlet WindowSetResizable = 22;\r\nlet WindowWidth = 23;\r\nlet WindowHeight = 24;\r\nlet WindowZoomIn = 25;\r\nlet WindowZoomOut = 26;\r\nlet WindowZoomReset = 27;\r\nlet WindowGetZoomLevel = 28;\r\nlet WindowSetZoomLevel = 29;\r\n\r\nexport function newWindow(windowName) {\r\n    let call = newRuntimeCallerWithID(objectNames.Window, windowName);\r\n    return {\r\n\r\n        /**\r\n         * Centers the window.\r\n         */\r\n        Center: () => void call(WindowCenter),\r\n\r\n        /**\r\n         * Set the window title.\r\n         * @param title\r\n         */\r\n        SetTitle: (title) => void call(WindowSetTitle, {title}),\r\n\r\n        /**\r\n         * Makes the window fullscreen.\r\n         */\r\n        Fullscreen: () => void call(WindowFullscreen),\r\n\r\n        /**\r\n         * Unfullscreen the window.\r\n         */\r\n        UnFullscreen: () => void call(WindowUnFullscreen),\r\n\r\n        /**\r\n         * Set the window size.\r\n         * @param {number} width The window width\r\n         * @param {number} height The window height\r\n         */\r\n        SetSize: (width, height) => call(WindowSetSize, {width,height}),\r\n\r\n        /**\r\n         * Get the window size.\r\n         * @returns {Promise<Size>} The window size\r\n         */\r\n        Size: () => { return call(WindowSize); },\r\n\r\n        /**\r\n         * Set the window maximum size.\r\n         * @param {number} width\r\n         * @param {number} height\r\n         */\r\n        SetMaxSize: (width, height) => void call(WindowSetMaxSize, {width,height}),\r\n\r\n        /**\r\n         * Set the window minimum size.\r\n         * @param {number} width\r\n         * @param {number} height\r\n         */\r\n        SetMinSize: (width, height) => void call(WindowSetMinSize, {width,height}),\r\n\r\n        /**\r\n         * Set window to be always on top.\r\n         * @param {boolean} onTop Whether the window should be always on top\r\n         */\r\n        SetAlwaysOnTop: (onTop) => void call(WindowSetAlwaysOnTop, {alwaysOnTop:onTop}),\r\n\r\n        /**\r\n         * Set the window relative position.\r\n         * @param {number} x\r\n         * @param {number} y\r\n         */\r\n        SetRelativePosition: (x, y) => call(WindowSetRelativePosition, {x,y}),\r\n\r\n        /**\r\n         * Get the window position.\r\n         * @returns {Promise<Position>} The window position\r\n         */\r\n        RelativePosition: () => { return call(WindowRelativePosition); },\r\n\r\n        /**\r\n         * Get the screen the window is on.\r\n         * @returns {Promise<Screen>}\r\n         */\r\n        Screen: () => { return call(WindowScreen); },\r\n\r\n        /**\r\n         * Hide the window\r\n         */\r\n        Hide: () => void call(WindowHide),\r\n\r\n        /**\r\n         * Maximise the window\r\n         */\r\n        Maximise: () => void call(WindowMaximise),\r\n\r\n        /**\r\n         * Show the window\r\n         */\r\n        Show: () => void call(WindowShow),\r\n\r\n        /**\r\n         * Close the window\r\n         */\r\n        Close: () => void call(WindowClose),\r\n\r\n        /**\r\n         * Toggle the window maximise state\r\n         */\r\n        ToggleMaximise: () => void call(WindowToggleMaximise),\r\n\r\n        /**\r\n         * Unmaximise the window\r\n         */\r\n        UnMaximise: () => void call(WindowUnMaximise),\r\n\r\n        /**\r\n         * Minimise the window\r\n         */\r\n        Minimise: () => void call(WindowMinimise),\r\n\r\n        /**\r\n         * Unminimise the window\r\n         */\r\n        UnMinimise: () => void call(WindowUnMinimise),\r\n\r\n        /**\r\n         * Restore the window\r\n         */\r\n        Restore: () => void call(WindowRestore),\r\n\r\n        /**\r\n         * Set the background colour of the window.\r\n         * @param {number} r - A value between 0 and 255\r\n         * @param {number} g - A value between 0 and 255\r\n         * @param {number} b - A value between 0 and 255\r\n         * @param {number} a - A value between 0 and 255\r\n         */\r\n        SetBackgroundColour: (r, g, b, a) => void call(WindowSetBackgroundColour, {r, g, b, a}),\r\n\r\n        /**\r\n         * Set whether the window can be resized or not\r\n         * @param {boolean} resizable\r\n         */\r\n        SetResizable: (resizable) => void call(WindowSetResizable, {resizable}),\r\n\r\n        /**\r\n         * Get the window width\r\n         * @returns {Promise<number>}\r\n         */\r\n        Width: () => { return call(WindowWidth); },\r\n\r\n        /**\r\n         * Get the window height\r\n         * @returns {Promise<number>}\r\n         */\r\n        Height: () => { return call(WindowHeight); },\r\n\r\n        /**\r\n         * Zoom in the window\r\n         */\r\n        ZoomIn: () => void call(WindowZoomIn),\r\n\r\n        /**\r\n         * Zoom out the window\r\n         */\r\n        ZoomOut: () => void call(WindowZoomOut),\r\n\r\n        /**\r\n         * Reset the window zoom\r\n         */\r\n        ZoomReset: () => void call(WindowZoomReset),\r\n\r\n        /**\r\n         * Get the window zoom\r\n         * @returns {Promise<number>}\r\n         */\r\n        GetZoomLevel: () => { return call(WindowGetZoomLevel); },\r\n\r\n        /**\r\n         * Set the window zoom level\r\n         * @param {number} zoomLevel\r\n         */\r\n        SetZoomLevel: (zoomLevel) => void call(WindowSetZoomLevel, {zoomLevel}),\r\n    };\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").WailsEvent} WailsEvent\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Events);\r\nlet EventEmit = 0;\r\n\r\n/**\r\n * The Listener class defines a listener! :-)\r\n *\r\n * @class Listener\r\n */\r\nclass Listener {\r\n    /**\r\n     * Creates an instance of Listener.\r\n     * @param {string} eventName\r\n     * @param {function} callback\r\n     * @param {number} maxCallbacks\r\n     * @memberof Listener\r\n     */\r\n    constructor(eventName, callback, maxCallbacks) {\r\n        this.eventName = eventName;\r\n        // Default of -1 means infinite\r\n        this.maxCallbacks = maxCallbacks || -1;\r\n        // Callback invokes the callback with the given data\r\n        // Returns true if this listener should be destroyed\r\n        this.Callback = (data) => {\r\n            callback(data);\r\n            // If maxCallbacks is infinite, return false (do not destroy)\r\n            if (this.maxCallbacks === -1) {\r\n                return false;\r\n            }\r\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\r\n            this.maxCallbacks -= 1;\r\n            return this.maxCallbacks === 0;\r\n        };\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * WailsEvent defines a custom event. It is passed to event listeners.\r\n *\r\n * @class WailsEvent\r\n * @property {string} name - Name of the event\r\n * @property {any} data - Data associated with the event\r\n */\r\nexport class WailsEvent {\r\n    /**\r\n     * Creates an instance of WailsEvent.\r\n     * @param {string} name - Name of the event\r\n     * @param {any=null} data - Data associated with the event\r\n     * @memberof WailsEvent\r\n     */\r\n    constructor(name, data = null) {\r\n        this.name = name;\r\n        this.data = data;\r\n    }\r\n}\r\n\r\nexport const eventListeners = new Map();\r\n\r\n/**\r\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n * @param {number} maxCallbacks\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function OnMultiple(eventName, callback, maxCallbacks) {\r\n    let listeners = eventListeners.get(eventName) || [];\r\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\r\n    listeners.push(thisListener);\r\n    eventListeners.set(eventName, listeners);\r\n    return () => listenerOff(thisListener);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked every time the event is emitted\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function On(eventName, callback) {\r\n    return OnMultiple(eventName, callback, -1);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked once then destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n @returns {function} A function to cancel the listener\r\n */\r\nexport function Once(eventName, callback) {\r\n    return OnMultiple(eventName, callback, 1);\r\n}\r\n\r\n/**\r\n * listenerOff unregisters a listener previously registered with On\r\n *\r\n * @param {Listener} listener\r\n */\r\nfunction listenerOff(listener) {\r\n    const eventName = listener.eventName;\r\n    // Remove local listener\r\n    let listeners = eventListeners.get(eventName).filter(l => l !== listener);\r\n    if (listeners.length === 0) {\r\n        eventListeners.delete(eventName);\r\n    } else {\r\n        eventListeners.set(eventName, listeners);\r\n    }\r\n}\r\n\r\n/**\r\n * dispatches an event to all listeners\r\n *\r\n * @export\r\n * @param {WailsEvent} event\r\n */\r\nexport function dispatchWailsEvent(event) {\r\n    let listeners = eventListeners.get(event.name);\r\n    if (listeners) {\r\n        // iterate listeners and call callback. If callback returns true, remove listener\r\n        let toRemove = [];\r\n        listeners.forEach(listener => {\r\n            let remove = listener.Callback(event);\r\n            if (remove) {\r\n                toRemove.push(listener);\r\n            }\r\n        });\r\n        // remove listeners\r\n        if (toRemove.length > 0) {\r\n            listeners = listeners.filter(l => !toRemove.includes(l));\r\n            if (listeners.length === 0) {\r\n                eventListeners.delete(event.name);\r\n            } else {\r\n                eventListeners.set(event.name, listeners);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Off unregisters a listener previously registered with On,\r\n * optionally multiple listeners can be unregistered via `additionalEventNames`\r\n *\r\n [v3 CHANGE] Off only unregisters listeners within the current window\r\n *\r\n * @param {string} eventName\r\n * @param  {...string} additionalEventNames\r\n */\r\nexport function Off(eventName, ...additionalEventNames) {\r\n    let eventsToRemove = [eventName, ...additionalEventNames];\r\n    eventsToRemove.forEach(eventName => {\r\n        eventListeners.delete(eventName);\r\n    });\r\n}\r\n\r\n/**\r\n * OffAll unregisters all listeners\r\n * [v3 CHANGE] OffAll only unregisters listeners within the current window\r\n *\r\n */\r\nexport function OffAll() {\r\n    eventListeners.clear();\r\n}\r\n\r\n/**\r\n * Emit an event\r\n * @param {WailsEvent} event The event to emit\r\n */\r\nexport function Emit(event) {\r\n    void call(EventEmit, event);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").MessageDialogOptions} MessageDialogOptions\r\n * @typedef {import(\"./api/types\").OpenDialogOptions} OpenDialogOptions\r\n * @typedef {import(\"./api/types\").SaveDialogOptions} SaveDialogOptions\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Dialog);\r\n\r\nlet DialogInfo = 0;\r\nlet DialogWarning = 1;\r\nlet DialogError = 2;\r\nlet DialogQuestion = 3;\r\nlet DialogOpenFile = 4;\r\nlet DialogSaveFile = 5;\r\n\r\n\r\nlet dialogResponses = new Map();\r\n\r\nfunction generateID() {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (dialogResponses.has(result));\r\n    return result;\r\n}\r\n\r\nexport function dialogCallback(id, data, isJSON) {\r\n    let p = dialogResponses.get(id);\r\n    if (p) {\r\n        if (isJSON) {\r\n            p.resolve(JSON.parse(data));\r\n        } else {\r\n            p.resolve(data);\r\n        }\r\n        dialogResponses.delete(id);\r\n    }\r\n}\r\nexport function dialogErrorCallback(id, message) {\r\n    let p = dialogResponses.get(id);\r\n    if (p) {\r\n        p.reject(message);\r\n        dialogResponses.delete(id);\r\n    }\r\n}\r\n\r\nfunction dialog(type, options) {\r\n    return new Promise((resolve, reject) => {\r\n        let id = generateID();\r\n        options = options || {};\r\n        options[\"dialog-id\"] = id;\r\n        dialogResponses.set(id, {resolve, reject});\r\n        call(type, options).catch((error) => {\r\n            reject(error);\r\n            dialogResponses.delete(id);\r\n        });\r\n    });\r\n}\r\n\r\n\r\n/**\r\n * Shows an Info dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Info(options) {\r\n    return dialog(DialogInfo, options);\r\n}\r\n\r\n/**\r\n * Shows a Warning dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Warning(options) {\r\n    return dialog(DialogWarning, options);\r\n}\r\n\r\n/**\r\n * Shows an Error dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Error(options) {\r\n    return dialog(DialogError, options);\r\n}\r\n\r\n/**\r\n * Shows a Question dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Question(options) {\r\n    return dialog(DialogQuestion, options);\r\n}\r\n\r\n/**\r\n * Shows an Open dialog with the given options.\r\n * @param {OpenDialogOptions} options\r\n * @returns {Promise<string[]|string>} Returns the selected file or an array of selected files if AllowsMultipleSelection is true. A blank string is returned if no file was selected.\r\n */\r\nexport function OpenFile(options) {\r\n    return dialog(DialogOpenFile, options);\r\n}\r\n\r\n/**\r\n * Shows a Save dialog with the given options.\r\n * @param {SaveDialogOptions} options\r\n * @returns {Promise<string>} Returns the selected file. A blank string is returned if no file was selected.\r\n */\r\nexport function SaveFile(options) {\r\n    return dialog(DialogSaveFile, options);\r\n}\r\n\r\n", "import {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.ContextMenu);\r\n\r\nlet ContextMenuOpen = 0;\r\n\r\nfunction openContextMenu(id, x, y, data) {\r\n    void call(ContextMenuOpen, {id, x, y, data});\r\n}\r\n\r\nexport function setupContextMenus() {\r\n    window.addEventListener('contextmenu', contextMenuHandler);\r\n}\r\n\r\nfunction contextMenuHandler(event) {\r\n    // Check for custom context menu\r\n    let element = event.target;\r\n    let customContextMenu = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu\");\r\n    customContextMenu = customContextMenu ? customContextMenu.trim() : \"\";\r\n    if (customContextMenu) {\r\n        event.preventDefault();\r\n        let customContextMenuData = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu-data\");\r\n        openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);\r\n        return\r\n    }\r\n\r\n    processDefaultContextMenu(event);\r\n}\r\n\r\n\r\n/*\r\n--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\r\n--default-contextmenu: show; will always show the default context menu\r\n--default-contextmenu: hide; will always hide the default context menu\r\n\r\nThis rule is inherited like normal CSS rules, so nesting works as expected\r\n*/\r\nfunction processDefaultContextMenu(event) {\r\n    // Debug builds always show the menu\r\n    if (DEBUG) {\r\n        return;\r\n    }\r\n\r\n    // Process default context menu\r\n    const element = event.target;\r\n    const computedStyle = window.getComputedStyle(element);\r\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\r\n    switch (defaultContextMenuAction) {\r\n        case \"show\":\r\n            return;\r\n        case \"hide\":\r\n            event.preventDefault();\r\n            return;\r\n        default:\r\n            // Check if contentEditable is true\r\n            if (element.isContentEditable) {\r\n                return;\r\n            }\r\n\r\n            // Check if text has been selected\r\n            const selection = window.getSelection();\r\n            const hasSelection = (selection.toString().length > 0)\r\n            if (hasSelection) {\r\n                for (let i = 0; i < selection.rangeCount; i++) {\r\n                    const range = selection.getRangeAt(i);\r\n                    const rects = range.getClientRects();\r\n                    for (let j = 0; j < rects.length; j++) {\r\n                        const rect = rects[j];\r\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\r\n                            return;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // Check if tagname is input or textarea\r\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\r\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\r\n                    return;\r\n                }\r\n            }\r\n\r\n            // hide default context menu\r\n            event.preventDefault();\r\n    }\r\n}\r\n", "\r\nimport {Emit, WailsEvent} from \"./events\";\r\nimport {Question} from \"./dialogs\";\r\n\r\nfunction sendEvent(eventName, data=null) {\r\n    let event = new WailsEvent(eventName, data);\r\n    Emit(event);\r\n}\r\n\r\nfunction addWMLEventListeners() {\r\n    const elements = document.querySelectorAll('[wml-event]');\r\n    elements.forEach(function (element) {\r\n        const eventType = element.getAttribute('wml-event');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Detached: false, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        sendEvent(eventType);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            sendEvent(eventType);\r\n        };\r\n        // Remove existing listeners\r\n\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nfunction callWindowMethod(method) {\r\n    if (wails.Window[method] === undefined) {\r\n        console.log(\"Window method \" + method + \" not found\");\r\n    }\r\n    wails.Window[method]();\r\n}\r\n\r\nfunction addWMLWindowListeners() {\r\n    const elements = document.querySelectorAll('[wml-window]');\r\n    elements.forEach(function (element) {\r\n        const windowMethod = element.getAttribute('wml-window');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        callWindowMethod(windowMethod);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            callWindowMethod(windowMethod);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nfunction addWMLOpenBrowserListener() {\r\n    const elements = document.querySelectorAll('[wml-openurl]');\r\n    elements.forEach(function (element) {\r\n        const url = element.getAttribute('wml-openurl');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        void wails.Browser.OpenURL(url);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            void wails.Browser.OpenURL(url);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nexport function reloadWML() {\r\n    addWMLEventListeners();\r\n    addWMLWindowListeners();\r\n    addWMLOpenBrowserListener();\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n// defined in the Taskfile\r\nexport let invoke = function(input) {\r\n    if(WINDOWS) {\r\n        chrome.webview.postMessage(input);\r\n    } else {\r\n        webkit.messageHandlers.external.postMessage(input);\r\n    }\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nlet flags = new Map();\r\n\r\nfunction convertToMap(obj) {\r\n    const map = new Map();\r\n\r\n    for (const [key, value] of Object.entries(obj)) {\r\n        if (typeof value === 'object' && value !== null) {\r\n            map.set(key, convertToMap(value)); // Recursively convert nested object\r\n        } else {\r\n            map.set(key, value);\r\n        }\r\n    }\r\n\r\n    return map;\r\n}\r\n\r\nfetch(\"/wails/flags\").then((response) => {\r\n    response.json().then((data) => {\r\n        flags = convertToMap(data);\r\n    });\r\n});\r\n\r\n\r\nfunction getValueFromMap(keyString) {\r\n    const keys = keyString.split('.');\r\n    let value = flags;\r\n\r\n    for (const key of keys) {\r\n        if (value instanceof Map) {\r\n            value = value.get(key);\r\n        } else {\r\n            value = value[key];\r\n        }\r\n\r\n        if (value === undefined) {\r\n            break;\r\n        }\r\n    }\r\n\r\n    return value;\r\n}\r\n\r\nexport function GetFlag(keyString) {\r\n    return getValueFromMap(keyString);\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {invoke} from \"./invoke\";\r\nimport {GetFlag} from \"./flags\";\r\n\r\nlet shouldDrag = false;\r\n\r\nexport function dragTest(e) {\r\n    let val = window.getComputedStyle(e.target).getPropertyValue(\"--webkit-app-region\");\r\n    if (val) {\r\n        val = val.trim();\r\n    }\r\n\r\n    if (val !== \"drag\") {\r\n        return false;\r\n    }\r\n\r\n    // Only process the primary button\r\n    if (e.buttons !== 1) {\r\n        return false;\r\n    }\r\n\r\n    return e.detail === 1;\r\n}\r\n\r\nexport function setupDrag() {\r\n    window.addEventListener('mousedown', onMouseDown);\r\n    window.addEventListener('mousemove', onMouseMove);\r\n    window.addEventListener('mouseup', onMouseUp);\r\n}\r\n\r\nlet resizeEdge = null;\r\nlet resizable = false;\r\n\r\nexport function setResizable(value) {\r\n    resizable = value;\r\n}\r\n\r\nfunction testResize(e) {\r\n    if( resizeEdge ) {\r\n        invoke(\"resize:\" + resizeEdge);\r\n        return true\r\n    }\r\n    return false;\r\n}\r\n\r\nfunction onMouseDown(e) {\r\n\r\n    // Check for resizing on Windows\r\n    if( WINDOWS ) {\r\n        if (testResize()) {\r\n            return;\r\n        }\r\n    }\r\n    if (dragTest(e)) {\r\n        // Ignore drag on scrollbars\r\n        if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\r\n            return;\r\n        }\r\n        shouldDrag = true;\r\n    } else {\r\n        shouldDrag = false;\r\n    }\r\n}\r\n\r\nfunction onMouseUp(e) {\r\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n    if (mousePressed > 0) {\r\n        endDrag();\r\n    }\r\n}\r\n\r\nexport function endDrag() {\r\n    document.body.style.cursor = 'default';\r\n    shouldDrag = false;\r\n}\r\n\r\nfunction setResize(cursor) {\r\n    document.documentElement.style.cursor = cursor || defaultCursor;\r\n    resizeEdge = cursor;\r\n}\r\n\r\nfunction onMouseMove(e) {\r\n    if (shouldDrag) {\r\n        shouldDrag = false;\r\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n        if (mousePressed > 0) {\r\n            invoke(\"drag\");\r\n        }\r\n        return;\r\n    }\r\n\r\n    if (WINDOWS) {\r\n        if (resizable) {\r\n            handleResize(e);\r\n        }\r\n    }\r\n}\r\n\r\nlet defaultCursor = \"auto\";\r\n\r\nfunction handleResize(e) {\r\n    let resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\r\n    let resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\r\n\r\n    // Extra pixels for the corner areas\r\n    let cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\r\n\r\n    let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;\r\n    let leftBorder = e.clientX < resizeHandleWidth;\r\n    let topBorder = e.clientY < resizeHandleHeight;\r\n    let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;\r\n\r\n    // Adjust for corners\r\n    let rightCorner = window.outerWidth - e.clientX < (resizeHandleWidth + cornerExtra);\r\n    let leftCorner = e.clientX < (resizeHandleWidth + cornerExtra);\r\n    let topCorner = e.clientY < (resizeHandleHeight + cornerExtra);\r\n    let bottomCorner = window.outerHeight - e.clientY < (resizeHandleHeight + cornerExtra);\r\n\r\n    // If we aren't on an edge, but were, reset the cursor to default\r\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== undefined) {\r\n        setResize();\r\n    }\r\n    // Adjusted for corner areas\r\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\r\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\r\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\r\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\r\n    else if (leftBorder) setResize(\"w-resize\");\r\n    else if (topBorder) setResize(\"n-resize\");\r\n    else if (bottomBorder) setResize(\"s-resize\");\r\n    else if (rightBorder) setResize(\"e-resize\");\r\n}\r\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 9 */\r\n\r\n\r\nimport * as Clipboard from './clipboard';\r\nimport * as Application from './application';\r\nimport * as Screens from './screens';\r\nimport * as System from './system';\r\nimport * as Browser from './browser';\r\nimport {Plugin, Call, callErrorCallback, callCallback, CallByID, CallByName} from \"./calls\";\r\nimport {clientId} from './runtime';\r\nimport {newWindow} from \"./window\";\r\nimport {dispatchWailsEvent, Emit, Off, OffAll, On, Once, OnMultiple} from \"./events\";\r\nimport {dialogCallback, dialogErrorCallback, Error, Info, OpenFile, Question, SaveFile, Warning,} from \"./dialogs\";\r\nimport {setupContextMenus} from \"./contextmenu\";\r\nimport {reloadWML} from \"./wml\";\r\nimport {setupDrag, endDrag, setResizable} from \"./drag\";\r\n\r\nwindow.wails = {\r\n    ...newRuntime(null),\r\n    Capabilities: {},\r\n    clientId: clientId,\r\n};\r\n\r\nfetch(\"/wails/capabilities\").then((response) => {\r\n    response.json().then((data) => {\r\n        window.wails.Capabilities = data;\r\n    });\r\n});\r\n\r\n// Internal wails endpoints\r\nwindow._wails = {\r\n    dialogCallback,\r\n    dialogErrorCallback,\r\n    dispatchWailsEvent,\r\n    callCallback,\r\n    callErrorCallback,\r\n    endDrag,\r\n    setResizable,\r\n};\r\n\r\nexport function newRuntime(windowName) {\r\n    return {\r\n        Clipboard: {\r\n            ...Clipboard\r\n        },\r\n        Application: {\r\n            ...Application,\r\n            GetWindowByName(windowName) {\r\n                return newRuntime(windowName);\r\n            }\r\n        },\r\n        System,\r\n        Screens,\r\n        Browser,\r\n        Call,\r\n        CallByID,\r\n        CallByName,\r\n        Plugin,\r\n        WML: {\r\n            Reload: reloadWML,\r\n        },\r\n        Dialog: {\r\n            Info,\r\n            Warning,\r\n            Error,\r\n            Question,\r\n            OpenFile,\r\n            SaveFile,\r\n        },\r\n        Events: {\r\n            Emit,\r\n            On,\r\n            Once,\r\n            OnMultiple,\r\n            Off,\r\n            OffAll,\r\n        },\r\n        Window: newWindow(windowName),\r\n    };\r\n}\r\n\r\nif (DEBUG) {\r\n    console.log(\"Wails v3.0.0 Debug Mode Enabled\");\r\n}\r\n\r\nsetupContextMenus();\r\nsetupDrag();\r\n\r\ndocument.addEventListener(\"DOMContentLoaded\", function() {\r\n    reloadWML();\r\n});\r\n"],
  "mappings": "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",
  "names": ["call", "call", "call", "call", "call", "call", "resizable", "call", "eventName", "call", "generateID", "Error", "call", "windowName", "Error"]
}
 diff --git a/v3/internal/runtime/runtime_debug_desktop_windows.js b/v3/internal/runtime/runtime_debug_desktop_windows.js deleted file mode 100644 index 1e90fd51115..00000000000 --- a/v3/internal/runtime/runtime_debug_desktop_windows.js +++ /dev/null @@ -1,935 +0,0 @@ -(() => { - var __defProp = Object.defineProperty; - var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); - }; - - // desktop/clipboard.js - var clipboard_exports = {}; - __export(clipboard_exports, { - SetText: () => SetText, - Text: () => Text - }); - - // node_modules/nanoid/non-secure/index.js - var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict"; - var nanoid = (size = 21) => { - let id = ""; - let i = size; - while (i--) { - id += urlAlphabet[Math.random() * 64 | 0]; - } - return id; - }; - - // desktop/runtime.js - var runtimeURL = window.location.origin + "/wails/runtime"; - var objectNames = { - Call: 0, - Clipboard: 1, - Application: 2, - Events: 3, - ContextMenu: 4, - Dialog: 5, - Window: 6, - Screens: 7, - System: 8, - Browser: 9 - }; - var clientId = nanoid(); - function runtimeCallWithID(objectID, method, windowName, args) { - let url = new URL(runtimeURL); - url.searchParams.append("object", objectID); - url.searchParams.append("method", method); - let fetchOptions = { - headers: {} - }; - if (windowName) { - fetchOptions.headers["x-wails-window-name"] = windowName; - } - if (args) { - url.searchParams.append("args", JSON.stringify(args)); - } - fetchOptions.headers["x-wails-client-id"] = clientId; - return new Promise((resolve, reject) => { - fetch(url, fetchOptions).then((response) => { - if (response.ok) { - if (response.headers.get("Content-Type") && response.headers.get("Content-Type").indexOf("application/json") !== -1) { - return response.json(); - } else { - return response.text(); - } - } - reject(Error(response.statusText)); - }).then((data) => resolve(data)).catch((error) => reject(error)); - }); - } - function newRuntimeCallerWithID(object, windowName) { - return function(method, args = null) { - return runtimeCallWithID(object, method, windowName, args); - }; - } - - // desktop/clipboard.js - var call = newRuntimeCallerWithID(objectNames.Clipboard); - var ClipboardSetText = 0; - var ClipboardText = 1; - function SetText(text) { - void call(ClipboardSetText, { text }); - } - function Text() { - return call(ClipboardText); - } - - // desktop/application.js - var application_exports = {}; - __export(application_exports, { - Hide: () => Hide, - Quit: () => Quit, - Show: () => Show - }); - var call2 = newRuntimeCallerWithID(objectNames.Application); - var methods = { - Hide: 0, - Show: 1, - Quit: 2 - }; - function Hide() { - void call2(methods.Hide); - } - function Show() { - void call2(methods.Show); - } - function Quit() { - void call2(methods.Quit); - } - - // desktop/screens.js - var screens_exports = {}; - __export(screens_exports, { - GetAll: () => GetAll, - GetCurrent: () => GetCurrent, - GetPrimary: () => GetPrimary - }); - var call3 = newRuntimeCallerWithID(objectNames.Screens); - var ScreensGetAll = 0; - var ScreensGetPrimary = 1; - var ScreensGetCurrent = 2; - function GetAll() { - return call3(ScreensGetAll); - } - function GetPrimary() { - return call3(ScreensGetPrimary); - } - function GetCurrent() { - return call3(ScreensGetCurrent); - } - - // desktop/system.js - var system_exports = {}; - __export(system_exports, { - IsDarkMode: () => IsDarkMode - }); - var call4 = newRuntimeCallerWithID(objectNames.System); - var SystemIsDarkMode = 0; - function IsDarkMode() { - return call4(SystemIsDarkMode); - } - - // desktop/browser.js - var browser_exports = {}; - __export(browser_exports, { - OpenURL: () => OpenURL - }); - var call5 = newRuntimeCallerWithID(objectNames.Browser); - var BrowserOpenURL = 0; - function OpenURL(url) { - void call5(BrowserOpenURL, { url }); - } - - // desktop/calls.js - var call6 = newRuntimeCallerWithID(objectNames.Call); - var CallBinding = 0; - var callResponses = /* @__PURE__ */ new Map(); - function generateID() { - let result; - do { - result = nanoid(); - } while (callResponses.has(result)); - return result; - } - function callCallback(id, data, isJSON) { - let p = callResponses.get(id); - if (p) { - if (isJSON) { - p.resolve(JSON.parse(data)); - } else { - p.resolve(data); - } - callResponses.delete(id); - } - } - function callErrorCallback(id, message) { - let p = callResponses.get(id); - if (p) { - p.reject(message); - callResponses.delete(id); - } - } - function callBinding(type, options) { - return new Promise((resolve, reject) => { - let id = generateID(); - options = options || {}; - options["call-id"] = id; - callResponses.set(id, { resolve, reject }); - call6(type, options).catch((error) => { - reject(error); - callResponses.delete(id); - }); - }); - } - function Call(options) { - return callBinding(CallBinding, options); - } - function CallByName(name, ...args) { - if (typeof name !== "string" || name.split(".").length !== 3) { - throw new Error("CallByName requires a string in the format 'package.struct.method'"); - } - let parts = name.split("."); - return callBinding(CallBinding, { - packageName: parts[0], - structName: parts[1], - methodName: parts[2], - args - }); - } - function CallByID(methodID, ...args) { - return callBinding(CallBinding, { - methodID, - args - }); - } - function Plugin(pluginName, methodName, ...args) { - return callBinding(CallBinding, { - packageName: "wails-plugins", - structName: pluginName, - methodName, - args - }); - } - - // desktop/window.js - var WindowCenter = 0; - var WindowSetTitle = 1; - var WindowFullscreen = 2; - var WindowUnFullscreen = 3; - var WindowSetSize = 4; - var WindowSize = 5; - var WindowSetMaxSize = 6; - var WindowSetMinSize = 7; - var WindowSetAlwaysOnTop = 8; - var WindowSetRelativePosition = 9; - var WindowRelativePosition = 10; - var WindowScreen = 11; - var WindowHide = 12; - var WindowMaximise = 13; - var WindowUnMaximise = 14; - var WindowToggleMaximise = 15; - var WindowMinimise = 16; - var WindowUnMinimise = 17; - var WindowRestore = 18; - var WindowShow = 19; - var WindowClose = 20; - var WindowSetBackgroundColour = 21; - var WindowSetResizable = 22; - var WindowWidth = 23; - var WindowHeight = 24; - var WindowZoomIn = 25; - var WindowZoomOut = 26; - var WindowZoomReset = 27; - var WindowGetZoomLevel = 28; - var WindowSetZoomLevel = 29; - function newWindow(windowName) { - let call10 = newRuntimeCallerWithID(objectNames.Window, windowName); - return { - /** - * Centers the window. - */ - Center: () => void call10(WindowCenter), - /** - * Set the window title. - * @param title - */ - SetTitle: (title) => void call10(WindowSetTitle, { title }), - /** - * Makes the window fullscreen. - */ - Fullscreen: () => void call10(WindowFullscreen), - /** - * Unfullscreen the window. - */ - UnFullscreen: () => void call10(WindowUnFullscreen), - /** - * Set the window size. - * @param {number} width The window width - * @param {number} height The window height - */ - SetSize: (width, height) => call10(WindowSetSize, { width, height }), - /** - * Get the window size. - * @returns {Promise} The window size - */ - Size: () => { - return call10(WindowSize); - }, - /** - * Set the window maximum size. - * @param {number} width - * @param {number} height - */ - SetMaxSize: (width, height) => void call10(WindowSetMaxSize, { width, height }), - /** - * Set the window minimum size. - * @param {number} width - * @param {number} height - */ - SetMinSize: (width, height) => void call10(WindowSetMinSize, { width, height }), - /** - * Set window to be always on top. - * @param {boolean} onTop Whether the window should be always on top - */ - SetAlwaysOnTop: (onTop) => void call10(WindowSetAlwaysOnTop, { alwaysOnTop: onTop }), - /** - * Set the window relative position. - * @param {number} x - * @param {number} y - */ - SetRelativePosition: (x, y) => call10(WindowSetRelativePosition, { x, y }), - /** - * Get the window position. - * @returns {Promise} The window position - */ - RelativePosition: () => { - return call10(WindowRelativePosition); - }, - /** - * Get the screen the window is on. - * @returns {Promise} - */ - Screen: () => { - return call10(WindowScreen); - }, - /** - * Hide the window - */ - Hide: () => void call10(WindowHide), - /** - * Maximise the window - */ - Maximise: () => void call10(WindowMaximise), - /** - * Show the window - */ - Show: () => void call10(WindowShow), - /** - * Close the window - */ - Close: () => void call10(WindowClose), - /** - * Toggle the window maximise state - */ - ToggleMaximise: () => void call10(WindowToggleMaximise), - /** - * Unmaximise the window - */ - UnMaximise: () => void call10(WindowUnMaximise), - /** - * Minimise the window - */ - Minimise: () => void call10(WindowMinimise), - /** - * Unminimise the window - */ - UnMinimise: () => void call10(WindowUnMinimise), - /** - * Restore the window - */ - Restore: () => void call10(WindowRestore), - /** - * Set the background colour of the window. - * @param {number} r - A value between 0 and 255 - * @param {number} g - A value between 0 and 255 - * @param {number} b - A value between 0 and 255 - * @param {number} a - A value between 0 and 255 - */ - SetBackgroundColour: (r, g, b, a) => void call10(WindowSetBackgroundColour, { r, g, b, a }), - /** - * Set whether the window can be resized or not - * @param {boolean} resizable - */ - SetResizable: (resizable2) => void call10(WindowSetResizable, { resizable: resizable2 }), - /** - * Get the window width - * @returns {Promise} - */ - Width: () => { - return call10(WindowWidth); - }, - /** - * Get the window height - * @returns {Promise} - */ - Height: () => { - return call10(WindowHeight); - }, - /** - * Zoom in the window - */ - ZoomIn: () => void call10(WindowZoomIn), - /** - * Zoom out the window - */ - ZoomOut: () => void call10(WindowZoomOut), - /** - * Reset the window zoom - */ - ZoomReset: () => void call10(WindowZoomReset), - /** - * Get the window zoom - * @returns {Promise} - */ - GetZoomLevel: () => { - return call10(WindowGetZoomLevel); - }, - /** - * Set the window zoom level - * @param {number} zoomLevel - */ - SetZoomLevel: (zoomLevel) => void call10(WindowSetZoomLevel, { zoomLevel }) - }; - } - - // desktop/events.js - var call7 = newRuntimeCallerWithID(objectNames.Events); - var EventEmit = 0; - var Listener = class { - /** - * Creates an instance of Listener. - * @param {string} eventName - * @param {function} callback - * @param {number} maxCallbacks - * @memberof Listener - */ - constructor(eventName, callback, maxCallbacks) { - this.eventName = eventName; - this.maxCallbacks = maxCallbacks || -1; - this.Callback = (data) => { - callback(data); - if (this.maxCallbacks === -1) { - return false; - } - this.maxCallbacks -= 1; - return this.maxCallbacks === 0; - }; - } - }; - var WailsEvent = class { - /** - * Creates an instance of WailsEvent. - * @param {string} name - Name of the event - * @param {any=null} data - Data associated with the event - * @memberof WailsEvent - */ - constructor(name, data = null) { - this.name = name; - this.data = data; - } - }; - var eventListeners = /* @__PURE__ */ new Map(); - function OnMultiple(eventName, callback, maxCallbacks) { - let listeners = eventListeners.get(eventName) || []; - const thisListener = new Listener(eventName, callback, maxCallbacks); - listeners.push(thisListener); - eventListeners.set(eventName, listeners); - return () => listenerOff(thisListener); - } - function On(eventName, callback) { - return OnMultiple(eventName, callback, -1); - } - function Once(eventName, callback) { - return OnMultiple(eventName, callback, 1); - } - function listenerOff(listener) { - const eventName = listener.eventName; - let listeners = eventListeners.get(eventName).filter((l) => l !== listener); - if (listeners.length === 0) { - eventListeners.delete(eventName); - } else { - eventListeners.set(eventName, listeners); - } - } - function dispatchWailsEvent(event) { - let listeners = eventListeners.get(event.name); - if (listeners) { - let toRemove = []; - listeners.forEach((listener) => { - let remove = listener.Callback(event); - if (remove) { - toRemove.push(listener); - } - }); - if (toRemove.length > 0) { - listeners = listeners.filter((l) => !toRemove.includes(l)); - if (listeners.length === 0) { - eventListeners.delete(event.name); - } else { - eventListeners.set(event.name, listeners); - } - } - } - } - function Off(eventName, ...additionalEventNames) { - let eventsToRemove = [eventName, ...additionalEventNames]; - eventsToRemove.forEach((eventName2) => { - eventListeners.delete(eventName2); - }); - } - function OffAll() { - eventListeners.clear(); - } - function Emit(event) { - void call7(EventEmit, event); - } - - // desktop/dialogs.js - var call8 = newRuntimeCallerWithID(objectNames.Dialog); - var DialogInfo = 0; - var DialogWarning = 1; - var DialogError = 2; - var DialogQuestion = 3; - var DialogOpenFile = 4; - var DialogSaveFile = 5; - var dialogResponses = /* @__PURE__ */ new Map(); - function generateID2() { - let result; - do { - result = nanoid(); - } while (dialogResponses.has(result)); - return result; - } - function dialogCallback(id, data, isJSON) { - let p = dialogResponses.get(id); - if (p) { - if (isJSON) { - p.resolve(JSON.parse(data)); - } else { - p.resolve(data); - } - dialogResponses.delete(id); - } - } - function dialogErrorCallback(id, message) { - let p = dialogResponses.get(id); - if (p) { - p.reject(message); - dialogResponses.delete(id); - } - } - function dialog(type, options) { - return new Promise((resolve, reject) => { - let id = generateID2(); - options = options || {}; - options["dialog-id"] = id; - dialogResponses.set(id, { resolve, reject }); - call8(type, options).catch((error) => { - reject(error); - dialogResponses.delete(id); - }); - }); - } - function Info(options) { - return dialog(DialogInfo, options); - } - function Warning(options) { - return dialog(DialogWarning, options); - } - function Error2(options) { - return dialog(DialogError, options); - } - function Question(options) { - return dialog(DialogQuestion, options); - } - function OpenFile(options) { - return dialog(DialogOpenFile, options); - } - function SaveFile(options) { - return dialog(DialogSaveFile, options); - } - - // desktop/contextmenu.js - var call9 = newRuntimeCallerWithID(objectNames.ContextMenu); - var ContextMenuOpen = 0; - function openContextMenu(id, x, y, data) { - void call9(ContextMenuOpen, { id, x, y, data }); - } - function setupContextMenus() { - window.addEventListener("contextmenu", contextMenuHandler); - } - function contextMenuHandler(event) { - let element = event.target; - let customContextMenu = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu"); - customContextMenu = customContextMenu ? customContextMenu.trim() : ""; - if (customContextMenu) { - event.preventDefault(); - let customContextMenuData = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu-data"); - openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData); - return; - } - processDefaultContextMenu(event); - } - function processDefaultContextMenu(event) { - if (true) { - return; - } - const element = event.target; - const computedStyle = window.getComputedStyle(element); - const defaultContextMenuAction = computedStyle.getPropertyValue("--default-contextmenu").trim(); - switch (defaultContextMenuAction) { - case "show": - return; - case "hide": - event.preventDefault(); - return; - default: - if (element.isContentEditable) { - return; - } - const selection = window.getSelection(); - const hasSelection = 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) === element) { - return; - } - } - } - } - if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") { - if (hasSelection || !element.readOnly && !element.disabled) { - return; - } - } - event.preventDefault(); - } - } - - // desktop/wml.js - function sendEvent(eventName, data = null) { - let event = new WailsEvent(eventName, data); - Emit(event); - } - function addWMLEventListeners() { - const elements = document.querySelectorAll("[wml-event]"); - elements.forEach(function(element) { - const eventType = element.getAttribute("wml-event"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Detached: false, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - sendEvent(eventType); - } - }); - return; - } - sendEvent(eventType); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function callWindowMethod(method) { - if (wails.Window[method] === void 0) { - console.log("Window method " + method + " not found"); - } - wails.Window[method](); - } - function addWMLWindowListeners() { - const elements = document.querySelectorAll("[wml-window]"); - elements.forEach(function(element) { - const windowMethod = element.getAttribute("wml-window"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - callWindowMethod(windowMethod); - } - }); - return; - } - callWindowMethod(windowMethod); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function addWMLOpenBrowserListener() { - const elements = document.querySelectorAll("[wml-openurl]"); - elements.forEach(function(element) { - const url = element.getAttribute("wml-openurl"); - const confirm = element.getAttribute("wml-confirm"); - const trigger = element.getAttribute("wml-trigger") || "click"; - let callback = function() { - if (confirm) { - Question({ Title: "Confirm", Message: confirm, Buttons: [{ Label: "Yes" }, { Label: "No", IsDefault: true }] }).then(function(result) { - if (result !== "No") { - void wails.Browser.OpenURL(url); - } - }); - return; - } - void wails.Browser.OpenURL(url); - }; - element.removeEventListener(trigger, callback); - element.addEventListener(trigger, callback); - }); - } - function reloadWML() { - addWMLEventListeners(); - addWMLWindowListeners(); - addWMLOpenBrowserListener(); - } - - // desktop/invoke.js - var invoke = function(input) { - if (true) { - chrome.webview.postMessage(input); - } else { - webkit.messageHandlers.external.postMessage(input); - } - }; - - // desktop/flags.js - var flags = /* @__PURE__ */ new Map(); - function convertToMap(obj) { - const map = /* @__PURE__ */ new Map(); - for (const [key, value] of Object.entries(obj)) { - if (typeof value === "object" && value !== null) { - map.set(key, convertToMap(value)); - } else { - map.set(key, value); - } - } - return map; - } - fetch("/wails/flags").then((response) => { - response.json().then((data) => { - flags = convertToMap(data); - }); - }); - function getValueFromMap(keyString) { - const keys = keyString.split("."); - let value = flags; - for (const key of keys) { - if (value instanceof Map) { - value = value.get(key); - } else { - value = value[key]; - } - if (value === void 0) { - break; - } - } - return value; - } - function GetFlag(keyString) { - return getValueFromMap(keyString); - } - - // desktop/drag.js - var shouldDrag = false; - function dragTest(e) { - let val = window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region"); - if (val) { - val = val.trim(); - } - if (val !== "drag") { - return false; - } - if (e.buttons !== 1) { - return false; - } - return e.detail === 1; - } - function setupDrag() { - window.addEventListener("mousedown", onMouseDown); - window.addEventListener("mousemove", onMouseMove); - window.addEventListener("mouseup", onMouseUp); - } - var resizeEdge = null; - var resizable = false; - function setResizable(value) { - resizable = value; - } - function testResize(e) { - if (resizeEdge) { - invoke("resize:" + resizeEdge); - return true; - } - return false; - } - function onMouseDown(e) { - if (true) { - if (testResize()) { - return; - } - } - if (dragTest(e)) { - if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) { - return; - } - shouldDrag = true; - } else { - shouldDrag = false; - } - } - function onMouseUp(e) { - let mousePressed = e.buttons !== void 0 ? e.buttons : e.which; - if (mousePressed > 0) { - endDrag(); - } - } - function endDrag() { - document.body.style.cursor = "default"; - shouldDrag = false; - } - function setResize(cursor) { - document.documentElement.style.cursor = cursor || defaultCursor; - resizeEdge = cursor; - } - function onMouseMove(e) { - if (shouldDrag) { - shouldDrag = false; - let mousePressed = e.buttons !== void 0 ? e.buttons : e.which; - if (mousePressed > 0) { - invoke("drag"); - } - return; - } - if (true) { - if (resizable) { - handleResize(e); - } - } - } - var defaultCursor = "auto"; - function handleResize(e) { - let resizeHandleHeight = GetFlag("system.resizeHandleHeight") || 5; - let resizeHandleWidth = GetFlag("system.resizeHandleWidth") || 5; - let cornerExtra = GetFlag("resizeCornerExtra") || 10; - let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth; - let leftBorder = e.clientX < resizeHandleWidth; - let topBorder = e.clientY < resizeHandleHeight; - let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight; - let rightCorner = window.outerWidth - e.clientX < resizeHandleWidth + cornerExtra; - let leftCorner = e.clientX < resizeHandleWidth + cornerExtra; - let topCorner = e.clientY < resizeHandleHeight + cornerExtra; - let bottomCorner = window.outerHeight - e.clientY < resizeHandleHeight + cornerExtra; - if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== void 0) { - setResize(); - } 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"); - else if (leftBorder) - setResize("w-resize"); - else if (topBorder) - setResize("n-resize"); - else if (bottomBorder) - setResize("s-resize"); - else if (rightBorder) - setResize("e-resize"); - } - - // desktop/main.js - window.wails = { - ...newRuntime(null), - Capabilities: {}, - clientId - }; - fetch("/wails/capabilities").then((response) => { - response.json().then((data) => { - window.wails.Capabilities = data; - }); - }); - window._wails = { - dialogCallback, - dialogErrorCallback, - dispatchWailsEvent, - callCallback, - callErrorCallback, - endDrag, - setResizable - }; - function newRuntime(windowName) { - return { - Clipboard: { - ...clipboard_exports - }, - Application: { - ...application_exports, - GetWindowByName(windowName2) { - return newRuntime(windowName2); - } - }, - System: system_exports, - Screens: screens_exports, - Browser: browser_exports, - Call, - CallByID, - CallByName, - Plugin, - WML: { - Reload: reloadWML - }, - Dialog: { - Info, - Warning, - Error: Error2, - Question, - OpenFile, - SaveFile - }, - Events: { - Emit, - On, - Once, - OnMultiple, - Off, - OffAll - }, - Window: newWindow(windowName) - }; - } - if (true) { - console.log("Wails v3.0.0 Debug Mode Enabled"); - } - setupContextMenus(); - setupDrag(); - document.addEventListener("DOMContentLoaded", function() { - reloadWML(); - }); -})(); -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/clipboard.js", "node_modules/nanoid/non-secure/index.js", "desktop/runtime.js", "desktop/application.js", "desktop/screens.js", "desktop/system.js", "desktop/browser.js", "desktop/calls.js", "desktop/window.js", "desktop/events.js", "desktop/dialogs.js", "desktop/contextmenu.js", "desktop/wml.js", "desktop/invoke.js", "desktop/flags.js", "desktop/drag.js", "desktop/main.js"],
  "sourcesContent": ["/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Clipboard);\r\n\r\nlet ClipboardSetText = 0;\r\nlet ClipboardText = 1;\r\n\r\n/**\r\n * Set the Clipboard text\r\n */\r\nexport function SetText(text) {\r\n    void call(ClipboardSetText, {text});\r\n}\r\n\r\n/**\r\n * Get the Clipboard text\r\n * @returns {Promise<string>}\r\n */\r\nexport function Text() {\r\n    return call(ClipboardText);\r\n}", "let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nexport let customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\r\n// Object Names\r\nexport const objectNames = {\r\n    Call: 0,\r\n    Clipboard: 1,\r\n    Application: 2,\r\n    Events: 3,\r\n    ContextMenu: 4,\r\n    Dialog: 5,\r\n    Window: 6,\r\n    Screens: 7,\r\n    System: 8,\r\n    Browser: 9,\r\n}\r\nexport let clientId = nanoid();\r\n\r\nfunction runtimeCall(method, windowName, args) {\r\n    let url = new URL(runtimeURL);\r\n    if( method ) {\r\n        url.searchParams.append(\"method\", method);\r\n    }\r\n    let fetchOptions = {\r\n        headers: {},\r\n    };\r\n    if (windowName) {\r\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n    if (args) {\r\n        url.searchParams.append(\"args\", JSON.stringify(args));\r\n    }\r\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\r\n\r\n    return new Promise((resolve, reject) => {\r\n        fetch(url, fetchOptions)\r\n            .then(response => {\r\n                if (response.ok) {\r\n                    // check content type\r\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\r\n                        return response.json();\r\n                    } else {\r\n                        return response.text();\r\n                    }\r\n                }\r\n                reject(Error(response.statusText));\r\n            })\r\n            .then(data => resolve(data))\r\n            .catch(error => reject(error));\r\n    });\r\n}\r\n\r\nexport function newRuntimeCaller(object, windowName) {\r\n    return function (method, args=null) {\r\n        return runtimeCall(object + \".\" + method, windowName, args);\r\n    };\r\n}\r\n\r\nfunction runtimeCallWithID(objectID, method, windowName, args) {\r\n    let url = new URL(runtimeURL);\r\n    url.searchParams.append(\"object\", objectID);\r\n    url.searchParams.append(\"method\", method);\r\n    let fetchOptions = {\r\n        headers: {},\r\n    };\r\n    if (windowName) {\r\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\r\n    }\r\n    if (args) {\r\n        url.searchParams.append(\"args\", JSON.stringify(args));\r\n    }\r\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\r\n    return new Promise((resolve, reject) => {\r\n        fetch(url, fetchOptions)\r\n            .then(response => {\r\n                if (response.ok) {\r\n                    // check content type\r\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\r\n                        return response.json();\r\n                    } else {\r\n                        return response.text();\r\n                    }\r\n                }\r\n                reject(Error(response.statusText));\r\n            })\r\n            .then(data => resolve(data))\r\n            .catch(error => reject(error));\r\n    });\r\n}\r\n\r\nexport function newRuntimeCallerWithID(object, windowName) {\r\n    return function (method, args=null) {\r\n        return runtimeCallWithID(object, method, windowName, args);\r\n    };\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Application);\r\n\r\nlet methods = {\r\n    Hide: 0,\r\n    Show: 1,\r\n    Quit: 2,\r\n}\r\n\r\n/**\r\n * Hide the application\r\n */\r\nexport function Hide() {\r\n    void call(methods.Hide);\r\n}\r\n\r\n/**\r\n * Show the application\r\n */\r\nexport function Show() {\r\n    void call(methods.Show);\r\n}\r\n\r\n\r\n/**\r\n * Quit the application\r\n */\r\nexport function Quit() {\r\n    void call(methods.Quit);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").Screen} Screen\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Screens);\r\n\r\nlet ScreensGetAll = 0;\r\nlet ScreensGetPrimary = 1;\r\nlet ScreensGetCurrent = 2;\r\n\r\n/**\r\n * Gets all screens.\r\n * @returns {Promise<Screen[]>}\r\n */\r\nexport function GetAll() {\r\n    return call(ScreensGetAll);\r\n}\r\n\r\n/**\r\n * Gets the primary screen.\r\n * @returns {Promise<Screen>}\r\n */\r\nexport function GetPrimary() {\r\n    return call(ScreensGetPrimary);\r\n}\r\n\r\n/**\r\n * Gets the current active screen.\r\n * @returns {Promise<Screen>}\r\n * @constructor\r\n */\r\nexport function GetCurrent() {\r\n    return call(ScreensGetCurrent);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.System);\r\n\r\nlet SystemIsDarkMode = 0;\r\n\r\n/**\r\n * Determines if the system is currently using dark mode\r\n * @returns {Promise<boolean>}\r\n */\r\nexport function IsDarkMode() {\r\n    return call(SystemIsDarkMode);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Browser);\r\n\r\nlet BrowserOpenURL = 0;\r\n\r\n/**\r\n * Open a browser window to the given URL\r\n * @param {string} url - The URL to open\r\n */\r\nexport function OpenURL(url) {\r\n    void call(BrowserOpenURL, {url});\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Call);\r\n\r\nlet CallBinding = 0;\r\n\r\nlet callResponses = new Map();\r\n\r\nfunction generateID() {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (callResponses.has(result));\r\n    return result;\r\n}\r\n\r\nexport function callCallback(id, data, isJSON) {\r\n    let p = callResponses.get(id);\r\n    if (p) {\r\n        if (isJSON) {\r\n            p.resolve(JSON.parse(data));\r\n        } else {\r\n            p.resolve(data);\r\n        }\r\n        callResponses.delete(id);\r\n    }\r\n}\r\n\r\nexport function callErrorCallback(id, message) {\r\n    let p = callResponses.get(id);\r\n    if (p) {\r\n        p.reject(message);\r\n        callResponses.delete(id);\r\n    }\r\n}\r\n\r\nfunction callBinding(type, options) {\r\n    return new Promise((resolve, reject) => {\r\n        let id = generateID();\r\n        options = options || {};\r\n        options[\"call-id\"] = id;\r\n\r\n        callResponses.set(id, {resolve, reject});\r\n        call(type, options).catch((error) => {\r\n            reject(error);\r\n            callResponses.delete(id);\r\n        });\r\n    });\r\n}\r\n\r\nexport function Call(options) {\r\n    return callBinding(CallBinding, options);\r\n}\r\n\r\nexport function CallByName(name, ...args) {\r\n\r\n    // Ensure first argument is a string and has 2 dots\r\n    if (typeof name !== \"string\" || name.split(\".\").length !== 3) {\r\n        throw new Error(\"CallByName requires a string in the format 'package.struct.method'\");\r\n    }\r\n    // Split inputs\r\n    let parts = name.split(\".\");\r\n\r\n    return callBinding(CallBinding, {\r\n        packageName: parts[0],\r\n        structName: parts[1],\r\n        methodName: parts[2],\r\n        args: args,\r\n    });\r\n}\r\n\r\nexport function CallByID(methodID, ...args) {\r\n    return callBinding(CallBinding, {\r\n        methodID: methodID,\r\n        args: args,\r\n    });\r\n}\r\n\r\n/**\r\n * Call a plugin method\r\n * @param {string} pluginName - name of the plugin\r\n * @param {string} methodName - name of the method\r\n * @param {...any} args - arguments to pass to the method\r\n * @returns {Promise<any>} - promise that resolves with the result\r\n */\r\nexport function Plugin(pluginName, methodName, ...args) {\r\n    return callBinding(CallBinding, {\r\n        packageName: \"wails-plugins\",\r\n        structName: pluginName,\r\n        methodName: methodName,\r\n        args: args,\r\n    });\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"../api/types\").Size} Size\r\n * @typedef {import(\"../api/types\").Position} Position\r\n * @typedef {import(\"../api/types\").Screen} Screen\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet WindowCenter = 0;\r\nlet WindowSetTitle = 1;\r\nlet WindowFullscreen = 2;\r\nlet WindowUnFullscreen = 3;\r\nlet WindowSetSize = 4;\r\nlet WindowSize = 5;\r\nlet WindowSetMaxSize = 6;\r\nlet WindowSetMinSize = 7;\r\nlet WindowSetAlwaysOnTop = 8;\r\nlet WindowSetRelativePosition = 9;\r\nlet WindowRelativePosition = 10;\r\nlet WindowScreen = 11;\r\nlet WindowHide = 12;\r\nlet WindowMaximise = 13;\r\nlet WindowUnMaximise = 14;\r\nlet WindowToggleMaximise = 15;\r\nlet WindowMinimise = 16;\r\nlet WindowUnMinimise = 17;\r\nlet WindowRestore = 18;\r\nlet WindowShow = 19;\r\nlet WindowClose = 20;\r\nlet WindowSetBackgroundColour = 21;\r\nlet WindowSetResizable = 22;\r\nlet WindowWidth = 23;\r\nlet WindowHeight = 24;\r\nlet WindowZoomIn = 25;\r\nlet WindowZoomOut = 26;\r\nlet WindowZoomReset = 27;\r\nlet WindowGetZoomLevel = 28;\r\nlet WindowSetZoomLevel = 29;\r\n\r\nexport function newWindow(windowName) {\r\n    let call = newRuntimeCallerWithID(objectNames.Window, windowName);\r\n    return {\r\n\r\n        /**\r\n         * Centers the window.\r\n         */\r\n        Center: () => void call(WindowCenter),\r\n\r\n        /**\r\n         * Set the window title.\r\n         * @param title\r\n         */\r\n        SetTitle: (title) => void call(WindowSetTitle, {title}),\r\n\r\n        /**\r\n         * Makes the window fullscreen.\r\n         */\r\n        Fullscreen: () => void call(WindowFullscreen),\r\n\r\n        /**\r\n         * Unfullscreen the window.\r\n         */\r\n        UnFullscreen: () => void call(WindowUnFullscreen),\r\n\r\n        /**\r\n         * Set the window size.\r\n         * @param {number} width The window width\r\n         * @param {number} height The window height\r\n         */\r\n        SetSize: (width, height) => call(WindowSetSize, {width,height}),\r\n\r\n        /**\r\n         * Get the window size.\r\n         * @returns {Promise<Size>} The window size\r\n         */\r\n        Size: () => { return call(WindowSize); },\r\n\r\n        /**\r\n         * Set the window maximum size.\r\n         * @param {number} width\r\n         * @param {number} height\r\n         */\r\n        SetMaxSize: (width, height) => void call(WindowSetMaxSize, {width,height}),\r\n\r\n        /**\r\n         * Set the window minimum size.\r\n         * @param {number} width\r\n         * @param {number} height\r\n         */\r\n        SetMinSize: (width, height) => void call(WindowSetMinSize, {width,height}),\r\n\r\n        /**\r\n         * Set window to be always on top.\r\n         * @param {boolean} onTop Whether the window should be always on top\r\n         */\r\n        SetAlwaysOnTop: (onTop) => void call(WindowSetAlwaysOnTop, {alwaysOnTop:onTop}),\r\n\r\n        /**\r\n         * Set the window relative position.\r\n         * @param {number} x\r\n         * @param {number} y\r\n         */\r\n        SetRelativePosition: (x, y) => call(WindowSetRelativePosition, {x,y}),\r\n\r\n        /**\r\n         * Get the window position.\r\n         * @returns {Promise<Position>} The window position\r\n         */\r\n        RelativePosition: () => { return call(WindowRelativePosition); },\r\n\r\n        /**\r\n         * Get the screen the window is on.\r\n         * @returns {Promise<Screen>}\r\n         */\r\n        Screen: () => { return call(WindowScreen); },\r\n\r\n        /**\r\n         * Hide the window\r\n         */\r\n        Hide: () => void call(WindowHide),\r\n\r\n        /**\r\n         * Maximise the window\r\n         */\r\n        Maximise: () => void call(WindowMaximise),\r\n\r\n        /**\r\n         * Show the window\r\n         */\r\n        Show: () => void call(WindowShow),\r\n\r\n        /**\r\n         * Close the window\r\n         */\r\n        Close: () => void call(WindowClose),\r\n\r\n        /**\r\n         * Toggle the window maximise state\r\n         */\r\n        ToggleMaximise: () => void call(WindowToggleMaximise),\r\n\r\n        /**\r\n         * Unmaximise the window\r\n         */\r\n        UnMaximise: () => void call(WindowUnMaximise),\r\n\r\n        /**\r\n         * Minimise the window\r\n         */\r\n        Minimise: () => void call(WindowMinimise),\r\n\r\n        /**\r\n         * Unminimise the window\r\n         */\r\n        UnMinimise: () => void call(WindowUnMinimise),\r\n\r\n        /**\r\n         * Restore the window\r\n         */\r\n        Restore: () => void call(WindowRestore),\r\n\r\n        /**\r\n         * Set the background colour of the window.\r\n         * @param {number} r - A value between 0 and 255\r\n         * @param {number} g - A value between 0 and 255\r\n         * @param {number} b - A value between 0 and 255\r\n         * @param {number} a - A value between 0 and 255\r\n         */\r\n        SetBackgroundColour: (r, g, b, a) => void call(WindowSetBackgroundColour, {r, g, b, a}),\r\n\r\n        /**\r\n         * Set whether the window can be resized or not\r\n         * @param {boolean} resizable\r\n         */\r\n        SetResizable: (resizable) => void call(WindowSetResizable, {resizable}),\r\n\r\n        /**\r\n         * Get the window width\r\n         * @returns {Promise<number>}\r\n         */\r\n        Width: () => { return call(WindowWidth); },\r\n\r\n        /**\r\n         * Get the window height\r\n         * @returns {Promise<number>}\r\n         */\r\n        Height: () => { return call(WindowHeight); },\r\n\r\n        /**\r\n         * Zoom in the window\r\n         */\r\n        ZoomIn: () => void call(WindowZoomIn),\r\n\r\n        /**\r\n         * Zoom out the window\r\n         */\r\n        ZoomOut: () => void call(WindowZoomOut),\r\n\r\n        /**\r\n         * Reset the window zoom\r\n         */\r\n        ZoomReset: () => void call(WindowZoomReset),\r\n\r\n        /**\r\n         * Get the window zoom\r\n         * @returns {Promise<number>}\r\n         */\r\n        GetZoomLevel: () => { return call(WindowGetZoomLevel); },\r\n\r\n        /**\r\n         * Set the window zoom level\r\n         * @param {number} zoomLevel\r\n         */\r\n        SetZoomLevel: (zoomLevel) => void call(WindowSetZoomLevel, {zoomLevel}),\r\n    };\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").WailsEvent} WailsEvent\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Events);\r\nlet EventEmit = 0;\r\n\r\n/**\r\n * The Listener class defines a listener! :-)\r\n *\r\n * @class Listener\r\n */\r\nclass Listener {\r\n    /**\r\n     * Creates an instance of Listener.\r\n     * @param {string} eventName\r\n     * @param {function} callback\r\n     * @param {number} maxCallbacks\r\n     * @memberof Listener\r\n     */\r\n    constructor(eventName, callback, maxCallbacks) {\r\n        this.eventName = eventName;\r\n        // Default of -1 means infinite\r\n        this.maxCallbacks = maxCallbacks || -1;\r\n        // Callback invokes the callback with the given data\r\n        // Returns true if this listener should be destroyed\r\n        this.Callback = (data) => {\r\n            callback(data);\r\n            // If maxCallbacks is infinite, return false (do not destroy)\r\n            if (this.maxCallbacks === -1) {\r\n                return false;\r\n            }\r\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\r\n            this.maxCallbacks -= 1;\r\n            return this.maxCallbacks === 0;\r\n        };\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * WailsEvent defines a custom event. It is passed to event listeners.\r\n *\r\n * @class WailsEvent\r\n * @property {string} name - Name of the event\r\n * @property {any} data - Data associated with the event\r\n */\r\nexport class WailsEvent {\r\n    /**\r\n     * Creates an instance of WailsEvent.\r\n     * @param {string} name - Name of the event\r\n     * @param {any=null} data - Data associated with the event\r\n     * @memberof WailsEvent\r\n     */\r\n    constructor(name, data = null) {\r\n        this.name = name;\r\n        this.data = data;\r\n    }\r\n}\r\n\r\nexport const eventListeners = new Map();\r\n\r\n/**\r\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n * @param {number} maxCallbacks\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function OnMultiple(eventName, callback, maxCallbacks) {\r\n    let listeners = eventListeners.get(eventName) || [];\r\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\r\n    listeners.push(thisListener);\r\n    eventListeners.set(eventName, listeners);\r\n    return () => listenerOff(thisListener);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked every time the event is emitted\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function On(eventName, callback) {\r\n    return OnMultiple(eventName, callback, -1);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked once then destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function(WailsEvent): void} callback\r\n @returns {function} A function to cancel the listener\r\n */\r\nexport function Once(eventName, callback) {\r\n    return OnMultiple(eventName, callback, 1);\r\n}\r\n\r\n/**\r\n * listenerOff unregisters a listener previously registered with On\r\n *\r\n * @param {Listener} listener\r\n */\r\nfunction listenerOff(listener) {\r\n    const eventName = listener.eventName;\r\n    // Remove local listener\r\n    let listeners = eventListeners.get(eventName).filter(l => l !== listener);\r\n    if (listeners.length === 0) {\r\n        eventListeners.delete(eventName);\r\n    } else {\r\n        eventListeners.set(eventName, listeners);\r\n    }\r\n}\r\n\r\n/**\r\n * dispatches an event to all listeners\r\n *\r\n * @export\r\n * @param {WailsEvent} event\r\n */\r\nexport function dispatchWailsEvent(event) {\r\n    let listeners = eventListeners.get(event.name);\r\n    if (listeners) {\r\n        // iterate listeners and call callback. If callback returns true, remove listener\r\n        let toRemove = [];\r\n        listeners.forEach(listener => {\r\n            let remove = listener.Callback(event);\r\n            if (remove) {\r\n                toRemove.push(listener);\r\n            }\r\n        });\r\n        // remove listeners\r\n        if (toRemove.length > 0) {\r\n            listeners = listeners.filter(l => !toRemove.includes(l));\r\n            if (listeners.length === 0) {\r\n                eventListeners.delete(event.name);\r\n            } else {\r\n                eventListeners.set(event.name, listeners);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Off unregisters a listener previously registered with On,\r\n * optionally multiple listeners can be unregistered via `additionalEventNames`\r\n *\r\n [v3 CHANGE] Off only unregisters listeners within the current window\r\n *\r\n * @param {string} eventName\r\n * @param  {...string} additionalEventNames\r\n */\r\nexport function Off(eventName, ...additionalEventNames) {\r\n    let eventsToRemove = [eventName, ...additionalEventNames];\r\n    eventsToRemove.forEach(eventName => {\r\n        eventListeners.delete(eventName);\r\n    });\r\n}\r\n\r\n/**\r\n * OffAll unregisters all listeners\r\n * [v3 CHANGE] OffAll only unregisters listeners within the current window\r\n *\r\n */\r\nexport function OffAll() {\r\n    eventListeners.clear();\r\n}\r\n\r\n/**\r\n * Emit an event\r\n * @param {WailsEvent} event The event to emit\r\n */\r\nexport function Emit(event) {\r\n    void call(EventEmit, event);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n/**\r\n * @typedef {import(\"./api/types\").MessageDialogOptions} MessageDialogOptions\r\n * @typedef {import(\"./api/types\").OpenDialogOptions} OpenDialogOptions\r\n * @typedef {import(\"./api/types\").SaveDialogOptions} SaveDialogOptions\r\n */\r\n\r\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nimport { nanoid } from 'nanoid/non-secure';\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.Dialog);\r\n\r\nlet DialogInfo = 0;\r\nlet DialogWarning = 1;\r\nlet DialogError = 2;\r\nlet DialogQuestion = 3;\r\nlet DialogOpenFile = 4;\r\nlet DialogSaveFile = 5;\r\n\r\n\r\nlet dialogResponses = new Map();\r\n\r\nfunction generateID() {\r\n    let result;\r\n    do {\r\n        result = nanoid();\r\n    } while (dialogResponses.has(result));\r\n    return result;\r\n}\r\n\r\nexport function dialogCallback(id, data, isJSON) {\r\n    let p = dialogResponses.get(id);\r\n    if (p) {\r\n        if (isJSON) {\r\n            p.resolve(JSON.parse(data));\r\n        } else {\r\n            p.resolve(data);\r\n        }\r\n        dialogResponses.delete(id);\r\n    }\r\n}\r\nexport function dialogErrorCallback(id, message) {\r\n    let p = dialogResponses.get(id);\r\n    if (p) {\r\n        p.reject(message);\r\n        dialogResponses.delete(id);\r\n    }\r\n}\r\n\r\nfunction dialog(type, options) {\r\n    return new Promise((resolve, reject) => {\r\n        let id = generateID();\r\n        options = options || {};\r\n        options[\"dialog-id\"] = id;\r\n        dialogResponses.set(id, {resolve, reject});\r\n        call(type, options).catch((error) => {\r\n            reject(error);\r\n            dialogResponses.delete(id);\r\n        });\r\n    });\r\n}\r\n\r\n\r\n/**\r\n * Shows an Info dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Info(options) {\r\n    return dialog(DialogInfo, options);\r\n}\r\n\r\n/**\r\n * Shows a Warning dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Warning(options) {\r\n    return dialog(DialogWarning, options);\r\n}\r\n\r\n/**\r\n * Shows an Error dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Error(options) {\r\n    return dialog(DialogError, options);\r\n}\r\n\r\n/**\r\n * Shows a Question dialog with the given options.\r\n * @param {MessageDialogOptions} options\r\n * @returns {Promise<string>} The label of the button pressed\r\n */\r\nexport function Question(options) {\r\n    return dialog(DialogQuestion, options);\r\n}\r\n\r\n/**\r\n * Shows an Open dialog with the given options.\r\n * @param {OpenDialogOptions} options\r\n * @returns {Promise<string[]|string>} Returns the selected file or an array of selected files if AllowsMultipleSelection is true. A blank string is returned if no file was selected.\r\n */\r\nexport function OpenFile(options) {\r\n    return dialog(DialogOpenFile, options);\r\n}\r\n\r\n/**\r\n * Shows a Save dialog with the given options.\r\n * @param {SaveDialogOptions} options\r\n * @returns {Promise<string>} Returns the selected file. A blank string is returned if no file was selected.\r\n */\r\nexport function SaveFile(options) {\r\n    return dialog(DialogSaveFile, options);\r\n}\r\n\r\n", "import {newRuntimeCallerWithID, objectNames} from \"./runtime\";\r\n\r\nlet call = newRuntimeCallerWithID(objectNames.ContextMenu);\r\n\r\nlet ContextMenuOpen = 0;\r\n\r\nfunction openContextMenu(id, x, y, data) {\r\n    void call(ContextMenuOpen, {id, x, y, data});\r\n}\r\n\r\nexport function setupContextMenus() {\r\n    window.addEventListener('contextmenu', contextMenuHandler);\r\n}\r\n\r\nfunction contextMenuHandler(event) {\r\n    // Check for custom context menu\r\n    let element = event.target;\r\n    let customContextMenu = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu\");\r\n    customContextMenu = customContextMenu ? customContextMenu.trim() : \"\";\r\n    if (customContextMenu) {\r\n        event.preventDefault();\r\n        let customContextMenuData = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu-data\");\r\n        openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);\r\n        return\r\n    }\r\n\r\n    processDefaultContextMenu(event);\r\n}\r\n\r\n\r\n/*\r\n--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\r\n--default-contextmenu: show; will always show the default context menu\r\n--default-contextmenu: hide; will always hide the default context menu\r\n\r\nThis rule is inherited like normal CSS rules, so nesting works as expected\r\n*/\r\nfunction processDefaultContextMenu(event) {\r\n    // Debug builds always show the menu\r\n    if (DEBUG) {\r\n        return;\r\n    }\r\n\r\n    // Process default context menu\r\n    const element = event.target;\r\n    const computedStyle = window.getComputedStyle(element);\r\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\r\n    switch (defaultContextMenuAction) {\r\n        case \"show\":\r\n            return;\r\n        case \"hide\":\r\n            event.preventDefault();\r\n            return;\r\n        default:\r\n            // Check if contentEditable is true\r\n            if (element.isContentEditable) {\r\n                return;\r\n            }\r\n\r\n            // Check if text has been selected\r\n            const selection = window.getSelection();\r\n            const hasSelection = (selection.toString().length > 0)\r\n            if (hasSelection) {\r\n                for (let i = 0; i < selection.rangeCount; i++) {\r\n                    const range = selection.getRangeAt(i);\r\n                    const rects = range.getClientRects();\r\n                    for (let j = 0; j < rects.length; j++) {\r\n                        const rect = rects[j];\r\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\r\n                            return;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // Check if tagname is input or textarea\r\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\r\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\r\n                    return;\r\n                }\r\n            }\r\n\r\n            // hide default context menu\r\n            event.preventDefault();\r\n    }\r\n}\r\n", "\r\nimport {Emit, WailsEvent} from \"./events\";\r\nimport {Question} from \"./dialogs\";\r\n\r\nfunction sendEvent(eventName, data=null) {\r\n    let event = new WailsEvent(eventName, data);\r\n    Emit(event);\r\n}\r\n\r\nfunction addWMLEventListeners() {\r\n    const elements = document.querySelectorAll('[wml-event]');\r\n    elements.forEach(function (element) {\r\n        const eventType = element.getAttribute('wml-event');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Detached: false, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        sendEvent(eventType);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            sendEvent(eventType);\r\n        };\r\n        // Remove existing listeners\r\n\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nfunction callWindowMethod(method) {\r\n    if (wails.Window[method] === undefined) {\r\n        console.log(\"Window method \" + method + \" not found\");\r\n    }\r\n    wails.Window[method]();\r\n}\r\n\r\nfunction addWMLWindowListeners() {\r\n    const elements = document.querySelectorAll('[wml-window]');\r\n    elements.forEach(function (element) {\r\n        const windowMethod = element.getAttribute('wml-window');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        callWindowMethod(windowMethod);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            callWindowMethod(windowMethod);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nfunction addWMLOpenBrowserListener() {\r\n    const elements = document.querySelectorAll('[wml-openurl]');\r\n    elements.forEach(function (element) {\r\n        const url = element.getAttribute('wml-openurl');\r\n        const confirm = element.getAttribute('wml-confirm');\r\n        const trigger = element.getAttribute('wml-trigger') || \"click\";\r\n\r\n        let callback = function () {\r\n            if (confirm) {\r\n                Question({Title: \"Confirm\", Message:confirm, Buttons:[{Label:\"Yes\"},{Label:\"No\", IsDefault:true}]}).then(function (result) {\r\n                    if (result !== \"No\") {\r\n                        void wails.Browser.OpenURL(url);\r\n                    }\r\n                });\r\n                return;\r\n            }\r\n            void wails.Browser.OpenURL(url);\r\n        };\r\n\r\n        // Remove existing listeners\r\n        element.removeEventListener(trigger, callback);\r\n\r\n        // Add new listener\r\n        element.addEventListener(trigger, callback);\r\n    });\r\n}\r\n\r\nexport function reloadWML() {\r\n    addWMLEventListeners();\r\n    addWMLWindowListeners();\r\n    addWMLOpenBrowserListener();\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n// defined in the Taskfile\r\nexport let invoke = function(input) {\r\n    if(WINDOWS) {\r\n        chrome.webview.postMessage(input);\r\n    } else {\r\n        webkit.messageHandlers.external.postMessage(input);\r\n    }\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nlet flags = new Map();\r\n\r\nfunction convertToMap(obj) {\r\n    const map = new Map();\r\n\r\n    for (const [key, value] of Object.entries(obj)) {\r\n        if (typeof value === 'object' && value !== null) {\r\n            map.set(key, convertToMap(value)); // Recursively convert nested object\r\n        } else {\r\n            map.set(key, value);\r\n        }\r\n    }\r\n\r\n    return map;\r\n}\r\n\r\nfetch(\"/wails/flags\").then((response) => {\r\n    response.json().then((data) => {\r\n        flags = convertToMap(data);\r\n    });\r\n});\r\n\r\n\r\nfunction getValueFromMap(keyString) {\r\n    const keys = keyString.split('.');\r\n    let value = flags;\r\n\r\n    for (const key of keys) {\r\n        if (value instanceof Map) {\r\n            value = value.get(key);\r\n        } else {\r\n            value = value[key];\r\n        }\r\n\r\n        if (value === undefined) {\r\n            break;\r\n        }\r\n    }\r\n\r\n    return value;\r\n}\r\n\r\nexport function GetFlag(keyString) {\r\n    return getValueFromMap(keyString);\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {invoke} from \"./invoke\";\r\nimport {GetFlag} from \"./flags\";\r\n\r\nlet shouldDrag = false;\r\n\r\nexport function dragTest(e) {\r\n    let val = window.getComputedStyle(e.target).getPropertyValue(\"--webkit-app-region\");\r\n    if (val) {\r\n        val = val.trim();\r\n    }\r\n\r\n    if (val !== \"drag\") {\r\n        return false;\r\n    }\r\n\r\n    // Only process the primary button\r\n    if (e.buttons !== 1) {\r\n        return false;\r\n    }\r\n\r\n    return e.detail === 1;\r\n}\r\n\r\nexport function setupDrag() {\r\n    window.addEventListener('mousedown', onMouseDown);\r\n    window.addEventListener('mousemove', onMouseMove);\r\n    window.addEventListener('mouseup', onMouseUp);\r\n}\r\n\r\nlet resizeEdge = null;\r\nlet resizable = false;\r\n\r\nexport function setResizable(value) {\r\n    resizable = value;\r\n}\r\n\r\nfunction testResize(e) {\r\n    if( resizeEdge ) {\r\n        invoke(\"resize:\" + resizeEdge);\r\n        return true\r\n    }\r\n    return false;\r\n}\r\n\r\nfunction onMouseDown(e) {\r\n\r\n    // Check for resizing on Windows\r\n    if( WINDOWS ) {\r\n        if (testResize()) {\r\n            return;\r\n        }\r\n    }\r\n    if (dragTest(e)) {\r\n        // Ignore drag on scrollbars\r\n        if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\r\n            return;\r\n        }\r\n        shouldDrag = true;\r\n    } else {\r\n        shouldDrag = false;\r\n    }\r\n}\r\n\r\nfunction onMouseUp(e) {\r\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n    if (mousePressed > 0) {\r\n        endDrag();\r\n    }\r\n}\r\n\r\nexport function endDrag() {\r\n    document.body.style.cursor = 'default';\r\n    shouldDrag = false;\r\n}\r\n\r\nfunction setResize(cursor) {\r\n    document.documentElement.style.cursor = cursor || defaultCursor;\r\n    resizeEdge = cursor;\r\n}\r\n\r\nfunction onMouseMove(e) {\r\n    if (shouldDrag) {\r\n        shouldDrag = false;\r\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n        if (mousePressed > 0) {\r\n            invoke(\"drag\");\r\n        }\r\n        return;\r\n    }\r\n\r\n    if (WINDOWS) {\r\n        if (resizable) {\r\n            handleResize(e);\r\n        }\r\n    }\r\n}\r\n\r\nlet defaultCursor = \"auto\";\r\n\r\nfunction handleResize(e) {\r\n    let resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\r\n    let resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\r\n\r\n    // Extra pixels for the corner areas\r\n    let cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\r\n\r\n    let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;\r\n    let leftBorder = e.clientX < resizeHandleWidth;\r\n    let topBorder = e.clientY < resizeHandleHeight;\r\n    let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;\r\n\r\n    // Adjust for corners\r\n    let rightCorner = window.outerWidth - e.clientX < (resizeHandleWidth + cornerExtra);\r\n    let leftCorner = e.clientX < (resizeHandleWidth + cornerExtra);\r\n    let topCorner = e.clientY < (resizeHandleHeight + cornerExtra);\r\n    let bottomCorner = window.outerHeight - e.clientY < (resizeHandleHeight + cornerExtra);\r\n\r\n    // If we aren't on an edge, but were, reset the cursor to default\r\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== undefined) {\r\n        setResize();\r\n    }\r\n    // Adjusted for corner areas\r\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\r\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\r\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\r\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\r\n    else if (leftBorder) setResize(\"w-resize\");\r\n    else if (topBorder) setResize(\"n-resize\");\r\n    else if (bottomBorder) setResize(\"s-resize\");\r\n    else if (rightBorder) setResize(\"e-resize\");\r\n}\r\n", "/*\r\n _     __     _ __\r\n| |  / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 9 */\r\n\r\n\r\nimport * as Clipboard from './clipboard';\r\nimport * as Application from './application';\r\nimport * as Screens from './screens';\r\nimport * as System from './system';\r\nimport * as Browser from './browser';\r\nimport {Plugin, Call, callErrorCallback, callCallback, CallByID, CallByName} from \"./calls\";\r\nimport {clientId} from './runtime';\r\nimport {newWindow} from \"./window\";\r\nimport {dispatchWailsEvent, Emit, Off, OffAll, On, Once, OnMultiple} from \"./events\";\r\nimport {dialogCallback, dialogErrorCallback, Error, Info, OpenFile, Question, SaveFile, Warning,} from \"./dialogs\";\r\nimport {setupContextMenus} from \"./contextmenu\";\r\nimport {reloadWML} from \"./wml\";\r\nimport {setupDrag, endDrag, setResizable} from \"./drag\";\r\n\r\nwindow.wails = {\r\n    ...newRuntime(null),\r\n    Capabilities: {},\r\n    clientId: clientId,\r\n};\r\n\r\nfetch(\"/wails/capabilities\").then((response) => {\r\n    response.json().then((data) => {\r\n        window.wails.Capabilities = data;\r\n    });\r\n});\r\n\r\n// Internal wails endpoints\r\nwindow._wails = {\r\n    dialogCallback,\r\n    dialogErrorCallback,\r\n    dispatchWailsEvent,\r\n    callCallback,\r\n    callErrorCallback,\r\n    endDrag,\r\n    setResizable,\r\n};\r\n\r\nexport function newRuntime(windowName) {\r\n    return {\r\n        Clipboard: {\r\n            ...Clipboard\r\n        },\r\n        Application: {\r\n            ...Application,\r\n            GetWindowByName(windowName) {\r\n                return newRuntime(windowName);\r\n            }\r\n        },\r\n        System,\r\n        Screens,\r\n        Browser,\r\n        Call,\r\n        CallByID,\r\n        CallByName,\r\n        Plugin,\r\n        WML: {\r\n            Reload: reloadWML,\r\n        },\r\n        Dialog: {\r\n            Info,\r\n            Warning,\r\n            Error,\r\n            Question,\r\n            OpenFile,\r\n            SaveFile,\r\n        },\r\n        Events: {\r\n            Emit,\r\n            On,\r\n            Once,\r\n            OnMultiple,\r\n            Off,\r\n            OffAll,\r\n        },\r\n        Window: newWindow(windowName),\r\n    };\r\n}\r\n\r\nif (DEBUG) {\r\n    console.log(\"Wails v3.0.0 Debug Mode Enabled\");\r\n}\r\n\r\nsetupContextMenus();\r\nsetupDrag();\r\n\r\ndocument.addEventListener(\"DOMContentLoaded\", function() {\r\n    reloadWML();\r\n});\r\n"],
  "mappings": "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",
  "names": ["call", "call", "call", "call", "call", "call", "resizable", "call", "eventName", "call", "generateID", "Error", "call", "windowName", "Error"]
}
 diff --git a/v3/internal/runtime/runtime_debug_linux.go b/v3/internal/runtime/runtime_debug_linux.go deleted file mode 100644 index c2940839204..00000000000 --- a/v3/internal/runtime/runtime_debug_linux.go +++ /dev/null @@ -1,8 +0,0 @@ -//go:build linux && !production - -package runtime - -import _ "embed" - -//go:embed runtime_debug_desktop_linux.js -var DesktopRuntime []byte diff --git a/v3/internal/runtime/runtime_debug_windows.go b/v3/internal/runtime/runtime_debug_windows.go deleted file mode 100644 index 09a3a91981f..00000000000 --- a/v3/internal/runtime/runtime_debug_windows.go +++ /dev/null @@ -1,8 +0,0 @@ -//go:build windows && !production - -package runtime - -import _ "embed" - -//go:embed runtime_debug_desktop_windows.js -var DesktopRuntime []byte diff --git a/v3/internal/runtime/runtime_production_darwin.go b/v3/internal/runtime/runtime_production_darwin.go deleted file mode 100644 index be2411d9ee9..00000000000 --- a/v3/internal/runtime/runtime_production_darwin.go +++ /dev/null @@ -1,8 +0,0 @@ -//go:build darwin && production - -package runtime - -import _ "embed" - -//go:embed runtime_production_desktop_darwin.js -var DesktopRuntime []byte diff --git a/v3/internal/runtime/runtime_production_desktop_darwin.js b/v3/internal/runtime/runtime_production_desktop_darwin.js deleted file mode 100644 index 5fdb99e378c..00000000000 --- a/v3/internal/runtime/runtime_production_desktop_darwin.js +++ /dev/null @@ -1 +0,0 @@ -(()=>{var fe=Object.defineProperty;var g=(t,e)=>{for(var n in e)fe(t,n,{get:e[n],enumerable:!0})};var E={};g(E,{SetText:()=>xe,Text:()=>Ce});var me="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";var m=(t=21)=>{let e="",n=t;for(;n--;)e+=me[Math.random()*64|0];return e};var pe=window.location.origin+"/wails/runtime",l={Call:0,Clipboard:1,Application:2,Events:3,ContextMenu:4,Dialog:5,Window:6,Screens:7,System:8,Browser:9},D=m();function we(t,e,n,o){let i=new URL(pe);i.searchParams.append("object",t),i.searchParams.append("method",e);let r={headers:{}};return n&&(r.headers["x-wails-window-name"]=n),o&&i.searchParams.append("args",JSON.stringify(o)),r.headers["x-wails-client-id"]=D,new Promise((u,S)=>{fetch(i,r).then(s=>{if(s.ok)return s.headers.get("Content-Type")&&s.headers.get("Content-Type").indexOf("application/json")!==-1?s.json():s.text();S(Error(s.statusText))}).then(s=>u(s)).catch(s=>S(s))})}function a(t,e){return function(n,o=null){return we(t,n,e,o)}}var B=a(l.Clipboard),ge=0,he=1;function xe(t){B(ge,{text:t})}function Ce(){return B(he)}var L={};g(L,{Hide:()=>ve,Quit:()=>We,Show:()=>be});var y=a(l.Application),R={Hide:0,Show:1,Quit:2};function ve(){y(R.Hide)}function be(){y(R.Show)}function We(){y(R.Quit)}var k={};g(k,{GetAll:()=>Ee,GetCurrent:()=>Re,GetPrimary:()=>ye});var O=a(l.Screens),Se=0,Me=1,De=2;function Ee(){return O(Se)}function ye(){return O(Me)}function Re(){return O(De)}var N={};g(N,{IsDarkMode:()=>ke});var Le=a(l.System),Oe=0;function ke(){return Le(Oe)}var z={};g(z,{OpenURL:()=>Ie});var Ne=a(l.Browser),ze=0;function Ie(t){Ne(ze,{url:t})}var Ae=a(l.Call),x=0,d=new Map;function Te(){let t;do t=m();while(d.has(t));return t}function j(t,e,n){let o=d.get(t);o&&(n?o.resolve(JSON.parse(e)):o.resolve(e),d.delete(t))}function H(t,e){let n=d.get(t);n&&(n.reject(e),d.delete(t))}function C(t,e){return new Promise((n,o)=>{let i=Te();e=e||{},e["call-id"]=i,d.set(i,{resolve:n,reject:o}),Ae(t,e).catch(r=>{o(r),d.delete(i)})})}function U(t){return C(x,t)}function F(t,...e){if(typeof t!="string"||t.split(".").length!==3)throw new Error("CallByName requires a string in the format 'package.struct.method'");let n=t.split(".");return C(x,{packageName:n[0],structName:n[1],methodName:n[2],args:e})}function G(t,...e){return C(x,{methodID:t,args:e})}function Z(t,e,...n){return C(x,{packageName:"wails-plugins",structName:t,methodName:e,args:n})}var Pe=0,Be=1,je=2,He=3,Ue=4,Fe=5,Ge=6,Ze=7,Ye=8,Qe=9,Xe=10,Ve=11,qe=12,Je=13,_e=14,Ke=15,$e=16,et=17,tt=18,nt=19,ot=20,it=21,rt=22,lt=23,at=24,st=25,ut=26,ct=27,dt=28,ft=29;function Y(t){let e=a(l.Window,t);return{Center:()=>void e(Pe),SetTitle:n=>void e(Be,{title:n}),Fullscreen:()=>void e(je),UnFullscreen:()=>void e(He),SetSize:(n,o)=>e(Ue,{width:n,height:o}),Size:()=>e(Fe),SetMaxSize:(n,o)=>void e(Ge,{width:n,height:o}),SetMinSize:(n,o)=>void e(Ze,{width:n,height:o}),SetAlwaysOnTop:n=>void e(Ye,{alwaysOnTop:n}),SetRelativePosition:(n,o)=>e(Qe,{x:n,y:o}),RelativePosition:()=>e(Xe),Screen:()=>e(Ve),Hide:()=>void e(qe),Maximise:()=>void e(Je),Show:()=>void e(nt),Close:()=>void e(ot),ToggleMaximise:()=>void e(Ke),UnMaximise:()=>void e(_e),Minimise:()=>void e($e),UnMinimise:()=>void e(et),Restore:()=>void e(tt),SetBackgroundColour:(n,o,i,r)=>void e(it,{r:n,g:o,b:i,a:r}),SetResizable:n=>void e(rt,{resizable:n}),Width:()=>e(lt),Height:()=>e(at),ZoomIn:()=>void e(st),ZoomOut:()=>void e(ut),ZoomReset:()=>void e(ct),GetZoomLevel:()=>e(dt),SetZoomLevel:n=>void e(ft,{zoomLevel:n})}}var mt=a(l.Events),pt=0,I=class{constructor(e,n,o){this.eventName=e,this.maxCallbacks=o||-1,this.Callback=i=>(n(i),this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0))}},v=class{constructor(e,n=null){this.name=e,this.data=n}},c=new Map;function b(t,e,n){let o=c.get(t)||[],i=new I(t,e,n);return o.push(i),c.set(t,o),()=>wt(i)}function Q(t,e){return b(t,e,-1)}function X(t,e){return b(t,e,1)}function wt(t){let e=t.eventName,n=c.get(e).filter(o=>o!==t);n.length===0?c.delete(e):c.set(e,n)}function V(t){let e=c.get(t.name);if(e){let n=[];e.forEach(o=>{o.Callback(t)&&n.push(o)}),n.length>0&&(e=e.filter(o=>!n.includes(o)),e.length===0?c.delete(t.name):c.set(t.name,e))}}function q(t,...e){[t,...e].forEach(o=>{c.delete(o)})}function J(){c.clear()}function W(t){mt(pt,t)}var gt=a(l.Dialog),ht=0,xt=1,Ct=2,vt=3,bt=4,Wt=5,f=new Map;function St(){let t;do t=m();while(f.has(t));return t}function _(t,e,n){let o=f.get(t);o&&(n?o.resolve(JSON.parse(e)):o.resolve(e),f.delete(t))}function K(t,e){let n=f.get(t);n&&(n.reject(e),f.delete(t))}function p(t,e){return new Promise((n,o)=>{let i=St();e=e||{},e["dialog-id"]=i,f.set(i,{resolve:n,reject:o}),gt(t,e).catch(r=>{o(r),f.delete(i)})})}function $(t){return p(ht,t)}function ee(t){return p(xt,t)}function te(t){return p(Ct,t)}function w(t){return p(vt,t)}function ne(t){return p(bt,t)}function oe(t){return p(Wt,t)}var Mt=a(l.ContextMenu),Dt=0;function Et(t,e,n,o){Mt(Dt,{id:t,x:e,y:n,data:o})}function ie(){window.addEventListener("contextmenu",yt)}function yt(t){let e=t.target,n=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu");if(n=n?n.trim():"",n){t.preventDefault();let o=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu-data");Et(n,t.clientX,t.clientY,o);return}Rt(t)}function Rt(t){let e=t.target;switch(window.getComputedStyle(e).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":t.preventDefault();return;default:if(e.isContentEditable)return;let i=window.getSelection(),r=i.toString().length>0;if(r)for(let u=0;u{t.json().then(e=>{Nt=se(e)})});var h=!1;function zt(t){let e=window.getComputedStyle(t.target).getPropertyValue("--webkit-app-region");return e&&(e=e.trim()),e!=="drag"||t.buttons!==1?!1:t.detail===1}function ue(){window.addEventListener("mousedown",At),window.addEventListener("mousemove",Pt),window.addEventListener("mouseup",Tt)}var It=!1;function ce(t){It=t}function At(t){if(zt(t)){if(t.offsetX>t.target.clientWidth||t.offsetY>t.target.clientHeight)return;h=!0}else h=!1}function Tt(t){(t.buttons!==void 0?t.buttons:t.which)>0&&T()}function T(){document.body.style.cursor="default",h=!1}function Pt(t){if(h){h=!1,(t.buttons!==void 0?t.buttons:t.which)>0&&ae("drag");return}}window.wails={...de(null),Capabilities:{},clientId:D};fetch("/wails/capabilities").then(t=>{t.json().then(e=>{window.wails.Capabilities=e})});window._wails={dialogCallback:_,dialogErrorCallback:K,dispatchWailsEvent:V,callCallback:j,callErrorCallback:H,endDrag:T,setResizable:ce};function de(t){return{Clipboard:{...E},Application:{...L,GetWindowByName(e){return de(e)}},System:N,Screens:k,Browser:z,Call:U,CallByID:G,CallByName:F,Plugin:Z,WML:{Reload:A},Dialog:{Info:$,Warning:ee,Error:te,Question:w,OpenFile:ne,SaveFile:oe},Events:{Emit:W,On:Q,Once:X,OnMultiple:b,Off:q,OffAll:J},Window:Y(t)}}ie();ue();document.addEventListener("DOMContentLoaded",function(){A()});})(); diff --git a/v3/internal/runtime/runtime_production_desktop_linux.js b/v3/internal/runtime/runtime_production_desktop_linux.js deleted file mode 100644 index 5fdb99e378c..00000000000 --- a/v3/internal/runtime/runtime_production_desktop_linux.js +++ /dev/null @@ -1 +0,0 @@ -(()=>{var fe=Object.defineProperty;var g=(t,e)=>{for(var n in e)fe(t,n,{get:e[n],enumerable:!0})};var E={};g(E,{SetText:()=>xe,Text:()=>Ce});var me="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";var m=(t=21)=>{let e="",n=t;for(;n--;)e+=me[Math.random()*64|0];return e};var pe=window.location.origin+"/wails/runtime",l={Call:0,Clipboard:1,Application:2,Events:3,ContextMenu:4,Dialog:5,Window:6,Screens:7,System:8,Browser:9},D=m();function we(t,e,n,o){let i=new URL(pe);i.searchParams.append("object",t),i.searchParams.append("method",e);let r={headers:{}};return n&&(r.headers["x-wails-window-name"]=n),o&&i.searchParams.append("args",JSON.stringify(o)),r.headers["x-wails-client-id"]=D,new Promise((u,S)=>{fetch(i,r).then(s=>{if(s.ok)return s.headers.get("Content-Type")&&s.headers.get("Content-Type").indexOf("application/json")!==-1?s.json():s.text();S(Error(s.statusText))}).then(s=>u(s)).catch(s=>S(s))})}function a(t,e){return function(n,o=null){return we(t,n,e,o)}}var B=a(l.Clipboard),ge=0,he=1;function xe(t){B(ge,{text:t})}function Ce(){return B(he)}var L={};g(L,{Hide:()=>ve,Quit:()=>We,Show:()=>be});var y=a(l.Application),R={Hide:0,Show:1,Quit:2};function ve(){y(R.Hide)}function be(){y(R.Show)}function We(){y(R.Quit)}var k={};g(k,{GetAll:()=>Ee,GetCurrent:()=>Re,GetPrimary:()=>ye});var O=a(l.Screens),Se=0,Me=1,De=2;function Ee(){return O(Se)}function ye(){return O(Me)}function Re(){return O(De)}var N={};g(N,{IsDarkMode:()=>ke});var Le=a(l.System),Oe=0;function ke(){return Le(Oe)}var z={};g(z,{OpenURL:()=>Ie});var Ne=a(l.Browser),ze=0;function Ie(t){Ne(ze,{url:t})}var Ae=a(l.Call),x=0,d=new Map;function Te(){let t;do t=m();while(d.has(t));return t}function j(t,e,n){let o=d.get(t);o&&(n?o.resolve(JSON.parse(e)):o.resolve(e),d.delete(t))}function H(t,e){let n=d.get(t);n&&(n.reject(e),d.delete(t))}function C(t,e){return new Promise((n,o)=>{let i=Te();e=e||{},e["call-id"]=i,d.set(i,{resolve:n,reject:o}),Ae(t,e).catch(r=>{o(r),d.delete(i)})})}function U(t){return C(x,t)}function F(t,...e){if(typeof t!="string"||t.split(".").length!==3)throw new Error("CallByName requires a string in the format 'package.struct.method'");let n=t.split(".");return C(x,{packageName:n[0],structName:n[1],methodName:n[2],args:e})}function G(t,...e){return C(x,{methodID:t,args:e})}function Z(t,e,...n){return C(x,{packageName:"wails-plugins",structName:t,methodName:e,args:n})}var Pe=0,Be=1,je=2,He=3,Ue=4,Fe=5,Ge=6,Ze=7,Ye=8,Qe=9,Xe=10,Ve=11,qe=12,Je=13,_e=14,Ke=15,$e=16,et=17,tt=18,nt=19,ot=20,it=21,rt=22,lt=23,at=24,st=25,ut=26,ct=27,dt=28,ft=29;function Y(t){let e=a(l.Window,t);return{Center:()=>void e(Pe),SetTitle:n=>void e(Be,{title:n}),Fullscreen:()=>void e(je),UnFullscreen:()=>void e(He),SetSize:(n,o)=>e(Ue,{width:n,height:o}),Size:()=>e(Fe),SetMaxSize:(n,o)=>void e(Ge,{width:n,height:o}),SetMinSize:(n,o)=>void e(Ze,{width:n,height:o}),SetAlwaysOnTop:n=>void e(Ye,{alwaysOnTop:n}),SetRelativePosition:(n,o)=>e(Qe,{x:n,y:o}),RelativePosition:()=>e(Xe),Screen:()=>e(Ve),Hide:()=>void e(qe),Maximise:()=>void e(Je),Show:()=>void e(nt),Close:()=>void e(ot),ToggleMaximise:()=>void e(Ke),UnMaximise:()=>void e(_e),Minimise:()=>void e($e),UnMinimise:()=>void e(et),Restore:()=>void e(tt),SetBackgroundColour:(n,o,i,r)=>void e(it,{r:n,g:o,b:i,a:r}),SetResizable:n=>void e(rt,{resizable:n}),Width:()=>e(lt),Height:()=>e(at),ZoomIn:()=>void e(st),ZoomOut:()=>void e(ut),ZoomReset:()=>void e(ct),GetZoomLevel:()=>e(dt),SetZoomLevel:n=>void e(ft,{zoomLevel:n})}}var mt=a(l.Events),pt=0,I=class{constructor(e,n,o){this.eventName=e,this.maxCallbacks=o||-1,this.Callback=i=>(n(i),this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0))}},v=class{constructor(e,n=null){this.name=e,this.data=n}},c=new Map;function b(t,e,n){let o=c.get(t)||[],i=new I(t,e,n);return o.push(i),c.set(t,o),()=>wt(i)}function Q(t,e){return b(t,e,-1)}function X(t,e){return b(t,e,1)}function wt(t){let e=t.eventName,n=c.get(e).filter(o=>o!==t);n.length===0?c.delete(e):c.set(e,n)}function V(t){let e=c.get(t.name);if(e){let n=[];e.forEach(o=>{o.Callback(t)&&n.push(o)}),n.length>0&&(e=e.filter(o=>!n.includes(o)),e.length===0?c.delete(t.name):c.set(t.name,e))}}function q(t,...e){[t,...e].forEach(o=>{c.delete(o)})}function J(){c.clear()}function W(t){mt(pt,t)}var gt=a(l.Dialog),ht=0,xt=1,Ct=2,vt=3,bt=4,Wt=5,f=new Map;function St(){let t;do t=m();while(f.has(t));return t}function _(t,e,n){let o=f.get(t);o&&(n?o.resolve(JSON.parse(e)):o.resolve(e),f.delete(t))}function K(t,e){let n=f.get(t);n&&(n.reject(e),f.delete(t))}function p(t,e){return new Promise((n,o)=>{let i=St();e=e||{},e["dialog-id"]=i,f.set(i,{resolve:n,reject:o}),gt(t,e).catch(r=>{o(r),f.delete(i)})})}function $(t){return p(ht,t)}function ee(t){return p(xt,t)}function te(t){return p(Ct,t)}function w(t){return p(vt,t)}function ne(t){return p(bt,t)}function oe(t){return p(Wt,t)}var Mt=a(l.ContextMenu),Dt=0;function Et(t,e,n,o){Mt(Dt,{id:t,x:e,y:n,data:o})}function ie(){window.addEventListener("contextmenu",yt)}function yt(t){let e=t.target,n=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu");if(n=n?n.trim():"",n){t.preventDefault();let o=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu-data");Et(n,t.clientX,t.clientY,o);return}Rt(t)}function Rt(t){let e=t.target;switch(window.getComputedStyle(e).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":t.preventDefault();return;default:if(e.isContentEditable)return;let i=window.getSelection(),r=i.toString().length>0;if(r)for(let u=0;u{t.json().then(e=>{Nt=se(e)})});var h=!1;function zt(t){let e=window.getComputedStyle(t.target).getPropertyValue("--webkit-app-region");return e&&(e=e.trim()),e!=="drag"||t.buttons!==1?!1:t.detail===1}function ue(){window.addEventListener("mousedown",At),window.addEventListener("mousemove",Pt),window.addEventListener("mouseup",Tt)}var It=!1;function ce(t){It=t}function At(t){if(zt(t)){if(t.offsetX>t.target.clientWidth||t.offsetY>t.target.clientHeight)return;h=!0}else h=!1}function Tt(t){(t.buttons!==void 0?t.buttons:t.which)>0&&T()}function T(){document.body.style.cursor="default",h=!1}function Pt(t){if(h){h=!1,(t.buttons!==void 0?t.buttons:t.which)>0&&ae("drag");return}}window.wails={...de(null),Capabilities:{},clientId:D};fetch("/wails/capabilities").then(t=>{t.json().then(e=>{window.wails.Capabilities=e})});window._wails={dialogCallback:_,dialogErrorCallback:K,dispatchWailsEvent:V,callCallback:j,callErrorCallback:H,endDrag:T,setResizable:ce};function de(t){return{Clipboard:{...E},Application:{...L,GetWindowByName(e){return de(e)}},System:N,Screens:k,Browser:z,Call:U,CallByID:G,CallByName:F,Plugin:Z,WML:{Reload:A},Dialog:{Info:$,Warning:ee,Error:te,Question:w,OpenFile:ne,SaveFile:oe},Events:{Emit:W,On:Q,Once:X,OnMultiple:b,Off:q,OffAll:J},Window:Y(t)}}ie();ue();document.addEventListener("DOMContentLoaded",function(){A()});})(); diff --git a/v3/internal/runtime/runtime_production_desktop_windows.js b/v3/internal/runtime/runtime_production_desktop_windows.js deleted file mode 100644 index f83dfd6739f..00000000000 --- a/v3/internal/runtime/runtime_production_desktop_windows.js +++ /dev/null @@ -1 +0,0 @@ -(()=>{var xe=Object.defineProperty;var v=(e,t)=>{for(var n in t)xe(e,n,{get:t[n],enumerable:!0})};var O={};v(O,{SetText:()=>Me,Text:()=>De});var Ce="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";var g=(e=21)=>{let t="",n=e;for(;n--;)t+=Ce[Math.random()*64|0];return t};var ve=window.location.origin+"/wails/runtime",l={Call:0,Clipboard:1,Application:2,Events:3,ContextMenu:4,Dialog:5,Window:6,Screens:7,System:8,Browser:9},L=g();function We(e,t,n,o){let i=new URL(ve);i.searchParams.append("object",e),i.searchParams.append("method",t);let r={headers:{}};return n&&(r.headers["x-wails-window-name"]=n),o&&i.searchParams.append("args",JSON.stringify(o)),r.headers["x-wails-client-id"]=L,new Promise((u,p)=>{fetch(i,r).then(s=>{if(s.ok)return s.headers.get("Content-Type")&&s.headers.get("Content-Type").indexOf("application/json")!==-1?s.json():s.text();p(Error(s.statusText))}).then(s=>u(s)).catch(s=>p(s))})}function a(e,t){return function(n,o=null){return We(e,n,t,o)}}var G=a(l.Clipboard),be=0,Se=1;function Me(e){G(be,{text:e})}function De(){return G(Se)}var I={};v(I,{Hide:()=>Ee,Quit:()=>Re,Show:()=>ye});var k=a(l.Application),N={Hide:0,Show:1,Quit:2};function Ee(){k(N.Hide)}function ye(){k(N.Show)}function Re(){k(N.Quit)}var A={};v(A,{GetAll:()=>Ne,GetCurrent:()=>ze,GetPrimary:()=>Ie});var z=a(l.Screens),Le=0,Oe=1,ke=2;function Ne(){return z(Le)}function Ie(){return z(Oe)}function ze(){return z(ke)}var T={};v(T,{IsDarkMode:()=>Pe});var Ae=a(l.System),Te=0;function Pe(){return Ae(Te)}var P={};v(P,{OpenURL:()=>He});var Be=a(l.Browser),je=0;function He(e){Be(je,{url:e})}var Ue=a(l.Call),b=0,f=new Map;function Fe(){let e;do e=g();while(f.has(e));return e}function Z(e,t,n){let o=f.get(e);o&&(n?o.resolve(JSON.parse(t)):o.resolve(t),f.delete(e))}function Y(e,t){let n=f.get(e);n&&(n.reject(t),f.delete(e))}function S(e,t){return new Promise((n,o)=>{let i=Fe();t=t||{},t["call-id"]=i,f.set(i,{resolve:n,reject:o}),Ue(e,t).catch(r=>{o(r),f.delete(i)})})}function Q(e){return S(b,e)}function X(e,...t){if(typeof e!="string"||e.split(".").length!==3)throw new Error("CallByName requires a string in the format 'package.struct.method'");let n=e.split(".");return S(b,{packageName:n[0],structName:n[1],methodName:n[2],args:t})}function V(e,...t){return S(b,{methodID:e,args:t})}function q(e,t,...n){return S(b,{packageName:"wails-plugins",structName:e,methodName:t,args:n})}var Ge=0,Ze=1,Ye=2,Qe=3,Xe=4,Ve=5,qe=6,Je=7,_e=8,Ke=9,$e=10,et=11,tt=12,nt=13,ot=14,it=15,rt=16,lt=17,at=18,st=19,ut=20,ct=21,dt=22,ft=23,mt=24,pt=25,wt=26,gt=27,ht=28,xt=29;function J(e){let t=a(l.Window,e);return{Center:()=>void t(Ge),SetTitle:n=>void t(Ze,{title:n}),Fullscreen:()=>void t(Ye),UnFullscreen:()=>void t(Qe),SetSize:(n,o)=>t(Xe,{width:n,height:o}),Size:()=>t(Ve),SetMaxSize:(n,o)=>void t(qe,{width:n,height:o}),SetMinSize:(n,o)=>void t(Je,{width:n,height:o}),SetAlwaysOnTop:n=>void t(_e,{alwaysOnTop:n}),SetRelativePosition:(n,o)=>t(Ke,{x:n,y:o}),RelativePosition:()=>t($e),Screen:()=>t(et),Hide:()=>void t(tt),Maximise:()=>void t(nt),Show:()=>void t(st),Close:()=>void t(ut),ToggleMaximise:()=>void t(it),UnMaximise:()=>void t(ot),Minimise:()=>void t(rt),UnMinimise:()=>void t(lt),Restore:()=>void t(at),SetBackgroundColour:(n,o,i,r)=>void t(ct,{r:n,g:o,b:i,a:r}),SetResizable:n=>void t(dt,{resizable:n}),Width:()=>t(ft),Height:()=>t(mt),ZoomIn:()=>void t(pt),ZoomOut:()=>void t(wt),ZoomReset:()=>void t(gt),GetZoomLevel:()=>t(ht),SetZoomLevel:n=>void t(xt,{zoomLevel:n})}}var Ct=a(l.Events),vt=0,B=class{constructor(t,n,o){this.eventName=t,this.maxCallbacks=o||-1,this.Callback=i=>(n(i),this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0))}},M=class{constructor(t,n=null){this.name=t,this.data=n}},c=new Map;function D(e,t,n){let o=c.get(e)||[],i=new B(e,t,n);return o.push(i),c.set(e,o),()=>Wt(i)}function _(e,t){return D(e,t,-1)}function K(e,t){return D(e,t,1)}function Wt(e){let t=e.eventName,n=c.get(t).filter(o=>o!==e);n.length===0?c.delete(t):c.set(t,n)}function $(e){let t=c.get(e.name);if(t){let n=[];t.forEach(o=>{o.Callback(e)&&n.push(o)}),n.length>0&&(t=t.filter(o=>!n.includes(o)),t.length===0?c.delete(e.name):c.set(e.name,t))}}function ee(e,...t){[e,...t].forEach(o=>{c.delete(o)})}function te(){c.clear()}function E(e){Ct(vt,e)}var bt=a(l.Dialog),St=0,Mt=1,Dt=2,Et=3,yt=4,Rt=5,m=new Map;function Lt(){let e;do e=g();while(m.has(e));return e}function ne(e,t,n){let o=m.get(e);o&&(n?o.resolve(JSON.parse(t)):o.resolve(t),m.delete(e))}function oe(e,t){let n=m.get(e);n&&(n.reject(t),m.delete(e))}function h(e,t){return new Promise((n,o)=>{let i=Lt();t=t||{},t["dialog-id"]=i,m.set(i,{resolve:n,reject:o}),bt(e,t).catch(r=>{o(r),m.delete(i)})})}function ie(e){return h(St,e)}function re(e){return h(Mt,e)}function le(e){return h(Dt,e)}function x(e){return h(Et,e)}function ae(e){return h(yt,e)}function se(e){return h(Rt,e)}var Ot=a(l.ContextMenu),kt=0;function Nt(e,t,n,o){Ot(kt,{id:e,x:t,y:n,data:o})}function ue(){window.addEventListener("contextmenu",It)}function It(e){let t=e.target,n=window.getComputedStyle(t).getPropertyValue("--custom-contextmenu");if(n=n?n.trim():"",n){e.preventDefault();let o=window.getComputedStyle(t).getPropertyValue("--custom-contextmenu-data");Nt(n,e.clientX,e.clientY,o);return}zt(e)}function zt(e){let t=e.target;switch(window.getComputedStyle(t).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":e.preventDefault();return;default:if(t.isContentEditable)return;let i=window.getSelection(),r=i.toString().length>0;if(r)for(let u=0;u{e.json().then(t=>{fe=me(t)})});function Bt(e){let t=e.split("."),n=fe;for(let o of t)if(n instanceof Map?n=n.get(o):n=n[o],n===void 0)break;return n}function y(e){return Bt(e)}var W=!1;function jt(e){let t=window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region");return t&&(t=t.trim()),t!=="drag"||e.buttons!==1?!1:e.detail===1}function pe(){window.addEventListener("mousedown",Ut),window.addEventListener("mousemove",Gt),window.addEventListener("mouseup",Ft)}var R=null,we=!1;function ge(e){we=e}function Ht(e){return R?(H("resize:"+R),!0):!1}function Ut(e){if(!Ht())if(jt(e)){if(e.offsetX>e.target.clientWidth||e.offsetY>e.target.clientHeight)return;W=!0}else W=!1}function Ft(e){(e.buttons!==void 0?e.buttons:e.which)>0&&U()}function U(){document.body.style.cursor="default",W=!1}function d(e){document.documentElement.style.cursor=e||Zt,R=e}function Gt(e){if(W){W=!1,(e.buttons!==void 0?e.buttons:e.which)>0&&H("drag");return}we&&Yt(e)}var Zt="auto";function Yt(e){let t=y("system.resizeHandleHeight")||5,n=y("system.resizeHandleWidth")||5,o=y("resizeCornerExtra")||10,i=window.outerWidth-e.clientX{e.json().then(t=>{window.wails.Capabilities=t})});window._wails={dialogCallback:ne,dialogErrorCallback:oe,dispatchWailsEvent:$,callCallback:Z,callErrorCallback:Y,endDrag:U,setResizable:ge};function he(e){return{Clipboard:{...O},Application:{...I,GetWindowByName(t){return he(t)}},System:T,Screens:A,Browser:P,Call:Q,CallByID:V,CallByName:X,Plugin:q,WML:{Reload:j},Dialog:{Info:ie,Warning:re,Error:le,Question:x,OpenFile:ae,SaveFile:se},Events:{Emit:E,On:_,Once:K,OnMultiple:D,Off:ee,OffAll:te},Window:J(e)}}ue();pe();document.addEventListener("DOMContentLoaded",function(){j()});})(); diff --git a/v3/internal/runtime/runtime_production_linux.go b/v3/internal/runtime/runtime_production_linux.go deleted file mode 100644 index d7c2bd1efdb..00000000000 --- a/v3/internal/runtime/runtime_production_linux.go +++ /dev/null @@ -1,8 +0,0 @@ -//go:build linux && production - -package runtime - -import _ "embed" - -//go:embed runtime_production_desktop_linux.js -var DesktopRuntime []byte diff --git a/v3/internal/runtime/runtime_production_windows.go b/v3/internal/runtime/runtime_production_windows.go deleted file mode 100644 index 8ab6d619947..00000000000 --- a/v3/internal/runtime/runtime_production_windows.go +++ /dev/null @@ -1,8 +0,0 @@ -//go:build windows && production - -package runtime - -import _ "embed" - -//go:embed runtime_production_desktop_windows.js -var DesktopRuntime []byte diff --git a/v3/pkg/application/application.go b/v3/pkg/application/application.go index 5fb7f96af36..afa61253180 100644 --- a/v3/pkg/application/application.go +++ b/v3/pkg/application/application.go @@ -825,3 +825,10 @@ func (a *App) BrowserOpenURL(url string) error { func (a *App) BrowserOpenFile(path string) error { return browser.OpenFile(path) } + +func (a *App) Environment() EnvironmentInfo { + return EnvironmentInfo{ + OS: runtime.GOOS, + Arch: runtime.GOARCH, + } +} diff --git a/v3/pkg/application/environment.go b/v3/pkg/application/environment.go new file mode 100644 index 00000000000..dbc7f3cedb1 --- /dev/null +++ b/v3/pkg/application/environment.go @@ -0,0 +1,6 @@ +package application + +type EnvironmentInfo struct { + OS string + Arch string +} diff --git a/v3/pkg/application/messageprocessor.go b/v3/pkg/application/messageprocessor.go index a7b4ee3c20c..1eef916c0e4 100644 --- a/v3/pkg/application/messageprocessor.go +++ b/v3/pkg/application/messageprocessor.go @@ -41,26 +41,26 @@ func (m *MessageProcessor) httpError(rw http.ResponseWriter, message string, arg rw.Write([]byte(fmt.Sprintf(message, args...))) } -func (m *MessageProcessor) getTargetWindow(r *http.Request) Window { +func (m *MessageProcessor) getTargetWindow(r *http.Request) (Window, string) { windowName := r.Header.Get(webViewRequestHeaderWindowName) if windowName != "" { - return globalApplication.GetWindowByName(windowName) + return globalApplication.GetWindowByName(windowName), windowName } windowID := r.Header.Get(webViewRequestHeaderWindowId) if windowID == "" { - return nil + return nil, windowID } wID, err := strconv.ParseUint(windowID, 10, 64) if err != nil { m.Error("Window ID '%s' not parsable: %s", windowID, err) - return nil + return nil, windowID } targetWindow := globalApplication.getWindowForID(uint(wID)) if targetWindow == nil { m.Error("Window ID %d not found", wID) - return nil + return nil, windowID } - return targetWindow + return targetWindow, windowID } func (m *MessageProcessor) HandleRuntimeCall(rw http.ResponseWriter, r *http.Request) { @@ -115,9 +115,9 @@ func (m *MessageProcessor) HandleRuntimeCallWithIDs(rw http.ResponseWriter, r *h } params := QueryParams(r.URL.Query()) - targetWindow := m.getTargetWindow(r) + targetWindow, nameOrID := m.getTargetWindow(r) if targetWindow == nil { - m.httpError(rw, "No valid window found") + m.httpError(rw, fmt.Sprintf("Window '%s' not found", nameOrID)) return } diff --git a/v3/pkg/application/messageprocessor_system.go b/v3/pkg/application/messageprocessor_system.go index fcd44a1a487..4930161eb8e 100644 --- a/v3/pkg/application/messageprocessor_system.go +++ b/v3/pkg/application/messageprocessor_system.go @@ -6,6 +6,7 @@ import ( const ( SystemIsDarkMode = 0 + Environment = 1 ) var systemMethodNames = map[int]string{ @@ -17,6 +18,8 @@ func (m *MessageProcessor) processSystemMethod(method int, rw http.ResponseWrite switch method { case SystemIsDarkMode: m.json(rw, globalApplication.IsDarkMode()) + case Environment: + m.json(rw, globalApplication.Environment()) default: m.httpError(rw, "Unknown system method: %d", method) } diff --git a/v3/pkg/application/webview_window.go b/v3/pkg/application/webview_window.go index a074b607a6d..8a2786db431 100644 --- a/v3/pkg/application/webview_window.go +++ b/v3/pkg/application/webview_window.go @@ -239,13 +239,13 @@ func (w *WebviewWindow) formatJS(f string, callID string, data string) string { func (w *WebviewWindow) CallError(callID string, result string) { if w.impl != nil { - w.impl.execJS(w.formatJS("_wails.callErrorCallback('%s', %s);", callID, result)) + w.impl.execJS(w.formatJS("_wails.callErrorHandler('%s', %s);", callID, result)) } } func (w *WebviewWindow) CallResponse(callID string, result string) { if w.impl != nil { - w.impl.execJS(w.formatJS("_wails.callCallback('%s', %s, true);", callID, result)) + w.impl.execJS(w.formatJS("_wails.callResultHandler('%s', %s, true);", callID, result)) } }