From 6b8c8d495f48bb0b6584270f5c13d9af4e2096ac Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 18 Dec 2025 02:41:03 +0000 Subject: [PATCH 01/40] chore(v3): bump to v3.0.0-alpha.49 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 5 +++++ v3/UNRELEASED_CHANGELOG.md | 1 - v3/internal/version/version.txt | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index fe2422da3..e93284cf9 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.49 - 2025-12-18 + +## Changed +- Update the `Frontend Runtime` documentation by adding more options for generating frontend bindings by @ndianabasi + ## v3.0.0-alpha.48 - 2025-12-16 ## Added diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index bd2039680..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -19,7 +19,6 @@ After processing, the content will be moved to the main changelog and this file ## Changed -- Update the `Frontend Runtime` documentation by adding more options for generating frontend bindings by @ndianabasi ## Fixed diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index f65f1f889..1840432d8 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.48 \ No newline at end of file +v3.0.0-alpha.49 \ No newline at end of file From 618489800cb60881d152a881558fcecd179a8d99 Mon Sep 17 00:00:00 2001 From: ruhuang Date: Sat, 20 Dec 2025 12:50:32 +0800 Subject: [PATCH 02/40] docs: add examples for window X/Y coordinate options (#4817) * docs: add examples for window X/Y coordinate options * Update UNRELEASED_CHANGELOG.md --- docs/src/content/docs/features/windows/options.mdx | 12 +++++++++++- v3/UNRELEASED_CHANGELOG.md | 1 + 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/docs/src/content/docs/features/windows/options.mdx b/docs/src/content/docs/features/windows/options.mdx index 0b278e651..521d50b01 100644 --- a/docs/src/content/docs/features/windows/options.mdx +++ b/docs/src/content/docs/features/windows/options.mdx @@ -158,7 +158,17 @@ Y: 100, // 100px from top edge - Positive X goes right - Positive Y goes down -**Best practice:** Use `Center()` instead: +**Example:** + +```go +settings := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + Name: "coordinate-window", + InitialPosition: application.WindowXY, // use coordinate system + X: 100, + Y: 100, +}) + +**Best practice:** Use `Center()` to center the window: ```go window := app.NewWebviewWindow() diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..0123dbe00 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -20,6 +20,7 @@ After processing, the content will be moved to the main changelog and this file ## Changed +- Update the documentation for Window `X/Y` options @ruhuang2001 ## Fixed From 0271c9e10cd76d122795bcd1a8d3360a6ae5d794 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 21 Dec 2025 02:47:21 +0000 Subject: [PATCH 03/40] chore(v3): bump to v3.0.0-alpha.50 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 5 +++++ v3/UNRELEASED_CHANGELOG.md | 1 - v3/internal/version/version.txt | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index e93284cf9..2f826dab1 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.50 - 2025-12-21 + +## Changed +- Update the documentation for Window `X/Y` options @ruhuang2001 + ## v3.0.0-alpha.49 - 2025-12-18 ## Changed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 0123dbe00..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -20,7 +20,6 @@ After processing, the content will be moved to the main changelog and this file ## Changed -- Update the documentation for Window `X/Y` options @ruhuang2001 ## Fixed diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 1840432d8..f24592cb0 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.49 \ No newline at end of file +v3.0.0-alpha.50 \ No newline at end of file From 9174be76f293fb0f88298c7363ec2ff689fa8a7c Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Tue, 23 Dec 2025 06:33:09 +1100 Subject: [PATCH 04/40] Prevent app crashing when calling systray.Run() before app.Run() (#4826) --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/pkg/application/systemtray.go | 7 +++++++ 2 files changed, 8 insertions(+) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..98c0451dd 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,6 +23,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Prevent app crashing when calling systray.Run() before app.Run() by @leaanthony ## Deprecated diff --git a/v3/pkg/application/systemtray.go b/v3/pkg/application/systemtray.go index ef0525e54..0735b52e2 100644 --- a/v3/pkg/application/systemtray.go +++ b/v3/pkg/application/systemtray.go @@ -96,6 +96,13 @@ func (s *SystemTray) Label() string { } func (s *SystemTray) Run() { + + // exit early if application isn't running. + // app.Run() will call this + if globalApplication == nil || globalApplication.running == false { + return + } + s.impl = newSystemTrayImpl(s) if s.attachedWindow.Window != nil { From e34c172f0cedd6d9805064507d4e86ab6afb5005 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 23 Dec 2025 02:43:45 +0000 Subject: [PATCH 05/40] chore(v3): bump to v3.0.0-alpha.51 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 5 +++++ v3/UNRELEASED_CHANGELOG.md | 1 - v3/internal/version/version.txt | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index 2f826dab1..d36feed8f 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.51 - 2025-12-23 + +## Fixed +- Prevent app crashing when calling systray.Run() before app.Run() by @leaanthony + ## v3.0.0-alpha.50 - 2025-12-21 ## Changed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 98c0451dd..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,7 +23,6 @@ After processing, the content will be moved to the main changelog and this file ## Fixed -- Prevent app crashing when calling systray.Run() before app.Run() by @leaanthony ## Deprecated diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index f24592cb0..541143cbe 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.50 \ No newline at end of file +v3.0.0-alpha.51 \ No newline at end of file From f30c888c5bce9b18f0f08c3f5212baf4431df634 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Thu, 25 Dec 2025 19:35:44 +1100 Subject: [PATCH 06/40] fix(windows): Prevent systray menu crash on rapid clicks (#4151) (#4812) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add guard against concurrent TrackPopupMenuEx calls using atomic.Bool to prevent race condition when user clicks systray icon repeatedly. Change TrackPopupMenuEx failure from fatal to debug log with early return so the application gracefully handles failed menu display attempts instead of crashing. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Vibe Kanban Co-authored-by: Claude --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/pkg/application/popupmenu_windows.go | 16 ++++++++++++++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..c6bcc38a2 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,6 +23,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Fix Windows systray menu crash when clicking icon repeatedly by adding guard against concurrent TrackPopupMenuEx calls (#4151) by @leaanthony ## Deprecated diff --git a/v3/pkg/application/popupmenu_windows.go b/v3/pkg/application/popupmenu_windows.go index f237b2669..ed809a130 100644 --- a/v3/pkg/application/popupmenu_windows.go +++ b/v3/pkg/application/popupmenu_windows.go @@ -1,8 +1,10 @@ package application import ( - "github.com/wailsapp/wails/v3/pkg/w32" + "sync/atomic" "unsafe" + + "github.com/wailsapp/wails/v3/pkg/w32" ) const ( @@ -49,6 +51,7 @@ type Win32Menu struct { currentMenuID int onMenuClose func() onMenuOpen func() + isShowing atomic.Bool // guards against concurrent TrackPopupMenuEx calls } func (p *Win32Menu) newMenu() w32.HMENU { @@ -189,6 +192,12 @@ func NewApplicationMenu(parent *windowsWebviewWindow, inputMenu *Menu) *Win32Men } func (p *Win32Menu) ShowAt(x int, y int) { + // Prevent concurrent menu displays - TrackPopupMenuEx is blocking and + // calling it while another popup is showing causes "TrackPopupMenu failed" + if !p.isShowing.CompareAndSwap(false, true) { + return + } + defer p.isShowing.Store(false) w32.SetForegroundWindow(p.parent) @@ -216,7 +225,10 @@ func (p *Win32Menu) ShowAt(x int, y int) { } if !w32.TrackPopupMenuEx(p.menu, menuFlags, int32(x), int32(y), p.parent, nil) { - globalApplication.fatal("TrackPopupMenu failed") + // TrackPopupMenuEx can fail if called during menu transitions or rapid clicks. + // This is not fatal - just skip this menu display attempt. + globalApplication.debug("TrackPopupMenu failed - menu may already be showing") + return } if p.onMenuClose != nil { From 3b055efcae822d5cdd405267801c75ae0b37dd35 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 26 Dec 2025 02:43:00 +0000 Subject: [PATCH 07/40] chore(v3): bump to v3.0.0-alpha.52 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 5 +++++ v3/UNRELEASED_CHANGELOG.md | 1 - v3/internal/version/version.txt | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index d36feed8f..f23edf746 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.52 - 2025-12-26 + +## Fixed +- Fix Windows systray menu crash when clicking icon repeatedly by adding guard against concurrent TrackPopupMenuEx calls (#4151) by @leaanthony + ## v3.0.0-alpha.51 - 2025-12-23 ## Fixed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index c6bcc38a2..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,7 +23,6 @@ After processing, the content will be moved to the main changelog and this file ## Fixed -- Fix Windows systray menu crash when clicking icon repeatedly by adding guard against concurrent TrackPopupMenuEx calls (#4151) by @leaanthony ## Deprecated diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 541143cbe..11d2c7943 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.51 \ No newline at end of file +v3.0.0-alpha.52 \ No newline at end of file From ab33eb594e111bbb2b7cf2ab088746210ad9840c Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Sat, 27 Dec 2025 09:52:26 +1100 Subject: [PATCH 08/40] docs: fix custom protocol association documentation (#4825) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * docs: fix custom protocol association documentation The documentation was incorrectly referencing `wails.json` with JSON format when the actual configuration file is `build/config.yml` using YAML format. Changes: - Update config file reference from `wails.json` to `build/config.yml` - Change format from JSON to YAML in code examples - Fix structure: `protocols` is at root level, not nested under `info` - Correct template variable references from `{{.Info.Protocols}}` to `{{.Protocols}}` - Update Info.plist example to show actual generated format (`wails.com.scheme`) - Add note about running `wails3 task common:update:build-assets` after changes - Clean up redundant file path references in platform-specific sections 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude * docs: consolidate custom protocol docs and add Universal Links - Remove duplicate custom-protocol-association.mdx - Add Universal Links section to macOS tab - Add Web-to-App Linking section to Windows tab - Keep the more comprehensive distribution/custom-protocols.mdx Addresses review comment about duplicate documentation. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 * feat(windows): add custom protocol support to MSIX packaging - Add uap3 namespace and protocol extension to MSIX template - Protocols defined in build/config.yml are now automatically registered when building MSIX packages - Update docs with MSIX section and clarify Web-to-App linking requires manual manifest configuration 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --------- Co-authored-by: Claude --- .../guides/custom-protocol-association.mdx | 216 ------------------ .../guides/distribution/custom-protocols.mdx | 73 +++++- v3/UNRELEASED_CHANGELOG.md | 2 + .../windows/msix/app_manifest.xml.tmpl | 11 +- 4 files changed, 84 insertions(+), 218 deletions(-) delete mode 100644 docs/src/content/docs/guides/custom-protocol-association.mdx diff --git a/docs/src/content/docs/guides/custom-protocol-association.mdx b/docs/src/content/docs/guides/custom-protocol-association.mdx deleted file mode 100644 index b4f2167c2..000000000 --- a/docs/src/content/docs/guides/custom-protocol-association.mdx +++ /dev/null @@ -1,216 +0,0 @@ ---- -title: Custom Protocol Schemes (Deep Linking) -description: Guide to implementing custom URL schemes for deep linking in Wails applications across macOS, Windows, and Linux. ---- - -import { Aside } from '@astrojs/starlight/components'; - -# Custom Protocol Schemes (Deep Linking) - -Custom protocol schemes (also known as custom URL schemes or deep linking) allow your Wails application to be launched or brought to the foreground by clicking a URL with a scheme you define (e.g., `myapp://some/data`). This is useful for various purposes, such as: - -- OAuth authentication flows. -- Inter-application communication. -- Launching your app with a specific context or to perform a particular action. - -Wails provides a unified way to handle these custom URL invocations across macOS, Windows, and Linux through the `events.Common.ApplicationLaunchedWithUrl` event. - -## Defining Your Protocols - -First, you need to define the custom protocol schemes your application will use. This is done in your `wails.json` project configuration file. Wails reads this file during the build process (`wails build`) to configure the necessary platform-specific assets like `Info.plist` for macOS, NSIS installer scripts for Windows, and `.desktop` files for Linux. - -**Example: `wails.json`** - -```json title="wails.json" -{ - "name": "My App", - "description": "An amazing Wails app!", - "info": { - "companyName": "My Company", - "productName": "My Product", - // ... other info fields ... - "protocols": [ - { - "scheme": "myapp", - "description": "My Application Custom Protocol" - }, - { - "scheme": "anotherprotocol", - "description": "Another protocol for specific actions" - } - ] - } - // ... other wails.json fields ... -} -``` - -This `info.protocols` array is what Wails uses to generate the necessary entries in platform-specific files. For example, in template files, you might access this via a path like `{{.Info.Protocols}}`. - - - -## Handling the Event in Your Application - -When your application is launched or activated via a custom URL, Wails emits an `events.Common.ApplicationLaunchedWithUrl` event. You can listen for this event and retrieve the URL that triggered the launch. - -```go title="main.go" -import ( - "log" - "github.com/wailsapp/wails/v3/pkg/application" - "github.com/wailsapp/wails/v3/pkg/events" -) - -func main() { - app := application.New(application.Options{ - Name: "My App", // Ensure this matches relevant info from wails.json if needed - Description: "An amazing Wails app!", - // ... other runtime options ... - }) - - app.Event.OnApplicationEvent(events.Common.ApplicationLaunchedWithUrl, func(e *application.ApplicationEvent) { - launchedURL := e.Context().URL() // Retrieve the URL from the event context - log.Printf("Application launched with URL: %s", launchedURL) - - // TODO: Process the URL (e.g., navigate, perform action, etc.) - // Example: app.Event.Emit("frontend:ShowURL", launchedURL) - }) - - // ... rest of your main function ... - err := app.Run() - if err != nil { - log.Fatal(err) - } -} -``` - - - -## Platform-Specific Setup and Behavior - -While Wails aims for a unified event, the underlying mechanism for custom protocol registration and URL delivery varies by operating system. - -### macOS - -- **Setup:** Wails automatically configures your application's `Info.plist` file during the build process. It adds `CFBundleURLTypes` entries based on the `info.protocols` defined in your `wails.json` file. - ```xml title="Info.plist (excerpt generated by Wails)" - CFBundleURLTypes - - - CFBundleURLName - My Application Custom Protocol - CFBundleURLSchemes - - myapp - - - - - ``` -- **How it Works:** When a URL like `myapp://` is opened, macOS uses LaunchServices to find the application registered for that scheme and sends it an Apple Event (`kAEGetURL`). Wails intercepts this event and translates it into the common `events.Common.ApplicationLaunchedWithUrl` Wails event, providing the URL via `e.Context().URL()`. - -#### Universal Links - -In addition to custom protocol schemes, macOS also supports **Universal Links**, which allow your app to be launched by regular HTTPS links (e.g., `https://myawesomeapp.com/path`). Universal Links provide a seamless user experience between your web and desktop app. - - - -To enable Universal Links, follow the [Apple guide on supporting Universal Links in your app](https://developer.apple.com/documentation/xcode/supporting-universal-links-in-your-app). You'll need to: - -1. **Add entitlements** in your `entitlements.plist`: - ```xml title="entitlements.plist" - com.apple.developer.associated-domains - - applinks:myawesomeapp.com - - ``` - -2. **Add NSUserActivityTypes to Info.plist**: - ```xml title="Info.plist" - NSUserActivityTypes - - NSUserActivityTypeBrowsingWeb - - ``` - -3. **Configure `apple-app-site-association` on your website:** Host an `apple-app-site-association` file at `https://myawesomeapp.com/.well-known/apple-app-site-association`. - -When a Universal Link triggers your app, you'll receive the same `events.Common.ApplicationLaunchedWithUrl` event, making the handling code identical to custom protocol schemes. - -### Windows - -- **Setup:** Custom protocol schemes on Windows are registered in the Windows Registry. Wails facilitates this through its NSIS installer template. - - When you build your application with the `-nsis` flag, Wails uses the `v3/internal/commands/updatable_build_assets/windows/nsis/wails_tools.nsh.tmpl` file. - - This template contains macros like `CUSTOM_PROTOCOL_ASSOCIATE` and `wails.associateCustomProtocols` which use the `info.protocols` from your `wails.json` (passed as `{{.Info.Protocols}}` to the template) to create the necessary registry entries during installation. - ```nsis title="wails_tools.nsh.tmpl (excerpt)" - !macro wails.associateCustomProtocols - ; Create custom protocols associations - {{range .Info.Protocols}} - !insertmacro CUSTOM_PROTOCOL_ASSOCIATE "{{.Scheme}}" "{{.Description}}" "$INSTDIR\${PRODUCT_EXECUTABLE},0" "$INSTDIR\${PRODUCT_EXECUTABLE} $\"%1$\"" - {{end}} - !macroend - ``` -- **How it Works:** The installer registers your application executable to be called with the URL as a command-line argument (`%1`). For example, `your_app.exe "myapp://some/data"`. - - The Wails runtime for Windows (`v3/pkg/application/application_windows.go`) has been updated to check `os.Args` upon startup. If it detects an argument that looks like a URL (e.g., `os.Args[1]` contains `"://"`), it now emits the `events.Common.ApplicationLaunchedWithUrl` event with this URL. - - - -#### Universal Links (Web-to-App Linking) - -Windows supports **Web-to-App linking**, which works similarly to Universal Links on macOS. When deploying your application as an MSIX package, you can enable HTTPS links to launch your app directly. - -To enable Web-to-App linking, follow the [Microsoft guide on web-to-app linking](https://learn.microsoft.com/en-us/windows/apps/develop/launch/web-to-app-linking). You'll need to: - -1. **Add App URI Handler in your MSIX manifest**: - ```xml title="AppPackage.appxmanifest (excerpt)" - - - - - - ``` - -2. **Configure `windows-app-web-link` on your website:** Host a `windows-app-web-link` file at `https://my.app.org/.well-known/windows-app-web-link`. This file should contain your app's package information and the paths it handles. - -When a Web-to-App link launches your application, you'll receive the same `events.Common.ApplicationLaunchedWithUrl` event as with custom protocol schemes. - -### Linux - -- **Setup:** On Linux, custom protocol handling is typically managed via `.desktop` files and the MIME type system. - - Wails uses a `.desktop` file template (e.g., `v3/internal/commands/updatable_build_assets/linux/desktop.tmpl`) which is populated during the build using information from `wails.json`. - ```desktop title="desktop.tmpl (excerpt)" - [Desktop Entry] - Name={{.ProductName}} - Exec=/usr/local/bin/{{.BinaryName}} %u - MimeType={{range $index, $protocol := .Info.Protocols}}x-scheme-handler/{{$protocol.Scheme}};{{end}} - ``` - The `Exec` line uses `%u` which gets replaced by the URL. The `MimeType` line registers your application as a handler for `x-scheme-handler/your-scheme` for each protocol defined in `wails.json` (via `{{.Info.Protocols}}`). - - When packaging for Linux (e.g., using `nfpm`), this `.desktop` file is installed to `/usr/share/applications/`. - - A `postinstall.sh` script (e.g., `v3/internal/commands/build_assets/linux/nfpm/scripts/postinstall.sh`) is used to update the system's application and MIME databases: - ```sh title="postinstall.sh (excerpt)" - #!/bin/sh - update-desktop-database -q /usr/share/applications - update-mime-database -n /usr/share/mime - ``` -- **How it Works:** When a URL like `myapp://` is opened, the desktop environment uses the MIME database to find the associated `.desktop` file and executes the command specified in its `Exec` line, substituting `%u` with the URL. Your application receives this URL as a command-line argument. - - The Wails runtime for Linux (`v3/pkg/application/application_linux.go`) checks `os.Args` on startup. If it detects an argument that looks like a URL, it emits the `events.Common.ApplicationLaunchedWithUrl` event. - -## Testing Your Custom Protocols - -- **macOS:** Open Terminal and type `open "your-scheme://your/data"`. -- **Linux:** Open a terminal and type `xdg-open "your-scheme://your/data"` (requires `xdg-utils` to be installed and the app to be properly packaged and registered). -- **Windows:** After installation via NSIS: - - You can try running `start your-scheme://your/data` from Command Prompt or PowerShell. - - Create a simple HTML file with a link `Test Link` and open it in a browser. - - - -By following this guide, you can effectively use custom protocol schemes to enhance your Wails application's interactivity and integration with other applications or web services. diff --git a/docs/src/content/docs/guides/distribution/custom-protocols.mdx b/docs/src/content/docs/guides/distribution/custom-protocols.mdx index 97c4b1372..760e8e2d8 100644 --- a/docs/src/content/docs/guides/distribution/custom-protocols.mdx +++ b/docs/src/content/docs/guides/distribution/custom-protocols.mdx @@ -5,7 +5,7 @@ sidebar: order: 3 --- -import { Tabs, TabItem } from '@astrojs/starlight/components'; +import { Tabs, TabItem, Aside } from '@astrojs/starlight/components'; Custom URL protocols (also called URL schemes) allow your application to be launched when users click links with your custom protocol, such as `myapp://action` or `myapp://open/document`. @@ -159,6 +159,47 @@ Start-Process "myapp://test/action" start myapp://test/action ``` +### Windows MSIX Package + +Custom protocols are also automatically registered when using MSIX packaging. + +#### Automatic Registration + +When you build your application with MSIX, the manifest automatically includes protocol registrations from your `build/config.yml` protocols configuration. + +The generated manifest includes: + +```xml + + + My Application Protocol + + +``` + +#### Universal Links (Web-to-App Linking) + +Windows supports **Web-to-App linking**, which works similarly to Universal Links on macOS. When deploying your application as an MSIX package, you can enable HTTPS links to launch your app directly. + + + +To enable Web-to-App linking, follow the [Microsoft guide on web-to-app linking](https://learn.microsoft.com/en-us/windows/apps/develop/launch/web-to-app-linking). You'll need to: + +1. **Manually add App URI Handler to your MSIX manifest** (`build/windows/msix/app_manifest.xml`): + ```xml + + + + + + ``` + +2. **Configure `windows-app-web-link` on your website:** Host a `windows-app-web-link` file at `https://myawesomeapp.com/.well-known/windows-app-web-link`. This file should contain your app's package information and the paths it handles. + +When a Web-to-App link launches your application, you'll receive the same `ApplicationOpenedWithURL` event as with custom protocol schemes. + @@ -199,6 +240,36 @@ open "myapp://test/action" /System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -dump | grep myapp ``` +#### Universal Links + +In addition to custom protocol schemes, macOS also supports **Universal Links**, which allow your app to be launched by regular HTTPS links (e.g., `https://myawesomeapp.com/path`). Universal Links provide a seamless user experience between your web and desktop app. + + + +To enable Universal Links, follow the [Apple guide on supporting Universal Links in your app](https://developer.apple.com/documentation/xcode/supporting-universal-links-in-your-app). You'll need to: + +1. **Add entitlements** in your `entitlements.plist`: + ```xml + com.apple.developer.associated-domains + + applinks:myawesomeapp.com + + ``` + +2. **Add NSUserActivityTypes to Info.plist**: + ```xml + NSUserActivityTypes + + NSUserActivityTypeBrowsingWeb + + ``` + +3. **Configure `apple-app-site-association` on your website:** Host an `apple-app-site-association` file at `https://myawesomeapp.com/.well-known/apple-app-site-association`. + +When a Universal Link triggers your app, you'll receive the same `ApplicationOpenedWithURL` event, making the handling code identical to custom protocol schemes. + diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..f9ed39c39 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -17,12 +17,14 @@ After processing, the content will be moved to the main changelog and this file ## Added +- Add custom protocol support to MSIX packaging by @leaanthony ## Changed ## Fixed +- Consolidate custom protocol documentation and add Universal Links sections by @leaanthony ## Deprecated diff --git a/v3/internal/commands/build_assets/windows/msix/app_manifest.xml.tmpl b/v3/internal/commands/build_assets/windows/msix/app_manifest.xml.tmpl index d68664afb..430f8c3a9 100644 --- a/v3/internal/commands/build_assets/windows/msix/app_manifest.xml.tmpl +++ b/v3/internal/commands/build_assets/windows/msix/app_manifest.xml.tmpl @@ -2,8 +2,10 @@ + xmlns:desktop="http://schemas.microsoft.com/appx/manifest/desktop/windows10" + IgnorableNamespaces="uap3"> {{end}} + {{range .Protocols}} + + + {{.Description}} + + + {{end}} From 2604ecc0f8bc60eb03868937e82e10b12c718b03 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Sat, 27 Dec 2025 09:53:24 +1100 Subject: [PATCH 09/40] test(v3): add comprehensive unit tests for pkg/application (#4827) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * test(v3): add comprehensive unit tests for pkg/application Add 11 new test files to improve test coverage of the pkg/application package from 13.6% to 17.7%. New test files: - context_test.go: Context struct operations - services_test.go: Service management and lifecycle - parameter_test.go: Parameter and CallError types - dialogs_test.go: Dialog utilities and button methods - webview_window_options_test.go: Window options and constants - application_options_test.go: ChainMiddleware and app config - keys_test.go: Keyboard accelerator parsing - single_instance_test.go: Single instance management and encryption - menuitem_internal_test.go: Menu item internal functions - menu_internal_test.go: Menu internal functions - screenmanager_internal_test.go: Screen geometry and transformations The 40% target was not fully achievable because ~50% of the codebase is platform-specific code that can only be tested on respective platforms. Tests focus on pure Go logic, utility functions, and data structures that can be tested cross-platform. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 * fix: address CodeRabbit review comments - dialogs_test.go: improve ID recycling test to verify either recycled ID (id3 == id1) or new unique ID (id3 > id2) - keys_test.go: make accelerator String() tests platform-agnostic by checking suffix patterns rather than exact platform-specific strings 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 * fix: normalize temp dir path for macOS compatibility in test os.TempDir() returns a trailing slash on macOS, causing path comparison to fail. Use filepath.Clean() to normalize both paths. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 * chore: remove REVIEW.md 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 * chore: simplify changelog entry 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --------- Co-authored-by: Claude Opus 4.5 --- v3/UNRELEASED_CHANGELOG.md | 1 + .../application/application_options_test.go | 301 ++++++++++++ v3/pkg/application/context_test.go | 120 +++++ v3/pkg/application/dialogs_test.go | 223 +++++++++ v3/pkg/application/keys_test.go | 293 ++++++++++++ v3/pkg/application/menu_internal_test.go | 403 ++++++++++++++++ v3/pkg/application/menuitem_internal_test.go | 413 +++++++++++++++++ v3/pkg/application/parameter_test.go | 118 +++++ .../screenmanager_internal_test.go | 435 ++++++++++++++++++ v3/pkg/application/services_test.go | 203 ++++++++ v3/pkg/application/single_instance_test.go | 229 +++++++++ .../webview_window_options_test.go | 388 ++++++++++++++++ 12 files changed, 3127 insertions(+) create mode 100644 v3/pkg/application/application_options_test.go create mode 100644 v3/pkg/application/context_test.go create mode 100644 v3/pkg/application/dialogs_test.go create mode 100644 v3/pkg/application/keys_test.go create mode 100644 v3/pkg/application/menu_internal_test.go create mode 100644 v3/pkg/application/menuitem_internal_test.go create mode 100644 v3/pkg/application/parameter_test.go create mode 100644 v3/pkg/application/screenmanager_internal_test.go create mode 100644 v3/pkg/application/services_test.go create mode 100644 v3/pkg/application/single_instance_test.go create mode 100644 v3/pkg/application/webview_window_options_test.go diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index f9ed39c39..3aad74272 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -17,6 +17,7 @@ After processing, the content will be moved to the main changelog and this file ## Added +- Add unit tests for pkg/application by @leaanthony - Add custom protocol support to MSIX packaging by @leaanthony ## Changed diff --git a/v3/pkg/application/application_options_test.go b/v3/pkg/application/application_options_test.go new file mode 100644 index 000000000..77ddbe522 --- /dev/null +++ b/v3/pkg/application/application_options_test.go @@ -0,0 +1,301 @@ +package application + +import ( + "net/http" + "net/http/httptest" + "testing" +) + +func TestActivationPolicy_Constants(t *testing.T) { + if ActivationPolicyRegular != 0 { + t.Error("ActivationPolicyRegular should be 0") + } + if ActivationPolicyAccessory != 1 { + t.Error("ActivationPolicyAccessory should be 1") + } + if ActivationPolicyProhibited != 2 { + t.Error("ActivationPolicyProhibited should be 2") + } +} + +func TestNativeTabIcon_Constants(t *testing.T) { + tests := []struct { + name string + icon NativeTabIcon + expected string + }{ + {"NativeTabIconNone", NativeTabIconNone, ""}, + {"NativeTabIconHouse", NativeTabIconHouse, "house"}, + {"NativeTabIconGear", NativeTabIconGear, "gear"}, + {"NativeTabIconStar", NativeTabIconStar, "star"}, + {"NativeTabIconPerson", NativeTabIconPerson, "person"}, + {"NativeTabIconBell", NativeTabIconBell, "bell"}, + {"NativeTabIconMagnify", NativeTabIconMagnify, "magnifyingglass"}, + {"NativeTabIconList", NativeTabIconList, "list.bullet"}, + {"NativeTabIconFolder", NativeTabIconFolder, "folder"}, + } + + for _, tt := range tests { + if string(tt.icon) != tt.expected { + t.Errorf("%s = %q, want %q", tt.name, string(tt.icon), tt.expected) + } + } +} + +func TestChainMiddleware_Empty(t *testing.T) { + baseHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + w.Write([]byte("base")) + }) + + chained := ChainMiddleware() + handler := chained(baseHandler) + + req := httptest.NewRequest("GET", "/", nil) + rec := httptest.NewRecorder() + + handler.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Errorf("Status = %d, want %d", rec.Code, http.StatusOK) + } + if rec.Body.String() != "base" { + t.Errorf("Body = %q, want %q", rec.Body.String(), "base") + } +} + +func TestChainMiddleware_Single(t *testing.T) { + callOrder := []string{} + + middleware := func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + callOrder = append(callOrder, "middleware") + next.ServeHTTP(w, r) + }) + } + + baseHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + callOrder = append(callOrder, "base") + w.WriteHeader(http.StatusOK) + }) + + chained := ChainMiddleware(middleware) + handler := chained(baseHandler) + + req := httptest.NewRequest("GET", "/", nil) + rec := httptest.NewRecorder() + + handler.ServeHTTP(rec, req) + + if len(callOrder) != 2 { + t.Errorf("Expected 2 calls, got %d", len(callOrder)) + } + if callOrder[0] != "middleware" { + t.Errorf("First call should be middleware, got %s", callOrder[0]) + } + if callOrder[1] != "base" { + t.Errorf("Second call should be base, got %s", callOrder[1]) + } +} + +func TestChainMiddleware_Multiple(t *testing.T) { + callOrder := []string{} + + middleware1 := func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + callOrder = append(callOrder, "middleware1") + next.ServeHTTP(w, r) + }) + } + + middleware2 := func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + callOrder = append(callOrder, "middleware2") + next.ServeHTTP(w, r) + }) + } + + middleware3 := func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + callOrder = append(callOrder, "middleware3") + next.ServeHTTP(w, r) + }) + } + + baseHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + callOrder = append(callOrder, "base") + w.WriteHeader(http.StatusOK) + }) + + chained := ChainMiddleware(middleware1, middleware2, middleware3) + handler := chained(baseHandler) + + req := httptest.NewRequest("GET", "/", nil) + rec := httptest.NewRecorder() + + handler.ServeHTTP(rec, req) + + expected := []string{"middleware1", "middleware2", "middleware3", "base"} + if len(callOrder) != len(expected) { + t.Errorf("Expected %d calls, got %d", len(expected), len(callOrder)) + } + for i, v := range expected { + if i < len(callOrder) && callOrder[i] != v { + t.Errorf("Call %d: expected %s, got %s", i, v, callOrder[i]) + } + } +} + +func TestOptions_Defaults(t *testing.T) { + opts := Options{} + + if opts.Name != "" { + t.Error("Name should default to empty string") + } + if opts.Description != "" { + t.Error("Description should default to empty string") + } + if opts.Icon != nil { + t.Error("Icon should default to nil") + } + if opts.Logger != nil { + t.Error("Logger should default to nil") + } + if opts.DisableDefaultSignalHandler != false { + t.Error("DisableDefaultSignalHandler should default to false") + } +} + +func TestMacOptions_Defaults(t *testing.T) { + opts := MacOptions{} + + if opts.ActivationPolicy != ActivationPolicyRegular { + t.Error("ActivationPolicy should default to ActivationPolicyRegular") + } + if opts.ApplicationShouldTerminateAfterLastWindowClosed != false { + t.Error("ApplicationShouldTerminateAfterLastWindowClosed should default to false") + } +} + +func TestWindowsOptions_Defaults(t *testing.T) { + opts := WindowsOptions{} + + if opts.WndClass != "" { + t.Error("WndClass should default to empty string") + } + if opts.DisableQuitOnLastWindowClosed != false { + t.Error("DisableQuitOnLastWindowClosed should default to false") + } + if opts.WebviewUserDataPath != "" { + t.Error("WebviewUserDataPath should default to empty string") + } + if opts.WebviewBrowserPath != "" { + t.Error("WebviewBrowserPath should default to empty string") + } +} + +func TestLinuxOptions_Defaults(t *testing.T) { + opts := LinuxOptions{} + + if opts.DisableQuitOnLastWindowClosed != false { + t.Error("DisableQuitOnLastWindowClosed should default to false") + } + if opts.ProgramName != "" { + t.Error("ProgramName should default to empty string") + } +} + +func TestIOSOptions_Defaults(t *testing.T) { + opts := IOSOptions{} + + if opts.DisableInputAccessoryView != false { + t.Error("DisableInputAccessoryView should default to false") + } + if opts.DisableScroll != false { + t.Error("DisableScroll should default to false") + } + if opts.DisableBounce != false { + t.Error("DisableBounce should default to false") + } + if opts.EnableBackForwardNavigationGestures != false { + t.Error("EnableBackForwardNavigationGestures should default to false") + } + if opts.EnableNativeTabs != false { + t.Error("EnableNativeTabs should default to false") + } +} + +func TestAndroidOptions_Defaults(t *testing.T) { + opts := AndroidOptions{} + + if opts.DisableScroll != false { + t.Error("DisableScroll should default to false") + } + if opts.DisableOverscroll != false { + t.Error("DisableOverscroll should default to false") + } + if opts.EnableZoom != false { + t.Error("EnableZoom should default to false") + } + if opts.DisableHardwareAcceleration != false { + t.Error("DisableHardwareAcceleration should default to false") + } +} + +func TestAssetOptions_Defaults(t *testing.T) { + opts := AssetOptions{} + + if opts.Handler != nil { + t.Error("Handler should default to nil") + } + if opts.Middleware != nil { + t.Error("Middleware should default to nil") + } + if opts.DisableLogging != false { + t.Error("DisableLogging should default to false") + } +} + +func TestNativeTabItem_Fields(t *testing.T) { + item := NativeTabItem{ + Title: "Home", + SystemImage: NativeTabIconHouse, + } + + if item.Title != "Home" { + t.Errorf("Title = %q, want %q", item.Title, "Home") + } + if item.SystemImage != NativeTabIconHouse { + t.Errorf("SystemImage = %q, want %q", item.SystemImage, NativeTabIconHouse) + } +} + +func TestMiddleware_ShortCircuit(t *testing.T) { + shortCircuit := func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusForbidden) + w.Write([]byte("forbidden")) + // Don't call next + }) + } + + baseHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + w.Write([]byte("base")) + }) + + chained := ChainMiddleware(shortCircuit) + handler := chained(baseHandler) + + req := httptest.NewRequest("GET", "/", nil) + rec := httptest.NewRecorder() + + handler.ServeHTTP(rec, req) + + if rec.Code != http.StatusForbidden { + t.Errorf("Status = %d, want %d", rec.Code, http.StatusForbidden) + } + if rec.Body.String() != "forbidden" { + t.Errorf("Body = %q, want %q", rec.Body.String(), "forbidden") + } +} diff --git a/v3/pkg/application/context_test.go b/v3/pkg/application/context_test.go new file mode 100644 index 000000000..268ca5af9 --- /dev/null +++ b/v3/pkg/application/context_test.go @@ -0,0 +1,120 @@ +package application + +import ( + "testing" +) + +func TestNewContext(t *testing.T) { + ctx := newContext() + if ctx == nil { + t.Fatal("newContext() returned nil") + } + if ctx.data == nil { + t.Error("newContext() should initialize data map") + } +} + +func TestContext_ClickedMenuItem_NotExists(t *testing.T) { + ctx := newContext() + result := ctx.ClickedMenuItem() + if result != nil { + t.Error("ClickedMenuItem() should return nil when not set") + } +} + +func TestContext_ClickedMenuItem_Exists(t *testing.T) { + ctx := newContext() + menuItem := &MenuItem{label: "Test"} + ctx.withClickedMenuItem(menuItem) + + result := ctx.ClickedMenuItem() + if result == nil { + t.Fatal("ClickedMenuItem() should return the menu item") + } + if result != menuItem { + t.Error("ClickedMenuItem() should return the same menu item") + } +} + +func TestContext_IsChecked_NotSet(t *testing.T) { + ctx := newContext() + if ctx.IsChecked() { + t.Error("IsChecked() should return false when not set") + } +} + +func TestContext_IsChecked_True(t *testing.T) { + ctx := newContext() + ctx.withChecked(true) + if !ctx.IsChecked() { + t.Error("IsChecked() should return true when set to true") + } +} + +func TestContext_IsChecked_False(t *testing.T) { + ctx := newContext() + ctx.withChecked(false) + if ctx.IsChecked() { + t.Error("IsChecked() should return false when set to false") + } +} + +func TestContext_ContextMenuData_Empty(t *testing.T) { + ctx := newContext() + result := ctx.ContextMenuData() + if result != "" { + t.Errorf("ContextMenuData() should return empty string when not set, got %q", result) + } +} + +func TestContext_ContextMenuData_Exists(t *testing.T) { + ctx := newContext() + data := &ContextMenuData{Data: "test-data"} + ctx.withContextMenuData(data) + + result := ctx.ContextMenuData() + if result != "test-data" { + t.Errorf("ContextMenuData() = %q, want %q", result, "test-data") + } +} + +func TestContext_ContextMenuData_NilData(t *testing.T) { + ctx := newContext() + ctx.withContextMenuData(nil) + + result := ctx.ContextMenuData() + if result != "" { + t.Errorf("ContextMenuData() should return empty string for nil data, got %q", result) + } +} + +func TestContext_ContextMenuData_WrongType(t *testing.T) { + ctx := newContext() + // Manually set wrong type to test type assertion + ctx.data[contextMenuData] = 123 + + result := ctx.ContextMenuData() + if result != "" { + t.Errorf("ContextMenuData() should return empty string for non-string type, got %q", result) + } +} + +func TestContext_WithClickedMenuItem_Chaining(t *testing.T) { + ctx := newContext() + menuItem := &MenuItem{label: "Test"} + + returnedCtx := ctx.withClickedMenuItem(menuItem) + if returnedCtx != ctx { + t.Error("withClickedMenuItem should return the same context for chaining") + } +} + +func TestContext_WithContextMenuData_Chaining(t *testing.T) { + ctx := newContext() + data := &ContextMenuData{Data: "test"} + + returnedCtx := ctx.withContextMenuData(data) + if returnedCtx != ctx { + t.Error("withContextMenuData should return the same context for chaining") + } +} diff --git a/v3/pkg/application/dialogs_test.go b/v3/pkg/application/dialogs_test.go new file mode 100644 index 000000000..60a923cb2 --- /dev/null +++ b/v3/pkg/application/dialogs_test.go @@ -0,0 +1,223 @@ +package application + +import ( + "testing" +) + +func TestGetDialogID(t *testing.T) { + // Get first dialog ID + id1 := getDialogID() + + // Get second dialog ID - should be different + id2 := getDialogID() + if id1 == id2 { + t.Error("getDialogID should return unique IDs") + } + + // Free first ID + freeDialogID(id1) + + // Get another ID - should recycle the freed id1 or be unique from id2 + id3 := getDialogID() + if id3 == id2 { + t.Error("getDialogID should not return the same ID as an active dialog") + } + // Verify recycling behavior: id3 should either be id1 (recycled) or a new unique ID + if id3 != id1 && id3 <= id2 { + t.Errorf("getDialogID returned unexpected ID: got %d, expected recycled %d or new > %d", id3, id1, id2) + } + + // Cleanup + freeDialogID(id2) + freeDialogID(id3) +} + +func TestFreeDialogID(t *testing.T) { + id := getDialogID() + freeDialogID(id) + + // Should be able to get the same ID again after freeing + newID := getDialogID() + freeDialogID(newID) + // Just verify it doesn't panic +} + +func TestButton_OnClick(t *testing.T) { + button := &Button{Label: "Test"} + called := false + + result := button.OnClick(func() { + called = true + }) + + // Should return the same button for chaining + if result != button { + t.Error("OnClick should return the same button") + } + + // Callback should be set + if button.Callback == nil { + t.Error("Callback should be set") + } + + // Call the callback + button.Callback() + if !called { + t.Error("Callback should have been called") + } +} + +func TestButton_SetAsDefault(t *testing.T) { + button := &Button{Label: "Test"} + + result := button.SetAsDefault() + + // Should return the same button for chaining + if result != button { + t.Error("SetAsDefault should return the same button") + } + + if !button.IsDefault { + t.Error("IsDefault should be true") + } +} + +func TestButton_SetAsCancel(t *testing.T) { + button := &Button{Label: "Test"} + + result := button.SetAsCancel() + + // Should return the same button for chaining + if result != button { + t.Error("SetAsCancel should return the same button") + } + + if !button.IsCancel { + t.Error("IsCancel should be true") + } +} + +func TestButton_Chaining(t *testing.T) { + button := &Button{Label: "OK"} + + button.SetAsDefault().SetAsCancel().OnClick(func() {}) + + if !button.IsDefault { + t.Error("IsDefault should be true after chaining") + } + if !button.IsCancel { + t.Error("IsCancel should be true after chaining") + } + if button.Callback == nil { + t.Error("Callback should be set after chaining") + } +} + +func TestDialogType_Constants(t *testing.T) { + // Verify dialog type constants are distinct + types := []DialogType{InfoDialogType, QuestionDialogType, WarningDialogType, ErrorDialogType} + seen := make(map[DialogType]bool) + + for _, dt := range types { + if seen[dt] { + t.Errorf("DialogType %d is duplicated", dt) + } + seen[dt] = true + } +} + +func TestMessageDialogOptions_Fields(t *testing.T) { + opts := MessageDialogOptions{ + DialogType: InfoDialogType, + Title: "Test Title", + Message: "Test Message", + Buttons: []*Button{{Label: "OK"}}, + Icon: []byte{1, 2, 3}, + } + + if opts.DialogType != InfoDialogType { + t.Error("DialogType not set correctly") + } + if opts.Title != "Test Title" { + t.Error("Title not set correctly") + } + if opts.Message != "Test Message" { + t.Error("Message not set correctly") + } + if len(opts.Buttons) != 1 { + t.Error("Buttons not set correctly") + } + if len(opts.Icon) != 3 { + t.Error("Icon not set correctly") + } +} + +func TestFileFilter_Fields(t *testing.T) { + filter := FileFilter{ + DisplayName: "Image Files (*.jpg, *.png)", + Pattern: "*.jpg;*.png", + } + + if filter.DisplayName != "Image Files (*.jpg, *.png)" { + t.Error("DisplayName not set correctly") + } + if filter.Pattern != "*.jpg;*.png" { + t.Error("Pattern not set correctly") + } +} + +func TestOpenFileDialogOptions_Fields(t *testing.T) { + opts := OpenFileDialogOptions{ + CanChooseDirectories: true, + CanChooseFiles: true, + CanCreateDirectories: true, + ShowHiddenFiles: true, + ResolvesAliases: true, + AllowsMultipleSelection: true, + Title: "Open", + Message: "Select a file", + ButtonText: "Choose", + Directory: "/home", + Filters: []FileFilter{ + {DisplayName: "All Files", Pattern: "*"}, + }, + } + + if !opts.CanChooseDirectories { + t.Error("CanChooseDirectories not set correctly") + } + if !opts.CanChooseFiles { + t.Error("CanChooseFiles not set correctly") + } + if opts.Title != "Open" { + t.Error("Title not set correctly") + } + if len(opts.Filters) != 1 { + t.Error("Filters not set correctly") + } +} + +func TestSaveFileDialogOptions_Fields(t *testing.T) { + opts := SaveFileDialogOptions{ + CanCreateDirectories: true, + ShowHiddenFiles: true, + Title: "Save", + Message: "Save as", + Directory: "/home", + Filename: "file.txt", + ButtonText: "Save", + Filters: []FileFilter{ + {DisplayName: "Text Files", Pattern: "*.txt"}, + }, + } + + if !opts.CanCreateDirectories { + t.Error("CanCreateDirectories not set correctly") + } + if opts.Title != "Save" { + t.Error("Title not set correctly") + } + if opts.Filename != "file.txt" { + t.Error("Filename not set correctly") + } +} diff --git a/v3/pkg/application/keys_test.go b/v3/pkg/application/keys_test.go new file mode 100644 index 000000000..3651395ed --- /dev/null +++ b/v3/pkg/application/keys_test.go @@ -0,0 +1,293 @@ +package application + +import ( + "runtime" + "strings" + "testing" +) + +func TestModifier_Constants(t *testing.T) { + // Verify modifier constants are distinct + modifiers := []modifier{CmdOrCtrlKey, OptionOrAltKey, ShiftKey, SuperKey, ControlKey} + seen := make(map[modifier]bool) + for _, m := range modifiers { + if seen[m] { + t.Errorf("Duplicate modifier value: %d", m) + } + seen[m] = true + } + + // CmdOrCtrlKey should be 0 (the base value) + if CmdOrCtrlKey != 0 { + t.Error("CmdOrCtrlKey should be 0") + } +} + +func TestParseKey_Valid(t *testing.T) { + tests := []struct { + input string + expected string + }{ + {"a", "a"}, + {"A", "a"}, + {"z", "z"}, + {"0", "0"}, + {"9", "9"}, + {"+", "+"}, // Single + is a valid printable character + {"plus", "+"}, + {"Plus", "+"}, + {"PLUS", "+"}, + {"backspace", "backspace"}, + {"Backspace", "backspace"}, + {"BACKSPACE", "backspace"}, + {"tab", "tab"}, + {"return", "return"}, + {"enter", "enter"}, + {"escape", "escape"}, + {"left", "left"}, + {"right", "right"}, + {"up", "up"}, + {"down", "down"}, + {"space", "space"}, + {"delete", "delete"}, + {"home", "home"}, + {"end", "end"}, + {"page up", "page up"}, + {"page down", "page down"}, + {"f1", "f1"}, + {"F1", "f1"}, + {"f12", "f12"}, + {"f35", "f35"}, + {"numlock", "numlock"}, + } + + for _, tt := range tests { + result, valid := parseKey(tt.input) + if tt.expected == "" { + if valid { + t.Errorf("parseKey(%q) should be invalid", tt.input) + } + } else { + if !valid { + t.Errorf("parseKey(%q) should be valid", tt.input) + } + if result != tt.expected { + t.Errorf("parseKey(%q) = %q, want %q", tt.input, result, tt.expected) + } + } + } +} + +func TestParseKey_Invalid(t *testing.T) { + tests := []string{ + "abc", // multiple chars + "", // empty + "notakey", // not a named key + "ctrl+a", // shortcut syntax + "backspac", // misspelled + } + + for _, tt := range tests { + _, valid := parseKey(tt) + if valid { + t.Errorf("parseKey(%q) should be invalid", tt) + } + } +} + +func TestParseAccelerator_Valid(t *testing.T) { + tests := []struct { + input string + key string + modCount int + }{ + {"a", "a", 0}, + {"Ctrl+A", "a", 1}, + {"ctrl+a", "a", 1}, + {"Ctrl+Shift+A", "a", 2}, + {"ctrl+shift+a", "a", 2}, + {"Cmd+A", "a", 1}, + {"Command+A", "a", 1}, + {"CmdOrCtrl+A", "a", 1}, + {"Alt+A", "a", 1}, + {"Option+A", "a", 1}, + {"OptionOrAlt+A", "a", 1}, + {"Shift+A", "a", 1}, + {"Super+A", "a", 1}, + {"Ctrl+Shift+Alt+A", "a", 3}, + {"Ctrl+plus", "+", 1}, + {"F1", "f1", 0}, + {"Ctrl+F12", "f12", 1}, + {"Ctrl+Shift+F1", "f1", 2}, + {"Ctrl+backspace", "backspace", 1}, + {"Ctrl+escape", "escape", 1}, + } + + for _, tt := range tests { + acc, err := parseAccelerator(tt.input) + if err != nil { + t.Errorf("parseAccelerator(%q) returned error: %v", tt.input, err) + continue + } + if acc.Key != tt.key { + t.Errorf("parseAccelerator(%q).Key = %q, want %q", tt.input, acc.Key, tt.key) + } + if len(acc.Modifiers) != tt.modCount { + t.Errorf("parseAccelerator(%q) has %d modifiers, want %d", tt.input, len(acc.Modifiers), tt.modCount) + } + } +} + +func TestParseAccelerator_Invalid(t *testing.T) { + tests := []struct { + input string + errMsg string + }{ + {"", "no components"}, + {"Ctrl+", "not a valid key"}, + {"Ctrl+abc", "not a valid key"}, + {"NotAModifier+A", "not a valid modifier"}, + {"Ctrl+Shift+notakey", "not a valid key"}, + } + + for _, tt := range tests { + _, err := parseAccelerator(tt.input) + if err == nil { + t.Errorf("parseAccelerator(%q) should return error", tt.input) + } + } +} + +func TestParseAccelerator_DuplicateModifiers(t *testing.T) { + // Duplicate modifiers should be deduplicated + acc, err := parseAccelerator("Ctrl+Ctrl+A") + if err != nil { + t.Errorf("parseAccelerator returned error: %v", err) + return + } + if len(acc.Modifiers) != 1 { + t.Errorf("Duplicate modifiers should be deduplicated, got %d modifiers", len(acc.Modifiers)) + } +} + +func TestAccelerator_Clone(t *testing.T) { + original := &accelerator{ + Key: "a", + Modifiers: []modifier{ControlKey, ShiftKey}, + } + + clone := original.clone() + + if clone == original { + t.Error("Clone should return a different pointer") + } + if clone.Key != original.Key { + t.Error("Clone should have same Key") + } + // Note: the slice reference is copied, so modifying the clone's slice would affect original + // This is a shallow clone +} + +func TestAccelerator_String(t *testing.T) { + // Test key-only accelerator (platform-independent) + acc := &accelerator{Key: "a", Modifiers: []modifier{}} + result := acc.String() + if result != "A" { + t.Errorf("accelerator.String() = %q, want %q", result, "A") + } + + // Test with ControlKey modifier - output varies by platform + acc = &accelerator{Key: "a", Modifiers: []modifier{ControlKey}} + result = acc.String() + // On macOS: "Ctrl+A", on Linux/Windows: "Ctrl+A" + // The representation should contain the key and be non-empty + if !strings.HasSuffix(result, "+A") && result != "A" { + t.Errorf("accelerator.String() = %q, expected to end with '+A'", result) + } + if result == "" { + t.Error("accelerator.String() should not return empty") + } + + // Test function key with modifier + acc = &accelerator{Key: "f1", Modifiers: []modifier{ControlKey}} + result = acc.String() + if !strings.HasSuffix(result, "+F1") { + t.Errorf("accelerator.String() = %q, expected to end with '+F1'", result) + } +} + +func TestAccelerator_String_PlatformSpecific(t *testing.T) { + // This test documents the expected platform-specific behavior + acc := &accelerator{Key: "a", Modifiers: []modifier{ControlKey}} + result := acc.String() + + switch runtime.GOOS { + case "darwin": + // On macOS, Ctrl key is represented as "Ctrl" (distinct from Cmd) + if !strings.Contains(result, "Ctrl") && !strings.Contains(result, "⌃") { + t.Logf("On macOS, got %q for ControlKey modifier", result) + } + case "linux", "windows": + if !strings.Contains(result, "Ctrl") { + t.Errorf("On %s, expected 'Ctrl' in result, got %q", runtime.GOOS, result) + } + } +} + +func TestAccelerator_StringWithMultipleModifiers(t *testing.T) { + acc := &accelerator{ + Key: "a", + Modifiers: []modifier{ShiftKey, ControlKey}, + } + + result := acc.String() + + // Result should contain both modifiers and the key + if result == "" { + t.Error("String() should not return empty") + } + // The modifiers are sorted, so order is deterministic +} + +func TestModifierMap_Contains(t *testing.T) { + expectedMappings := map[string]modifier{ + "cmdorctrl": CmdOrCtrlKey, + "cmd": CmdOrCtrlKey, + "command": CmdOrCtrlKey, + "ctrl": ControlKey, + "optionoralt": OptionOrAltKey, + "alt": OptionOrAltKey, + "option": OptionOrAltKey, + "shift": ShiftKey, + "super": SuperKey, + } + + for key, expected := range expectedMappings { + actual, ok := modifierMap[key] + if !ok { + t.Errorf("modifierMap should contain key %q", key) + } + if actual != expected { + t.Errorf("modifierMap[%q] = %v, want %v", key, actual, expected) + } + } +} + +func TestNamedKeys_Contains(t *testing.T) { + expectedKeys := []string{ + "backspace", "tab", "return", "enter", "escape", + "left", "right", "up", "down", "space", "delete", + "home", "end", "page up", "page down", + "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", + "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", + "f21", "f22", "f23", "f24", "f25", "f26", "f27", "f28", "f29", "f30", + "f31", "f32", "f33", "f34", "f35", + "numlock", + } + + for _, key := range expectedKeys { + if _, ok := namedKeys[key]; !ok { + t.Errorf("namedKeys should contain %q", key) + } + } +} diff --git a/v3/pkg/application/menu_internal_test.go b/v3/pkg/application/menu_internal_test.go new file mode 100644 index 000000000..488e9a520 --- /dev/null +++ b/v3/pkg/application/menu_internal_test.go @@ -0,0 +1,403 @@ +package application + +import ( + "testing" +) + +func TestNewMenu(t *testing.T) { + menu := NewMenu() + if menu == nil { + t.Fatal("NewMenu returned nil") + } + if menu.items != nil { + t.Error("items should be nil initially") + } +} + +func TestMenu_Add(t *testing.T) { + menu := NewMenu() + + item := menu.Add("Test Item") + if item == nil { + t.Fatal("Add returned nil") + } + if item.label != "Test Item" { + t.Errorf("label = %q, want %q", item.label, "Test Item") + } + if len(menu.items) != 1 { + t.Errorf("items count = %d, want 1", len(menu.items)) + } + + // Clean up + menu.Destroy() +} + +func TestMenu_AddSeparator(t *testing.T) { + menu := NewMenu() + + menu.AddSeparator() + if len(menu.items) != 1 { + t.Errorf("items count = %d, want 1", len(menu.items)) + } + if menu.items[0].itemType != separator { + t.Error("item should be a separator") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_AddCheckbox(t *testing.T) { + menu := NewMenu() + + item := menu.AddCheckbox("Check Me", true) + if item == nil { + t.Fatal("AddCheckbox returned nil") + } + if item.label != "Check Me" { + t.Errorf("label = %q, want %q", item.label, "Check Me") + } + if item.itemType != checkbox { + t.Error("item should be a checkbox") + } + if !item.checked { + t.Error("checkbox should be checked") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_AddRadio(t *testing.T) { + menu := NewMenu() + + item := menu.AddRadio("Radio Option", false) + if item == nil { + t.Fatal("AddRadio returned nil") + } + if item.label != "Radio Option" { + t.Errorf("label = %q, want %q", item.label, "Radio Option") + } + if item.itemType != radio { + t.Error("item should be a radio") + } + if item.checked { + t.Error("radio should not be checked") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_AddSubmenu(t *testing.T) { + menu := NewMenu() + + subMenu := menu.AddSubmenu("Submenu") + if subMenu == nil { + t.Fatal("AddSubmenu returned nil") + } + if len(menu.items) != 1 { + t.Errorf("items count = %d, want 1", len(menu.items)) + } + if menu.items[0].itemType != submenu { + t.Error("item should be a submenu") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_SetLabel(t *testing.T) { + menu := NewMenu() + + menu.SetLabel("My Menu") + if menu.label != "My Menu" { + t.Errorf("label = %q, want %q", menu.label, "My Menu") + } +} + +func TestMenu_ItemAt(t *testing.T) { + menu := NewMenu() + menu.Add("Item 0") + menu.Add("Item 1") + menu.Add("Item 2") + + item := menu.ItemAt(1) + if item == nil { + t.Fatal("ItemAt returned nil") + } + if item.label != "Item 1" { + t.Errorf("label = %q, want %q", item.label, "Item 1") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_ItemAt_OutOfBounds(t *testing.T) { + menu := NewMenu() + menu.Add("Item") + + if menu.ItemAt(-1) != nil { + t.Error("ItemAt(-1) should return nil") + } + if menu.ItemAt(1) != nil { + t.Error("ItemAt(1) should return nil for single item menu") + } + if menu.ItemAt(100) != nil { + t.Error("ItemAt(100) should return nil") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_FindByLabel(t *testing.T) { + menu := NewMenu() + menu.Add("First") + menu.Add("Second") + menu.Add("Third") + + found := menu.FindByLabel("Second") + if found == nil { + t.Fatal("FindByLabel returned nil") + } + if found.label != "Second" { + t.Errorf("label = %q, want %q", found.label, "Second") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_FindByLabel_NotFound(t *testing.T) { + menu := NewMenu() + menu.Add("First") + + found := menu.FindByLabel("NonExistent") + if found != nil { + t.Error("FindByLabel should return nil for non-existent label") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_FindByLabel_InSubmenu(t *testing.T) { + menu := NewMenu() + submenu := menu.AddSubmenu("Submenu") + submenu.Add("Nested Item") + + found := menu.FindByLabel("Nested Item") + if found == nil { + t.Fatal("FindByLabel should find item in submenu") + } + if found.label != "Nested Item" { + t.Errorf("label = %q, want %q", found.label, "Nested Item") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_RemoveMenuItem(t *testing.T) { + menu := NewMenu() + item1 := menu.Add("First") + item2 := menu.Add("Second") + menu.Add("Third") + + menu.RemoveMenuItem(item2) + if len(menu.items) != 2 { + t.Errorf("items count = %d, want 2", len(menu.items)) + } + if menu.FindByLabel("Second") != nil { + t.Error("Second item should be removed") + } + + // Clean up + removeMenuItemByID(item1.id) +} + +func TestMenu_Clear(t *testing.T) { + menu := NewMenu() + menu.Add("First") + menu.Add("Second") + menu.Add("Third") + + menu.Clear() + if menu.items != nil { + t.Error("items should be nil after Clear") + } +} + +func TestMenu_Append(t *testing.T) { + menu1 := NewMenu() + menu1.Add("Item 1") + + menu2 := NewMenu() + menu2.Add("Item 2") + menu2.Add("Item 3") + + menu1.Append(menu2) + if len(menu1.items) != 3 { + t.Errorf("items count = %d, want 3", len(menu1.items)) + } + + // Clean up + menu1.Destroy() +} + +func TestMenu_Append_Nil(t *testing.T) { + menu := NewMenu() + menu.Add("Item") + + menu.Append(nil) + if len(menu.items) != 1 { + t.Error("Append(nil) should not change menu") + } + + // Clean up + menu.Destroy() +} + +func TestMenu_Prepend(t *testing.T) { + menu1 := NewMenu() + menu1.Add("Item 3") + + menu2 := NewMenu() + menu2.Add("Item 1") + menu2.Add("Item 2") + + menu1.Prepend(menu2) + if len(menu1.items) != 3 { + t.Errorf("items count = %d, want 3", len(menu1.items)) + } + if menu1.items[0].label != "Item 1" { + t.Errorf("First item should be 'Item 1', got %q", menu1.items[0].label) + } + + // Clean up + menu1.Destroy() +} + +func TestMenu_Clone(t *testing.T) { + menu := NewMenu() + menu.SetLabel("Original Menu") + menu.Add("Item 1") + menu.Add("Item 2") + + clone := menu.Clone() + if clone == menu { + t.Error("Clone should return different pointer") + } + if clone.label != menu.label { + t.Error("Clone should have same label") + } + if len(clone.items) != len(menu.items) { + t.Error("Clone should have same number of items") + } + + // Clean up + menu.Destroy() + clone.Destroy() +} + +func TestNewMenuFromItems(t *testing.T) { + item1 := NewMenuItem("Item 1") + item2 := NewMenuItem("Item 2") + item3 := NewMenuItem("Item 3") + + menu := NewMenuFromItems(item1, item2, item3) + if menu == nil { + t.Fatal("NewMenuFromItems returned nil") + } + if len(menu.items) != 3 { + t.Errorf("items count = %d, want 3", len(menu.items)) + } + + // Clean up + menu.Destroy() +} + +func TestNewSubmenu(t *testing.T) { + items := NewMenu() + items.Add("Sub Item 1") + items.Add("Sub Item 2") + + item := NewSubmenu("My Submenu", items) + if item == nil { + t.Fatal("NewSubmenu returned nil") + } + if item.label != "My Submenu" { + t.Errorf("label = %q, want %q", item.label, "My Submenu") + } + if item.submenu != items { + t.Error("submenu should be the provided menu") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenu_ProcessRadioGroups(t *testing.T) { + menu := NewMenu() + + // Add some non-radio items + menu.Add("Regular Item") + + // Add a group of radio items + radio1 := menu.AddRadio("Radio 1", true) + radio2 := menu.AddRadio("Radio 2", false) + radio3 := menu.AddRadio("Radio 3", false) + + // Add separator to end the group + menu.AddSeparator() + + // Add another group + radio4 := menu.AddRadio("Radio A", true) + radio5 := menu.AddRadio("Radio B", false) + + // Process radio groups + menu.processRadioGroups() + + // First group should be linked + if len(radio1.radioGroupMembers) != 3 { + t.Errorf("First group should have 3 members, got %d", len(radio1.radioGroupMembers)) + } + if len(radio2.radioGroupMembers) != 3 { + t.Errorf("radio2 should have 3 members, got %d", len(radio2.radioGroupMembers)) + } + if len(radio3.radioGroupMembers) != 3 { + t.Errorf("radio3 should have 3 members, got %d", len(radio3.radioGroupMembers)) + } + + // Second group should be linked + if len(radio4.radioGroupMembers) != 2 { + t.Errorf("Second group should have 2 members, got %d", len(radio4.radioGroupMembers)) + } + if len(radio5.radioGroupMembers) != 2 { + t.Errorf("radio5 should have 2 members, got %d", len(radio5.radioGroupMembers)) + } + + // Clean up + menu.Destroy() +} + +func TestMenu_SetContextData(t *testing.T) { + menu := NewMenu() + menu.Add("Item 1") + menu.Add("Item 2") + + data := &ContextMenuData{Data: "test-data"} + menu.setContextData(data) + + // Verify data was set on items + for _, item := range menu.items { + if item.contextMenuData != data { + t.Error("Context data should be set on all items") + } + } + + // Clean up + menu.Destroy() +} diff --git a/v3/pkg/application/menuitem_internal_test.go b/v3/pkg/application/menuitem_internal_test.go new file mode 100644 index 000000000..12843d4c8 --- /dev/null +++ b/v3/pkg/application/menuitem_internal_test.go @@ -0,0 +1,413 @@ +package application + +import ( + "testing" +) + +func TestMenuItemType_Constants(t *testing.T) { + // Verify menu item type constants are distinct + if text != 0 { + t.Error("text should be 0") + } + if separator != 1 { + t.Error("separator should be 1") + } + if checkbox != 2 { + t.Error("checkbox should be 2") + } + if radio != 3 { + t.Error("radio should be 3") + } + if submenu != 4 { + t.Error("submenu should be 4") + } +} + +func TestNewMenuItem(t *testing.T) { + item := NewMenuItem("Test Label") + + if item == nil { + t.Fatal("NewMenuItem returned nil") + } + if item.label != "Test Label" { + t.Errorf("label = %q, want %q", item.label, "Test Label") + } + if item.itemType != text { + t.Error("itemType should be text") + } + if item.id == 0 { + t.Error("id should be non-zero") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestNewMenuItemSeparator(t *testing.T) { + item := NewMenuItemSeparator() + + if item == nil { + t.Fatal("NewMenuItemSeparator returned nil") + } + if item.itemType != separator { + t.Error("itemType should be separator") + } +} + +func TestNewMenuItemCheckbox(t *testing.T) { + item := NewMenuItemCheckbox("Checkbox", true) + + if item == nil { + t.Fatal("NewMenuItemCheckbox returned nil") + } + if item.label != "Checkbox" { + t.Errorf("label = %q, want %q", item.label, "Checkbox") + } + if item.itemType != checkbox { + t.Error("itemType should be checkbox") + } + if !item.checked { + t.Error("checked should be true") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestNewMenuItemCheckbox_Unchecked(t *testing.T) { + item := NewMenuItemCheckbox("Unchecked", false) + + if item.checked { + t.Error("checked should be false") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestNewMenuItemRadio(t *testing.T) { + item := NewMenuItemRadio("Radio", true) + + if item == nil { + t.Fatal("NewMenuItemRadio returned nil") + } + if item.label != "Radio" { + t.Errorf("label = %q, want %q", item.label, "Radio") + } + if item.itemType != radio { + t.Error("itemType should be radio") + } + if !item.checked { + t.Error("checked should be true") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestNewSubMenuItem(t *testing.T) { + item := NewSubMenuItem("Submenu") + + if item == nil { + t.Fatal("NewSubMenuItem returned nil") + } + if item.label != "Submenu" { + t.Errorf("label = %q, want %q", item.label, "Submenu") + } + if item.itemType != submenu { + t.Error("itemType should be submenu") + } + if item.submenu == nil { + t.Error("submenu should not be nil") + } + if item.submenu.label != "Submenu" { + t.Errorf("submenu.label = %q, want %q", item.submenu.label, "Submenu") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItemMap_AddGetRemove(t *testing.T) { + item := NewMenuItem("Test") + id := item.id + + // Item should be in map + retrieved := getMenuItemByID(id) + if retrieved != item { + t.Error("getMenuItemByID should return the same item") + } + + // Remove item + removeMenuItemByID(id) + + // Item should be gone + retrieved = getMenuItemByID(id) + if retrieved != nil { + t.Error("getMenuItemByID should return nil after removal") + } +} + +func TestGetMenuItemByID_NotFound(t *testing.T) { + result := getMenuItemByID(999999) + if result != nil { + t.Error("getMenuItemByID should return nil for non-existent ID") + } +} + +func TestMenuItem_UniqueIDs(t *testing.T) { + item1 := NewMenuItem("Item 1") + item2 := NewMenuItem("Item 2") + item3 := NewMenuItem("Item 3") + + if item1.id == item2.id || item2.id == item3.id || item1.id == item3.id { + t.Error("Menu items should have unique IDs") + } + + // Clean up + removeMenuItemByID(item1.id) + removeMenuItemByID(item2.id) + removeMenuItemByID(item3.id) +} + +func TestMenuItem_Label(t *testing.T) { + item := NewMenuItem("Original") + + if item.Label() != "Original" { + t.Errorf("Label() = %q, want %q", item.Label(), "Original") + } + + item.SetLabel("Updated") + if item.label != "Updated" { + t.Errorf("label = %q, want %q", item.label, "Updated") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_Enabled(t *testing.T) { + item := NewMenuItem("Test") + + if item.disabled { + t.Error("disabled should default to false") + } + + item.SetEnabled(false) + if !item.disabled { + t.Error("disabled should be true after SetEnabled(false)") + } + + item.SetEnabled(true) + if item.disabled { + t.Error("disabled should be false after SetEnabled(true)") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_Checked(t *testing.T) { + item := NewMenuItemCheckbox("Test", false) + + if item.checked { + t.Error("checked should be false") + } + + item.SetChecked(true) + if !item.checked { + t.Error("checked should be true after SetChecked(true)") + } + + item.SetChecked(false) + if item.checked { + t.Error("checked should be false after SetChecked(false)") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_Hidden(t *testing.T) { + item := NewMenuItem("Test") + + if item.hidden { + t.Error("hidden should default to false") + } + + item.SetHidden(true) + if !item.hidden { + t.Error("hidden should be true after SetHidden(true)") + } + + item.SetHidden(false) + if item.hidden { + t.Error("hidden should be false after SetHidden(false)") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_Tooltip(t *testing.T) { + item := NewMenuItem("Test") + + if item.tooltip != "" { + t.Error("tooltip should default to empty string") + } + + item.SetTooltip("Tooltip text") + if item.tooltip != "Tooltip text" { + t.Errorf("tooltip = %q, want %q", item.tooltip, "Tooltip text") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_Bitmap(t *testing.T) { + item := NewMenuItem("Test") + + if item.bitmap != nil { + t.Error("bitmap should default to nil") + } + + bitmap := []byte{0x89, 0x50, 0x4E, 0x47} + item.SetBitmap(bitmap) + if len(item.bitmap) != 4 { + t.Error("bitmap should be set") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_OnClick(t *testing.T) { + item := NewMenuItem("Test") + + if item.callback != nil { + t.Error("callback should default to nil") + } + + called := false + item.OnClick(func(ctx *Context) { + called = true + }) + + if item.callback == nil { + t.Error("callback should be set after OnClick") + } + + // Call the callback + item.callback(nil) + if !called { + t.Error("callback should have been called") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_SetAccelerator(t *testing.T) { + item := NewMenuItem("Test") + + if item.accelerator != nil { + t.Error("accelerator should default to nil") + } + + result := item.SetAccelerator("Ctrl+A") + if result != item { + t.Error("SetAccelerator should return the same item for chaining") + } + + if item.accelerator == nil { + t.Error("accelerator should be set after SetAccelerator") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_GetAccelerator(t *testing.T) { + item := NewMenuItem("Test") + + if item.GetAccelerator() != "" { + t.Error("GetAccelerator should return empty string when not set") + } + + item.SetAccelerator("Ctrl+B") + acc := item.GetAccelerator() + if acc == "" { + t.Error("GetAccelerator should return non-empty string when set") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_RemoveAccelerator(t *testing.T) { + item := NewMenuItem("Test") + item.SetAccelerator("Ctrl+C") + + item.RemoveAccelerator() + if item.accelerator != nil { + t.Error("accelerator should be nil after RemoveAccelerator") + } + + // Clean up + removeMenuItemByID(item.id) +} + +func TestMenuItem_Clone(t *testing.T) { + original := NewMenuItem("Original") + original.SetTooltip("Tooltip") + original.SetChecked(true) + original.SetEnabled(false) + + clone := original.Clone() + + if clone == original { + t.Error("Clone should return a different pointer") + } + if clone.label != original.label { + t.Error("Clone should have same label") + } + if clone.tooltip != original.tooltip { + t.Error("Clone should have same tooltip") + } + if clone.checked != original.checked { + t.Error("Clone should have same checked state") + } + if clone.disabled != original.disabled { + t.Error("Clone should have same disabled state") + } + // Note: Clone preserves the ID (shallow clone behavior) + + // Clean up + removeMenuItemByID(original.id) + removeMenuItemByID(clone.id) +} + +func TestMenuItem_Chaining(t *testing.T) { + item := NewMenuItem("Test"). + SetTooltip("Tooltip"). + SetEnabled(false). + SetHidden(true). + SetAccelerator("Ctrl+X") + + if item.tooltip != "Tooltip" { + t.Error("Chaining SetTooltip failed") + } + if !item.disabled { + t.Error("Chaining SetEnabled failed") + } + if !item.hidden { + t.Error("Chaining SetHidden failed") + } + if item.accelerator == nil { + t.Error("Chaining SetAccelerator failed") + } + + // Clean up + removeMenuItemByID(item.id) +} diff --git a/v3/pkg/application/parameter_test.go b/v3/pkg/application/parameter_test.go new file mode 100644 index 000000000..3a106e48e --- /dev/null +++ b/v3/pkg/application/parameter_test.go @@ -0,0 +1,118 @@ +package application + +import ( + "reflect" + "testing" +) + +func TestParameter_IsType(t *testing.T) { + param := &Parameter{ + Name: "test", + TypeName: "string", + } + + if !param.IsType("string") { + t.Error("IsType should return true for matching type") + } + + if param.IsType("int") { + t.Error("IsType should return false for non-matching type") + } +} + +func TestParameter_IsError(t *testing.T) { + errorParam := &Parameter{ + Name: "err", + TypeName: "error", + } + + if !errorParam.IsError() { + t.Error("IsError should return true for error type") + } + + stringParam := &Parameter{ + Name: "s", + TypeName: "string", + } + + if stringParam.IsError() { + t.Error("IsError should return false for non-error type") + } +} + +func TestNewParameter(t *testing.T) { + stringType := reflect.TypeOf("") + param := newParameter("myParam", stringType) + + if param.Name != "myParam" { + t.Errorf("Name = %q, want %q", param.Name, "myParam") + } + + if param.TypeName != "string" { + t.Errorf("TypeName = %q, want %q", param.TypeName, "string") + } + + if param.ReflectType != stringType { + t.Error("ReflectType not set correctly") + } +} + +func TestCallError_Error(t *testing.T) { + err := &CallError{ + Kind: ReferenceError, + Message: "test error", + } + + if err.Error() != "test error" { + t.Errorf("Error() = %q, want %q", err.Error(), "test error") + } +} + +func TestCallError_Kinds(t *testing.T) { + tests := []struct { + kind ErrorKind + expected string + }{ + {ReferenceError, "ReferenceError"}, + {TypeError, "TypeError"}, + {RuntimeError, "RuntimeError"}, + } + + for _, tt := range tests { + if string(tt.kind) != tt.expected { + t.Errorf("ErrorKind = %q, want %q", string(tt.kind), tt.expected) + } + } +} + +func TestCallError_WithCause(t *testing.T) { + cause := map[string]string{"detail": "some detail"} + err := &CallError{ + Kind: RuntimeError, + Message: "runtime error occurred", + Cause: cause, + } + + if err.Error() != "runtime error occurred" { + t.Error("Error() should return the message") + } + + if err.Cause == nil { + t.Error("Cause should be set") + } +} + +func TestCallOptions_Fields(t *testing.T) { + opts := CallOptions{ + MethodID: 12345, + MethodName: "TestService.Method", + } + + if opts.MethodID != 12345 { + t.Error("MethodID not set correctly") + } + + if opts.MethodName != "TestService.Method" { + t.Error("MethodName not set correctly") + } +} diff --git a/v3/pkg/application/screenmanager_internal_test.go b/v3/pkg/application/screenmanager_internal_test.go new file mode 100644 index 000000000..9445c1f6d --- /dev/null +++ b/v3/pkg/application/screenmanager_internal_test.go @@ -0,0 +1,435 @@ +package application + +import ( + "testing" +) + +func TestAlignment_Constants(t *testing.T) { + if TOP != 0 { + t.Error("TOP should be 0") + } + if RIGHT != 1 { + t.Error("RIGHT should be 1") + } + if BOTTOM != 2 { + t.Error("BOTTOM should be 2") + } + if LEFT != 3 { + t.Error("LEFT should be 3") + } +} + +func TestOffsetReference_Constants(t *testing.T) { + if BEGIN != 0 { + t.Error("BEGIN should be 0") + } + if END != 1 { + t.Error("END should be 1") + } +} + +func TestRect_Origin(t *testing.T) { + rect := Rect{X: 10, Y: 20, Width: 100, Height: 200} + origin := rect.Origin() + + if origin.X != 10 { + t.Errorf("origin.X = %d, want 10", origin.X) + } + if origin.Y != 20 { + t.Errorf("origin.Y = %d, want 20", origin.Y) + } +} + +func TestRect_Corner(t *testing.T) { + rect := Rect{X: 10, Y: 20, Width: 100, Height: 200} + corner := rect.Corner() + + if corner.X != 110 { // 10 + 100 + t.Errorf("corner.X = %d, want 110", corner.X) + } + if corner.Y != 220 { // 20 + 200 + t.Errorf("corner.Y = %d, want 220", corner.Y) + } +} + +func TestRect_InsideCorner(t *testing.T) { + rect := Rect{X: 10, Y: 20, Width: 100, Height: 200} + inside := rect.InsideCorner() + + if inside.X != 109 { // 10 + 100 - 1 + t.Errorf("inside.X = %d, want 109", inside.X) + } + if inside.Y != 219 { // 20 + 200 - 1 + t.Errorf("inside.Y = %d, want 219", inside.Y) + } +} + +func TestRect_right(t *testing.T) { + rect := Rect{X: 10, Y: 20, Width: 100, Height: 200} + if rect.right() != 110 { + t.Errorf("right() = %d, want 110", rect.right()) + } +} + +func TestRect_bottom(t *testing.T) { + rect := Rect{X: 10, Y: 20, Width: 100, Height: 200} + if rect.bottom() != 220 { + t.Errorf("bottom() = %d, want 220", rect.bottom()) + } +} + +func TestRect_Size(t *testing.T) { + rect := Rect{X: 10, Y: 20, Width: 100, Height: 200} + size := rect.Size() + + if size.Width != 100 { + t.Errorf("Width = %d, want 100", size.Width) + } + if size.Height != 200 { + t.Errorf("Height = %d, want 200", size.Height) + } +} + +func TestRect_IsEmpty(t *testing.T) { + tests := []struct { + rect Rect + expected bool + }{ + {Rect{X: 0, Y: 0, Width: 0, Height: 0}, true}, + {Rect{X: 0, Y: 0, Width: 100, Height: 0}, true}, + {Rect{X: 0, Y: 0, Width: 0, Height: 100}, true}, + {Rect{X: 0, Y: 0, Width: -1, Height: 100}, true}, + {Rect{X: 0, Y: 0, Width: 100, Height: -1}, true}, + {Rect{X: 0, Y: 0, Width: 100, Height: 200}, false}, + {Rect{X: 10, Y: 20, Width: 1, Height: 1}, false}, + } + + for _, tt := range tests { + result := tt.rect.IsEmpty() + if result != tt.expected { + t.Errorf("Rect%v.IsEmpty() = %v, want %v", tt.rect, result, tt.expected) + } + } +} + +func TestRect_Contains(t *testing.T) { + rect := Rect{X: 10, Y: 20, Width: 100, Height: 200} + + tests := []struct { + point Point + expected bool + }{ + {Point{X: 10, Y: 20}, true}, // top-left corner + {Point{X: 50, Y: 100}, true}, // inside + {Point{X: 109, Y: 219}, true}, // inside corner + {Point{X: 110, Y: 220}, false}, // corner (exclusive) + {Point{X: 0, Y: 0}, false}, // outside + {Point{X: 9, Y: 20}, false}, // left of rect + {Point{X: 10, Y: 19}, false}, // above rect + {Point{X: 111, Y: 100}, false}, // right of rect + {Point{X: 50, Y: 221}, false}, // below rect + } + + for _, tt := range tests { + result := rect.Contains(tt.point) + if result != tt.expected { + t.Errorf("Rect%v.Contains(%v) = %v, want %v", rect, tt.point, result, tt.expected) + } + } +} + +func TestRect_Intersect(t *testing.T) { + tests := []struct { + name string + r1 Rect + r2 Rect + expected Rect + }{ + { + name: "overlapping", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 50, Y: 50, Width: 100, Height: 100}, + expected: Rect{X: 50, Y: 50, Width: 50, Height: 50}, + }, + { + name: "no overlap - horizontal", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 200, Y: 0, Width: 100, Height: 100}, + expected: Rect{}, + }, + { + name: "no overlap - vertical", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 0, Y: 200, Width: 100, Height: 100}, + expected: Rect{}, + }, + { + name: "contained", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 25, Y: 25, Width: 50, Height: 50}, + expected: Rect{X: 25, Y: 25, Width: 50, Height: 50}, + }, + { + name: "identical", + r1: Rect{X: 10, Y: 20, Width: 100, Height: 100}, + r2: Rect{X: 10, Y: 20, Width: 100, Height: 100}, + expected: Rect{X: 10, Y: 20, Width: 100, Height: 100}, + }, + { + name: "empty rect 1", + r1: Rect{}, + r2: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + expected: Rect{}, + }, + { + name: "empty rect 2", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{}, + expected: Rect{}, + }, + { + name: "touching edges - no intersection", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 100, Y: 0, Width: 100, Height: 100}, + expected: Rect{}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.r1.Intersect(tt.r2) + if result != tt.expected { + t.Errorf("Intersect: got %v, want %v", result, tt.expected) + } + }) + } +} + +func TestRect_distanceFromRectSquared(t *testing.T) { + tests := []struct { + name string + r1 Rect + r2 Rect + expected int + }{ + { + name: "overlapping - negative area", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 50, Y: 50, Width: 100, Height: 100}, + expected: -(50 * 50), // intersection area + }, + { + name: "horizontal gap", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 110, Y: 0, Width: 100, Height: 100}, + expected: 100, // gap of 10, squared + }, + { + name: "vertical gap", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 0, Y: 120, Width: 100, Height: 100}, + expected: 400, // gap of 20, squared + }, + { + name: "diagonal gap", + r1: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + r2: Rect{X: 110, Y: 110, Width: 100, Height: 100}, + expected: 200, // dX=10, dY=10, 10^2 + 10^2 = 200 + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.r1.distanceFromRectSquared(tt.r2) + if result != tt.expected { + t.Errorf("distanceFromRectSquared: got %d, want %d", result, tt.expected) + } + }) + } +} + +func TestScreen_Origin(t *testing.T) { + screen := Screen{X: 100, Y: 200} + origin := screen.Origin() + + if origin.X != 100 { + t.Errorf("origin.X = %d, want 100", origin.X) + } + if origin.Y != 200 { + t.Errorf("origin.Y = %d, want 200", origin.Y) + } +} + +func TestScreen_scale(t *testing.T) { + screen := Screen{ScaleFactor: 2.0} + + tests := []struct { + value int + toDip bool + expected int + }{ + {100, true, 50}, // to DIP: 100 / 2 = 50 + {100, false, 200}, // to physical: 100 * 2 = 200 + {101, true, 51}, // to DIP: ceil(101 / 2) = 51 + {101, false, 202}, // to physical: floor(101 * 2) = 202 + {0, true, 0}, + {0, false, 0}, + } + + for _, tt := range tests { + result := screen.scale(tt.value, tt.toDip) + if result != tt.expected { + t.Errorf("scale(%d, %v) = %d, want %d", tt.value, tt.toDip, result, tt.expected) + } + } +} + +func TestScreen_scale_1_5(t *testing.T) { + screen := Screen{ScaleFactor: 1.5} + + tests := []struct { + value int + toDip bool + expected int + }{ + {150, true, 100}, // to DIP: ceil(150 / 1.5) = 100 + {100, false, 150}, // to physical: floor(100 * 1.5) = 150 + {100, true, 67}, // to DIP: ceil(100 / 1.5) = 67 + {67, false, 100}, // to physical: floor(67 * 1.5) = 100 + } + + for _, tt := range tests { + result := screen.scale(tt.value, tt.toDip) + if result != tt.expected { + t.Errorf("scale(%d, %v) with factor 1.5 = %d, want %d", tt.value, tt.toDip, result, tt.expected) + } + } +} + +func TestScreen_right(t *testing.T) { + screen := Screen{ + Bounds: Rect{X: 100, Y: 0, Width: 200, Height: 100}, + } + if screen.right() != 300 { + t.Errorf("right() = %d, want 300", screen.right()) + } +} + +func TestScreen_bottom(t *testing.T) { + screen := Screen{ + Bounds: Rect{X: 0, Y: 100, Width: 100, Height: 200}, + } + if screen.bottom() != 300 { + t.Errorf("bottom() = %d, want 300", screen.bottom()) + } +} + +func TestScreen_intersects(t *testing.T) { + screen1 := &Screen{ + X: 0, + Y: 0, + Bounds: Rect{X: 0, Y: 0, Width: 100, Height: 100}, + } + + screen2 := &Screen{ + X: 50, + Y: 50, + Bounds: Rect{X: 50, Y: 50, Width: 100, Height: 100}, + } + + screen3 := &Screen{ + X: 200, + Y: 0, + Bounds: Rect{X: 200, Y: 0, Width: 100, Height: 100}, + } + + if !screen1.intersects(screen2) { + t.Error("screen1 and screen2 should intersect") + } + if screen1.intersects(screen3) { + t.Error("screen1 and screen3 should not intersect") + } +} + +func TestPoint_Fields(t *testing.T) { + pt := Point{X: 10, Y: 20} + if pt.X != 10 || pt.Y != 20 { + t.Error("Point fields not set correctly") + } +} + +func TestSize_Fields(t *testing.T) { + size := Size{Width: 100, Height: 200} + if size.Width != 100 || size.Height != 200 { + t.Error("Size fields not set correctly") + } +} + +func TestScreen_Fields(t *testing.T) { + screen := Screen{ + ID: "display-1", + Name: "Primary Display", + ScaleFactor: 2.0, + X: 0, + Y: 0, + Size: Size{Width: 1920, Height: 1080}, + Bounds: Rect{X: 0, Y: 0, Width: 1920, Height: 1080}, + IsPrimary: true, + Rotation: 0, + } + + if screen.ID != "display-1" { + t.Error("ID not set correctly") + } + if screen.Name != "Primary Display" { + t.Error("Name not set correctly") + } + if screen.ScaleFactor != 2.0 { + t.Error("ScaleFactor not set correctly") + } + if !screen.IsPrimary { + t.Error("IsPrimary not set correctly") + } +} + +func TestScreenPlacement_Fields(t *testing.T) { + parent := &Screen{ID: "parent"} + child := &Screen{ID: "child"} + + placement := ScreenPlacement{ + screen: child, + parent: parent, + alignment: RIGHT, + offset: 100, + offsetReference: BEGIN, + } + + if placement.screen != child { + t.Error("screen not set correctly") + } + if placement.parent != parent { + t.Error("parent not set correctly") + } + if placement.alignment != RIGHT { + t.Error("alignment not set correctly") + } + if placement.offset != 100 { + t.Error("offset not set correctly") + } + if placement.offsetReference != BEGIN { + t.Error("offsetReference not set correctly") + } +} + +func TestNewScreenManager(t *testing.T) { + sm := newScreenManager(nil) + if sm == nil { + t.Fatal("newScreenManager returned nil") + } + if sm.screens != nil { + t.Error("screens should be nil initially") + } + if sm.primaryScreen != nil { + t.Error("primaryScreen should be nil initially") + } +} diff --git a/v3/pkg/application/services_test.go b/v3/pkg/application/services_test.go new file mode 100644 index 000000000..79fbb64ea --- /dev/null +++ b/v3/pkg/application/services_test.go @@ -0,0 +1,203 @@ +package application + +import ( + "context" + "testing" +) + +// Test service implementations +type testService struct { + name string +} + +func (s *testService) ServiceName() string { + return s.name +} + +type testServiceWithStartup struct { + started bool +} + +func (s *testServiceWithStartup) ServiceStartup(ctx context.Context, options ServiceOptions) error { + s.started = true + return nil +} + +type testServiceWithShutdown struct { + shutdown bool +} + +func (s *testServiceWithShutdown) ServiceShutdown() error { + s.shutdown = true + return nil +} + +type testServiceNoInterface struct { + value int +} + +func TestNewService(t *testing.T) { + svc := &testService{name: "test"} + service := NewService(svc) + + if service.instance == nil { + t.Error("NewService should set instance") + } + if service.Instance() != svc { + t.Error("Instance() should return the original service") + } +} + +func TestNewServiceWithOptions(t *testing.T) { + svc := &testService{name: "original"} + opts := ServiceOptions{ + Name: "custom-name", + Route: "/api", + } + service := NewServiceWithOptions(svc, opts) + + if service.Instance() != svc { + t.Error("Instance() should return the original service") + } + if service.options.Name != "custom-name" { + t.Errorf("options.Name = %q, want %q", service.options.Name, "custom-name") + } + if service.options.Route != "/api" { + t.Errorf("options.Route = %q, want %q", service.options.Route, "/api") + } +} + +func TestGetServiceName_FromOptions(t *testing.T) { + svc := &testService{name: "service-name"} + opts := ServiceOptions{Name: "options-name"} + service := NewServiceWithOptions(svc, opts) + + name := getServiceName(service) + if name != "options-name" { + t.Errorf("getServiceName() = %q, want %q (options takes precedence)", name, "options-name") + } +} + +func TestGetServiceName_FromInterface(t *testing.T) { + svc := &testService{name: "interface-name"} + service := NewService(svc) + + name := getServiceName(service) + if name != "interface-name" { + t.Errorf("getServiceName() = %q, want %q (from interface)", name, "interface-name") + } +} + +func TestGetServiceName_FromType(t *testing.T) { + svc := &testServiceNoInterface{value: 42} + service := NewService(svc) + + name := getServiceName(service) + // Should contain the type name + if name == "" { + t.Error("getServiceName() should return type name for services without ServiceName interface") + } + // The name should contain "testServiceNoInterface" + expected := "application.testServiceNoInterface" + if name != expected { + t.Errorf("getServiceName() = %q, want %q", name, expected) + } +} + +func TestService_Instance(t *testing.T) { + svc := &testService{name: "test"} + service := NewService(svc) + + instance := service.Instance() + if instance == nil { + t.Error("Instance() should not return nil") + } + + // Type assertion to verify it's the correct type + if _, ok := instance.(*testService); !ok { + t.Error("Instance() should return the correct type") + } +} + +func TestDefaultServiceOptions(t *testing.T) { + // Verify DefaultServiceOptions is zero-valued + if DefaultServiceOptions.Name != "" { + t.Errorf("DefaultServiceOptions.Name should be empty, got %q", DefaultServiceOptions.Name) + } + if DefaultServiceOptions.Route != "" { + t.Errorf("DefaultServiceOptions.Route should be empty, got %q", DefaultServiceOptions.Route) + } + if DefaultServiceOptions.MarshalError != nil { + t.Error("DefaultServiceOptions.MarshalError should be nil") + } +} + +func TestNewService_UsesDefaultOptions(t *testing.T) { + svc := &testService{name: "test"} + service := NewService(svc) + + // Service created with NewService should use DefaultServiceOptions + if service.options.Name != DefaultServiceOptions.Name { + t.Error("NewService should use DefaultServiceOptions") + } +} + +func TestServiceOptions_WithMarshalError(t *testing.T) { + customMarshal := func(err error) []byte { + return []byte(`{"error": "custom"}`) + } + + svc := &testService{name: "test"} + opts := ServiceOptions{ + MarshalError: customMarshal, + } + service := NewServiceWithOptions(svc, opts) + + if service.options.MarshalError == nil { + t.Error("MarshalError should be set") + } + + result := service.options.MarshalError(nil) + expected := `{"error": "custom"}` + if string(result) != expected { + t.Errorf("MarshalError result = %q, want %q", string(result), expected) + } +} + +func TestServiceStartupInterface(t *testing.T) { + svc := &testServiceWithStartup{} + service := NewService(svc) + + // Verify the service implements ServiceStartup + instance := service.Instance() + if startup, ok := instance.(ServiceStartup); ok { + err := startup.ServiceStartup(context.Background(), ServiceOptions{}) + if err != nil { + t.Errorf("ServiceStartup returned error: %v", err) + } + if !svc.started { + t.Error("ServiceStartup should have been called") + } + } else { + t.Error("testServiceWithStartup should implement ServiceStartup") + } +} + +func TestServiceShutdownInterface(t *testing.T) { + svc := &testServiceWithShutdown{} + service := NewService(svc) + + // Verify the service implements ServiceShutdown + instance := service.Instance() + if shutdown, ok := instance.(ServiceShutdown); ok { + err := shutdown.ServiceShutdown() + if err != nil { + t.Errorf("ServiceShutdown returned error: %v", err) + } + if !svc.shutdown { + t.Error("ServiceShutdown should have been called") + } + } else { + t.Error("testServiceWithShutdown should implement ServiceShutdown") + } +} diff --git a/v3/pkg/application/single_instance_test.go b/v3/pkg/application/single_instance_test.go new file mode 100644 index 000000000..230f8e07d --- /dev/null +++ b/v3/pkg/application/single_instance_test.go @@ -0,0 +1,229 @@ +package application + +import ( + "os" + "path/filepath" + "testing" +) + +func TestEncryptDecrypt(t *testing.T) { + key := [32]byte{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + } + + plaintext := []byte("Hello, World! This is a test message.") + + encrypted, err := encrypt(key, plaintext) + if err != nil { + t.Fatalf("encrypt failed: %v", err) + } + + if encrypted == "" { + t.Error("encrypted should not be empty") + } + + if encrypted == string(plaintext) { + t.Error("encrypted should be different from plaintext") + } + + decrypted, err := decrypt(key, encrypted) + if err != nil { + t.Fatalf("decrypt failed: %v", err) + } + + if string(decrypted) != string(plaintext) { + t.Errorf("decrypted = %q, want %q", string(decrypted), string(plaintext)) + } +} + +func TestEncryptDecrypt_EmptyData(t *testing.T) { + key := [32]byte{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + } + + plaintext := []byte{} + + encrypted, err := encrypt(key, plaintext) + if err != nil { + t.Fatalf("encrypt failed: %v", err) + } + + decrypted, err := decrypt(key, encrypted) + if err != nil { + t.Fatalf("decrypt failed: %v", err) + } + + if len(decrypted) != 0 { + t.Errorf("decrypted should be empty, got %d bytes", len(decrypted)) + } +} + +func TestDecrypt_InvalidData(t *testing.T) { + key := [32]byte{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + } + + tests := []struct { + name string + data string + }{ + {"invalid base64", "not-valid-base64!!!"}, + {"too short", "YWJj"}, // "abc" base64 encoded (3 bytes) + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + _, err := decrypt(key, tt.data) + if err == nil { + t.Error("decrypt should return error for invalid data") + } + }) + } +} + +func TestDecrypt_WrongKey(t *testing.T) { + key1 := [32]byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f} + + key2 := [32]byte{0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f} + + plaintext := []byte("Secret message") + + encrypted, err := encrypt(key1, plaintext) + if err != nil { + t.Fatalf("encrypt failed: %v", err) + } + + _, err = decrypt(key2, encrypted) + if err == nil { + t.Error("decrypt with wrong key should return error") + } +} + +func TestGetLockPath(t *testing.T) { + uniqueID := "com.example.myapp" + path := getLockPath(uniqueID) + + if path == "" { + t.Error("getLockPath should return non-empty path") + } + + expectedFileName := uniqueID + ".lock" + actualFileName := filepath.Base(path) + if actualFileName != expectedFileName { + t.Errorf("filename = %q, want %q", actualFileName, expectedFileName) + } + + // Path should be in temp directory + // Use filepath.Clean to normalize paths (os.TempDir may have trailing slash on macOS) + tmpDir := filepath.Clean(os.TempDir()) + if filepath.Dir(path) != tmpDir { + t.Errorf("path should be in temp directory %q, got %q", tmpDir, filepath.Dir(path)) + } +} + +func TestGetCurrentWorkingDir(t *testing.T) { + dir := getCurrentWorkingDir() + + // Should return a non-empty path + if dir == "" { + t.Error("getCurrentWorkingDir should return non-empty path") + } + + // Should match os.Getwd() + expected, err := os.Getwd() + if err != nil { + t.Skipf("os.Getwd failed: %v", err) + } + + if dir != expected { + t.Errorf("getCurrentWorkingDir() = %q, want %q", dir, expected) + } +} + +func TestSecondInstanceData_Fields(t *testing.T) { + data := SecondInstanceData{ + Args: []string{"arg1", "arg2"}, + WorkingDir: "/home/user", + AdditionalData: map[string]string{ + "key1": "value1", + "key2": "value2", + }, + } + + if len(data.Args) != 2 { + t.Error("Args not set correctly") + } + if data.WorkingDir != "/home/user" { + t.Error("WorkingDir not set correctly") + } + if len(data.AdditionalData) != 2 { + t.Error("AdditionalData not set correctly") + } +} + +func TestSingleInstanceOptions_Defaults(t *testing.T) { + opts := SingleInstanceOptions{} + + if opts.UniqueID != "" { + t.Error("UniqueID should default to empty string") + } + if opts.OnSecondInstanceLaunch != nil { + t.Error("OnSecondInstanceLaunch should default to nil") + } + if opts.AdditionalData != nil { + t.Error("AdditionalData should default to nil") + } + if opts.ExitCode != 0 { + t.Error("ExitCode should default to 0") + } + var zeroKey [32]byte + if opts.EncryptionKey != zeroKey { + t.Error("EncryptionKey should default to zero array") + } +} + +func TestSingleInstanceManager_Cleanup_Nil(t *testing.T) { + // Calling cleanup on nil manager should not panic + var m *singleInstanceManager + m.cleanup() // Should not panic +} + +func TestSingleInstanceManager_Cleanup_NilLock(t *testing.T) { + // Calling cleanup with nil lock should not panic + m := &singleInstanceManager{} + m.cleanup() // Should not panic +} + +func TestNewSingleInstanceManager_NilOptions(t *testing.T) { + manager, err := newSingleInstanceManager(nil, nil) + if err != nil { + t.Errorf("newSingleInstanceManager(nil, nil) should not return error: %v", err) + } + if manager != nil { + t.Error("newSingleInstanceManager(nil, nil) should return nil manager") + } +} + +func TestAlreadyRunningError(t *testing.T) { + if alreadyRunningError == nil { + t.Error("alreadyRunningError should not be nil") + } + if alreadyRunningError.Error() != "application is already running" { + t.Errorf("alreadyRunningError.Error() = %q", alreadyRunningError.Error()) + } +} diff --git a/v3/pkg/application/webview_window_options_test.go b/v3/pkg/application/webview_window_options_test.go new file mode 100644 index 000000000..309f3f542 --- /dev/null +++ b/v3/pkg/application/webview_window_options_test.go @@ -0,0 +1,388 @@ +package application + +import ( + "testing" +) + +func TestNewRGBA(t *testing.T) { + rgba := NewRGBA(100, 150, 200, 255) + + if rgba.Red != 100 { + t.Errorf("Red = %d, want 100", rgba.Red) + } + if rgba.Green != 150 { + t.Errorf("Green = %d, want 150", rgba.Green) + } + if rgba.Blue != 200 { + t.Errorf("Blue = %d, want 200", rgba.Blue) + } + if rgba.Alpha != 255 { + t.Errorf("Alpha = %d, want 255", rgba.Alpha) + } +} + +func TestNewRGB(t *testing.T) { + rgba := NewRGB(100, 150, 200) + + if rgba.Red != 100 { + t.Errorf("Red = %d, want 100", rgba.Red) + } + if rgba.Green != 150 { + t.Errorf("Green = %d, want 150", rgba.Green) + } + if rgba.Blue != 200 { + t.Errorf("Blue = %d, want 200", rgba.Blue) + } + if rgba.Alpha != 255 { + t.Errorf("Alpha = %d, want 255 (default)", rgba.Alpha) + } +} + +func TestNewRGBPtr(t *testing.T) { + ptr := NewRGBPtr(0x12, 0x34, 0x56) + + if ptr == nil { + t.Fatal("NewRGBPtr returned nil") + } + + // RGB is packed as 0x00BBGGRR + expected := uint32(0x12) | (uint32(0x34) << 8) | (uint32(0x56) << 16) + if *ptr != expected { + t.Errorf("*ptr = 0x%X, want 0x%X", *ptr, expected) + } +} + +func TestBackgroundType_Constants(t *testing.T) { + if BackgroundTypeSolid != 0 { + t.Error("BackgroundTypeSolid should be 0") + } + if BackgroundTypeTransparent != 1 { + t.Error("BackgroundTypeTransparent should be 1") + } + if BackgroundTypeTranslucent != 2 { + t.Error("BackgroundTypeTranslucent should be 2") + } +} + +func TestBackdropType_Constants(t *testing.T) { + if Auto != 0 { + t.Error("Auto should be 0") + } + if None != 1 { + t.Error("None should be 1") + } + if Mica != 2 { + t.Error("Mica should be 2") + } + if Acrylic != 3 { + t.Error("Acrylic should be 3") + } + if Tabbed != 4 { + t.Error("Tabbed should be 4") + } +} + +func TestDragEffect_Constants(t *testing.T) { + if DragEffectNone != 1 { + t.Error("DragEffectNone should be 1") + } + if DragEffectCopy != 2 { + t.Error("DragEffectCopy should be 2") + } + if DragEffectMove != 3 { + t.Error("DragEffectMove should be 3") + } + if DragEffectLink != 4 { + t.Error("DragEffectLink should be 4") + } +} + +func TestTheme_Constants(t *testing.T) { + if SystemDefault != 0 { + t.Error("SystemDefault should be 0") + } + if Dark != 1 { + t.Error("Dark should be 1") + } + if Light != 2 { + t.Error("Light should be 2") + } +} + +func TestMacBackdrop_Constants(t *testing.T) { + if MacBackdropNormal != 0 { + t.Error("MacBackdropNormal should be 0") + } + if MacBackdropTransparent != 1 { + t.Error("MacBackdropTransparent should be 1") + } + if MacBackdropTranslucent != 2 { + t.Error("MacBackdropTranslucent should be 2") + } + if MacBackdropLiquidGlass != 3 { + t.Error("MacBackdropLiquidGlass should be 3") + } +} + +func TestMacToolbarStyle_Constants(t *testing.T) { + if MacToolbarStyleAutomatic != 0 { + t.Error("MacToolbarStyleAutomatic should be 0") + } + if MacToolbarStyleExpanded != 1 { + t.Error("MacToolbarStyleExpanded should be 1") + } + if MacToolbarStylePreference != 2 { + t.Error("MacToolbarStylePreference should be 2") + } + if MacToolbarStyleUnified != 3 { + t.Error("MacToolbarStyleUnified should be 3") + } + if MacToolbarStyleUnifiedCompact != 4 { + t.Error("MacToolbarStyleUnifiedCompact should be 4") + } +} + +func TestWebviewGpuPolicy_Constants(t *testing.T) { + if WebviewGpuPolicyAlways != 0 { + t.Error("WebviewGpuPolicyAlways should be 0") + } + if WebviewGpuPolicyOnDemand != 1 { + t.Error("WebviewGpuPolicyOnDemand should be 1") + } + if WebviewGpuPolicyNever != 2 { + t.Error("WebviewGpuPolicyNever should be 2") + } +} + +func TestMacTitleBarDefault(t *testing.T) { + titleBar := MacTitleBarDefault + + if titleBar.AppearsTransparent != false { + t.Error("MacTitleBarDefault.AppearsTransparent should be false") + } + if titleBar.Hide != false { + t.Error("MacTitleBarDefault.Hide should be false") + } + if titleBar.HideTitle != false { + t.Error("MacTitleBarDefault.HideTitle should be false") + } + if titleBar.FullSizeContent != false { + t.Error("MacTitleBarDefault.FullSizeContent should be false") + } + if titleBar.UseToolbar != false { + t.Error("MacTitleBarDefault.UseToolbar should be false") + } + if titleBar.HideToolbarSeparator != false { + t.Error("MacTitleBarDefault.HideToolbarSeparator should be false") + } +} + +func TestMacTitleBarHidden(t *testing.T) { + titleBar := MacTitleBarHidden + + if titleBar.AppearsTransparent != true { + t.Error("MacTitleBarHidden.AppearsTransparent should be true") + } + if titleBar.Hide != false { + t.Error("MacTitleBarHidden.Hide should be false") + } + if titleBar.HideTitle != true { + t.Error("MacTitleBarHidden.HideTitle should be true") + } + if titleBar.FullSizeContent != true { + t.Error("MacTitleBarHidden.FullSizeContent should be true") + } + if titleBar.UseToolbar != false { + t.Error("MacTitleBarHidden.UseToolbar should be false") + } + if titleBar.HideToolbarSeparator != false { + t.Error("MacTitleBarHidden.HideToolbarSeparator should be false") + } +} + +func TestMacTitleBarHiddenInset(t *testing.T) { + titleBar := MacTitleBarHiddenInset + + if titleBar.AppearsTransparent != true { + t.Error("MacTitleBarHiddenInset.AppearsTransparent should be true") + } + if titleBar.Hide != false { + t.Error("MacTitleBarHiddenInset.Hide should be false") + } + if titleBar.HideTitle != true { + t.Error("MacTitleBarHiddenInset.HideTitle should be true") + } + if titleBar.FullSizeContent != true { + t.Error("MacTitleBarHiddenInset.FullSizeContent should be true") + } + if titleBar.UseToolbar != true { + t.Error("MacTitleBarHiddenInset.UseToolbar should be true") + } + if titleBar.HideToolbarSeparator != true { + t.Error("MacTitleBarHiddenInset.HideToolbarSeparator should be true") + } +} + +func TestMacTitleBarHiddenInsetUnified(t *testing.T) { + titleBar := MacTitleBarHiddenInsetUnified + + if titleBar.AppearsTransparent != true { + t.Error("MacTitleBarHiddenInsetUnified.AppearsTransparent should be true") + } + if titleBar.ToolbarStyle != MacToolbarStyleUnified { + t.Error("MacTitleBarHiddenInsetUnified.ToolbarStyle should be MacToolbarStyleUnified") + } +} + +func TestMacAppearanceType_Constants(t *testing.T) { + tests := []struct { + name string + value MacAppearanceType + expected string + }{ + {"DefaultAppearance", DefaultAppearance, ""}, + {"NSAppearanceNameAqua", NSAppearanceNameAqua, "NSAppearanceNameAqua"}, + {"NSAppearanceNameDarkAqua", NSAppearanceNameDarkAqua, "NSAppearanceNameDarkAqua"}, + {"NSAppearanceNameVibrantLight", NSAppearanceNameVibrantLight, "NSAppearanceNameVibrantLight"}, + } + + for _, tt := range tests { + if string(tt.value) != tt.expected { + t.Errorf("%s = %q, want %q", tt.name, string(tt.value), tt.expected) + } + } +} + +func TestMacWindowLevel_Constants(t *testing.T) { + tests := []struct { + name string + value MacWindowLevel + expected string + }{ + {"MacWindowLevelNormal", MacWindowLevelNormal, "normal"}, + {"MacWindowLevelFloating", MacWindowLevelFloating, "floating"}, + {"MacWindowLevelTornOffMenu", MacWindowLevelTornOffMenu, "tornOffMenu"}, + {"MacWindowLevelModalPanel", MacWindowLevelModalPanel, "modalPanel"}, + {"MacWindowLevelMainMenu", MacWindowLevelMainMenu, "mainMenu"}, + {"MacWindowLevelStatus", MacWindowLevelStatus, "status"}, + {"MacWindowLevelPopUpMenu", MacWindowLevelPopUpMenu, "popUpMenu"}, + {"MacWindowLevelScreenSaver", MacWindowLevelScreenSaver, "screenSaver"}, + } + + for _, tt := range tests { + if string(tt.value) != tt.expected { + t.Errorf("%s = %q, want %q", tt.name, string(tt.value), tt.expected) + } + } +} + +func TestWebviewWindowOptions_Defaults(t *testing.T) { + opts := WebviewWindowOptions{} + + // Verify zero values + if opts.Name != "" { + t.Error("Name should default to empty string") + } + if opts.Title != "" { + t.Error("Title should default to empty string") + } + if opts.Width != 0 { + t.Error("Width should default to 0") + } + if opts.Height != 0 { + t.Error("Height should default to 0") + } + if opts.AlwaysOnTop != false { + t.Error("AlwaysOnTop should default to false") + } + if opts.Frameless != false { + t.Error("Frameless should default to false") + } +} + +func TestWindowsWindow_Defaults(t *testing.T) { + opts := WindowsWindow{} + + if opts.BackdropType != Auto { + t.Error("BackdropType should default to Auto") + } + if opts.DisableIcon != false { + t.Error("DisableIcon should default to false") + } + if opts.Theme != SystemDefault { + t.Error("Theme should default to SystemDefault") + } +} + +func TestMacWindow_Defaults(t *testing.T) { + opts := MacWindow{} + + if opts.Backdrop != MacBackdropNormal { + t.Error("Backdrop should default to MacBackdropNormal") + } + if opts.DisableShadow != false { + t.Error("DisableShadow should default to false") + } +} + +func TestLinuxWindow_Defaults(t *testing.T) { + opts := LinuxWindow{} + + if opts.WindowIsTranslucent != false { + t.Error("WindowIsTranslucent should default to false") + } + if opts.WebviewGpuPolicy != WebviewGpuPolicyAlways { + t.Error("WebviewGpuPolicy should default to WebviewGpuPolicyAlways") + } +} + +func TestCoreWebView2PermissionKind_Constants(t *testing.T) { + if CoreWebView2PermissionKindUnknownPermission != 0 { + t.Error("CoreWebView2PermissionKindUnknownPermission should be 0") + } + if CoreWebView2PermissionKindMicrophone != 1 { + t.Error("CoreWebView2PermissionKindMicrophone should be 1") + } + if CoreWebView2PermissionKindCamera != 2 { + t.Error("CoreWebView2PermissionKindCamera should be 2") + } +} + +func TestCoreWebView2PermissionState_Constants(t *testing.T) { + if CoreWebView2PermissionStateDefault != 0 { + t.Error("CoreWebView2PermissionStateDefault should be 0") + } + if CoreWebView2PermissionStateAllow != 1 { + t.Error("CoreWebView2PermissionStateAllow should be 1") + } + if CoreWebView2PermissionStateDeny != 2 { + t.Error("CoreWebView2PermissionStateDeny should be 2") + } +} + +func TestMacLiquidGlassStyle_Constants(t *testing.T) { + if LiquidGlassStyleAutomatic != 0 { + t.Error("LiquidGlassStyleAutomatic should be 0") + } + if LiquidGlassStyleLight != 1 { + t.Error("LiquidGlassStyleLight should be 1") + } + if LiquidGlassStyleDark != 2 { + t.Error("LiquidGlassStyleDark should be 2") + } + if LiquidGlassStyleVibrant != 3 { + t.Error("LiquidGlassStyleVibrant should be 3") + } +} + +func TestNSVisualEffectMaterial_Constants(t *testing.T) { + if NSVisualEffectMaterialAppearanceBased != 0 { + t.Error("NSVisualEffectMaterialAppearanceBased should be 0") + } + if NSVisualEffectMaterialLight != 1 { + t.Error("NSVisualEffectMaterialLight should be 1") + } + if NSVisualEffectMaterialAuto != -1 { + t.Error("NSVisualEffectMaterialAuto should be -1") + } +} From 9ebdf229bb4ebb6189843f24d95733a4ee1debd2 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 27 Dec 2025 02:40:47 +0000 Subject: [PATCH 10/40] chore(v3): bump to v3.0.0-alpha.53 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 9 +++++++++ v3/UNRELEASED_CHANGELOG.md | 3 --- v3/internal/version/version.txt | 2 +- 3 files changed, 10 insertions(+), 4 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index f23edf746..7c2938c71 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.53 - 2025-12-27 + +## Added +- Add unit tests for pkg/application by @leaanthony +- Add custom protocol support to MSIX packaging by @leaanthony + +## Fixed +- Consolidate custom protocol documentation and add Universal Links sections by @leaanthony + ## v3.0.0-alpha.52 - 2025-12-26 ## Fixed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 3aad74272..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -17,15 +17,12 @@ After processing, the content will be moved to the main changelog and this file ## Added -- Add unit tests for pkg/application by @leaanthony -- Add custom protocol support to MSIX packaging by @leaanthony ## Changed ## Fixed -- Consolidate custom protocol documentation and add Universal Links sections by @leaanthony ## Deprecated diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 11d2c7943..1c9bf46cc 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.52 \ No newline at end of file +v3.0.0-alpha.53 \ No newline at end of file From 7bc6501a846cd5c78918198ee38c9794a37773bd Mon Sep 17 00:00:00 2001 From: Dzmitryi Hilimovich Date: Mon, 29 Dec 2025 01:05:17 +0100 Subject: [PATCH 11/40] [v3] Debug printf statements left in webview_window_darwin.m (#4834) * Clean up debug output in webView URL scheme handler Removed debug print statements for CSS requests in web view. * Add changelog entry for #4834 * Fix Changelog --------- Co-authored-by: Lea Anthony --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/pkg/application/webview_window_darwin.m | 6 ------ 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..21cde115e 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -29,6 +29,7 @@ After processing, the content will be moved to the main changelog and this file ## Removed +- Remove debug printf statements from Darwin URL scheme handler (#4834) ## Security diff --git a/v3/pkg/application/webview_window_darwin.m b/v3/pkg/application/webview_window_darwin.m index 34c0ef019..752e3675a 100644 --- a/v3/pkg/application/webview_window_darwin.m +++ b/v3/pkg/application/webview_window_darwin.m @@ -373,14 +373,8 @@ typedef NS_ENUM(NSInteger, MacLiquidGlassStyle) { } - (void)webView:(nonnull WKWebView *)webView startURLSchemeTask:(nonnull id)urlSchemeTask { NSURL *url = urlSchemeTask.request.URL; - printf("🎨🎨🎨 [DARWIN] URL SCHEME HANDLER: %s\n", [url.absoluteString UTF8String]); fflush(stdout); if ([url.path hasSuffix:@".css"] || [url.path containsString:@"style"]) { - printf("🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨\n"); - printf("🎨 [DARWIN] CSS REQUEST INTERCEPTED!\n"); - printf("🎨 URL: %s\n", [url.absoluteString UTF8String]); - printf("🎨 Path: %s\n", [url.path UTF8String]); - printf("🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨\n"); fflush(stdout); } processURLRequest(self.windowId, urlSchemeTask); From 0de429b8fc8332ea4ab278b52ae95f6ebbcb88b6 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Mon, 29 Dec 2025 11:07:37 +1100 Subject: [PATCH 12/40] feat(macos): add CollectionBehavior option to MacWindow (#4799) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(macos): add CollectionBehavior option to MacWindow (#4756) Add configurable NSWindowCollectionBehavior support for macOS windows, allowing control over window behavior across Spaces and fullscreen. New options include: - MacWindowCollectionBehaviorCanJoinAllSpaces - MacWindowCollectionBehaviorFullScreenAuxiliary - MacWindowCollectionBehaviorMoveToActiveSpace - And more... This enables building Spotlight-like apps that appear on all Spaces or overlay fullscreen applications. Closes #4756 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude * Potential fix for code scanning alert no. 140: Workflow does not contain permissions Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com> * Potential fix for code scanning alert no. 139: Workflow does not contain permissions Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com> * feat(examples): add spotlight example for CollectionBehavior Demonstrates creating a Spotlight-like launcher window that: - Appears on all macOS Spaces - Floats above other windows - Uses accessory activation policy (no Dock icon) - Has frameless translucent design 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude * feat(macos): support bitwise OR for CollectionBehavior options Update CollectionBehavior to use actual NSWindowCollectionBehavior bitmask values, allowing multiple behaviors to be combined: ```go CollectionBehavior: application.MacWindowCollectionBehaviorCanJoinAllSpaces | application.MacWindowCollectionBehaviorFullScreenAuxiliary, ``` Changes: - Update Go constants to use actual bitmask values (1<<0, 1<<1, etc.) - Simplify C function to pass through combined bitmask directly - Add ParticipatesInCycle, IgnoresCycle, FullScreenDisallowsTiling options - Update documentation with combined behavior examples - Update spotlight example to demonstrate combining behaviors 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --------- Co-authored-by: Claude Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com> --- .github/workflows/automated-releases.yml | 1 + .github/workflows/test-nightly-releases.yml | 2 + .../content/docs/features/windows/basics.mdx | 19 ++- .../content/docs/features/windows/options.mdx | 90 ++++++++--- v3/UNRELEASED_CHANGELOG.md | 1 + v3/examples/spotlight/README.md | 66 ++++++++ v3/examples/spotlight/main.go | 142 ++++++++++++++++++ v3/pkg/application/webview_window_darwin.go | 24 ++- v3/pkg/application/webview_window_options.go | 37 +++++ 9 files changed, 352 insertions(+), 30 deletions(-) create mode 100644 v3/examples/spotlight/README.md create mode 100644 v3/examples/spotlight/main.go diff --git a/.github/workflows/automated-releases.yml b/.github/workflows/automated-releases.yml index e88f54eb9..83445d869 100644 --- a/.github/workflows/automated-releases.yml +++ b/.github/workflows/automated-releases.yml @@ -23,6 +23,7 @@ env: jobs: check-permissions: name: Check Release Permissions + permissions: {} runs-on: ubuntu-latest outputs: authorized: ${{ steps.check.outputs.authorized }} diff --git a/.github/workflows/test-nightly-releases.yml b/.github/workflows/test-nightly-releases.yml index 63df09935..1e6f12a69 100644 --- a/.github/workflows/test-nightly-releases.yml +++ b/.github/workflows/test-nightly-releases.yml @@ -1,4 +1,6 @@ name: Test Nightly Releases (Dry Run) +permissions: + contents: read on: workflow_dispatch: diff --git a/docs/src/content/docs/features/windows/basics.mdx b/docs/src/content/docs/features/windows/basics.mdx index 007c62c52..3137111ac 100644 --- a/docs/src/content/docs/features/windows/basics.mdx +++ b/docs/src/content/docs/features/windows/basics.mdx @@ -410,22 +410,29 @@ childWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ **macOS-specific features:** - + ```go // Transparent title bar window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ - Mac: application.MacOptions{ - TitleBarAppearsTransparent: true, - Backdrop: application.MacBackdropTranslucent, + Mac: application.MacWindow{ + TitleBar: application.MacTitleBar{ + AppearsTransparent: true, + }, + Backdrop: application.MacBackdropTranslucent, }, }) ``` - + **Backdrop types:** - `MacBackdropNormal` - Standard window - `MacBackdropTranslucent` - Translucent background - `MacBackdropTransparent` - Fully transparent - + + **Collection behavior:** + Control how windows behave across Spaces: + - `MacWindowCollectionBehaviorCanJoinAllSpaces` - Visible on all Spaces + - `MacWindowCollectionBehaviorFullScreenAuxiliary` - Can overlay fullscreen apps + **Native fullscreen:** macOS fullscreen creates a new Space (virtual desktop). diff --git a/docs/src/content/docs/features/windows/options.mdx b/docs/src/content/docs/features/windows/options.mdx index 521d50b01..93a468120 100644 --- a/docs/src/content/docs/features/windows/options.mdx +++ b/docs/src/content/docs/features/windows/options.mdx @@ -665,39 +665,85 @@ OnDestroy: func() { ### Mac Options ```go -Mac: application.MacOptions{ - TitleBarAppearsTransparent: true, - Backdrop: application.MacBackdropTranslucent, - InvisibleTitleBarHeight: 50, - TitleBarStyle: application.MacTitleBarStyleHidden, +Mac: application.MacWindow{ + TitleBar: application.MacTitleBar{ + AppearsTransparent: true, + Hide: false, + HideTitle: true, + FullSizeContent: true, + }, + Backdrop: application.MacBackdropTranslucent, + InvisibleTitleBarHeight: 50, + WindowLevel: application.MacWindowLevelNormal, + CollectionBehavior: application.MacWindowCollectionBehaviorDefault, }, ``` -**TitleBarAppearsTransparent** (`bool`) -- Makes title bar transparent -- Content extends into title bar area +**TitleBar** (`MacTitleBar`) +- `AppearsTransparent` - Makes title bar transparent, content extends into title bar area +- `Hide` - Hides the title bar completely +- `HideTitle` - Hides only the title text +- `FullSizeContent` - Extends content to full window size **Backdrop** (`MacBackdrop`) -- `MacBackdropNormal` - Standard -- `MacBackdropTranslucent` - Blurred translucent -- `MacBackdropTransparent` - Fully transparent +- `MacBackdropNormal` - Standard opaque background +- `MacBackdropTranslucent` - Blurred translucent background +- `MacBackdropTransparent` - Fully transparent background **InvisibleTitleBarHeight** (`int`) -- Height of invisible title bar (for dragging) -- Only when `TitleBarStyle` is `MacTitleBarStyleHidden` +- Height of invisible title bar area (for dragging) +- Useful when title bar is hidden -**TitleBarStyle** (`MacTitleBarStyle`) -- `MacTitleBarStyleDefault` - Standard title bar -- `MacTitleBarStyleHidden` - Hidden title bar -- `MacTitleBarStyleHiddenInset` - Hidden with inset +**WindowLevel** (`MacWindowLevel`) +- `MacWindowLevelNormal` - Standard window level (default) +- `MacWindowLevelFloating` - Floats above normal windows +- `MacWindowLevelTornOffMenu` - Torn-off menu level +- `MacWindowLevelModalPanel` - Modal panel level +- `MacWindowLevelMainMenu` - Main menu level +- `MacWindowLevelStatus` - Status window level +- `MacWindowLevelPopUpMenu` - Pop-up menu level +- `MacWindowLevelScreenSaver` - Screen saver level -**Example:** +**CollectionBehavior** (`MacWindowCollectionBehavior`) + +Controls how the window behaves across macOS Spaces and fullscreen. These are bitmask values that can be combined using bitwise OR (`|`). + +**Space behavior:** +- `MacWindowCollectionBehaviorDefault` - Uses FullScreenPrimary (default, backwards compatible) +- `MacWindowCollectionBehaviorCanJoinAllSpaces` - Window appears on all Spaces +- `MacWindowCollectionBehaviorMoveToActiveSpace` - Moves to active Space when shown +- `MacWindowCollectionBehaviorManaged` - Default managed window behavior +- `MacWindowCollectionBehaviorTransient` - Temporary/transient window +- `MacWindowCollectionBehaviorStationary` - Stays stationary during Space switches + +**Window cycling:** +- `MacWindowCollectionBehaviorParticipatesInCycle` - Included in Cmd+` cycling +- `MacWindowCollectionBehaviorIgnoresCycle` - Excluded from Cmd+` cycling + +**Fullscreen behavior:** +- `MacWindowCollectionBehaviorFullScreenPrimary` - Can enter fullscreen mode +- `MacWindowCollectionBehaviorFullScreenAuxiliary` - Can overlay fullscreen apps +- `MacWindowCollectionBehaviorFullScreenNone` - Disables fullscreen capability +- `MacWindowCollectionBehaviorFullScreenAllowsTiling` - Allows side-by-side tiling (macOS 10.11+) +- `MacWindowCollectionBehaviorFullScreenDisallowsTiling` - Prevents tiling (macOS 10.11+) + +**Example - Spotlight-like window:** ```go -Mac: application.MacOptions{ - TitleBarAppearsTransparent: true, - Backdrop: application.MacBackdropTranslucent, - InvisibleTitleBarHeight: 50, +// Window that appears on all Spaces AND can overlay fullscreen apps +Mac: application.MacWindow{ + CollectionBehavior: application.MacWindowCollectionBehaviorCanJoinAllSpaces | + application.MacWindowCollectionBehaviorFullScreenAuxiliary, + WindowLevel: application.MacWindowLevelFloating, +}, +``` + +**Example - Single behavior:** + +```go +// Window that can appear over fullscreen applications +Mac: application.MacWindow{ + CollectionBehavior: application.MacWindowCollectionBehaviorFullScreenAuxiliary, }, ``` diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 21cde115e..a3289242e 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -17,6 +17,7 @@ After processing, the content will be moved to the main changelog and this file ## Added +- Add `CollectionBehavior` option to `MacWindow` for controlling window behavior across macOS Spaces and fullscreen (#4756) by @leaanthony ## Changed diff --git a/v3/examples/spotlight/README.md b/v3/examples/spotlight/README.md new file mode 100644 index 000000000..bda8f464e --- /dev/null +++ b/v3/examples/spotlight/README.md @@ -0,0 +1,66 @@ +# Spotlight Example + +This example demonstrates how to create a Spotlight-like launcher window using the `CollectionBehavior` option on macOS. + +## Features + +- **Appears on all Spaces**: Using `MacWindowCollectionBehaviorCanJoinAllSpaces`, the window is visible across all virtual desktops +- **Overlays fullscreen apps**: Using `MacWindowCollectionBehaviorFullScreenAuxiliary`, the window can appear over fullscreen applications +- **Combined behaviors**: Demonstrates combining multiple behaviors with bitwise OR +- **Floating window**: `MacWindowLevelFloating` keeps the window above other windows +- **Accessory app**: Doesn't appear in the Dock (uses `ActivationPolicyAccessory`) +- **Frameless design**: Clean, borderless appearance with translucent backdrop + +## Running the example + +```bash +go run . +``` + +**Note**: This example is macOS-specific due to the use of `CollectionBehavior`. + +## Combining CollectionBehaviors + +Behaviors can be combined using bitwise OR (`|`): + +```go +CollectionBehavior: application.MacWindowCollectionBehaviorCanJoinAllSpaces | + application.MacWindowCollectionBehaviorFullScreenAuxiliary, +``` + +## CollectionBehavior Options + +These are bitmask values that can be combined: + +**Space behavior:** +| Option | Description | +|--------|-------------| +| `MacWindowCollectionBehaviorDefault` | Uses FullScreenPrimary (default) | +| `MacWindowCollectionBehaviorCanJoinAllSpaces` | Window appears on all Spaces | +| `MacWindowCollectionBehaviorMoveToActiveSpace` | Moves to active Space when shown | +| `MacWindowCollectionBehaviorManaged` | Default managed window behavior | +| `MacWindowCollectionBehaviorTransient` | Temporary/transient window | +| `MacWindowCollectionBehaviorStationary` | Stays stationary during Space switches | + +**Fullscreen behavior:** +| Option | Description | +|--------|-------------| +| `MacWindowCollectionBehaviorFullScreenPrimary` | Can enter fullscreen mode | +| `MacWindowCollectionBehaviorFullScreenAuxiliary` | Can overlay fullscreen apps | +| `MacWindowCollectionBehaviorFullScreenNone` | Disables fullscreen | +| `MacWindowCollectionBehaviorFullScreenAllowsTiling` | Allows side-by-side tiling | + +## Use Cases + +- **Launcher apps** (like Spotlight, Alfred, Raycast) +- **Quick capture tools** (notes, screenshots) +- **System utilities** that need to be accessible anywhere +- **Overlay widgets** that should appear over fullscreen apps + +## Status + +| Platform | Status | +|----------|--------| +| Mac | Working | +| Windows | N/A (macOS-specific feature) | +| Linux | N/A (macOS-specific feature) | diff --git a/v3/examples/spotlight/main.go b/v3/examples/spotlight/main.go new file mode 100644 index 000000000..d961f1f54 --- /dev/null +++ b/v3/examples/spotlight/main.go @@ -0,0 +1,142 @@ +package main + +import ( + "log" + "net/http" + + "github.com/wailsapp/wails/v3/pkg/application" +) + +// This example demonstrates how to create a Spotlight-like launcher window +// that appears on all macOS Spaces and can overlay fullscreen applications. +// +// Key features: +// - Window appears on all Spaces (virtual desktops) +// - Can overlay fullscreen applications +// - Floating window level keeps it above other windows +// - Accessory activation policy hides from Dock +// - Frameless design with translucent backdrop + +func main() { + app := application.New(application.Options{ + Name: "Spotlight Example", + Description: "A Spotlight-like launcher demonstrating CollectionBehavior", + Mac: application.MacOptions{ + // Accessory apps don't appear in the Dock + ActivationPolicy: application.ActivationPolicyAccessory, + ApplicationShouldTerminateAfterLastWindowClosed: true, + }, + Assets: application.AssetOptions{ + Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + w.Write([]byte(spotlightHTML)) + }), + }, + }) + + // Create a Spotlight-like window + app.Window.NewWithOptions(application.WebviewWindowOptions{ + Title: "Spotlight", + Width: 680, + Height: 80, + Frameless: true, + // Center the window + InitialPosition: application.WindowCentered, + // Prevent resizing + DisableResize: true, + Mac: application.MacWindow{ + // Combine multiple behaviors using bitwise OR: + // - CanJoinAllSpaces: window appears on ALL Spaces (virtual desktops) + // - FullScreenAuxiliary: window can overlay fullscreen applications + CollectionBehavior: application.MacWindowCollectionBehaviorCanJoinAllSpaces | + application.MacWindowCollectionBehaviorFullScreenAuxiliary, + // Float above other windows + WindowLevel: application.MacWindowLevelFloating, + // Translucent vibrancy effect + Backdrop: application.MacBackdropTranslucent, + // Hidden title bar for clean look + TitleBar: application.MacTitleBar{ + AppearsTransparent: true, + Hide: true, + }, + }, + URL: "/", + }) + + err := app.Run() + if err != nil { + log.Fatal(err) + } +} + +const spotlightHTML = ` + + + Spotlight + + + + +
+ + + + + +
+ +` diff --git a/v3/pkg/application/webview_window_darwin.go b/v3/pkg/application/webview_window_darwin.go index b8d3736d3..fc81974bf 100644 --- a/v3/pkg/application/webview_window_darwin.go +++ b/v3/pkg/application/webview_window_darwin.go @@ -34,8 +34,8 @@ void* windowNew(unsigned int id, int width, int height, bool fraudulentWebsiteWa backing:NSBackingStoreBuffered defer:NO]; - // Allow fullscreen. Needed for frameless windows - window.collectionBehavior = NSWindowCollectionBehaviorFullScreenPrimary; + // Note: collectionBehavior is set later via windowSetCollectionBehavior() + // to allow user configuration of Space and fullscreen behavior // Create delegate WebviewWindowDelegate* delegate = [[WebviewWindowDelegate alloc] init]; @@ -234,6 +234,19 @@ void setModalPanelWindowLevel(void* nsWindow) { [(WebviewWindow*)nsWindow setLev void setScreenSaverWindowLevel(void* nsWindow) { [(WebviewWindow*)nsWindow setLevel:NSScreenSaverWindowLevel]; } void setTornOffMenuWindowLevel(void* nsWindow) { [(WebviewWindow*)nsWindow setLevel:NSTornOffMenuWindowLevel]; } +// Set NSWindow collection behavior for Spaces and fullscreen +// The behavior parameter is a bitmask that can combine multiple NSWindowCollectionBehavior values +void windowSetCollectionBehavior(void* nsWindow, int behavior) { + WebviewWindow* window = (WebviewWindow*)nsWindow; + if (behavior == 0) { + // Default: use FullScreenPrimary for backwards compatibility + window.collectionBehavior = NSWindowCollectionBehaviorFullScreenPrimary; + } else { + // Pass through the combined bitmask directly + window.collectionBehavior = (NSWindowCollectionBehavior)behavior; + } +} + // Load URL in NSWindow void navigationLoadURL(void* nsWindow, char* url) { // Load URL on main thread @@ -1162,6 +1175,10 @@ func (w *macosWebviewWindow) setWindowLevel(level MacWindowLevel) { } } +func (w *macosWebviewWindow) setCollectionBehavior(behavior MacWindowCollectionBehavior) { + C.windowSetCollectionBehavior(w.nsWindow, C.int(behavior)) +} + func (w *macosWebviewWindow) width() int { var width C.int var wg sync.WaitGroup @@ -1260,6 +1277,9 @@ func (w *macosWebviewWindow) run() { } w.setWindowLevel(macOptions.WindowLevel) + // Set collection behavior (defaults to FullScreenPrimary for backwards compatibility) + w.setCollectionBehavior(macOptions.CollectionBehavior) + // Initialise the window buttons w.setMinimiseButtonState(options.MinimiseButtonState) w.setMaximiseButtonState(options.MaximiseButtonState) diff --git a/v3/pkg/application/webview_window_options.go b/v3/pkg/application/webview_window_options.go index 4c9c0f57a..8ca629559 100644 --- a/v3/pkg/application/webview_window_options.go +++ b/v3/pkg/application/webview_window_options.go @@ -489,6 +489,9 @@ type MacWindow struct { // WindowLevel sets the window level to control the order of windows in the screen WindowLevel MacWindowLevel + // CollectionBehavior controls how the window behaves across macOS Spaces and fullscreen + CollectionBehavior MacWindowCollectionBehavior + // LiquidGlass contains configuration for the Liquid Glass effect LiquidGlass MacLiquidGlass } @@ -506,6 +509,40 @@ const ( MacWindowLevelScreenSaver MacWindowLevel = "screenSaver" ) +// MacWindowCollectionBehavior controls window behavior across macOS Spaces and fullscreen. +// These correspond to NSWindowCollectionBehavior bitmask values and can be combined using bitwise OR. +// For example: MacWindowCollectionBehaviorCanJoinAllSpaces | MacWindowCollectionBehaviorFullScreenAuxiliary +type MacWindowCollectionBehavior int + +const ( + // MacWindowCollectionBehaviorDefault is zero value - when set, FullScreenPrimary is used for backwards compatibility + MacWindowCollectionBehaviorDefault MacWindowCollectionBehavior = 0 + // MacWindowCollectionBehaviorCanJoinAllSpaces allows window to appear on all Spaces + MacWindowCollectionBehaviorCanJoinAllSpaces MacWindowCollectionBehavior = 1 << 0 // 1 + // MacWindowCollectionBehaviorMoveToActiveSpace moves window to active Space when shown + MacWindowCollectionBehaviorMoveToActiveSpace MacWindowCollectionBehavior = 1 << 1 // 2 + // MacWindowCollectionBehaviorManaged is the default managed window behavior + MacWindowCollectionBehaviorManaged MacWindowCollectionBehavior = 1 << 2 // 4 + // MacWindowCollectionBehaviorTransient marks window as temporary/transient + MacWindowCollectionBehaviorTransient MacWindowCollectionBehavior = 1 << 3 // 8 + // MacWindowCollectionBehaviorStationary keeps window stationary during Space switches + MacWindowCollectionBehaviorStationary MacWindowCollectionBehavior = 1 << 4 // 16 + // MacWindowCollectionBehaviorParticipatesInCycle includes window in Cmd+` cycling (default for normal windows) + MacWindowCollectionBehaviorParticipatesInCycle MacWindowCollectionBehavior = 1 << 5 // 32 + // MacWindowCollectionBehaviorIgnoresCycle excludes window from Cmd+` cycling + MacWindowCollectionBehaviorIgnoresCycle MacWindowCollectionBehavior = 1 << 6 // 64 + // MacWindowCollectionBehaviorFullScreenPrimary allows the window to enter fullscreen + MacWindowCollectionBehaviorFullScreenPrimary MacWindowCollectionBehavior = 1 << 7 // 128 + // MacWindowCollectionBehaviorFullScreenAuxiliary allows window to overlay fullscreen apps + MacWindowCollectionBehaviorFullScreenAuxiliary MacWindowCollectionBehavior = 1 << 8 // 256 + // MacWindowCollectionBehaviorFullScreenNone prevents window from entering fullscreen (macOS 10.7+) + MacWindowCollectionBehaviorFullScreenNone MacWindowCollectionBehavior = 1 << 9 // 512 + // MacWindowCollectionBehaviorFullScreenAllowsTiling allows side-by-side tiling in fullscreen (macOS 10.11+) + MacWindowCollectionBehaviorFullScreenAllowsTiling MacWindowCollectionBehavior = 1 << 11 // 2048 + // MacWindowCollectionBehaviorFullScreenDisallowsTiling prevents tiling in fullscreen (macOS 10.11+) + MacWindowCollectionBehaviorFullScreenDisallowsTiling MacWindowCollectionBehavior = 1 << 12 // 4096 +) + // MacWebviewPreferences contains preferences for the Mac webview type MacWebviewPreferences struct { // TabFocusesLinks will enable tabbing to links From cee729dd85119d18df04eba27e087b08da8613e1 Mon Sep 17 00:00:00 2001 From: wux1an <87492350+wux1an@users.noreply.github.com> Date: Mon, 29 Dec 2025 09:14:25 +0800 Subject: [PATCH 13/40] fix(v3): resolve some issues in template code when compiling macOS program on Linux (#4832) * fix(v3): resolve Docker error "undefined symbol: ___ubsan_handle_xxxxxxx" when running 'wails3 build GOOS=darwin GOARCH=arm64' on Linux * fix(v3): correct command argument error when executing 'build:universal:lipo:go' task on Linux * docs(v3): update changelog * Fix CHANGELOG * Fix CHANGELOG --------- Co-authored-by: Lea Anthony --- v3/UNRELEASED_CHANGELOG.md | 2 ++ v3/internal/commands/build_assets/darwin/Taskfile.yml | 2 +- v3/internal/commands/build_assets/docker/Dockerfile.cross | 4 ++-- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index a3289242e..f91d072e3 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -24,6 +24,8 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Fix command argument error when executing 'build:universal:lipo:go' task on Linux by @wux1an +- Fix Docker error "undefined symbol: ___ubsan_handle_xxxxxxx" when running 'wails3 build GOOS=darwin GOARCH=arm64' on Linux by @wux1an ## Deprecated diff --git a/v3/internal/commands/build_assets/darwin/Taskfile.yml b/v3/internal/commands/build_assets/darwin/Taskfile.yml index 3458c96ef..054da1a63 100644 --- a/v3/internal/commands/build_assets/darwin/Taskfile.yml +++ b/v3/internal/commands/build_assets/darwin/Taskfile.yml @@ -117,7 +117,7 @@ tasks: summary: Creates universal binary using wails3 tool lipo (Linux/Windows) internal: true cmds: - - wails3 tool lipo -o "{{.BIN_DIR}}/{{.APP_NAME}}" -i "{{.BIN_DIR}}/{{.APP_NAME}}-amd64" -i "{{.BIN_DIR}}/{{.APP_NAME}}-arm64" + - wails3 tool lipo -output "{{.BIN_DIR}}/{{.APP_NAME}}" -input "{{.BIN_DIR}}/{{.APP_NAME}}-amd64" -input "{{.BIN_DIR}}/{{.APP_NAME}}-arm64" - rm -f "{{.BIN_DIR}}/{{.APP_NAME}}-amd64" "{{.BIN_DIR}}/{{.APP_NAME}}-arm64" package: diff --git a/v3/internal/commands/build_assets/docker/Dockerfile.cross b/v3/internal/commands/build_assets/docker/Dockerfile.cross index e1c05a05d..474c05525 100644 --- a/v3/internal/commands/build_assets/docker/Dockerfile.cross +++ b/v3/internal/commands/build_assets/docker/Dockerfile.cross @@ -46,7 +46,7 @@ for arg in "$@"; do *) ARGS="$ARGS $arg" ;; esac done -exec zig cc -target aarch64-macos-none -isysroot /opt/macos-sdk -I/opt/macos-sdk/usr/include -L/opt/macos-sdk/usr/lib -F/opt/macos-sdk/System/Library/Frameworks -w $ARGS +exec zig cc -fno-sanitize=all -target aarch64-macos-none -isysroot /opt/macos-sdk -I/opt/macos-sdk/usr/include -L/opt/macos-sdk/usr/lib -F/opt/macos-sdk/System/Library/Frameworks -w $ARGS ZIGWRAP RUN chmod +x /usr/local/bin/zcc-darwin-arm64 @@ -66,7 +66,7 @@ for arg in "$@"; do *) ARGS="$ARGS $arg" ;; esac done -exec zig cc -target x86_64-macos-none -isysroot /opt/macos-sdk -I/opt/macos-sdk/usr/include -L/opt/macos-sdk/usr/lib -F/opt/macos-sdk/System/Library/Frameworks -w $ARGS +exec zig cc -fno-sanitize=all -target x86_64-macos-none -isysroot /opt/macos-sdk -I/opt/macos-sdk/usr/include -L/opt/macos-sdk/usr/lib -F/opt/macos-sdk/System/Library/Frameworks -w $ARGS ZIGWRAP RUN chmod +x /usr/local/bin/zcc-darwin-amd64 From 3256041d8b0a3cd4559b37c83e06ced971049047 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 29 Dec 2025 02:52:26 +0000 Subject: [PATCH 14/40] chore(v3): bump to v3.0.0-alpha.54 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 12 ++++++++++++ v3/UNRELEASED_CHANGELOG.md | 4 ---- v3/internal/version/version.txt | 2 +- 3 files changed, 13 insertions(+), 5 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index 7c2938c71..d0edd228a 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.54 - 2025-12-29 + +## Added +- Add `CollectionBehavior` option to `MacWindow` for controlling window behavior across macOS Spaces and fullscreen (#4756) by @leaanthony + +## Fixed +- Fix command argument error when executing 'build:universal:lipo:go' task on Linux by @wux1an +- Fix Docker error "undefined symbol: ___ubsan_handle_xxxxxxx" when running 'wails3 build GOOS=darwin GOARCH=arm64' on Linux by @wux1an + +## Removed +- Remove debug printf statements from Darwin URL scheme handler (#4834) + ## v3.0.0-alpha.53 - 2025-12-27 ## Added diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index f91d072e3..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -17,22 +17,18 @@ After processing, the content will be moved to the main changelog and this file ## Added -- Add `CollectionBehavior` option to `MacWindow` for controlling window behavior across macOS Spaces and fullscreen (#4756) by @leaanthony ## Changed ## Fixed -- Fix command argument error when executing 'build:universal:lipo:go' task on Linux by @wux1an -- Fix Docker error "undefined symbol: ___ubsan_handle_xxxxxxx" when running 'wails3 build GOOS=darwin GOARCH=arm64' on Linux by @wux1an ## Deprecated ## Removed -- Remove debug printf statements from Darwin URL scheme handler (#4834) ## Security diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 1c9bf46cc..3ca87f3ac 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.53 \ No newline at end of file +v3.0.0-alpha.54 \ No newline at end of file From a06d55804cfb150db9aa107a249e5d1e8f6e1549 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Fri, 2 Jan 2026 07:03:36 +1100 Subject: [PATCH 15/40] perf(v3): optimize JSON processing and reduce allocations in hot paths (#4843) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * perf(v3): optimize JSON processing and reduce allocations in hot paths - Switch to goccy/go-json for method binding, events, and HTTP transport (21-63% faster, 40-60% less memory for method calls) - Optimize BoundMethod struct layout to reduce padding (144 -> 136 bytes) - Cache isVariadic flag at registration to avoid reflect call per invocation - Use stack-allocated buffer for method arguments (<=8 args) - Optimize result collection to avoid slice allocation for single return values - Use sync.Map for MIME cache to improve concurrent read performance - Use buffer pool for HTTP transport request body reading - Lazily allocate CloseNotify channel in content type sniffer - Remove debug CSS logging from asset server - Add comprehensive benchmark tests (build tag: bench) Performance improvements for BoundMethod.Call: - SimpleCall: 1290ns -> 930ns (28% faster), 240B -> 80B (67% less memory) - ComplexCall: 10500ns -> 3900ns (63% faster), 1192B -> 1020B (14% less) - VariadicCall: 3460ns -> 1600ns (54% faster), 512B -> 289B (44% less) * perf(v3): add max size limit to buffer pool to prevent memory bloat Buffers larger than 512KB are not returned to the pool, allowing GC to reclaim memory after large requests (e.g., base64 encoded images). * perf(v3): remove mimetype library dependency, saving ~208KB binary size - Replace github.com/wailsapp/mimetype with expanded extension map + stdlib - Expand MIME type map from 16 to 50+ common web formats (fonts, audio, video, etc.) - Add comprehensive test suite validating MIME detection for all web formats - Use http.DetectContentType as fallback for unknown extensions - Actual binary size reduction: 1.2MB (11MB -> 9.8MB in test app) * perf(v3): migrate all runtime code to goccy/go-json Migrate remaining encoding/json usages to goccy/go-json in: - pkg/application (android, darwin, ios, single_instance, webview_window) - pkg/services (kvstore, notifications on all platforms) - internal/assetserver/webview (request/response handling) - internal/runtime and internal/capabilities Note: encoding/json (110KB) remains in binary because: 1. goccy/go-json imports it for interface compatibility (json.Marshaler, etc.) 2. log/slog (stdlib) uses it for JSON output The performance benefit is in the hot paths which now use the faster library. * perf(v3): replace gopkg.in/ini.v1 with minimal .desktop file parser Replace the gopkg.in/ini.v1 dependency with a purpose-built minimal parser for Linux .desktop files. The new parser: - Only extracts the Exec key from [Desktop Entry] section (all we need) - Follows the Desktop Entry Specification - Has comprehensive test coverage (40 tests) including: - All major file managers (Nautilus, Dolphin, Thunar, PCManFM, Caja, Nemo) - Edge cases (UTF-8, special chars, comments, empty files, etc.) - Buffer limit handling Binary size reduction: 45KB (10.22MB -> 10.18MB) * perf(v3): remove samber/lo from runtime code, saving ~310KB binary size Replace samber/lo with Go 1.21+ stdlib slices package and minimal internal helpers in all runtime code paths. This removes 80 transitive dependencies from the production binary. Changes: - Create internal/sliceutil package with Unique and FindMapKey helpers - Replace lo.Without with slices.DeleteFunc in event handling - Replace lo.Ternary with inline if/else in Windows code - Replace lo.Uniq with sliceutil.Unique for feature flags - Replace lo.FindKey with sliceutil.FindMapKey for method aliases - Replace lo.Filter with slices.DeleteFunc in event listeners - Replace lo.Must with inline panic in w32 package Binary size: 10.18MB -> 9.87MB (~310KB / 3% reduction) Note: CLI tools still use samber/lo since they don't affect production binary size. The application_debug.go file also retains lo usage as it has //go:build !production tag. * fix: address CodeRabbit review comments - Use application/x-typescript MIME type (not IANA-registered text/typescript) - Fix potential panic in mimetype_stdlib_test.go for short MIME strings - Use cached isVariadic flag in bindings_optimized_bench_test.go * fix: initialize goccy/go-json decoder early to fix Windows test failure On Windows, goccy/go-json's type address calculation can fail if the decoder is first invoked during test execution rather than at init time. Force early initialization by unmarshaling a []int during package init. See: https://github.com/goccy/go-json/issues/474 * 📝 Add docstrings to `v3/performance-improvements` (#4844) * fix: initialize goccy/go-json decoder early to fix Windows test failure On Windows, goccy/go-json's type address calculation can fail if the decoder is first invoked during test execution rather than at init time. Force early initialization by unmarshaling a []int during package init. See: https://github.com/goccy/go-json/issues/474 * 📝 Add docstrings to `v3/performance-improvements` Docstrings generation was requested by @leaanthony. * https://github.com/wailsapp/wails/pull/4843#issuecomment-3703472562 The following files were modified: * `v3/internal/assetserver/common.go` * `v3/internal/assetserver/content_type_sniffer.go` * `v3/internal/assetserver/mimecache.go` * `v3/internal/fileexplorer/desktopfile.go` * `v3/internal/fileexplorer/fileexplorer_linux.go` * `v3/internal/sliceutil/sliceutil.go` * `v3/pkg/application/application_ios.go` * `v3/pkg/application/bindings.go` * `v3/pkg/application/ios_runtime_ios.go` * `v3/pkg/w32/window.go` --------- Co-authored-by: Lea Anthony Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --------- Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- v3/UNRELEASED_CHANGELOG.md | 12 + v3/go.mod | 17 +- v3/go.sum | 34 +- .../assetserver/assetserver_bench_test.go | 242 ++++++++ v3/internal/assetserver/common.go | 29 +- .../assetserver/content_type_sniffer.go | 18 +- v3/internal/assetserver/mimecache.go | 125 ++-- .../assetserver/mimetype_stdlib_test.go | 277 +++++++++ .../assetserver/webview/request_darwin.go | 3 +- .../assetserver/webview/request_ios.go | 3 +- .../webview/responsewriter_darwin.go | 3 +- .../assetserver/webview/responsewriter_ios.go | 3 +- v3/internal/capabilities/capabilities.go | 2 +- v3/internal/fileexplorer/desktopfile.go | 96 ++++ v3/internal/fileexplorer/desktopfile_test.go | 532 ++++++++++++++++++ .../fileexplorer/fileexplorer_linux.go | 15 +- v3/internal/runtime/runtime.go | 3 +- v3/internal/sliceutil/sliceutil.go | 39 ++ v3/internal/sliceutil/sliceutil_test.go | 172 ++++++ v3/pkg/application/application_android.go | 3 +- .../application/application_android_nocgo.go | 3 +- v3/pkg/application/application_darwin.go | 4 +- v3/pkg/application/application_ios.go | 37 +- v3/pkg/application/bindings.go | 171 ++++-- v3/pkg/application/bindings_bench_test.go | 506 +++++++++++++++++ .../bindings_optimized_bench_test.go | 469 +++++++++++++++ v3/pkg/application/event_manager.go | 9 +- v3/pkg/application/events.go | 17 +- v3/pkg/application/events_bench_test.go | 380 +++++++++++++ v3/pkg/application/ios_runtime_ios.go | 36 +- v3/pkg/application/json_libs_bench_test.go | 310 ++++++++++ v3/pkg/application/json_v2_bench_test.go | 270 +++++++++ v3/pkg/application/logger_ios.go | 9 +- v3/pkg/application/messageprocessor_args.go | 3 +- v3/pkg/application/messageprocessor_call.go | 3 +- v3/pkg/application/messageprocessor_events.go | 2 +- v3/pkg/application/single_instance.go | 3 +- v3/pkg/application/systemtray_bench_test.go | 374 ++++++++++++ v3/pkg/application/transport_http.go | 30 +- v3/pkg/application/webview_window.go | 13 +- v3/pkg/application/webview_window_windows.go | 27 +- v3/pkg/application/window_bench_test.go | 442 +++++++++++++++ v3/pkg/services/kvstore/kvstore.go | 2 +- .../notifications/notifications_darwin.go | 3 +- .../notifications/notifications_linux.go | 3 +- .../notifications/notifications_windows.go | 3 +- v3/pkg/w32/window.go | 23 +- 47 files changed, 4580 insertions(+), 200 deletions(-) create mode 100644 v3/internal/assetserver/assetserver_bench_test.go create mode 100644 v3/internal/assetserver/mimetype_stdlib_test.go create mode 100644 v3/internal/fileexplorer/desktopfile.go create mode 100644 v3/internal/fileexplorer/desktopfile_test.go create mode 100644 v3/internal/sliceutil/sliceutil.go create mode 100644 v3/internal/sliceutil/sliceutil_test.go create mode 100644 v3/pkg/application/bindings_bench_test.go create mode 100644 v3/pkg/application/bindings_optimized_bench_test.go create mode 100644 v3/pkg/application/events_bench_test.go create mode 100644 v3/pkg/application/json_libs_bench_test.go create mode 100644 v3/pkg/application/json_v2_bench_test.go create mode 100644 v3/pkg/application/systemtray_bench_test.go create mode 100644 v3/pkg/application/window_bench_test.go diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..c4109328c 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -20,6 +20,15 @@ After processing, the content will be moved to the main changelog and this file ## Changed +- Switch to goccy/go-json for all runtime JSON processing (method bindings, events, webview requests, notifications, kvstore), improving performance by 21-63% and reducing memory allocations by 40-60% +- Optimize BoundMethod struct layout and cache isVariadic flag to reduce per-call overhead +- Use stack-allocated argument buffer for methods with <=8 arguments to avoid heap allocations +- Optimize result collection in method calls to avoid slice allocation for single return values +- Use sync.Map for MIME type cache to improve concurrent performance +- Use buffer pool for HTTP transport request body reading +- Lazily allocate CloseNotify channel in content type sniffer to reduce per-request allocations +- Remove debug CSS logging from asset server +- Expand MIME type extension map to cover 50+ common web formats (fonts, audio, video, etc.) ## Fixed @@ -29,6 +38,9 @@ After processing, the content will be moved to the main changelog and this file ## Removed +- Remove github.com/wailsapp/mimetype dependency in favor of expanded extension map + stdlib http.DetectContentType, reducing binary size by ~1.2MB +- Remove gopkg.in/ini.v1 dependency by implementing minimal .desktop file parser for Linux file explorer, saving ~45KB +- Remove samber/lo from runtime code by using Go 1.21+ stdlib slices package and minimal internal helpers, saving ~310KB ## Security diff --git a/v3/go.mod b/v3/go.mod index 5eb97b298..407db2905 100644 --- a/v3/go.mod +++ b/v3/go.mod @@ -1,6 +1,6 @@ module github.com/wailsapp/wails/v3 -go 1.24.0 +go 1.25 require ( git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 @@ -8,11 +8,14 @@ require ( github.com/adrg/xdg v0.5.3 github.com/atterpac/refresh v0.8.6 github.com/bep/debounce v1.2.1 + github.com/bytedance/sonic v1.14.2 github.com/charmbracelet/glamour v0.9.0 github.com/charmbracelet/huh v0.8.0 github.com/ebitengine/purego v0.8.2 github.com/go-git/go-git/v5 v5.13.2 + github.com/go-json-experiment/json v0.0.0-20251027170946-4849db3c2f7e github.com/go-ole/go-ole v1.3.0 + github.com/goccy/go-json v0.10.5 github.com/godbus/dbus/v5 v5.1.0 github.com/google/go-cmp v0.7.0 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 @@ -21,6 +24,7 @@ require ( github.com/gorilla/websocket v1.5.3 github.com/jackmordaunt/icns/v2 v2.2.7 github.com/jaypipes/ghw v0.17.0 + github.com/json-iterator/go v1.1.12 github.com/konoui/lipo v0.10.0 github.com/leaanthony/clir v1.7.0 github.com/leaanthony/go-ansi-parser v1.6.1 @@ -38,13 +42,11 @@ require ( github.com/stretchr/testify v1.10.0 github.com/tc-hib/winres v0.3.1 github.com/wailsapp/go-webview2 v1.0.22 - github.com/wailsapp/mimetype v1.4.1 github.com/wailsapp/task/v3 v3.40.1-patched3 github.com/zalando/go-keyring v0.2.6 golang.org/x/sys v0.33.0 golang.org/x/term v0.30.0 golang.org/x/tools v0.31.0 - gopkg.in/ini.v1 v1.67.0 gopkg.in/yaml.v3 v3.0.1 modernc.org/sqlite v1.36.0 ) @@ -53,6 +55,8 @@ require ( al.essio.dev/pkg/shellescape v1.5.1 // indirect atomicgo.dev/schedule v0.1.0 // indirect github.com/atotto/clipboard v0.1.4 // indirect + github.com/bytedance/gopkg v0.1.3 // indirect + github.com/bytedance/sonic/loader v0.4.0 // indirect github.com/catppuccin/go v0.3.0 // indirect github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7 // indirect github.com/charmbracelet/bubbletea v1.3.6 // indirect @@ -60,13 +64,18 @@ require ( github.com/charmbracelet/x/cellbuf v0.0.13 // indirect github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 // indirect github.com/charmbracelet/x/term v0.2.1 // indirect + github.com/cloudwego/base64x v0.1.6 // indirect github.com/danieljoos/wincred v1.2.2 // indirect github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect github.com/konoui/go-qsort v0.1.0 // indirect github.com/mattn/go-localereader v0.0.1 // indirect + github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect github.com/ncruces/go-strftime v0.1.9 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/twitchyliquid64/golang-asm v0.15.1 // indirect + golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect ) require ( @@ -160,7 +169,7 @@ require ( golang.org/x/text v0.23.0 // indirect gopkg.in/warnings.v0 v0.1.2 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect - howett.net/plist v1.0.1 // indirect + howett.net/plist v1.0.1 modernc.org/libc v1.61.13 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.8.2 // indirect diff --git a/v3/go.sum b/v3/go.sum index 42265744d..899e70059 100644 --- a/v3/go.sum +++ b/v3/go.sum @@ -77,6 +77,12 @@ github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY= github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0= github.com/blakesmith/ar v0.0.0-20190502131153-809d4375e1fb h1:m935MPodAbYS46DG4pJSv7WO+VECIWUQ7OJYSoTrMh4= github.com/blakesmith/ar v0.0.0-20190502131153-809d4375e1fb/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI= +github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M= +github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM= +github.com/bytedance/sonic v1.14.2 h1:k1twIoe97C1DtYUo+fZQy865IuHia4PR5RPiuGPPIIE= +github.com/bytedance/sonic v1.14.2/go.mod h1:T80iDELeHiHKSc0C9tubFygiuXoGzrkjKzX2quAx980= +github.com/bytedance/sonic/loader v0.4.0 h1:olZ7lEqcxtZygCK9EKYKADnpQoYkRQxaeY2NYzevs+o= +github.com/bytedance/sonic/loader v0.4.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo= github.com/caarlos0/testfs v0.4.4 h1:3PHvzHi5Lt+g332CiShwS8ogTgS3HjrmzZxCm6JCDr8= github.com/caarlos0/testfs v0.4.4/go.mod h1:bRN55zgG4XCUVVHZCeU+/Tz1Q6AxEJOEJTliBy+1DMk= github.com/catppuccin/go v0.3.0 h1:d+0/YicIq+hSTo5oPuRi5kOpqkVA5tAsU6dNhvRu+aY= @@ -117,6 +123,8 @@ github.com/charmbracelet/x/xpty v0.1.2 h1:Pqmu4TEJ8KeA9uSkISKMU3f+C1F6OGBn8ABuGl github.com/charmbracelet/x/xpty v0.1.2/go.mod h1:XK2Z0id5rtLWcpeNiMYBccNNBrP2IJnzHI0Lq13Xzq4= github.com/cloudflare/circl v1.6.0 h1:cr5JKic4HI+LkINy2lg3W2jF8sHCVTBncJr5gIIq7qk= github.com/cloudflare/circl v1.6.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs= +github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M= +github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU= github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U= github.com/containerd/console v1.0.4 h1:F2g4+oChYvBTsASRTz8NP6iIAi97J3TtSAsLbIFn4ro= github.com/containerd/console v1.0.4/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= @@ -157,6 +165,8 @@ github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMj github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII= github.com/go-git/go-git/v5 v5.13.2 h1:7O7xvsK7K+rZPKW6AQR1YyNhfywkv7B8/FsP3ki6Zv0= github.com/go-git/go-git/v5 v5.13.2/go.mod h1:hWdW5P4YZRjmpGHwRH2v3zkWcNl6HeXaXQEMGb3NJ9A= +github.com/go-json-experiment/json v0.0.0-20251027170946-4849db3c2f7e h1:Lf/gRkoycfOBPa42vU2bbgPurFong6zXeFtPoxholzU= +github.com/go-json-experiment/json v0.0.0-20251027170946-4849db3c2f7e/go.mod h1:uNVvRXArCGbZ508SxYYTC5v1JWoz2voff5pm25jU1Ok= github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= @@ -168,12 +178,15 @@ github.com/go-task/template v0.1.0 h1:ym/r2G937RZA1bsgiWedNnY9e5kxDT+3YcoAnuIetT github.com/go-task/template v0.1.0/go.mod h1:RgwRaZK+kni/hJJ7/AaOE2lPQFPbAdji/DyhC6pxo4k= github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y= github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8= +github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= +github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk= github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ= github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd h1:gbpYu9NMq8jhDVbvlGkMFWCjLFlqqEZjEmObmhUy6Vo= github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw= github.com/google/rpmpack v0.6.1-0.20240329070804-c2247cbb881a h1:JJBdjSfqSy3mnDT0940ASQFghwcZ4y4cb6ttjAoXqwE= @@ -215,6 +228,8 @@ github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEE github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= @@ -283,6 +298,10 @@ github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4 github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE= github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= @@ -349,22 +368,28 @@ github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cA github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/tc-hib/winres v0.3.1 h1:CwRjEGrKdbi5CvZ4ID+iyVhgyfatxFoizjPhzez9Io4= github.com/tc-hib/winres v0.3.1/go.mod h1:C/JaNhH3KBvhNKVbvdlDWkbMDO9H4fKKDaN7/07SSuk= +github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= +github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc= github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= github.com/wailsapp/go-webview2 v1.0.22 h1:YT61F5lj+GGaat5OB96Aa3b4QA+mybD0Ggq6NZijQ58= github.com/wailsapp/go-webview2 v1.0.22/go.mod h1:qJmWAmAmaniuKGZPWwne+uor3AHMB5PFhqiK0Bbj8kc= -github.com/wailsapp/mimetype v1.4.1 h1:pQN9ycO7uo4vsUUuPeHEYoUkLVkaRntMnHJxVwYhwHs= -github.com/wailsapp/mimetype v1.4.1/go.mod h1:9aV5k31bBOv5z6u+QP8TltzvNGJPmNJD4XlAL3U+j3o= github.com/wailsapp/task/v3 v3.40.1-patched3 h1:i6O1WNdSur9CGaiMDIYGjsmj/qS4465zqv+WEs6sPRs= github.com/wailsapp/task/v3 v3.40.1-patched3/go.mod h1:jIP48r8ftoSQNlxFP4+aEnkvGQqQXqCnRi/B7ROaecE= github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= @@ -388,6 +413,8 @@ github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0= github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= gitlab.com/digitalxero/go-conventional-commit v1.0.7 h1:8/dO6WWG+98PMhlZowt/YjuiKhqhGlOCwlIV8SqqGh8= gitlab.com/digitalxero/go-conventional-commit v1.0.7/go.mod h1:05Xc2BFsSyC5tKhK0y+P3bs0AwUtNuTp+mTpbCU/DZ0= +golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VAiXCnxFY6NyDX0bHDmkU= +golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= @@ -406,7 +433,6 @@ golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU= golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= @@ -464,8 +490,6 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= -gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME= gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg= diff --git a/v3/internal/assetserver/assetserver_bench_test.go b/v3/internal/assetserver/assetserver_bench_test.go new file mode 100644 index 000000000..59a55411b --- /dev/null +++ b/v3/internal/assetserver/assetserver_bench_test.go @@ -0,0 +1,242 @@ +//go:build bench + +package assetserver + +import ( + "fmt" + "log/slog" + "net/http" + "net/http/httptest" + "os" + "sync" + "testing" +) + +// resetMimeCache clears the mime cache for benchmark isolation +func resetMimeCache() { + mimeCache = sync.Map{} +} + +// BenchmarkGetMimetype measures MIME type detection performance +func BenchmarkGetMimetype(b *testing.B) { + // Reset cache between runs + resetMimeCache() + + b.Run("ByExtension/JS", func(b *testing.B) { + data := []byte("function test() {}") + for b.Loop() { + _ = GetMimetype("script.js", data) + } + }) + + resetMimeCache() + b.Run("ByExtension/CSS", func(b *testing.B) { + data := []byte(".class { color: red; }") + for b.Loop() { + _ = GetMimetype("style.css", data) + } + }) + + resetMimeCache() + b.Run("ByExtension/HTML", func(b *testing.B) { + data := []byte("") + for b.Loop() { + _ = GetMimetype("index.html", data) + } + }) + + resetMimeCache() + b.Run("ByExtension/JSON", func(b *testing.B) { + data := []byte(`{"key": "value"}`) + for b.Loop() { + _ = GetMimetype("data.json", data) + } + }) + + resetMimeCache() + b.Run("Detection/Unknown", func(b *testing.B) { + data := []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05} + for b.Loop() { + _ = GetMimetype("unknown.bin", data) + } + }) + + resetMimeCache() + b.Run("Detection/PNG", func(b *testing.B) { + // PNG magic bytes + data := []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00} + for b.Loop() { + _ = GetMimetype("image.unknown", data) + } + }) + + resetMimeCache() + b.Run("CacheHit", func(b *testing.B) { + data := []byte{0x00, 0x01, 0x02} + // Prime the cache + _ = GetMimetype("cached.bin", data) + b.ResetTimer() + for b.Loop() { + _ = GetMimetype("cached.bin", data) + } + }) +} + +// BenchmarkGetMimetype_Concurrent tests concurrent MIME type lookups +func BenchmarkGetMimetype_Concurrent(b *testing.B) { + resetMimeCache() + data := []byte("function test() {}") + + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + _ = GetMimetype("script.js", data) + } + }) +} + +// BenchmarkAssetServerServeHTTP measures request handling overhead +func BenchmarkAssetServerServeHTTP(b *testing.B) { + logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelError + 1})) + + handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/html") + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("Hello")) + }) + + server, err := NewAssetServer(&Options{ + Handler: handler, + Logger: logger, + }) + if err != nil { + b.Fatal(err) + } + + b.Run("SimpleRequest", func(b *testing.B) { + req := httptest.NewRequest("GET", "/index.html", nil) + for b.Loop() { + rr := httptest.NewRecorder() + server.ServeHTTP(rr, req) + } + }) + + b.Run("WithHeaders", func(b *testing.B) { + req := httptest.NewRequest("GET", "/index.html", nil) + req.Header.Set("x-wails-window-id", "1") + req.Header.Set("x-wails-window-name", "main") + req.Header.Set("Accept-Language", "en-US,en;q=0.9") + for b.Loop() { + rr := httptest.NewRecorder() + server.ServeHTTP(rr, req) + } + }) +} + +// BenchmarkAssetServerServeHTTP_Concurrent tests concurrent request handling +func BenchmarkAssetServerServeHTTP_Concurrent(b *testing.B) { + logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelError + 1})) + + handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/html") + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("Hello")) + }) + + server, err := NewAssetServer(&Options{ + Handler: handler, + Logger: logger, + }) + if err != nil { + b.Fatal(err) + } + + b.RunParallel(func(pb *testing.PB) { + req := httptest.NewRequest("GET", "/index.html", nil) + for pb.Next() { + rr := httptest.NewRecorder() + server.ServeHTTP(rr, req) + } + }) +} + +// BenchmarkContentTypeSniffer measures the content type sniffer overhead +func BenchmarkContentTypeSniffer(b *testing.B) { + b.Run("SmallResponse", func(b *testing.B) { + data := []byte("Hello, World!") + for b.Loop() { + rr := httptest.NewRecorder() + sniffer := newContentTypeSniffer(rr) + _, _ = sniffer.Write(data) + _, _ = sniffer.complete() + } + }) + + b.Run("HTMLResponse", func(b *testing.B) { + data := []byte("Test

Hello

") + for b.Loop() { + rr := httptest.NewRecorder() + sniffer := newContentTypeSniffer(rr) + _, _ = sniffer.Write(data) + _, _ = sniffer.complete() + } + }) + + b.Run("LargeResponse", func(b *testing.B) { + data := make([]byte, 64*1024) // 64KB + for i := range data { + data[i] = byte(i % 256) + } + for b.Loop() { + rr := httptest.NewRecorder() + sniffer := newContentTypeSniffer(rr) + _, _ = sniffer.Write(data) + _, _ = sniffer.complete() + } + }) +} + +// BenchmarkServiceRouting measures service route matching performance +func BenchmarkServiceRouting(b *testing.B) { + logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelError + 1})) + + dummyHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + }) + + server, err := NewAssetServer(&Options{ + Handler: dummyHandler, + Logger: logger, + }) + if err != nil { + b.Fatal(err) + } + + // Attach multiple service routes + for i := 0; i < 10; i++ { + server.AttachServiceHandler(fmt.Sprintf("/api/v%d/", i), dummyHandler) + } + + b.Run("FirstRoute", func(b *testing.B) { + req := httptest.NewRequest("GET", "/api/v0/users", nil) + for b.Loop() { + rr := httptest.NewRecorder() + server.ServeHTTP(rr, req) + } + }) + + b.Run("LastRoute", func(b *testing.B) { + req := httptest.NewRequest("GET", "/api/v9/users", nil) + for b.Loop() { + rr := httptest.NewRecorder() + server.ServeHTTP(rr, req) + } + }) + + b.Run("NoMatch", func(b *testing.B) { + req := httptest.NewRequest("GET", "/static/app.js", nil) + for b.Loop() { + rr := httptest.NewRecorder() + server.ServeHTTP(rr, req) + } + }) +} diff --git a/v3/internal/assetserver/common.go b/v3/internal/assetserver/common.go index 6e1dfca17..a41139dff 100644 --- a/v3/internal/assetserver/common.go +++ b/v3/internal/assetserver/common.go @@ -1,10 +1,8 @@ package assetserver import ( - "bytes" "context" "fmt" - "io" "log/slog" "net/http" "strings" @@ -26,32 +24,23 @@ type assetServerLogger struct{} var assetServerLoggerKey assetServerLogger +// ServeFile writes the provided blob to rw as an HTTP 200 response, ensuring appropriate +// Content-Length and Content-Type headers are set. +// +// If the Content-Type header is not already present, ServeFile determines an appropriate +// MIME type from the filename and blob and sets the Content-Type header. It then writes +// the 200 status and the blob body to the response, returning any error encountered while +// writing the body. func ServeFile(rw http.ResponseWriter, filename string, blob []byte) error { header := rw.Header() header.Set(HeaderContentLength, fmt.Sprintf("%d", len(blob))) if mimeType := header.Get(HeaderContentType); mimeType == "" { mimeType = GetMimetype(filename, blob) header.Set(HeaderContentType, mimeType) - // Debug CSS serving with clear markers - if strings.HasSuffix(filename, ".css") { - fmt.Printf("\n🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨\n") - fmt.Printf("CSS FILE BEING SERVED:\n") - fmt.Printf(" Filename: %s\n", filename) - fmt.Printf(" MimeType: %s\n", mimeType) - fmt.Printf(" Size: %d bytes\n", len(blob)) - if len(blob) > 0 { - preview := string(blob) - if len(preview) > 100 { - preview = preview[:100] + "..." - } - fmt.Printf(" Preview: %s\n", preview) - } - fmt.Printf("🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨🎨\n\n") - } } rw.WriteHeader(http.StatusOK) - _, err := io.Copy(rw, bytes.NewReader(blob)) + _, err := rw.Write(blob) return err } @@ -74,4 +63,4 @@ func logError(ctx context.Context, message string, args ...interface{}) { if logger, _ := ctx.Value(assetServerLoggerKey).(*slog.Logger); logger != nil { logger.Error(message, args...) } -} +} \ No newline at end of file diff --git a/v3/internal/assetserver/content_type_sniffer.go b/v3/internal/assetserver/content_type_sniffer.go index e36db90e8..fd51a6101 100644 --- a/v3/internal/assetserver/content_type_sniffer.go +++ b/v3/internal/assetserver/content_type_sniffer.go @@ -4,20 +4,21 @@ import ( "net/http" ) +// newContentTypeSniffer creates a contentTypeSniffer that wraps the provided http.ResponseWriter. +// The returned sniffer does not allocate a close notification channel; it will be initialized lazily by CloseNotify. func newContentTypeSniffer(rw http.ResponseWriter) *contentTypeSniffer { return &contentTypeSniffer{ - rw: rw, - closeChannel: make(chan bool, 1), + rw: rw, } } type contentTypeSniffer struct { rw http.ResponseWriter prefix []byte + closeChannel chan bool // lazily allocated only if CloseNotify is called status int headerCommitted bool headerWritten bool - closeChannel chan bool } // Unwrap returns the wrapped [http.ResponseWriter] for use with [http.ResponseController]. @@ -118,12 +119,19 @@ func (rw *contentTypeSniffer) complete() (n int, err error) { } // CloseNotify implements the http.CloseNotifier interface. +// The channel is lazily allocated to avoid allocation overhead for requests +// that don't use this deprecated interface. func (rw *contentTypeSniffer) CloseNotify() <-chan bool { + if rw.closeChannel == nil { + rw.closeChannel = make(chan bool, 1) + } return rw.closeChannel } func (rw *contentTypeSniffer) closeClient() { - rw.closeChannel <- true + if rw.closeChannel != nil { + rw.closeChannel <- true + } } // Flush implements the http.Flusher interface. @@ -131,4 +139,4 @@ func (rw *contentTypeSniffer) Flush() { if f, ok := rw.rw.(http.Flusher); ok { f.Flush() } -} +} \ No newline at end of file diff --git a/v3/internal/assetserver/mimecache.go b/v3/internal/assetserver/mimecache.go index c43de519d..9034a4a0f 100644 --- a/v3/internal/assetserver/mimecache.go +++ b/v3/internal/assetserver/mimecache.go @@ -4,64 +4,113 @@ import ( "net/http" "path/filepath" "sync" - - "github.com/wailsapp/mimetype" ) var ( - mimeCache = map[string]string{} - mimeMutex sync.Mutex + // mimeCache uses sync.Map for better concurrent read performance + // since reads are far more common than writes + mimeCache sync.Map - // The list of builtin mime-types by extension as defined by - // the golang standard lib package "mime" - // The standard lib also takes into account mime type definitions from - // /etc files like '/etc/apache2/mime.types' but we want to have the - // same behaviour on all platforms and not depend on some external file. + // mimeTypesByExt maps file extensions to MIME types for common web formats. + // This approach is preferred over content-based detection because: + // 1. Extension-based lookup is O(1) vs O(n) content scanning + // 2. Web assets typically have correct extensions + // 3. stdlib's http.DetectContentType handles remaining cases adequately + // 4. Saves ~208KB binary size by not using github.com/wailsapp/mimetype mimeTypesByExt = map[string]string{ - ".avif": "image/avif", - ".css": "text/css; charset=utf-8", - ".gif": "image/gif", + // HTML ".htm": "text/html; charset=utf-8", ".html": "text/html; charset=utf-8", - ".jpeg": "image/jpeg", - ".jpg": "image/jpeg", - ".js": "text/javascript; charset=utf-8", + + // CSS/JS + ".css": "text/css; charset=utf-8", + ".js": "text/javascript; charset=utf-8", + ".mjs": "text/javascript; charset=utf-8", + ".ts": "application/x-typescript; charset=utf-8", + ".tsx": "application/x-typescript; charset=utf-8", + ".jsx": "text/javascript; charset=utf-8", + + // Data formats ".json": "application/json", - ".mjs": "text/javascript; charset=utf-8", - ".pdf": "application/pdf", - ".png": "image/png", - ".svg": "image/svg+xml", - ".wasm": "application/wasm", - ".webp": "image/webp", ".xml": "text/xml; charset=utf-8", + ".yaml": "text/yaml; charset=utf-8", + ".yml": "text/yaml; charset=utf-8", + ".toml": "text/toml; charset=utf-8", + + // Images + ".png": "image/png", + ".jpg": "image/jpeg", + ".jpeg": "image/jpeg", + ".gif": "image/gif", + ".webp": "image/webp", + ".avif": "image/avif", + ".svg": "image/svg+xml", + ".ico": "image/x-icon", + ".bmp": "image/bmp", + ".tiff": "image/tiff", + ".tif": "image/tiff", + + // Fonts + ".woff": "font/woff", + ".woff2": "font/woff2", + ".ttf": "font/ttf", + ".otf": "font/otf", + ".eot": "application/vnd.ms-fontobject", + + // Audio + ".mp3": "audio/mpeg", + ".wav": "audio/wav", + ".ogg": "audio/ogg", + ".m4a": "audio/mp4", + ".aac": "audio/aac", + ".flac": "audio/flac", + ".opus": "audio/opus", + + // Video + ".mp4": "video/mp4", + ".webm": "video/webm", + ".ogv": "video/ogg", + ".mov": "video/quicktime", + ".avi": "video/x-msvideo", + ".mkv": "video/x-matroska", + ".m4v": "video/mp4", + + // Documents + ".pdf": "application/pdf", + ".txt": "text/plain; charset=utf-8", + ".md": "text/markdown; charset=utf-8", + + // Archives + ".zip": "application/zip", + ".gz": "application/gzip", + ".tar": "application/x-tar", + + // WebAssembly + ".wasm": "application/wasm", + + // Source maps + ".map": "application/json", } ) +// "application/octet-stream". func GetMimetype(filename string, data []byte) string { - mimeMutex.Lock() - defer mimeMutex.Unlock() - - result := mimeTypesByExt[filepath.Ext(filename)] - if result != "" { + // Fast path: check extension map first (no lock needed) + if result := mimeTypesByExt[filepath.Ext(filename)]; result != "" { return result } - result = mimeCache[filename] - if result != "" { - return result - } - - detect := mimetype.Detect(data) - if detect == nil { - result = http.DetectContentType(data) - } else { - result = detect.String() + // Check cache (lock-free read) + if cached, ok := mimeCache.Load(filename); ok { + return cached.(string) } + // Slow path: use stdlib content-based detection and cache + result := http.DetectContentType(data) if result == "" { result = "application/octet-stream" } - mimeCache[filename] = result + mimeCache.Store(filename, result) return result -} +} \ No newline at end of file diff --git a/v3/internal/assetserver/mimetype_stdlib_test.go b/v3/internal/assetserver/mimetype_stdlib_test.go new file mode 100644 index 000000000..18a20131d --- /dev/null +++ b/v3/internal/assetserver/mimetype_stdlib_test.go @@ -0,0 +1,277 @@ +package assetserver + +import ( + "net/http" + "path/filepath" + "strings" + "testing" +) + +// TestMimeTypeDetection_WebFormats validates that extension-based detection +// plus stdlib fallback correctly handles all common web asset formats. +// This test ensures we can safely remove the github.com/wailsapp/mimetype dependency. +func TestMimeTypeDetection_WebFormats(t *testing.T) { + // webMimeTests covers all common web formats that Wails applications typically serve + webMimeTests := []struct { + name string + filename string + data []byte + wantPrefix string // Use prefix matching since charset may vary + }{ + // === TEXT FORMATS (extension-based) === + {"HTML file", "index.html", []byte(""), "text/html"}, + {"HTM file", "page.htm", []byte(""), "text/html"}, + {"CSS file", "styles.css", []byte(".class { color: red; }"), "text/css"}, + {"JavaScript file", "app.js", []byte("function test() {}"), "text/javascript"}, + {"ES Module file", "module.mjs", []byte("export default {}"), "text/javascript"}, + {"JSON file", "data.json", []byte(`{"key": "value"}`), "application/json"}, + {"XML file", "data.xml", []byte(""), "text/xml"}, + + // === IMAGE FORMATS (extension-based) === + {"PNG file", "image.png", pngData, "image/png"}, + {"JPEG file", "photo.jpg", jpegData, "image/jpeg"}, + {"JPEG alt ext", "photo.jpeg", jpegData, "image/jpeg"}, + {"GIF file", "anim.gif", gifData, "image/gif"}, + {"WebP file", "image.webp", webpData, "image/webp"}, + {"AVIF file", "image.avif", avifData, "image/avif"}, + {"SVG file", "icon.svg", []byte(""), "image/svg+xml"}, + {"PDF file", "doc.pdf", pdfData, "application/pdf"}, + + // === WASM (extension-based) === + {"WASM file", "app.wasm", wasmData, "application/wasm"}, + + // === FONT FORMATS (need detection or extension map) === + {"WOFF file", "font.woff", woffData, "font/woff"}, + {"WOFF2 file", "font.woff2", woff2Data, "font/woff2"}, + {"TTF file", "font.ttf", ttfData, "font/ttf"}, + {"OTF file", "font.otf", otfData, "font/otf"}, + {"EOT file", "font.eot", eotData, "application/vnd.ms-fontobject"}, + + // === AUDIO/VIDEO (common web formats) === + {"MP3 file", "audio.mp3", mp3Data, "audio/mpeg"}, + {"MP4 file", "video.mp4", mp4Data, "video/mp4"}, + {"WebM file", "video.webm", webmData, "video/webm"}, + {"OGG file", "audio.ogg", oggData, "audio/ogg"}, + + // === ARCHIVES (sometimes served by web apps) === + {"ZIP file", "archive.zip", zipData, "application/zip"}, + {"GZIP file", "data.gz", gzipData, "application/"}, + + // === SOURCE MAPS (common in dev mode) === + {"Source map", "app.js.map", []byte(`{"version":3}`), "application/json"}, + + // === ICO (favicon) === + {"ICO file", "favicon.ico", icoData, "image/"}, + + // === FALLBACK TESTS === + {"Unknown binary", "data.bin", []byte{0x00, 0x01, 0x02, 0x03}, "application/octet-stream"}, + {"Plain text (no ext)", "readme", []byte("Hello World"), "text/plain"}, + } + + for _, tt := range webMimeTests { + t.Run(tt.name, func(t *testing.T) { + got := getMimeTypeStdlib(tt.filename, tt.data) + if !hasPrefix(got, tt.wantPrefix) { + t.Errorf("getMimeTypeStdlib(%q) = %q, want prefix %q", tt.filename, got, tt.wantPrefix) + } + }) + } +} + +// getMimeTypeStdlib is the proposed replacement that uses only stdlib +func getMimeTypeStdlib(filename string, data []byte) string { + // Fast path: check extension map first + if result := extMimeTypes[filepath.Ext(filename)]; result != "" { + return result + } + + // Fallback to stdlib content-based detection + result := http.DetectContentType(data) + if result == "" { + result = "application/octet-stream" + } + return result +} + +// extMimeTypes is an expanded map covering all common web formats +// This replaces the need for the mimetype library for web assets +var extMimeTypes = map[string]string{ + // HTML + ".htm": "text/html; charset=utf-8", + ".html": "text/html; charset=utf-8", + + // CSS/JS + ".css": "text/css; charset=utf-8", + ".js": "text/javascript; charset=utf-8", + ".mjs": "text/javascript; charset=utf-8", + ".ts": "application/x-typescript; charset=utf-8", + ".tsx": "application/x-typescript; charset=utf-8", + ".jsx": "text/javascript; charset=utf-8", + + // Data formats + ".json": "application/json", + ".xml": "text/xml; charset=utf-8", + ".yaml": "text/yaml; charset=utf-8", + ".yml": "text/yaml; charset=utf-8", + ".toml": "text/toml; charset=utf-8", + + // Images + ".png": "image/png", + ".jpg": "image/jpeg", + ".jpeg": "image/jpeg", + ".gif": "image/gif", + ".webp": "image/webp", + ".avif": "image/avif", + ".svg": "image/svg+xml", + ".ico": "image/x-icon", + ".bmp": "image/bmp", + ".tiff": "image/tiff", + ".tif": "image/tiff", + + // Fonts + ".woff": "font/woff", + ".woff2": "font/woff2", + ".ttf": "font/ttf", + ".otf": "font/otf", + ".eot": "application/vnd.ms-fontobject", + + // Audio + ".mp3": "audio/mpeg", + ".wav": "audio/wav", + ".ogg": "audio/ogg", + ".m4a": "audio/mp4", + ".aac": "audio/aac", + ".flac": "audio/flac", + ".opus": "audio/opus", + + // Video + ".mp4": "video/mp4", + ".webm": "video/webm", + ".ogv": "video/ogg", + ".mov": "video/quicktime", + ".avi": "video/x-msvideo", + ".mkv": "video/x-matroska", + ".m4v": "video/mp4", + + // Documents + ".pdf": "application/pdf", + ".txt": "text/plain; charset=utf-8", + ".md": "text/markdown; charset=utf-8", + + // Archives + ".zip": "application/zip", + ".gz": "application/gzip", + ".tar": "application/x-tar", + + // WebAssembly + ".wasm": "application/wasm", + + // Source maps + ".map": "application/json", +} + +func hasPrefix(s, prefix string) bool { + return len(s) >= len(prefix) && s[:len(prefix)] == prefix +} + +// Magic bytes for various formats +var ( + // PNG: 89 50 4E 47 0D 0A 1A 0A + pngData = []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D} + + // JPEG: FF D8 FF + jpegData = []byte{0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46} + + // GIF: 47 49 46 38 + gifData = []byte{0x47, 0x49, 0x46, 0x38, 0x39, 0x61} + + // WebP: 52 49 46 46 ... 57 45 42 50 + webpData = []byte{0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50} + + // AVIF: ... ftypavif or ftypavis + avifData = []byte{0x00, 0x00, 0x00, 0x1C, 0x66, 0x74, 0x79, 0x70, 0x61, 0x76, 0x69, 0x66} + + // PDF: 25 50 44 46 + pdfData = []byte{0x25, 0x50, 0x44, 0x46, 0x2D, 0x31, 0x2E} + + // WASM: 00 61 73 6D + wasmData = []byte{0x00, 0x61, 0x73, 0x6D, 0x01, 0x00, 0x00, 0x00} + + // WOFF: 77 4F 46 46 + woffData = []byte{0x77, 0x4F, 0x46, 0x46, 0x00, 0x01, 0x00, 0x00} + + // WOFF2: 77 4F 46 32 + woff2Data = []byte{0x77, 0x4F, 0x46, 0x32, 0x00, 0x01, 0x00, 0x00} + + // TTF: 00 01 00 00 + ttfData = []byte{0x00, 0x01, 0x00, 0x00, 0x00} + + // OTF: 4F 54 54 4F (OTTO) + otfData = []byte{0x4F, 0x54, 0x54, 0x4F, 0x00} + + // EOT: varies, but starts with size bytes then magic + eotData = []byte{0x00, 0x00, 0x01, 0x00, 0x00, 0x00} + + // MP3: FF FB or FF FA or ID3 + mp3Data = []byte{0xFF, 0xFB, 0x90, 0x00} + + // MP4: ... ftyp + mp4Data = []byte{0x00, 0x00, 0x00, 0x1C, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6F, 0x6D} + + // WebM: 1A 45 DF A3 (EBML header) + webmData = []byte{0x1A, 0x45, 0xDF, 0xA3} + + // OGG: 4F 67 67 53 + oggData = []byte{0x4F, 0x67, 0x67, 0x53, 0x00, 0x02} + + // ZIP: 50 4B 03 04 + zipData = []byte{0x50, 0x4B, 0x03, 0x04} + + // GZIP: 1F 8B + gzipData = []byte{0x1F, 0x8B, 0x08} + + // ICO: 00 00 01 00 + icoData = []byte{0x00, 0x00, 0x01, 0x00, 0x01, 0x00} +) + +// TestMimeTypeExtensionMapCompleteness checks that all extensions in the +// original mimeTypesByExt are covered by the expanded extMimeTypes +func TestMimeTypeExtensionMapCompleteness(t *testing.T) { + for ext, mime := range mimeTypesByExt { + if newMime, ok := extMimeTypes[ext]; !ok { + t.Errorf("extension %q missing from extMimeTypes (was: %q)", ext, mime) + } else if newMime != mime { + // Allow differences as long as they're equivalent (compare base MIME type) + mimeBase := mime + if idx := strings.Index(mime, ";"); idx > 0 { + mimeBase = mime[:idx] + } + if !hasPrefix(newMime, mimeBase) { + t.Logf("extension %q changed: %q -> %q (verify this is correct)", ext, mime, newMime) + } + } + } +} + +// BenchmarkMimeType_StdlibOnly benchmarks the stdlib-only implementation +func BenchmarkMimeType_StdlibOnly(b *testing.B) { + testCases := []struct { + name string + filename string + data []byte + }{ + {"ExtHit_JS", "app.js", []byte("function() {}")}, + {"ExtHit_CSS", "styles.css", []byte(".class { }")}, + {"ExtHit_PNG", "image.png", pngData}, + {"ExtMiss_Binary", "data.bin", []byte{0x00, 0x01, 0x02}}, + {"ContentDetect_PNG", "unknown", pngData}, + } + + for _, tc := range testCases { + b.Run(tc.name, func(b *testing.B) { + for b.Loop() { + _ = getMimeTypeStdlib(tc.filename, tc.data) + } + }) + } +} diff --git a/v3/internal/assetserver/webview/request_darwin.go b/v3/internal/assetserver/webview/request_darwin.go index 275e0d38d..2b961d781 100644 --- a/v3/internal/assetserver/webview/request_darwin.go +++ b/v3/internal/assetserver/webview/request_darwin.go @@ -109,12 +109,13 @@ import "C" import ( "bytes" - "encoding/json" "errors" "fmt" "io" "net/http" "unsafe" + + json "github.com/goccy/go-json" ) // NewRequest creates as new WebViewRequest based on a pointer to an `id` diff --git a/v3/internal/assetserver/webview/request_ios.go b/v3/internal/assetserver/webview/request_ios.go index 28e1c31ac..1a1941c7e 100644 --- a/v3/internal/assetserver/webview/request_ios.go +++ b/v3/internal/assetserver/webview/request_ios.go @@ -107,12 +107,13 @@ import "C" import ( "bytes" - "encoding/json" "errors" "fmt" "io" "net/http" "unsafe" + + json "github.com/goccy/go-json" ) // NewRequest creates as new WebViewRequest based on a pointer to an `id` diff --git a/v3/internal/assetserver/webview/responsewriter_darwin.go b/v3/internal/assetserver/webview/responsewriter_darwin.go index b6e2f5ef4..4bac699d6 100644 --- a/v3/internal/assetserver/webview/responsewriter_darwin.go +++ b/v3/internal/assetserver/webview/responsewriter_darwin.go @@ -68,9 +68,10 @@ static bool URLSchemeTaskDidReceiveResponse(void *wkUrlSchemeTask, int statusCod import "C" import ( - "encoding/json" "net/http" "unsafe" + + json "github.com/goccy/go-json" ) var _ ResponseWriter = &responseWriter{} diff --git a/v3/internal/assetserver/webview/responsewriter_ios.go b/v3/internal/assetserver/webview/responsewriter_ios.go index 6dc56bb81..a6284b804 100644 --- a/v3/internal/assetserver/webview/responsewriter_ios.go +++ b/v3/internal/assetserver/webview/responsewriter_ios.go @@ -68,11 +68,12 @@ static bool URLSchemeTaskDidReceiveResponse(void *wkUrlSchemeTask, int statusCod import "C" import ( - "encoding/json" "fmt" "net/http" "strings" "unsafe" + + json "github.com/goccy/go-json" ) var _ ResponseWriter = &responseWriter{} diff --git a/v3/internal/capabilities/capabilities.go b/v3/internal/capabilities/capabilities.go index af9428bb2..1af25e91a 100644 --- a/v3/internal/capabilities/capabilities.go +++ b/v3/internal/capabilities/capabilities.go @@ -1,6 +1,6 @@ package capabilities -import "encoding/json" +import json "github.com/goccy/go-json" type Capabilities struct { HasNativeDrag bool diff --git a/v3/internal/fileexplorer/desktopfile.go b/v3/internal/fileexplorer/desktopfile.go new file mode 100644 index 000000000..4cdd0af04 --- /dev/null +++ b/v3/internal/fileexplorer/desktopfile.go @@ -0,0 +1,96 @@ +package fileexplorer + +import ( + "bufio" + "io" + "os" + "strings" +) + +// DesktopEntry represents a parsed .desktop file's [Desktop Entry] section. +// This is a minimal parser that only extracts the fields we need, +// replacing the full gopkg.in/ini.v1 dependency (~34KB + 68 transitive deps). +type DesktopEntry struct { + Exec string +} + +// ParseDesktopFile parses a .desktop file and returns the Desktop Entry section. +// It follows the Desktop Entry Specification: +// ParseDesktopFile parses the `[Desktop Entry]` section of the desktop file at path and returns a DesktopEntry. +// It returns an error if the file cannot be opened or if parsing the file fails. +func ParseDesktopFile(path string) (*DesktopEntry, error) { + f, err := os.Open(path) + if err != nil { + return nil, err + } + defer f.Close() + return ParseDesktopReader(f) +} + +// ParseDesktopReader parses the [Desktop Entry] section of a .desktop file from r and extracts the Exec value. +// It ignores empty lines and lines starting with '#', treats section names as case-sensitive, and stops parsing after leaving the [Desktop Entry] section. +// The returned *DesktopEntry has Exec set to the exact value of the Exec key if present (whitespace preserved). +// An error is returned if reading from r fails. +func ParseDesktopReader(r io.Reader) (*DesktopEntry, error) { + scanner := bufio.NewScanner(r) + entry := &DesktopEntry{} + + inDesktopEntry := false + + for scanner.Scan() { + line := scanner.Text() + + // Skip empty lines + if len(line) == 0 { + continue + } + + // Skip comments (# at start of line) + if line[0] == '#' { + continue + } + + // Handle section headers + if line[0] == '[' { + // Check if this is the [Desktop Entry] section + // The spec says section names are case-sensitive + trimmed := strings.TrimSpace(line) + if trimmed == "[Desktop Entry]" { + inDesktopEntry = true + } else if inDesktopEntry { + // We've left the [Desktop Entry] section + // (e.g., entering [Desktop Action new-window]) + // We already have what we need, so we can stop + break + } + continue + } + + // Only process key=value pairs in [Desktop Entry] section + if !inDesktopEntry { + continue + } + + // Parse key=value (spec says no spaces around =, but be lenient) + eqIdx := strings.Index(line, "=") + if eqIdx == -1 { + continue + } + + key := strings.TrimSpace(line[:eqIdx]) + value := line[eqIdx+1:] // Don't trim value - preserve intentional whitespace + + // We only need the Exec key + // Per spec, keys are case-sensitive and Exec is always "Exec" + if key == "Exec" { + entry.Exec = value + // Continue parsing in case there are multiple Exec lines (shouldn't happen but be safe) + } + } + + if err := scanner.Err(); err != nil { + return nil, err + } + + return entry, nil +} \ No newline at end of file diff --git a/v3/internal/fileexplorer/desktopfile_test.go b/v3/internal/fileexplorer/desktopfile_test.go new file mode 100644 index 000000000..feac60fcb --- /dev/null +++ b/v3/internal/fileexplorer/desktopfile_test.go @@ -0,0 +1,532 @@ +package fileexplorer + +import ( + "strings" + "testing" +) + +func TestParseDesktopReader(t *testing.T) { + tests := []struct { + name string + input string + wantExec string + wantErr bool + }{ + { + name: "simple desktop file", + input: `[Desktop Entry] +Name=Files +Exec=nautilus %U +Icon=org.gnome.Nautilus +`, + wantExec: "nautilus %U", + }, + { + name: "exec with full path", + input: `[Desktop Entry] +Name=1Password +Exec=/opt/1Password/1password %U +`, + wantExec: "/opt/1Password/1password %U", + }, + { + name: "exec without arguments", + input: `[Desktop Entry] +Name=Btop +Exec=btop +Terminal=true +`, + wantExec: "btop", + }, + { + name: "exec with spaces in path", + input: `[Desktop Entry] +Name=My App +Exec="/path/with spaces/myapp" %f +`, + wantExec: `"/path/with spaces/myapp" %f`, + }, + { + name: "comments are ignored", + input: `# This is a comment +[Desktop Entry] +# Another comment +Name=Files +Exec=nautilus +# Comment after +`, + wantExec: "nautilus", + }, + { + name: "empty lines are ignored", + input: ` + +[Desktop Entry] + +Name=Files + +Exec=nautilus + +`, + wantExec: "nautilus", + }, + { + name: "key before section is ignored", + input: `Exec=ignored +[Desktop Entry] +Exec=nautilus +`, + wantExec: "nautilus", + }, + { + name: "other sections after Desktop Entry are ignored", + input: `[Desktop Entry] +Exec=nautilus --new-window %U +Icon=nautilus + +[Desktop Action new-window] +Name=New Window +Exec=nautilus --new-window +`, + wantExec: "nautilus --new-window %U", + }, + { + name: "section before Desktop Entry is ignored", + input: `[Some Other Section] +Exec=ignored + +[Desktop Entry] +Exec=nautilus +`, + wantExec: "nautilus", + }, + { + name: "case sensitive section name", + input: `[desktop entry] +Exec=ignored + +[Desktop Entry] +Exec=correct +`, + wantExec: "correct", + }, + { + name: "case sensitive key name", + input: `[Desktop Entry] +exec=ignored +EXEC=also ignored +Exec=correct +`, + wantExec: "correct", + }, + { + name: "value with equals sign", + input: `[Desktop Entry] +Exec=env VAR=value myapp +`, + wantExec: "env VAR=value myapp", + }, + { + name: "value with multiple equals signs", + input: `[Desktop Entry] +Exec=env A=1 B=2 C=3 myapp +`, + wantExec: "env A=1 B=2 C=3 myapp", + }, + { + name: "localized keys are separate", + input: `[Desktop Entry] +Name[en]=Files +Name=Default Files +Exec[en]=ignored +Exec=nautilus +`, + wantExec: "nautilus", + }, + { + name: "whitespace in section header", + input: `[Desktop Entry] +Exec=nautilus +`, + wantExec: "nautilus", + }, + { + name: "no exec key", + input: `[Desktop Entry] +Name=Files +Icon=nautilus +`, + wantExec: "", + }, + { + name: "empty file", + input: ``, + wantExec: "", + }, + { + name: "only comments", + input: `# Comment 1 +# Comment 2 +`, + wantExec: "", + }, + { + name: "no Desktop Entry section", + input: `[Other Section] +Exec=ignored +`, + wantExec: "", + }, + { + name: "real nautilus desktop file structure", + input: `[Desktop Entry] +Name[en_CA]=Files +Name[en_GB]=Files +Name=Files +Comment=Access and organize files +Keywords=folder;manager;explore;disk;filesystem;nautilus; +Exec=nautilus --new-window %U +Icon=org.gnome.Nautilus +Terminal=false +Type=Application +DBusActivatable=true +StartupNotify=true +Categories=GNOME;GTK;Utility;Core;FileManager; +MimeType=inode/directory;application/x-7z-compressed; +X-GNOME-UsesNotifications=true +Actions=new-window; + +[Desktop Action new-window] +Name=New Window +Exec=nautilus --new-window +`, + wantExec: "nautilus --new-window %U", + }, + { + name: "thunar style", + input: `[Desktop Entry] +Version=1.0 +Name=Thunar File Manager +Exec=thunar %F +Icon=Thunar +Type=Application +Categories=System;FileTools;FileManager; +`, + wantExec: "thunar %F", + }, + { + name: "dolphin style", + input: `[Desktop Entry] +Type=Application +Exec=dolphin %u +Icon=system-file-manager +Name=Dolphin +GenericName=File Manager +`, + wantExec: "dolphin %u", + }, + { + name: "pcmanfm style", + input: `[Desktop Entry] +Type=Application +Name=PCManFM +GenericName=File Manager +Exec=pcmanfm %U +Icon=system-file-manager +`, + wantExec: "pcmanfm %U", + }, + { + name: "exec with environment variable", + input: `[Desktop Entry] +Exec=env GDK_BACKEND=x11 nautilus %U +`, + wantExec: "env GDK_BACKEND=x11 nautilus %U", + }, + { + name: "trailing whitespace in value preserved", + input: `[Desktop Entry] +Exec=nautilus +`, + wantExec: "nautilus ", + }, + { + name: "leading whitespace in key", + input: `[Desktop Entry] + Exec=nautilus +`, + wantExec: "nautilus", + }, + { + name: "space around equals", + input: `[Desktop Entry] +Exec = nautilus +`, + wantExec: " nautilus", // We trim the key, value starts after = + }, + { + name: "line without equals is ignored", + input: `[Desktop Entry] +InvalidLine +Exec=nautilus +AnotherInvalidLine +`, + wantExec: "nautilus", + }, + { + name: "UTF-8 in exec path", + input: `[Desktop Entry] +Exec=/usr/bin/文件管理器 %U +`, + wantExec: "/usr/bin/文件管理器 %U", + }, + { + name: "special characters in exec", + input: `[Desktop Entry] +Exec=sh -c "echo 'hello world' && nautilus %U" +`, + wantExec: `sh -c "echo 'hello world' && nautilus %U"`, + }, + { + name: "multiple Desktop Entry sections (invalid file, last value wins)", + input: `[Desktop Entry] +Exec=first + +[Desktop Entry] +Exec=second +`, + wantExec: "second", // Invalid file, but we handle it gracefully + }, + { + name: "very long exec line", + input: `[Desktop Entry] +Exec=` + strings.Repeat("a", 1000) + ` +`, + wantExec: strings.Repeat("a", 1000), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + entry, err := ParseDesktopReader(strings.NewReader(tt.input)) + if (err != nil) != tt.wantErr { + t.Errorf("ParseDesktopReader() error = %v, wantErr %v", err, tt.wantErr) + return + } + if err != nil { + return + } + if entry.Exec != tt.wantExec { + t.Errorf("ParseDesktopReader() Exec = %q, want %q", entry.Exec, tt.wantExec) + } + }) + } +} + +func TestParseDesktopReader_LineScanning(t *testing.T) { + // Test that we handle lines at the scanner's limit (64KB default) + // bufio.Scanner returns an error for lines > 64KB, which is acceptable + // since real .desktop files never have lines that long + + t.Run("line at buffer limit returns error", func(t *testing.T) { + // Create a line that exceeds the buffer size (64KB) + longValue := strings.Repeat("x", 65536) + input := "[Desktop Entry]\nExec=" + longValue + "\n" + + _, err := ParseDesktopReader(strings.NewReader(input)) + if err == nil { + t.Error("Expected error for line exceeding buffer size, got nil") + } + }) + + t.Run("line under buffer limit works", func(t *testing.T) { + // Create a line that's under the limit (should work fine) + longValue := strings.Repeat("x", 60000) + input := "[Desktop Entry]\nExec=" + longValue + "\n" + + entry, err := ParseDesktopReader(strings.NewReader(input)) + if err != nil { + t.Errorf("Unexpected error for long but valid line: %v", err) + return + } + if entry.Exec != longValue { + t.Errorf("Long line not parsed correctly, got length %d, want %d", len(entry.Exec), len(longValue)) + } + }) +} + +func TestParseDesktopReader_RealWorldFiles(t *testing.T) { + // These are actual .desktop file contents from real systems + realWorldTests := []struct { + name string + content string + wantExec string + }{ + { + name: "GNOME Nautilus 43.x", + content: `[Desktop Entry] +Name=Files +Comment=Access and organize files +Keywords=folder;manager;explore;disk;filesystem;nautilus; +Exec=nautilus --new-window %U +Icon=org.gnome.Nautilus +Terminal=false +Type=Application +DBusActivatable=true +StartupNotify=true +Categories=GNOME;GTK;Utility;Core;FileManager; +MimeType=inode/directory;application/x-7z-compressed; +Actions=new-window; + +[Desktop Action new-window] +Name=New Window +Exec=nautilus --new-window`, + wantExec: "nautilus --new-window %U", + }, + { + name: "KDE Dolphin", + content: `[Desktop Entry] +Type=Application +Exec=dolphin %u +Icon=system-file-manager +Terminal=false +InitialPreference=9 +Name=Dolphin +GenericName=File Manager +MimeType=inode/directory; +Categories=Qt;KDE;System;FileTools;FileManager; +Actions=new-window; + +[Desktop Action new-window] +Name=Open a New Window +Exec=dolphin %u`, + wantExec: "dolphin %u", + }, + { + name: "Thunar", + content: `[Desktop Entry] +Version=1.0 +Name=Thunar File Manager +GenericName=File Manager +Comment=Browse the filesystem with the file manager +Exec=thunar %F +Icon=Thunar +Terminal=false +StartupNotify=true +Type=Application +Categories=System;FileTools;FileManager; +`, + wantExec: "thunar %F", + }, + { + name: "PCManFM", + content: `[Desktop Entry] +Type=Application +Name=PCManFM +GenericName=File Manager +Comment=Browse the file system +Exec=pcmanfm %U +Icon=system-file-manager +Terminal=false +StartupNotify=true +Categories=Utility;FileManager;`, + wantExec: "pcmanfm %U", + }, + { + name: "Caja (MATE)", + content: `[Desktop Entry] +Name=Files +Comment=Access and organize files +Exec=caja %U +Icon=system-file-manager +Terminal=false +Type=Application +Categories=MATE;System;FileManager; +StartupNotify=true`, + wantExec: "caja %U", + }, + { + name: "Nemo (Cinnamon)", + content: `[Desktop Entry] +Name=Files +Comment=Access and organize files +Exec=nemo %U +Icon=folder +Terminal=false +Type=Application +StartupNotify=true +Categories=GNOME;GTK;Utility;Core; +MimeType=inode/directory;`, + wantExec: "nemo %U", + }, + } + + for _, tt := range realWorldTests { + t.Run(tt.name, func(t *testing.T) { + entry, err := ParseDesktopReader(strings.NewReader(tt.content)) + if err != nil { + t.Fatalf("ParseDesktopReader() error = %v", err) + } + if entry.Exec != tt.wantExec { + t.Errorf("ParseDesktopReader() Exec = %q, want %q", entry.Exec, tt.wantExec) + } + }) + } +} + +// BenchmarkParseDesktopReader measures parsing performance +func BenchmarkParseDesktopReader(b *testing.B) { + // Real Nautilus .desktop file content + content := `[Desktop Entry] +Name=Files +Comment=Access and organize files +Keywords=folder;manager;explore;disk;filesystem;nautilus; +Exec=nautilus --new-window %U +Icon=org.gnome.Nautilus +Terminal=false +Type=Application +DBusActivatable=true +StartupNotify=true +Categories=GNOME;GTK;Utility;Core;FileManager; +MimeType=inode/directory;application/x-7z-compressed; +Actions=new-window; + +[Desktop Action new-window] +Name=New Window +Exec=nautilus --new-window +` + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := ParseDesktopReader(strings.NewReader(content)) + if err != nil { + b.Fatal(err) + } + } +} + +// BenchmarkParseDesktopReader_Large tests parsing a file with many localized entries +func BenchmarkParseDesktopReader_Large(b *testing.B) { + // Simulate a desktop file with many localized Name entries (like Nautilus) + var sb strings.Builder + sb.WriteString("[Desktop Entry]\n") + for i := 0; i < 100; i++ { + sb.WriteString("Name[lang") + sb.WriteString(strings.Repeat("x", 5)) + sb.WriteString("]=Localized Name\n") + } + sb.WriteString("Exec=nautilus %U\n") + sb.WriteString("[Desktop Action new-window]\n") + sb.WriteString("Name=New Window\n") + sb.WriteString("Exec=nautilus\n") + + content := sb.String() + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := ParseDesktopReader(strings.NewReader(content)) + if err != nil { + b.Fatal(err) + } + } +} diff --git a/v3/internal/fileexplorer/fileexplorer_linux.go b/v3/internal/fileexplorer/fileexplorer_linux.go index cd0201dfc..bf7e070a7 100644 --- a/v3/internal/fileexplorer/fileexplorer_linux.go +++ b/v3/internal/fileexplorer/fileexplorer_linux.go @@ -11,10 +11,9 @@ import ( "path/filepath" "strings" "syscall" - - ini "gopkg.in/ini.v1" ) +// when possible; the fallback method does not support selecting a file. func explorerBinArgs(path string, selectFile bool) (string, []string, error) { // Map of field codes to their replacements var fieldCodes = map[string]string{ @@ -38,22 +37,22 @@ func explorerBinArgs(path string, selectFile bool) (string, []string, error) { return fallbackExplorerBinArgs(path, selectFile) } - desktopFile, err := findDesktopFile(strings.TrimSpace((buf.String()))) + desktopFilePath, err := findDesktopFile(strings.TrimSpace((buf.String()))) if err != nil { return fallbackExplorerBinArgs(path, selectFile) } - cfg, err := ini.Load(desktopFile) + entry, err := ParseDesktopFile(desktopFilePath) if err != nil { // Opting to fallback rather than fail return fallbackExplorerBinArgs(path, selectFile) } - exec := cfg.Section("Desktop Entry").Key("Exec").String() + execCmd := entry.Exec for fieldCode, replacement := range fieldCodes { - exec = strings.ReplaceAll(exec, fieldCode, replacement) + execCmd = strings.ReplaceAll(execCmd, fieldCode, replacement) } - args := strings.Fields(exec) + args := strings.Fields(execCmd) if !strings.Contains(strings.Join(args, " "), path) { args = append(args, path) } @@ -111,4 +110,4 @@ func findDesktopFile(xdgFileName string) (string, error) { } err := fmt.Errorf("desktop file not found: %s", xdgFileName) return "", err -} +} \ No newline at end of file diff --git a/v3/internal/runtime/runtime.go b/v3/internal/runtime/runtime.go index 0c08108df..04b29fd4d 100644 --- a/v3/internal/runtime/runtime.go +++ b/v3/internal/runtime/runtime.go @@ -1,8 +1,9 @@ package runtime import ( - "encoding/json" "fmt" + + json "github.com/goccy/go-json" ) var runtimeInit = `window._wails=window._wails||{};window.wails=window.wails||{};` diff --git a/v3/internal/sliceutil/sliceutil.go b/v3/internal/sliceutil/sliceutil.go new file mode 100644 index 000000000..5023d6110 --- /dev/null +++ b/v3/internal/sliceutil/sliceutil.go @@ -0,0 +1,39 @@ +// Package sliceutil provides generic utility functions not available in stdlib. +// For most slice operations, use the standard library "slices" package directly. +// This package only contains functions that have no stdlib equivalent. +package sliceutil + +// Unique returns a new slice with duplicate elements removed. +// Preserves the order of first occurrence. +// The original slice is not modified. +// +// Unique returns a new slice containing the first occurrence of each element from the input slice, preserving their original order. +// If the input slice is nil, Unique returns nil. +// The original slice is not modified. +func Unique[T comparable](slice []T) []T { + if slice == nil { + return nil + } + seen := make(map[T]struct{}, len(slice)) + result := make([]T, 0, len(slice)) + for _, v := range slice { + if _, ok := seen[v]; !ok { + seen[v] = struct{}{} + result = append(result, v) + } + } + return result +} + +// FindMapKey returns the first key in map m whose value equals val. +// FindMapKey returns the first key in m whose value equals val. +// If no such key exists it returns the zero value of K and false. If multiple keys map to val, the returned key depends on Go's map iteration order. +func FindMapKey[K comparable, V comparable](m map[K]V, val V) (K, bool) { + for k, v := range m { + if v == val { + return k, true + } + } + var zero K + return zero, false +} \ No newline at end of file diff --git a/v3/internal/sliceutil/sliceutil_test.go b/v3/internal/sliceutil/sliceutil_test.go new file mode 100644 index 000000000..1b10cc123 --- /dev/null +++ b/v3/internal/sliceutil/sliceutil_test.go @@ -0,0 +1,172 @@ +package sliceutil + +import ( + "reflect" + "testing" +) + +func TestUnique(t *testing.T) { + tests := []struct { + name string + slice []int + want []int + }{ + { + name: "no duplicates", + slice: []int{1, 2, 3}, + want: []int{1, 2, 3}, + }, + { + name: "with duplicates", + slice: []int{1, 2, 2, 3, 3, 3}, + want: []int{1, 2, 3}, + }, + { + name: "all duplicates", + slice: []int{1, 1, 1}, + want: []int{1}, + }, + { + name: "preserves order", + slice: []int{3, 1, 2, 1, 3, 2}, + want: []int{3, 1, 2}, + }, + { + name: "single element", + slice: []int{1}, + want: []int{1}, + }, + { + name: "empty slice", + slice: []int{}, + want: []int{}, + }, + { + name: "nil slice", + slice: nil, + want: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := Unique(tt.slice) + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("Unique() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestUnique_Strings(t *testing.T) { + slice := []string{"a", "b", "a", "c", "b"} + got := Unique(slice) + want := []string{"a", "b", "c"} + if !reflect.DeepEqual(got, want) { + t.Errorf("Unique() = %v, want %v", got, want) + } +} + +func TestUnique_DoesNotModifyOriginal(t *testing.T) { + original := []int{1, 2, 2, 3} + originalCopy := make([]int, len(original)) + copy(originalCopy, original) + + _ = Unique(original) + + if !reflect.DeepEqual(original, originalCopy) { + t.Errorf("Unique() modified original slice: got %v, want %v", original, originalCopy) + } +} + +func TestFindMapKey(t *testing.T) { + tests := []struct { + name string + m map[string]int + val int + wantKey string + wantFound bool + }{ + { + name: "find existing value", + m: map[string]int{"a": 1, "b": 2, "c": 3}, + val: 2, + wantKey: "b", + wantFound: true, + }, + { + name: "value not found", + m: map[string]int{"a": 1, "b": 2}, + val: 3, + wantKey: "", + wantFound: false, + }, + { + name: "empty map", + m: map[string]int{}, + val: 1, + wantKey: "", + wantFound: false, + }, + { + name: "nil map", + m: nil, + val: 1, + wantKey: "", + wantFound: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + gotKey, gotFound := FindMapKey(tt.m, tt.val) + if gotFound != tt.wantFound { + t.Errorf("FindMapKey() found = %v, want %v", gotFound, tt.wantFound) + } + if gotFound && gotKey != tt.wantKey { + t.Errorf("FindMapKey() key = %v, want %v", gotKey, tt.wantKey) + } + }) + } +} + +func TestFindMapKey_DuplicateValues(t *testing.T) { + // When multiple keys have the same value, any matching key is acceptable + m := map[string]int{"a": 1, "b": 1, "c": 2} + key, found := FindMapKey(m, 1) + if !found { + t.Error("FindMapKey() should find a key") + } + if key != "a" && key != "b" { + t.Errorf("FindMapKey() = %v, want 'a' or 'b'", key) + } +} + +func TestFindMapKey_IntKeys(t *testing.T) { + m := map[int]string{1: "one", 2: "two", 3: "three"} + key, found := FindMapKey(m, "two") + if !found || key != 2 { + t.Errorf("FindMapKey() = (%v, %v), want (2, true)", key, found) + } +} + +// Benchmarks + +func BenchmarkUnique(b *testing.B) { + slice := []int{1, 2, 3, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 10} + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Unique(slice) + } +} + +func BenchmarkFindMapKey(b *testing.B) { + m := make(map[string]int) + for i := 0; i < 100; i++ { + m[string(rune('a'+i))] = i + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindMapKey(m, 50) + } +} diff --git a/v3/pkg/application/application_android.go b/v3/pkg/application/application_android.go index 46a45fc17..e5da744eb 100644 --- a/v3/pkg/application/application_android.go +++ b/v3/pkg/application/application_android.go @@ -139,7 +139,6 @@ static void executeJavaScriptOnBridge(const char* js) { import "C" import ( - "encoding/json" "fmt" "io" "net/http" @@ -149,6 +148,8 @@ import ( "time" "unsafe" + json "github.com/goccy/go-json" + "github.com/wailsapp/wails/v3/internal/runtime" ) diff --git a/v3/pkg/application/application_android_nocgo.go b/v3/pkg/application/application_android_nocgo.go index cd897031e..cb31203dd 100644 --- a/v3/pkg/application/application_android_nocgo.go +++ b/v3/pkg/application/application_android_nocgo.go @@ -3,10 +3,11 @@ package application import ( - "encoding/json" "fmt" "sync" "unsafe" + + json "github.com/goccy/go-json" ) var ( diff --git a/v3/pkg/application/application_darwin.go b/v3/pkg/application/application_darwin.go index b70f98870..7393035c3 100644 --- a/v3/pkg/application/application_darwin.go +++ b/v3/pkg/application/application_darwin.go @@ -196,12 +196,12 @@ static void startSingleInstanceListener(const char *uniqueID) { */ import "C" import ( - "encoding/json" "unsafe" - "github.com/wailsapp/wails/v3/internal/operatingsystem" + json "github.com/goccy/go-json" "github.com/wailsapp/wails/v3/internal/assetserver/webview" + "github.com/wailsapp/wails/v3/internal/operatingsystem" "github.com/wailsapp/wails/v3/pkg/events" ) diff --git a/v3/pkg/application/application_ios.go b/v3/pkg/application/application_ios.go index 8965f2afb..7b0da7eee 100644 --- a/v3/pkg/application/application_ios.go +++ b/v3/pkg/application/application_ios.go @@ -15,12 +15,13 @@ package application import "C" import ( - "encoding/json" "fmt" "strings" "time" "unsafe" + json "github.com/goccy/go-json" + "github.com/wailsapp/wails/v3/internal/assetserver/webview" "github.com/wailsapp/wails/v3/pkg/events" ) @@ -107,6 +108,12 @@ type iosApp struct { parent *App } +// newPlatformApp creates an iosApp for the provided App and applies iOS-specific +// configuration derived from app.options. It sets input accessory visibility, +// scrolling/bounce/indicator behavior, navigation gestures, link preview, +// media playback, inspector, user agent strings, app background color, and +// native tabs (marshaling items to JSON when enabled). The function invokes +// platform bindings to apply these settings and returns the configured *iosApp. func newPlatformApp(app *App) *iosApp { iosConsoleLogf("info", "🔵 [application_ios.go] START newPlatformApp()") // iOS initialization @@ -161,19 +168,19 @@ func newPlatformApp(app *App) *iosApp { // Ensure it's marked as not set to allow delegate to fallback to white C.ios_set_app_background_color(255, 255, 255, 255, C.bool(false)) } - // Native tabs option: only enable when explicitly requested - if app.options.IOS.EnableNativeTabs { - if len(app.options.IOS.NativeTabsItems) > 0 { - if data, err := json.Marshal(app.options.IOS.NativeTabsItems); err == nil { - cjson := C.CString(string(data)) - C.ios_native_tabs_set_items_json(cjson) - C.free(unsafe.Pointer(cjson)) - } else if globalApplication != nil { - globalApplication.error("Failed to marshal IOS.NativeTabsItems: %v", err) - } - } - C.ios_native_tabs_set_enabled(C.bool(true)) - } + // Native tabs option: only enable when explicitly requested + if app.options.IOS.EnableNativeTabs { + if len(app.options.IOS.NativeTabsItems) > 0 { + if data, err := json.Marshal(app.options.IOS.NativeTabsItems); err == nil { + cjson := C.CString(string(data)) + C.ios_native_tabs_set_items_json(cjson) + C.free(unsafe.Pointer(cjson)) + } else if globalApplication != nil { + globalApplication.error("Failed to marshal IOS.NativeTabsItems: %v", err) + } + } + C.ios_native_tabs_set_enabled(C.bool(true)) + } iosConsoleLogf("info", "🔵 [application_ios.go] END newPlatformApp() - iosApp created") return result @@ -452,4 +459,4 @@ func hasListeners(eventID C.uint) C.bool { // For now, return true to enable all events // TODO: Check actual listener registration return C.bool(true) -} +} \ No newline at end of file diff --git a/v3/pkg/application/bindings.go b/v3/pkg/application/bindings.go index 431caab62..42830d07e 100644 --- a/v3/pkg/application/bindings.go +++ b/v3/pkg/application/bindings.go @@ -2,22 +2,81 @@ package application import ( "context" - "encoding/json" "errors" "fmt" "reflect" "runtime" "strings" - "github.com/wailsapp/wails/v3/internal/hash" + json "github.com/goccy/go-json" - "github.com/samber/lo" + "github.com/wailsapp/wails/v3/internal/hash" + "github.com/wailsapp/wails/v3/internal/sliceutil" ) +// init forces goccy/go-json to initialize its type address cache at program startup. +// This prevents a Windows-specific index out-of-bounds panic that can occur when the decoder is first invoked later (see https://github.com/goccy/go-json/issues/474). +func init() { + // Force goccy/go-json to initialize its type address cache early. + // On Windows, if the decoder is first invoked later (e.g., during tests), + // the type address calculation can fail with an index out of bounds panic. + // See: https://github.com/goccy/go-json/issues/474 + var ( + s string + i int + i8 int8 + i16 int16 + i32 int32 + i64 int64 + u uint + u8 uint8 + u16 uint16 + u32 uint32 + u64 uint64 + f32 float32 + f64 float64 + b bool + bs []byte + ss []string + si []int + sf []float64 + sa []any + msa map[string]any + mss map[string]string + msi map[string]int + rm json.RawMessage + ) + _ = json.Unmarshal([]byte(`""`), &s) + _ = json.Unmarshal([]byte(`0`), &i) + _ = json.Unmarshal([]byte(`0`), &i8) + _ = json.Unmarshal([]byte(`0`), &i16) + _ = json.Unmarshal([]byte(`0`), &i32) + _ = json.Unmarshal([]byte(`0`), &i64) + _ = json.Unmarshal([]byte(`0`), &u) + _ = json.Unmarshal([]byte(`0`), &u8) + _ = json.Unmarshal([]byte(`0`), &u16) + _ = json.Unmarshal([]byte(`0`), &u32) + _ = json.Unmarshal([]byte(`0`), &u64) + _ = json.Unmarshal([]byte(`0`), &f32) + _ = json.Unmarshal([]byte(`0`), &f64) + _ = json.Unmarshal([]byte(`false`), &b) + _ = json.Unmarshal([]byte(`""`), &bs) + _ = json.Unmarshal([]byte(`[]`), &ss) + _ = json.Unmarshal([]byte(`[]`), &si) + _ = json.Unmarshal([]byte(`[]`), &sf) + _ = json.Unmarshal([]byte(`[]`), &sa) + _ = json.Unmarshal([]byte(`{}`), &msa) + _ = json.Unmarshal([]byte(`{}`), &mss) + _ = json.Unmarshal([]byte(`{}`), &msi) + _ = json.Unmarshal([]byte(`""`), &rm) +} + +// CallOptions defines the options for a method call. +// Field order is optimized to minimize struct padding. type CallOptions struct { - MethodID uint32 `json:"methodID"` MethodName string `json:"methodName"` Args []json.RawMessage `json:"args"` + MethodID uint32 `json:"methodID"` } type ErrorKind string @@ -28,10 +87,12 @@ const ( RuntimeError ErrorKind = "RuntimeError" ) +// CallError represents an error that occurred during a method call. +// Field order is optimized to minimize struct padding. type CallError struct { - Kind ErrorKind `json:"kind"` Message string `json:"message"` Cause any `json:"cause,omitempty"` + Kind ErrorKind `json:"kind"` } func (e *CallError) Error() string { @@ -64,18 +125,19 @@ func (p *Parameter) IsError() bool { } // BoundMethod defines all the data related to a Go method that is -// bound to the Wails application +// bound to the Wails application. +// Field order is optimized to minimize struct padding (136 bytes vs 144 bytes). type BoundMethod struct { - ID uint32 `json:"id"` - Name string `json:"name"` - Inputs []*Parameter `json:"inputs,omitempty"` - Outputs []*Parameter `json:"outputs,omitempty"` - Comments string `json:"comments,omitempty"` - Method reflect.Value `json:"-"` - FQN string - + Method reflect.Value `json:"-"` + Name string `json:"name"` + FQN string `json:"-"` + Comments string `json:"comments,omitempty"` + Inputs []*Parameter `json:"inputs,omitempty"` + Outputs []*Parameter `json:"outputs,omitempty"` marshalError func(error) []byte + ID uint32 `json:"id"` needsContext bool + isVariadic bool // cached at registration to avoid reflect call per invocation } type Bindings struct { @@ -114,7 +176,7 @@ func (b *Bindings) Add(service Service) error { // Log attrs := []any{"fqn", method.FQN, "id", method.ID} - if alias, ok := lo.FindKey(b.methodAliases, method.ID); ok { + if alias, ok := sliceutil.FindMapKey(b.methodAliases, method.ID); ok { attrs = append(attrs, "alias", alias) } globalApplication.debug("Registering bound method:", attrs...) @@ -165,6 +227,10 @@ var internalServiceMethods = map[string]bool{ var ctxType = reflect.TypeFor[context.Context]() +// getMethods returns the list of BoundMethod descriptors for the methods of the named pointer type provided by value. +// +// It returns an error if value is not a pointer to a named type, if a function value is supplied (binding functions is deprecated), or if a generic type is supplied. +// The returned BoundMethod slice includes only exported methods that are not listed in internalServiceMethods. Each BoundMethod has its FQN, ID (computed from the FQN), Method reflect.Value, Inputs and Outputs populated, isVariadic cached from the method signature, and needsContext set when the first parameter is context.Context. func getMethods(value any) ([]*BoundMethod, error) { // Create result placeholder var result []*BoundMethod @@ -203,19 +269,20 @@ func getMethods(value any) ([]*BoundMethod, error) { fqn := fmt.Sprintf("%s.%s.%s", packagePath, typeName, methodName) - // Create new method - boundMethod := &BoundMethod{ - ID: hash.Fnv(fqn), - FQN: fqn, - Name: methodName, - Inputs: nil, - Outputs: nil, - Comments: "", - Method: method, - } - // Iterate inputs methodType := method.Type() + + // Create new method with cached flags + boundMethod := &BoundMethod{ + ID: hash.Fnv(fqn), + FQN: fqn, + Name: methodName, + Inputs: nil, + Outputs: nil, + Comments: "", + Method: method, + isVariadic: methodType.IsVariadic(), // cache to avoid reflect call per invocation + } inputParamCount := methodType.NumIn() var inputs []*Parameter for inputIndex := 0; inputIndex < inputParamCount; inputIndex++ { @@ -268,14 +335,20 @@ func (b *BoundMethod) Call(ctx context.Context, args []json.RawMessage) (result if argCount != len(b.Inputs) { err = &CallError{ - Kind: TypeError, Message: fmt.Sprintf("%s expects %d arguments, got %d", b.FQN, len(b.Inputs), argCount), + Kind: TypeError, } return } - // Convert inputs to values of appropriate type - callArgs := make([]reflect.Value, argCount) + // Use stack-allocated buffer for common case (<=8 args), heap for larger + var argBuffer [8]reflect.Value + var callArgs []reflect.Value + if argCount <= len(argBuffer) { + callArgs = argBuffer[:argCount] + } else { + callArgs = make([]reflect.Value, argCount) + } base := 0 if b.needsContext { @@ -289,24 +362,28 @@ func (b *BoundMethod) Call(ctx context.Context, args []json.RawMessage) (result err = json.Unmarshal(arg, value.Interface()) if err != nil { err = &CallError{ - Kind: TypeError, Message: fmt.Sprintf("could not parse argument #%d: %s", index, err), Cause: json.RawMessage(b.marshalError(err)), + Kind: TypeError, } return } callArgs[base+index] = value.Elem() } - // Do the call + // Do the call using cached isVariadic flag var callResults []reflect.Value - if b.Method.Type().IsVariadic() { + if b.isVariadic { callResults = b.Method.CallSlice(callArgs) } else { callResults = b.Method.Call(callArgs) } - var nonErrorOutputs = make([]any, 0, len(callResults)) + // Process results - optimized for common case of 0-2 return values + // to avoid slice allocation + var firstResult any + var hasFirstResult bool + var nonErrorOutputs []any // only allocated if >1 non-error results var errorOutputs []error for _, field := range callResults { @@ -315,12 +392,22 @@ func (b *BoundMethod) Call(ctx context.Context, args []json.RawMessage) (result continue } if errorOutputs == nil { - errorOutputs = make([]error, 0, len(callResults)-len(nonErrorOutputs)) - nonErrorOutputs = nil + errorOutputs = make([]error, 0, len(callResults)) } errorOutputs = append(errorOutputs, field.Interface().(error)) - } else if nonErrorOutputs != nil { - nonErrorOutputs = append(nonErrorOutputs, field.Interface()) + } else if errorOutputs == nil { + // Only collect non-error outputs if no errors yet + val := field.Interface() + if !hasFirstResult { + firstResult = val + hasFirstResult = true + } else if nonErrorOutputs == nil { + // Second result - need to allocate slice + nonErrorOutputs = make([]any, 0, len(callResults)) + nonErrorOutputs = append(nonErrorOutputs, firstResult, val) + } else { + nonErrorOutputs = append(nonErrorOutputs, val) + } } } @@ -331,19 +418,19 @@ func (b *BoundMethod) Call(ctx context.Context, args []json.RawMessage) (result } cerr := &CallError{ - Kind: RuntimeError, Message: errors.Join(errorOutputs...).Error(), Cause: info, + Kind: RuntimeError, } if len(info) == 1 { cerr.Cause = info[0] } err = cerr - } else if len(nonErrorOutputs) == 1 { - result = nonErrorOutputs[0] - } else if len(nonErrorOutputs) > 1 { + } else if nonErrorOutputs != nil { result = nonErrorOutputs + } else if hasFirstResult { + result = firstResult } return @@ -395,4 +482,4 @@ func isNamed(value interface{}) bool { } return rv.Type().Name() != "" -} +} \ No newline at end of file diff --git a/v3/pkg/application/bindings_bench_test.go b/v3/pkg/application/bindings_bench_test.go new file mode 100644 index 000000000..2e23cc92d --- /dev/null +++ b/v3/pkg/application/bindings_bench_test.go @@ -0,0 +1,506 @@ +//go:build bench + +package application_test + +import ( + "context" + "encoding/json" + "fmt" + "testing" + + "github.com/wailsapp/wails/v3/internal/hash" + "github.com/wailsapp/wails/v3/pkg/application" +) + +// BenchmarkService provides methods with varying complexity for benchmarking +type BenchmarkService struct{} + +func (s *BenchmarkService) NoArgs() {} + +func (s *BenchmarkService) StringArg(str string) string { + return str +} + +func (s *BenchmarkService) IntArg(i int) int { + return i +} + +func (s *BenchmarkService) MultipleArgs(s1 string, i int, b bool) (string, int, bool) { + return s1, i, b +} + +func (s *BenchmarkService) StructArg(p BenchPerson) BenchPerson { + return p +} + +func (s *BenchmarkService) ComplexStruct(c ComplexData) ComplexData { + return c +} + +func (s *BenchmarkService) SliceArg(items []int) []int { + return items +} + +func (s *BenchmarkService) VariadicArg(items ...string) []string { + return items +} + +func (s *BenchmarkService) WithContext(ctx context.Context, s1 string) string { + return s1 +} + +func (s *BenchmarkService) Method1() {} +func (s *BenchmarkService) Method2() {} +func (s *BenchmarkService) Method3() {} +func (s *BenchmarkService) Method4() {} +func (s *BenchmarkService) Method5() {} +func (s *BenchmarkService) Method6() {} +func (s *BenchmarkService) Method7() {} +func (s *BenchmarkService) Method8() {} +func (s *BenchmarkService) Method9() {} +func (s *BenchmarkService) Method10() {} + +type BenchPerson struct { + Name string `json:"name"` + Age int `json:"age"` + Email string `json:"email"` + Address string `json:"address"` +} + +type ComplexData struct { + ID int `json:"id"` + Name string `json:"name"` + Tags []string `json:"tags"` + Metadata map[string]interface{} `json:"metadata"` + Nested *NestedData `json:"nested"` +} + +type NestedData struct { + Value float64 `json:"value"` + Enabled bool `json:"enabled"` +} + +// Helper to create JSON args +func benchArgs(jsonArgs ...string) []json.RawMessage { + args := make([]json.RawMessage, len(jsonArgs)) + for i, j := range jsonArgs { + args[i] = json.RawMessage(j) + } + return args +} + +// BenchmarkMethodBinding measures the cost of registering services with varying method counts +func BenchmarkMethodBinding(b *testing.B) { + // Initialize global application (required for bindings) + _ = application.New(application.Options{}) + + b.Run("SingleService", func(b *testing.B) { + for b.Loop() { + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + } + }) + + b.Run("MultipleServices", func(b *testing.B) { + for b.Loop() { + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + _ = bindings.Add(application.NewService(&BenchPerson{})) // Will fail but tests the path + } + }) +} + +// BenchmarkMethodLookupByID measures method lookup by ID performance +func BenchmarkMethodLookupByID(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + // Get a valid method ID + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + methodID := method.ID + + b.ResetTimer() + for b.Loop() { + _ = bindings.GetByID(methodID) + } +} + +// BenchmarkMethodLookupByName measures method lookup by name performance +func BenchmarkMethodLookupByName(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.StringArg", + } + + b.ResetTimer() + for b.Loop() { + _ = bindings.Get(callOptions) + } +} + +// BenchmarkSimpleCall measures the cost of calling a method with a simple string argument +func BenchmarkSimpleCall(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := benchArgs(`"hello world"`) + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.Call(ctx, args) + } +} + +// BenchmarkComplexCall measures the cost of calling a method with a complex struct argument +func BenchmarkComplexCall(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.ComplexStruct", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + complexArg := `{ + "id": 12345, + "name": "Test Complex Data", + "tags": ["tag1", "tag2", "tag3", "tag4", "tag5"], + "metadata": {"key1": "value1", "key2": 42, "key3": true}, + "nested": {"value": 3.14159, "enabled": true} + }` + args := benchArgs(complexArg) + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.Call(ctx, args) + } +} + +// BenchmarkVariadicCall measures the cost of calling a variadic method +func BenchmarkVariadicCall(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.VariadicArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := benchArgs(`["one", "two", "three", "four", "five"]`) + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.Call(ctx, args) + } +} + +// BenchmarkCallWithContext measures the cost of calling a method that requires context +func BenchmarkCallWithContext(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.WithContext", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := benchArgs(`"context test"`) + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.Call(ctx, args) + } +} + +// BenchmarkJSONMarshalResult measures JSON marshaling overhead for results +func BenchmarkJSONMarshalResult(b *testing.B) { + person := BenchPerson{ + Name: "John Doe", + Age: 30, + Email: "john@example.com", + Address: "123 Main St, City, Country", + } + + b.Run("SimplePerson", func(b *testing.B) { + for b.Loop() { + _, _ = json.Marshal(person) + } + }) + + complex := ComplexData{ + ID: 12345, + Name: "Complex Test", + Tags: []string{"tag1", "tag2", "tag3", "tag4", "tag5"}, + Metadata: map[string]interface{}{ + "key1": "value1", + "key2": 42, + "key3": true, + }, + Nested: &NestedData{ + Value: 3.14159, + Enabled: true, + }, + } + + b.Run("ComplexData", func(b *testing.B) { + for b.Loop() { + _, _ = json.Marshal(complex) + } + }) +} + +// BenchmarkHashComputation measures the FNV hash computation used for method IDs +func BenchmarkHashComputation(b *testing.B) { + testCases := []struct { + name string + fqn string + }{ + {"Short", "pkg.Service.Method"}, + {"Medium", "github.com/user/project/pkg.Service.Method"}, + {"Long", "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.ComplexStruct"}, + } + + for _, tc := range testCases { + b.Run(tc.name, func(b *testing.B) { + for b.Loop() { + _ = hash.Fnv(tc.fqn) + } + }) + } +} + +// BenchmarkJSONUnmarshal measures JSON unmarshaling overhead for arguments +func BenchmarkJSONUnmarshal(b *testing.B) { + b.Run("String", func(b *testing.B) { + data := []byte(`"hello world"`) + for b.Loop() { + var s string + _ = json.Unmarshal(data, &s) + } + }) + + b.Run("Int", func(b *testing.B) { + data := []byte(`12345`) + for b.Loop() { + var i int + _ = json.Unmarshal(data, &i) + } + }) + + b.Run("Struct", func(b *testing.B) { + data := []byte(`{"name":"John","age":30,"email":"john@example.com","address":"123 Main St"}`) + for b.Loop() { + var p BenchPerson + _ = json.Unmarshal(data, &p) + } + }) + + b.Run("ComplexStruct", func(b *testing.B) { + data := []byte(`{"id":12345,"name":"Test","tags":["a","b","c"],"metadata":{"k":"v"},"nested":{"value":3.14,"enabled":true}}`) + for b.Loop() { + var c ComplexData + _ = json.Unmarshal(data, &c) + } + }) +} + +// BenchmarkMethodLookupWithAliases measures method lookup with alias resolution +func BenchmarkMethodLookupWithAliases(b *testing.B) { + _ = application.New(application.Options{}) + + // Create aliases map + aliases := make(map[uint32]uint32) + for i := uint32(0); i < 100; i++ { + aliases[i+1000] = i + } + + bindings := application.NewBindings(nil, aliases) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + b.Run("DirectLookup", func(b *testing.B) { + id := method.ID + for b.Loop() { + _ = bindings.GetByID(id) + } + }) + + b.Run("AliasLookup", func(b *testing.B) { + // Add an alias for this method + aliases[9999] = method.ID + for b.Loop() { + _ = bindings.GetByID(9999) + } + }) +} + +// BenchmarkReflectValueCall measures the overhead of reflect.Value.Call +func BenchmarkReflectValueCall(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + ctx := context.Background() + + b.Run("NoArgs", func(b *testing.B) { + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.NoArgs", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + args := benchArgs() + for b.Loop() { + _, _ = method.Call(ctx, args) + } + }) + + b.Run("MultipleArgs", func(b *testing.B) { + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.MultipleArgs", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + args := benchArgs(`"test"`, `42`, `true`) + for b.Loop() { + _, _ = method.Call(ctx, args) + } + }) +} + +// BenchmarkBindingsScaling measures how bindings performance scales with service count +func BenchmarkBindingsScaling(b *testing.B) { + _ = application.New(application.Options{}) + + // We can only add one service of each type, so we test lookup scaling + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + // Generate method names for lookup + methodNames := []string{ + "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.NoArgs", + "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.StringArg", + "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.IntArg", + "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.MultipleArgs", + "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.StructArg", + } + + b.Run("SequentialLookup", func(b *testing.B) { + for b.Loop() { + for _, name := range methodNames { + _ = bindings.Get(&application.CallOptions{MethodName: name}) + } + } + }) +} + +// BenchmarkCallErrorPath measures the cost of error handling in method calls +func BenchmarkCallErrorPath(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + ctx := context.Background() + + b.Run("WrongArgCount", func(b *testing.B) { + args := benchArgs() // No args when one is expected + for b.Loop() { + _, _ = method.Call(ctx, args) + } + }) + + b.Run("WrongArgType", func(b *testing.B) { + args := benchArgs(`123`) // Int when string is expected + for b.Loop() { + _, _ = method.Call(ctx, args) + } + }) +} + +// BenchmarkSliceArgSizes measures performance with varying slice sizes +func BenchmarkSliceArgSizes(b *testing.B) { + _ = application.New(application.Options{}) + bindings := application.NewBindings(nil, nil) + _ = bindings.Add(application.NewService(&BenchmarkService{})) + + callOptions := &application.CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.SliceArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + ctx := context.Background() + + sizes := []int{1, 10, 100, 1000} + for _, size := range sizes { + b.Run(fmt.Sprintf("Size%d", size), func(b *testing.B) { + // Build slice JSON + slice := make([]int, size) + for i := range slice { + slice[i] = i + } + data, _ := json.Marshal(slice) + args := []json.RawMessage{data} + + b.ResetTimer() + for b.Loop() { + _, _ = method.Call(ctx, args) + } + }) + } +} diff --git a/v3/pkg/application/bindings_optimized_bench_test.go b/v3/pkg/application/bindings_optimized_bench_test.go new file mode 100644 index 000000000..1a9b137f5 --- /dev/null +++ b/v3/pkg/application/bindings_optimized_bench_test.go @@ -0,0 +1,469 @@ +//go:build bench + +package application + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "reflect" + "sync" + "testing" + + jsonv2 "github.com/go-json-experiment/json" +) + +// This file contains optimized versions of BoundMethod.Call for benchmarking. +// These demonstrate potential optimizations that could be applied. + +// Pools for reducing allocations +var ( + // Pool for []reflect.Value slices (sized for typical arg counts) + callArgsPool = sync.Pool{ + New: func() any { + // Pre-allocate for up to 8 args (covers vast majority of methods) + return make([]reflect.Value, 0, 8) + }, + } + + // Pool for []any slices + anySlicePool = sync.Pool{ + New: func() any { + return make([]any, 0, 4) + }, + } + + // Pool for CallError structs + callErrorPool = sync.Pool{ + New: func() any { + return &CallError{} + }, + } +) + +// CallOptimized is an optimized version of BoundMethod.Call that uses sync.Pool +func (b *BoundMethod) CallOptimized(ctx context.Context, args []json.RawMessage) (result any, err error) { + defer handlePanic(handlePanicOptions{skipEnd: 5}) + + argCount := len(args) + if b.needsContext { + argCount++ + } + + if argCount != len(b.Inputs) { + cerr := callErrorPool.Get().(*CallError) + cerr.Kind = TypeError + cerr.Message = fmt.Sprintf("%s expects %d arguments, got %d", b.FQN, len(b.Inputs), argCount) + cerr.Cause = nil + return nil, cerr + } + + // Get callArgs from pool + callArgs := callArgsPool.Get().([]reflect.Value) + callArgs = callArgs[:0] // Reset length but keep capacity + + // Ensure capacity + if cap(callArgs) < argCount { + callArgs = make([]reflect.Value, 0, argCount) + } + callArgs = callArgs[:argCount] + + base := 0 + if b.needsContext { + callArgs[0] = reflect.ValueOf(ctx) + base++ + } + + // Iterate over given arguments + for index, arg := range args { + value := reflect.New(b.Inputs[base+index].ReflectType) + err = json.Unmarshal(arg, value.Interface()) + if err != nil { + // Return callArgs to pool before returning error + callArgsPool.Put(callArgs[:0]) + + cerr := callErrorPool.Get().(*CallError) + cerr.Kind = TypeError + cerr.Message = fmt.Sprintf("could not parse argument #%d: %s", index, err) + cerr.Cause = json.RawMessage(b.marshalError(err)) + return nil, cerr + } + callArgs[base+index] = value.Elem() + } + + // Do the call - use cached isVariadic flag like production code + var callResults []reflect.Value + if b.isVariadic { + callResults = b.Method.CallSlice(callArgs) + } else { + callResults = b.Method.Call(callArgs) + } + + // Return callArgs to pool + callArgsPool.Put(callArgs[:0]) + + // Get output slice from pool + nonErrorOutputs := anySlicePool.Get().([]any) + nonErrorOutputs = nonErrorOutputs[:0] + defer func() { + anySlicePool.Put(nonErrorOutputs[:0]) + }() + + var errorOutputs []error + + for _, field := range callResults { + if field.Type() == errorType { + if field.IsNil() { + continue + } + if errorOutputs == nil { + errorOutputs = make([]error, 0, len(callResults)-len(nonErrorOutputs)) + nonErrorOutputs = nil + } + errorOutputs = append(errorOutputs, field.Interface().(error)) + } else if nonErrorOutputs != nil { + nonErrorOutputs = append(nonErrorOutputs, field.Interface()) + } + } + + if len(errorOutputs) > 0 { + info := make([]json.RawMessage, len(errorOutputs)) + for i, err := range errorOutputs { + info[i] = b.marshalError(err) + } + + cerr := &CallError{ + Kind: RuntimeError, + Message: errors.Join(errorOutputs...).Error(), + Cause: info, + } + if len(info) == 1 { + cerr.Cause = info[0] + } + return nil, cerr + } + + if len(nonErrorOutputs) == 1 { + result = nonErrorOutputs[0] + } else if len(nonErrorOutputs) > 1 { + // Need to copy since we're returning the pooled slice + resultSlice := make([]any, len(nonErrorOutputs)) + copy(resultSlice, nonErrorOutputs) + result = resultSlice + } + + return result, nil +} + +// Benchmark comparing original vs optimized Call +func BenchmarkCallOriginal(b *testing.B) { + _ = New(Options{}) + bindings := NewBindings(nil, nil) + + service := &benchService{} + _ = bindings.Add(NewService(service)) + + callOptions := &CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application.benchService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := []json.RawMessage{json.RawMessage(`"hello world"`)} + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.Call(ctx, args) + } +} + +func BenchmarkCallOptimized(b *testing.B) { + _ = New(Options{}) + bindings := NewBindings(nil, nil) + + service := &benchService{} + _ = bindings.Add(NewService(service)) + + callOptions := &CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application.benchService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := []json.RawMessage{json.RawMessage(`"hello world"`)} + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.CallOptimized(ctx, args) + } +} + +// benchService for internal tests +type benchService struct{} + +func (s *benchService) StringArg(str string) string { + return str +} + +func (s *benchService) MultipleArgs(s1 string, i int, b bool) (string, int, bool) { + return s1, i, b +} + +func BenchmarkCallOriginal_MultiArgs(b *testing.B) { + _ = New(Options{}) + bindings := NewBindings(nil, nil) + + service := &benchService{} + _ = bindings.Add(NewService(service)) + + callOptions := &CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application.benchService.MultipleArgs", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := []json.RawMessage{ + json.RawMessage(`"test"`), + json.RawMessage(`42`), + json.RawMessage(`true`), + } + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.Call(ctx, args) + } +} + +func BenchmarkCallOptimized_MultiArgs(b *testing.B) { + _ = New(Options{}) + bindings := NewBindings(nil, nil) + + service := &benchService{} + _ = bindings.Add(NewService(service)) + + callOptions := &CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application.benchService.MultipleArgs", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := []json.RawMessage{ + json.RawMessage(`"test"`), + json.RawMessage(`42`), + json.RawMessage(`true`), + } + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.CallOptimized(ctx, args) + } +} + +// CallWithJSONv2 uses the new JSON v2 library for unmarshaling +func (b *BoundMethod) CallWithJSONv2(ctx context.Context, args []json.RawMessage) (result any, err error) { + defer handlePanic(handlePanicOptions{skipEnd: 5}) + + argCount := len(args) + if b.needsContext { + argCount++ + } + + if argCount != len(b.Inputs) { + return nil, &CallError{ + Kind: TypeError, + Message: fmt.Sprintf("%s expects %d arguments, got %d", b.FQN, len(b.Inputs), argCount), + } + } + + // Convert inputs to values of appropriate type + callArgs := make([]reflect.Value, argCount) + base := 0 + + if b.needsContext { + callArgs[0] = reflect.ValueOf(ctx) + base++ + } + + // Iterate over given arguments - use JSON v2 for unmarshaling + for index, arg := range args { + value := reflect.New(b.Inputs[base+index].ReflectType) + err = jsonv2.Unmarshal(arg, value.Interface()) + if err != nil { + return nil, &CallError{ + Kind: TypeError, + Message: fmt.Sprintf("could not parse argument #%d: %s", index, err), + Cause: json.RawMessage(b.marshalError(err)), + } + } + callArgs[base+index] = value.Elem() + } + + // Do the call + var callResults []reflect.Value + if b.Method.Type().IsVariadic() { + callResults = b.Method.CallSlice(callArgs) + } else { + callResults = b.Method.Call(callArgs) + } + + var nonErrorOutputs = make([]any, 0, len(callResults)) + var errorOutputs []error + + for _, field := range callResults { + if field.Type() == errorType { + if field.IsNil() { + continue + } + if errorOutputs == nil { + errorOutputs = make([]error, 0, len(callResults)-len(nonErrorOutputs)) + nonErrorOutputs = nil + } + errorOutputs = append(errorOutputs, field.Interface().(error)) + } else if nonErrorOutputs != nil { + nonErrorOutputs = append(nonErrorOutputs, field.Interface()) + } + } + + if len(errorOutputs) > 0 { + info := make([]json.RawMessage, len(errorOutputs)) + for i, err := range errorOutputs { + info[i] = b.marshalError(err) + } + + cerr := &CallError{ + Kind: RuntimeError, + Message: errors.Join(errorOutputs...).Error(), + Cause: info, + } + if len(info) == 1 { + cerr.Cause = info[0] + } + return nil, cerr + } + + if len(nonErrorOutputs) == 1 { + result = nonErrorOutputs[0] + } else if len(nonErrorOutputs) > 1 { + result = nonErrorOutputs + } + + return result, nil +} + +func BenchmarkCallJSONv2(b *testing.B) { + _ = New(Options{}) + bindings := NewBindings(nil, nil) + + service := &benchService{} + _ = bindings.Add(NewService(service)) + + callOptions := &CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application.benchService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := []json.RawMessage{json.RawMessage(`"hello world"`)} + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.CallWithJSONv2(ctx, args) + } +} + +func BenchmarkCallJSONv2_MultiArgs(b *testing.B) { + _ = New(Options{}) + bindings := NewBindings(nil, nil) + + service := &benchService{} + _ = bindings.Add(NewService(service)) + + callOptions := &CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application.benchService.MultipleArgs", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := []json.RawMessage{ + json.RawMessage(`"test"`), + json.RawMessage(`42`), + json.RawMessage(`true`), + } + ctx := context.Background() + + b.ResetTimer() + for b.Loop() { + _, _ = method.CallWithJSONv2(ctx, args) + } +} + +// Concurrent benchmark to test pool effectiveness under load +func BenchmarkCallOriginal_Concurrent(b *testing.B) { + _ = New(Options{}) + bindings := NewBindings(nil, nil) + + service := &benchService{} + _ = bindings.Add(NewService(service)) + + callOptions := &CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application.benchService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := []json.RawMessage{json.RawMessage(`"hello world"`)} + ctx := context.Background() + + b.ResetTimer() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + _, _ = method.Call(ctx, args) + } + }) +} + +func BenchmarkCallOptimized_Concurrent(b *testing.B) { + _ = New(Options{}) + bindings := NewBindings(nil, nil) + + service := &benchService{} + _ = bindings.Add(NewService(service)) + + callOptions := &CallOptions{ + MethodName: "github.com/wailsapp/wails/v3/pkg/application.benchService.StringArg", + } + method := bindings.Get(callOptions) + if method == nil { + b.Fatal("method not found") + } + + args := []json.RawMessage{json.RawMessage(`"hello world"`)} + ctx := context.Background() + + b.ResetTimer() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + _, _ = method.CallOptimized(ctx, args) + } + }) +} diff --git a/v3/pkg/application/event_manager.go b/v3/pkg/application/event_manager.go index 54f1d421b..7555ff685 100644 --- a/v3/pkg/application/event_manager.go +++ b/v3/pkg/application/event_manager.go @@ -3,7 +3,6 @@ package application import ( "slices" - "github.com/samber/lo" "github.com/wailsapp/wails/v3/pkg/events" ) @@ -100,7 +99,9 @@ func (em *EventManager) OnApplicationEvent(eventType events.ApplicationEventType em.app.applicationEventListenersLock.Lock() defer em.app.applicationEventListenersLock.Unlock() // Remove listener - em.app.applicationEventListeners[eventID] = lo.Without(em.app.applicationEventListeners[eventID], listener) + em.app.applicationEventListeners[eventID] = slices.DeleteFunc(em.app.applicationEventListeners[eventID], func(l *EventListener) bool { + return l == listener + }) } } @@ -116,7 +117,9 @@ func (em *EventManager) RegisterApplicationEventHook(eventType events.Applicatio return func() { em.app.applicationEventHooksLock.Lock() - em.app.applicationEventHooks[eventID] = lo.Without(em.app.applicationEventHooks[eventID], thisHook) + em.app.applicationEventHooks[eventID] = slices.DeleteFunc(em.app.applicationEventHooks[eventID], func(h *eventHook) bool { + return h == thisHook + }) em.app.applicationEventHooksLock.Unlock() } } diff --git a/v3/pkg/application/events.go b/v3/pkg/application/events.go index 2c5afc960..f70d37123 100644 --- a/v3/pkg/application/events.go +++ b/v3/pkg/application/events.go @@ -1,13 +1,14 @@ package application import ( - "encoding/json" "fmt" "reflect" + "slices" "sync" "sync/atomic" - "github.com/samber/lo" + json "github.com/goccy/go-json" + "github.com/wailsapp/wails/v3/pkg/events" ) @@ -197,8 +198,8 @@ func (e *EventProcessor) registerListener(eventName string, callback func(*Custo if _, ok := e.listeners[eventName]; !ok { return } - e.listeners[eventName] = lo.Filter(e.listeners[eventName], func(l *eventListener, i int) bool { - return l != thisListener + e.listeners[eventName] = slices.DeleteFunc(e.listeners[eventName], func(l *eventListener) bool { + return l == thisListener }) } } @@ -220,8 +221,8 @@ func (e *EventProcessor) RegisterHook(eventName string, callback func(*CustomEve if _, ok := e.hooks[eventName]; !ok { return } - e.hooks[eventName] = lo.Filter(e.hooks[eventName], func(l *hook, i int) bool { - return l != thisHook + e.hooks[eventName] = slices.DeleteFunc(e.hooks[eventName], func(h *hook) bool { + return h == thisHook }) } } @@ -268,8 +269,8 @@ func (e *EventProcessor) dispatchEventToListeners(event *CustomEvent) { // Do we have items to delete? if itemsToDelete == true { - e.listeners[event.Name] = lo.Filter(listeners, func(l *eventListener, i int) bool { - return l.delete == false + e.listeners[event.Name] = slices.DeleteFunc(listeners, func(l *eventListener) bool { + return l.delete == true }) } } diff --git a/v3/pkg/application/events_bench_test.go b/v3/pkg/application/events_bench_test.go new file mode 100644 index 000000000..c6ed4341f --- /dev/null +++ b/v3/pkg/application/events_bench_test.go @@ -0,0 +1,380 @@ +//go:build bench + +package application_test + +import ( + "fmt" + "sync" + "sync/atomic" + "testing" + + "github.com/wailsapp/wails/v3/pkg/application" +) + +// mockWindowDispatcher implements a no-op dispatcher for benchmarking +type mockWindowDispatcher struct { + count atomic.Int64 +} + +func (m *mockWindowDispatcher) dispatchEventToWindows(event *application.CustomEvent) { + m.count.Add(1) +} + +// BenchmarkEventEmit measures event emission with varying listener counts +func BenchmarkEventEmit(b *testing.B) { + listenerCounts := []int{0, 1, 10, 100} + + for _, count := range listenerCounts { + b.Run(fmt.Sprintf("Listeners%d", count), func(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + + // Register listeners + for i := 0; i < count; i++ { + processor.On("benchmark-event", func(event *application.CustomEvent) { + // Minimal work + _ = event.Data + }) + } + + event := &application.CustomEvent{ + Name: "benchmark-event", + Data: "test payload", + } + + b.ResetTimer() + for b.Loop() { + _ = processor.Emit(event) + } + }) + } +} + +// BenchmarkEventRegistration measures the cost of registering event listeners +func BenchmarkEventRegistration(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + + b.Run("SingleRegistration", func(b *testing.B) { + for b.Loop() { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + processor.On("test-event", func(event *application.CustomEvent) {}) + } + }) + + b.Run("MultipleRegistrations", func(b *testing.B) { + for b.Loop() { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + for i := 0; i < 10; i++ { + processor.On(fmt.Sprintf("test-event-%d", i), func(event *application.CustomEvent) {}) + } + } + }) + + b.Run("SameEventMultipleListeners", func(b *testing.B) { + for b.Loop() { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + for i := 0; i < 10; i++ { + processor.On("test-event", func(event *application.CustomEvent) {}) + } + } + }) +} + +// BenchmarkEventUnregistration measures the cost of unregistering event listeners +func BenchmarkEventUnregistration(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + + b.Run("SingleUnregister", func(b *testing.B) { + for b.Loop() { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + cancel := processor.On("test-event", func(event *application.CustomEvent) {}) + cancel() + } + }) + + b.Run("UnregisterFromMany", func(b *testing.B) { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + // Pre-register many listeners + cancels := make([]func(), 100) + for i := 0; i < 100; i++ { + cancels[i] = processor.On("test-event", func(event *application.CustomEvent) {}) + } + + b.ResetTimer() + for i := 0; b.Loop(); i++ { + // Re-register to have something to unregister + if i%100 == 0 { + for j := 0; j < 100; j++ { + cancels[j] = processor.On("test-event", func(event *application.CustomEvent) {}) + } + } + cancels[i%100]() + } + }) + + b.Run("OffAllListeners", func(b *testing.B) { + for b.Loop() { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + for i := 0; i < 10; i++ { + processor.On("test-event", func(event *application.CustomEvent) {}) + } + processor.Off("test-event") + } + }) +} + +// BenchmarkHookExecution measures the cost of hook execution during emit +func BenchmarkHookExecution(b *testing.B) { + hookCounts := []int{0, 1, 5, 10} + + for _, count := range hookCounts { + b.Run(fmt.Sprintf("Hooks%d", count), func(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + + // Register hooks + for i := 0; i < count; i++ { + processor.RegisterHook("benchmark-event", func(event *application.CustomEvent) { + // Minimal work - don't cancel + _ = event.Data + }) + } + + event := &application.CustomEvent{ + Name: "benchmark-event", + Data: "test payload", + } + + b.ResetTimer() + for b.Loop() { + _ = processor.Emit(event) + } + }) + } +} + +// BenchmarkConcurrentEmit measures event emission under concurrent load +func BenchmarkConcurrentEmit(b *testing.B) { + concurrencyLevels := []int{1, 4, 16} + + for _, concurrency := range concurrencyLevels { + b.Run(fmt.Sprintf("Goroutines%d", concurrency), func(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + + // Register a few listeners + for i := 0; i < 5; i++ { + processor.On("benchmark-event", func(event *application.CustomEvent) { + _ = event.Data + }) + } + + b.ResetTimer() + b.SetParallelism(concurrency) + b.RunParallel(func(pb *testing.PB) { + event := &application.CustomEvent{ + Name: "benchmark-event", + Data: "test payload", + } + for pb.Next() { + _ = processor.Emit(event) + } + }) + }) + } +} + +// BenchmarkEventToJSON measures CustomEvent JSON serialization +func BenchmarkEventToJSON(b *testing.B) { + b.Run("SimpleData", func(b *testing.B) { + event := &application.CustomEvent{ + Name: "test-event", + Data: "simple string payload", + } + for b.Loop() { + _ = event.ToJSON() + } + }) + + b.Run("ComplexData", func(b *testing.B) { + event := &application.CustomEvent{ + Name: "test-event", + Data: map[string]interface{}{ + "id": 12345, + "name": "Test Event", + "tags": []string{"tag1", "tag2", "tag3"}, + "enabled": true, + "nested": map[string]interface{}{ + "value": 3.14159, + }, + }, + } + for b.Loop() { + _ = event.ToJSON() + } + }) + + b.Run("WithSender", func(b *testing.B) { + event := &application.CustomEvent{ + Name: "test-event", + Data: "payload", + Sender: "main-window", + } + for b.Loop() { + _ = event.ToJSON() + } + }) +} + +// BenchmarkAtomicCancel measures the atomic cancel/check operations +func BenchmarkAtomicCancel(b *testing.B) { + b.Run("Cancel", func(b *testing.B) { + for b.Loop() { + event := &application.CustomEvent{ + Name: "test", + Data: nil, + } + event.Cancel() + } + }) + + b.Run("IsCancelled", func(b *testing.B) { + event := &application.CustomEvent{ + Name: "test", + Data: nil, + } + for b.Loop() { + _ = event.IsCancelled() + } + }) + + b.Run("CancelAndCheck", func(b *testing.B) { + for b.Loop() { + event := &application.CustomEvent{ + Name: "test", + Data: nil, + } + event.Cancel() + _ = event.IsCancelled() + } + }) +} + +// BenchmarkEventProcessorCreation measures processor instantiation +func BenchmarkEventProcessorCreation(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + for b.Loop() { + _ = application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + } +} + +// BenchmarkOnceEvent measures the Once registration and auto-unregistration +func BenchmarkOnceEvent(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + + b.Run("RegisterAndTrigger", func(b *testing.B) { + for b.Loop() { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + var wg sync.WaitGroup + wg.Add(1) + processor.Once("once-event", func(event *application.CustomEvent) { + wg.Done() + }) + _ = processor.Emit(&application.CustomEvent{Name: "once-event", Data: nil}) + wg.Wait() + } + }) +} + +// BenchmarkOnMultipleEvent measures the OnMultiple registration +func BenchmarkOnMultipleEvent(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + + b.Run("ThreeEvents", func(b *testing.B) { + for b.Loop() { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + var wg sync.WaitGroup + wg.Add(3) + processor.OnMultiple("multi-event", func(event *application.CustomEvent) { + wg.Done() + }, 3) + for i := 0; i < 3; i++ { + _ = processor.Emit(&application.CustomEvent{Name: "multi-event", Data: nil}) + } + wg.Wait() + } + }) +} + +// BenchmarkMixedEventOperations simulates realistic event usage patterns +func BenchmarkMixedEventOperations(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + + b.Run("RegisterEmitUnregister", func(b *testing.B) { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + + for b.Loop() { + cancel := processor.On("mixed-event", func(event *application.CustomEvent) { + _ = event.Data + }) + _ = processor.Emit(&application.CustomEvent{Name: "mixed-event", Data: "test"}) + cancel() + } + }) + + b.Run("HookAndEmit", func(b *testing.B) { + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + processor.RegisterHook("hooked-event", func(event *application.CustomEvent) { + // Validation hook + if event.Data == nil { + event.Cancel() + } + }) + processor.On("hooked-event", func(event *application.CustomEvent) { + _ = event.Data + }) + + event := &application.CustomEvent{Name: "hooked-event", Data: "valid"} + + b.ResetTimer() + for b.Loop() { + _ = processor.Emit(event) + } + }) +} + +// BenchmarkEventNameLookup measures the map lookup performance for event names +func BenchmarkEventNameLookup(b *testing.B) { + dispatcher := &mockWindowDispatcher{} + processor := application.NewWailsEventProcessor(dispatcher.dispatchEventToWindows) + + // Register events with different name lengths + shortName := "evt" + mediumName := "application:user:action" + longName := "com.mycompany.myapp.module.submodule.event.type.action" + + processor.On(shortName, func(event *application.CustomEvent) {}) + processor.On(mediumName, func(event *application.CustomEvent) {}) + processor.On(longName, func(event *application.CustomEvent) {}) + + b.Run("ShortName", func(b *testing.B) { + event := &application.CustomEvent{Name: shortName, Data: nil} + for b.Loop() { + _ = processor.Emit(event) + } + }) + + b.Run("MediumName", func(b *testing.B) { + event := &application.CustomEvent{Name: mediumName, Data: nil} + for b.Loop() { + _ = processor.Emit(event) + } + }) + + b.Run("LongName", func(b *testing.B) { + event := &application.CustomEvent{Name: longName, Data: nil} + for b.Loop() { + _ = processor.Emit(event) + } + }) +} diff --git a/v3/pkg/application/ios_runtime_ios.go b/v3/pkg/application/ios_runtime_ios.go index 551e3e029..0b4b5b35b 100644 --- a/v3/pkg/application/ios_runtime_ios.go +++ b/v3/pkg/application/ios_runtime_ios.go @@ -10,10 +10,13 @@ package application */ import "C" import ( - "encoding/json" "unsafe" + + json "github.com/goccy/go-json" ) +// iosHapticsImpact triggers an iOS haptic impact using the provided style. +// The style parameter specifies the impact style name understood by the native haptic engine. func iosHapticsImpact(style string) { cstr := C.CString(style) defer C.free(unsafe.Pointer(cstr)) @@ -39,27 +42,38 @@ func iosDeviceInfo() deviceInfo { return out } -// Live mutations +// iosSetScrollEnabled sets whether scrolling is enabled in the iOS runtime. func iosSetScrollEnabled(enabled bool) { C.ios_runtime_set_scroll_enabled(C.bool(enabled)) } +// iosSetBounceEnabled sets whether scroll bounce (rubber-band) behavior is enabled at runtime. +// If enabled is true, scrollable content will bounce when pulled past its edges; if false, that bounce is disabled. func iosSetBounceEnabled(enabled bool) { C.ios_runtime_set_bounce_enabled(C.bool(enabled)) } +// iosSetScrollIndicatorsEnabled configures whether the iOS runtime shows scroll indicators. +// The enabled parameter controls visibility: true shows indicators, false hides them. func iosSetScrollIndicatorsEnabled(enabled bool) { - C.ios_runtime_set_scroll_indicators_enabled(C.bool(enabled)) + C.ios_runtime_set_scroll_indicators_enabled(C.bool(enabled)) } +// iosSetBackForwardGesturesEnabled enables back-forward navigation gestures when enabled is true and disables them when enabled is false. func iosSetBackForwardGesturesEnabled(enabled bool) { - C.ios_runtime_set_back_forward_gestures_enabled(C.bool(enabled)) + C.ios_runtime_set_back_forward_gestures_enabled(C.bool(enabled)) } +// iosSetLinkPreviewEnabled sets whether link previews are enabled in the iOS runtime. +// Pass true to enable link previews, false to disable them. func iosSetLinkPreviewEnabled(enabled bool) { C.ios_runtime_set_link_preview_enabled(C.bool(enabled)) } +// iosSetInspectableEnabled sets whether runtime web content inspection is enabled. +// When enabled is true the runtime allows inspection of web content; when false inspection is disabled. func iosSetInspectableEnabled(enabled bool) { C.ios_runtime_set_inspectable_enabled(C.bool(enabled)) } +// iosSetCustomUserAgent sets the runtime's custom User-Agent string. +// If ua is an empty string, the custom User-Agent is cleared. func iosSetCustomUserAgent(ua string) { - var cstr *C.char - if ua != "" { - cstr = C.CString(ua) - defer C.free(unsafe.Pointer(cstr)) - } - C.ios_runtime_set_custom_user_agent(cstr) + var cstr *C.char + if ua != "" { + cstr = C.CString(ua) + defer C.free(unsafe.Pointer(cstr)) + } + C.ios_runtime_set_custom_user_agent(cstr) } // Native tabs func iosSetNativeTabsEnabled(enabled bool) { C.ios_native_tabs_set_enabled(C.bool(enabled)) } func iosNativeTabsIsEnabled() bool { return bool(C.ios_native_tabs_is_enabled()) } -func iosSelectNativeTab(index int) { C.ios_native_tabs_select_index(C.int(index)) } +func iosSelectNativeTab(index int) { C.ios_native_tabs_select_index(C.int(index)) } \ No newline at end of file diff --git a/v3/pkg/application/json_libs_bench_test.go b/v3/pkg/application/json_libs_bench_test.go new file mode 100644 index 000000000..274b29b5f --- /dev/null +++ b/v3/pkg/application/json_libs_bench_test.go @@ -0,0 +1,310 @@ +//go:build bench + +package application_test + +import ( + "encoding/json" + "testing" + + "github.com/bytedance/sonic" + gojson "github.com/goccy/go-json" + jsoniter "github.com/json-iterator/go" +) + +// Test structures matching real Wails binding patterns + +type SimpleBindingArg struct { + Name string `json:"name"` + Value int `json:"value"` +} + +type ComplexBindingArg struct { + ID int `json:"id"` + Name string `json:"name"` + Tags []string `json:"tags"` + Metadata map[string]interface{} `json:"metadata"` + Nested *NestedBindingArg `json:"nested,omitempty"` +} + +type NestedBindingArg struct { + Value float64 `json:"value"` + Enabled bool `json:"enabled"` +} + +// Test data simulating frontend calls +var ( + simpleJSON = []byte(`{"name":"test","value":42}`) + + complexJSON = []byte(`{"id":12345,"name":"Test Complex Data","tags":["tag1","tag2","tag3","tag4","tag5"],"metadata":{"key1":"value1","key2":42,"key3":true},"nested":{"value":3.14159,"enabled":true}}`) + + stringJSON = []byte(`"hello world this is a test string"`) + + multiArgsJSON = [][]byte{ + []byte(`"arg1"`), + []byte(`42`), + []byte(`true`), + []byte(`{"key":"value"}`), + } +) + +// Configure jsoniter for maximum compatibility +var jsoniterStd = jsoniter.ConfigCompatibleWithStandardLibrary + +// ============================================================================ +// UNMARSHAL BENCHMARKS - This is the HOT PATH (bindings.go:289) +// ============================================================================ + +// --- Simple struct unmarshal --- + +func BenchmarkUnmarshal_Simple_StdLib(b *testing.B) { + for b.Loop() { + var arg SimpleBindingArg + _ = json.Unmarshal(simpleJSON, &arg) + } +} + +func BenchmarkUnmarshal_Simple_GoJSON(b *testing.B) { + for b.Loop() { + var arg SimpleBindingArg + _ = gojson.Unmarshal(simpleJSON, &arg) + } +} + +func BenchmarkUnmarshal_Simple_JSONIter(b *testing.B) { + for b.Loop() { + var arg SimpleBindingArg + _ = jsoniterStd.Unmarshal(simpleJSON, &arg) + } +} + +func BenchmarkUnmarshal_Simple_Sonic(b *testing.B) { + for b.Loop() { + var arg SimpleBindingArg + _ = sonic.Unmarshal(simpleJSON, &arg) + } +} + +// --- Complex struct unmarshal --- + +func BenchmarkUnmarshal_Complex_StdLib(b *testing.B) { + for b.Loop() { + var arg ComplexBindingArg + _ = json.Unmarshal(complexJSON, &arg) + } +} + +func BenchmarkUnmarshal_Complex_GoJSON(b *testing.B) { + for b.Loop() { + var arg ComplexBindingArg + _ = gojson.Unmarshal(complexJSON, &arg) + } +} + +func BenchmarkUnmarshal_Complex_JSONIter(b *testing.B) { + for b.Loop() { + var arg ComplexBindingArg + _ = jsoniterStd.Unmarshal(complexJSON, &arg) + } +} + +func BenchmarkUnmarshal_Complex_Sonic(b *testing.B) { + for b.Loop() { + var arg ComplexBindingArg + _ = sonic.Unmarshal(complexJSON, &arg) + } +} + +// --- String unmarshal (most common single arg) --- + +func BenchmarkUnmarshal_String_StdLib(b *testing.B) { + for b.Loop() { + var arg string + _ = json.Unmarshal(stringJSON, &arg) + } +} + +func BenchmarkUnmarshal_String_GoJSON(b *testing.B) { + for b.Loop() { + var arg string + _ = gojson.Unmarshal(stringJSON, &arg) + } +} + +func BenchmarkUnmarshal_String_JSONIter(b *testing.B) { + for b.Loop() { + var arg string + _ = jsoniterStd.Unmarshal(stringJSON, &arg) + } +} + +func BenchmarkUnmarshal_String_Sonic(b *testing.B) { + for b.Loop() { + var arg string + _ = sonic.Unmarshal(stringJSON, &arg) + } +} + +// --- Interface{} unmarshal (dynamic typing) --- + +func BenchmarkUnmarshal_Interface_StdLib(b *testing.B) { + for b.Loop() { + var arg interface{} + _ = json.Unmarshal(complexJSON, &arg) + } +} + +func BenchmarkUnmarshal_Interface_GoJSON(b *testing.B) { + for b.Loop() { + var arg interface{} + _ = gojson.Unmarshal(complexJSON, &arg) + } +} + +func BenchmarkUnmarshal_Interface_JSONIter(b *testing.B) { + for b.Loop() { + var arg interface{} + _ = jsoniterStd.Unmarshal(complexJSON, &arg) + } +} + +func BenchmarkUnmarshal_Interface_Sonic(b *testing.B) { + for b.Loop() { + var arg interface{} + _ = sonic.Unmarshal(complexJSON, &arg) + } +} + +// --- Multi-arg unmarshal (simulating typical method call) --- + +func BenchmarkUnmarshal_MultiArgs_StdLib(b *testing.B) { + for b.Loop() { + var s string + var i int + var bl bool + var m map[string]string + _ = json.Unmarshal(multiArgsJSON[0], &s) + _ = json.Unmarshal(multiArgsJSON[1], &i) + _ = json.Unmarshal(multiArgsJSON[2], &bl) + _ = json.Unmarshal(multiArgsJSON[3], &m) + } +} + +func BenchmarkUnmarshal_MultiArgs_GoJSON(b *testing.B) { + for b.Loop() { + var s string + var i int + var bl bool + var m map[string]string + _ = gojson.Unmarshal(multiArgsJSON[0], &s) + _ = gojson.Unmarshal(multiArgsJSON[1], &i) + _ = gojson.Unmarshal(multiArgsJSON[2], &bl) + _ = gojson.Unmarshal(multiArgsJSON[3], &m) + } +} + +func BenchmarkUnmarshal_MultiArgs_JSONIter(b *testing.B) { + for b.Loop() { + var s string + var i int + var bl bool + var m map[string]string + _ = jsoniterStd.Unmarshal(multiArgsJSON[0], &s) + _ = jsoniterStd.Unmarshal(multiArgsJSON[1], &i) + _ = jsoniterStd.Unmarshal(multiArgsJSON[2], &bl) + _ = jsoniterStd.Unmarshal(multiArgsJSON[3], &m) + } +} + +func BenchmarkUnmarshal_MultiArgs_Sonic(b *testing.B) { + for b.Loop() { + var s string + var i int + var bl bool + var m map[string]string + _ = sonic.Unmarshal(multiArgsJSON[0], &s) + _ = sonic.Unmarshal(multiArgsJSON[1], &i) + _ = sonic.Unmarshal(multiArgsJSON[2], &bl) + _ = sonic.Unmarshal(multiArgsJSON[3], &m) + } +} + +// ============================================================================ +// MARSHAL BENCHMARKS - Result serialization +// ============================================================================ + +type BindingResult struct { + Success bool `json:"success"` + Data interface{} `json:"data,omitempty"` + Error string `json:"error,omitempty"` +} + +var simpleResult = BindingResult{ + Success: true, + Data: "hello world", +} + +var complexResult = BindingResult{ + Success: true, + Data: ComplexBindingArg{ + ID: 12345, + Name: "Result Data", + Tags: []string{"a", "b", "c"}, + Metadata: map[string]interface{}{ + "processed": true, + "count": 100, + }, + Nested: &NestedBindingArg{Value: 2.718, Enabled: true}, + }, +} + +// --- Simple result marshal --- + +func BenchmarkMarshal_Simple_StdLib(b *testing.B) { + for b.Loop() { + _, _ = json.Marshal(simpleResult) + } +} + +func BenchmarkMarshal_Simple_GoJSON(b *testing.B) { + for b.Loop() { + _, _ = gojson.Marshal(simpleResult) + } +} + +func BenchmarkMarshal_Simple_JSONIter(b *testing.B) { + for b.Loop() { + _, _ = jsoniterStd.Marshal(simpleResult) + } +} + +func BenchmarkMarshal_Simple_Sonic(b *testing.B) { + for b.Loop() { + _, _ = sonic.Marshal(simpleResult) + } +} + +// --- Complex result marshal --- + +func BenchmarkMarshal_Complex_StdLib(b *testing.B) { + for b.Loop() { + _, _ = json.Marshal(complexResult) + } +} + +func BenchmarkMarshal_Complex_GoJSON(b *testing.B) { + for b.Loop() { + _, _ = gojson.Marshal(complexResult) + } +} + +func BenchmarkMarshal_Complex_JSONIter(b *testing.B) { + for b.Loop() { + _, _ = jsoniterStd.Marshal(complexResult) + } +} + +func BenchmarkMarshal_Complex_Sonic(b *testing.B) { + for b.Loop() { + _, _ = sonic.Marshal(complexResult) + } +} diff --git a/v3/pkg/application/json_v2_bench_test.go b/v3/pkg/application/json_v2_bench_test.go new file mode 100644 index 000000000..d7b45193c --- /dev/null +++ b/v3/pkg/application/json_v2_bench_test.go @@ -0,0 +1,270 @@ +//go:build bench && goexperiment.jsonv2 + +package application_test + +import ( + "encoding/json" + "encoding/json/jsontext" + jsonv2 "encoding/json/v2" + "testing" +) + +// Benchmark structures matching real Wails usage patterns + +type SimpleArg struct { + Name string `json:"name"` + Value int `json:"value"` +} + +type ComplexArg struct { + ID int `json:"id"` + Name string `json:"name"` + Tags []string `json:"tags"` + Metadata map[string]interface{} `json:"metadata"` + Nested *NestedArg `json:"nested,omitempty"` +} + +type NestedArg struct { + Value float64 `json:"value"` + Enabled bool `json:"enabled"` +} + +type CallResult struct { + Success bool `json:"success"` + Data interface{} `json:"data,omitempty"` + Error string `json:"error,omitempty"` +} + +// Test data +var ( + simpleArgJSON = []byte(`{"name":"test","value":42}`) + complexArgJSON = []byte(`{ + "id": 12345, + "name": "Test Complex Data", + "tags": ["tag1", "tag2", "tag3", "tag4", "tag5"], + "metadata": {"key1": "value1", "key2": 42, "key3": true}, + "nested": {"value": 3.14159, "enabled": true} + }`) + + simpleResult = CallResult{ + Success: true, + Data: "hello world", + } + + complexResult = CallResult{ + Success: true, + Data: ComplexArg{ + ID: 12345, + Name: "Result Data", + Tags: []string{"a", "b", "c"}, + Metadata: map[string]interface{}{ + "processed": true, + "count": 100, + }, + Nested: &NestedArg{Value: 2.718, Enabled: true}, + }, + } +) + +// === UNMARSHAL BENCHMARKS (argument parsing) === + +func BenchmarkJSONv1_Unmarshal_Simple(b *testing.B) { + for b.Loop() { + var arg SimpleArg + _ = json.Unmarshal(simpleArgJSON, &arg) + } +} + +func BenchmarkJSONv2_Unmarshal_Simple(b *testing.B) { + for b.Loop() { + var arg SimpleArg + _ = jsonv2.Unmarshal(simpleArgJSON, &arg) + } +} + +func BenchmarkJSONv1_Unmarshal_Complex(b *testing.B) { + for b.Loop() { + var arg ComplexArg + _ = json.Unmarshal(complexArgJSON, &arg) + } +} + +func BenchmarkJSONv2_Unmarshal_Complex(b *testing.B) { + for b.Loop() { + var arg ComplexArg + _ = jsonv2.Unmarshal(complexArgJSON, &arg) + } +} + +func BenchmarkJSONv1_Unmarshal_Interface(b *testing.B) { + for b.Loop() { + var arg interface{} + _ = json.Unmarshal(complexArgJSON, &arg) + } +} + +func BenchmarkJSONv2_Unmarshal_Interface(b *testing.B) { + for b.Loop() { + var arg interface{} + _ = jsonv2.Unmarshal(complexArgJSON, &arg) + } +} + +// === MARSHAL BENCHMARKS (result serialization) === + +func BenchmarkJSONv1_Marshal_Simple(b *testing.B) { + for b.Loop() { + _, _ = json.Marshal(simpleResult) + } +} + +func BenchmarkJSONv2_Marshal_Simple(b *testing.B) { + for b.Loop() { + _, _ = jsonv2.Marshal(simpleResult) + } +} + +func BenchmarkJSONv1_Marshal_Complex(b *testing.B) { + for b.Loop() { + _, _ = json.Marshal(complexResult) + } +} + +func BenchmarkJSONv2_Marshal_Complex(b *testing.B) { + for b.Loop() { + _, _ = jsonv2.Marshal(complexResult) + } +} + +// === RAW MESSAGE HANDLING (common in Wails bindings) === + +func BenchmarkJSONv1_RawMessage_Unmarshal(b *testing.B) { + raw := json.RawMessage(complexArgJSON) + for b.Loop() { + var arg ComplexArg + _ = json.Unmarshal(raw, &arg) + } +} + +func BenchmarkJSONv2_RawMessage_Unmarshal(b *testing.B) { + raw := jsontext.Value(complexArgJSON) + for b.Loop() { + var arg ComplexArg + _ = jsonv2.Unmarshal(raw, &arg) + } +} + +// === SLICE ARGUMENTS (common pattern) === + +var sliceArgJSON = []byte(`[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`) +var largeSliceArgJSON = func() []byte { + data, _ := json.Marshal(make([]int, 100)) + return data +}() + +func BenchmarkJSONv1_Unmarshal_Slice(b *testing.B) { + for b.Loop() { + var arg []int + _ = json.Unmarshal(sliceArgJSON, &arg) + } +} + +func BenchmarkJSONv2_Unmarshal_Slice(b *testing.B) { + for b.Loop() { + var arg []int + _ = jsonv2.Unmarshal(sliceArgJSON, &arg) + } +} + +func BenchmarkJSONv1_Unmarshal_LargeSlice(b *testing.B) { + for b.Loop() { + var arg []int + _ = json.Unmarshal(largeSliceArgJSON, &arg) + } +} + +func BenchmarkJSONv2_Unmarshal_LargeSlice(b *testing.B) { + for b.Loop() { + var arg []int + _ = jsonv2.Unmarshal(largeSliceArgJSON, &arg) + } +} + +// === STRING ARGUMENT (most common) === + +var stringArgJSON = []byte(`"hello world this is a test string"`) + +func BenchmarkJSONv1_Unmarshal_String(b *testing.B) { + for b.Loop() { + var arg string + _ = json.Unmarshal(stringArgJSON, &arg) + } +} + +func BenchmarkJSONv2_Unmarshal_String(b *testing.B) { + for b.Loop() { + var arg string + _ = jsonv2.Unmarshal(stringArgJSON, &arg) + } +} + +// === MULTIPLE ARGUMENTS (simulating method call) === + +var multiArgJSON = [][]byte{ + []byte(`"arg1"`), + []byte(`42`), + []byte(`true`), + []byte(`{"key": "value"}`), +} + +func BenchmarkJSONv1_Unmarshal_MultiArgs(b *testing.B) { + for b.Loop() { + var s string + var i int + var bl bool + var m map[string]string + _ = json.Unmarshal(multiArgJSON[0], &s) + _ = json.Unmarshal(multiArgJSON[1], &i) + _ = json.Unmarshal(multiArgJSON[2], &bl) + _ = json.Unmarshal(multiArgJSON[3], &m) + } +} + +func BenchmarkJSONv2_Unmarshal_MultiArgs(b *testing.B) { + for b.Loop() { + var s string + var i int + var bl bool + var m map[string]string + _ = jsonv2.Unmarshal(multiArgJSON[0], &s) + _ = jsonv2.Unmarshal(multiArgJSON[1], &i) + _ = jsonv2.Unmarshal(multiArgJSON[2], &bl) + _ = jsonv2.Unmarshal(multiArgJSON[3], &m) + } +} + +// === ERROR RESPONSE MARSHALING === + +type ErrorResponse struct { + Code int `json:"code"` + Message string `json:"message"` + Details string `json:"details,omitempty"` +} + +var errorResp = ErrorResponse{ + Code: 500, + Message: "Internal server error", + Details: "Something went wrong while processing the request", +} + +func BenchmarkJSONv1_Marshal_Error(b *testing.B) { + for b.Loop() { + _, _ = json.Marshal(errorResp) + } +} + +func BenchmarkJSONv2_Marshal_Error(b *testing.B) { + for b.Loop() { + _, _ = jsonv2.Marshal(errorResp) + } +} diff --git a/v3/pkg/application/logger_ios.go b/v3/pkg/application/logger_ios.go index 559a033a4..ed77d09b5 100644 --- a/v3/pkg/application/logger_ios.go +++ b/v3/pkg/application/logger_ios.go @@ -12,18 +12,19 @@ import "C" import ( "bytes" "context" - "encoding/json" "log/slog" "strings" "time" "unsafe" + + json "github.com/goccy/go-json" ) // iosConsoleHandler implements slog.Handler and forwards records to the WKWebView console. type iosConsoleHandler struct { - level slog.Leveler - attrs []slog.Attr - group string + level slog.Leveler + attrs []slog.Attr + group string } func (h *iosConsoleHandler) Enabled(_ context.Context, lvl slog.Level) bool { diff --git a/v3/pkg/application/messageprocessor_args.go b/v3/pkg/application/messageprocessor_args.go index 838e389f5..3eeb98701 100644 --- a/v3/pkg/application/messageprocessor_args.go +++ b/v3/pkg/application/messageprocessor_args.go @@ -1,8 +1,9 @@ package application import ( - "encoding/json" "fmt" + + json "github.com/goccy/go-json" ) type Args struct { diff --git a/v3/pkg/application/messageprocessor_call.go b/v3/pkg/application/messageprocessor_call.go index 20023a5a6..9b58801da 100644 --- a/v3/pkg/application/messageprocessor_call.go +++ b/v3/pkg/application/messageprocessor_call.go @@ -2,9 +2,10 @@ package application import ( "context" - "encoding/json" "errors" + json "github.com/goccy/go-json" + "github.com/wailsapp/wails/v3/pkg/errs" ) diff --git a/v3/pkg/application/messageprocessor_events.go b/v3/pkg/application/messageprocessor_events.go index 9de3ae136..d251c6ace 100644 --- a/v3/pkg/application/messageprocessor_events.go +++ b/v3/pkg/application/messageprocessor_events.go @@ -1,7 +1,7 @@ package application import ( - "encoding/json" + json "github.com/goccy/go-json" "github.com/wailsapp/wails/v3/pkg/errs" ) diff --git a/v3/pkg/application/single_instance.go b/v3/pkg/application/single_instance.go index 24bbf5c31..681998874 100644 --- a/v3/pkg/application/single_instance.go +++ b/v3/pkg/application/single_instance.go @@ -5,11 +5,12 @@ import ( "crypto/cipher" "crypto/rand" "encoding/base64" - "encoding/json" "errors" "os" "path/filepath" "sync" + + json "github.com/goccy/go-json" ) var alreadyRunningError = errors.New("application is already running") diff --git a/v3/pkg/application/systemtray_bench_test.go b/v3/pkg/application/systemtray_bench_test.go new file mode 100644 index 000000000..3691f0f59 --- /dev/null +++ b/v3/pkg/application/systemtray_bench_test.go @@ -0,0 +1,374 @@ +//go:build bench + +package application + +import ( + "testing" + "time" +) + +// Note: SystemTray benchmarks are limited since actual system tray operations +// require platform-specific GUI initialization. These benchmarks focus on +// the Go-side logic that can be tested without a running GUI. + +// BenchmarkSystemTrayCreation measures the cost of creating SystemTray instances +func BenchmarkSystemTrayCreation(b *testing.B) { + for b.Loop() { + tray := newSystemTray(1) + _ = tray + } +} + +// BenchmarkSystemTrayConfiguration measures configuration operations +func BenchmarkSystemTrayConfiguration(b *testing.B) { + b.Run("SetLabel", func(b *testing.B) { + tray := newSystemTray(1) + // impl is nil, so this just sets the field + for b.Loop() { + tray.SetLabel("Test Label") + } + }) + + b.Run("SetTooltip", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.SetTooltip("Test Tooltip") + } + }) + + b.Run("SetIcon", func(b *testing.B) { + tray := newSystemTray(1) + icon := make([]byte, 1024) // 1KB icon data + for b.Loop() { + tray.SetIcon(icon) + } + }) + + b.Run("SetDarkModeIcon", func(b *testing.B) { + tray := newSystemTray(1) + icon := make([]byte, 1024) + for b.Loop() { + tray.SetDarkModeIcon(icon) + } + }) + + b.Run("SetTemplateIcon", func(b *testing.B) { + tray := newSystemTray(1) + icon := make([]byte, 1024) + for b.Loop() { + tray.SetTemplateIcon(icon) + } + }) + + b.Run("SetIconPosition", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.SetIconPosition(NSImageLeading) + } + }) + + b.Run("ChainedConfiguration", func(b *testing.B) { + icon := make([]byte, 1024) + for b.Loop() { + tray := newSystemTray(1) + tray.SetIcon(icon). + SetDarkModeIcon(icon). + SetIconPosition(NSImageLeading) + } + }) +} + +// BenchmarkClickHandlerExecution measures handler registration and invocation +func BenchmarkClickHandlerExecution(b *testing.B) { + b.Run("RegisterClickHandler", func(b *testing.B) { + for b.Loop() { + tray := newSystemTray(1) + tray.OnClick(func() {}) + } + }) + + b.Run("RegisterAllHandlers", func(b *testing.B) { + for b.Loop() { + tray := newSystemTray(1) + tray.OnClick(func() {}) + tray.OnRightClick(func() {}) + tray.OnDoubleClick(func() {}) + tray.OnRightDoubleClick(func() {}) + tray.OnMouseEnter(func() {}) + tray.OnMouseLeave(func() {}) + } + }) + + b.Run("InvokeClickHandler", func(b *testing.B) { + tray := newSystemTray(1) + counter := 0 + tray.OnClick(func() { + counter++ + }) + + b.ResetTimer() + for b.Loop() { + if tray.clickHandler != nil { + tray.clickHandler() + } + } + }) + + b.Run("InvokeAllHandlers", func(b *testing.B) { + tray := newSystemTray(1) + counter := 0 + handler := func() { counter++ } + tray.OnClick(handler) + tray.OnRightClick(handler) + tray.OnDoubleClick(handler) + tray.OnRightDoubleClick(handler) + tray.OnMouseEnter(handler) + tray.OnMouseLeave(handler) + + b.ResetTimer() + for b.Loop() { + if tray.clickHandler != nil { + tray.clickHandler() + } + if tray.rightClickHandler != nil { + tray.rightClickHandler() + } + if tray.doubleClickHandler != nil { + tray.doubleClickHandler() + } + if tray.rightDoubleClickHandler != nil { + tray.rightDoubleClickHandler() + } + if tray.mouseEnterHandler != nil { + tray.mouseEnterHandler() + } + if tray.mouseLeaveHandler != nil { + tray.mouseLeaveHandler() + } + } + }) +} + +// BenchmarkWindowAttachment measures window attachment configuration +func BenchmarkWindowAttachment(b *testing.B) { + b.Run("AttachWindow", func(b *testing.B) { + // We can't create real windows, but we can test the attachment logic + for b.Loop() { + tray := newSystemTray(1) + // AttachWindow accepts nil gracefully + tray.AttachWindow(nil) + } + }) + + b.Run("WindowOffset", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.WindowOffset(10) + } + }) + + b.Run("WindowDebounce", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.WindowDebounce(200 * time.Millisecond) + } + }) + + b.Run("ChainedAttachment", func(b *testing.B) { + for b.Loop() { + tray := newSystemTray(1) + tray.AttachWindow(nil). + WindowOffset(10). + WindowDebounce(200 * time.Millisecond) + } + }) +} + +// BenchmarkMenuConfiguration measures menu setup operations +func BenchmarkMenuConfiguration(b *testing.B) { + b.Run("SetNilMenu", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.SetMenu(nil) + } + }) + + b.Run("SetSimpleMenu", func(b *testing.B) { + menu := NewMenu() + menu.Add("Item 1") + menu.Add("Item 2") + menu.Add("Item 3") + + tray := newSystemTray(1) + b.ResetTimer() + for b.Loop() { + tray.SetMenu(menu) + } + }) + + b.Run("SetComplexMenu", func(b *testing.B) { + menu := NewMenu() + for i := 0; i < 20; i++ { + menu.Add("Item") + } + submenu := NewMenu() + for i := 0; i < 10; i++ { + submenu.Add("Subitem") + } + + tray := newSystemTray(1) + b.ResetTimer() + for b.Loop() { + tray.SetMenu(menu) + } + }) +} + +// BenchmarkIconSizes measures icon handling with different sizes +func BenchmarkIconSizes(b *testing.B) { + sizes := []struct { + name string + size int + }{ + {"16x16", 16 * 16 * 4}, // 1KB - small icon + {"32x32", 32 * 32 * 4}, // 4KB - medium icon + {"64x64", 64 * 64 * 4}, // 16KB - large icon + {"128x128", 128 * 128 * 4}, // 64KB - retina icon + {"256x256", 256 * 256 * 4}, // 256KB - high-res icon + } + + for _, size := range sizes { + b.Run(size.name, func(b *testing.B) { + icon := make([]byte, size.size) + tray := newSystemTray(1) + + b.ResetTimer() + for b.Loop() { + tray.SetIcon(icon) + } + }) + } +} + +// BenchmarkWindowAttachConfigInit measures WindowAttachConfig initialization +func BenchmarkWindowAttachConfigInit(b *testing.B) { + b.Run("DefaultConfig", func(b *testing.B) { + for b.Loop() { + config := WindowAttachConfig{ + Window: nil, + Offset: 0, + Debounce: 200 * time.Millisecond, + } + _ = config + } + }) + + b.Run("FullConfig", func(b *testing.B) { + for b.Loop() { + config := WindowAttachConfig{ + Window: nil, + Offset: 10, + Debounce: 300 * time.Millisecond, + justClosed: false, + hasBeenShown: true, + } + _ = config + } + }) +} + +// BenchmarkSystemTrayShowHide measures show/hide state changes +// Note: These operations are no-ops when impl is nil, but we measure the check overhead +func BenchmarkSystemTrayShowHide(b *testing.B) { + b.Run("Show", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.Show() + } + }) + + b.Run("Hide", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.Hide() + } + }) + + b.Run("ToggleShowHide", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.Show() + tray.Hide() + } + }) +} + +// BenchmarkIconPositionConstants measures icon position constant access +func BenchmarkIconPositionConstants(b *testing.B) { + positions := []IconPosition{ + NSImageNone, + NSImageOnly, + NSImageLeft, + NSImageRight, + NSImageBelow, + NSImageAbove, + NSImageOverlaps, + NSImageLeading, + NSImageTrailing, + } + + b.Run("SetAllPositions", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + for _, pos := range positions { + tray.SetIconPosition(pos) + } + } + }) +} + +// BenchmarkLabelOperations measures label getter/setter performance +func BenchmarkLabelOperations(b *testing.B) { + b.Run("SetLabel", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.SetLabel("System Tray Label") + } + }) + + b.Run("GetLabel", func(b *testing.B) { + tray := newSystemTray(1) + tray.SetLabel("System Tray Label") + b.ResetTimer() + for b.Loop() { + _ = tray.Label() + } + }) + + b.Run("SetGetLabel", func(b *testing.B) { + tray := newSystemTray(1) + for b.Loop() { + tray.SetLabel("Label") + _ = tray.Label() + } + }) +} + +// BenchmarkDefaultClickHandler measures the default click handler logic +func BenchmarkDefaultClickHandler(b *testing.B) { + b.Run("NoAttachedWindow", func(b *testing.B) { + tray := newSystemTray(1) + // With no menu and no attached window, defaultClickHandler returns early + for b.Loop() { + tray.defaultClickHandler() + } + }) + + b.Run("WithNilWindow", func(b *testing.B) { + tray := newSystemTray(1) + tray.attachedWindow.Window = nil + for b.Loop() { + tray.defaultClickHandler() + } + }) +} diff --git a/v3/pkg/application/transport_http.go b/v3/pkg/application/transport_http.go index 971628518..d043c9b53 100644 --- a/v3/pkg/application/transport_http.go +++ b/v3/pkg/application/transport_http.go @@ -1,17 +1,31 @@ package application import ( + "bytes" "context" - "encoding/json" "errors" "io" "log/slog" "net/http" "strconv" + "sync" + + json "github.com/goccy/go-json" "github.com/wailsapp/wails/v3/pkg/errs" ) +// bufferPool reduces allocations for reading request bodies. +// Buffers larger than maxPooledBufferSize are not returned to the pool +// to prevent memory bloat from occasional large requests (e.g., images). +const maxPooledBufferSize = 512 * 1024 // 512KB + +var bufferPool = sync.Pool{ + New: func() any { + return bytes.NewBuffer(make([]byte, 0, 4096)) + }, +} + type HTTPTransport struct { messageProcessor *MessageProcessor logger *slog.Logger @@ -75,14 +89,24 @@ func (t *HTTPTransport) Handler() func(next http.Handler) http.Handler { } func (t *HTTPTransport) handleRuntimeRequest(rw http.ResponseWriter, r *http.Request) { - bodyBytes, err := io.ReadAll(r.Body) + // Use pooled buffer to reduce allocations + buf := bufferPool.Get().(*bytes.Buffer) + buf.Reset() + defer func() { + // Don't return large buffers to pool to prevent memory bloat + if buf.Cap() <= maxPooledBufferSize { + bufferPool.Put(buf) + } + }() + + _, err := io.Copy(buf, r.Body) if err != nil { t.httpError(rw, errs.WrapInvalidRuntimeCallErrorf(err, "Unable to read request body")) return } var body request - err = json.Unmarshal(bodyBytes, &body) + err = json.Unmarshal(buf.Bytes(), &body) if err != nil { t.httpError(rw, errs.WrapInvalidRuntimeCallErrorf(err, "Unable to parse request body as JSON")) return diff --git a/v3/pkg/application/webview_window.go b/v3/pkg/application/webview_window.go index 2193a236b..95102c048 100644 --- a/v3/pkg/application/webview_window.go +++ b/v3/pkg/application/webview_window.go @@ -1,7 +1,6 @@ package application import ( - "encoding/json" "fmt" "runtime" "slices" @@ -10,9 +9,9 @@ import ( "sync/atomic" "unsafe" - "github.com/leaanthony/u" + json "github.com/goccy/go-json" - "github.com/samber/lo" + "github.com/leaanthony/u" "github.com/wailsapp/wails/v3/internal/assetserver" "github.com/wailsapp/wails/v3/pkg/events" ) @@ -772,7 +771,9 @@ func (w *WebviewWindow) OnWindowEvent( return func() { // Check if eventListener is already locked w.eventListenersLock.Lock() - w.eventListeners[eventID] = lo.Without(w.eventListeners[eventID], windowEventListener) + w.eventListeners[eventID] = slices.DeleteFunc(w.eventListeners[eventID], func(l *WindowEventListener) bool { + return l == windowEventListener + }) w.eventListenersLock.Unlock() } } @@ -793,7 +794,9 @@ func (w *WebviewWindow) RegisterHook( return func() { w.eventHooksLock.Lock() defer w.eventHooksLock.Unlock() - w.eventHooks[eventID] = lo.Without(w.eventHooks[eventID], windowEventHook) + w.eventHooks[eventID] = slices.DeleteFunc(w.eventHooks[eventID], func(l *WindowEventListener) bool { + return l == windowEventHook + }) } } diff --git a/v3/pkg/application/webview_window_windows.go b/v3/pkg/application/webview_window_windows.go index 5a0b9a30f..abc759d7b 100644 --- a/v3/pkg/application/webview_window_windows.go +++ b/v3/pkg/application/webview_window_windows.go @@ -20,8 +20,7 @@ import ( "github.com/wailsapp/wails/v3/internal/assetserver/webview" "github.com/wailsapp/wails/v3/internal/capabilities" "github.com/wailsapp/wails/v3/internal/runtime" - - "github.com/samber/lo" + "github.com/wailsapp/wails/v3/internal/sliceutil" "github.com/wailsapp/go-webview2/pkg/edge" "github.com/wailsapp/wails/v3/pkg/events" @@ -245,8 +244,14 @@ func (w *windowsWebviewWindow) setTitle(title string) { } func (w *windowsWebviewWindow) setAlwaysOnTop(alwaysOnTop bool) { + var hwndInsertAfter uintptr + if alwaysOnTop { + hwndInsertAfter = w32.HWND_TOPMOST + } else { + hwndInsertAfter = w32.HWND_NOTOPMOST + } w32.SetWindowPos(w.hwnd, - lo.Ternary(alwaysOnTop, w32.HWND_TOPMOST, w32.HWND_NOTOPMOST), + hwndInsertAfter, 0, 0, 0, @@ -1186,14 +1191,22 @@ func (w *windowsWebviewWindow) openContextMenu(menu *Menu, _ *ContextMenuData) { func (w *windowsWebviewWindow) setStyle(b bool, style int) { currentStyle := int(w32.GetWindowLongPtr(w.hwnd, w32.GWL_STYLE)) if currentStyle != 0 { - currentStyle = lo.Ternary(b, currentStyle|style, currentStyle&^style) + if b { + currentStyle = currentStyle | style + } else { + currentStyle = currentStyle &^ style + } w32.SetWindowLongPtr(w.hwnd, w32.GWL_STYLE, uintptr(currentStyle)) } } func (w *windowsWebviewWindow) setExStyle(b bool, style int) { currentStyle := int(w32.GetWindowLongPtr(w.hwnd, w32.GWL_EXSTYLE)) if currentStyle != 0 { - currentStyle = lo.Ternary(b, currentStyle|style, currentStyle&^style) + if b { + currentStyle = currentStyle | style + } else { + currentStyle = currentStyle &^ style + } w32.SetWindowLongPtr(w.hwnd, w32.GWL_EXSTYLE, uintptr(currentStyle)) } } @@ -1914,13 +1927,13 @@ func (w *windowsWebviewWindow) setupChromium() { opts.DisabledFeatures = append(opts.DisabledFeatures, "msSmartScreenProtection") if len(opts.DisabledFeatures) > 0 { - opts.DisabledFeatures = lo.Uniq(opts.DisabledFeatures) + opts.DisabledFeatures = sliceutil.Unique(opts.DisabledFeatures) arg := fmt.Sprintf("--disable-features=%s", strings.Join(opts.DisabledFeatures, ",")) chromium.AdditionalBrowserArgs = append(chromium.AdditionalBrowserArgs, arg) } if len(opts.EnabledFeatures) > 0 { - opts.EnabledFeatures = lo.Uniq(opts.EnabledFeatures) + opts.EnabledFeatures = sliceutil.Unique(opts.EnabledFeatures) arg := fmt.Sprintf("--enable-features=%s", strings.Join(opts.EnabledFeatures, ",")) chromium.AdditionalBrowserArgs = append(chromium.AdditionalBrowserArgs, arg) } diff --git a/v3/pkg/application/window_bench_test.go b/v3/pkg/application/window_bench_test.go new file mode 100644 index 000000000..31418053d --- /dev/null +++ b/v3/pkg/application/window_bench_test.go @@ -0,0 +1,442 @@ +//go:build bench + +package application + +import ( + "fmt" + "sync" + "testing" + + "github.com/wailsapp/wails/v3/pkg/events" +) + +// Note: This file uses internal package access to benchmark window internals +// without requiring GUI initialization. + +// BenchmarkWindowEventRegistration measures the cost of registering window event listeners +func BenchmarkWindowEventRegistration(b *testing.B) { + b.Run("SingleListener", func(b *testing.B) { + for b.Loop() { + w := &WebviewWindow{ + eventListeners: make(map[uint][]*WindowEventListener), + } + w.OnWindowEvent(events.Common.WindowFocus, func(event *WindowEvent) {}) + } + }) + + b.Run("MultipleListenersSameEvent", func(b *testing.B) { + for b.Loop() { + w := &WebviewWindow{ + eventListeners: make(map[uint][]*WindowEventListener), + } + for i := 0; i < 10; i++ { + w.OnWindowEvent(events.Common.WindowFocus, func(event *WindowEvent) {}) + } + } + }) + + b.Run("MultipleListenersDifferentEvents", func(b *testing.B) { + eventTypes := []events.WindowEventType{ + events.Common.WindowFocus, + events.Common.WindowLostFocus, + events.Common.WindowShow, + events.Common.WindowHide, + events.Common.WindowDidMove, + } + for b.Loop() { + w := &WebviewWindow{ + eventListeners: make(map[uint][]*WindowEventListener), + } + for _, evt := range eventTypes { + w.OnWindowEvent(evt, func(event *WindowEvent) {}) + } + } + }) +} + +// BenchmarkWindowHookRegistration measures the cost of registering window event hooks +func BenchmarkWindowHookRegistration(b *testing.B) { + b.Run("SingleHook", func(b *testing.B) { + eventID := uint(events.Common.WindowClosing) + for b.Loop() { + w := &WebviewWindow{ + eventHooks: make(map[uint][]*WindowEventListener), + } + w.eventHooksLock.Lock() + w.eventHooks[eventID] = append(w.eventHooks[eventID], &WindowEventListener{ + callback: func(event *WindowEvent) {}, + }) + w.eventHooksLock.Unlock() + } + }) + + b.Run("MultipleHooks", func(b *testing.B) { + eventID := uint(events.Common.WindowClosing) + for b.Loop() { + w := &WebviewWindow{ + eventHooks: make(map[uint][]*WindowEventListener), + } + for i := 0; i < 5; i++ { + w.eventHooksLock.Lock() + w.eventHooks[eventID] = append(w.eventHooks[eventID], &WindowEventListener{ + callback: func(event *WindowEvent) {}, + }) + w.eventHooksLock.Unlock() + } + } + }) +} + +// BenchmarkWindowEventDispatch measures the internal event dispatch mechanism +func BenchmarkWindowEventDispatch(b *testing.B) { + listenerCounts := []int{0, 1, 5, 10, 50} + + for _, count := range listenerCounts { + b.Run(fmt.Sprintf("Listeners%d", count), func(b *testing.B) { + w := &WebviewWindow{ + eventListeners: make(map[uint][]*WindowEventListener), + } + + eventID := uint(events.Common.WindowFocus) + + // Register listeners + for i := 0; i < count; i++ { + w.eventListeners[eventID] = append(w.eventListeners[eventID], &WindowEventListener{ + callback: func(event *WindowEvent) { + _ = event.IsCancelled() + }, + }) + } + + b.ResetTimer() + for b.Loop() { + w.eventListenersLock.RLock() + listeners := w.eventListeners[eventID] + w.eventListenersLock.RUnlock() + _ = listeners + } + }) + } +} + +// BenchmarkKeyBindingLookup measures key binding lookup performance +func BenchmarkKeyBindingLookup(b *testing.B) { + bindingCounts := []int{1, 10, 50, 100} + + for _, count := range bindingCounts { + b.Run(fmt.Sprintf("Bindings%d", count), func(b *testing.B) { + w := &WebviewWindow{ + keyBindings: make(map[string]func(Window)), + } + + // Register bindings + for i := 0; i < count; i++ { + key := fmt.Sprintf("ctrl+shift+%c", 'a'+i%26) + w.keyBindings[key] = func(Window) {} + } + + // Lookup key that exists + lookupKey := "ctrl+shift+m" + w.keyBindings[lookupKey] = func(Window) {} + + b.ResetTimer() + for b.Loop() { + w.keyBindingsLock.RLock() + _ = w.keyBindings[lookupKey] + w.keyBindingsLock.RUnlock() + } + }) + } + + b.Run("MissLookup", func(b *testing.B) { + w := &WebviewWindow{ + keyBindings: make(map[string]func(Window)), + } + + // Register some bindings + for i := 0; i < 50; i++ { + key := fmt.Sprintf("ctrl+shift+%c", 'a'+i%26) + w.keyBindings[key] = func(Window) {} + } + + lookupKey := "ctrl+alt+nonexistent" + + b.ResetTimer() + for b.Loop() { + w.keyBindingsLock.RLock() + _ = w.keyBindings[lookupKey] + w.keyBindingsLock.RUnlock() + } + }) +} + +// BenchmarkConcurrentWindowOps measures concurrent access patterns +func BenchmarkConcurrentWindowOps(b *testing.B) { + b.Run("ConcurrentEventLookup", func(b *testing.B) { + w := &WebviewWindow{ + eventListeners: make(map[uint][]*WindowEventListener), + } + + eventID := uint(events.Common.WindowFocus) + for i := 0; i < 10; i++ { + w.eventListeners[eventID] = append(w.eventListeners[eventID], &WindowEventListener{ + callback: func(event *WindowEvent) {}, + }) + } + + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + w.eventListenersLock.RLock() + _ = w.eventListeners[eventID] + w.eventListenersLock.RUnlock() + } + }) + }) + + b.Run("ConcurrentKeyBindingLookup", func(b *testing.B) { + w := &WebviewWindow{ + keyBindings: make(map[string]func(Window)), + } + + for i := 0; i < 50; i++ { + key := fmt.Sprintf("ctrl+shift+%c", 'a'+i%26) + w.keyBindings[key] = func(Window) {} + } + + keys := []string{"ctrl+shift+a", "ctrl+shift+m", "ctrl+shift+z"} + + b.RunParallel(func(pb *testing.PB) { + i := 0 + for pb.Next() { + w.keyBindingsLock.RLock() + _ = w.keyBindings[keys[i%len(keys)]] + w.keyBindingsLock.RUnlock() + i++ + } + }) + }) + + b.Run("MixedReadWrite", func(b *testing.B) { + w := &WebviewWindow{ + eventListeners: make(map[uint][]*WindowEventListener), + } + + eventID := uint(events.Common.WindowFocus) + + b.RunParallel(func(pb *testing.PB) { + i := 0 + for pb.Next() { + if i%10 == 0 { + // Write operation (10% of ops) + w.eventListenersLock.Lock() + w.eventListeners[eventID] = append(w.eventListeners[eventID], &WindowEventListener{ + callback: func(event *WindowEvent) {}, + }) + w.eventListenersLock.Unlock() + } else { + // Read operation (90% of ops) + w.eventListenersLock.RLock() + _ = w.eventListeners[eventID] + w.eventListenersLock.RUnlock() + } + i++ + } + }) + }) +} + +// BenchmarkWindowEventCreation measures WindowEvent allocation +func BenchmarkWindowEventCreation(b *testing.B) { + for b.Loop() { + event := NewWindowEvent() + _ = event + } +} + +// BenchmarkWindowEventCancellation measures cancel/check operations +func BenchmarkWindowEventCancellation(b *testing.B) { + b.Run("Cancel", func(b *testing.B) { + for b.Loop() { + event := NewWindowEvent() + event.Cancel() + } + }) + + b.Run("IsCancelled", func(b *testing.B) { + event := NewWindowEvent() + for b.Loop() { + _ = event.IsCancelled() + } + }) + + b.Run("CancelledCheck", func(b *testing.B) { + event := NewWindowEvent() + event.Cancel() + for b.Loop() { + _ = event.IsCancelled() + } + }) +} + +// BenchmarkWindowOptionsInit measures window options initialization patterns +func BenchmarkWindowOptionsInit(b *testing.B) { + b.Run("DefaultOptions", func(b *testing.B) { + for b.Loop() { + opts := WebviewWindowOptions{} + _ = opts + } + }) + + b.Run("CommonOptions", func(b *testing.B) { + for b.Loop() { + opts := WebviewWindowOptions{ + Title: "Test Window", + Width: 800, + Height: 600, + MinWidth: 400, + MinHeight: 300, + } + _ = opts + } + }) + + b.Run("FullOptions", func(b *testing.B) { + for b.Loop() { + opts := WebviewWindowOptions{ + Title: "Full Test Window", + Width: 1024, + Height: 768, + MinWidth: 400, + MinHeight: 300, + MaxWidth: 1920, + MaxHeight: 1080, + URL: "http://localhost:8080", + Frameless: false, + DisableResize: false, + AlwaysOnTop: false, + Hidden: false, + EnableDragAndDrop: true, + BackgroundColour: RGBA{Red: 255, Green: 255, Blue: 255, Alpha: 255}, + } + _ = opts + } + }) +} + +// BenchmarkMenuBindingLookup measures menu binding lookups +func BenchmarkMenuBindingLookup(b *testing.B) { + w := &WebviewWindow{ + menuBindings: make(map[string]*MenuItem), + } + + // Register some menu bindings + for i := 0; i < 50; i++ { + id := fmt.Sprintf("menu-item-%d", i) + w.menuBindings[id] = &MenuItem{id: uint(i)} + } + + lookupID := "menu-item-25" + + b.Run("Hit", func(b *testing.B) { + for b.Loop() { + w.menuBindingsLock.RLock() + _ = w.menuBindings[lookupID] + w.menuBindingsLock.RUnlock() + } + }) + + b.Run("Miss", func(b *testing.B) { + missID := "nonexistent-menu-item" + for b.Loop() { + w.menuBindingsLock.RLock() + _ = w.menuBindings[missID] + w.menuBindingsLock.RUnlock() + } + }) +} + +// BenchmarkWindowDestroyedCheck measures the destroyed flag check pattern +func BenchmarkWindowDestroyedCheck(b *testing.B) { + w := &WebviewWindow{} + + b.Run("NotDestroyed", func(b *testing.B) { + for b.Loop() { + w.destroyedLock.RLock() + _ = w.destroyed + w.destroyedLock.RUnlock() + } + }) + + b.Run("Destroyed", func(b *testing.B) { + w.destroyed = true + for b.Loop() { + w.destroyedLock.RLock() + _ = w.destroyed + w.destroyedLock.RUnlock() + } + }) +} + +// BenchmarkCancellerManagement measures canceller function management +func BenchmarkCancellerManagement(b *testing.B) { + b.Run("AddCanceller", func(b *testing.B) { + for b.Loop() { + w := &WebviewWindow{ + cancellers: make([]func(), 0), + } + for i := 0; i < 10; i++ { + w.cancellersLock.Lock() + w.cancellers = append(w.cancellers, func() {}) + w.cancellersLock.Unlock() + } + } + }) + + b.Run("ExecuteCancellers", func(b *testing.B) { + w := &WebviewWindow{ + cancellers: make([]func(), 100), + } + for i := 0; i < 100; i++ { + w.cancellers[i] = func() {} + } + + b.ResetTimer() + for b.Loop() { + w.cancellersLock.RLock() + cancellers := w.cancellers + w.cancellersLock.RUnlock() + for _, cancel := range cancellers { + cancel() + } + } + }) +} + +// BenchmarkRWMutexPatterns compares different locking patterns +func BenchmarkRWMutexPatterns(b *testing.B) { + b.Run("RLockUnlock", func(b *testing.B) { + var mu sync.RWMutex + for b.Loop() { + mu.RLock() + mu.RUnlock() + } + }) + + b.Run("LockUnlock", func(b *testing.B) { + var mu sync.RWMutex + for b.Loop() { + mu.Lock() + mu.Unlock() + } + }) + + b.Run("DeferredRLock", func(b *testing.B) { + var mu sync.RWMutex + for b.Loop() { + func() { + mu.RLock() + defer mu.RUnlock() + }() + } + }) +} diff --git a/v3/pkg/services/kvstore/kvstore.go b/v3/pkg/services/kvstore/kvstore.go index 899dd86ec..94ce6c61f 100644 --- a/v3/pkg/services/kvstore/kvstore.go +++ b/v3/pkg/services/kvstore/kvstore.go @@ -2,10 +2,10 @@ package kvstore import ( "context" - "encoding/json" "os" "sync" + json "github.com/goccy/go-json" "github.com/pkg/errors" "github.com/wailsapp/wails/v3/pkg/application" ) diff --git a/v3/pkg/services/notifications/notifications_darwin.go b/v3/pkg/services/notifications/notifications_darwin.go index c497e8c35..70a505fc9 100644 --- a/v3/pkg/services/notifications/notifications_darwin.go +++ b/v3/pkg/services/notifications/notifications_darwin.go @@ -15,12 +15,13 @@ package notifications import "C" import ( "context" - "encoding/json" "fmt" "sync" "time" "unsafe" + json "github.com/goccy/go-json" + "github.com/wailsapp/wails/v3/pkg/application" ) diff --git a/v3/pkg/services/notifications/notifications_linux.go b/v3/pkg/services/notifications/notifications_linux.go index 8dc9765cd..455f96cdb 100644 --- a/v3/pkg/services/notifications/notifications_linux.go +++ b/v3/pkg/services/notifications/notifications_linux.go @@ -4,12 +4,13 @@ package notifications import ( "context" - "encoding/json" "fmt" "os" "path/filepath" "sync" + json "github.com/goccy/go-json" + "github.com/godbus/dbus/v5" "github.com/wailsapp/wails/v3/pkg/application" ) diff --git a/v3/pkg/services/notifications/notifications_windows.go b/v3/pkg/services/notifications/notifications_windows.go index 1a1a6dd85..6bca1e747 100644 --- a/v3/pkg/services/notifications/notifications_windows.go +++ b/v3/pkg/services/notifications/notifications_windows.go @@ -5,13 +5,14 @@ package notifications import ( "context" "encoding/base64" - "encoding/json" "fmt" "os" "path/filepath" "sync" _ "unsafe" + json "github.com/goccy/go-json" + "git.sr.ht/~jackmordaunt/go-toast/v2" wintoast "git.sr.ht/~jackmordaunt/go-toast/v2/wintoast" "github.com/google/uuid" diff --git a/v3/pkg/w32/window.go b/v3/pkg/w32/window.go index 3e488a49c..c26ec414d 100644 --- a/v3/pkg/w32/window.go +++ b/v3/pkg/w32/window.go @@ -4,7 +4,6 @@ package w32 import ( "fmt" - "github.com/samber/lo" "strconv" "strings" "sync" @@ -180,17 +179,33 @@ func MustStringToUTF16Ptr(input string) *uint16 { return result } +// MustStringToUTF16uintptr converts input to a NUL-terminated UTF-16 buffer and returns its pointer as a uintptr. +// It first removes any internal NUL characters from input, then converts the result to a UTF-16 pointer. +// The function panics if the conversion fails. func MustStringToUTF16uintptr(input string) uintptr { input = stripNulls(input) - ret := lo.Must(syscall.UTF16PtrFromString(input)) + ret, err := syscall.UTF16PtrFromString(input) + if err != nil { + panic(err) + } return uintptr(unsafe.Pointer(ret)) } +// MustStringToUTF16 converts s to UTF-16 encoding, stripping any embedded NULs and panicking on error. +// +// The returned slice is suitable for Windows API calls that expect a UTF-16 encoded string. func MustStringToUTF16(input string) []uint16 { input = stripNulls(input) - return lo.Must(syscall.UTF16FromString(input)) + ret, err := syscall.UTF16FromString(input) + if err != nil { + panic(err) + } + return ret } +// StringToUTF16 converts input to a UTF-16 encoded, NUL-terminated []uint16 suitable for Windows API calls. +// It first removes any embedded NUL ('\x00') characters from input. The returned slice is NUL-terminated; +// an error is returned if the conversion fails. func StringToUTF16(input string) ([]uint16, error) { input = stripNulls(input) return syscall.UTF16FromString(input) @@ -359,4 +374,4 @@ func SendMessageToWindow(hwnd HWND, msg string) { func GetMenu(hwnd HWND) HMENU { ret, _, _ := getMenuProc.Call(hwnd) return ret -} +} \ No newline at end of file From 0b6dfe032cb0968a09174c7c8a2e15fa7bc6c765 Mon Sep 17 00:00:00 2001 From: Ndianabasi Udonkang Date: Fri, 2 Jan 2026 01:21:22 +0100 Subject: [PATCH 16/40] Improve Build Commands to Accommodate Spaces (#4845) * fix: improve darwin build commands to accommodate spaces in APP_NAME * fix: improve android build commands to accommodate spaces in APP_NAME * fix: improve ios build commands to accommodate spaces in APP_NAME * fix: improve linux build commands to accommodate spaces in APP_NAME * fix: improve windows build commands to accommodate spaces in APP_NAME * docs: update `v3/UNRELEASED_CHANGELOG.md` * fix(docs): correct changelog * fix: remove quotes around GO_CACHE_MOUNT and REPLACE_MOUNTS --------- Co-authored-by: Lea Anthony --- v3/UNRELEASED_CHANGELOG.md | 2 +- .../build_assets/android/Taskfile.yml | 8 ++--- .../commands/build_assets/darwin/Taskfile.yml | 28 +++++++-------- .../commands/build_assets/ios/Taskfile.yml | 36 +++++++++---------- .../commands/build_assets/linux/Taskfile.yml | 22 ++++++------ .../build_assets/windows/Taskfile.yml | 8 ++--- 6 files changed, 52 insertions(+), 52 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index c4109328c..abe9f78a6 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -31,7 +31,7 @@ After processing, the content will be moved to the main changelog and this file - Expand MIME type extension map to cover 50+ common web formats (fonts, audio, video, etc.) ## Fixed - +- Update all commands in Taskfile.yml files for all operating systems to accommodate spaces in variables such as `APP_NAME` by @ndianabasi ## Deprecated diff --git a/v3/internal/commands/build_assets/android/Taskfile.yml b/v3/internal/commands/build_assets/android/Taskfile.yml index 5005f9f4e..aca62e4f9 100644 --- a/v3/internal/commands/build_assets/android/Taskfile.yml +++ b/v3/internal/commands/build_assets/android/Taskfile.yml @@ -125,7 +125,7 @@ tasks: - | cd build/android ./gradlew assembleDebug - cp app/build/outputs/apk/debug/app-debug.apk ../../{{.BIN_DIR}}/{{.APP_NAME}}.apk + cp app/build/outputs/apk/debug/app-debug.apk "../../{{.BIN_DIR}}/{{.APP_NAME}}.apk" echo "APK created: {{.BIN_DIR}}/{{.APP_NAME}}.apk" assemble:apk:release: @@ -134,7 +134,7 @@ tasks: - | cd build/android ./gradlew assembleRelease - cp app/build/outputs/apk/release/app-release-unsigned.apk ../../{{.BIN_DIR}}/{{.APP_NAME}}-release.apk + cp app/build/outputs/apk/release/app-release-unsigned.apk "../../{{.BIN_DIR}}/{{.APP_NAME}}-release.apk" echo "Release APK created: {{.BIN_DIR}}/{{.APP_NAME}}-release.apk" generate:android:bindings: @@ -202,7 +202,7 @@ tasks: deps: [package] cmds: - adb uninstall {{.APP_ID}} 2>/dev/null || true - - adb install {{.BIN_DIR}}/{{.APP_NAME}}.apk + - adb install "{{.BIN_DIR}}/{{.APP_NAME}}.apk" - adb shell am start -n {{.APP_ID}}/.MainActivity run: @@ -215,7 +215,7 @@ tasks: cmds: - task: assemble:apk - adb uninstall {{.APP_ID}} 2>/dev/null || true - - adb install {{.BIN_DIR}}/{{.APP_NAME}}.apk + - adb install "{{.BIN_DIR}}/{{.APP_NAME}}.apk" - adb shell am start -n {{.APP_ID}}/.MainActivity logs: diff --git a/v3/internal/commands/build_assets/darwin/Taskfile.yml b/v3/internal/commands/build_assets/darwin/Taskfile.yml index 054da1a63..b76d5bae0 100644 --- a/v3/internal/commands/build_assets/darwin/Taskfile.yml +++ b/v3/internal/commands/build_assets/darwin/Taskfile.yml @@ -65,10 +65,10 @@ tasks: Docker image '{{.CROSS_IMAGE}}' not found. Build it first: wails3 task setup:docker cmds: - - docker run --rm -v "{{.ROOT_DIR}}:/app" {{.GO_CACHE_MOUNT}} {{.REPLACE_MOUNTS}} -e APP_NAME={{.APP_NAME}} {{.CROSS_IMAGE}} darwin {{.DOCKER_ARCH}} + - docker run --rm -v "{{.ROOT_DIR}}:/app" {{.GO_CACHE_MOUNT}} {{.REPLACE_MOUNTS}} -e APP_NAME="{{.APP_NAME}}" {{.CROSS_IMAGE}} darwin {{.DOCKER_ARCH}} - docker run --rm -v "{{.ROOT_DIR}}:/app" alpine chown -R $(id -u):$(id -g) /app/bin - mkdir -p {{.BIN_DIR}} - - mv bin/{{.APP_NAME}}-darwin-{{.DOCKER_ARCH}} {{.OUTPUT}} + - mv "bin/{{.APP_NAME}}-darwin-{{.DOCKER_ARCH}}" "{{.OUTPUT}}" vars: DOCKER_ARCH: '{{if eq .ARCH "arm64"}}arm64{{else if eq .ARCH "amd64"}}amd64{{else}}arm64{{end}}' DEFAULT_OUTPUT: '{{.BIN_DIR}}/{{.APP_NAME}}' @@ -138,17 +138,17 @@ tasks: create:app:bundle: summary: Creates an `.app` bundle cmds: - - mkdir -p {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/{MacOS,Resources} - - cp build/darwin/icons.icns {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/Resources - - cp {{.BIN_DIR}}/{{.APP_NAME}} {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/MacOS - - cp build/darwin/Info.plist {{.BIN_DIR}}/{{.APP_NAME}}.app/Contents + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/{MacOS,Resources}" + - cp build/darwin/icons.icns "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/Resources" + - cp "{{.BIN_DIR}}/{{.APP_NAME}}" "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/MacOS" + - cp build/darwin/Info.plist "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents" - task: '{{if eq OS "darwin"}}codesign:adhoc{{else}}codesign:skip{{end}}' codesign:adhoc: summary: Ad-hoc signs the app bundle (macOS only) internal: true cmds: - - codesign --force --deep --sign - {{.BIN_DIR}}/{{.APP_NAME}}.app + - codesign --force --deep --sign - "{{.BIN_DIR}}/{{.APP_NAME}}.app" codesign:skip: summary: Skips codesigning when cross-compiling @@ -158,11 +158,11 @@ tasks: run: cmds: - - mkdir -p {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/{MacOS,Resources} - - cp build/darwin/icons.icns {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Resources - - cp {{.BIN_DIR}}/{{.APP_NAME}} {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/MacOS - - cp build/darwin/Info.dev.plist {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Info.plist - - codesign --force --deep --sign - {{.BIN_DIR}}/{{.APP_NAME}}.dev.app + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/{MacOS,Resources}" + - cp build/darwin/icons.icns "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Resources" + - cp "{{.BIN_DIR}}/{{.APP_NAME}}" "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/MacOS" + - cp "build/darwin/Info.dev.plist" "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Info.plist" + - codesign --force --deep --sign - "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app" - '{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/MacOS/{{.APP_NAME}}' sign: @@ -173,7 +173,7 @@ tasks: deps: - task: package cmds: - - wails3 tool sign --input {{.BIN_DIR}}/{{.APP_NAME}}.app --identity "{{.SIGN_IDENTITY}}" {{if .ENTITLEMENTS}}--entitlements {{.ENTITLEMENTS}}{{end}} + - wails3 tool sign --input "{{.BIN_DIR}}/{{.APP_NAME}}.app" --identity "{{.SIGN_IDENTITY}}" {{if .ENTITLEMENTS}}--entitlements {{.ENTITLEMENTS}}{{end}} preconditions: - sh: '[ -n "{{.SIGN_IDENTITY}}" ]' msg: "SIGN_IDENTITY is required. Set it in the vars section at the top of build/darwin/Taskfile.yml" @@ -189,7 +189,7 @@ tasks: deps: - task: package cmds: - - wails3 tool sign --input {{.BIN_DIR}}/{{.APP_NAME}}.app --identity "{{.SIGN_IDENTITY}}" {{if .ENTITLEMENTS}}--entitlements {{.ENTITLEMENTS}}{{end}} --notarize --keychain-profile {{.KEYCHAIN_PROFILE}} + - wails3 tool sign --input "{{.BIN_DIR}}/{{.APP_NAME}}.app" --identity "{{.SIGN_IDENTITY}}" {{if .ENTITLEMENTS}}--entitlements {{.ENTITLEMENTS}}{{end}} --notarize --keychain-profile {{.KEYCHAIN_PROFILE}} preconditions: - sh: '[ -n "{{.SIGN_IDENTITY}}" ]' msg: "SIGN_IDENTITY is required. Set it in the vars section at the top of build/darwin/Taskfile.yml" diff --git a/v3/internal/commands/build_assets/ios/Taskfile.yml b/v3/internal/commands/build_assets/ios/Taskfile.yml index 19f57f04f..8c27f0894 100644 --- a/v3/internal/commands/build_assets/ios/Taskfile.yml +++ b/v3/internal/commands/build_assets/ios/Taskfile.yml @@ -61,7 +61,7 @@ tasks: sh: xcrun --sdk iphonesimulator --show-sdk-path cmds: - xcrun -sdk iphonesimulator clang -target arm64-apple-ios15.0-simulator -isysroot {{.SDK_PATH}} -framework Foundation -framework UIKit -framework WebKit -o {{.BIN_DIR}}/{{.APP_NAME}} build/ios/main.m - - codesign --force --sign - {{.BIN_DIR}}/{{.APP_NAME}} + - codesign --force --sign - "{{.BIN_DIR}}/{{.APP_NAME}}" package: summary: Packages a production build of the application into a `.app` bundle @@ -75,10 +75,10 @@ tasks: create:app:bundle: summary: Creates an iOS `.app` bundle cmds: - - rm -rf {{.BIN_DIR}}/{{.APP_NAME}}.app - - mkdir -p {{.BIN_DIR}}/{{.APP_NAME}}.app - - cp {{.BIN_DIR}}/{{.APP_NAME}} {{.BIN_DIR}}/{{.APP_NAME}}.app/ - - cp build/ios/Info.plist {{.BIN_DIR}}/{{.APP_NAME}}.app/ + - rm -rf "{{.BIN_DIR}}/{{.APP_NAME}}.app" + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.app" + - cp "{{.BIN_DIR}}/{{.APP_NAME}}" "{{.BIN_DIR}}/{{.APP_NAME}}.app/" + - cp build/ios/Info.plist "{{.BIN_DIR}}/{{.APP_NAME}}.app/" - | # Compile asset catalog and embed icons in the app bundle APP_BUNDLE="{{.BIN_DIR}}/{{.APP_NAME}}.app" @@ -103,7 +103,7 @@ tasks: /usr/libexec/PlistBuddy -c "Merge $APP_BUNDLE/assetcatalog_generated_info.plist" "$APP_BUNDLE/Info.plist" || true fi fi - - codesign --force --sign - {{.BIN_DIR}}/{{.APP_NAME}}.app + - codesign --force --sign - "{{.BIN_DIR}}/{{.APP_NAME}}.app" deploy-simulator: summary: Deploy to iOS Simulator @@ -111,7 +111,7 @@ tasks: cmds: - xcrun simctl terminate booted {{.BUNDLE_ID}} 2>/dev/null || true - xcrun simctl uninstall booted {{.BUNDLE_ID}} 2>/dev/null || true - - xcrun simctl install booted {{.BIN_DIR}}/{{.APP_NAME}}.app + - xcrun simctl install booted "{{.BIN_DIR}}/{{.APP_NAME}}.app" - xcrun simctl launch booted {{.BUNDLE_ID}} compile:ios: @@ -133,8 +133,8 @@ tasks: -framework Foundation -framework UIKit -framework WebKit \ -framework Security -framework CoreFoundation \ -lresolv \ - -o {{.BIN_DIR}}/{{.APP_NAME | lower}} \ - "$MAIN_M" {{.BIN_DIR}}/{{.APP_NAME}}.a + -o "{{.BIN_DIR}}/{{.APP_NAME | lower}}" \ + "$MAIN_M" "{{.BIN_DIR}}/{{.APP_NAME}}.a" generate:ios:bindings: internal: true @@ -225,10 +225,10 @@ tasks: - task: ensure-simulator - task: compile:ios cmds: - - rm -rf {{.BIN_DIR}}/{{.APP_NAME}}.dev.app - - mkdir -p {{.BIN_DIR}}/{{.APP_NAME}}.dev.app - - cp {{.BIN_DIR}}/{{.APP_NAME | lower}} {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/{{.APP_NAME | lower}} - - cp build/ios/Info.dev.plist {{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Info.plist + - rm -rf "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app" + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app" + - cp "{{.BIN_DIR}}/{{.APP_NAME | lower}}" "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/{{.APP_NAME | lower}}" + - cp build/ios/Info.dev.plist "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Info.plist" - | # Compile asset catalog and embed icons for dev bundle APP_BUNDLE="{{.BIN_DIR}}/{{.APP_NAME}}.dev.app" @@ -253,11 +253,11 @@ tasks: /usr/libexec/PlistBuddy -c "Merge $APP_BUNDLE/assetcatalog_generated_info.plist" "$APP_BUNDLE/Info.plist" || true fi fi - - codesign --force --sign - {{.BIN_DIR}}/{{.APP_NAME}}.dev.app - - xcrun simctl terminate booted com.wails.{{.APP_NAME | lower}}.dev 2>/dev/null || true - - xcrun simctl uninstall booted com.wails.{{.APP_NAME | lower}}.dev 2>/dev/null || true - - xcrun simctl install booted {{.BIN_DIR}}/{{.APP_NAME}}.dev.app - - xcrun simctl launch booted com.wails.{{.APP_NAME | lower}}.dev + - codesign --force --sign - "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app" + - xcrun simctl terminate booted "com.wails.{{.APP_NAME | lower}}.dev" 2>/dev/null || true + - xcrun simctl uninstall booted "com.wails.{{.APP_NAME | lower}}.dev" 2>/dev/null || true + - xcrun simctl install booted "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app" + - xcrun simctl launch booted "com.wails.{{.APP_NAME | lower}}.dev" xcode: summary: Open the generated Xcode project for this app diff --git a/v3/internal/commands/build_assets/linux/Taskfile.yml b/v3/internal/commands/build_assets/linux/Taskfile.yml index 69e3e727a..c29558671 100644 --- a/v3/internal/commands/build_assets/linux/Taskfile.yml +++ b/v3/internal/commands/build_assets/linux/Taskfile.yml @@ -69,10 +69,10 @@ tasks: Docker image '{{.CROSS_IMAGE}}' not found. Build it first: wails3 task setup:docker cmds: - - docker run --rm -v "{{.ROOT_DIR}}:/app" {{.GO_CACHE_MOUNT}} {{.REPLACE_MOUNTS}} -e APP_NAME={{.APP_NAME}} {{.CROSS_IMAGE}} linux {{.DOCKER_ARCH}} + - docker run --rm -v "{{.ROOT_DIR}}:/app" {{.GO_CACHE_MOUNT}} {{.REPLACE_MOUNTS}} -e APP_NAME="{{.APP_NAME}}" "{{.CROSS_IMAGE}}" linux {{.DOCKER_ARCH}} - docker run --rm -v "{{.ROOT_DIR}}:/app" alpine chown -R $(id -u):$(id -g) /app/bin - mkdir -p {{.BIN_DIR}} - - mv bin/{{.APP_NAME}}-linux-{{.DOCKER_ARCH}} {{.OUTPUT}} + - mv "bin/{{.APP_NAME}}-linux-{{.DOCKER_ARCH}}" "{{.OUTPUT}}" vars: DOCKER_ARCH: '{{.ARCH | default "amd64"}}' DEFAULT_OUTPUT: '{{.BIN_DIR}}/{{.APP_NAME}}' @@ -112,9 +112,9 @@ tasks: - task: build - task: generate:dotdesktop cmds: - - cp {{.APP_BINARY}} {{.APP_NAME}} - - cp ../../appicon.png {{.APP_NAME}}.png - - wails3 generate appimage -binary {{.APP_NAME}} -icon {{.ICON}} -desktopfile {{.DESKTOP_FILE}} -outputdir {{.OUTPUT_DIR}} -builddir {{.ROOT_DIR}}/build/linux/appimage/build + - cp "{{.APP_BINARY}}" "{{.APP_NAME}}" + - cp ../../appicon.png "{{.APP_NAME}}.png" + - wails3 generate appimage -binary "{{.APP_NAME}}" -icon {{.ICON}} -desktopfile {{.DESKTOP_FILE}} -outputdir {{.OUTPUT_DIR}} -builddir {{.ROOT_DIR}}/build/linux/appimage/build vars: APP_NAME: '{{.APP_NAME}}' APP_BINARY: '../../../bin/{{.APP_NAME}}' @@ -149,24 +149,24 @@ tasks: generate:deb: summary: Creates a deb package cmds: - - wails3 tool package -name {{.APP_NAME}} -format deb -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin + - wails3 tool package -name "{{.APP_NAME}}" -format deb -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin generate:rpm: summary: Creates a rpm package cmds: - - wails3 tool package -name {{.APP_NAME}} -format rpm -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin + - wails3 tool package -name "{{.APP_NAME}}" -format rpm -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin generate:aur: summary: Creates a arch linux packager package cmds: - - wails3 tool package -name {{.APP_NAME}} -format archlinux -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin + - wails3 tool package -name "{{.APP_NAME}}" -format archlinux -config ./build/linux/nfpm/nfpm.yaml -out {{.ROOT_DIR}}/bin generate:dotdesktop: summary: Generates a `.desktop` file dir: build cmds: - mkdir -p {{.ROOT_DIR}}/build/linux/appimage - - wails3 generate .desktop -name "{{.APP_NAME}}" -exec "{{.EXEC}}" -icon "{{.ICON}}" -outputfile {{.ROOT_DIR}}/build/linux/{{.APP_NAME}}.desktop -categories "{{.CATEGORIES}}" + - wails3 generate .desktop -name "{{.APP_NAME}}" -exec "{{.EXEC}}" -icon "{{.ICON}}" -outputfile "{{.ROOT_DIR}}/build/linux/{{.APP_NAME}}.desktop" -categories "{{.CATEGORIES}}" vars: APP_NAME: '{{.APP_NAME}}' EXEC: '{{.APP_NAME}}' @@ -187,7 +187,7 @@ tasks: deps: - task: create:deb cmds: - - wails3 tool sign --input {{.BIN_DIR}}/{{.APP_NAME}}*.deb --pgp-key {{.PGP_KEY}} {{if .SIGN_ROLE}}--role {{.SIGN_ROLE}}{{end}} + - wails3 tool sign --input "{{.BIN_DIR}}/{{.APP_NAME}}*.deb" --pgp-key {{.PGP_KEY}} {{if .SIGN_ROLE}}--role {{.SIGN_ROLE}}{{end}} preconditions: - sh: '[ -n "{{.PGP_KEY}}" ]' msg: "PGP_KEY is required. Set it in the vars section at the top of build/linux/Taskfile.yml" @@ -201,7 +201,7 @@ tasks: deps: - task: create:rpm cmds: - - wails3 tool sign --input {{.BIN_DIR}}/{{.APP_NAME}}*.rpm --pgp-key {{.PGP_KEY}} + - wails3 tool sign --input "{{.BIN_DIR}}/{{.APP_NAME}}*.rpm" --pgp-key {{.PGP_KEY}} preconditions: - sh: '[ -n "{{.PGP_KEY}}" ]' msg: "PGP_KEY is required. Set it in the vars section at the top of build/linux/Taskfile.yml" diff --git a/v3/internal/commands/build_assets/windows/Taskfile.yml b/v3/internal/commands/build_assets/windows/Taskfile.yml index 1ca955f67..77b620b7d 100644 --- a/v3/internal/commands/build_assets/windows/Taskfile.yml +++ b/v3/internal/commands/build_assets/windows/Taskfile.yml @@ -41,7 +41,7 @@ tasks: - task: common:generate:icons cmds: - task: generate:syso - - go build {{.BUILD_FLAGS}} -o {{.BIN_DIR}}/{{.APP_NAME}}.exe + - go build {{.BUILD_FLAGS}} -o "{{.BIN_DIR}}/{{.APP_NAME}}.exe" - cmd: powershell Remove-item *.syso platforms: [windows] - cmd: rm -f *.syso @@ -68,7 +68,7 @@ tasks: Build it first: wails3 task setup:docker cmds: - task: generate:syso - - docker run --rm -v "{{.ROOT_DIR}}:/app" {{.GO_CACHE_MOUNT}} {{.REPLACE_MOUNTS}} -e APP_NAME={{.APP_NAME}} {{.CROSS_IMAGE}} windows {{.DOCKER_ARCH}} + - docker run --rm -v "{{.ROOT_DIR}}:/app" {{.GO_CACHE_MOUNT}} {{.REPLACE_MOUNTS}} -e APP_NAME="{{.APP_NAME}}" {{.CROSS_IMAGE}} windows {{.DOCKER_ARCH}} - docker run --rm -v "{{.ROOT_DIR}}:/app" alpine chown -R $(id -u):$(id -g) /app/bin - rm -f *.syso vars: @@ -163,7 +163,7 @@ tasks: deps: - task: build cmds: - - wails3 tool sign --input {{.BIN_DIR}}/{{.APP_NAME}}.exe {{if .SIGN_CERTIFICATE}}--certificate {{.SIGN_CERTIFICATE}}{{end}} {{if .SIGN_THUMBPRINT}}--thumbprint {{.SIGN_THUMBPRINT}}{{end}} {{if .TIMESTAMP_SERVER}}--timestamp {{.TIMESTAMP_SERVER}}{{end}} + - wails3 tool sign --input "{{.BIN_DIR}}/{{.APP_NAME}}.exe" {{if .SIGN_CERTIFICATE}}--certificate {{.SIGN_CERTIFICATE}}{{end}} {{if .SIGN_THUMBPRINT}}--thumbprint {{.SIGN_THUMBPRINT}}{{end}} {{if .TIMESTAMP_SERVER}}--timestamp {{.TIMESTAMP_SERVER}}{{end}} preconditions: - sh: '[ -n "{{.SIGN_CERTIFICATE}}" ] || [ -n "{{.SIGN_THUMBPRINT}}" ]' msg: "Either SIGN_CERTIFICATE or SIGN_THUMBPRINT is required. Set it in the vars section at the top of build/windows/Taskfile.yml" @@ -177,7 +177,7 @@ tasks: deps: - task: create:nsis:installer cmds: - - wails3 tool sign --input build/windows/nsis/{{.APP_NAME}}-installer.exe {{if .SIGN_CERTIFICATE}}--certificate {{.SIGN_CERTIFICATE}}{{end}} {{if .SIGN_THUMBPRINT}}--thumbprint {{.SIGN_THUMBPRINT}}{{end}} {{if .TIMESTAMP_SERVER}}--timestamp {{.TIMESTAMP_SERVER}}{{end}} + - wails3 tool sign --input "build/windows/nsis/{{.APP_NAME}}-installer.exe" {{if .SIGN_CERTIFICATE}}--certificate {{.SIGN_CERTIFICATE}}{{end}} {{if .SIGN_THUMBPRINT}}--thumbprint {{.SIGN_THUMBPRINT}}{{end}} {{if .TIMESTAMP_SERVER}}--timestamp {{.TIMESTAMP_SERVER}}{{end}} preconditions: - sh: '[ -n "{{.SIGN_CERTIFICATE}}" ] || [ -n "{{.SIGN_THUMBPRINT}}" ]' msg: "Either SIGN_CERTIFICATE or SIGN_THUMBPRINT is required. Set it in the vars section at the top of build/windows/Taskfile.yml" From 53cd30acc77c5f891599d981db36df27f86a545c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 2 Jan 2026 02:46:35 +0000 Subject: [PATCH 17/40] chore(v3): bump to v3.0.0-alpha.55 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 21 +++++++++++++++++++++ v3/UNRELEASED_CHANGELOG.md | 14 +------------- v3/internal/version/version.txt | 2 +- 3 files changed, 23 insertions(+), 14 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index d0edd228a..15463dde6 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.55 - 2026-01-02 + +## Changed +- Switch to goccy/go-json for all runtime JSON processing (method bindings, events, webview requests, notifications, kvstore), improving performance by 21-63% and reducing memory allocations by 40-60% +- Optimize BoundMethod struct layout and cache isVariadic flag to reduce per-call overhead +- Use stack-allocated argument buffer for methods with <=8 arguments to avoid heap allocations +- Optimize result collection in method calls to avoid slice allocation for single return values +- Use sync.Map for MIME type cache to improve concurrent performance +- Use buffer pool for HTTP transport request body reading +- Lazily allocate CloseNotify channel in content type sniffer to reduce per-request allocations +- Remove debug CSS logging from asset server +- Expand MIME type extension map to cover 50+ common web formats (fonts, audio, video, etc.) + +## Fixed +- Update all commands in Taskfile.yml files for all operating systems to accommodate spaces in variables such as `APP_NAME` by @ndianabasi + +## Removed +- Remove github.com/wailsapp/mimetype dependency in favor of expanded extension map + stdlib http.DetectContentType, reducing binary size by ~1.2MB +- Remove gopkg.in/ini.v1 dependency by implementing minimal .desktop file parser for Linux file explorer, saving ~45KB +- Remove samber/lo from runtime code by using Go 1.21+ stdlib slices package and minimal internal helpers, saving ~310KB + ## v3.0.0-alpha.54 - 2025-12-29 ## Added diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index abe9f78a6..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -20,27 +20,15 @@ After processing, the content will be moved to the main changelog and this file ## Changed -- Switch to goccy/go-json for all runtime JSON processing (method bindings, events, webview requests, notifications, kvstore), improving performance by 21-63% and reducing memory allocations by 40-60% -- Optimize BoundMethod struct layout and cache isVariadic flag to reduce per-call overhead -- Use stack-allocated argument buffer for methods with <=8 arguments to avoid heap allocations -- Optimize result collection in method calls to avoid slice allocation for single return values -- Use sync.Map for MIME type cache to improve concurrent performance -- Use buffer pool for HTTP transport request body reading -- Lazily allocate CloseNotify channel in content type sniffer to reduce per-request allocations -- Remove debug CSS logging from asset server -- Expand MIME type extension map to cover 50+ common web formats (fonts, audio, video, etc.) ## Fixed -- Update all commands in Taskfile.yml files for all operating systems to accommodate spaces in variables such as `APP_NAME` by @ndianabasi + ## Deprecated ## Removed -- Remove github.com/wailsapp/mimetype dependency in favor of expanded extension map + stdlib http.DetectContentType, reducing binary size by ~1.2MB -- Remove gopkg.in/ini.v1 dependency by implementing minimal .desktop file parser for Linux file explorer, saving ~45KB -- Remove samber/lo from runtime code by using Go 1.21+ stdlib slices package and minimal internal helpers, saving ~310KB ## Security diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 3ca87f3ac..8b6038c41 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.54 \ No newline at end of file +v3.0.0-alpha.55 \ No newline at end of file From 53c2275fea08e236b1f0e75efad855c7aeac54b2 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Sun, 4 Jan 2026 11:08:29 +1100 Subject: [PATCH 18/40] fix(v3): overhaul drag-and-drop for Linux reliability and simplify Windows implementation (#4848) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(v3): overhaul drag-and-drop for Linux reliability and simplify Windows This commit fixes drag-and-drop reliability on Linux and simplifies the Windows implementation. ## Linux - Rewrite GTK drag handlers to properly intercept external file drops - Fix HTML5 internal drag-and-drop being broken when file drop enabled - Add hover effects during file drag operations - Fix multiple app instances interfering with each other ## Windows - Remove native IDropTarget in favor of JavaScript approach (matches v2) - File drops now handled via chrome.webview.postMessageWithAdditionalObjects ## All Platforms - Rename EnableDragAndDrop to EnableFileDrop - Rename data-wails-drop-target to data-file-drop-target - Rename wails-drop-target-active to file-drop-target-active - Add comprehensive drag-and-drop documentation ## Breaking Changes - EnableDragAndDrop -> EnableFileDrop - data-wails-dropzone -> data-file-drop-target - wails-dropzone-hover -> file-drop-target-active - DropZoneDetails -> DropTargetDetails - Remove WindowDropZoneFilesDropped event (use WindowFilesDropped) * feat(macos): optimize drag event performance with debouncing and caching - Add 50ms debouncing to limit drag events to 20/sec (was 120/sec) - Implement window implementation caching to avoid repeated lookups - Maintain existing 5-pixel threshold for immediate response - Keep zero-allocation path with pre-allocated buffers - Rename linuxDragActive to nativeDragActive for clarity - Update IMPLEMENTATION.md with optimization details and Windows guidance Performance improvements: - 83% reduction in event frequency - ~6x reduction in CPU/memory usage during drag operations - Maintains smooth visual feedback with InvokeSync for timer callbacks * fix(windows): implement proper file drop support for Windows - Remove incorrect AllowExternalDrag(false) call that was blocking file drops - Fix message prefix from 'FilesDropped' to 'file:drop:' to match JS runtime - Fix coordinate parsing for 'file:drop:x:y' format (indices 2,3 not 1,2) - Add enableFileDrop flag injection to JS runtime during navigation - Update JS runtime to check enableFileDrop flag before processing drops - Always call preventDefault() to stop browser navigation on file drags - Show 'no drop' cursor when file drops are disabled - Update example to filter file drags from HTML drop zone handlers - Add documentation for combining file drop with HTML drag-and-drop * fix(v3): block file drops on Linux when EnableFileDrop is false - Add disableDND() to intercept and reject external file drags at GTK level - Show 'no drop' cursor when files are dragged over window - Allow internal HTML5 drag-and-drop to work normally - Initialize _wails.flags object in runtime core to prevent undefined errors - Inject enableFileDrop flag on Linux and macOS (matching Windows) - Fix bare _wails reference to use window._wails - Update docs with info about blocked drops and combining with HTML DnD * fix(darwin): add missing fmt import in webview_window_darwin.go * fix(macOS): implement hover effects for file drag-and-drop with optimizations - Added draggingUpdated: handler to track mouse movement during drag operations - Implemented macosOnDragEnter/Exit/Over export functions for real-time hover state - Fixed JS function call from '_wails.handlePlatformFileDrop' to correct 'wails.Window.HandlePlatformFileDrop' - Added EnableFileDrop flag checks to prevent hover effects when file drops are disabled - Renamed linuxDragActive to nativeDragActive for cross-platform consistency Performance optimizations: - Added 50ms debounce to reduce event frequency from ~120/sec to ~20/sec - Implemented 5-pixel movement threshold for immediate response - Added window caching with sync.Map to avoid repeated lookups - Zero-allocation JavaScript calls with pre-allocated 128-byte buffer - Reduced memory usage to ~18 bytes per event (6x reduction) Build improvements: - Updated runtime Taskfile to include documentation generation - Added docs:build task to runtime build process - Fixed build order: events → docs → runtime Documentation: - Added IMPLEMENTATION.md with optimization details - Included guidance for Windows implementation * chore(v3/examples): remove html-dnd-api example The drag-n-drop example now demonstrates both external file drops and internal HTML5 drag-and-drop, making this separate example redundant. * docs(v3): move drag-and-drop implementation details to runtime-internals - Add drag-and-drop section to contributing/runtime-internals.mdx - Remove IMPLEMENTATION.md from example (content now in proper docs) - Covers platform differences, debugging tips, and key files * fix(v3): remove html-dnd-api from example build list * fix(v3): remove duplicate json import in application_darwin.go * fix(v3): address CodeRabbit review feedback - Fix docs to use app.Window.NewWithOptions() instead of deprecated API - Add mutex protection to dragOverJSBuffer to prevent race conditions - Add mutex protection to dragThrottleState fields for thread safety * docs: add coderabbit pre-push requirement to AGENTS.md * fix(v3/test): use correct CSS class name file-drop-target-active * chore(v3/test): remove dnd-test directory This was a development test file that shouldn't be in the PR. The drag-n-drop example serves as the proper test case. * docs(v3): update Windows file drop comment to reflect implemented fix Remove stale TODO - enableFileDrop flag is now injected in navigationCompleted * refactor(v3): make handleDragAndDropMessage unexported Internal method only called by application event loop, not part of public API. --- AGENTS.md | 1 + docs/astro.config.mjs | 6 +- .../docs/contributing/runtime-internals.mdx | 74 ++ .../docs/features/drag-and-drop/files.mdx | 212 +++++ .../docs/features/drag-and-drop/html.mdx | 232 +++++ .../content/docs/features/windows/options.mdx | 55 ++ .../content/docs/quick-start/next-steps.mdx | 2 +- v3/Taskfile.yaml | 2 - v3/UNRELEASED_CHANGELOG.md | 13 + v3/examples/drag-n-drop/README.md | 76 +- v3/examples/drag-n-drop/assets/index.html | 749 ++++++++-------- v3/examples/drag-n-drop/main.go | 150 +--- v3/examples/html-dnd-api/README.md | 43 - v3/examples/html-dnd-api/assets/index.html | 75 -- v3/examples/html-dnd-api/main.go | 40 - v3/examples/liquid-glass/main.go | 126 +-- .../bundledassets/runtime.debug.js | 241 +++-- .../assetserver/bundledassets/runtime.js | 2 +- v3/internal/generator/collect/known_events.go | 425 +++++---- v3/internal/runtime/Taskfile.yaml | 59 +- .../@wailsio/runtime/package-lock.json | 4 + .../@wailsio/runtime/src/event_types.ts | 1 - .../desktop/@wailsio/runtime/src/index.ts | 7 +- .../desktop/@wailsio/runtime/src/system.ts | 33 - .../desktop/@wailsio/runtime/src/window.ts | 306 +++++-- v3/internal/runtime/runtime.go | 2 +- v3/pkg/application/application.go | 43 +- v3/pkg/application/application_darwin.go | 250 ++++++ v3/pkg/application/context_window_event.go | 20 +- v3/pkg/application/linux_cgo.go | 333 ++++++- v3/pkg/application/linux_purego.go | 7 +- v3/pkg/application/messageprocessor_window.go | 34 +- v3/pkg/application/webview_window.go | 99 ++- v3/pkg/application/webview_window_darwin.go | 27 +- v3/pkg/application/webview_window_darwin.m | 18 - .../application/webview_window_darwin_drag.m | 44 +- v3/pkg/application/webview_window_linux.go | 9 +- v3/pkg/application/webview_window_options.go | 24 +- .../webview_window_options_test.go | 15 - v3/pkg/application/webview_window_windows.go | 106 +-- v3/pkg/application/window.go | 2 +- v3/pkg/events/events.go | 839 +++++++++--------- v3/pkg/events/events.txt | 1 - v3/pkg/events/events_darwin.h | 266 +++--- v3/pkg/events/events_ios.h | 46 +- v3/pkg/events/events_linux.h | 24 +- v3/pkg/events/known_events.go | 425 +++++---- 47 files changed, 3342 insertions(+), 2226 deletions(-) create mode 100644 docs/src/content/docs/features/drag-and-drop/files.mdx create mode 100644 docs/src/content/docs/features/drag-and-drop/html.mdx delete mode 100644 v3/examples/html-dnd-api/README.md delete mode 100644 v3/examples/html-dnd-api/assets/index.html delete mode 100644 v3/examples/html-dnd-api/main.go diff --git a/AGENTS.md b/AGENTS.md index 5c1a6e9f8..d4c111ea8 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -135,6 +135,7 @@ For example: `bd create --help` shows `--parent`, `--deps`, `--assignee`, etc. - Check `bd ready` before asking "what should I work on?" - Store AI planning docs in `history/` directory - Run `bd --help` to discover available flags +- **ALWAYS run `coderabbit --plain` before committing** to get code analysis and catch issues early - Do NOT create markdown TODO lists - Do NOT use external issue trackers - Do NOT duplicate tracking systems diff --git a/docs/astro.config.mjs b/docs/astro.config.mjs index 7529ea4e5..ee02aa8e3 100644 --- a/docs/astro.config.mjs +++ b/docs/astro.config.mjs @@ -171,7 +171,11 @@ export default defineConfig({ collapsed: true, autogenerate: { directory: "features/browser" }, }, - { label: "Drag & Drop", link: "/features/drag-drop" }, + { + label: "Drag & Drop", + collapsed: true, + autogenerate: { directory: "features/drag-and-drop" }, + }, { label: "Keyboard", collapsed: true, diff --git a/docs/src/content/docs/contributing/runtime-internals.mdx b/docs/src/content/docs/contributing/runtime-internals.mdx index d150c2d8b..7d35ae91b 100644 --- a/docs/src/content/docs/contributing/runtime-internals.mdx +++ b/docs/src/content/docs/contributing/runtime-internals.mdx @@ -170,6 +170,80 @@ Follow this checklist and you'll keep the cross-platform contract intact. --- +## 9. Drag-and-Drop + +File drag-and-drop uses a **JavaScript-first approach** on all platforms. The native layer intercepts OS drag events, but the actual drop handling and DOM interaction happens in JavaScript. + +### Flow + +1. User drags files from OS over the Wails window +2. Native layer detects the drag and notifies JavaScript for hover effects +3. User drops files +4. Native layer sends file paths + coordinates to JavaScript +5. JavaScript finds the drop target element (`data-file-drop-target`) +6. JavaScript sends file paths + element details to Go backend +7. Go emits `WindowFilesDropped` event with full context + +### Platform Implementations + +| Platform | Native Layer | Key Challenge | +|----------|--------------|---------------| +| **Windows** | WebView2's built-in drag support | Coordinates in CSS pixels, no conversion needed | +| **macOS** | NSWindow drag delegates | Convert window-relative to webview-relative coords | +| **Linux** | GTK3 drag signals | Must distinguish file drags from internal HTML5 drags | + +### Linux: Distinguishing Drag Types + +GTK and WebKit both want to handle drag events. The key is checking the drag target type: + +```c +static gboolean is_file_drag(GdkDragContext *context) { + GList *targets = gdk_drag_context_list_targets(context); + for (GList *l = targets; l != NULL; l = l->next) { + GdkAtom atom = GDK_POINTER_TO_ATOM(l->data); + gchar *name = gdk_atom_name(atom); + if (name && g_strcmp0(name, "text/uri-list") == 0) { + g_free(name); + return TRUE; // External file drag + } + g_free(name); + } + return FALSE; // Internal HTML5 drag +} +``` + +Signal handlers return `FALSE` for internal drags (letting WebKit handle them) and `TRUE` for file drags (handling them ourselves). + +### Blocking File Drops + +When `EnableFileDrop` is `false`, we still need to prevent the browser from navigating to dropped files. Each platform handles this differently: + +- **Windows**: JavaScript calls `preventDefault()` on drag events +- **macOS**: JavaScript calls `preventDefault()` on drag events +- **Linux**: GTK signal handlers intercept and reject file drags at the native level + +### Key Files + +| File | Purpose | +|------|---------| +| `pkg/application/linux_cgo.go` | GTK drag signal handlers (C code in cgo preamble) | +| `pkg/application/webview_window_darwin.go` | macOS drag delegates | +| `pkg/application/webview_window_windows.go` | WebView2 message handling | +| `internal/runtime/desktop/@wailsio/runtime/src/window.ts` | JavaScript drop handling | + +### Debugging + +- **Linux**: Add `printf` in C code (remember `fflush(stdout)`) +- **Windows**: Use `globalApplication.debug()` +- **JavaScript**: Check browser console, enable debug mode + +Common issues: +1. **Internal HTML5 drag not working**: Native handler intercepting it (return `FALSE` for non-file drags) +2. **Hover effects not showing**: JavaScript handlers not being called +3. **Wrong coordinates**: Check coordinate space conversions + +--- + You now have a guided tour of the runtime internals. Combine this knowledge with the **Codebase Layout** map and the **Asset Server** docs to navigate confidently and make impactful contributions. Happy coding! diff --git a/docs/src/content/docs/features/drag-and-drop/files.mdx b/docs/src/content/docs/features/drag-and-drop/files.mdx new file mode 100644 index 000000000..6d53d7934 --- /dev/null +++ b/docs/src/content/docs/features/drag-and-drop/files.mdx @@ -0,0 +1,212 @@ +--- +title: File Drop +description: Accept files dragged from the operating system into your application +sidebar: + order: 1 +--- + +Wails lets users drag files from the operating system (file manager, desktop) into your application. Unlike HTML5 drag-and-drop which only works within the browser, this gives you access to actual file paths on disk. + +## Enable File Drop + +File drop is disabled by default. To enable it, set `EnableFileDrop: true` in your window options: + +```go +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ + Title: "My App", + Width: 800, + Height: 600, + EnableFileDrop: true, +}) +``` + +When `EnableFileDrop` is `false` (the default), files dragged from the OS are blocked - they won't open in the webview or trigger any events. This prevents accidental navigation when users drag files over your app. + +## Define Drop Zones + +Drop zones tell Wails which elements should accept files. Files dropped outside a drop zone are ignored. + +Add the `data-file-drop-target` attribute to any element: + +```html +
+ Drop files here +
+``` + +You can have multiple drop zones. The element's `id` and CSS classes are passed to your Go code, so you can handle drops differently depending on where files land. + +## Style Drag Hover + +When files are dragged over a drop zone, Wails adds the `file-drop-target-active` class. This lets you provide visual feedback so users know where they can drop: + +```css +.drop-zone { + border: 2px dashed #ccc; + padding: 40px; + text-align: center; + transition: all 0.2s ease; +} + +.drop-zone.file-drop-target-active { + border-color: #007bff; + background-color: rgba(0, 123, 255, 0.1); +} +``` + +The class is removed automatically when files leave the zone or are dropped. + +## Detect Dropped Files + +When files are dropped on a valid drop zone, Wails fires a `WindowFilesDropped` event. The event context contains the full filesystem paths of all dropped files: + +```go +import "github.com/wailsapp/wails/v3/pkg/events" + +window.OnWindowEvent(events.Common.WindowFilesDropped, func(event *application.WindowEvent) { + files := event.Context().DroppedFiles() + + for _, file := range files { + fmt.Println("Dropped:", file) + } +}) +``` + +The paths are absolute, like `/home/user/documents/report.pdf` or `C:\Users\Name\Documents\report.pdf`. + +## Get Drop Target Info + +When you have multiple drop zones, you can find out which one received the files using `DropTargetDetails()`: + +```go +window.OnWindowEvent(events.Common.WindowFilesDropped, func(event *application.WindowEvent) { + files := event.Context().DroppedFiles() + details := event.Context().DropTargetDetails() + + fmt.Printf("Dropped on element: id=%s, classes=%v\n", + details.ElementID, details.ClassList) + fmt.Printf("Position: x=%d, y=%d\n", details.X, details.Y) +}) +``` + +This lets you route files to different handlers: + +```go +switch details.ElementID { +case "images": + handleImageUpload(files) +case "documents": + handleDocumentUpload(files) +} +``` + +## Complete Example + +**Go:** + +```go +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ + Title: "File Uploader", + EnableFileDrop: true, +}) + +window.OnWindowEvent(events.Common.WindowFilesDropped, func(event *application.WindowEvent) { + files := event.Context().DroppedFiles() + details := event.Context().DropTargetDetails() + + // Send to frontend + app.EmitEvent("files-dropped", map[string]any{ + "files": files, + "target": details.ElementID, + }) +}) +``` + +**HTML:** + +```html +
+ Drop images here +
+ +
+ Drop documents here +
+ + +``` + +## Full Window Drop + +If you want files to be droppable anywhere in your app, add the attribute to the body element: + +```html + + + +``` + +You can use a CSS overlay to indicate the entire window is a drop target: + +```css +body.file-drop-target-active::after { + content: "Drop files anywhere"; + position: fixed; + inset: 0; + display: flex; + align-items: center; + justify-content: center; + font-size: 24px; + color: #007bff; + background: rgba(255, 255, 255, 0.9); + pointer-events: none; +} +``` + +## Combining with HTML Drag & Drop + +You can use both external file drops and internal HTML drag-and-drop in the same application. When `EnableFileDrop` is `true`, Wails intercepts external file drags but lets internal HTML5 drags pass through normally. + +To distinguish between them in your HTML drop zone handlers, check if the drag contains files: + +```javascript +zone.addEventListener('dragenter', (e) => { + // Skip external file drags - Wails handles these + if (e.dataTransfer?.types.includes('Files')) { + return; + } + // Handle internal HTML5 drags + zone.classList.add('drag-over'); +}); + +zone.addEventListener('drop', (e) => { + // Skip external file drops - Wails handles these + if (e.dataTransfer?.types.includes('Files')) { + return; + } + e.preventDefault(); + zone.classList.remove('drag-over'); + // Handle internal drop +}); +``` + +This ensures your HTML drop handlers only respond to internal drags (like moving list items), while Wails handles external file drops separately via the `WindowFilesDropped` event. + +## Next Steps + +- [HTML Drag & Drop](./html) - Drag elements within your app +- [Window Options](/features/windows/options) - All window configuration options diff --git a/docs/src/content/docs/features/drag-and-drop/html.mdx b/docs/src/content/docs/features/drag-and-drop/html.mdx new file mode 100644 index 000000000..7eeebc7be --- /dev/null +++ b/docs/src/content/docs/features/drag-and-drop/html.mdx @@ -0,0 +1,232 @@ +--- +title: HTML Drag & Drop +description: Drag and drop elements within your application +sidebar: + order: 2 +--- + +HTML5 drag-and-drop lets users drag elements within your app's UI - for example, reordering a list or moving items between columns. This is standard web functionality that works in Wails without any special setup. + +## Make an Element Draggable + +By default, most elements can't be dragged. To make an element draggable, add `draggable="true"`: + +```html +
Drag me
+``` + +The element will now show a drag preview when the user clicks and drags it. + +## Define a Drop Zone + +Elements don't accept drops by default. To make an element accept drops, you need to cancel the default behaviour on `dragover`: + +```html +
Drop here
+ + +``` + +Calling `preventDefault()` on `dragover` is required - it signals that this element accepts drops. Without it, the drop event won't fire. + +## Style Drag Hover + +To show users where they can drop, add visual feedback when dragging over a drop zone. The `dragenter` event fires when something enters the zone, and `dragleave` fires when it leaves: + +```css +.drop-zone { + border: 2px dashed #ccc; + padding: 40px; + transition: all 0.2s ease; +} + +.drop-zone.drag-over { + border-color: #007bff; + background-color: rgba(0, 123, 255, 0.1); +} +``` + +```javascript +const target = document.getElementById('target'); + +target.addEventListener('dragenter', () => { + target.classList.add('drag-over'); +}); + +target.addEventListener('dragleave', () => { + target.classList.remove('drag-over'); +}); + +target.addEventListener('drop', (e) => { + e.preventDefault(); + target.classList.remove('drag-over'); + // Handle the drop +}); +``` + +Note: `dragleave` also fires when entering a child element, which can cause flickering. The complete example below shows how to handle this. + +## Complete Example + +A task list where items can be dragged between priority columns. This tracks the dragged element in a variable, which is the simplest approach when everything is on the same page: + +```html +
+
Fix login bug
+
Update docs
+
Add dark mode
+
+ +
+
+

High Priority

+
    +
    +
    +

    Low Priority

    +
      +
      +
      + + + + +``` + +## Combining with File Drop + +If your app uses both HTML drag-and-drop and [File Drop](./files), your HTML drop zones will also receive events when users drag files from the operating system. To prevent confusion, filter out file drags in your handlers: + +```javascript +zone.addEventListener('dragenter', (e) => { + // Ignore external file drags + if (e.dataTransfer?.types.includes('Files')) return; + + zone.classList.add('drag-over'); +}); + +zone.addEventListener('dragover', (e) => { + // Ignore external file drags + if (e.dataTransfer?.types.includes('Files')) return; + + e.preventDefault(); +}); + +zone.addEventListener('drop', (e) => { + // Ignore external file drags + if (e.dataTransfer?.types.includes('Files')) return; + + e.preventDefault(); + zone.classList.remove('drag-over'); + // Handle the internal drop +}); +``` + +The `dataTransfer.types` array contains `'Files'` when the user is dragging files from the OS, but contains types like `'text/plain'` for internal HTML drags. This lets you distinguish between the two. + +## Passing Data with dataTransfer + +The example above tracks the dragged element in a JavaScript variable. This works well when everything is on the same page. But if you need to drag between iframes or pass data that isn't tied to a DOM element, use the `dataTransfer` API: + +```javascript +// When drag starts, store data +item.addEventListener('dragstart', (e) => { + e.dataTransfer.setData('text/plain', item.id); +}); + +// When dropped, retrieve the data +target.addEventListener('drop', (e) => { + e.preventDefault(); + const itemId = e.dataTransfer.getData('text/plain'); + const item = document.getElementById(itemId); + // Move or copy the item +}); +``` + +The data is stored as strings, so you'll need to serialize objects with `JSON.stringify()` if needed. + +## Next Steps + +- [File Drop](./files) - Accept files from the operating system +- [MDN Drag and Drop API](https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API) - Full browser API reference diff --git a/docs/src/content/docs/features/windows/options.mdx b/docs/src/content/docs/features/windows/options.mdx index 93a468120..d2f338fc9 100644 --- a/docs/src/content/docs/features/windows/options.mdx +++ b/docs/src/content/docs/features/windows/options.mdx @@ -546,6 +546,61 @@ Assets: application.AssetOptions{ **See [Build System](/concepts/build-system) for details.** +## Input Options + +### EnableFileDrop + +**Type:** `bool` +**Default:** `false` +**Platform:** All + +```go +EnableFileDrop: true, +``` + +**Purpose:** Enable drag-and-drop of files from the operating system into the window. + +When enabled: +- Files dragged from file managers can be dropped into your application +- The `WindowFilesDropped` event fires with the dropped file paths +- Elements with `data-file-drop-target` attribute provide detailed drop information + +**Use cases:** +- File upload interfaces +- Document editors +- Media importers +- Any app that accepts files + +**Example:** + +```go +window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + Title: "File Uploader", + EnableFileDrop: true, +}) + +// Handle dropped files +window.OnWindowEvent(events.Common.WindowFilesDropped, func(event *application.WindowEvent) { + files := event.Context().DroppedFiles() + details := event.Context().DropTargetDetails() + + for _, file := range files { + fmt.Println("Dropped:", file) + } +}) +``` + +**HTML drop zones:** + +```html + +
      + Drop files here +
      +``` + +**See [File Drop](/features/drag-and-drop/files) for complete documentation.** + ## Security Options ### ContentProtectionEnabled diff --git a/docs/src/content/docs/quick-start/next-steps.mdx b/docs/src/content/docs/quick-start/next-steps.mdx index fc17185d4..394d8e69a 100644 --- a/docs/src/content/docs/quick-start/next-steps.mdx +++ b/docs/src/content/docs/quick-start/next-steps.mdx @@ -24,7 +24,7 @@ Wails provides native desktop capabilities: - [Events](/features/events/system) - Communication between components - [Bindings](/features/bindings/methods) - Type-safe Go ↔ JavaScript calls - [Clipboard](/features/clipboard) - Copy/paste operations -- [Drag & Drop](/features/drag-drop) - File drag and drop +- [Drag & Drop](/features/drag-and-drop/files) - File drag and drop - [Keyboard](/features/keyboard) - Global shortcuts ## Get Help diff --git a/v3/Taskfile.yaml b/v3/Taskfile.yaml index 04afd60f4..396b7aee5 100644 --- a/v3/Taskfile.yaml +++ b/v3/Taskfile.yaml @@ -181,7 +181,6 @@ tasks: gin-routing gin-service hide-window - html-dnd-api ignore-mouse keybindings liquid-glass @@ -306,7 +305,6 @@ tasks: gin-routing gin-service hide-window - html-dnd-api ignore-mouse keybindings liquid-glass diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..61496656d 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -20,15 +20,28 @@ After processing, the content will be moved to the main changelog and this file ## Changed +- **BREAKING:** Rename `EnableDragAndDrop` to `EnableFileDrop` in window options +- **BREAKING:** Rename `DropZoneDetails` to `DropTargetDetails` in event context +- **BREAKING:** Rename `DropZoneDetails()` method to `DropTargetDetails()` on `WindowEventContext` +- **BREAKING:** Remove `WindowDropZoneFilesDropped` event, use `WindowFilesDropped` instead +- **BREAKING:** Change HTML attribute from `data-wails-dropzone` to `data-file-drop-target` +- **BREAKING:** Change CSS hover class from `wails-dropzone-hover` to `file-drop-target-active` +- **BREAKING:** Remove `DragEffect`, `OnEnterEffect`, `OnOverEffect` options from Windows (were part of removed IDropTarget) ## Fixed +- Fix file drag-and-drop on Windows not working at non-100% display scaling +- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Windows +- Fix file drop coordinates being in wrong pixel space on Windows (physical vs CSS pixels) +- Fix file drag-and-drop on Linux not working reliably with hover effects +- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Linux ## Deprecated ## Removed +- Remove native `IDropTarget` implementation on Windows in favor of JavaScript-based approach (matches v2 behavior) ## Security diff --git a/v3/examples/drag-n-drop/README.md b/v3/examples/drag-n-drop/README.md index cb3c56fd0..d1a4bfb31 100644 --- a/v3/examples/drag-n-drop/README.md +++ b/v3/examples/drag-n-drop/README.md @@ -1,27 +1,73 @@ -# Drag-n-drop Example +# File Drop Example -This example demonstrates how to handle files being dragged into the application. +This example demonstrates how to handle files being dragged from the operating system (Finder, Explorer, file managers) into a Wails application. + +Dropped files are automatically categorised by type and displayed in separate buckets: documents, images, or other files. + +## How it works + +1. Enable file drops in window options: + ```go + EnableFileDrop: true + ``` + +2. Mark elements as drop targets in HTML: + ```html +
      Drop files here
      + ``` + +3. Listen for the `WindowFilesDropped` event: + ```go + win.OnWindowEvent(events.Common.WindowFilesDropped, func(event *application.WindowEvent) { + files := event.Context().DroppedFiles() + details := event.Context().DropTargetDetails() + // Handle the dropped files + }) + ``` + +4. Optionally forward to frontend: + ```go + application.Get().Event.Emit("files-dropped", map[string]any{ + "files": files, + "details": details, + }) + ``` + +## Drop Target Details + +When files are dropped, you can get information about the drop location: + +- `ElementID` - The ID of the element that received the drop +- `ClassList` - CSS classes on the drop target +- `X`, `Y` - Coordinates of the drop within the element + +## Styling + +When files are dragged over a valid drop target, Wails adds the `file-drop-target-active` class: + +```css +.file-drop-target-active { + border-color: #4a9eff; + background: rgba(74, 158, 255, 0.1); +} +``` ## Running the example -To run the example, simply run the following command: - ```bash go run main.go ``` -## Building the example +Then drag files from your desktop or file manager into the drop zone. -To build the example in debug mode, simply run the following command: +## See also -```bash -wails3 task build -``` +- [html-dnd-api](../html-dnd-api) - For dragging elements *within* your application (HTML5 Drag and Drop API) -# Status +## Status -| Platform | Status | -|----------|-------------| -| Mac | Working | -| Windows | Not Working | -| Linux | | +| Platform | Status | +|----------|---------| +| Mac | Working | +| Windows | Working | +| Linux | Working | diff --git a/v3/examples/drag-n-drop/assets/index.html b/v3/examples/drag-n-drop/assets/index.html index 3d89c9bcb..7843cc057 100644 --- a/v3/examples/drag-n-drop/assets/index.html +++ b/v3/examples/drag-n-drop/assets/index.html @@ -3,422 +3,433 @@ - File Tree Drag-and-Drop Example - - - - - - + Drag and Drop Demo -
      -

      File Tree Drag & Drop Example

      -

      Drag files onto folders to upload them to that location

      +

      Drag and Drop Demo

      + + +

      External File Drop

      +
      +

      + Drop files from your operating system (Finder, Explorer, file managers). + Uses EnableFileDrop: true and data-file-drop-target +

      -
      -
      -
      /home/user
      - - -
      - folder - Home +
      +
      +

      Drop files from your desktop or file manager here

      +
      + +
      +
      +

      Documents

      +
        +
      • No documents yet
        • +
      -
      - -
      - folder - Documents +
      +

      Images

      +
        +
      • No images yet
        • +
      +
      + +
      +

      Other Files

      +
        +
      • No other files yet
        • +
      +
      +
      +
      + + +

      Internal Drag and Drop

      +
      +

      + Drag items between zones using the HTML5 Drag and Drop API. + Uses draggable="true" and standard DOM events. +

      +
      + +
      +
      +
      +

      Tasks

      +
      Fix login bug
      +
      Update documentation
      +
      Add dark mode
      +
      Refactor API calls
      +
      Write unit tests
      +
      + +
      +
      +

      High Priority

      +
        -
        -
        - description - report.pdf -
        -
        - description - notes.txt -
        +
        +

        Medium Priority

        +
          - -
          - folder - Pictures -
          - -
          -
          - image - vacation.jpg -
          -
          - image - profile.png -
          -
          - - -
          - folder - Downloads -
          - -
          -
          - archive - app.dmg -
          -
          - archive - data.zip -
          -
          - - -
          - folder - Projects -
          - -
          - -
          - folder - Wails -
          - -
          -
          - code - main.go -
          -
          - code - go.mod -
          -
          +
          +

          Low Priority

          +
            - -
            -

            Drop Information

            -
            Drag and drop files onto any folder in the file tree... +
            + +
            + Last action: No actions yet +
            -The folder elements have the following attributes: -- data-wails-dropzone: Marks the element as a dropzone -- data-path: Contains the full path (used for destination) -- data-folder-id: A unique ID for the folder -- data-folder-name: The display name of the folder
            -
            -
            - - \ No newline at end of file + diff --git a/v3/examples/drag-n-drop/main.go b/v3/examples/drag-n-drop/main.go index 3746a406c..5caafef1e 100644 --- a/v3/examples/drag-n-drop/main.go +++ b/v3/examples/drag-n-drop/main.go @@ -1,10 +1,7 @@ package main import ( - "context" "embed" - _ "embed" - "fmt" "log" "github.com/wailsapp/wails/v3/pkg/application" @@ -14,153 +11,50 @@ import ( //go:embed assets var assets embed.FS -// App struct -type App struct { - ctx context.Context - app *application.App -} - -// NewApp creates a new App application struct -func NewApp() *App { - return &App{} -} - -// Startup is called when the app starts. The context is saved -// so we can call the runtime methods -func (a *App) Startup(ctx context.Context) { - a.ctx = ctx - a.app = application.Get() -} - -// FileDropInfo defines the payload for the file drop event sent to the frontend. -type FileDropInfo struct { - Files []string `json:"files"` - TargetID string `json:"targetID"` - TargetClasses []string `json:"targetClasses"` - DropX float64 `json:"dropX"` - DropY float64 `json:"dropY"` - Attributes map[string]string `json:"attributes,omitempty"` -} - -// FilesDroppedOnTarget is called when files are dropped onto a registered drop target -// or the window if no specific target is hit. -func FilesDroppedOnTarget( - files []string, - targetID string, - targetClasses []string, - dropX float64, - dropY float64, - isTargetDropzone bool, // This parameter is kept for logging but not sent to frontend in this event - attributes map[string]string, -) { - log.Println("=============== Go: FilesDroppedOnTarget Debug Info ===============") - log.Println(fmt.Sprintf(" Files: %v", files)) - log.Println(fmt.Sprintf(" Target ID: '%s'", targetID)) - log.Println(fmt.Sprintf(" Target Classes: %v", targetClasses)) - log.Println(fmt.Sprintf(" Drop X: %f, Drop Y: %f", dropX, dropY)) - log.Println( - fmt.Sprintf( - " Drop occurred on a designated dropzone (runtime validated before this Go event): %t", - isTargetDropzone, - ), - ) - log.Println(fmt.Sprintf(" Element Attributes: %v", attributes)) - log.Println("================================================================") - - payload := FileDropInfo{ - Files: files, - TargetID: targetID, - TargetClasses: targetClasses, - DropX: dropX, - DropY: dropY, - Attributes: attributes, - } - - log.Println("Go: Emitted 'frontend:FileDropInfo' event with payload:", payload) -} - func main() { - appInstance := NewApp() - app := application.New(application.Options{ - Name: "Drag-n-drop Demo", - Description: "A demo of the Drag-n-drop API", + Name: "File Drop Demo", + Description: "A demo of file drag and drop", Assets: application.AssetOptions{ Handler: application.BundledAssetFileServer(assets), }, Mac: application.MacOptions{ ApplicationShouldTerminateAfterLastWindowClosed: true, }, - Services: []application.Service{ - application.NewService(appInstance), - }, }) win := app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "Drag-n-drop Demo", + Title: "File Drop Demo", + Width: 800, + Height: 600, + EnableFileDrop: true, Mac: application.MacWindow{ Backdrop: application.MacBackdropTranslucent, TitleBar: application.MacTitleBarHiddenInsetUnified, InvisibleTitleBarHeight: 50, }, - EnableDragAndDrop: true, }) - log.Println("Setting up event listener for 'WindowDropZoneFilesDropped'...") - win.OnWindowEvent( - events.Common.WindowDropZoneFilesDropped, - func(event *application.WindowEvent) { + // Listen for file drop events + win.OnWindowEvent(events.Common.WindowFilesDropped, func(event *application.WindowEvent) { + files := event.Context().DroppedFiles() + details := event.Context().DropTargetDetails() - droppedFiles := event.Context().DroppedFiles() - details := event.Context().DropZoneDetails() + log.Printf("Files dropped: %v", files) + if details != nil { + log.Printf("Drop target: id=%s, classes=%v, x=%d, y=%d", + details.ElementID, details.ClassList, details.X, details.Y) + } - log.Printf("Dropped files count: %d", len(droppedFiles)) - log.Printf("Event context: %+v", event.Context()) - - if details != nil { - log.Printf("DropZone details found:") - log.Printf(" ElementID: '%s'", details.ElementID) - log.Printf(" ClassList: %v", details.ClassList) - log.Printf(" X: %d, Y: %d", details.X, details.Y) - log.Printf(" Attributes: %+v", details.Attributes) - - // Call the App method with the extracted data - FilesDroppedOnTarget( - droppedFiles, - details.ElementID, - details.ClassList, - float64(details.X), - float64(details.Y), - details.ElementID != "", // isTargetDropzone based on whether an ID was found - details.Attributes, - ) - } else { - log.Println("DropZone details are nil - drop was not on a specific registered zone") - // This case might occur if DropZoneDetails are nil, meaning the drop was not on a specific registered zone - // or if the context itself was problematic. - FilesDroppedOnTarget(droppedFiles, "", nil, 0, 0, false, nil) - } - - payload := FileDropInfo{ - Files: droppedFiles, - TargetID: details.ElementID, - TargetClasses: details.ClassList, - DropX: float64(details.X), - DropY: float64(details.Y), - Attributes: details.Attributes, // Add the attributes - } - - log.Printf("Emitting event payload: %+v", payload) - application.Get().Event.Emit("frontend:FileDropInfo", payload) - log.Println( - "=============== End WindowDropZoneFilesDropped Event Debug ===============", - ) - }, - ) + // Emit event to frontend + application.Get().Event.Emit("files-dropped", map[string]any{ + "files": files, + "details": details, + }) + }) err := app.Run() - if err != nil { - log.Fatal(err.Error()) + log.Fatal(err) } } diff --git a/v3/examples/html-dnd-api/README.md b/v3/examples/html-dnd-api/README.md deleted file mode 100644 index 1b06f3882..000000000 --- a/v3/examples/html-dnd-api/README.md +++ /dev/null @@ -1,43 +0,0 @@ -# HTML Drag and Drop API Example - -This example should demonstrate whether the [HTML Drag and Drop API](https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API") works correctly. - -## Expected Behaviour - -When dragging the "draggable", in the console should be printed: -1. "dragstart" once -2. "drag" many times -3. "dragend" once - -When dragging the "draggable" on the drop target, the inner text of the latter shoud change and in the console should be printed: -1. "dragstart" once -2. "drag" many times -3. "dragenter" once -4. "dragover" many times (alternating with "drag") -5. - "drop" once (in case of a drop inside the drop target) - - "dragleave" once (in case the draggable div leaves the drop target) -6. "dragend" once - -## Running the example - -To run the example, simply run the following command: - -```bash -go run main.go -``` - -## Building the example - -To build the example in debug mode, simply run the following command: - -```bash -wails3 task build -``` - -# Status - -| Platform | Status | -|----------|-------------| -| Mac | Working | -| Windows | Not Working | -| Linux | | diff --git a/v3/examples/html-dnd-api/assets/index.html b/v3/examples/html-dnd-api/assets/index.html deleted file mode 100644 index a64b9378a..000000000 --- a/v3/examples/html-dnd-api/assets/index.html +++ /dev/null @@ -1,75 +0,0 @@ - - - - - Title - - - -

            HTML Drag and Drop API Demo

            -
            - -
            draggable
            - -
            drop target
            - - - - - - diff --git a/v3/examples/html-dnd-api/main.go b/v3/examples/html-dnd-api/main.go deleted file mode 100644 index 549523ef1..000000000 --- a/v3/examples/html-dnd-api/main.go +++ /dev/null @@ -1,40 +0,0 @@ -package main - -import ( - "embed" - "log" - - "github.com/wailsapp/wails/v3/pkg/application" -) - -//go:embed assets -var assets embed.FS - -func main() { - - app := application.New(application.Options{ - Name: "HTML Drag and Drop API Demo", - Description: "A demo of the HTML Drag and drop API", - Assets: application.AssetOptions{ - Handler: application.BundledAssetFileServer(assets), - }, - Mac: application.MacOptions{ - ApplicationShouldTerminateAfterLastWindowClosed: true, - }, - }) - - app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "Drag-n-drop Demo", - Mac: application.MacWindow{ - Backdrop: application.MacBackdropTranslucent, - TitleBar: application.MacTitleBarHiddenInsetUnified, - InvisibleTitleBarHeight: 50, - }, - }) - - err := app.Run() - - if err != nil { - log.Fatal(err.Error()) - } -} diff --git a/v3/examples/liquid-glass/main.go b/v3/examples/liquid-glass/main.go index ff2644cab..61f338b96 100644 --- a/v3/examples/liquid-glass/main.go +++ b/v3/examples/liquid-glass/main.go @@ -61,15 +61,15 @@ func main() { // Window 1: Light style with no tint window1 := app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "Light Glass", - Width: 350, - Height: 280, - X: 100, - Y: 100, - Frameless: true, - EnableDragAndDrop: false, - HTML: lightHTML, - InitialPosition: application.WindowXY, + Title: "Light Glass", + Width: 350, + Height: 280, + X: 100, + Y: 100, + Frameless: true, + EnableFileDrop: false, + HTML: lightHTML, + InitialPosition: application.WindowXY, Mac: application.MacWindow{ Backdrop: application.MacBackdropLiquidGlass, InvisibleTitleBarHeight: 500, @@ -84,15 +84,15 @@ func main() { // Window 2: Dark style window2 := app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "Dark Glass", - Width: 350, - Height: 280, - X: 500, - Y: 100, - Frameless: true, - EnableDragAndDrop: false, - HTML: darkHTML, - InitialPosition: application.WindowXY, + Title: "Dark Glass", + Width: 350, + Height: 280, + X: 500, + Y: 100, + Frameless: true, + EnableFileDrop: false, + HTML: darkHTML, + InitialPosition: application.WindowXY, Mac: application.MacWindow{ Backdrop: application.MacBackdropLiquidGlass, InvisibleTitleBarHeight: 500, @@ -107,15 +107,15 @@ func main() { // Window 3: Vibrant style window3 := app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "Vibrant Glass", - Width: 350, - Height: 280, - X: 900, - Y: 100, - Frameless: true, - EnableDragAndDrop: false, - HTML: vibrantHTML, - InitialPosition: application.WindowXY, + Title: "Vibrant Glass", + Width: 350, + Height: 280, + X: 900, + Y: 100, + Frameless: true, + EnableFileDrop: false, + HTML: vibrantHTML, + InitialPosition: application.WindowXY, Mac: application.MacWindow{ Backdrop: application.MacBackdropLiquidGlass, InvisibleTitleBarHeight: 500, @@ -130,15 +130,15 @@ func main() { // Window 4: Blue tinted glass window4 := app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "Tinted Glass", - Width: 350, - Height: 280, - X: 300, - Y: 420, - Frameless: true, - EnableDragAndDrop: false, - HTML: tintedHTML, - InitialPosition: application.WindowXY, + Title: "Tinted Glass", + Width: 350, + Height: 280, + X: 300, + Y: 420, + Frameless: true, + EnableFileDrop: false, + HTML: tintedHTML, + InitialPosition: application.WindowXY, Mac: application.MacWindow{ Backdrop: application.MacBackdropLiquidGlass, InvisibleTitleBarHeight: 500, @@ -153,15 +153,15 @@ func main() { // Window 5: Using specific NSVisualEffectMaterial window5 := app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "Sheet Material", - Width: 350, - Height: 280, - X: 700, - Y: 420, - Frameless: true, - EnableDragAndDrop: false, - HTML: sheetHTML, - InitialPosition: application.WindowXY, + Title: "Sheet Material", + Width: 350, + Height: 280, + X: 700, + Y: 420, + Frameless: true, + EnableFileDrop: false, + HTML: sheetHTML, + InitialPosition: application.WindowXY, Mac: application.MacWindow{ Backdrop: application.MacBackdropLiquidGlass, InvisibleTitleBarHeight: 500, @@ -176,15 +176,15 @@ func main() { // Window 6: HUD Window Material (very light, translucent) window6 := app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "HUD Window", - Width: 350, - Height: 280, - X: 100, - Y: 740, - Frameless: true, - EnableDragAndDrop: false, - HTML: hudHTML, - InitialPosition: application.WindowXY, + Title: "HUD Window", + Width: 350, + Height: 280, + X: 100, + Y: 740, + Frameless: true, + EnableFileDrop: false, + HTML: hudHTML, + InitialPosition: application.WindowXY, Mac: application.MacWindow{ Backdrop: application.MacBackdropLiquidGlass, InvisibleTitleBarHeight: 500, @@ -199,15 +199,15 @@ func main() { // Window 7: Content Background Material window7 := app.Window.NewWithOptions(application.WebviewWindowOptions{ - Title: "Content Background", - Width: 350, - Height: 280, - X: 500, - Y: 740, - Frameless: true, - EnableDragAndDrop: false, - HTML: contentHTML, - InitialPosition: application.WindowXY, + Title: "Content Background", + Width: 350, + Height: 280, + X: 500, + Y: 740, + Frameless: true, + EnableFileDrop: false, + HTML: contentHTML, + InitialPosition: application.WindowXY, Mac: application.MacWindow{ Backdrop: application.MacBackdropLiquidGlass, InvisibleTitleBarHeight: 500, diff --git a/v3/internal/assetserver/bundledassets/runtime.debug.js b/v3/internal/assetserver/bundledassets/runtime.debug.js index ad54d9bdf..bd783ca6b 100644 --- a/v3/internal/assetserver/bundledassets/runtime.debug.js +++ b/v3/internal/assetserver/bundledassets/runtime.debug.js @@ -546,8 +546,7 @@ var Types = Object.freeze({ WindowZoom: "common:WindowZoom", WindowZoomIn: "common:WindowZoomIn", WindowZoomOut: "common:WindowZoomOut", - WindowZoomReset: "common:WindowZoomReset", - WindowDropZoneFilesDropped: "common:WindowDropZoneFilesDropped" + WindowZoomReset: "common:WindowZoomReset" }) }); @@ -651,9 +650,9 @@ function whenReady(callback) { } // desktop/@wailsio/runtime/src/window.ts -var DROPZONE_ATTRIBUTE = "data-wails-dropzone"; -var DROPZONE_HOVER_CLASS = "wails-dropzone-hover"; -var currentHoveredDropzone = null; +var DROP_TARGET_ATTRIBUTE = "data-file-drop-target"; +var DROP_TARGET_ACTIVE_CLASS = "file-drop-target-active"; +var currentDropTarget = null; var PositionMethod = 0; var CenterMethod = 1; var CloseMethod = 2; @@ -704,13 +703,62 @@ var ZoomInMethod = 46; var ZoomOutMethod = 47; var ZoomResetMethod = 48; var SnapAssistMethod = 49; -var WindowDropZoneDropped = 50; +var FilesDropped = 50; var PrintMethod = 51; -function getDropzoneElement(element) { +function getDropTargetElement(element) { if (!element) { return null; } - return element.closest("[".concat(DROPZONE_ATTRIBUTE, "]")); + return element.closest("[".concat(DROP_TARGET_ATTRIBUTE, "]")); +} +function canResolveFilePaths() { + var _a2, _b, _c, _d; + if (((_b = (_a2 = window.chrome) == null ? void 0 : _a2.webview) == null ? void 0 : _b.postMessageWithAdditionalObjects) == null) { + return false; + } + return ((_d = (_c = window._wails) == null ? void 0 : _c.flags) == null ? void 0 : _d.enableFileDrop) === true; +} +function resolveFilePaths(x, y, files) { + var _a2, _b; + if ((_b = (_a2 = window.chrome) == null ? void 0 : _a2.webview) == null ? void 0 : _b.postMessageWithAdditionalObjects) { + window.chrome.webview.postMessageWithAdditionalObjects("file:drop:".concat(x, ":").concat(y), files); + } +} +var nativeDragActive = false; +function cleanupNativeDrag() { + nativeDragActive = false; + if (currentDropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + currentDropTarget = null; + } +} +function handleDragEnter() { + var _a2, _b; + if (((_b = (_a2 = window._wails) == null ? void 0 : _a2.flags) == null ? void 0 : _b.enableFileDrop) === false) { + return; + } + nativeDragActive = true; +} +function handleDragLeave() { + cleanupNativeDrag(); +} +function handleDragOver(x, y) { + var _a2, _b; + if (!nativeDragActive) return; + if (((_b = (_a2 = window._wails) == null ? void 0 : _a2.flags) == null ? void 0 : _b.enableFileDrop) === false) { + return; + } + const targetElement = document.elementFromPoint(x, y); + const dropTarget = getDropTargetElement(targetElement); + if (currentDropTarget && currentDropTarget !== dropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + } + if (dropTarget) { + dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS); + currentDropTarget = dropTarget; + } else { + currentDropTarget = null; + } } var callerSym = /* @__PURE__ */ Symbol("caller"); callerSym; @@ -1091,28 +1139,30 @@ var _Window = class _Window { return this[callerSym](ZoomResetMethod); } /** - * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop). + * Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop). * Gathers information about the drop target element and sends it back to the Go backend. * * @param filenames - An array of file paths (strings) that were dropped. - * @param x - The x-coordinate of the drop event. - * @param y - The y-coordinate of the drop event. + * @param x - The x-coordinate of the drop event (CSS pixels). + * @param y - The y-coordinate of the drop event (CSS pixels). */ HandlePlatformFileDrop(filenames, x, y) { - const element = document.elementFromPoint(x, y); - const dropzoneTarget = getDropzoneElement(element); - if (!dropzoneTarget) { - console.log("Wails Runtime: Drop on element (or no element) at ".concat(x, ",").concat(y, " which is not a designated dropzone. Ignoring. Element:"), element); + var _a2, _b; + if (((_b = (_a2 = window._wails) == null ? void 0 : _a2.flags) == null ? void 0 : _b.enableFileDrop) === false) { + return; + } + const element = document.elementFromPoint(x, y); + const dropTarget = getDropTargetElement(element); + if (!dropTarget) { return; } - console.log("Wails Runtime: Drop on designated dropzone. Element at (".concat(x, ", ").concat(y, "):"), element, "Effective dropzone:", dropzoneTarget); const elementDetails = { - id: dropzoneTarget.id, - classList: Array.from(dropzoneTarget.classList), + id: dropTarget.id, + classList: Array.from(dropTarget.classList), attributes: {} }; - for (let i = 0; i < dropzoneTarget.attributes.length; i++) { - const attr = dropzoneTarget.attributes[i]; + for (let i = 0; i < dropTarget.attributes.length; i++) { + const attr = dropTarget.attributes[i]; elementDetails.attributes[attr.name] = attr.value; } const payload = { @@ -1121,7 +1171,8 @@ var _Window = class _Window { y, elementDetails }; - this[callerSym](WindowDropZoneDropped, payload); + this[callerSym](FilesDropped, payload); + cleanupNativeDrag(); } /* Triggers Windows 11 Snap Assist feature (Windows only). * This is equivalent to pressing Win+Z and shows snap layout options. @@ -1138,65 +1189,117 @@ var _Window = class _Window { }; var Window = _Window; var thisWindow = new Window(""); -function setupGlobalDropzoneListeners() { +function setupDropTargetListeners() { const docElement = document.documentElement; let dragEnterCounter = 0; docElement.addEventListener("dragenter", (event) => { + var _a2, _b, _c; + if (!((_a2 = event.dataTransfer) == null ? void 0 : _a2.types.includes("Files"))) { + return; + } event.preventDefault(); - if (event.dataTransfer && event.dataTransfer.types.includes("Files")) { - dragEnterCounter++; - const targetElement = document.elementFromPoint(event.clientX, event.clientY); - const dropzone = getDropzoneElement(targetElement); - if (currentHoveredDropzone && currentHoveredDropzone !== dropzone) { - currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS); - } - if (dropzone) { - dropzone.classList.add(DROPZONE_HOVER_CLASS); - event.dataTransfer.dropEffect = "copy"; - currentHoveredDropzone = dropzone; - } else { - event.dataTransfer.dropEffect = "none"; - currentHoveredDropzone = null; - } + if (((_c = (_b = window._wails) == null ? void 0 : _b.flags) == null ? void 0 : _c.enableFileDrop) === false) { + event.dataTransfer.dropEffect = "none"; + return; + } + dragEnterCounter++; + const targetElement = document.elementFromPoint(event.clientX, event.clientY); + const dropTarget = getDropTargetElement(targetElement); + if (currentDropTarget && currentDropTarget !== dropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + } + if (dropTarget) { + dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS); + event.dataTransfer.dropEffect = "copy"; + currentDropTarget = dropTarget; + } else { + event.dataTransfer.dropEffect = "none"; + currentDropTarget = null; } }, false); docElement.addEventListener("dragover", (event) => { + var _a2, _b, _c; + if (!((_a2 = event.dataTransfer) == null ? void 0 : _a2.types.includes("Files"))) { + return; + } event.preventDefault(); - if (event.dataTransfer && event.dataTransfer.types.includes("Files")) { - if (currentHoveredDropzone) { - if (!currentHoveredDropzone.classList.contains(DROPZONE_HOVER_CLASS)) { - currentHoveredDropzone.classList.add(DROPZONE_HOVER_CLASS); - } - event.dataTransfer.dropEffect = "copy"; - } else { - event.dataTransfer.dropEffect = "none"; + if (((_c = (_b = window._wails) == null ? void 0 : _b.flags) == null ? void 0 : _c.enableFileDrop) === false) { + event.dataTransfer.dropEffect = "none"; + return; + } + const targetElement = document.elementFromPoint(event.clientX, event.clientY); + const dropTarget = getDropTargetElement(targetElement); + if (currentDropTarget && currentDropTarget !== dropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + } + if (dropTarget) { + if (!dropTarget.classList.contains(DROP_TARGET_ACTIVE_CLASS)) { + dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS); } + event.dataTransfer.dropEffect = "copy"; + currentDropTarget = dropTarget; + } else { + event.dataTransfer.dropEffect = "none"; + currentDropTarget = null; } }, false); docElement.addEventListener("dragleave", (event) => { + var _a2, _b, _c; + if (!((_a2 = event.dataTransfer) == null ? void 0 : _a2.types.includes("Files"))) { + return; + } event.preventDefault(); - if (event.dataTransfer && event.dataTransfer.types.includes("Files")) { - dragEnterCounter--; - if (dragEnterCounter === 0 || event.relatedTarget === null || currentHoveredDropzone && !currentHoveredDropzone.contains(event.relatedTarget)) { - if (currentHoveredDropzone) { - currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS); - currentHoveredDropzone = null; - } - dragEnterCounter = 0; + if (((_c = (_b = window._wails) == null ? void 0 : _b.flags) == null ? void 0 : _c.enableFileDrop) === false) { + return; + } + if (event.relatedTarget === null) { + return; + } + dragEnterCounter--; + if (dragEnterCounter === 0 || currentDropTarget && !currentDropTarget.contains(event.relatedTarget)) { + if (currentDropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + currentDropTarget = null; } + dragEnterCounter = 0; } }, false); docElement.addEventListener("drop", (event) => { + var _a2, _b, _c; + if (!((_a2 = event.dataTransfer) == null ? void 0 : _a2.types.includes("Files"))) { + return; + } event.preventDefault(); + if (((_c = (_b = window._wails) == null ? void 0 : _b.flags) == null ? void 0 : _c.enableFileDrop) === false) { + return; + } dragEnterCounter = 0; - if (currentHoveredDropzone) { - currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS); - currentHoveredDropzone = null; + if (currentDropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + currentDropTarget = null; + } + if (canResolveFilePaths()) { + const files = []; + if (event.dataTransfer.items) { + for (const item of event.dataTransfer.items) { + if (item.kind === "file") { + const file = item.getAsFile(); + if (file) files.push(file); + } + } + } else if (event.dataTransfer.files) { + for (const file of event.dataTransfer.files) { + files.push(file); + } + } + if (files.length > 0) { + resolveFilePaths(event.clientX, event.clientY, files); + } } }, false); } if (typeof window !== "undefined" && typeof document !== "undefined") { - setupGlobalDropzoneListeners(); + setupDropTargetListeners(); } var window_default = thisWindow; @@ -1345,7 +1448,6 @@ var system_exports = {}; __export(system_exports, { Capabilities: () => Capabilities, Environment: () => Environment, - HandlePlatformFileDrop: () => HandlePlatformFileDrop, IsAMD64: () => IsAMD64, IsARM: () => IsARM, IsARM64: () => IsARM64, @@ -1360,7 +1462,6 @@ var call4 = newRuntimeCaller(objectNames.System); var SystemIsDarkMode = 0; var SystemEnvironment = 1; var SystemCapabilities = 2; -var ApplicationFilesDroppedWithContext = 100; var _invoke = (function() { var _a2, _b, _c, _d, _e, _f; try { @@ -1421,23 +1522,6 @@ function IsDebug() { var _a2, _b; return Boolean((_b = (_a2 = window._wails) == null ? void 0 : _a2.environment) == null ? void 0 : _b.Debug); } -function HandlePlatformFileDrop(filenames, x, y) { - const element = document.elementFromPoint(x, y); - const elementId = element ? element.id : ""; - const classList = element ? Array.from(element.classList) : []; - const payload = { - filenames, - x, - y, - elementId, - classList - }; - call4(ApplicationFilesDroppedWithContext, payload).then(() => { - console.log("Platform file drop processed and sent to Go."); - }).catch((err) => { - console.error("Error sending platform file drop to Go:", err); - }); -} // desktop/@wailsio/runtime/src/contextmenu.ts window.addEventListener("contextmenu", contextMenuHandler); @@ -2647,6 +2731,9 @@ var Device; window._wails = window._wails || {}; window._wails.invoke = invoke; window._wails.handlePlatformFileDrop = window_default.HandlePlatformFileDrop.bind(window_default); +window._wails.handleDragEnter = handleDragEnter; +window._wails.handleDragLeave = handleDragLeave; +window._wails.handleDragOver = handleDragOver; invoke("wails:runtime:ready"); export { application_exports as Application, @@ -2670,4 +2757,4 @@ export { objectNames, setTransport }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.ts", "../../runtime/desktop/@wailsio/runtime/src/wml.ts", "../../runtime/desktop/@wailsio/runtime/src/browser.ts", "../../runtime/desktop/@wailsio/runtime/src/nanoid.ts", "../../runtime/desktop/@wailsio/runtime/src/runtime.ts", "../../runtime/desktop/@wailsio/runtime/src/dialogs.ts", "../../runtime/desktop/@wailsio/runtime/src/events.ts", "../../runtime/desktop/@wailsio/runtime/src/listener.ts", "../../runtime/desktop/@wailsio/runtime/src/create.ts", "../../runtime/desktop/@wailsio/runtime/src/event_types.ts", "../../runtime/desktop/@wailsio/runtime/src/utils.ts", "../../runtime/desktop/@wailsio/runtime/src/window.ts", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.ts", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.ts", "../../runtime/desktop/@wailsio/runtime/src/flags.ts", "../../runtime/desktop/@wailsio/runtime/src/drag.ts", "../../runtime/desktop/@wailsio/runtime/src/application.ts", "../../runtime/desktop/@wailsio/runtime/src/calls.ts", "../../runtime/desktop/@wailsio/runtime/src/callable.ts", "../../runtime/desktop/@wailsio/runtime/src/cancellable.ts", "../../runtime/desktop/@wailsio/runtime/src/clipboard.ts", "../../runtime/desktop/@wailsio/runtime/src/screens.ts", "../../runtime/desktop/@wailsio/runtime/src/ios.ts"],
  "sourcesContent": ["/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Setup\nwindow._wails = window._wails || {};\n\nimport \"./contextmenu.js\";\nimport \"./drag.js\";\n\n// Re-export public API\nimport * as Application from \"./application.js\";\nimport * as Browser from \"./browser.js\";\nimport * as Call from \"./calls.js\";\nimport * as Clipboard from \"./clipboard.js\";\nimport * as Create from \"./create.js\";\nimport * as Dialogs from \"./dialogs.js\";\nimport * as Events from \"./events.js\";\nimport * as Flags from \"./flags.js\";\nimport * as Screens from \"./screens.js\";\nimport * as System from \"./system.js\";\nimport * as IOS from \"./ios.js\";\nimport Window from \"./window.js\";\nimport * as WML from \"./wml.js\";\n\nexport {\n    Application,\n    Browser,\n    Call,\n    Clipboard,\n    Dialogs,\n    Events,\n    Flags,\n    Screens,\n    System,\n    IOS,\n    Window,\n    WML\n};\n\n/**\n * An internal utility consumed by the binding generator.\n *\n * @ignore\n */\nexport { Create };\n\nexport * from \"./cancellable.js\";\n\n// Export transport interfaces and utilities\nexport {\n    setTransport,\n    getTransport,\n    type RuntimeTransport,\n    objectNames,\n    clientId,\n} from \"./runtime.js\";\n\n// Notify backend\nwindow._wails.invoke = System.invoke;\n\n// Register platform handlers (internal API)\n// Note: Window is the thisWindow instance (default export from window.ts)\n// Binding ensures 'this' correctly refers to the current window instance\nwindow._wails.handlePlatformFileDrop = Window.HandlePlatformFileDrop.bind(Window);\n\nSystem.invoke(\"wails:runtime:ready\");\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { OpenURL } from \"./browser.js\";\nimport { Question } from \"./dialogs.js\";\nimport { Emit } from \"./events.js\";\nimport { canAbortListeners, whenReady } from \"./utils.js\";\nimport Window from \"./window.js\";\n\n/**\n * Sends an event with the given name and optional data.\n *\n * @param eventName - - The name of the event to send.\n * @param [data=null] - - Optional data to send along with the event.\n */\nfunction sendEvent(eventName: string, data: any = null): void {\n    Emit(eventName, data);\n}\n\n/**\n * Calls a method on a specified window.\n *\n * @param windowName - The name of the window to call the method on.\n * @param methodName - The name of the method to call.\n */\nfunction callWindowMethod(windowName: string, methodName: string) {\n    const targetWindow = Window.Get(windowName);\n    const method = (targetWindow as any)[methodName];\n\n    if (typeof method !== \"function\") {\n        console.error(`Window method '${methodName}' not found`);\n        return;\n    }\n\n    try {\n        method.call(targetWindow);\n    } catch (e) {\n        console.error(`Error calling window method '${methodName}': `, e);\n    }\n}\n\n/**\n * Responds to a triggering event by running appropriate WML actions for the current target.\n */\nfunction onWMLTriggered(ev: Event): void {\n    const element = ev.currentTarget as Element;\n\n    function runEffect(choice = \"Yes\") {\n        if (choice !== \"Yes\")\n            return;\n\n        const eventType = element.getAttribute('wml-event') || element.getAttribute('data-wml-event');\n        const targetWindow = element.getAttribute('wml-target-window') || element.getAttribute('data-wml-target-window') || \"\";\n        const windowMethod = element.getAttribute('wml-window') || element.getAttribute('data-wml-window');\n        const url = element.getAttribute('wml-openurl') || element.getAttribute('data-wml-openurl');\n\n        if (eventType !== null)\n            sendEvent(eventType);\n        if (windowMethod !== null)\n            callWindowMethod(targetWindow, windowMethod);\n        if (url !== null)\n            void OpenURL(url);\n    }\n\n    const confirm = element.getAttribute('wml-confirm') || element.getAttribute('data-wml-confirm');\n\n    if (confirm) {\n        Question({\n            Title: \"Confirm\",\n            Message: confirm,\n            Detached: false,\n            Buttons: [\n                { Label: \"Yes\" },\n                { Label: \"No\", IsDefault: true }\n            ]\n        }).then(runEffect);\n    } else {\n        runEffect();\n    }\n}\n\n// Private field names.\nconst controllerSym = Symbol(\"controller\");\nconst triggerMapSym = Symbol(\"triggerMap\");\nconst elementCountSym = Symbol(\"elementCount\");\n\n/**\n * AbortControllerRegistry does not actually remember active event listeners: instead\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\n */\nclass AbortControllerRegistry {\n    // Private fields.\n    [controllerSym]: AbortController;\n\n    constructor() {\n        this[controllerSym] = new AbortController();\n    }\n\n    /**\n     * Returns an options object for addEventListener that ties the listener\n     * to the AbortSignal from the current AbortController.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified elements\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        return { signal: this[controllerSym].signal };\n    }\n\n    /**\n     * Removes all registered event listeners and resets the registry.\n     */\n    reset(): void {\n        this[controllerSym].abort();\n        this[controllerSym] = new AbortController();\n    }\n}\n\n/**\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\n * This ensures that the mapping remains private to this module, while still allowing garbage\n * collection of the involved elements.\n */\nclass WeakMapRegistry {\n    /** Stores the current element-to-trigger mapping. */\n    [triggerMapSym]: WeakMap<Element, string[]>;\n    /** Counts the number of elements with active WML triggers. */\n    [elementCountSym]: number;\n\n    constructor() {\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n\n    /**\n     * Sets active triggers for the specified element.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified element\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        if (!this[triggerMapSym].has(element)) { this[elementCountSym]++; }\n        this[triggerMapSym].set(element, triggers);\n        return {};\n    }\n\n    /**\n     * Removes all registered event listeners.\n     */\n    reset(): void {\n        if (this[elementCountSym] <= 0)\n            return;\n\n        for (const element of document.body.querySelectorAll('*')) {\n            if (this[elementCountSym] <= 0)\n                break;\n\n            const triggers = this[triggerMapSym].get(element);\n            if (triggers != null) { this[elementCountSym]--; }\n\n            for (const trigger of triggers || [])\n                element.removeEventListener(trigger, onWMLTriggered);\n        }\n\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n}\n\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\n\n/**\n * Adds event listeners to the specified element.\n */\nfunction addWMLListeners(element: Element): void {\n    const triggerRegExp = /\\S+/g;\n    const triggerAttr = (element.getAttribute('wml-trigger') || element.getAttribute('data-wml-trigger') || \"click\");\n    const triggers: string[] = [];\n\n    let match;\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\n        triggers.push(match[0]);\n\n    const options = triggerRegistry.set(element, triggers);\n    for (const trigger of triggers)\n        element.addEventListener(trigger, onWMLTriggered, options);\n}\n\n/**\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\n */\nexport function Enable(): void {\n    whenReady(Reload);\n}\n\n/**\n * Reloads the WML page by adding necessary event listeners and browser listeners.\n */\nexport function Reload(): void {\n    triggerRegistry.reset();\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]').forEach(addWMLListeners);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Browser);\n\nconst BrowserOpenURL = 0;\n\n/**\n * Open a browser window to the given URL.\n *\n * @param url - The URL to open\n */\nexport function OpenURL(url: string | URL): Promise<void> {\n    return call(BrowserOpenURL, {url: url.toString()});\n}\n", "// Source: https://github.com/ai/nanoid\n\n// The MIT License (MIT)\n//\n// Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n//     subject to the following conditions:\n//\n//     The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n//     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// This alphabet uses `A-Za-z0-9_-` symbols.\n// The order of characters is optimized for better gzip and brotli compression.\n// References to the same file (works both for gzip and brotli):\n// `'use`, `andom`, and `rict'`\n// References to the brotli default dictionary:\n// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`\nconst urlAlphabet =\n    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n\nexport function nanoid(size: number = 21): string {\n    let id = ''\n    // A compact alternative for `for (var i = 0; i < step; i++)`.\n    let i = size | 0\n    while (i--) {\n        // `| 0` is more compact and faster than `Math.floor()`.\n        id += urlAlphabet[(Math.random() * 64) | 0]\n    }\n    return id\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { nanoid } from \"./nanoid.js\";\n\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\n\n// Re-export nanoid for custom transport implementations\nexport { nanoid };\n\n// Object Names\nexport const objectNames = Object.freeze({\n    Call: 0,\n    Clipboard: 1,\n    Application: 2,\n    Events: 3,\n    ContextMenu: 4,\n    Dialog: 5,\n    Window: 6,\n    Screens: 7,\n    System: 8,\n    Browser: 9,\n    CancelCall: 10,\n    IOS: 11,\n});\nexport let clientId = nanoid();\n\n/**\n * RuntimeTransport defines the interface for custom IPC transport implementations.\n * Implement this interface to use WebSockets, custom protocols, or any other\n * transport mechanism instead of the default HTTP fetch.\n */\nexport interface RuntimeTransport {\n    /**\n     * Send a runtime call and return the response.\n     *\n     * @param objectID - The Wails object ID (0=Call, 1=Clipboard, etc.)\n     * @param method - The method ID to call\n     * @param windowName - Optional window name\n     * @param args - Arguments to pass (will be JSON stringified if present)\n     * @returns Promise that resolves with the response data\n     */\n    call(objectID: number, method: number, windowName: string, args: any): Promise<any>;\n}\n\n/**\n * Custom transport implementation (can be set by user)\n */\nlet customTransport: RuntimeTransport | null = null;\n\n/**\n * Set a custom transport for all Wails runtime calls.\n * This allows you to replace the default HTTP fetch transport with\n * WebSockets, custom protocols, or any other mechanism.\n *\n * @param transport - Your custom transport implementation\n *\n * @example\n * ```typescript\n * import { setTransport } from '/wails/runtime.js';\n *\n * const wsTransport = {\n *   call: async (objectID, method, windowName, args) => {\n *     // Your WebSocket implementation\n *   }\n * };\n *\n * setTransport(wsTransport);\n * ```\n */\nexport function setTransport(transport: RuntimeTransport | null): void {\n    customTransport = transport;\n}\n\n/**\n * Get the current transport (useful for extending/wrapping)\n */\nexport function getTransport(): RuntimeTransport | null {\n    return customTransport;\n}\n\n/**\n * Creates a new runtime caller with specified ID.\n *\n * @param object - The object to invoke the method on.\n * @param windowName - The name of the window.\n * @return The new runtime caller function.\n */\nexport function newRuntimeCaller(object: number, windowName: string = '') {\n    return function (method: number, args: any = null) {\n        return runtimeCallWithID(object, method, windowName, args);\n    };\n}\n\nasync function runtimeCallWithID(objectID: number, method: number, windowName: string, args: any): Promise<any> {\n    // Use custom transport if available\n    if (customTransport) {\n        return customTransport.call(objectID, method, windowName, args);\n    }\n\n    // Default HTTP fetch transport\n    let url = new URL(runtimeURL);\n\n    let body: { object: number; method: number, args?: any } = {\n      object: objectID,\n      method\n    }\n    if (args !== null && args !== undefined) {\n      body.args = args;\n    }\n\n    let headers: Record<string, string> = {\n        [\"x-wails-client-id\"]: clientId,\n        [\"Content-Type\"]: \"application/json\"\n    }\n    if (windowName) {\n        headers[\"x-wails-window-name\"] = windowName;\n    }\n\n    let response = await fetch(url, {\n      method: 'POST',\n      headers,\n      body: JSON.stringify(body)\n    });\n    if (!response.ok) {\n        throw new Error(await response.text());\n    }\n\n    if ((response.headers.get(\"Content-Type\")?.indexOf(\"application/json\") ?? -1) !== -1) {\n        return response.json();\n    } else {\n        return response.text();\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\n// setup\nwindow._wails = window._wails || {};\n\nconst call = newRuntimeCaller(objectNames.Dialog);\n\n// Define constants from the `methods` object in Title Case\nconst DialogInfo = 0;\nconst DialogWarning = 1;\nconst DialogError = 2;\nconst DialogQuestion = 3;\nconst DialogOpenFile = 4;\nconst DialogSaveFile = 5;\n\nexport interface OpenFileDialogOptions {\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if multiple selection is allowed. */\n    AllowsMultipleSelection?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface SaveFileDialogOptions {\n    /** Default filename to use in the dialog. */\n    Filename?: string;\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface MessageDialogOptions {\n    /** The title of the dialog window. */\n    Title?: string;\n    /** The main message to show in the dialog. */\n    Message?: string;\n    /** Array of button options to show in the dialog. */\n    Buttons?: Button[];\n    /** True if the dialog should appear detached from the main window (if applicable). */\n    Detached?: boolean;\n}\n\nexport interface Button {\n    /** Text that appears within the button. */\n    Label?: string;\n    /** True if the button should cancel an operation when clicked. */\n    IsCancel?: boolean;\n    /** True if the button should be the default action when the user presses enter. */\n    IsDefault?: boolean;\n}\n\nexport interface FileFilter {\n    /** Display name for the filter, it could be \"Text Files\", \"Images\" etc. */\n    DisplayName?: string;\n    /** Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files. */\n    Pattern?: string;\n}\n\n/**\n * Presents a dialog of specified type with the given options.\n *\n * @param type - Dialog type.\n * @param options - Options for the dialog.\n * @returns A promise that resolves with result of dialog.\n */\nfunction dialog(type: number, options: MessageDialogOptions | OpenFileDialogOptions | SaveFileDialogOptions = {}): Promise<any> {\n    return call(type, options);\n}\n\n/**\n * Presents an info dialog.\n *\n * @param options - Dialog options\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Info(options: MessageDialogOptions): Promise<string> { return dialog(DialogInfo, options); }\n\n/**\n * Presents a warning dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Warning(options: MessageDialogOptions): Promise<string> { return dialog(DialogWarning, options); }\n\n/**\n * Presents an error dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Error(options: MessageDialogOptions): Promise<string> { return dialog(DialogError, options); }\n\n/**\n * Presents a question dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Question(options: MessageDialogOptions): Promise<string> { return dialog(DialogQuestion, options); }\n\n/**\n * Presents a file selection dialog to pick one or more files to open.\n *\n * @param options - Dialog options.\n * @returns Selected file or list of files, or a blank string/empty list if no file has been selected.\n */\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection: true }): Promise<string[]>;\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection?: false | undefined }): Promise<string>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]> { return dialog(DialogOpenFile, options) ?? []; }\n\n/**\n * Presents a file selection dialog to pick a file to save.\n *\n * @param options - Dialog options.\n * @returns Selected file, or a blank string if no file has been selected.\n */\nexport function SaveFile(options: SaveFileDialogOptions): Promise<string> { return dialog(DialogSaveFile, options); }\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { eventListeners, Listener, listenerOff } from \"./listener.js\";\nimport { Events as Create } from \"./create.js\";\nimport { Types } from \"./event_types.js\";\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.dispatchWailsEvent = dispatchWailsEvent;\n\nconst call = newRuntimeCaller(objectNames.Events);\nconst EmitMethod = 0;\n\nexport * from \"./event_types.js\";\n\n/**\n * A table of data types for all known events.\n * Will be monkey-patched by the binding generator.\n */\nexport interface CustomEvents {}\n\n/**\n * Either a known event name or an arbitrary string.\n */\nexport type WailsEventName<E extends keyof CustomEvents = keyof CustomEvents> = E | (string & {});\n\n/**\n * Union of all known system event names.\n */\ntype SystemEventName = {\n    [K in keyof (typeof Types)]: (typeof Types)[K][keyof ((typeof Types)[K])]\n} extends (infer M) ? M[keyof M] : never;\n\n/**\n * The data type associated to a given event.\n */\nexport type WailsEventData<E extends WailsEventName = WailsEventName> =\n    E extends keyof CustomEvents ? CustomEvents[E] : (E extends SystemEventName ? void : any);\n\n/**\n * The type of handlers for a given event.\n */\nexport type WailsEventCallback<E extends WailsEventName = WailsEventName> = (ev: WailsEvent<E>) => void;\n\n/**\n * Represents a system event or a custom event emitted through wails-provided facilities.\n */\nexport class WailsEvent<E extends WailsEventName = WailsEventName> {\n    /**\n     * The name of the event.\n     */\n    name: E;\n\n    /**\n     * Optional data associated with the emitted event.\n     */\n    data: WailsEventData<E>;\n\n    /**\n     * Name of the originating window. Omitted for application events.\n     * Will be overridden if set manually.\n     */\n    sender?: string;\n\n    constructor(name: E, data: WailsEventData<E>);\n    constructor(name: WailsEventData<E> extends null | void ? E : never)\n    constructor(name: E, data?: any) {\n        this.name = name;\n        this.data = data ?? null;\n    }\n}\n\nfunction dispatchWailsEvent(event: any) {\n    let listeners = eventListeners.get(event.name);\n    if (!listeners) {\n        return;\n    }\n\n    let wailsEvent = new WailsEvent(\n        event.name,\n        (event.name in Create) ? Create[event.name](event.data) : event.data\n    );\n    if ('sender' in event) {\n        wailsEvent.sender = event.sender;\n    }\n\n    listeners = listeners.filter(listener => !listener.dispatch(wailsEvent));\n    if (listeners.length === 0) {\n        eventListeners.delete(event.name);\n    } else {\n        eventListeners.set(event.name, listeners);\n    }\n}\n\n/**\n * Register a callback function to be called multiple times for a specific event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @param 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.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function OnMultiple<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>, maxCallbacks: number) {\n    let listeners = eventListeners.get(eventName) || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    listeners.push(thisListener);\n    eventListeners.set(eventName, listeners);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers a callback function to be executed when the specified event occurs.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function On<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void {\n    return OnMultiple(eventName, callback, -1);\n}\n\n/**\n * Registers a callback function to be executed only once for the specified event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function Once<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void {\n    return OnMultiple(eventName, callback, 1);\n}\n\n/**\n * Removes event listeners for the specified event names.\n *\n * @param eventNames - The name of the events to remove listeners for.\n */\nexport function Off(...eventNames: [WailsEventName, ...WailsEventName[]]): void {\n    eventNames.forEach(eventName => eventListeners.delete(eventName));\n}\n\n/**\n * Removes all event listeners.\n */\nexport function OffAll(): void {\n    eventListeners.clear();\n}\n\n/**\n * Emits an event.\n *\n * @returns A promise that will be fulfilled once the event has been emitted.  Resolves to true if the event was cancelled.\n * @param name - The name of the event to emit\n * @param data - The data that will be sent with the event\n */\nexport function Emit<E extends WailsEventName = WailsEventName>(name: E, data: WailsEventData<E>): Promise<boolean>\nexport function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E> extends null | void ? E : never): Promise<boolean>\nexport function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E>, data?: any): Promise<boolean> {\n    return call(EmitMethod,  new WailsEvent(name, data))\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// The following utilities have been factored out of ./events.ts\n// for testing purposes.\n\nexport const eventListeners = new Map<string, Listener[]>();\n\nexport class Listener {\n    eventName: string;\n    callback: (data: any) => void;\n    maxCallbacks: number;\n\n    constructor(eventName: string, callback: (data: any) => void, maxCallbacks: number) {\n        this.eventName = eventName;\n        this.callback = callback;\n        this.maxCallbacks = maxCallbacks || -1;\n    }\n\n    dispatch(data: any): boolean {\n        try {\n            this.callback(data);\n        } catch (err) {\n            console.error(err);\n        }\n\n        if (this.maxCallbacks === -1) return false;\n        this.maxCallbacks -= 1;\n        return this.maxCallbacks === 0;\n    }\n}\n\nexport function listenerOff(listener: Listener): void {\n    let listeners = eventListeners.get(listener.eventName);\n    if (!listeners) {\n        return;\n    }\n\n    listeners = listeners.filter(l => l !== listener);\n    if (listeners.length === 0) {\n        eventListeners.delete(listener.eventName);\n    } else {\n        eventListeners.set(listener.eventName, listeners);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Any is a dummy creation function for simple or unknown types.\n */\nexport function Any<T = any>(source: any): T {\n    return source;\n}\n\n/**\n * ByteSlice is a creation function that replaces\n * null strings with empty strings.\n */\nexport function ByteSlice(source: any): string {\n    return ((source == null) ? \"\" : source);\n}\n\n/**\n * Array takes a creation function for an arbitrary type\n * and returns an in-place creation function for an array\n * whose elements are of that type.\n */\nexport function Array<T = any>(element: (source: any) => T): (source: any) => T[] {\n    if (element === Any) {\n        return (source) => (source === null ? [] : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return [];\n        }\n        for (let i = 0; i < source.length; i++) {\n            source[i] = element(source[i]);\n        }\n        return source;\n    };\n}\n\n/**\n * Map takes creation functions for two arbitrary types\n * and returns an in-place creation function for an object\n * whose keys and values are of those types.\n */\nexport function Map<V = any>(key: (source: any) => string, value: (source: any) => V): (source: any) => Record<string, V> {\n    if (value === Any) {\n        return (source) => (source === null ? {} : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return {};\n        }\n        for (const key in source) {\n            source[key] = value(source[key]);\n        }\n        return source;\n    };\n}\n\n/**\n * Nullable takes a creation function for an arbitrary type\n * and returns a creation function for a nullable value of that type.\n */\nexport function Nullable<T = any>(element: (source: any) => T): (source: any) => (T | null) {\n    if (element === Any) {\n        return Any;\n    }\n\n    return (source) => (source === null ? null : element(source));\n}\n\n/**\n * Struct takes an object mapping field names to creation functions\n * and returns an in-place creation function for a struct.\n */\nexport function Struct(createField: Record<string, (source: any) => any>):\n    <U extends Record<string, any> = any>(source: any) => U\n{\n    let allAny = true;\n    for (const name in createField) {\n        if (createField[name] !== Any) {\n            allAny = false;\n            break;\n        }\n    }\n    if (allAny) {\n        return Any;\n    }\n\n    return (source) => {\n        for (const name in createField) {\n            if (name in source) {\n                source[name] = createField[name](source[name]);\n            }\n        }\n        return source;\n    };\n}\n\n/**\n * Maps known event names to creation functions for their data types.\n * Will be monkey-patched by the binding generator.\n */\nexport const Events: Record<string, (source: any) => any> = {};\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH \u00C2 MODIWL\n// This file is automatically generated. DO NOT EDIT\n\nexport const Types = Object.freeze({\n\tWindows: Object.freeze({\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\n\t\tAPMSuspend: \"windows:APMSuspend\",\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\n\t\tWindowActive: \"windows:WindowActive\",\n\t\tWindowBackgroundErase: \"windows:WindowBackgroundErase\",\n\t\tWindowClickActive: \"windows:WindowClickActive\",\n\t\tWindowClosing: \"windows:WindowClosing\",\n\t\tWindowDidMove: \"windows:WindowDidMove\",\n\t\tWindowDidResize: \"windows:WindowDidResize\",\n\t\tWindowDPIChanged: \"windows:WindowDPIChanged\",\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\n\t\tWindowDragOver: \"windows:WindowDragOver\",\n\t\tWindowEndMove: \"windows:WindowEndMove\",\n\t\tWindowEndResize: \"windows:WindowEndResize\",\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\n\t\tWindowHide: \"windows:WindowHide\",\n\t\tWindowInactive: \"windows:WindowInactive\",\n\t\tWindowKeyDown: \"windows:WindowKeyDown\",\n\t\tWindowKeyUp: \"windows:WindowKeyUp\",\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\n\t\tWindowNonClientHit: \"windows:WindowNonClientHit\",\n\t\tWindowNonClientMouseDown: \"windows:WindowNonClientMouseDown\",\n\t\tWindowNonClientMouseLeave: \"windows:WindowNonClientMouseLeave\",\n\t\tWindowNonClientMouseMove: \"windows:WindowNonClientMouseMove\",\n\t\tWindowNonClientMouseUp: \"windows:WindowNonClientMouseUp\",\n\t\tWindowPaint: \"windows:WindowPaint\",\n\t\tWindowRestore: \"windows:WindowRestore\",\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\n\t\tWindowShow: \"windows:WindowShow\",\n\t\tWindowStartMove: \"windows:WindowStartMove\",\n\t\tWindowStartResize: \"windows:WindowStartResize\",\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\n\t\tWindowZOrderChanged: \"windows:WindowZOrderChanged\",\n\t\tWindowMinimise: \"windows:WindowMinimise\",\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\n\t\tWindowMaximise: \"windows:WindowMaximise\",\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\n\t}),\n\tMac: Object.freeze({\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme\",\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\n\t\tApplicationDidResignActive: \"mac:ApplicationDidResignActive\",\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen\",\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\n\t\tMenuDidClose: \"mac:MenuDidClose\",\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\n\t\tWindowDidMove: \"mac:WindowDidMove\",\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\n\t\tWindowDidResize: \"mac:WindowDidResize\",\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\n\t\tWindowDidZoom: \"mac:WindowDidZoom\",\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\n\t\tWindowHide: \"mac:WindowHide\",\n\t\tWindowMaximise: \"mac:WindowMaximise\",\n\t\tWindowUnMaximise: \"mac:WindowUnMaximise\",\n\t\tWindowMinimise: \"mac:WindowMinimise\",\n\t\tWindowUnMinimise: \"mac:WindowUnMinimise\",\n\t\tWindowShouldClose: \"mac:WindowShouldClose\",\n\t\tWindowShow: \"mac:WindowShow\",\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\n\t\tWindowWillClose: \"mac:WindowWillClose\",\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\n\t\tWindowWillMove: \"mac:WindowWillMove\",\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\n\t\tWindowWillResize: \"mac:WindowWillResize\",\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\n\t\tWindowZoomIn: \"mac:WindowZoomIn\",\n\t\tWindowZoomOut: \"mac:WindowZoomOut\",\n\t\tWindowZoomReset: \"mac:WindowZoomReset\",\n\t}),\n\tLinux: Object.freeze({\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\n\t\tWindowDidMove: \"linux:WindowDidMove\",\n\t\tWindowDidResize: \"linux:WindowDidResize\",\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\n\t\tWindowLoadStarted: \"linux:WindowLoadStarted\",\n\t\tWindowLoadRedirected: \"linux:WindowLoadRedirected\",\n\t\tWindowLoadCommitted: \"linux:WindowLoadCommitted\",\n\t\tWindowLoadFinished: \"linux:WindowLoadFinished\",\n\t}),\n\tiOS: Object.freeze({\n\t\tApplicationDidBecomeActive: \"ios:ApplicationDidBecomeActive\",\n\t\tApplicationDidEnterBackground: \"ios:ApplicationDidEnterBackground\",\n\t\tApplicationDidFinishLaunching: \"ios:ApplicationDidFinishLaunching\",\n\t\tApplicationDidReceiveMemoryWarning: \"ios:ApplicationDidReceiveMemoryWarning\",\n\t\tApplicationWillEnterForeground: \"ios:ApplicationWillEnterForeground\",\n\t\tApplicationWillResignActive: \"ios:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"ios:ApplicationWillTerminate\",\n\t\tWindowDidLoad: \"ios:WindowDidLoad\",\n\t\tWindowWillAppear: \"ios:WindowWillAppear\",\n\t\tWindowDidAppear: \"ios:WindowDidAppear\",\n\t\tWindowWillDisappear: \"ios:WindowWillDisappear\",\n\t\tWindowDidDisappear: \"ios:WindowDidDisappear\",\n\t\tWindowSafeAreaInsetsChanged: \"ios:WindowSafeAreaInsetsChanged\",\n\t\tWindowOrientationChanged: \"ios:WindowOrientationChanged\",\n\t\tWindowTouchBegan: \"ios:WindowTouchBegan\",\n\t\tWindowTouchMoved: \"ios:WindowTouchMoved\",\n\t\tWindowTouchEnded: \"ios:WindowTouchEnded\",\n\t\tWindowTouchCancelled: \"ios:WindowTouchCancelled\",\n\t\tWebViewDidStartNavigation: \"ios:WebViewDidStartNavigation\",\n\t\tWebViewDidFinishNavigation: \"ios:WebViewDidFinishNavigation\",\n\t\tWebViewDidFailNavigation: \"ios:WebViewDidFailNavigation\",\n\t\tWebViewDecidePolicyForNavigationAction: \"ios:WebViewDecidePolicyForNavigationAction\",\n\t}),\n\tCommon: Object.freeze({\n\t\tApplicationOpenedWithFile: \"common:ApplicationOpenedWithFile\",\n\t\tApplicationStarted: \"common:ApplicationStarted\",\n\t\tApplicationLaunchedWithUrl: \"common:ApplicationLaunchedWithUrl\",\n\t\tThemeChanged: \"common:ThemeChanged\",\n\t\tWindowClosing: \"common:WindowClosing\",\n\t\tWindowDidMove: \"common:WindowDidMove\",\n\t\tWindowDidResize: \"common:WindowDidResize\",\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\n\t\tWindowFocus: \"common:WindowFocus\",\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\n\t\tWindowHide: \"common:WindowHide\",\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\n\t\tWindowMaximise: \"common:WindowMaximise\",\n\t\tWindowMinimise: \"common:WindowMinimise\",\n\t\tWindowToggleFrameless: \"common:WindowToggleFrameless\",\n\t\tWindowRestore: \"common:WindowRestore\",\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\n\t\tWindowShow: \"common:WindowShow\",\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\n\t\tWindowZoom: \"common:WindowZoom\",\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\n\t\tWindowDropZoneFilesDropped: \"common:WindowDropZoneFilesDropped\",\n\t}),\n});\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Logs a message to the console with custom formatting.\n *\n * @param message - The message to be logged.\n */\nexport function debugLog(message: any) {\n    // eslint-disable-next-line\n    console.log(\n        '%c wails3 %c ' + message + ' ',\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\n    );\n}\n\n/**\n * Checks whether the webview supports the {@link MouseEvent#buttons} property.\n * Looking at you macOS High Sierra!\n */\nexport function canTrackButtons(): boolean {\n    return (new MouseEvent('mousedown')).buttons === 0;\n}\n\n/**\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal).\n */\nexport function canAbortListeners() {\n    if (!EventTarget || !AbortSignal || !AbortController)\n        return false;\n\n    let result = true;\n\n    const target = new EventTarget();\n    const controller = new AbortController();\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\n    controller.abort();\n    target.dispatchEvent(new CustomEvent('test'));\n\n    return result;\n}\n\n/**\n * Resolves the closest HTMLElement ancestor of an event's target.\n */\nexport function eventTarget(event: Event): HTMLElement {\n    if (event.target instanceof HTMLElement) {\n        return event.target;\n    } else if (!(event.target instanceof HTMLElement) && event.target instanceof Node) {\n        return event.target.parentElement ?? document.body;\n    } else {\n        return document.body;\n    }\n}\n\n/***\n This technique for proper load detection is taken from HTMX:\n\n BSD 2-Clause License\n\n Copyright (c) 2020, Big Sky Software\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n ***/\n\nlet isReady = false;\ndocument.addEventListener('DOMContentLoaded', () => { isReady = true });\n\nexport function whenReady(callback: () => void) {\n    if (isReady || document.readyState === 'complete') {\n        callback();\n    } else {\n        document.addEventListener('DOMContentLoaded', callback);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\nimport type { Screen } from \"./screens.js\";\n\n// NEW: Dropzone constants\nconst DROPZONE_ATTRIBUTE = 'data-wails-dropzone';\nconst DROPZONE_HOVER_CLASS = 'wails-dropzone-hover'; // User can style this class\nlet currentHoveredDropzone: Element | null = null;\n\nconst PositionMethod                    = 0;\nconst CenterMethod                      = 1;\nconst CloseMethod                       = 2;\nconst DisableSizeConstraintsMethod      = 3;\nconst EnableSizeConstraintsMethod       = 4;\nconst FocusMethod                       = 5;\nconst ForceReloadMethod                 = 6;\nconst FullscreenMethod                  = 7;\nconst GetScreenMethod                   = 8;\nconst GetZoomMethod                     = 9;\nconst HeightMethod                      = 10;\nconst HideMethod                        = 11;\nconst IsFocusedMethod                   = 12;\nconst IsFullscreenMethod                = 13;\nconst IsMaximisedMethod                 = 14;\nconst IsMinimisedMethod                 = 15;\nconst MaximiseMethod                    = 16;\nconst MinimiseMethod                    = 17;\nconst NameMethod                        = 18;\nconst OpenDevToolsMethod                = 19;\nconst RelativePositionMethod            = 20;\nconst ReloadMethod                      = 21;\nconst ResizableMethod                   = 22;\nconst RestoreMethod                     = 23;\nconst SetPositionMethod                 = 24;\nconst SetAlwaysOnTopMethod              = 25;\nconst SetBackgroundColourMethod         = 26;\nconst SetFramelessMethod                = 27;\nconst SetFullscreenButtonEnabledMethod  = 28;\nconst SetMaxSizeMethod                  = 29;\nconst SetMinSizeMethod                  = 30;\nconst SetRelativePositionMethod         = 31;\nconst SetResizableMethod                = 32;\nconst SetSizeMethod                     = 33;\nconst SetTitleMethod                    = 34;\nconst SetZoomMethod                     = 35;\nconst ShowMethod                        = 36;\nconst SizeMethod                        = 37;\nconst ToggleFullscreenMethod            = 38;\nconst ToggleMaximiseMethod              = 39;\nconst ToggleFramelessMethod             = 40; \nconst UnFullscreenMethod                = 41;\nconst UnMaximiseMethod                  = 42;\nconst UnMinimiseMethod                  = 43;\nconst WidthMethod                       = 44;\nconst ZoomMethod                        = 45;\nconst ZoomInMethod                      = 46;\nconst ZoomOutMethod                     = 47;\nconst ZoomResetMethod                   = 48;\nconst SnapAssistMethod                  = 49;\nconst WindowDropZoneDropped             = 50;\nconst PrintMethod                       = 51;\n\nfunction getDropzoneElement(element: Element | null): Element | null {\n    if (!element) {\n        return null;\n    }\n    // Allow dropzone attribute to be on the element itself or any parent\n    return element.closest(`[${DROPZONE_ATTRIBUTE}]`);\n}\n\n/**\n * A record describing the position of a window.\n */\ninterface Position {\n    /** The horizontal position of the window. */\n    x: number;\n    /** The vertical position of the window. */\n    y: number;\n}\n\n/**\n * A record describing the size of a window.\n */\ninterface Size {\n    /** The width of the window. */\n    width: number;\n    /** The height of the window. */\n    height: number;\n}\n\n// Private field names.\nconst callerSym = Symbol(\"caller\");\n\nclass Window {\n    // Private fields.\n    private [callerSym]: (message: number, args?: any) => Promise<any>;\n\n    /**\n     * Initialises a window object with the specified name.\n     *\n     * @private\n     * @param name - The name of the target window.\n     */\n    constructor(name: string = '') {\n        this[callerSym] = newRuntimeCaller(objectNames.Window, name)\n\n        // bind instance method to make them easily usable in event handlers\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\n            if (\n                method !== \"constructor\"\n                && typeof (this as any)[method] === \"function\"\n            ) {\n                (this as any)[method] = (this as any)[method].bind(this);\n            }\n        }\n    }\n\n    /**\n     * Gets the specified window.\n     *\n     * @param name - The name of the window to get.\n     * @returns The corresponding window object.\n     */\n    Get(name: string): Window {\n        return new Window(name);\n    }\n\n    /**\n     * Returns the absolute position of the window.\n     *\n     * @returns The current absolute position of the window.\n     */\n    Position(): Promise<Position> {\n        return this[callerSym](PositionMethod);\n    }\n\n    /**\n     * Centers the window on the screen.\n     */\n    Center(): Promise<void> {\n        return this[callerSym](CenterMethod);\n    }\n\n    /**\n     * Closes the window.\n     */\n    Close(): Promise<void> {\n        return this[callerSym](CloseMethod);\n    }\n\n    /**\n     * Disables min/max size constraints.\n     */\n    DisableSizeConstraints(): Promise<void> {\n        return this[callerSym](DisableSizeConstraintsMethod);\n    }\n\n    /**\n     * Enables min/max size constraints.\n     */\n    EnableSizeConstraints(): Promise<void> {\n        return this[callerSym](EnableSizeConstraintsMethod);\n    }\n\n    /**\n     * Focuses the window.\n     */\n    Focus(): Promise<void> {\n        return this[callerSym](FocusMethod);\n    }\n\n    /**\n     * Forces the window to reload the page assets.\n     */\n    ForceReload(): Promise<void> {\n        return this[callerSym](ForceReloadMethod);\n    }\n\n    /**\n     * Switches the window to fullscreen mode.\n     */\n    Fullscreen(): Promise<void> {\n        return this[callerSym](FullscreenMethod);\n    }\n\n    /**\n     * Returns the screen that the window is on.\n     *\n     * @returns The screen the window is currently on.\n     */\n    GetScreen(): Promise<Screen> {\n        return this[callerSym](GetScreenMethod);\n    }\n\n    /**\n     * Returns the current zoom level of the window.\n     *\n     * @returns The current zoom level.\n     */\n    GetZoom(): Promise<number> {\n        return this[callerSym](GetZoomMethod);\n    }\n\n    /**\n     * Returns the height of the window.\n     *\n     * @returns The current height of the window.\n     */\n    Height(): Promise<number> {\n        return this[callerSym](HeightMethod);\n    }\n\n    /**\n     * Hides the window.\n     */\n    Hide(): Promise<void> {\n        return this[callerSym](HideMethod);\n    }\n\n    /**\n     * Returns true if the window is focused.\n     *\n     * @returns Whether the window is currently focused.\n     */\n    IsFocused(): Promise<boolean> {\n        return this[callerSym](IsFocusedMethod);\n    }\n\n    /**\n     * Returns true if the window is fullscreen.\n     *\n     * @returns Whether the window is currently fullscreen.\n     */\n    IsFullscreen(): Promise<boolean> {\n        return this[callerSym](IsFullscreenMethod);\n    }\n\n    /**\n     * Returns true if the window is maximised.\n     *\n     * @returns Whether the window is currently maximised.\n     */\n    IsMaximised(): Promise<boolean> {\n        return this[callerSym](IsMaximisedMethod);\n    }\n\n    /**\n     * Returns true if the window is minimised.\n     *\n     * @returns Whether the window is currently minimised.\n     */\n    IsMinimised(): Promise<boolean> {\n        return this[callerSym](IsMinimisedMethod);\n    }\n\n    /**\n     * Maximises the window.\n     */\n    Maximise(): Promise<void> {\n        return this[callerSym](MaximiseMethod);\n    }\n\n    /**\n     * Minimises the window.\n     */\n    Minimise(): Promise<void> {\n        return this[callerSym](MinimiseMethod);\n    }\n\n    /**\n     * Returns the name of the window.\n     *\n     * @returns The name of the window.\n     */\n    Name(): Promise<string> {\n        return this[callerSym](NameMethod);\n    }\n\n    /**\n     * Opens the development tools pane.\n     */\n    OpenDevTools(): Promise<void> {\n        return this[callerSym](OpenDevToolsMethod);\n    }\n\n    /**\n     * Returns the relative position of the window to the screen.\n     *\n     * @returns The current relative position of the window.\n     */\n    RelativePosition(): Promise<Position> {\n        return this[callerSym](RelativePositionMethod);\n    }\n\n    /**\n     * Reloads the page assets.\n     */\n    Reload(): Promise<void> {\n        return this[callerSym](ReloadMethod);\n    }\n\n    /**\n     * Returns true if the window is resizable.\n     *\n     * @returns Whether the window is currently resizable.\n     */\n    Resizable(): Promise<boolean> {\n        return this[callerSym](ResizableMethod);\n    }\n\n    /**\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\n     */\n    Restore(): Promise<void> {\n        return this[callerSym](RestoreMethod);\n    }\n\n    /**\n     * Sets the absolute position of the window.\n     *\n     * @param x - The desired horizontal absolute position of the window.\n     * @param y - The desired vertical absolute position of the window.\n     */\n    SetPosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetPositionMethod, { x, y });\n    }\n\n    /**\n     * Sets the window to be always on top.\n     *\n     * @param alwaysOnTop - Whether the window should stay on top.\n     */\n    SetAlwaysOnTop(alwaysOnTop: boolean): Promise<void> {\n        return this[callerSym](SetAlwaysOnTopMethod, { alwaysOnTop });\n    }\n\n    /**\n     * Sets the background colour of the window.\n     *\n     * @param r - The desired red component of the window background.\n     * @param g - The desired green component of the window background.\n     * @param b - The desired blue component of the window background.\n     * @param a - The desired alpha component of the window background.\n     */\n    SetBackgroundColour(r: number, g: number, b: number, a: number): Promise<void> {\n        return this[callerSym](SetBackgroundColourMethod, { r, g, b, a });\n    }\n\n    /**\n     * Removes the window frame and title bar.\n     *\n     * @param frameless - Whether the window should be frameless.\n     */\n    SetFrameless(frameless: boolean): Promise<void> {\n        return this[callerSym](SetFramelessMethod, { frameless });\n    }\n\n    /**\n     * Disables the system fullscreen button.\n     *\n     * @param enabled - Whether the fullscreen button should be enabled.\n     */\n    SetFullscreenButtonEnabled(enabled: boolean): Promise<void> {\n        return this[callerSym](SetFullscreenButtonEnabledMethod, { enabled });\n    }\n\n    /**\n     * Sets the maximum size of the window.\n     *\n     * @param width - The desired maximum width of the window.\n     * @param height - The desired maximum height of the window.\n     */\n    SetMaxSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMaxSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the minimum size of the window.\n     *\n     * @param width - The desired minimum width of the window.\n     * @param height - The desired minimum height of the window.\n     */\n    SetMinSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMinSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the relative position of the window to the screen.\n     *\n     * @param x - The desired horizontal relative position of the window.\n     * @param y - The desired vertical relative position of the window.\n     */\n    SetRelativePosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetRelativePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets whether the window is resizable.\n     *\n     * @param resizable - Whether the window should be resizable.\n     */\n    SetResizable(resizable: boolean): Promise<void> {\n        return this[callerSym](SetResizableMethod, { resizable });\n    }\n\n    /**\n     * Sets the size of the window.\n     *\n     * @param width - The desired width of the window.\n     * @param height - The desired height of the window.\n     */\n    SetSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the title of the window.\n     *\n     * @param title - The desired title of the window.\n     */\n    SetTitle(title: string): Promise<void> {\n        return this[callerSym](SetTitleMethod, { title });\n    }\n\n    /**\n     * Sets the zoom level of the window.\n     *\n     * @param zoom - The desired zoom level.\n     */\n    SetZoom(zoom: number): Promise<void> {\n        return this[callerSym](SetZoomMethod, { zoom });\n    }\n\n    /**\n     * Shows the window.\n     */\n    Show(): Promise<void> {\n        return this[callerSym](ShowMethod);\n    }\n\n    /**\n     * Returns the size of the window.\n     *\n     * @returns The current size of the window.\n     */\n    Size(): Promise<Size> {\n        return this[callerSym](SizeMethod);\n    }\n\n    /**\n     * Toggles the window between fullscreen and normal.\n     */\n    ToggleFullscreen(): Promise<void> {\n        return this[callerSym](ToggleFullscreenMethod);\n    }\n\n    /**\n     * Toggles the window between maximised and normal.\n     */\n    ToggleMaximise(): Promise<void> {\n        return this[callerSym](ToggleMaximiseMethod);\n    }\n\n    /**\n     * Toggles the window between frameless and normal.\n     */\n    ToggleFrameless(): Promise<void> {\n        return this[callerSym](ToggleFramelessMethod);\n    }\n\n    /**\n     * Un-fullscreens the window.\n     */\n    UnFullscreen(): Promise<void> {\n        return this[callerSym](UnFullscreenMethod);\n    }\n\n    /**\n     * Un-maximises the window.\n     */\n    UnMaximise(): Promise<void> {\n        return this[callerSym](UnMaximiseMethod);\n    }\n\n    /**\n     * Un-minimises the window.\n     */\n    UnMinimise(): Promise<void> {\n        return this[callerSym](UnMinimiseMethod);\n    }\n\n    /**\n     * Returns the width of the window.\n     *\n     * @returns The current width of the window.\n     */\n    Width(): Promise<number> {\n        return this[callerSym](WidthMethod);\n    }\n\n    /**\n     * Zooms the window.\n     */\n    Zoom(): Promise<void> {\n        return this[callerSym](ZoomMethod);\n    }\n\n    /**\n     * Increases the zoom level of the webview content.\n     */\n    ZoomIn(): Promise<void> {\n        return this[callerSym](ZoomInMethod);\n    }\n\n    /**\n     * Decreases the zoom level of the webview content.\n     */\n    ZoomOut(): Promise<void> {\n        return this[callerSym](ZoomOutMethod);\n    }\n\n    /**\n     * Resets the zoom level of the webview content.\n     */\n    ZoomReset(): Promise<void> {\n        return this[callerSym](ZoomResetMethod);\n    }\n\n    /**\n     * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).\n     * Gathers information about the drop target element and sends it back to the Go backend.\n     *\n     * @param filenames - An array of file paths (strings) that were dropped.\n     * @param x - The x-coordinate of the drop event.\n     * @param y - The y-coordinate of the drop event.\n     */\n    HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\n        const element = document.elementFromPoint(x, y);\n\n        // NEW: Check if the drop target is a valid dropzone\n        const dropzoneTarget = getDropzoneElement(element);\n\n        if (!dropzoneTarget) {\n            console.log(`Wails Runtime: Drop on element (or no element) at ${x},${y} which is not a designated dropzone. Ignoring. Element:`, element);\n            // No need to call backend if not a valid dropzone target\n            return;\n        }\n\n        console.log(`Wails Runtime: Drop on designated dropzone. Element at (${x}, ${y}):`, element, 'Effective dropzone:', dropzoneTarget);\n        const elementDetails = {\n            id: dropzoneTarget.id,\n            classList: Array.from(dropzoneTarget.classList),\n            attributes: {} as { [key: string]: string },\n        };\n        for (let i = 0; i < dropzoneTarget.attributes.length; i++) {\n            const attr = dropzoneTarget.attributes[i];\n            elementDetails.attributes[attr.name] = attr.value;\n        }\n\n        const payload = {\n            filenames,\n            x,\n            y,\n            elementDetails,\n        };\n\n        this[callerSym](WindowDropZoneDropped, payload);\n    }\n  \n    /* Triggers Windows 11 Snap Assist feature (Windows only).\n     * This is equivalent to pressing Win+Z and shows snap layout options.\n     */\n    SnapAssist(): Promise<void> {\n        return this[callerSym](SnapAssistMethod);\n    }\n\n    /**\n     * Opens the print dialog for the window.\n     */\n    Print(): Promise<void> {\n        return this[callerSym](PrintMethod);\n    }\n}\n\n/**\n * The window within which the script is running.\n */\nconst thisWindow = new Window('');\n\n// NEW: Global Drag Event Listeners\nfunction setupGlobalDropzoneListeners() {\n    const docElement = document.documentElement;\n    let dragEnterCounter = 0; // To handle dragenter/dragleave on child elements\n\n    docElement.addEventListener('dragenter', (event) => {\n        event.preventDefault();\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\n            dragEnterCounter++;\n            const targetElement = document.elementFromPoint(event.clientX, event.clientY);\n            const dropzone = getDropzoneElement(targetElement);\n\n            // Clear previous hover regardless, then apply new if valid\n            if (currentHoveredDropzone && currentHoveredDropzone !== dropzone) {\n                currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\n            }\n\n            if (dropzone) {\n                dropzone.classList.add(DROPZONE_HOVER_CLASS);\n                event.dataTransfer.dropEffect = 'copy';\n                currentHoveredDropzone = dropzone;\n            } else {\n                event.dataTransfer.dropEffect = 'none';\n                currentHoveredDropzone = null; // Ensure it's cleared if no dropzone found\n            }\n        }\n    }, false);\n\n    docElement.addEventListener('dragover', (event) => {\n        event.preventDefault(); // Necessary to allow drop\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\n            // No need to query elementFromPoint again if already handled by dragenter correctly\n            // Just ensure dropEffect is continuously set based on currentHoveredDropzone\n            if (currentHoveredDropzone) {\n                 // Re-apply class just in case it was removed by some other JS\n                if(!currentHoveredDropzone.classList.contains(DROPZONE_HOVER_CLASS)) {\n                    currentHoveredDropzone.classList.add(DROPZONE_HOVER_CLASS);\n                }\n                event.dataTransfer.dropEffect = 'copy';\n            } else {\n                event.dataTransfer.dropEffect = 'none';\n            }\n        }\n    }, false);\n\n    docElement.addEventListener('dragleave', (event) => {\n        event.preventDefault();\n        if (event.dataTransfer && event.dataTransfer.types.includes('Files')) {\n            dragEnterCounter--;\n            // Only remove hover if drag truly left the window or the last dropzone\n            if (dragEnterCounter === 0 || event.relatedTarget === null || (currentHoveredDropzone && !currentHoveredDropzone.contains(event.relatedTarget as Node))) {\n                if (currentHoveredDropzone) {\n                    currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\n                    currentHoveredDropzone = null;\n                }\n                dragEnterCounter = 0; // Reset counter if it went negative or left window\n            }\n        }\n    }, false);\n\n    docElement.addEventListener('drop', (event) => {\n        event.preventDefault(); // Prevent default browser file handling\n        dragEnterCounter = 0; // Reset counter\n        if (currentHoveredDropzone) {\n            currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS);\n            currentHoveredDropzone = null;\n        }\n        // The actual drop processing is initiated by the native side calling HandlePlatformFileDrop\n        // HandlePlatformFileDrop will then check if the drop was on a valid zone.\n    }, false);\n}\n\n// Initialize listeners when the script loads\nif (typeof window !== \"undefined\" && typeof document !== \"undefined\") {\n    setupGlobalDropzoneListeners();\n}\n\nexport default thisWindow;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport * as Runtime from \"../@wailsio/runtime/src\";\n\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\nimport { Enable as EnableWML } from \"../@wailsio/runtime/src/wml\";\nimport { debugLog } from \"../@wailsio/runtime/src/utils\";\n\nwindow.wails = Runtime;\nEnableWML();\n\nif (DEBUG) {\n    debugLog(\"Wails Runtime Loaded\")\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.System);\n\nconst SystemIsDarkMode = 0;\nconst SystemEnvironment = 1;\nconst SystemCapabilities = 2;\nconst ApplicationFilesDroppedWithContext = 100; // New method ID for enriched drop event\n\nconst _invoke = (function () {\n    try {\n        // Windows WebView2\n        if ((window as any).chrome?.webview?.postMessage) {\n            return (window as any).chrome.webview.postMessage.bind((window as any).chrome.webview);\n        }\n        // macOS/iOS WKWebView\n        else if ((window as any).webkit?.messageHandlers?.['external']?.postMessage) {\n            return (window as any).webkit.messageHandlers['external'].postMessage.bind((window as any).webkit.messageHandlers['external']);\n        }\n        // Android WebView - uses addJavascriptInterface which exposes window.wails.invoke\n        else if ((window as any).wails?.invoke) {\n            return (msg: any) => (window as any).wails.invoke(typeof msg === 'string' ? msg : JSON.stringify(msg));\n        }\n    } catch(e) {}\n\n    console.warn('\\n%c\u26A0\uFE0F Browser Environment Detected %c\\n\\n%cOnly UI previews are available in the browser. For full functionality, please run the application in desktop mode.\\nMore information at: https://v3.wails.io/learn/build/#using-a-browser-for-development\\n',\n        'background: #ffffff; color: #000000; font-weight: bold; padding: 4px 8px; border-radius: 4px; border: 2px solid #000000;',\n        'background: transparent;',\n        'color: #ffffff; font-style: italic; font-weight: bold;');\n    return null;\n})();\n\nexport function invoke(msg: any): void {\n    _invoke?.(msg);\n}\n\n/**\n * Retrieves the system dark mode status.\n *\n * @returns A promise that resolves to a boolean value indicating if the system is in dark mode.\n */\nexport function IsDarkMode(): Promise<boolean> {\n    return call(SystemIsDarkMode);\n}\n\n/**\n * Fetches the capabilities of the application from the server.\n *\n * @returns A promise that resolves to an object containing the capabilities.\n */\nexport async function Capabilities(): Promise<Record<string, any>> {\n    return call(SystemCapabilities);\n}\n\nexport interface OSInfo {\n    /** The branding of the OS. */\n    Branding: string;\n    /** The ID of the OS. */\n    ID: string;\n    /** The name of the OS. */\n    Name: string;\n    /** The version of the OS. */\n    Version: string;\n}\n\nexport interface EnvironmentInfo {\n    /** The architecture of the system. */\n    Arch: string;\n    /** True if the application is running in debug mode, otherwise false. */\n    Debug: boolean;\n    /** The operating system in use. */\n    OS: string;\n    /** Details of the operating system. */\n    OSInfo: OSInfo;\n    /** Additional platform information. */\n    PlatformInfo: Record<string, any>;\n}\n\n/**\n * Retrieves environment details.\n *\n * @returns A promise that resolves to an object containing OS and system architecture.\n */\nexport function Environment(): Promise<EnvironmentInfo> {\n    return call(SystemEnvironment);\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @return True if the operating system is Windows, otherwise false.\n */\nexport function IsWindows(): boolean {\n    return (window as any)._wails?.environment?.OS === \"windows\";\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns Returns true if the current operating system is Linux, false otherwise.\n */\nexport function IsLinux(): boolean {\n    return (window as any)._wails?.environment?.OS === \"linux\";\n}\n\n/**\n * Checks if the current environment is a macOS operating system.\n *\n * @returns True if the environment is macOS, false otherwise.\n */\nexport function IsMac(): boolean {\n    return (window as any)._wails?.environment?.OS === \"darwin\";\n}\n\n/**\n * Checks if the current environment architecture is AMD64.\n *\n * @returns True if the current environment architecture is AMD64, false otherwise.\n */\nexport function IsAMD64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"amd64\";\n}\n\n/**\n * Checks if the current architecture is ARM.\n *\n * @returns True if the current architecture is ARM, false otherwise.\n */\nexport function IsARM(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm\";\n}\n\n/**\n * Checks if the current environment is ARM64 architecture.\n *\n * @returns Returns true if the environment is ARM64 architecture, otherwise returns false.\n */\nexport function IsARM64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm64\";\n}\n\n/**\n * Reports whether the app is being run in debug mode.\n *\n * @returns True if the app is being run in debug mode.\n */\nexport function IsDebug(): boolean {\n    return Boolean((window as any)._wails?.environment?.Debug);\n}\n\n/**\n * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop).\n * Gathers information about the drop target element and sends it back to the Go backend.\n *\n * @param filenames - An array of file paths (strings) that were dropped.\n * @param x - The x-coordinate of the drop event.\n * @param y - The y-coordinate of the drop event.\n */\nexport function HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\n    const element = document.elementFromPoint(x, y);\n    const elementId = element ? element.id : '';\n    const classList = element ? Array.from(element.classList) : [];\n\n    const payload = {\n        filenames,\n        x,\n        y,\n        elementId,\n        classList,\n    };\n\n    call(ApplicationFilesDroppedWithContext, payload)\n        .then(() => {\n            // Optional: Log success or handle if needed\n            console.log(\"Platform file drop processed and sent to Go.\");\n        })\n        .catch(err => {\n            // Optional: Log error\n            console.error(\"Error sending platform file drop to Go:\", err);\n        });\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { IsDebug } from \"./system.js\";\nimport { eventTarget } from \"./utils.js\";\n\n// setup\nwindow.addEventListener('contextmenu', contextMenuHandler);\n\nconst call = newRuntimeCaller(objectNames.ContextMenu);\n\nconst ContextMenuOpen = 0;\n\nfunction openContextMenu(id: string, x: number, y: number, data: any): void {\n    void call(ContextMenuOpen, {id, x, y, data});\n}\n\nfunction contextMenuHandler(event: MouseEvent) {\n    const target = eventTarget(event);\n\n    // Check for custom context menu\n    const customContextMenu = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu\").trim();\n\n    if (customContextMenu) {\n        event.preventDefault();\n        const data = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu-data\");\n        openContextMenu(customContextMenu, event.clientX, event.clientY, data);\n    } else {\n        processDefaultContextMenu(event, target);\n    }\n}\n\n\n/*\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\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nfunction processDefaultContextMenu(event: MouseEvent, target: HTMLElement) {\n    // Debug builds always show the menu\n    if (IsDebug()) {\n        return;\n    }\n\n    // Process default context menu\n    switch (window.getComputedStyle(target).getPropertyValue(\"--default-contextmenu\").trim()) {\n        case 'show':\n            return;\n        case 'hide':\n            event.preventDefault();\n            return;\n    }\n\n    // Check if contentEditable is true\n    if (target.isContentEditable) {\n        return;\n    }\n\n    // Check if text has been selected\n    const selection = window.getSelection();\n    const hasSelection = selection && selection.toString().length > 0;\n    if (hasSelection) {\n        for (let i = 0; i < selection.rangeCount; i++) {\n            const range = selection.getRangeAt(i);\n            const rects = range.getClientRects();\n            for (let j = 0; j < rects.length; j++) {\n                const rect = rects[j];\n                if (document.elementFromPoint(rect.left, rect.top) === target) {\n                    return;\n                }\n            }\n        }\n    }\n\n    // Check if tag is input or textarea.\n    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {\n        if (hasSelection || (!target.readOnly && !target.disabled)) {\n            return;\n        }\n    }\n\n    // hide default context menu\n    event.preventDefault();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Retrieves the value associated with the specified key from the flag map.\n *\n * @param key - The key to retrieve the value for.\n * @return The value associated with the specified key.\n */\nexport function GetFlag(key: string): any {\n    try {\n        return window._wails.flags[key];\n    } catch (e) {\n        throw new Error(\"Unable to retrieve flag '\" + key + \"': \" + e, { cause: e });\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { invoke, IsWindows } from \"./system.js\";\nimport { GetFlag } from \"./flags.js\";\nimport { canTrackButtons, eventTarget } from \"./utils.js\";\n\n// Setup\nlet canDrag = false;\nlet dragging = false;\n\nlet resizable = false;\nlet canResize = false;\nlet resizing = false;\nlet resizeEdge: string = \"\";\nlet defaultCursor = \"auto\";\n\nlet buttons = 0;\nconst buttonsTracked = canTrackButtons();\n\nwindow._wails = window._wails || {};\nwindow._wails.setResizable = (value: boolean): void => {\n    resizable = value;\n    if (!resizable) {\n        // Stop resizing if in progress.\n        canResize = resizing = false;\n        setResize();\n    }\n};\n\n// Defer attaching mouse listeners until we know we're not on mobile.\nlet dragInitDone = false;\nfunction isMobile(): boolean {\n    const os = (window as any)._wails?.environment?.OS;\n    if (os === \"ios\" || os === \"android\") return true;\n    // Fallback heuristic if environment not yet set\n    const ua = navigator.userAgent || navigator.vendor || (window as any).opera || \"\";\n    return /android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(ua);\n}\nfunction tryInitDragHandlers(): void {\n    if (dragInitDone) return;\n    if (isMobile()) return;\n    window.addEventListener('mousedown', update, { capture: true });\n    window.addEventListener('mousemove', update, { capture: true });\n    window.addEventListener('mouseup', update, { capture: true });\n    for (const ev of ['click', 'contextmenu', 'dblclick']) {\n        window.addEventListener(ev, suppressEvent, { capture: true });\n    }\n    dragInitDone = true;\n}\n// Attempt immediate init (in case environment already present)\ntryInitDragHandlers();\n// Also attempt on DOM ready\ndocument.addEventListener('DOMContentLoaded', tryInitDragHandlers, { once: true });\n// As a last resort, poll for environment for a short period\nlet dragEnvPolls = 0;\nconst dragEnvPoll = window.setInterval(() => {\n    if (dragInitDone) { window.clearInterval(dragEnvPoll); return; }\n    tryInitDragHandlers();\n    if (++dragEnvPolls > 100) { window.clearInterval(dragEnvPoll); }\n}, 50);\n\nfunction suppressEvent(event: Event) {\n    // Suppress click events while resizing or dragging.\n    if (dragging || resizing) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n}\n\n// Use constants to avoid comparing strings multiple times.\nconst MouseDown = 0;\nconst MouseUp   = 1;\nconst MouseMove = 2;\n\nfunction update(event: MouseEvent) {\n    // Windows suppresses mouse events at the end of dragging or resizing,\n    // so we need to be smart and synthesize button events.\n\n    let eventType: number, eventButtons = event.buttons;\n    switch (event.type) {\n        case 'mousedown':\n            eventType = MouseDown;\n            if (!buttonsTracked) { eventButtons = buttons | (1 << event.button); }\n            break;\n        case 'mouseup':\n            eventType = MouseUp;\n            if (!buttonsTracked) { eventButtons = buttons & ~(1 << event.button); }\n            break;\n        default:\n            eventType = MouseMove;\n            if (!buttonsTracked) { eventButtons = buttons; }\n            break;\n    }\n\n    let released = buttons & ~eventButtons;\n    let pressed = eventButtons & ~buttons;\n\n    buttons = eventButtons;\n\n    // Synthesize a release-press sequence if we detect a press of an already pressed button.\n    if (eventType === MouseDown && !(pressed & event.button)) {\n        released |= (1 << event.button);\n        pressed |= (1 << event.button);\n    }\n\n    // Suppress all button events during dragging and resizing,\n    // unless this is a mouseup event that is ending a drag action.\n    if (\n        eventType !== MouseMove // Fast path for mousemove\n        && resizing\n        || (\n            dragging\n            && (\n                eventType === MouseDown\n                || event.button !== 0\n            )\n        )\n    ) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n\n    // Handle releases\n    if (released & 1) { primaryUp(event); }\n    // Handle presses\n    if (pressed & 1) { primaryDown(event); }\n\n    // Handle mousemove\n    if (eventType === MouseMove) { onMouseMove(event); };\n}\n\nfunction primaryDown(event: MouseEvent): void {\n    // Reset readiness state.\n    canDrag = false;\n    canResize = false;\n\n    // Ignore repeated clicks on macOS and Linux.\n    if (!IsWindows()) {\n        if (event.type === 'mousedown' && event.button === 0 && event.detail !== 1) {\n            return;\n        }\n    }\n\n    if (resizeEdge) {\n        // Ready to resize if the primary button was pressed for the first time.\n        canResize = true;\n        // Do not start drag operations when on resize edges.\n        return;\n    }\n\n    // Retrieve target element\n    const target = eventTarget(event);\n\n    // Ready to drag if the primary button was pressed for the first time on a draggable element.\n    // Ignore clicks on the scrollbar.\n    const style = window.getComputedStyle(target);\n    canDrag = (\n        style.getPropertyValue(\"--wails-draggable\").trim() === \"drag\"\n        && (\n            event.offsetX - parseFloat(style.paddingLeft) < target.clientWidth\n            && event.offsetY - parseFloat(style.paddingTop) < target.clientHeight\n        )\n    );\n}\n\nfunction primaryUp(event: MouseEvent) {\n    // Stop dragging and resizing.\n    canDrag = false;\n    dragging = false;\n    canResize = false;\n    resizing = false;\n}\n\nconst cursorForEdge = Object.freeze({\n    \"se-resize\": \"nwse-resize\",\n    \"sw-resize\": \"nesw-resize\",\n    \"nw-resize\": \"nwse-resize\",\n    \"ne-resize\": \"nesw-resize\",\n    \"w-resize\": \"ew-resize\",\n    \"n-resize\": \"ns-resize\",\n    \"s-resize\": \"ns-resize\",\n    \"e-resize\": \"ew-resize\",\n})\n\nfunction setResize(edge?: keyof typeof cursorForEdge): void {\n    if (edge) {\n        if (!resizeEdge) { defaultCursor = document.body.style.cursor; }\n        document.body.style.cursor = cursorForEdge[edge];\n    } else if (!edge && resizeEdge) {\n        document.body.style.cursor = defaultCursor;\n    }\n\n    resizeEdge = edge || \"\";\n}\n\nfunction onMouseMove(event: MouseEvent): void {\n    if (canResize && resizeEdge) {\n        // Start resizing.\n        resizing = true;\n        invoke(\"wails:resize:\" + resizeEdge);\n    } else if (canDrag) {\n        // Start dragging.\n        dragging = true;\n        invoke(\"wails:drag\");\n    }\n\n    if (dragging || resizing) {\n        // Either drag or resize is ongoing,\n        // reset readiness and stop processing.\n        canDrag = canResize = false;\n        return;\n    }\n\n    if (!resizable || !IsWindows()) {\n        if (resizeEdge) { setResize(); }\n        return;\n    }\n\n    const resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\n    const resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\n\n    // Extra pixels for the corner areas.\n    const cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\n\n    const rightBorder = (window.outerWidth - event.clientX) < resizeHandleWidth;\n    const leftBorder = event.clientX < resizeHandleWidth;\n    const topBorder = event.clientY < resizeHandleHeight;\n    const bottomBorder = (window.outerHeight - event.clientY) < resizeHandleHeight;\n\n    // Adjust for corner areas.\n    const rightCorner = (window.outerWidth - event.clientX) < (resizeHandleWidth + cornerExtra);\n    const leftCorner = event.clientX < (resizeHandleWidth + cornerExtra);\n    const topCorner = event.clientY < (resizeHandleHeight + cornerExtra);\n    const bottomCorner = (window.outerHeight - event.clientY) < (resizeHandleHeight + cornerExtra);\n\n    if (!leftCorner && !topCorner && !bottomCorner && !rightCorner) {\n        // Optimisation: out of all corner areas implies out of borders.\n        setResize();\n    }\n    // Detect corners.\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\n    // Detect borders.\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n    // Out of border area.\n    else setResize();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Application);\n\nconst HideMethod = 0;\nconst ShowMethod = 1;\nconst QuitMethod = 2;\n\n/**\n * Hides a certain method by calling the HideMethod function.\n */\nexport function Hide(): Promise<void> {\n    return call(HideMethod);\n}\n\n/**\n * Calls the ShowMethod and returns the result.\n */\nexport function Show(): Promise<void> {\n    return call(ShowMethod);\n}\n\n/**\n * Calls the QuitMethod to terminate the program.\n */\nexport function Quit(): Promise<void> {\n    return call(QuitMethod);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { CancellablePromise, type CancellablePromiseWithResolvers } from \"./cancellable.js\";\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { nanoid } from \"./nanoid.js\";\n\n// Setup\nwindow._wails = window._wails || {};\n\ntype PromiseResolvers = Omit<CancellablePromiseWithResolvers<any>, \"promise\" | \"oncancelled\">\n\nconst call = newRuntimeCaller(objectNames.Call);\nconst cancelCall = newRuntimeCaller(objectNames.CancelCall);\nconst callResponses = new Map<string, PromiseResolvers>();\n\nconst CallBinding = 0;\nconst CancelMethod = 0\n\n/**\n * Holds all required information for a binding call.\n * May provide either a method ID or a method name, but not both.\n */\nexport type CallOptions = {\n    /** The numeric ID of the bound method to call. */\n    methodID: number;\n    /** The fully qualified name of the bound method to call. */\n    methodName?: never;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n} | {\n    /** The numeric ID of the bound method to call. */\n    methodID?: never;\n    /** The fully qualified name of the bound method to call. */\n    methodName: string;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n};\n\n/**\n * Exception class that will be thrown in case the bound method returns an error.\n * The value of the {@link RuntimeError#name} property is \"RuntimeError\".\n */\nexport class RuntimeError extends Error {\n    /**\n     * Constructs a new RuntimeError instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"RuntimeError\";\n    }\n}\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @returns A unique ID that does not exist in the callResponses set.\n */\nfunction generateID(): string {\n    let result;\n    do {\n        result = nanoid();\n    } while (callResponses.has(result));\n    return result;\n}\n\n/**\n * Call a bound method according to the given call options.\n *\n * In case of failure, the returned promise will reject with an exception\n * among ReferenceError (unknown method), TypeError (wrong argument count or type),\n * {@link RuntimeError} (method returned an error), or other (network or internal errors).\n * The exception might have a \"cause\" field with the value returned\n * by the application- or service-level error marshaling functions.\n *\n * @param options - A method call descriptor.\n * @returns The result of the call.\n */\nexport function Call(options: CallOptions): CancellablePromise<any> {\n    const id = generateID();\n\n    const result = CancellablePromise.withResolvers<any>();\n    callResponses.set(id, { resolve: result.resolve, reject: result.reject });\n\n    const request = call(CallBinding, Object.assign({ \"call-id\": id }, options));\n    let running = true;\n\n    request.then((res) => {\n        running = false;\n        callResponses.delete(id);\n        result.resolve(res);\n    }, (err) => {\n        running = false;\n        callResponses.delete(id);\n        result.reject(err);\n    });\n\n    const cancel = () => {\n        callResponses.delete(id);\n        return cancelCall(CancelMethod, {\"call-id\": id}).catch((err) => {\n            console.error(\"Error while requesting binding call cancellation:\", err);\n        });\n    };\n\n    result.oncancelled = () => {\n        if (running) {\n            return cancel();\n        } else {\n            return request.then(cancel);\n        }\n    };\n\n    return result.promise;\n}\n\n/**\n * Calls a bound method by name with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodName - The name of the method in the format 'package.struct.method'.\n * @param args - The arguments to pass to the method.\n * @returns The result of the method call.\n */\nexport function ByName(methodName: string, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodName, args });\n}\n\n/**\n * Calls a method by its numeric ID with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodID - The ID of the method to call.\n * @param args - The arguments to pass to the method.\n * @return The result of the method call.\n */\nexport function ByID(methodID: number, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodID, args });\n}\n", "// Source: https://github.com/inspect-js/is-callable\n\n// The MIT License (MIT)\n//\n// Copyright (c) 2015 Jordan Harband\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply: typeof Reflect.apply | false | null = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike: any;\nvar isCallableMarker: any;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n    try {\n        badArrayLike = Object.defineProperty({}, 'length', {\n            get: function () {\n                throw isCallableMarker;\n            }\n        });\n        isCallableMarker = {};\n        // eslint-disable-next-line no-throw-literal\n        reflectApply(function () { throw 42; }, null, badArrayLike);\n    } catch (_) {\n        if (_ !== isCallableMarker) {\n            reflectApply = null;\n        }\n    }\n} else {\n    reflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value: any): boolean {\n    try {\n        var fnStr = fnToStr.call(value);\n        return constructorRegex.test(fnStr);\n    } catch (e) {\n        return false; // not a function\n    }\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value: any): boolean {\n    try {\n        if (isES6ClassFn(value)) { return false; }\n        fnToStr.call(value);\n        return true;\n    } catch (e) {\n        return false;\n    }\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA: (value: any) => boolean = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n    // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n    var all = document.all;\n    if (toStr.call(all) === toStr.call(document.all)) {\n        isDDA = function isDocumentDotAll(value) {\n            /* globals document: false */\n            // in IE 6-8, typeof document.all is \"object\" and it's truthy\n            if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n                try {\n                    var str = toStr.call(value);\n                    return (\n                        str === ddaClass\n                        || str === ddaClass2\n                        || str === ddaClass3 // opera 12.16\n                        || str === objectClass // IE 6-8\n                    ) && value('') == null; // eslint-disable-line eqeqeq\n                } catch (e) { /**/ }\n            }\n            return false;\n        };\n    }\n}\n\nfunction isCallableRefApply<T>(value: T | unknown): value is (...args: any[]) => any  {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    try {\n        (reflectApply as any)(value, null, badArrayLike);\n    } catch (e) {\n        if (e !== isCallableMarker) { return false; }\n    }\n    return !isES6ClassFn(value) && tryFunctionObject(value);\n}\n\nfunction isCallableNoRefApply<T>(value: T | unknown): value is (...args: any[]) => any {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    if (hasToStringTag) { return tryFunctionObject(value); }\n    if (isES6ClassFn(value)) { return false; }\n    var strClass = toStr.call(value);\n    if (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n    return tryFunctionObject(value);\n};\n\nexport default reflectApply ? isCallableRefApply : isCallableNoRefApply;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport isCallable from \"./callable.js\";\n\n/**\n * Exception class that will be used as rejection reason\n * in case a {@link CancellablePromise} is cancelled successfully.\n *\n * The value of the {@link name} property is the string `\"CancelError\"`.\n * The value of the {@link cause} property is the cause passed to the cancel method, if any.\n */\nexport class CancelError extends Error {\n    /**\n     * Constructs a new `CancelError` instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CancelError\";\n    }\n}\n\n/**\n * Exception class that will be reported as an unhandled rejection\n * in case a {@link CancellablePromise} rejects after being cancelled,\n * or when the `oncancelled` callback throws or rejects.\n *\n * The value of the {@link name} property is the string `\"CancelledRejectionError\"`.\n * The value of the {@link cause} property is the reason the promise rejected with.\n *\n * Because the original promise was cancelled,\n * a wrapper promise will be passed to the unhandled rejection listener instead.\n * The {@link promise} property holds a reference to the original promise.\n */\nexport class CancelledRejectionError extends Error {\n    /**\n     * Holds a reference to the promise that was cancelled and then rejected.\n     */\n    promise: CancellablePromise<unknown>;\n\n    /**\n     * Constructs a new `CancelledRejectionError` instance.\n     * @param promise - The promise that caused the error originally.\n     * @param reason - The rejection reason.\n     * @param info - An optional informative message specifying the circumstances in which the error was thrown.\n     *               Defaults to the string `\"Unhandled rejection in cancelled promise.\"`.\n     */\n    constructor(promise: CancellablePromise<unknown>, reason?: any, info?: string) {\n        super((info ?? \"Unhandled rejection in cancelled promise.\") + \" Reason: \" + errorMessage(reason), { cause: reason });\n        this.promise = promise;\n        this.name = \"CancelledRejectionError\";\n    }\n}\n\ntype CancellablePromiseResolver<T> = (value: T | PromiseLike<T> | CancellablePromiseLike<T>) => void;\ntype CancellablePromiseRejector = (reason?: any) => void;\ntype CancellablePromiseCanceller = (cause?: any) => void | PromiseLike<void>;\ntype CancellablePromiseExecutor<T> = (resolve: CancellablePromiseResolver<T>, reject: CancellablePromiseRejector) => void;\n\nexport interface CancellablePromiseLike<T> {\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null): CancellablePromiseLike<TResult1 | TResult2>;\n    cancel(cause?: any): void | PromiseLike<void>;\n}\n\n/**\n * Wraps a cancellable promise along with its resolution methods.\n * The `oncancelled` field will be null initially but may be set to provide a custom cancellation function.\n */\nexport interface CancellablePromiseWithResolvers<T> {\n    promise: CancellablePromise<T>;\n    resolve: CancellablePromiseResolver<T>;\n    reject: CancellablePromiseRejector;\n    oncancelled: CancellablePromiseCanceller | null;\n}\n\ninterface CancellablePromiseState {\n    readonly root: CancellablePromiseState;\n    resolving: boolean;\n    settled: boolean;\n    reason?: CancelError;\n}\n\n// Private field names.\nconst barrierSym = Symbol(\"barrier\");\nconst cancelImplSym = Symbol(\"cancelImpl\");\nconst species: typeof Symbol.species = Symbol.species ?? Symbol(\"speciesPolyfill\");\n\n/**\n * A promise with an attached method for cancelling long-running operations (see {@link CancellablePromise#cancel}).\n * Cancellation can optionally be bound to an {@link AbortSignal}\n * for better composability (see {@link CancellablePromise#cancelOn}).\n *\n * Cancelling a pending promise will result in an immediate rejection\n * with an instance of {@link CancelError} as reason,\n * but whoever started the promise will be responsible\n * for actually aborting the underlying operation.\n * To this purpose, the constructor and all chaining methods\n * accept optional cancellation callbacks.\n *\n * If a `CancellablePromise` still resolves after having been cancelled,\n * the result will be discarded. If it rejects, the reason\n * will be reported as an unhandled rejection,\n * wrapped in a {@link CancelledRejectionError} instance.\n * To facilitate the handling of cancellation requests,\n * cancelled `CancellablePromise`s will _not_ report unhandled `CancelError`s\n * whose `cause` field is the same as the one with which the current promise was cancelled.\n *\n * All usual promise methods are defined and return a `CancellablePromise`\n * whose cancel method will cancel the parent operation as well, propagating the cancellation reason\n * upwards through promise chains.\n * Conversely, cancelling a promise will not automatically cancel dependent promises downstream:\n * ```ts\n * let root = new CancellablePromise((resolve, reject) => { ... });\n * let child1 = root.then(() => { ... });\n * let child2 = child1.then(() => { ... });\n * let child3 = root.catch(() => { ... });\n * child1.cancel(); // Cancels child1 and root, but not child2 or child3\n * ```\n * Cancelling a promise that has already settled is safe and has no consequence.\n *\n * The `cancel` method returns a promise that _always fulfills_\n * after the whole chain has processed the cancel request\n * and all attached callbacks up to that moment have run.\n *\n * All ES2024 promise methods (static and instance) are defined on CancellablePromise,\n * but actual availability may vary with OS/webview version.\n *\n * In line with the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing,\n * `CancellablePromise` does not support transparent subclassing.\n * Extenders should take care to provide their own method implementations.\n * This might be reconsidered in case the proposal is retired.\n *\n * CancellablePromise is a wrapper around the DOM Promise object\n * and is compliant with the [Promises/A+ specification](https://promisesaplus.com/)\n * (it passes the [compliance suite](https://github.com/promises-aplus/promises-tests))\n * if so is the underlying implementation.\n */\nexport class CancellablePromise<T> extends Promise<T> implements PromiseLike<T>, CancellablePromiseLike<T> {\n    // Private fields.\n    /** @internal */\n    private [barrierSym]!: Partial<PromiseWithResolvers<void>> | null;\n    /** @internal */\n    private readonly [cancelImplSym]!: (reason: CancelError) => void | PromiseLike<void>;\n\n    /**\n     * Creates a new `CancellablePromise`.\n     *\n     * @param executor - A callback used to initialize the promise. This callback is passed two arguments:\n     *                   a `resolve` callback used to resolve the promise with a value\n     *                   or the result of another promise (possibly cancellable),\n     *                   and a `reject` callback used to reject the promise with a provided reason or error.\n     *                   If the value provided to the `resolve` callback is a thenable _and_ cancellable object\n     *                   (it has a `then` _and_ a `cancel` method),\n     *                   cancellation requests will be forwarded to that object and the oncancelled will not be invoked anymore.\n     *                   If any one of the two callbacks is called _after_ the promise has been cancelled,\n     *                   the provided values will be cancelled and resolved as usual,\n     *                   but their results will be discarded.\n     *                   However, if the resolution process ultimately ends up in a rejection\n     *                   that is not due to cancellation, the rejection reason\n     *                   will be wrapped in a {@link CancelledRejectionError}\n     *                   and bubbled up as an unhandled rejection.\n     * @param oncancelled - It is the caller's responsibility to ensure that any operation\n     *                      started by the executor is properly halted upon cancellation.\n     *                      This optional callback can be used to that purpose.\n     *                      It will be called _synchronously_ with a cancellation cause\n     *                      when cancellation is requested, _after_ the promise has already rejected\n     *                      with a {@link CancelError}, but _before_\n     *                      any {@link then}/{@link catch}/{@link finally} callback runs.\n     *                      If the callback returns a thenable, the promise returned from {@link cancel}\n     *                      will only fulfill after the former has settled.\n     *                      Unhandled exceptions or rejections from the callback will be wrapped\n     *                      in a {@link CancelledRejectionError} and bubbled up as unhandled rejections.\n     *                      If the `resolve` callback is called before cancellation with a cancellable promise,\n     *                      cancellation requests on this promise will be diverted to that promise,\n     *                      and the original `oncancelled` callback will be discarded.\n     */\n    constructor(executor: CancellablePromiseExecutor<T>, oncancelled?: CancellablePromiseCanceller) {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        super((res, rej) => { resolve = res; reject = rej; });\n\n        if ((this.constructor as any)[species] !== Promise) {\n            throw new TypeError(\"CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.\");\n        }\n\n        let promise: CancellablePromiseWithResolvers<T> = {\n            promise: this,\n            resolve,\n            reject,\n            get oncancelled() { return oncancelled ?? null; },\n            set oncancelled(cb) { oncancelled = cb ?? undefined; }\n        };\n\n        const state: CancellablePromiseState = {\n            get root() { return state; },\n            resolving: false,\n            settled: false\n        };\n\n        // Setup cancellation system.\n        void Object.defineProperties(this, {\n            [barrierSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: true,\n                value: null\n            },\n            [cancelImplSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: false,\n                value: cancellerFor(promise, state)\n            }\n        });\n\n        // Run the actual executor.\n        const rejector = rejectorFor(promise, state);\n        try {\n            executor(resolverFor(promise, state), rejector);\n        } catch (err) {\n            if (state.resolving) {\n                console.log(\"Unhandled exception in CancellablePromise executor.\", err);\n            } else {\n                rejector(err);\n            }\n        }\n    }\n\n    /**\n     * Cancels immediately the execution of the operation associated with this promise.\n     * The promise rejects with a {@link CancelError} instance as reason,\n     * with the {@link CancelError#cause} property set to the given argument, if any.\n     *\n     * Has no effect if called after the promise has already settled;\n     * repeated calls in particular are safe, but only the first one\n     * will set the cancellation cause.\n     *\n     * The `CancelError` exception _need not_ be handled explicitly _on the promises that are being cancelled:_\n     * cancelling a promise with no attached rejection handler does not trigger an unhandled rejection event.\n     * Therefore, the following idioms are all equally correct:\n     * ```ts\n     * new CancellablePromise((resolve, reject) => { ... }).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).catch(...).cancel();\n     * ```\n     * Whenever some cancelled promise in a chain rejects with a `CancelError`\n     * with the same cancellation cause as itself, the error will be discarded silently.\n     * However, the `CancelError` _will still be delivered_ to all attached rejection handlers\n     * added by {@link then} and related methods:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * cancellable.then(() => { ... }).catch(console.log);\n     * cancellable.cancel(); // A CancelError is printed to the console.\n     * ```\n     * If the `CancelError` is not handled downstream by the time it reaches\n     * a _non-cancelled_ promise, it _will_ trigger an unhandled rejection event,\n     * just like normal rejections would:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * let chained = cancellable.then(() => { ... }).then(() => { ... }); // No catch...\n     * cancellable.cancel(); // Unhandled rejection event on chained!\n     * ```\n     * Therefore, it is important to either cancel whole promise chains from their tail,\n     * as shown in the correct idioms above, or take care of handling errors everywhere.\n     *\n     * @returns A cancellable promise that _fulfills_ after the cancel callback (if any)\n     * and all handlers attached up to the call to cancel have run.\n     * If the cancel callback returns a thenable, the promise returned by `cancel`\n     * will also wait for that thenable to settle.\n     * This enables callers to wait for the cancelled operation to terminate\n     * without being forced to handle potential errors at the call site.\n     * ```ts\n     * cancellable.cancel().then(() => {\n     *     // Cleanup finished, it's safe to do something else.\n     * }, (err) => {\n     *     // Unreachable: the promise returned from cancel will never reject.\n     * });\n     * ```\n     * Note that the returned promise will _not_ handle implicitly any rejection\n     * that might have occurred already in the cancelled chain.\n     * It will just track whether registered handlers have been executed or not.\n     * Therefore, unhandled rejections will never be silently handled by calling cancel.\n     */\n    cancel(cause?: any): CancellablePromise<void> {\n        return new CancellablePromise<void>((resolve) => {\n            // INVARIANT: the result of this[cancelImplSym] and the barrier do not ever reject.\n            // Unfortunately macOS High Sierra does not support Promise.allSettled.\n            Promise.all([\n                this[cancelImplSym](new CancelError(\"Promise cancelled.\", { cause })),\n                currentBarrier(this)\n            ]).then(() => resolve(), () => resolve());\n        });\n    }\n\n    /**\n     * Binds promise cancellation to the abort event of the given {@link AbortSignal}.\n     * If the signal has already aborted, the promise will be cancelled immediately.\n     * When either condition is verified, the cancellation cause will be set\n     * to the signal's abort reason (see {@link AbortSignal#reason}).\n     *\n     * Has no effect if called (or if the signal aborts) _after_ the promise has already settled.\n     * Only the first signal to abort will set the cancellation cause.\n     *\n     * For more details about the cancellation process,\n     * see {@link cancel} and the `CancellablePromise` constructor.\n     *\n     * This method enables `await`ing cancellable promises without having\n     * to store them for future cancellation, e.g.:\n     * ```ts\n     * await longRunningOperation().cancelOn(signal);\n     * ```\n     * instead of:\n     * ```ts\n     * let promiseToBeCancelled = longRunningOperation();\n     * await promiseToBeCancelled;\n     * ```\n     *\n     * @returns This promise, for method chaining.\n     */\n    cancelOn(signal: AbortSignal): CancellablePromise<T> {\n        if (signal.aborted) {\n            void this.cancel(signal.reason)\n        } else {\n            signal.addEventListener('abort', () => void this.cancel(signal.reason), {capture: true});\n        }\n\n        return this;\n    }\n\n    /**\n     * Attaches callbacks for the resolution and/or rejection of the `CancellablePromise`.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * @param onfulfilled The callback to execute when the Promise is resolved.\n     * @param onrejected The callback to execute when the Promise is rejected.\n     * @returns A `CancellablePromise` for the completion of whichever callback is executed.\n     * The returned promise is hooked up to propagate cancellation requests up the chain, but not down:\n     *\n     *   - if the parent promise is cancelled, the `onrejected` handler will be invoked with a `CancelError`\n     *     and the returned promise _will resolve regularly_ with its result;\n     *   - conversely, if the returned promise is cancelled, _the parent promise is cancelled too;_\n     *     the `onrejected` handler will still be invoked with the parent's `CancelError`,\n     *     but its result will be discarded\n     *     and the returned promise will reject with a `CancelError` as well.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If either callback returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     */\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<TResult1 | TResult2> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.then called on an invalid object.\");\n        }\n\n        // NOTE: TypeScript's built-in type for then is broken,\n        // as it allows specifying an arbitrary TResult1 != T even when onfulfilled is not a function.\n        // We cannot fix it if we want to CancellablePromise to implement PromiseLike<T>.\n\n        if (!isCallable(onfulfilled)) { onfulfilled = identity as any; }\n        if (!isCallable(onrejected)) { onrejected = thrower; }\n\n        if (onfulfilled === identity && onrejected == thrower) {\n            // Shortcut for trivial arguments.\n            return new CancellablePromise((resolve) => resolve(this as any));\n        }\n\n        const barrier: Partial<PromiseWithResolvers<void>> = {};\n        this[barrierSym] = barrier;\n\n        return new CancellablePromise<TResult1 | TResult2>((resolve, reject) => {\n            void super.then(\n                (value) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onfulfilled!(value));\n                    } catch (err) {\n                        reject(err);\n                    }\n                },\n                (reason?) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onrejected!(reason));\n                    } catch (err) {\n                        reject(err);\n                    }\n                }\n            );\n        }, async (cause?) => {\n            //cancelled = true;\n            try {\n                return oncancelled?.(cause);\n            } finally {\n                await this.cancel(cause);\n            }\n        });\n    }\n\n    /**\n     * Attaches a callback for only the rejection of the Promise.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * It is equivalent to\n     * ```ts\n     * cancellablePromise.then(undefined, onrejected, oncancelled);\n     * ```\n     * and the same caveats apply.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onrejected` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    catch<TResult = never>(onrejected?: ((reason: any) => (PromiseLike<TResult> | TResult)) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T | TResult> {\n        return this.then(undefined, onrejected, oncancelled);\n    }\n\n    /**\n     * Attaches a callback that is invoked when the CancellablePromise is settled (fulfilled or rejected). The\n     * resolved value cannot be accessed or modified from the callback.\n     * The returned promise will settle in the same state as the original one\n     * after the provided callback has completed execution,\n     * unless the callback throws or returns a rejecting promise,\n     * in which case the returned promise will reject as well.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * Once the parent promise settles, the `onfinally` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * This method is implemented in terms of {@link then} and the same caveats apply.\n     * It is polyfilled, hence available in every OS/webview version.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onfinally` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    finally(onfinally?: (() => void) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.finally called on an invalid object.\");\n        }\n\n        if (!isCallable(onfinally)) {\n            return this.then(onfinally, onfinally, oncancelled);\n        }\n\n        return this.then(\n            (value) => CancellablePromise.resolve(onfinally()).then(() => value),\n            (reason?) => CancellablePromise.resolve(onfinally()).then(() => { throw reason; }),\n            oncancelled,\n        );\n    }\n\n    /**\n     * We use the `[Symbol.species]` static property, if available,\n     * to disable the built-in automatic subclassing features from {@link Promise}.\n     * It is critical for performance reasons that extenders do not override this.\n     * Once the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing\n     * is either accepted or retired, this implementation will have to be revised accordingly.\n     *\n     * @ignore\n     * @internal\n     */\n    static get [species]() {\n        return Promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve, or rejected when any Promise is rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static all<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>[]>;\n    static all<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;\n    static all<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.all(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve or reject.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static allSettled<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<PromiseSettledResult<Awaited<T>>[]>;\n    static allSettled<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;\n    static allSettled<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.allSettled(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled,\n     * or rejected with an AggregateError containing an array of rejection reasons\n     * if all of the given promises are rejected.\n     * It resolves all elements of the passed iterable to promises as it runs this algorithm.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static any<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static any<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static any<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.any(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static race<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static race<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static race<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = new CancellablePromise<unknown>((resolve, reject) => {\n            void Promise.race(collected).then(resolve, reject);\n        }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a new cancelled CancellablePromise for the provided cause.\n     *\n     * @group Static Methods\n     */\n    static cancel<T = never>(cause?: any): CancellablePromise<T> {\n        const p = new CancellablePromise<T>(() => {});\n        p.cancel(cause);\n        return p;\n    }\n\n    /**\n     * Creates a new CancellablePromise that cancels\n     * after the specified timeout, with the provided cause.\n     *\n     * If the {@link AbortSignal.timeout} factory method is available,\n     * it is used to base the timeout on _active_ time rather than _elapsed_ time.\n     * Otherwise, `timeout` falls back to {@link setTimeout}.\n     *\n     * @group Static Methods\n     */\n    static timeout<T = never>(milliseconds: number, cause?: any): CancellablePromise<T> {\n        const promise = new CancellablePromise<T>(() => {});\n        if (AbortSignal && typeof AbortSignal === 'function' && AbortSignal.timeout && typeof AbortSignal.timeout === 'function') {\n            AbortSignal.timeout(milliseconds).addEventListener('abort', () => void promise.cancel(cause));\n        } else {\n            setTimeout(() => void promise.cancel(cause), milliseconds);\n        }\n        return promise;\n    }\n\n    /**\n     * Creates a new CancellablePromise that resolves after the specified timeout.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep(milliseconds: number): CancellablePromise<void>;\n    /**\n     * Creates a new CancellablePromise that resolves after\n     * the specified timeout, with the provided value.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep<T>(milliseconds: number, value: T): CancellablePromise<T>;\n    static sleep<T = void>(milliseconds: number, value?: T): CancellablePromise<T> {\n        return new CancellablePromise<T>((resolve) => {\n            setTimeout(() => resolve(value!), milliseconds);\n        });\n    }\n\n    /**\n     * Creates a new rejected CancellablePromise for the provided reason.\n     *\n     * @group Static Methods\n     */\n    static reject<T = never>(reason?: any): CancellablePromise<T> {\n        return new CancellablePromise<T>((_, reject) => reject(reason));\n    }\n\n    /**\n     * Creates a new resolved CancellablePromise.\n     *\n     * @group Static Methods\n     */\n    static resolve(): CancellablePromise<void>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T): CancellablePromise<Awaited<T>>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T | PromiseLike<T>): CancellablePromise<Awaited<T>>;\n    static resolve<T = void>(value?: T | PromiseLike<T>): CancellablePromise<Awaited<T>> {\n        if (value instanceof CancellablePromise) {\n            // Optimise for cancellable promises.\n            return value;\n        }\n        return new CancellablePromise<any>((resolve) => resolve(value));\n    }\n\n    /**\n     * Creates a new CancellablePromise and returns it in an object, along with its resolve and reject functions\n     * and a getter/setter for the cancellation callback.\n     *\n     * This method is polyfilled, hence available in every OS/webview version.\n     *\n     * @group Static Methods\n     */\n    static withResolvers<T>(): CancellablePromiseWithResolvers<T> {\n        let result: CancellablePromiseWithResolvers<T> = { oncancelled: null } as any;\n        result.promise = new CancellablePromise<T>((resolve, reject) => {\n            result.resolve = resolve;\n            result.reject = reject;\n        }, (cause?: any) => { result.oncancelled?.(cause); });\n        return result;\n    }\n}\n\n/**\n * Returns a callback that implements the cancellation algorithm for the given cancellable promise.\n * The promise returned from the resulting function does not reject.\n */\nfunction cancellerFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState) {\n    let cancellationPromise: void | PromiseLike<void> = undefined;\n\n    return (reason: CancelError): void | PromiseLike<void> => {\n        if (!state.settled) {\n            state.settled = true;\n            state.reason = reason;\n            promise.reject(reason);\n\n            // Attach an error handler that ignores this specific rejection reason and nothing else.\n            // In theory, a sane underlying implementation at this point\n            // should always reject with our cancellation reason,\n            // hence the handler will never throw.\n            void Promise.prototype.then.call(promise.promise, undefined, (err) => {\n                if (err !== reason) {\n                    throw err;\n                }\n            });\n        }\n\n        // If reason is not set, the promise resolved regularly, hence we must not call oncancelled.\n        // If oncancelled is unset, no need to go any further.\n        if (!state.reason || !promise.oncancelled) { return; }\n\n        cancellationPromise = new Promise<void>((resolve) => {\n            try {\n                resolve(promise.oncancelled!(state.reason!.cause));\n            } catch (err) {\n                Promise.reject(new CancelledRejectionError(promise.promise, err, \"Unhandled exception in oncancelled callback.\"));\n            }\n        }).catch((reason?) => {\n            Promise.reject(new CancelledRejectionError(promise.promise, reason, \"Unhandled rejection in oncancelled callback.\"));\n        });\n\n        // Unset oncancelled to prevent repeated calls.\n        promise.oncancelled = null;\n\n        return cancellationPromise;\n    }\n}\n\n/**\n * Returns a callback that implements the resolution algorithm for the given cancellable promise.\n */\nfunction resolverFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseResolver<T> {\n    return (value) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (value === promise.promise) {\n            if (state.settled) { return; }\n            state.settled = true;\n            promise.reject(new TypeError(\"A promise cannot be resolved with itself.\"));\n            return;\n        }\n\n        if (value != null && (typeof value === 'object' || typeof value === 'function')) {\n            let then: any;\n            try {\n                then = (value as any).then;\n            } catch (err) {\n                state.settled = true;\n                promise.reject(err);\n                return;\n            }\n\n            if (isCallable(then)) {\n                try {\n                    let cancel = (value as any).cancel;\n                    if (isCallable(cancel)) {\n                        const oncancelled = (cause?: any) => {\n                            Reflect.apply(cancel, value, [cause]);\n                        };\n                        if (state.reason) {\n                            // If already cancelled, propagate cancellation.\n                            // The promise returned from the canceller algorithm does not reject\n                            // so it can be discarded safely.\n                            void cancellerFor({ ...promise, oncancelled }, state)(state.reason);\n                        } else {\n                            promise.oncancelled = oncancelled;\n                        }\n                    }\n                } catch {}\n\n                const newState: CancellablePromiseState = {\n                    root: state.root,\n                    resolving: false,\n                    get settled() { return this.root.settled },\n                    set settled(value) { this.root.settled = value; },\n                    get reason() { return this.root.reason }\n                };\n\n                const rejector = rejectorFor(promise, newState);\n                try {\n                    Reflect.apply(then, value, [resolverFor(promise, newState), rejector]);\n                } catch (err) {\n                    rejector(err);\n                }\n                return; // IMPORTANT!\n            }\n        }\n\n        if (state.settled) { return; }\n        state.settled = true;\n        promise.resolve(value);\n    };\n}\n\n/**\n * Returns a callback that implements the rejection algorithm for the given cancellable promise.\n */\nfunction rejectorFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseRejector {\n    return (reason?) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (state.settled) {\n            try {\n                if (reason instanceof CancelError && state.reason instanceof CancelError && Object.is(reason.cause, state.reason.cause)) {\n                    // Swallow late rejections that are CancelErrors whose cancellation cause is the same as ours.\n                    return;\n                }\n            } catch {}\n\n            void Promise.reject(new CancelledRejectionError(promise.promise, reason));\n        } else {\n            state.settled = true;\n            promise.reject(reason);\n        }\n    }\n}\n\n/**\n * Cancels all values in an array that look like cancellable thenables.\n * Returns a promise that fulfills once all cancellation procedures for the given values have settled.\n */\nfunction cancelAll(parent: CancellablePromise<unknown>, values: any[], cause?: any): Promise<void> {\n    const results: Promise<void>[] = [];\n\n    for (const value of values) {\n        let cancel: CancellablePromiseCanceller;\n        try {\n            if (!isCallable(value.then)) { continue; }\n            cancel = value.cancel;\n            if (!isCallable(cancel)) { continue; }\n        } catch { continue; }\n\n        let result: void | PromiseLike<void>;\n        try {\n            result = Reflect.apply(cancel, value, [cause]);\n        } catch (err) {\n            Promise.reject(new CancelledRejectionError(parent, err, \"Unhandled exception in cancel method.\"));\n            continue;\n        }\n\n        if (!result) { continue; }\n        results.push(\n            (result instanceof Promise  ? result : Promise.resolve(result)).catch((reason?) => {\n                Promise.reject(new CancelledRejectionError(parent, reason, \"Unhandled rejection in cancel method.\"));\n            })\n        );\n    }\n\n    return Promise.all(results) as any;\n}\n\n/**\n * Returns its argument.\n */\nfunction identity<T>(x: T): T {\n    return x;\n}\n\n/**\n * Throws its argument.\n */\nfunction thrower(reason?: any): never {\n    throw reason;\n}\n\n/**\n * Attempts various strategies to convert an error to a string.\n */\nfunction errorMessage(err: any): string {\n    try {\n        if (err instanceof Error || typeof err !== 'object' || err.toString !== Object.prototype.toString) {\n            return \"\" + err;\n        }\n    } catch {}\n\n    try {\n        return JSON.stringify(err);\n    } catch {}\n\n    try {\n        return Object.prototype.toString.call(err);\n    } catch {}\n\n    return \"<could not convert error to string>\";\n}\n\n/**\n * Gets the current barrier promise for the given cancellable promise. If necessary, initialises the barrier.\n */\nfunction currentBarrier<T>(promise: CancellablePromise<T>): Promise<void> {\n    let pwr: Partial<PromiseWithResolvers<void>> = promise[barrierSym] ?? {};\n    if (!('promise' in pwr)) {\n        Object.assign(pwr, promiseWithResolvers<void>());\n    }\n    if (promise[barrierSym] == null) {\n        pwr.resolve!();\n        promise[barrierSym] = pwr;\n    }\n    return pwr.promise!;\n}\n\n// Polyfill Promise.withResolvers.\nlet promiseWithResolvers = Promise.withResolvers;\nif (promiseWithResolvers && typeof promiseWithResolvers === 'function') {\n    promiseWithResolvers = promiseWithResolvers.bind(Promise);\n} else {\n    promiseWithResolvers = function <T>(): PromiseWithResolvers<T> {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });\n        return { promise, resolve, reject };\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Clipboard);\n\nconst ClipboardSetText = 0;\nconst ClipboardText = 1;\n\n/**\n * Sets the text to the Clipboard.\n *\n * @param text - The text to be set to the Clipboard.\n * @return A Promise that resolves when the operation is successful.\n */\nexport function SetText(text: string): Promise<void> {\n    return call(ClipboardSetText, {text});\n}\n\n/**\n * Get the Clipboard text\n *\n * @returns A promise that resolves with the text from the Clipboard.\n */\nexport function Text(): Promise<string> {\n    return call(ClipboardText);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nexport interface Size {\n    /** The width of a rectangular area. */\n    Width: number;\n    /** The height of a rectangular area. */\n    Height: number;\n}\n\nexport interface Rect {\n    /** The X coordinate of the origin. */\n    X: number;\n    /** The Y coordinate of the origin. */\n    Y: number;\n    /** The width of the rectangle. */\n    Width: number;\n    /** The height of the rectangle. */\n    Height: number;\n}\n\nexport interface Screen {\n    /** Unique identifier for the screen. */\n    ID: string;\n    /** Human-readable name of the screen. */\n    Name: string;\n    /** The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc. */\n    ScaleFactor: number;\n    /** The X coordinate of the screen. */\n    X: number;\n    /** The Y coordinate of the screen. */\n    Y: number;\n    /** Contains the width and height of the screen. */\n    Size: Size;\n    /** Contains the bounds of the screen in terms of X, Y, Width, and Height. */\n    Bounds: Rect;\n    /** Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling). */\n    PhysicalBounds: Rect;\n    /** Contains the area of the screen that is actually usable (excluding taskbar and other system UI). */\n    WorkArea: Rect;\n    /** Contains the physical WorkArea of the screen (before scaling). */\n    PhysicalWorkArea: Rect;\n    /** True if this is the primary monitor selected by the user in the operating system. */\n    IsPrimary: boolean;\n    /** The rotation of the screen. */\n    Rotation: number;\n}\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Screens);\n\nconst getAll = 0;\nconst getPrimary = 1;\nconst getCurrent = 2;\n\n/**\n * Gets all screens.\n *\n * @returns A promise that resolves to an array of Screen objects.\n */\nexport function GetAll(): Promise<Screen[]> {\n    return call(getAll);\n}\n\n/**\n * Gets the primary screen.\n *\n * @returns A promise that resolves to the primary screen.\n */\nexport function GetPrimary(): Promise<Screen> {\n    return call(getPrimary);\n}\n\n/**\n * Gets the current active screen.\n *\n * @returns A promise that resolves with the current active screen.\n */\nexport function GetCurrent(): Promise<Screen> {\n    return call(getCurrent);\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.IOS);\n\n// Method IDs\nconst HapticsImpact = 0;\nconst DeviceInfo = 1;\n\nexport namespace Haptics {\n    export type ImpactStyle = \"light\"|\"medium\"|\"heavy\"|\"soft\"|\"rigid\";\n    export function Impact(style: ImpactStyle = \"medium\"): Promise<void> {\n        return call(HapticsImpact, { style });\n    }\n}\n\nexport namespace Device {\n    export interface Info {\n        model: string;\n        systemName: string;\n        systemVersion: string;\n        isSimulator: boolean;\n    }\n    export function Info(): Promise<Info> {\n        return call(DeviceInfo);\n    }\n}\n"],
  "mappings": "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",
  "names": ["_a", "Error", "call", "Error", "_a", "Array", "Map", "Array", "Map", "key", "call", "_a", "resizable", "call", "_a", "call", "_a", "call", "HideMethod", "ShowMethod", "isDocumentDotAll", "_a", "reason", "value", "call", "call", "call", "call", "Haptics", "Device", "Info"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.ts", "../../runtime/desktop/@wailsio/runtime/src/wml.ts", "../../runtime/desktop/@wailsio/runtime/src/browser.ts", "../../runtime/desktop/@wailsio/runtime/src/nanoid.ts", "../../runtime/desktop/@wailsio/runtime/src/runtime.ts", "../../runtime/desktop/@wailsio/runtime/src/dialogs.ts", "../../runtime/desktop/@wailsio/runtime/src/events.ts", "../../runtime/desktop/@wailsio/runtime/src/listener.ts", "../../runtime/desktop/@wailsio/runtime/src/create.ts", "../../runtime/desktop/@wailsio/runtime/src/event_types.ts", "../../runtime/desktop/@wailsio/runtime/src/utils.ts", "../../runtime/desktop/@wailsio/runtime/src/window.ts", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.ts", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.ts", "../../runtime/desktop/@wailsio/runtime/src/flags.ts", "../../runtime/desktop/@wailsio/runtime/src/drag.ts", "../../runtime/desktop/@wailsio/runtime/src/application.ts", "../../runtime/desktop/@wailsio/runtime/src/calls.ts", "../../runtime/desktop/@wailsio/runtime/src/callable.ts", "../../runtime/desktop/@wailsio/runtime/src/cancellable.ts", "../../runtime/desktop/@wailsio/runtime/src/clipboard.ts", "../../runtime/desktop/@wailsio/runtime/src/screens.ts", "../../runtime/desktop/@wailsio/runtime/src/ios.ts"],
  "sourcesContent": ["/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Setup\nwindow._wails = window._wails || {};\n\nimport \"./contextmenu.js\";\nimport \"./drag.js\";\n\n// Re-export public API\nimport * as Application from \"./application.js\";\nimport * as Browser from \"./browser.js\";\nimport * as Call from \"./calls.js\";\nimport * as Clipboard from \"./clipboard.js\";\nimport * as Create from \"./create.js\";\nimport * as Dialogs from \"./dialogs.js\";\nimport * as Events from \"./events.js\";\nimport * as Flags from \"./flags.js\";\nimport * as Screens from \"./screens.js\";\nimport * as System from \"./system.js\";\nimport * as IOS from \"./ios.js\";\nimport Window, { handleDragEnter, handleDragLeave, handleDragOver } from \"./window.js\";\nimport * as WML from \"./wml.js\";\n\nexport {\n    Application,\n    Browser,\n    Call,\n    Clipboard,\n    Dialogs,\n    Events,\n    Flags,\n    Screens,\n    System,\n    IOS,\n    Window,\n    WML\n};\n\n/**\n * An internal utility consumed by the binding generator.\n *\n * @ignore\n */\nexport { Create };\n\nexport * from \"./cancellable.js\";\n\n// Export transport interfaces and utilities\nexport {\n    setTransport,\n    getTransport,\n    type RuntimeTransport,\n    objectNames,\n    clientId,\n} from \"./runtime.js\";\n\n// Notify backend\nwindow._wails.invoke = System.invoke;\n\n// Register platform handlers (internal API)\n// Note: Window is the thisWindow instance (default export from window.ts)\n// Binding ensures 'this' correctly refers to the current window instance\nwindow._wails.handlePlatformFileDrop = Window.HandlePlatformFileDrop.bind(Window);\n\n// Linux-specific drag handlers (GTK intercepts DOM drag events)\nwindow._wails.handleDragEnter = handleDragEnter;\nwindow._wails.handleDragLeave = handleDragLeave;\nwindow._wails.handleDragOver = handleDragOver;\n\nSystem.invoke(\"wails:runtime:ready\");\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { OpenURL } from \"./browser.js\";\nimport { Question } from \"./dialogs.js\";\nimport { Emit } from \"./events.js\";\nimport { canAbortListeners, whenReady } from \"./utils.js\";\nimport Window from \"./window.js\";\n\n/**\n * Sends an event with the given name and optional data.\n *\n * @param eventName - - The name of the event to send.\n * @param [data=null] - - Optional data to send along with the event.\n */\nfunction sendEvent(eventName: string, data: any = null): void {\n    Emit(eventName, data);\n}\n\n/**\n * Calls a method on a specified window.\n *\n * @param windowName - The name of the window to call the method on.\n * @param methodName - The name of the method to call.\n */\nfunction callWindowMethod(windowName: string, methodName: string) {\n    const targetWindow = Window.Get(windowName);\n    const method = (targetWindow as any)[methodName];\n\n    if (typeof method !== \"function\") {\n        console.error(`Window method '${methodName}' not found`);\n        return;\n    }\n\n    try {\n        method.call(targetWindow);\n    } catch (e) {\n        console.error(`Error calling window method '${methodName}': `, e);\n    }\n}\n\n/**\n * Responds to a triggering event by running appropriate WML actions for the current target.\n */\nfunction onWMLTriggered(ev: Event): void {\n    const element = ev.currentTarget as Element;\n\n    function runEffect(choice = \"Yes\") {\n        if (choice !== \"Yes\")\n            return;\n\n        const eventType = element.getAttribute('wml-event') || element.getAttribute('data-wml-event');\n        const targetWindow = element.getAttribute('wml-target-window') || element.getAttribute('data-wml-target-window') || \"\";\n        const windowMethod = element.getAttribute('wml-window') || element.getAttribute('data-wml-window');\n        const url = element.getAttribute('wml-openurl') || element.getAttribute('data-wml-openurl');\n\n        if (eventType !== null)\n            sendEvent(eventType);\n        if (windowMethod !== null)\n            callWindowMethod(targetWindow, windowMethod);\n        if (url !== null)\n            void OpenURL(url);\n    }\n\n    const confirm = element.getAttribute('wml-confirm') || element.getAttribute('data-wml-confirm');\n\n    if (confirm) {\n        Question({\n            Title: \"Confirm\",\n            Message: confirm,\n            Detached: false,\n            Buttons: [\n                { Label: \"Yes\" },\n                { Label: \"No\", IsDefault: true }\n            ]\n        }).then(runEffect);\n    } else {\n        runEffect();\n    }\n}\n\n// Private field names.\nconst controllerSym = Symbol(\"controller\");\nconst triggerMapSym = Symbol(\"triggerMap\");\nconst elementCountSym = Symbol(\"elementCount\");\n\n/**\n * AbortControllerRegistry does not actually remember active event listeners: instead\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\n */\nclass AbortControllerRegistry {\n    // Private fields.\n    [controllerSym]: AbortController;\n\n    constructor() {\n        this[controllerSym] = new AbortController();\n    }\n\n    /**\n     * Returns an options object for addEventListener that ties the listener\n     * to the AbortSignal from the current AbortController.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified elements\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        return { signal: this[controllerSym].signal };\n    }\n\n    /**\n     * Removes all registered event listeners and resets the registry.\n     */\n    reset(): void {\n        this[controllerSym].abort();\n        this[controllerSym] = new AbortController();\n    }\n}\n\n/**\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\n * This ensures that the mapping remains private to this module, while still allowing garbage\n * collection of the involved elements.\n */\nclass WeakMapRegistry {\n    /** Stores the current element-to-trigger mapping. */\n    [triggerMapSym]: WeakMap<Element, string[]>;\n    /** Counts the number of elements with active WML triggers. */\n    [elementCountSym]: number;\n\n    constructor() {\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n\n    /**\n     * Sets active triggers for the specified element.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified element\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        if (!this[triggerMapSym].has(element)) { this[elementCountSym]++; }\n        this[triggerMapSym].set(element, triggers);\n        return {};\n    }\n\n    /**\n     * Removes all registered event listeners.\n     */\n    reset(): void {\n        if (this[elementCountSym] <= 0)\n            return;\n\n        for (const element of document.body.querySelectorAll('*')) {\n            if (this[elementCountSym] <= 0)\n                break;\n\n            const triggers = this[triggerMapSym].get(element);\n            if (triggers != null) { this[elementCountSym]--; }\n\n            for (const trigger of triggers || [])\n                element.removeEventListener(trigger, onWMLTriggered);\n        }\n\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n}\n\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\n\n/**\n * Adds event listeners to the specified element.\n */\nfunction addWMLListeners(element: Element): void {\n    const triggerRegExp = /\\S+/g;\n    const triggerAttr = (element.getAttribute('wml-trigger') || element.getAttribute('data-wml-trigger') || \"click\");\n    const triggers: string[] = [];\n\n    let match;\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\n        triggers.push(match[0]);\n\n    const options = triggerRegistry.set(element, triggers);\n    for (const trigger of triggers)\n        element.addEventListener(trigger, onWMLTriggered, options);\n}\n\n/**\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\n */\nexport function Enable(): void {\n    whenReady(Reload);\n}\n\n/**\n * Reloads the WML page by adding necessary event listeners and browser listeners.\n */\nexport function Reload(): void {\n    triggerRegistry.reset();\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]').forEach(addWMLListeners);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Browser);\n\nconst BrowserOpenURL = 0;\n\n/**\n * Open a browser window to the given URL.\n *\n * @param url - The URL to open\n */\nexport function OpenURL(url: string | URL): Promise<void> {\n    return call(BrowserOpenURL, {url: url.toString()});\n}\n", "// Source: https://github.com/ai/nanoid\n\n// The MIT License (MIT)\n//\n// Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n//     subject to the following conditions:\n//\n//     The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n//     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// This alphabet uses `A-Za-z0-9_-` symbols.\n// The order of characters is optimized for better gzip and brotli compression.\n// References to the same file (works both for gzip and brotli):\n// `'use`, `andom`, and `rict'`\n// References to the brotli default dictionary:\n// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`\nconst urlAlphabet =\n    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n\nexport function nanoid(size: number = 21): string {\n    let id = ''\n    // A compact alternative for `for (var i = 0; i < step; i++)`.\n    let i = size | 0\n    while (i--) {\n        // `| 0` is more compact and faster than `Math.floor()`.\n        id += urlAlphabet[(Math.random() * 64) | 0]\n    }\n    return id\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { nanoid } from \"./nanoid.js\";\n\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\n\n// Re-export nanoid for custom transport implementations\nexport { nanoid };\n\n// Object Names\nexport const objectNames = Object.freeze({\n    Call: 0,\n    Clipboard: 1,\n    Application: 2,\n    Events: 3,\n    ContextMenu: 4,\n    Dialog: 5,\n    Window: 6,\n    Screens: 7,\n    System: 8,\n    Browser: 9,\n    CancelCall: 10,\n    IOS: 11,\n});\nexport let clientId = nanoid();\n\n/**\n * RuntimeTransport defines the interface for custom IPC transport implementations.\n * Implement this interface to use WebSockets, custom protocols, or any other\n * transport mechanism instead of the default HTTP fetch.\n */\nexport interface RuntimeTransport {\n    /**\n     * Send a runtime call and return the response.\n     *\n     * @param objectID - The Wails object ID (0=Call, 1=Clipboard, etc.)\n     * @param method - The method ID to call\n     * @param windowName - Optional window name\n     * @param args - Arguments to pass (will be JSON stringified if present)\n     * @returns Promise that resolves with the response data\n     */\n    call(objectID: number, method: number, windowName: string, args: any): Promise<any>;\n}\n\n/**\n * Custom transport implementation (can be set by user)\n */\nlet customTransport: RuntimeTransport | null = null;\n\n/**\n * Set a custom transport for all Wails runtime calls.\n * This allows you to replace the default HTTP fetch transport with\n * WebSockets, custom protocols, or any other mechanism.\n *\n * @param transport - Your custom transport implementation\n *\n * @example\n * ```typescript\n * import { setTransport } from '/wails/runtime.js';\n *\n * const wsTransport = {\n *   call: async (objectID, method, windowName, args) => {\n *     // Your WebSocket implementation\n *   }\n * };\n *\n * setTransport(wsTransport);\n * ```\n */\nexport function setTransport(transport: RuntimeTransport | null): void {\n    customTransport = transport;\n}\n\n/**\n * Get the current transport (useful for extending/wrapping)\n */\nexport function getTransport(): RuntimeTransport | null {\n    return customTransport;\n}\n\n/**\n * Creates a new runtime caller with specified ID.\n *\n * @param object - The object to invoke the method on.\n * @param windowName - The name of the window.\n * @return The new runtime caller function.\n */\nexport function newRuntimeCaller(object: number, windowName: string = '') {\n    return function (method: number, args: any = null) {\n        return runtimeCallWithID(object, method, windowName, args);\n    };\n}\n\nasync function runtimeCallWithID(objectID: number, method: number, windowName: string, args: any): Promise<any> {\n    // Use custom transport if available\n    if (customTransport) {\n        return customTransport.call(objectID, method, windowName, args);\n    }\n\n    // Default HTTP fetch transport\n    let url = new URL(runtimeURL);\n\n    let body: { object: number; method: number, args?: any } = {\n      object: objectID,\n      method\n    }\n    if (args !== null && args !== undefined) {\n      body.args = args;\n    }\n\n    let headers: Record<string, string> = {\n        [\"x-wails-client-id\"]: clientId,\n        [\"Content-Type\"]: \"application/json\"\n    }\n    if (windowName) {\n        headers[\"x-wails-window-name\"] = windowName;\n    }\n\n    let response = await fetch(url, {\n      method: 'POST',\n      headers,\n      body: JSON.stringify(body)\n    });\n    if (!response.ok) {\n        throw new Error(await response.text());\n    }\n\n    if ((response.headers.get(\"Content-Type\")?.indexOf(\"application/json\") ?? -1) !== -1) {\n        return response.json();\n    } else {\n        return response.text();\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\n// setup\nwindow._wails = window._wails || {};\n\nconst call = newRuntimeCaller(objectNames.Dialog);\n\n// Define constants from the `methods` object in Title Case\nconst DialogInfo = 0;\nconst DialogWarning = 1;\nconst DialogError = 2;\nconst DialogQuestion = 3;\nconst DialogOpenFile = 4;\nconst DialogSaveFile = 5;\n\nexport interface OpenFileDialogOptions {\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if multiple selection is allowed. */\n    AllowsMultipleSelection?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface SaveFileDialogOptions {\n    /** Default filename to use in the dialog. */\n    Filename?: string;\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface MessageDialogOptions {\n    /** The title of the dialog window. */\n    Title?: string;\n    /** The main message to show in the dialog. */\n    Message?: string;\n    /** Array of button options to show in the dialog. */\n    Buttons?: Button[];\n    /** True if the dialog should appear detached from the main window (if applicable). */\n    Detached?: boolean;\n}\n\nexport interface Button {\n    /** Text that appears within the button. */\n    Label?: string;\n    /** True if the button should cancel an operation when clicked. */\n    IsCancel?: boolean;\n    /** True if the button should be the default action when the user presses enter. */\n    IsDefault?: boolean;\n}\n\nexport interface FileFilter {\n    /** Display name for the filter, it could be \"Text Files\", \"Images\" etc. */\n    DisplayName?: string;\n    /** Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files. */\n    Pattern?: string;\n}\n\n/**\n * Presents a dialog of specified type with the given options.\n *\n * @param type - Dialog type.\n * @param options - Options for the dialog.\n * @returns A promise that resolves with result of dialog.\n */\nfunction dialog(type: number, options: MessageDialogOptions | OpenFileDialogOptions | SaveFileDialogOptions = {}): Promise<any> {\n    return call(type, options);\n}\n\n/**\n * Presents an info dialog.\n *\n * @param options - Dialog options\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Info(options: MessageDialogOptions): Promise<string> { return dialog(DialogInfo, options); }\n\n/**\n * Presents a warning dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Warning(options: MessageDialogOptions): Promise<string> { return dialog(DialogWarning, options); }\n\n/**\n * Presents an error dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Error(options: MessageDialogOptions): Promise<string> { return dialog(DialogError, options); }\n\n/**\n * Presents a question dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Question(options: MessageDialogOptions): Promise<string> { return dialog(DialogQuestion, options); }\n\n/**\n * Presents a file selection dialog to pick one or more files to open.\n *\n * @param options - Dialog options.\n * @returns Selected file or list of files, or a blank string/empty list if no file has been selected.\n */\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection: true }): Promise<string[]>;\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection?: false | undefined }): Promise<string>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]> { return dialog(DialogOpenFile, options) ?? []; }\n\n/**\n * Presents a file selection dialog to pick a file to save.\n *\n * @param options - Dialog options.\n * @returns Selected file, or a blank string if no file has been selected.\n */\nexport function SaveFile(options: SaveFileDialogOptions): Promise<string> { return dialog(DialogSaveFile, options); }\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { eventListeners, Listener, listenerOff } from \"./listener.js\";\nimport { Events as Create } from \"./create.js\";\nimport { Types } from \"./event_types.js\";\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.dispatchWailsEvent = dispatchWailsEvent;\n\nconst call = newRuntimeCaller(objectNames.Events);\nconst EmitMethod = 0;\n\nexport * from \"./event_types.js\";\n\n/**\n * A table of data types for all known events.\n * Will be monkey-patched by the binding generator.\n */\nexport interface CustomEvents {}\n\n/**\n * Either a known event name or an arbitrary string.\n */\nexport type WailsEventName<E extends keyof CustomEvents = keyof CustomEvents> = E | (string & {});\n\n/**\n * Union of all known system event names.\n */\ntype SystemEventName = {\n    [K in keyof (typeof Types)]: (typeof Types)[K][keyof ((typeof Types)[K])]\n} extends (infer M) ? M[keyof M] : never;\n\n/**\n * The data type associated to a given event.\n */\nexport type WailsEventData<E extends WailsEventName = WailsEventName> =\n    E extends keyof CustomEvents ? CustomEvents[E] : (E extends SystemEventName ? void : any);\n\n/**\n * The type of handlers for a given event.\n */\nexport type WailsEventCallback<E extends WailsEventName = WailsEventName> = (ev: WailsEvent<E>) => void;\n\n/**\n * Represents a system event or a custom event emitted through wails-provided facilities.\n */\nexport class WailsEvent<E extends WailsEventName = WailsEventName> {\n    /**\n     * The name of the event.\n     */\n    name: E;\n\n    /**\n     * Optional data associated with the emitted event.\n     */\n    data: WailsEventData<E>;\n\n    /**\n     * Name of the originating window. Omitted for application events.\n     * Will be overridden if set manually.\n     */\n    sender?: string;\n\n    constructor(name: E, data: WailsEventData<E>);\n    constructor(name: WailsEventData<E> extends null | void ? E : never)\n    constructor(name: E, data?: any) {\n        this.name = name;\n        this.data = data ?? null;\n    }\n}\n\nfunction dispatchWailsEvent(event: any) {\n    let listeners = eventListeners.get(event.name);\n    if (!listeners) {\n        return;\n    }\n\n    let wailsEvent = new WailsEvent(\n        event.name,\n        (event.name in Create) ? Create[event.name](event.data) : event.data\n    );\n    if ('sender' in event) {\n        wailsEvent.sender = event.sender;\n    }\n\n    listeners = listeners.filter(listener => !listener.dispatch(wailsEvent));\n    if (listeners.length === 0) {\n        eventListeners.delete(event.name);\n    } else {\n        eventListeners.set(event.name, listeners);\n    }\n}\n\n/**\n * Register a callback function to be called multiple times for a specific event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @param 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.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function OnMultiple<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>, maxCallbacks: number) {\n    let listeners = eventListeners.get(eventName) || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    listeners.push(thisListener);\n    eventListeners.set(eventName, listeners);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers a callback function to be executed when the specified event occurs.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function On<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void {\n    return OnMultiple(eventName, callback, -1);\n}\n\n/**\n * Registers a callback function to be executed only once for the specified event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function Once<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void {\n    return OnMultiple(eventName, callback, 1);\n}\n\n/**\n * Removes event listeners for the specified event names.\n *\n * @param eventNames - The name of the events to remove listeners for.\n */\nexport function Off(...eventNames: [WailsEventName, ...WailsEventName[]]): void {\n    eventNames.forEach(eventName => eventListeners.delete(eventName));\n}\n\n/**\n * Removes all event listeners.\n */\nexport function OffAll(): void {\n    eventListeners.clear();\n}\n\n/**\n * Emits an event.\n *\n * @returns A promise that will be fulfilled once the event has been emitted.  Resolves to true if the event was cancelled.\n * @param name - The name of the event to emit\n * @param data - The data that will be sent with the event\n */\nexport function Emit<E extends WailsEventName = WailsEventName>(name: E, data: WailsEventData<E>): Promise<boolean>\nexport function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E> extends null | void ? E : never): Promise<boolean>\nexport function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E>, data?: any): Promise<boolean> {\n    return call(EmitMethod,  new WailsEvent(name, data))\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// The following utilities have been factored out of ./events.ts\n// for testing purposes.\n\nexport const eventListeners = new Map<string, Listener[]>();\n\nexport class Listener {\n    eventName: string;\n    callback: (data: any) => void;\n    maxCallbacks: number;\n\n    constructor(eventName: string, callback: (data: any) => void, maxCallbacks: number) {\n        this.eventName = eventName;\n        this.callback = callback;\n        this.maxCallbacks = maxCallbacks || -1;\n    }\n\n    dispatch(data: any): boolean {\n        try {\n            this.callback(data);\n        } catch (err) {\n            console.error(err);\n        }\n\n        if (this.maxCallbacks === -1) return false;\n        this.maxCallbacks -= 1;\n        return this.maxCallbacks === 0;\n    }\n}\n\nexport function listenerOff(listener: Listener): void {\n    let listeners = eventListeners.get(listener.eventName);\n    if (!listeners) {\n        return;\n    }\n\n    listeners = listeners.filter(l => l !== listener);\n    if (listeners.length === 0) {\n        eventListeners.delete(listener.eventName);\n    } else {\n        eventListeners.set(listener.eventName, listeners);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Any is a dummy creation function for simple or unknown types.\n */\nexport function Any<T = any>(source: any): T {\n    return source;\n}\n\n/**\n * ByteSlice is a creation function that replaces\n * null strings with empty strings.\n */\nexport function ByteSlice(source: any): string {\n    return ((source == null) ? \"\" : source);\n}\n\n/**\n * Array takes a creation function for an arbitrary type\n * and returns an in-place creation function for an array\n * whose elements are of that type.\n */\nexport function Array<T = any>(element: (source: any) => T): (source: any) => T[] {\n    if (element === Any) {\n        return (source) => (source === null ? [] : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return [];\n        }\n        for (let i = 0; i < source.length; i++) {\n            source[i] = element(source[i]);\n        }\n        return source;\n    };\n}\n\n/**\n * Map takes creation functions for two arbitrary types\n * and returns an in-place creation function for an object\n * whose keys and values are of those types.\n */\nexport function Map<V = any>(key: (source: any) => string, value: (source: any) => V): (source: any) => Record<string, V> {\n    if (value === Any) {\n        return (source) => (source === null ? {} : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return {};\n        }\n        for (const key in source) {\n            source[key] = value(source[key]);\n        }\n        return source;\n    };\n}\n\n/**\n * Nullable takes a creation function for an arbitrary type\n * and returns a creation function for a nullable value of that type.\n */\nexport function Nullable<T = any>(element: (source: any) => T): (source: any) => (T | null) {\n    if (element === Any) {\n        return Any;\n    }\n\n    return (source) => (source === null ? null : element(source));\n}\n\n/**\n * Struct takes an object mapping field names to creation functions\n * and returns an in-place creation function for a struct.\n */\nexport function Struct(createField: Record<string, (source: any) => any>):\n    <U extends Record<string, any> = any>(source: any) => U\n{\n    let allAny = true;\n    for (const name in createField) {\n        if (createField[name] !== Any) {\n            allAny = false;\n            break;\n        }\n    }\n    if (allAny) {\n        return Any;\n    }\n\n    return (source) => {\n        for (const name in createField) {\n            if (name in source) {\n                source[name] = createField[name](source[name]);\n            }\n        }\n        return source;\n    };\n}\n\n/**\n * Maps known event names to creation functions for their data types.\n * Will be monkey-patched by the binding generator.\n */\nexport const Events: Record<string, (source: any) => any> = {};\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH \u00C2 MODIWL\n// This file is automatically generated. DO NOT EDIT\n\nexport const Types = Object.freeze({\n\tWindows: Object.freeze({\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\n\t\tAPMSuspend: \"windows:APMSuspend\",\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\n\t\tWindowActive: \"windows:WindowActive\",\n\t\tWindowBackgroundErase: \"windows:WindowBackgroundErase\",\n\t\tWindowClickActive: \"windows:WindowClickActive\",\n\t\tWindowClosing: \"windows:WindowClosing\",\n\t\tWindowDidMove: \"windows:WindowDidMove\",\n\t\tWindowDidResize: \"windows:WindowDidResize\",\n\t\tWindowDPIChanged: \"windows:WindowDPIChanged\",\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\n\t\tWindowDragOver: \"windows:WindowDragOver\",\n\t\tWindowEndMove: \"windows:WindowEndMove\",\n\t\tWindowEndResize: \"windows:WindowEndResize\",\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\n\t\tWindowHide: \"windows:WindowHide\",\n\t\tWindowInactive: \"windows:WindowInactive\",\n\t\tWindowKeyDown: \"windows:WindowKeyDown\",\n\t\tWindowKeyUp: \"windows:WindowKeyUp\",\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\n\t\tWindowNonClientHit: \"windows:WindowNonClientHit\",\n\t\tWindowNonClientMouseDown: \"windows:WindowNonClientMouseDown\",\n\t\tWindowNonClientMouseLeave: \"windows:WindowNonClientMouseLeave\",\n\t\tWindowNonClientMouseMove: \"windows:WindowNonClientMouseMove\",\n\t\tWindowNonClientMouseUp: \"windows:WindowNonClientMouseUp\",\n\t\tWindowPaint: \"windows:WindowPaint\",\n\t\tWindowRestore: \"windows:WindowRestore\",\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\n\t\tWindowShow: \"windows:WindowShow\",\n\t\tWindowStartMove: \"windows:WindowStartMove\",\n\t\tWindowStartResize: \"windows:WindowStartResize\",\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\n\t\tWindowZOrderChanged: \"windows:WindowZOrderChanged\",\n\t\tWindowMinimise: \"windows:WindowMinimise\",\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\n\t\tWindowMaximise: \"windows:WindowMaximise\",\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\n\t}),\n\tMac: Object.freeze({\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme\",\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\n\t\tApplicationDidResignActive: \"mac:ApplicationDidResignActive\",\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen\",\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\n\t\tMenuDidClose: \"mac:MenuDidClose\",\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\n\t\tWindowDidMove: \"mac:WindowDidMove\",\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\n\t\tWindowDidResize: \"mac:WindowDidResize\",\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\n\t\tWindowDidZoom: \"mac:WindowDidZoom\",\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\n\t\tWindowHide: \"mac:WindowHide\",\n\t\tWindowMaximise: \"mac:WindowMaximise\",\n\t\tWindowUnMaximise: \"mac:WindowUnMaximise\",\n\t\tWindowMinimise: \"mac:WindowMinimise\",\n\t\tWindowUnMinimise: \"mac:WindowUnMinimise\",\n\t\tWindowShouldClose: \"mac:WindowShouldClose\",\n\t\tWindowShow: \"mac:WindowShow\",\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\n\t\tWindowWillClose: \"mac:WindowWillClose\",\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\n\t\tWindowWillMove: \"mac:WindowWillMove\",\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\n\t\tWindowWillResize: \"mac:WindowWillResize\",\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\n\t\tWindowZoomIn: \"mac:WindowZoomIn\",\n\t\tWindowZoomOut: \"mac:WindowZoomOut\",\n\t\tWindowZoomReset: \"mac:WindowZoomReset\",\n\t}),\n\tLinux: Object.freeze({\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\n\t\tWindowDidMove: \"linux:WindowDidMove\",\n\t\tWindowDidResize: \"linux:WindowDidResize\",\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\n\t\tWindowLoadStarted: \"linux:WindowLoadStarted\",\n\t\tWindowLoadRedirected: \"linux:WindowLoadRedirected\",\n\t\tWindowLoadCommitted: \"linux:WindowLoadCommitted\",\n\t\tWindowLoadFinished: \"linux:WindowLoadFinished\",\n\t}),\n\tiOS: Object.freeze({\n\t\tApplicationDidBecomeActive: \"ios:ApplicationDidBecomeActive\",\n\t\tApplicationDidEnterBackground: \"ios:ApplicationDidEnterBackground\",\n\t\tApplicationDidFinishLaunching: \"ios:ApplicationDidFinishLaunching\",\n\t\tApplicationDidReceiveMemoryWarning: \"ios:ApplicationDidReceiveMemoryWarning\",\n\t\tApplicationWillEnterForeground: \"ios:ApplicationWillEnterForeground\",\n\t\tApplicationWillResignActive: \"ios:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"ios:ApplicationWillTerminate\",\n\t\tWindowDidLoad: \"ios:WindowDidLoad\",\n\t\tWindowWillAppear: \"ios:WindowWillAppear\",\n\t\tWindowDidAppear: \"ios:WindowDidAppear\",\n\t\tWindowWillDisappear: \"ios:WindowWillDisappear\",\n\t\tWindowDidDisappear: \"ios:WindowDidDisappear\",\n\t\tWindowSafeAreaInsetsChanged: \"ios:WindowSafeAreaInsetsChanged\",\n\t\tWindowOrientationChanged: \"ios:WindowOrientationChanged\",\n\t\tWindowTouchBegan: \"ios:WindowTouchBegan\",\n\t\tWindowTouchMoved: \"ios:WindowTouchMoved\",\n\t\tWindowTouchEnded: \"ios:WindowTouchEnded\",\n\t\tWindowTouchCancelled: \"ios:WindowTouchCancelled\",\n\t\tWebViewDidStartNavigation: \"ios:WebViewDidStartNavigation\",\n\t\tWebViewDidFinishNavigation: \"ios:WebViewDidFinishNavigation\",\n\t\tWebViewDidFailNavigation: \"ios:WebViewDidFailNavigation\",\n\t\tWebViewDecidePolicyForNavigationAction: \"ios:WebViewDecidePolicyForNavigationAction\",\n\t}),\n\tCommon: Object.freeze({\n\t\tApplicationOpenedWithFile: \"common:ApplicationOpenedWithFile\",\n\t\tApplicationStarted: \"common:ApplicationStarted\",\n\t\tApplicationLaunchedWithUrl: \"common:ApplicationLaunchedWithUrl\",\n\t\tThemeChanged: \"common:ThemeChanged\",\n\t\tWindowClosing: \"common:WindowClosing\",\n\t\tWindowDidMove: \"common:WindowDidMove\",\n\t\tWindowDidResize: \"common:WindowDidResize\",\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\n\t\tWindowFocus: \"common:WindowFocus\",\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\n\t\tWindowHide: \"common:WindowHide\",\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\n\t\tWindowMaximise: \"common:WindowMaximise\",\n\t\tWindowMinimise: \"common:WindowMinimise\",\n\t\tWindowToggleFrameless: \"common:WindowToggleFrameless\",\n\t\tWindowRestore: \"common:WindowRestore\",\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\n\t\tWindowShow: \"common:WindowShow\",\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\n\t\tWindowZoom: \"common:WindowZoom\",\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\n\t}),\n});\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Logs a message to the console with custom formatting.\n *\n * @param message - The message to be logged.\n */\nexport function debugLog(message: any) {\n    // eslint-disable-next-line\n    console.log(\n        '%c wails3 %c ' + message + ' ',\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\n    );\n}\n\n/**\n * Checks whether the webview supports the {@link MouseEvent#buttons} property.\n * Looking at you macOS High Sierra!\n */\nexport function canTrackButtons(): boolean {\n    return (new MouseEvent('mousedown')).buttons === 0;\n}\n\n/**\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal).\n */\nexport function canAbortListeners() {\n    if (!EventTarget || !AbortSignal || !AbortController)\n        return false;\n\n    let result = true;\n\n    const target = new EventTarget();\n    const controller = new AbortController();\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\n    controller.abort();\n    target.dispatchEvent(new CustomEvent('test'));\n\n    return result;\n}\n\n/**\n * Resolves the closest HTMLElement ancestor of an event's target.\n */\nexport function eventTarget(event: Event): HTMLElement {\n    if (event.target instanceof HTMLElement) {\n        return event.target;\n    } else if (!(event.target instanceof HTMLElement) && event.target instanceof Node) {\n        return event.target.parentElement ?? document.body;\n    } else {\n        return document.body;\n    }\n}\n\n/***\n This technique for proper load detection is taken from HTMX:\n\n BSD 2-Clause License\n\n Copyright (c) 2020, Big Sky Software\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n ***/\n\nlet isReady = false;\ndocument.addEventListener('DOMContentLoaded', () => { isReady = true });\n\nexport function whenReady(callback: () => void) {\n    if (isReady || document.readyState === 'complete') {\n        callback();\n    } else {\n        document.addEventListener('DOMContentLoaded', callback);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\nimport type { Screen } from \"./screens.js\";\n\n// Drop target constants\nconst DROP_TARGET_ATTRIBUTE = 'data-file-drop-target';\nconst DROP_TARGET_ACTIVE_CLASS = 'file-drop-target-active';\nlet currentDropTarget: Element | null = null;\n\nconst PositionMethod                    = 0;\nconst CenterMethod                      = 1;\nconst CloseMethod                       = 2;\nconst DisableSizeConstraintsMethod      = 3;\nconst EnableSizeConstraintsMethod       = 4;\nconst FocusMethod                       = 5;\nconst ForceReloadMethod                 = 6;\nconst FullscreenMethod                  = 7;\nconst GetScreenMethod                   = 8;\nconst GetZoomMethod                     = 9;\nconst HeightMethod                      = 10;\nconst HideMethod                        = 11;\nconst IsFocusedMethod                   = 12;\nconst IsFullscreenMethod                = 13;\nconst IsMaximisedMethod                 = 14;\nconst IsMinimisedMethod                 = 15;\nconst MaximiseMethod                    = 16;\nconst MinimiseMethod                    = 17;\nconst NameMethod                        = 18;\nconst OpenDevToolsMethod                = 19;\nconst RelativePositionMethod            = 20;\nconst ReloadMethod                      = 21;\nconst ResizableMethod                   = 22;\nconst RestoreMethod                     = 23;\nconst SetPositionMethod                 = 24;\nconst SetAlwaysOnTopMethod              = 25;\nconst SetBackgroundColourMethod         = 26;\nconst SetFramelessMethod                = 27;\nconst SetFullscreenButtonEnabledMethod  = 28;\nconst SetMaxSizeMethod                  = 29;\nconst SetMinSizeMethod                  = 30;\nconst SetRelativePositionMethod         = 31;\nconst SetResizableMethod                = 32;\nconst SetSizeMethod                     = 33;\nconst SetTitleMethod                    = 34;\nconst SetZoomMethod                     = 35;\nconst ShowMethod                        = 36;\nconst SizeMethod                        = 37;\nconst ToggleFullscreenMethod            = 38;\nconst ToggleMaximiseMethod              = 39;\nconst ToggleFramelessMethod             = 40; \nconst UnFullscreenMethod                = 41;\nconst UnMaximiseMethod                  = 42;\nconst UnMinimiseMethod                  = 43;\nconst WidthMethod                       = 44;\nconst ZoomMethod                        = 45;\nconst ZoomInMethod                      = 46;\nconst ZoomOutMethod                     = 47;\nconst ZoomResetMethod                   = 48;\nconst SnapAssistMethod                  = 49;\nconst FilesDropped                      = 50;\nconst PrintMethod                       = 51;\n\n/**\n * Finds the nearest drop target element by walking up the DOM tree.\n */\nfunction getDropTargetElement(element: Element | null): Element | null {\n    if (!element) {\n        return null;\n    }\n    return element.closest(`[${DROP_TARGET_ATTRIBUTE}]`);\n}\n\n/**\n * Check if we can use WebView2's postMessageWithAdditionalObjects (Windows)\n * Also checks that EnableFileDrop is true for this window.\n */\nfunction canResolveFilePaths(): boolean {\n    // Must have WebView2's postMessageWithAdditionalObjects API (Windows only)\n    if ((window as any).chrome?.webview?.postMessageWithAdditionalObjects == null) {\n        return false;\n    }\n    // Must have EnableFileDrop set to true for this window\n    // This flag is set by the Go backend during runtime initialization\n    return (window as any)._wails?.flags?.enableFileDrop === true;\n}\n\n/**\n * Send file drop to backend via WebView2 (Windows only)\n */\nfunction resolveFilePaths(x: number, y: number, files: File[]): void {\n    if ((window as any).chrome?.webview?.postMessageWithAdditionalObjects) {\n        (window as any).chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files);\n    }\n}\n\n// Native drag state (Linux/macOS intercept DOM drag events)\nlet nativeDragActive = false;\n\n/**\n * Cleans up native drag state and hover effects.\n * Called on drop or when drag leaves the window.\n */\nfunction cleanupNativeDrag(): void {\n    nativeDragActive = false;\n    if (currentDropTarget) {\n        currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        currentDropTarget = null;\n    }\n}\n\n/**\n * Called from Go when a file drag enters the window on Linux/macOS.\n */\nfunction handleDragEnter(): void {\n    // Check if file drops are enabled for this window\n    if ((window as any)._wails?.flags?.enableFileDrop === false) {\n        return; // File drops disabled, don't activate drag state\n    }\n    nativeDragActive = true;\n}\n\n/**\n * Called from Go when a file drag leaves the window on Linux/macOS.\n */\nfunction handleDragLeave(): void {\n    cleanupNativeDrag();\n}\n\n/**\n * Called from Go during file drag to update hover state on Linux/macOS.\n * @param x - X coordinate in CSS pixels\n * @param y - Y coordinate in CSS pixels\n */\nfunction handleDragOver(x: number, y: number): void {\n    if (!nativeDragActive) return;\n    \n    // Check if file drops are enabled for this window\n    if ((window as any)._wails?.flags?.enableFileDrop === false) {\n        return; // File drops disabled, don't show hover effects\n    }\n    \n    const targetElement = document.elementFromPoint(x, y);\n    const dropTarget = getDropTargetElement(targetElement);\n    \n    if (currentDropTarget && currentDropTarget !== dropTarget) {\n        currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n    }\n    \n    if (dropTarget) {\n        dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n        currentDropTarget = dropTarget;\n    } else {\n        currentDropTarget = null;\n    }\n}\n\n\n\n// Export the handlers for use by Go via index.ts\nexport { handleDragEnter, handleDragLeave, handleDragOver };\n\n/**\n * A record describing the position of a window.\n */\ninterface Position {\n    /** The horizontal position of the window. */\n    x: number;\n    /** The vertical position of the window. */\n    y: number;\n}\n\n/**\n * A record describing the size of a window.\n */\ninterface Size {\n    /** The width of the window. */\n    width: number;\n    /** The height of the window. */\n    height: number;\n}\n\n// Private field names.\nconst callerSym = Symbol(\"caller\");\n\nclass Window {\n    // Private fields.\n    private [callerSym]: (message: number, args?: any) => Promise<any>;\n\n    /**\n     * Initialises a window object with the specified name.\n     *\n     * @private\n     * @param name - The name of the target window.\n     */\n    constructor(name: string = '') {\n        this[callerSym] = newRuntimeCaller(objectNames.Window, name)\n\n        // bind instance method to make them easily usable in event handlers\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\n            if (\n                method !== \"constructor\"\n                && typeof (this as any)[method] === \"function\"\n            ) {\n                (this as any)[method] = (this as any)[method].bind(this);\n            }\n        }\n    }\n\n    /**\n     * Gets the specified window.\n     *\n     * @param name - The name of the window to get.\n     * @returns The corresponding window object.\n     */\n    Get(name: string): Window {\n        return new Window(name);\n    }\n\n    /**\n     * Returns the absolute position of the window.\n     *\n     * @returns The current absolute position of the window.\n     */\n    Position(): Promise<Position> {\n        return this[callerSym](PositionMethod);\n    }\n\n    /**\n     * Centers the window on the screen.\n     */\n    Center(): Promise<void> {\n        return this[callerSym](CenterMethod);\n    }\n\n    /**\n     * Closes the window.\n     */\n    Close(): Promise<void> {\n        return this[callerSym](CloseMethod);\n    }\n\n    /**\n     * Disables min/max size constraints.\n     */\n    DisableSizeConstraints(): Promise<void> {\n        return this[callerSym](DisableSizeConstraintsMethod);\n    }\n\n    /**\n     * Enables min/max size constraints.\n     */\n    EnableSizeConstraints(): Promise<void> {\n        return this[callerSym](EnableSizeConstraintsMethod);\n    }\n\n    /**\n     * Focuses the window.\n     */\n    Focus(): Promise<void> {\n        return this[callerSym](FocusMethod);\n    }\n\n    /**\n     * Forces the window to reload the page assets.\n     */\n    ForceReload(): Promise<void> {\n        return this[callerSym](ForceReloadMethod);\n    }\n\n    /**\n     * Switches the window to fullscreen mode.\n     */\n    Fullscreen(): Promise<void> {\n        return this[callerSym](FullscreenMethod);\n    }\n\n    /**\n     * Returns the screen that the window is on.\n     *\n     * @returns The screen the window is currently on.\n     */\n    GetScreen(): Promise<Screen> {\n        return this[callerSym](GetScreenMethod);\n    }\n\n    /**\n     * Returns the current zoom level of the window.\n     *\n     * @returns The current zoom level.\n     */\n    GetZoom(): Promise<number> {\n        return this[callerSym](GetZoomMethod);\n    }\n\n    /**\n     * Returns the height of the window.\n     *\n     * @returns The current height of the window.\n     */\n    Height(): Promise<number> {\n        return this[callerSym](HeightMethod);\n    }\n\n    /**\n     * Hides the window.\n     */\n    Hide(): Promise<void> {\n        return this[callerSym](HideMethod);\n    }\n\n    /**\n     * Returns true if the window is focused.\n     *\n     * @returns Whether the window is currently focused.\n     */\n    IsFocused(): Promise<boolean> {\n        return this[callerSym](IsFocusedMethod);\n    }\n\n    /**\n     * Returns true if the window is fullscreen.\n     *\n     * @returns Whether the window is currently fullscreen.\n     */\n    IsFullscreen(): Promise<boolean> {\n        return this[callerSym](IsFullscreenMethod);\n    }\n\n    /**\n     * Returns true if the window is maximised.\n     *\n     * @returns Whether the window is currently maximised.\n     */\n    IsMaximised(): Promise<boolean> {\n        return this[callerSym](IsMaximisedMethod);\n    }\n\n    /**\n     * Returns true if the window is minimised.\n     *\n     * @returns Whether the window is currently minimised.\n     */\n    IsMinimised(): Promise<boolean> {\n        return this[callerSym](IsMinimisedMethod);\n    }\n\n    /**\n     * Maximises the window.\n     */\n    Maximise(): Promise<void> {\n        return this[callerSym](MaximiseMethod);\n    }\n\n    /**\n     * Minimises the window.\n     */\n    Minimise(): Promise<void> {\n        return this[callerSym](MinimiseMethod);\n    }\n\n    /**\n     * Returns the name of the window.\n     *\n     * @returns The name of the window.\n     */\n    Name(): Promise<string> {\n        return this[callerSym](NameMethod);\n    }\n\n    /**\n     * Opens the development tools pane.\n     */\n    OpenDevTools(): Promise<void> {\n        return this[callerSym](OpenDevToolsMethod);\n    }\n\n    /**\n     * Returns the relative position of the window to the screen.\n     *\n     * @returns The current relative position of the window.\n     */\n    RelativePosition(): Promise<Position> {\n        return this[callerSym](RelativePositionMethod);\n    }\n\n    /**\n     * Reloads the page assets.\n     */\n    Reload(): Promise<void> {\n        return this[callerSym](ReloadMethod);\n    }\n\n    /**\n     * Returns true if the window is resizable.\n     *\n     * @returns Whether the window is currently resizable.\n     */\n    Resizable(): Promise<boolean> {\n        return this[callerSym](ResizableMethod);\n    }\n\n    /**\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\n     */\n    Restore(): Promise<void> {\n        return this[callerSym](RestoreMethod);\n    }\n\n    /**\n     * Sets the absolute position of the window.\n     *\n     * @param x - The desired horizontal absolute position of the window.\n     * @param y - The desired vertical absolute position of the window.\n     */\n    SetPosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetPositionMethod, { x, y });\n    }\n\n    /**\n     * Sets the window to be always on top.\n     *\n     * @param alwaysOnTop - Whether the window should stay on top.\n     */\n    SetAlwaysOnTop(alwaysOnTop: boolean): Promise<void> {\n        return this[callerSym](SetAlwaysOnTopMethod, { alwaysOnTop });\n    }\n\n    /**\n     * Sets the background colour of the window.\n     *\n     * @param r - The desired red component of the window background.\n     * @param g - The desired green component of the window background.\n     * @param b - The desired blue component of the window background.\n     * @param a - The desired alpha component of the window background.\n     */\n    SetBackgroundColour(r: number, g: number, b: number, a: number): Promise<void> {\n        return this[callerSym](SetBackgroundColourMethod, { r, g, b, a });\n    }\n\n    /**\n     * Removes the window frame and title bar.\n     *\n     * @param frameless - Whether the window should be frameless.\n     */\n    SetFrameless(frameless: boolean): Promise<void> {\n        return this[callerSym](SetFramelessMethod, { frameless });\n    }\n\n    /**\n     * Disables the system fullscreen button.\n     *\n     * @param enabled - Whether the fullscreen button should be enabled.\n     */\n    SetFullscreenButtonEnabled(enabled: boolean): Promise<void> {\n        return this[callerSym](SetFullscreenButtonEnabledMethod, { enabled });\n    }\n\n    /**\n     * Sets the maximum size of the window.\n     *\n     * @param width - The desired maximum width of the window.\n     * @param height - The desired maximum height of the window.\n     */\n    SetMaxSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMaxSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the minimum size of the window.\n     *\n     * @param width - The desired minimum width of the window.\n     * @param height - The desired minimum height of the window.\n     */\n    SetMinSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMinSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the relative position of the window to the screen.\n     *\n     * @param x - The desired horizontal relative position of the window.\n     * @param y - The desired vertical relative position of the window.\n     */\n    SetRelativePosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetRelativePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets whether the window is resizable.\n     *\n     * @param resizable - Whether the window should be resizable.\n     */\n    SetResizable(resizable: boolean): Promise<void> {\n        return this[callerSym](SetResizableMethod, { resizable });\n    }\n\n    /**\n     * Sets the size of the window.\n     *\n     * @param width - The desired width of the window.\n     * @param height - The desired height of the window.\n     */\n    SetSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the title of the window.\n     *\n     * @param title - The desired title of the window.\n     */\n    SetTitle(title: string): Promise<void> {\n        return this[callerSym](SetTitleMethod, { title });\n    }\n\n    /**\n     * Sets the zoom level of the window.\n     *\n     * @param zoom - The desired zoom level.\n     */\n    SetZoom(zoom: number): Promise<void> {\n        return this[callerSym](SetZoomMethod, { zoom });\n    }\n\n    /**\n     * Shows the window.\n     */\n    Show(): Promise<void> {\n        return this[callerSym](ShowMethod);\n    }\n\n    /**\n     * Returns the size of the window.\n     *\n     * @returns The current size of the window.\n     */\n    Size(): Promise<Size> {\n        return this[callerSym](SizeMethod);\n    }\n\n    /**\n     * Toggles the window between fullscreen and normal.\n     */\n    ToggleFullscreen(): Promise<void> {\n        return this[callerSym](ToggleFullscreenMethod);\n    }\n\n    /**\n     * Toggles the window between maximised and normal.\n     */\n    ToggleMaximise(): Promise<void> {\n        return this[callerSym](ToggleMaximiseMethod);\n    }\n\n    /**\n     * Toggles the window between frameless and normal.\n     */\n    ToggleFrameless(): Promise<void> {\n        return this[callerSym](ToggleFramelessMethod);\n    }\n\n    /**\n     * Un-fullscreens the window.\n     */\n    UnFullscreen(): Promise<void> {\n        return this[callerSym](UnFullscreenMethod);\n    }\n\n    /**\n     * Un-maximises the window.\n     */\n    UnMaximise(): Promise<void> {\n        return this[callerSym](UnMaximiseMethod);\n    }\n\n    /**\n     * Un-minimises the window.\n     */\n    UnMinimise(): Promise<void> {\n        return this[callerSym](UnMinimiseMethod);\n    }\n\n    /**\n     * Returns the width of the window.\n     *\n     * @returns The current width of the window.\n     */\n    Width(): Promise<number> {\n        return this[callerSym](WidthMethod);\n    }\n\n    /**\n     * Zooms the window.\n     */\n    Zoom(): Promise<void> {\n        return this[callerSym](ZoomMethod);\n    }\n\n    /**\n     * Increases the zoom level of the webview content.\n     */\n    ZoomIn(): Promise<void> {\n        return this[callerSym](ZoomInMethod);\n    }\n\n    /**\n     * Decreases the zoom level of the webview content.\n     */\n    ZoomOut(): Promise<void> {\n        return this[callerSym](ZoomOutMethod);\n    }\n\n    /**\n     * Resets the zoom level of the webview content.\n     */\n    ZoomReset(): Promise<void> {\n        return this[callerSym](ZoomResetMethod);\n    }\n\n    /**\n     * Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop).\n     * Gathers information about the drop target element and sends it back to the Go backend.\n     *\n     * @param filenames - An array of file paths (strings) that were dropped.\n     * @param x - The x-coordinate of the drop event (CSS pixels).\n     * @param y - The y-coordinate of the drop event (CSS pixels).\n     */\n    HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\n        // Check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return; // File drops disabled, ignore the drop\n        }\n        \n        const element = document.elementFromPoint(x, y);\n        const dropTarget = getDropTargetElement(element);\n\n        if (!dropTarget) {\n            // Drop was not on a designated drop target - ignore\n            return;\n        }\n\n        const elementDetails = {\n            id: dropTarget.id,\n            classList: Array.from(dropTarget.classList),\n            attributes: {} as { [key: string]: string },\n        };\n        for (let i = 0; i < dropTarget.attributes.length; i++) {\n            const attr = dropTarget.attributes[i];\n            elementDetails.attributes[attr.name] = attr.value;\n        }\n\n        const payload = {\n            filenames,\n            x,\n            y,\n            elementDetails,\n        };\n\n        this[callerSym](FilesDropped, payload);\n        \n        // Clean up native drag state after drop\n        cleanupNativeDrag();\n    }\n  \n    /* Triggers Windows 11 Snap Assist feature (Windows only).\n     * This is equivalent to pressing Win+Z and shows snap layout options.\n     */\n    SnapAssist(): Promise<void> {\n        return this[callerSym](SnapAssistMethod);\n    }\n\n    /**\n     * Opens the print dialog for the window.\n     */\n    Print(): Promise<void> {\n        return this[callerSym](PrintMethod);\n    }\n}\n\n/**\n * The window within which the script is running.\n */\nconst thisWindow = new Window('');\n\n/**\n * Sets up global drag and drop event listeners for file drops.\n * Handles visual feedback (hover state) and file drop processing.\n */\nfunction setupDropTargetListeners() {\n    const docElement = document.documentElement;\n    let dragEnterCounter = 0;\n\n    docElement.addEventListener('dragenter', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drags, let other drags pass through\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            event.dataTransfer.dropEffect = 'none'; // Show \"no drop\" cursor\n            return; // File drops disabled, don't show hover effects\n        }\n        dragEnterCounter++;\n        \n        const targetElement = document.elementFromPoint(event.clientX, event.clientY);\n        const dropTarget = getDropTargetElement(targetElement);\n\n        // Update hover state\n        if (currentDropTarget && currentDropTarget !== dropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        }\n\n        if (dropTarget) {\n            dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n            event.dataTransfer.dropEffect = 'copy';\n            currentDropTarget = dropTarget;\n        } else {\n            event.dataTransfer.dropEffect = 'none';\n            currentDropTarget = null;\n        }\n    }, false);\n\n    docElement.addEventListener('dragover', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drags\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            event.dataTransfer.dropEffect = 'none'; // Show \"no drop\" cursor\n            return; // File drops disabled, don't show hover effects\n        }\n        \n        // Update drop target as cursor moves\n        const targetElement = document.elementFromPoint(event.clientX, event.clientY);\n        const dropTarget = getDropTargetElement(targetElement);\n        \n        if (currentDropTarget && currentDropTarget !== dropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        }\n        \n        if (dropTarget) {\n            if (!dropTarget.classList.contains(DROP_TARGET_ACTIVE_CLASS)) {\n                dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n            }\n            event.dataTransfer.dropEffect = 'copy';\n            currentDropTarget = dropTarget;\n        } else {\n            event.dataTransfer.dropEffect = 'none';\n            currentDropTarget = null;\n        }\n    }, false);\n\n    docElement.addEventListener('dragleave', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return;\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return;\n        }\n        \n        // On Linux/WebKitGTK and macOS, dragleave fires immediately with relatedTarget=null when native\n        // drag handling is involved. Ignore these spurious events - we'll clean up on drop instead.\n        if (event.relatedTarget === null) {\n            return;\n        }\n        \n        dragEnterCounter--;\n        \n        if (dragEnterCounter === 0 || \n            (currentDropTarget && !currentDropTarget.contains(event.relatedTarget as Node))) {\n            if (currentDropTarget) {\n                currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n                currentDropTarget = null;\n            }\n            dragEnterCounter = 0;\n        }\n    }, false);\n\n    docElement.addEventListener('drop', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drops\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return;\n        }\n        dragEnterCounter = 0;\n        \n        if (currentDropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n            currentDropTarget = null;\n        }\n\n        // On Windows, handle file drops via JavaScript\n        // On macOS/Linux, native code will call HandlePlatformFileDrop\n        if (canResolveFilePaths()) {\n            const files: File[] = [];\n            if (event.dataTransfer.items) {\n                for (const item of event.dataTransfer.items) {\n                    if (item.kind === 'file') {\n                        const file = item.getAsFile();\n                        if (file) files.push(file);\n                    }\n                }\n            } else if (event.dataTransfer.files) {\n                for (const file of event.dataTransfer.files) {\n                    files.push(file);\n                }\n            }\n            \n            if (files.length > 0) {\n                resolveFilePaths(event.clientX, event.clientY, files);\n            }\n        }\n    }, false);\n}\n\n// Initialize listeners when the script loads\nif (typeof window !== \"undefined\" && typeof document !== \"undefined\") {\n    setupDropTargetListeners();\n}\n\nexport default thisWindow;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport * as Runtime from \"../@wailsio/runtime/src\";\n\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\nimport { Enable as EnableWML } from \"../@wailsio/runtime/src/wml\";\nimport { debugLog } from \"../@wailsio/runtime/src/utils\";\n\nwindow.wails = Runtime;\nEnableWML();\n\nif (DEBUG) {\n    debugLog(\"Wails Runtime Loaded\")\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.System);\n\nconst SystemIsDarkMode = 0;\nconst SystemEnvironment = 1;\nconst SystemCapabilities = 2;\n\nconst _invoke = (function () {\n    try {\n        // Windows WebView2\n        if ((window as any).chrome?.webview?.postMessage) {\n            return (window as any).chrome.webview.postMessage.bind((window as any).chrome.webview);\n        }\n        // macOS/iOS WKWebView\n        else if ((window as any).webkit?.messageHandlers?.['external']?.postMessage) {\n            return (window as any).webkit.messageHandlers['external'].postMessage.bind((window as any).webkit.messageHandlers['external']);\n        }\n        // Android WebView - uses addJavascriptInterface which exposes window.wails.invoke\n        else if ((window as any).wails?.invoke) {\n            return (msg: any) => (window as any).wails.invoke(typeof msg === 'string' ? msg : JSON.stringify(msg));\n        }\n    } catch(e) {}\n\n    console.warn('\\n%c\u26A0\uFE0F Browser Environment Detected %c\\n\\n%cOnly UI previews are available in the browser. For full functionality, please run the application in desktop mode.\\nMore information at: https://v3.wails.io/learn/build/#using-a-browser-for-development\\n',\n        'background: #ffffff; color: #000000; font-weight: bold; padding: 4px 8px; border-radius: 4px; border: 2px solid #000000;',\n        'background: transparent;',\n        'color: #ffffff; font-style: italic; font-weight: bold;');\n    return null;\n})();\n\nexport function invoke(msg: any): void {\n    _invoke?.(msg);\n}\n\n/**\n * Retrieves the system dark mode status.\n *\n * @returns A promise that resolves to a boolean value indicating if the system is in dark mode.\n */\nexport function IsDarkMode(): Promise<boolean> {\n    return call(SystemIsDarkMode);\n}\n\n/**\n * Fetches the capabilities of the application from the server.\n *\n * @returns A promise that resolves to an object containing the capabilities.\n */\nexport async function Capabilities(): Promise<Record<string, any>> {\n    return call(SystemCapabilities);\n}\n\nexport interface OSInfo {\n    /** The branding of the OS. */\n    Branding: string;\n    /** The ID of the OS. */\n    ID: string;\n    /** The name of the OS. */\n    Name: string;\n    /** The version of the OS. */\n    Version: string;\n}\n\nexport interface EnvironmentInfo {\n    /** The architecture of the system. */\n    Arch: string;\n    /** True if the application is running in debug mode, otherwise false. */\n    Debug: boolean;\n    /** The operating system in use. */\n    OS: string;\n    /** Details of the operating system. */\n    OSInfo: OSInfo;\n    /** Additional platform information. */\n    PlatformInfo: Record<string, any>;\n}\n\n/**\n * Retrieves environment details.\n *\n * @returns A promise that resolves to an object containing OS and system architecture.\n */\nexport function Environment(): Promise<EnvironmentInfo> {\n    return call(SystemEnvironment);\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @return True if the operating system is Windows, otherwise false.\n */\nexport function IsWindows(): boolean {\n    return (window as any)._wails?.environment?.OS === \"windows\";\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns Returns true if the current operating system is Linux, false otherwise.\n */\nexport function IsLinux(): boolean {\n    return (window as any)._wails?.environment?.OS === \"linux\";\n}\n\n/**\n * Checks if the current environment is a macOS operating system.\n *\n * @returns True if the environment is macOS, false otherwise.\n */\nexport function IsMac(): boolean {\n    return (window as any)._wails?.environment?.OS === \"darwin\";\n}\n\n/**\n * Checks if the current environment architecture is AMD64.\n *\n * @returns True if the current environment architecture is AMD64, false otherwise.\n */\nexport function IsAMD64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"amd64\";\n}\n\n/**\n * Checks if the current architecture is ARM.\n *\n * @returns True if the current architecture is ARM, false otherwise.\n */\nexport function IsARM(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm\";\n}\n\n/**\n * Checks if the current environment is ARM64 architecture.\n *\n * @returns Returns true if the environment is ARM64 architecture, otherwise returns false.\n */\nexport function IsARM64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm64\";\n}\n\n/**\n * Reports whether the app is being run in debug mode.\n *\n * @returns True if the app is being run in debug mode.\n */\nexport function IsDebug(): boolean {\n    return Boolean((window as any)._wails?.environment?.Debug);\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { IsDebug } from \"./system.js\";\nimport { eventTarget } from \"./utils.js\";\n\n// setup\nwindow.addEventListener('contextmenu', contextMenuHandler);\n\nconst call = newRuntimeCaller(objectNames.ContextMenu);\n\nconst ContextMenuOpen = 0;\n\nfunction openContextMenu(id: string, x: number, y: number, data: any): void {\n    void call(ContextMenuOpen, {id, x, y, data});\n}\n\nfunction contextMenuHandler(event: MouseEvent) {\n    const target = eventTarget(event);\n\n    // Check for custom context menu\n    const customContextMenu = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu\").trim();\n\n    if (customContextMenu) {\n        event.preventDefault();\n        const data = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu-data\");\n        openContextMenu(customContextMenu, event.clientX, event.clientY, data);\n    } else {\n        processDefaultContextMenu(event, target);\n    }\n}\n\n\n/*\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\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nfunction processDefaultContextMenu(event: MouseEvent, target: HTMLElement) {\n    // Debug builds always show the menu\n    if (IsDebug()) {\n        return;\n    }\n\n    // Process default context menu\n    switch (window.getComputedStyle(target).getPropertyValue(\"--default-contextmenu\").trim()) {\n        case 'show':\n            return;\n        case 'hide':\n            event.preventDefault();\n            return;\n    }\n\n    // Check if contentEditable is true\n    if (target.isContentEditable) {\n        return;\n    }\n\n    // Check if text has been selected\n    const selection = window.getSelection();\n    const hasSelection = selection && selection.toString().length > 0;\n    if (hasSelection) {\n        for (let i = 0; i < selection.rangeCount; i++) {\n            const range = selection.getRangeAt(i);\n            const rects = range.getClientRects();\n            for (let j = 0; j < rects.length; j++) {\n                const rect = rects[j];\n                if (document.elementFromPoint(rect.left, rect.top) === target) {\n                    return;\n                }\n            }\n        }\n    }\n\n    // Check if tag is input or textarea.\n    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {\n        if (hasSelection || (!target.readOnly && !target.disabled)) {\n            return;\n        }\n    }\n\n    // hide default context menu\n    event.preventDefault();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Retrieves the value associated with the specified key from the flag map.\n *\n * @param key - The key to retrieve the value for.\n * @return The value associated with the specified key.\n */\nexport function GetFlag(key: string): any {\n    try {\n        return window._wails.flags[key];\n    } catch (e) {\n        throw new Error(\"Unable to retrieve flag '\" + key + \"': \" + e, { cause: e });\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { invoke, IsWindows } from \"./system.js\";\nimport { GetFlag } from \"./flags.js\";\nimport { canTrackButtons, eventTarget } from \"./utils.js\";\n\n// Setup\nlet canDrag = false;\nlet dragging = false;\n\nlet resizable = false;\nlet canResize = false;\nlet resizing = false;\nlet resizeEdge: string = \"\";\nlet defaultCursor = \"auto\";\n\nlet buttons = 0;\nconst buttonsTracked = canTrackButtons();\n\nwindow._wails = window._wails || {};\nwindow._wails.setResizable = (value: boolean): void => {\n    resizable = value;\n    if (!resizable) {\n        // Stop resizing if in progress.\n        canResize = resizing = false;\n        setResize();\n    }\n};\n\n// Defer attaching mouse listeners until we know we're not on mobile.\nlet dragInitDone = false;\nfunction isMobile(): boolean {\n    const os = (window as any)._wails?.environment?.OS;\n    if (os === \"ios\" || os === \"android\") return true;\n    // Fallback heuristic if environment not yet set\n    const ua = navigator.userAgent || navigator.vendor || (window as any).opera || \"\";\n    return /android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(ua);\n}\nfunction tryInitDragHandlers(): void {\n    if (dragInitDone) return;\n    if (isMobile()) return;\n    window.addEventListener('mousedown', update, { capture: true });\n    window.addEventListener('mousemove', update, { capture: true });\n    window.addEventListener('mouseup', update, { capture: true });\n    for (const ev of ['click', 'contextmenu', 'dblclick']) {\n        window.addEventListener(ev, suppressEvent, { capture: true });\n    }\n    dragInitDone = true;\n}\n// Attempt immediate init (in case environment already present)\ntryInitDragHandlers();\n// Also attempt on DOM ready\ndocument.addEventListener('DOMContentLoaded', tryInitDragHandlers, { once: true });\n// As a last resort, poll for environment for a short period\nlet dragEnvPolls = 0;\nconst dragEnvPoll = window.setInterval(() => {\n    if (dragInitDone) { window.clearInterval(dragEnvPoll); return; }\n    tryInitDragHandlers();\n    if (++dragEnvPolls > 100) { window.clearInterval(dragEnvPoll); }\n}, 50);\n\nfunction suppressEvent(event: Event) {\n    // Suppress click events while resizing or dragging.\n    if (dragging || resizing) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n}\n\n// Use constants to avoid comparing strings multiple times.\nconst MouseDown = 0;\nconst MouseUp   = 1;\nconst MouseMove = 2;\n\nfunction update(event: MouseEvent) {\n    // Windows suppresses mouse events at the end of dragging or resizing,\n    // so we need to be smart and synthesize button events.\n\n    let eventType: number, eventButtons = event.buttons;\n    switch (event.type) {\n        case 'mousedown':\n            eventType = MouseDown;\n            if (!buttonsTracked) { eventButtons = buttons | (1 << event.button); }\n            break;\n        case 'mouseup':\n            eventType = MouseUp;\n            if (!buttonsTracked) { eventButtons = buttons & ~(1 << event.button); }\n            break;\n        default:\n            eventType = MouseMove;\n            if (!buttonsTracked) { eventButtons = buttons; }\n            break;\n    }\n\n    let released = buttons & ~eventButtons;\n    let pressed = eventButtons & ~buttons;\n\n    buttons = eventButtons;\n\n    // Synthesize a release-press sequence if we detect a press of an already pressed button.\n    if (eventType === MouseDown && !(pressed & event.button)) {\n        released |= (1 << event.button);\n        pressed |= (1 << event.button);\n    }\n\n    // Suppress all button events during dragging and resizing,\n    // unless this is a mouseup event that is ending a drag action.\n    if (\n        eventType !== MouseMove // Fast path for mousemove\n        && resizing\n        || (\n            dragging\n            && (\n                eventType === MouseDown\n                || event.button !== 0\n            )\n        )\n    ) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n\n    // Handle releases\n    if (released & 1) { primaryUp(event); }\n    // Handle presses\n    if (pressed & 1) { primaryDown(event); }\n\n    // Handle mousemove\n    if (eventType === MouseMove) { onMouseMove(event); };\n}\n\nfunction primaryDown(event: MouseEvent): void {\n    // Reset readiness state.\n    canDrag = false;\n    canResize = false;\n\n    // Ignore repeated clicks on macOS and Linux.\n    if (!IsWindows()) {\n        if (event.type === 'mousedown' && event.button === 0 && event.detail !== 1) {\n            return;\n        }\n    }\n\n    if (resizeEdge) {\n        // Ready to resize if the primary button was pressed for the first time.\n        canResize = true;\n        // Do not start drag operations when on resize edges.\n        return;\n    }\n\n    // Retrieve target element\n    const target = eventTarget(event);\n\n    // Ready to drag if the primary button was pressed for the first time on a draggable element.\n    // Ignore clicks on the scrollbar.\n    const style = window.getComputedStyle(target);\n    canDrag = (\n        style.getPropertyValue(\"--wails-draggable\").trim() === \"drag\"\n        && (\n            event.offsetX - parseFloat(style.paddingLeft) < target.clientWidth\n            && event.offsetY - parseFloat(style.paddingTop) < target.clientHeight\n        )\n    );\n}\n\nfunction primaryUp(event: MouseEvent) {\n    // Stop dragging and resizing.\n    canDrag = false;\n    dragging = false;\n    canResize = false;\n    resizing = false;\n}\n\nconst cursorForEdge = Object.freeze({\n    \"se-resize\": \"nwse-resize\",\n    \"sw-resize\": \"nesw-resize\",\n    \"nw-resize\": \"nwse-resize\",\n    \"ne-resize\": \"nesw-resize\",\n    \"w-resize\": \"ew-resize\",\n    \"n-resize\": \"ns-resize\",\n    \"s-resize\": \"ns-resize\",\n    \"e-resize\": \"ew-resize\",\n})\n\nfunction setResize(edge?: keyof typeof cursorForEdge): void {\n    if (edge) {\n        if (!resizeEdge) { defaultCursor = document.body.style.cursor; }\n        document.body.style.cursor = cursorForEdge[edge];\n    } else if (!edge && resizeEdge) {\n        document.body.style.cursor = defaultCursor;\n    }\n\n    resizeEdge = edge || \"\";\n}\n\nfunction onMouseMove(event: MouseEvent): void {\n    if (canResize && resizeEdge) {\n        // Start resizing.\n        resizing = true;\n        invoke(\"wails:resize:\" + resizeEdge);\n    } else if (canDrag) {\n        // Start dragging.\n        dragging = true;\n        invoke(\"wails:drag\");\n    }\n\n    if (dragging || resizing) {\n        // Either drag or resize is ongoing,\n        // reset readiness and stop processing.\n        canDrag = canResize = false;\n        return;\n    }\n\n    if (!resizable || !IsWindows()) {\n        if (resizeEdge) { setResize(); }\n        return;\n    }\n\n    const resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\n    const resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\n\n    // Extra pixels for the corner areas.\n    const cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\n\n    const rightBorder = (window.outerWidth - event.clientX) < resizeHandleWidth;\n    const leftBorder = event.clientX < resizeHandleWidth;\n    const topBorder = event.clientY < resizeHandleHeight;\n    const bottomBorder = (window.outerHeight - event.clientY) < resizeHandleHeight;\n\n    // Adjust for corner areas.\n    const rightCorner = (window.outerWidth - event.clientX) < (resizeHandleWidth + cornerExtra);\n    const leftCorner = event.clientX < (resizeHandleWidth + cornerExtra);\n    const topCorner = event.clientY < (resizeHandleHeight + cornerExtra);\n    const bottomCorner = (window.outerHeight - event.clientY) < (resizeHandleHeight + cornerExtra);\n\n    if (!leftCorner && !topCorner && !bottomCorner && !rightCorner) {\n        // Optimisation: out of all corner areas implies out of borders.\n        setResize();\n    }\n    // Detect corners.\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\n    // Detect borders.\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n    // Out of border area.\n    else setResize();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Application);\n\nconst HideMethod = 0;\nconst ShowMethod = 1;\nconst QuitMethod = 2;\n\n/**\n * Hides a certain method by calling the HideMethod function.\n */\nexport function Hide(): Promise<void> {\n    return call(HideMethod);\n}\n\n/**\n * Calls the ShowMethod and returns the result.\n */\nexport function Show(): Promise<void> {\n    return call(ShowMethod);\n}\n\n/**\n * Calls the QuitMethod to terminate the program.\n */\nexport function Quit(): Promise<void> {\n    return call(QuitMethod);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { CancellablePromise, type CancellablePromiseWithResolvers } from \"./cancellable.js\";\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { nanoid } from \"./nanoid.js\";\n\n// Setup\nwindow._wails = window._wails || {};\n\ntype PromiseResolvers = Omit<CancellablePromiseWithResolvers<any>, \"promise\" | \"oncancelled\">\n\nconst call = newRuntimeCaller(objectNames.Call);\nconst cancelCall = newRuntimeCaller(objectNames.CancelCall);\nconst callResponses = new Map<string, PromiseResolvers>();\n\nconst CallBinding = 0;\nconst CancelMethod = 0\n\n/**\n * Holds all required information for a binding call.\n * May provide either a method ID or a method name, but not both.\n */\nexport type CallOptions = {\n    /** The numeric ID of the bound method to call. */\n    methodID: number;\n    /** The fully qualified name of the bound method to call. */\n    methodName?: never;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n} | {\n    /** The numeric ID of the bound method to call. */\n    methodID?: never;\n    /** The fully qualified name of the bound method to call. */\n    methodName: string;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n};\n\n/**\n * Exception class that will be thrown in case the bound method returns an error.\n * The value of the {@link RuntimeError#name} property is \"RuntimeError\".\n */\nexport class RuntimeError extends Error {\n    /**\n     * Constructs a new RuntimeError instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"RuntimeError\";\n    }\n}\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @returns A unique ID that does not exist in the callResponses set.\n */\nfunction generateID(): string {\n    let result;\n    do {\n        result = nanoid();\n    } while (callResponses.has(result));\n    return result;\n}\n\n/**\n * Call a bound method according to the given call options.\n *\n * In case of failure, the returned promise will reject with an exception\n * among ReferenceError (unknown method), TypeError (wrong argument count or type),\n * {@link RuntimeError} (method returned an error), or other (network or internal errors).\n * The exception might have a \"cause\" field with the value returned\n * by the application- or service-level error marshaling functions.\n *\n * @param options - A method call descriptor.\n * @returns The result of the call.\n */\nexport function Call(options: CallOptions): CancellablePromise<any> {\n    const id = generateID();\n\n    const result = CancellablePromise.withResolvers<any>();\n    callResponses.set(id, { resolve: result.resolve, reject: result.reject });\n\n    const request = call(CallBinding, Object.assign({ \"call-id\": id }, options));\n    let running = true;\n\n    request.then((res) => {\n        running = false;\n        callResponses.delete(id);\n        result.resolve(res);\n    }, (err) => {\n        running = false;\n        callResponses.delete(id);\n        result.reject(err);\n    });\n\n    const cancel = () => {\n        callResponses.delete(id);\n        return cancelCall(CancelMethod, {\"call-id\": id}).catch((err) => {\n            console.error(\"Error while requesting binding call cancellation:\", err);\n        });\n    };\n\n    result.oncancelled = () => {\n        if (running) {\n            return cancel();\n        } else {\n            return request.then(cancel);\n        }\n    };\n\n    return result.promise;\n}\n\n/**\n * Calls a bound method by name with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodName - The name of the method in the format 'package.struct.method'.\n * @param args - The arguments to pass to the method.\n * @returns The result of the method call.\n */\nexport function ByName(methodName: string, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodName, args });\n}\n\n/**\n * Calls a method by its numeric ID with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodID - The ID of the method to call.\n * @param args - The arguments to pass to the method.\n * @return The result of the method call.\n */\nexport function ByID(methodID: number, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodID, args });\n}\n", "// Source: https://github.com/inspect-js/is-callable\n\n// The MIT License (MIT)\n//\n// Copyright (c) 2015 Jordan Harband\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply: typeof Reflect.apply | false | null = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike: any;\nvar isCallableMarker: any;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n    try {\n        badArrayLike = Object.defineProperty({}, 'length', {\n            get: function () {\n                throw isCallableMarker;\n            }\n        });\n        isCallableMarker = {};\n        // eslint-disable-next-line no-throw-literal\n        reflectApply(function () { throw 42; }, null, badArrayLike);\n    } catch (_) {\n        if (_ !== isCallableMarker) {\n            reflectApply = null;\n        }\n    }\n} else {\n    reflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value: any): boolean {\n    try {\n        var fnStr = fnToStr.call(value);\n        return constructorRegex.test(fnStr);\n    } catch (e) {\n        return false; // not a function\n    }\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value: any): boolean {\n    try {\n        if (isES6ClassFn(value)) { return false; }\n        fnToStr.call(value);\n        return true;\n    } catch (e) {\n        return false;\n    }\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA: (value: any) => boolean = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n    // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n    var all = document.all;\n    if (toStr.call(all) === toStr.call(document.all)) {\n        isDDA = function isDocumentDotAll(value) {\n            /* globals document: false */\n            // in IE 6-8, typeof document.all is \"object\" and it's truthy\n            if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n                try {\n                    var str = toStr.call(value);\n                    return (\n                        str === ddaClass\n                        || str === ddaClass2\n                        || str === ddaClass3 // opera 12.16\n                        || str === objectClass // IE 6-8\n                    ) && value('') == null; // eslint-disable-line eqeqeq\n                } catch (e) { /**/ }\n            }\n            return false;\n        };\n    }\n}\n\nfunction isCallableRefApply<T>(value: T | unknown): value is (...args: any[]) => any  {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    try {\n        (reflectApply as any)(value, null, badArrayLike);\n    } catch (e) {\n        if (e !== isCallableMarker) { return false; }\n    }\n    return !isES6ClassFn(value) && tryFunctionObject(value);\n}\n\nfunction isCallableNoRefApply<T>(value: T | unknown): value is (...args: any[]) => any {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    if (hasToStringTag) { return tryFunctionObject(value); }\n    if (isES6ClassFn(value)) { return false; }\n    var strClass = toStr.call(value);\n    if (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n    return tryFunctionObject(value);\n};\n\nexport default reflectApply ? isCallableRefApply : isCallableNoRefApply;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport isCallable from \"./callable.js\";\n\n/**\n * Exception class that will be used as rejection reason\n * in case a {@link CancellablePromise} is cancelled successfully.\n *\n * The value of the {@link name} property is the string `\"CancelError\"`.\n * The value of the {@link cause} property is the cause passed to the cancel method, if any.\n */\nexport class CancelError extends Error {\n    /**\n     * Constructs a new `CancelError` instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CancelError\";\n    }\n}\n\n/**\n * Exception class that will be reported as an unhandled rejection\n * in case a {@link CancellablePromise} rejects after being cancelled,\n * or when the `oncancelled` callback throws or rejects.\n *\n * The value of the {@link name} property is the string `\"CancelledRejectionError\"`.\n * The value of the {@link cause} property is the reason the promise rejected with.\n *\n * Because the original promise was cancelled,\n * a wrapper promise will be passed to the unhandled rejection listener instead.\n * The {@link promise} property holds a reference to the original promise.\n */\nexport class CancelledRejectionError extends Error {\n    /**\n     * Holds a reference to the promise that was cancelled and then rejected.\n     */\n    promise: CancellablePromise<unknown>;\n\n    /**\n     * Constructs a new `CancelledRejectionError` instance.\n     * @param promise - The promise that caused the error originally.\n     * @param reason - The rejection reason.\n     * @param info - An optional informative message specifying the circumstances in which the error was thrown.\n     *               Defaults to the string `\"Unhandled rejection in cancelled promise.\"`.\n     */\n    constructor(promise: CancellablePromise<unknown>, reason?: any, info?: string) {\n        super((info ?? \"Unhandled rejection in cancelled promise.\") + \" Reason: \" + errorMessage(reason), { cause: reason });\n        this.promise = promise;\n        this.name = \"CancelledRejectionError\";\n    }\n}\n\ntype CancellablePromiseResolver<T> = (value: T | PromiseLike<T> | CancellablePromiseLike<T>) => void;\ntype CancellablePromiseRejector = (reason?: any) => void;\ntype CancellablePromiseCanceller = (cause?: any) => void | PromiseLike<void>;\ntype CancellablePromiseExecutor<T> = (resolve: CancellablePromiseResolver<T>, reject: CancellablePromiseRejector) => void;\n\nexport interface CancellablePromiseLike<T> {\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null): CancellablePromiseLike<TResult1 | TResult2>;\n    cancel(cause?: any): void | PromiseLike<void>;\n}\n\n/**\n * Wraps a cancellable promise along with its resolution methods.\n * The `oncancelled` field will be null initially but may be set to provide a custom cancellation function.\n */\nexport interface CancellablePromiseWithResolvers<T> {\n    promise: CancellablePromise<T>;\n    resolve: CancellablePromiseResolver<T>;\n    reject: CancellablePromiseRejector;\n    oncancelled: CancellablePromiseCanceller | null;\n}\n\ninterface CancellablePromiseState {\n    readonly root: CancellablePromiseState;\n    resolving: boolean;\n    settled: boolean;\n    reason?: CancelError;\n}\n\n// Private field names.\nconst barrierSym = Symbol(\"barrier\");\nconst cancelImplSym = Symbol(\"cancelImpl\");\nconst species: typeof Symbol.species = Symbol.species ?? Symbol(\"speciesPolyfill\");\n\n/**\n * A promise with an attached method for cancelling long-running operations (see {@link CancellablePromise#cancel}).\n * Cancellation can optionally be bound to an {@link AbortSignal}\n * for better composability (see {@link CancellablePromise#cancelOn}).\n *\n * Cancelling a pending promise will result in an immediate rejection\n * with an instance of {@link CancelError} as reason,\n * but whoever started the promise will be responsible\n * for actually aborting the underlying operation.\n * To this purpose, the constructor and all chaining methods\n * accept optional cancellation callbacks.\n *\n * If a `CancellablePromise` still resolves after having been cancelled,\n * the result will be discarded. If it rejects, the reason\n * will be reported as an unhandled rejection,\n * wrapped in a {@link CancelledRejectionError} instance.\n * To facilitate the handling of cancellation requests,\n * cancelled `CancellablePromise`s will _not_ report unhandled `CancelError`s\n * whose `cause` field is the same as the one with which the current promise was cancelled.\n *\n * All usual promise methods are defined and return a `CancellablePromise`\n * whose cancel method will cancel the parent operation as well, propagating the cancellation reason\n * upwards through promise chains.\n * Conversely, cancelling a promise will not automatically cancel dependent promises downstream:\n * ```ts\n * let root = new CancellablePromise((resolve, reject) => { ... });\n * let child1 = root.then(() => { ... });\n * let child2 = child1.then(() => { ... });\n * let child3 = root.catch(() => { ... });\n * child1.cancel(); // Cancels child1 and root, but not child2 or child3\n * ```\n * Cancelling a promise that has already settled is safe and has no consequence.\n *\n * The `cancel` method returns a promise that _always fulfills_\n * after the whole chain has processed the cancel request\n * and all attached callbacks up to that moment have run.\n *\n * All ES2024 promise methods (static and instance) are defined on CancellablePromise,\n * but actual availability may vary with OS/webview version.\n *\n * In line with the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing,\n * `CancellablePromise` does not support transparent subclassing.\n * Extenders should take care to provide their own method implementations.\n * This might be reconsidered in case the proposal is retired.\n *\n * CancellablePromise is a wrapper around the DOM Promise object\n * and is compliant with the [Promises/A+ specification](https://promisesaplus.com/)\n * (it passes the [compliance suite](https://github.com/promises-aplus/promises-tests))\n * if so is the underlying implementation.\n */\nexport class CancellablePromise<T> extends Promise<T> implements PromiseLike<T>, CancellablePromiseLike<T> {\n    // Private fields.\n    /** @internal */\n    private [barrierSym]!: Partial<PromiseWithResolvers<void>> | null;\n    /** @internal */\n    private readonly [cancelImplSym]!: (reason: CancelError) => void | PromiseLike<void>;\n\n    /**\n     * Creates a new `CancellablePromise`.\n     *\n     * @param executor - A callback used to initialize the promise. This callback is passed two arguments:\n     *                   a `resolve` callback used to resolve the promise with a value\n     *                   or the result of another promise (possibly cancellable),\n     *                   and a `reject` callback used to reject the promise with a provided reason or error.\n     *                   If the value provided to the `resolve` callback is a thenable _and_ cancellable object\n     *                   (it has a `then` _and_ a `cancel` method),\n     *                   cancellation requests will be forwarded to that object and the oncancelled will not be invoked anymore.\n     *                   If any one of the two callbacks is called _after_ the promise has been cancelled,\n     *                   the provided values will be cancelled and resolved as usual,\n     *                   but their results will be discarded.\n     *                   However, if the resolution process ultimately ends up in a rejection\n     *                   that is not due to cancellation, the rejection reason\n     *                   will be wrapped in a {@link CancelledRejectionError}\n     *                   and bubbled up as an unhandled rejection.\n     * @param oncancelled - It is the caller's responsibility to ensure that any operation\n     *                      started by the executor is properly halted upon cancellation.\n     *                      This optional callback can be used to that purpose.\n     *                      It will be called _synchronously_ with a cancellation cause\n     *                      when cancellation is requested, _after_ the promise has already rejected\n     *                      with a {@link CancelError}, but _before_\n     *                      any {@link then}/{@link catch}/{@link finally} callback runs.\n     *                      If the callback returns a thenable, the promise returned from {@link cancel}\n     *                      will only fulfill after the former has settled.\n     *                      Unhandled exceptions or rejections from the callback will be wrapped\n     *                      in a {@link CancelledRejectionError} and bubbled up as unhandled rejections.\n     *                      If the `resolve` callback is called before cancellation with a cancellable promise,\n     *                      cancellation requests on this promise will be diverted to that promise,\n     *                      and the original `oncancelled` callback will be discarded.\n     */\n    constructor(executor: CancellablePromiseExecutor<T>, oncancelled?: CancellablePromiseCanceller) {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        super((res, rej) => { resolve = res; reject = rej; });\n\n        if ((this.constructor as any)[species] !== Promise) {\n            throw new TypeError(\"CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.\");\n        }\n\n        let promise: CancellablePromiseWithResolvers<T> = {\n            promise: this,\n            resolve,\n            reject,\n            get oncancelled() { return oncancelled ?? null; },\n            set oncancelled(cb) { oncancelled = cb ?? undefined; }\n        };\n\n        const state: CancellablePromiseState = {\n            get root() { return state; },\n            resolving: false,\n            settled: false\n        };\n\n        // Setup cancellation system.\n        void Object.defineProperties(this, {\n            [barrierSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: true,\n                value: null\n            },\n            [cancelImplSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: false,\n                value: cancellerFor(promise, state)\n            }\n        });\n\n        // Run the actual executor.\n        const rejector = rejectorFor(promise, state);\n        try {\n            executor(resolverFor(promise, state), rejector);\n        } catch (err) {\n            if (state.resolving) {\n                console.log(\"Unhandled exception in CancellablePromise executor.\", err);\n            } else {\n                rejector(err);\n            }\n        }\n    }\n\n    /**\n     * Cancels immediately the execution of the operation associated with this promise.\n     * The promise rejects with a {@link CancelError} instance as reason,\n     * with the {@link CancelError#cause} property set to the given argument, if any.\n     *\n     * Has no effect if called after the promise has already settled;\n     * repeated calls in particular are safe, but only the first one\n     * will set the cancellation cause.\n     *\n     * The `CancelError` exception _need not_ be handled explicitly _on the promises that are being cancelled:_\n     * cancelling a promise with no attached rejection handler does not trigger an unhandled rejection event.\n     * Therefore, the following idioms are all equally correct:\n     * ```ts\n     * new CancellablePromise((resolve, reject) => { ... }).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).catch(...).cancel();\n     * ```\n     * Whenever some cancelled promise in a chain rejects with a `CancelError`\n     * with the same cancellation cause as itself, the error will be discarded silently.\n     * However, the `CancelError` _will still be delivered_ to all attached rejection handlers\n     * added by {@link then} and related methods:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * cancellable.then(() => { ... }).catch(console.log);\n     * cancellable.cancel(); // A CancelError is printed to the console.\n     * ```\n     * If the `CancelError` is not handled downstream by the time it reaches\n     * a _non-cancelled_ promise, it _will_ trigger an unhandled rejection event,\n     * just like normal rejections would:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * let chained = cancellable.then(() => { ... }).then(() => { ... }); // No catch...\n     * cancellable.cancel(); // Unhandled rejection event on chained!\n     * ```\n     * Therefore, it is important to either cancel whole promise chains from their tail,\n     * as shown in the correct idioms above, or take care of handling errors everywhere.\n     *\n     * @returns A cancellable promise that _fulfills_ after the cancel callback (if any)\n     * and all handlers attached up to the call to cancel have run.\n     * If the cancel callback returns a thenable, the promise returned by `cancel`\n     * will also wait for that thenable to settle.\n     * This enables callers to wait for the cancelled operation to terminate\n     * without being forced to handle potential errors at the call site.\n     * ```ts\n     * cancellable.cancel().then(() => {\n     *     // Cleanup finished, it's safe to do something else.\n     * }, (err) => {\n     *     // Unreachable: the promise returned from cancel will never reject.\n     * });\n     * ```\n     * Note that the returned promise will _not_ handle implicitly any rejection\n     * that might have occurred already in the cancelled chain.\n     * It will just track whether registered handlers have been executed or not.\n     * Therefore, unhandled rejections will never be silently handled by calling cancel.\n     */\n    cancel(cause?: any): CancellablePromise<void> {\n        return new CancellablePromise<void>((resolve) => {\n            // INVARIANT: the result of this[cancelImplSym] and the barrier do not ever reject.\n            // Unfortunately macOS High Sierra does not support Promise.allSettled.\n            Promise.all([\n                this[cancelImplSym](new CancelError(\"Promise cancelled.\", { cause })),\n                currentBarrier(this)\n            ]).then(() => resolve(), () => resolve());\n        });\n    }\n\n    /**\n     * Binds promise cancellation to the abort event of the given {@link AbortSignal}.\n     * If the signal has already aborted, the promise will be cancelled immediately.\n     * When either condition is verified, the cancellation cause will be set\n     * to the signal's abort reason (see {@link AbortSignal#reason}).\n     *\n     * Has no effect if called (or if the signal aborts) _after_ the promise has already settled.\n     * Only the first signal to abort will set the cancellation cause.\n     *\n     * For more details about the cancellation process,\n     * see {@link cancel} and the `CancellablePromise` constructor.\n     *\n     * This method enables `await`ing cancellable promises without having\n     * to store them for future cancellation, e.g.:\n     * ```ts\n     * await longRunningOperation().cancelOn(signal);\n     * ```\n     * instead of:\n     * ```ts\n     * let promiseToBeCancelled = longRunningOperation();\n     * await promiseToBeCancelled;\n     * ```\n     *\n     * @returns This promise, for method chaining.\n     */\n    cancelOn(signal: AbortSignal): CancellablePromise<T> {\n        if (signal.aborted) {\n            void this.cancel(signal.reason)\n        } else {\n            signal.addEventListener('abort', () => void this.cancel(signal.reason), {capture: true});\n        }\n\n        return this;\n    }\n\n    /**\n     * Attaches callbacks for the resolution and/or rejection of the `CancellablePromise`.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * @param onfulfilled The callback to execute when the Promise is resolved.\n     * @param onrejected The callback to execute when the Promise is rejected.\n     * @returns A `CancellablePromise` for the completion of whichever callback is executed.\n     * The returned promise is hooked up to propagate cancellation requests up the chain, but not down:\n     *\n     *   - if the parent promise is cancelled, the `onrejected` handler will be invoked with a `CancelError`\n     *     and the returned promise _will resolve regularly_ with its result;\n     *   - conversely, if the returned promise is cancelled, _the parent promise is cancelled too;_\n     *     the `onrejected` handler will still be invoked with the parent's `CancelError`,\n     *     but its result will be discarded\n     *     and the returned promise will reject with a `CancelError` as well.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If either callback returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     */\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<TResult1 | TResult2> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.then called on an invalid object.\");\n        }\n\n        // NOTE: TypeScript's built-in type for then is broken,\n        // as it allows specifying an arbitrary TResult1 != T even when onfulfilled is not a function.\n        // We cannot fix it if we want to CancellablePromise to implement PromiseLike<T>.\n\n        if (!isCallable(onfulfilled)) { onfulfilled = identity as any; }\n        if (!isCallable(onrejected)) { onrejected = thrower; }\n\n        if (onfulfilled === identity && onrejected == thrower) {\n            // Shortcut for trivial arguments.\n            return new CancellablePromise((resolve) => resolve(this as any));\n        }\n\n        const barrier: Partial<PromiseWithResolvers<void>> = {};\n        this[barrierSym] = barrier;\n\n        return new CancellablePromise<TResult1 | TResult2>((resolve, reject) => {\n            void super.then(\n                (value) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onfulfilled!(value));\n                    } catch (err) {\n                        reject(err);\n                    }\n                },\n                (reason?) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onrejected!(reason));\n                    } catch (err) {\n                        reject(err);\n                    }\n                }\n            );\n        }, async (cause?) => {\n            //cancelled = true;\n            try {\n                return oncancelled?.(cause);\n            } finally {\n                await this.cancel(cause);\n            }\n        });\n    }\n\n    /**\n     * Attaches a callback for only the rejection of the Promise.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * It is equivalent to\n     * ```ts\n     * cancellablePromise.then(undefined, onrejected, oncancelled);\n     * ```\n     * and the same caveats apply.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onrejected` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    catch<TResult = never>(onrejected?: ((reason: any) => (PromiseLike<TResult> | TResult)) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T | TResult> {\n        return this.then(undefined, onrejected, oncancelled);\n    }\n\n    /**\n     * Attaches a callback that is invoked when the CancellablePromise is settled (fulfilled or rejected). The\n     * resolved value cannot be accessed or modified from the callback.\n     * The returned promise will settle in the same state as the original one\n     * after the provided callback has completed execution,\n     * unless the callback throws or returns a rejecting promise,\n     * in which case the returned promise will reject as well.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * Once the parent promise settles, the `onfinally` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * This method is implemented in terms of {@link then} and the same caveats apply.\n     * It is polyfilled, hence available in every OS/webview version.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onfinally` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    finally(onfinally?: (() => void) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.finally called on an invalid object.\");\n        }\n\n        if (!isCallable(onfinally)) {\n            return this.then(onfinally, onfinally, oncancelled);\n        }\n\n        return this.then(\n            (value) => CancellablePromise.resolve(onfinally()).then(() => value),\n            (reason?) => CancellablePromise.resolve(onfinally()).then(() => { throw reason; }),\n            oncancelled,\n        );\n    }\n\n    /**\n     * We use the `[Symbol.species]` static property, if available,\n     * to disable the built-in automatic subclassing features from {@link Promise}.\n     * It is critical for performance reasons that extenders do not override this.\n     * Once the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing\n     * is either accepted or retired, this implementation will have to be revised accordingly.\n     *\n     * @ignore\n     * @internal\n     */\n    static get [species]() {\n        return Promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve, or rejected when any Promise is rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static all<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>[]>;\n    static all<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;\n    static all<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.all(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve or reject.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static allSettled<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<PromiseSettledResult<Awaited<T>>[]>;\n    static allSettled<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;\n    static allSettled<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.allSettled(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled,\n     * or rejected with an AggregateError containing an array of rejection reasons\n     * if all of the given promises are rejected.\n     * It resolves all elements of the passed iterable to promises as it runs this algorithm.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static any<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static any<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static any<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.any(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static race<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static race<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static race<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = new CancellablePromise<unknown>((resolve, reject) => {\n            void Promise.race(collected).then(resolve, reject);\n        }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a new cancelled CancellablePromise for the provided cause.\n     *\n     * @group Static Methods\n     */\n    static cancel<T = never>(cause?: any): CancellablePromise<T> {\n        const p = new CancellablePromise<T>(() => {});\n        p.cancel(cause);\n        return p;\n    }\n\n    /**\n     * Creates a new CancellablePromise that cancels\n     * after the specified timeout, with the provided cause.\n     *\n     * If the {@link AbortSignal.timeout} factory method is available,\n     * it is used to base the timeout on _active_ time rather than _elapsed_ time.\n     * Otherwise, `timeout` falls back to {@link setTimeout}.\n     *\n     * @group Static Methods\n     */\n    static timeout<T = never>(milliseconds: number, cause?: any): CancellablePromise<T> {\n        const promise = new CancellablePromise<T>(() => {});\n        if (AbortSignal && typeof AbortSignal === 'function' && AbortSignal.timeout && typeof AbortSignal.timeout === 'function') {\n            AbortSignal.timeout(milliseconds).addEventListener('abort', () => void promise.cancel(cause));\n        } else {\n            setTimeout(() => void promise.cancel(cause), milliseconds);\n        }\n        return promise;\n    }\n\n    /**\n     * Creates a new CancellablePromise that resolves after the specified timeout.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep(milliseconds: number): CancellablePromise<void>;\n    /**\n     * Creates a new CancellablePromise that resolves after\n     * the specified timeout, with the provided value.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep<T>(milliseconds: number, value: T): CancellablePromise<T>;\n    static sleep<T = void>(milliseconds: number, value?: T): CancellablePromise<T> {\n        return new CancellablePromise<T>((resolve) => {\n            setTimeout(() => resolve(value!), milliseconds);\n        });\n    }\n\n    /**\n     * Creates a new rejected CancellablePromise for the provided reason.\n     *\n     * @group Static Methods\n     */\n    static reject<T = never>(reason?: any): CancellablePromise<T> {\n        return new CancellablePromise<T>((_, reject) => reject(reason));\n    }\n\n    /**\n     * Creates a new resolved CancellablePromise.\n     *\n     * @group Static Methods\n     */\n    static resolve(): CancellablePromise<void>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T): CancellablePromise<Awaited<T>>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T | PromiseLike<T>): CancellablePromise<Awaited<T>>;\n    static resolve<T = void>(value?: T | PromiseLike<T>): CancellablePromise<Awaited<T>> {\n        if (value instanceof CancellablePromise) {\n            // Optimise for cancellable promises.\n            return value;\n        }\n        return new CancellablePromise<any>((resolve) => resolve(value));\n    }\n\n    /**\n     * Creates a new CancellablePromise and returns it in an object, along with its resolve and reject functions\n     * and a getter/setter for the cancellation callback.\n     *\n     * This method is polyfilled, hence available in every OS/webview version.\n     *\n     * @group Static Methods\n     */\n    static withResolvers<T>(): CancellablePromiseWithResolvers<T> {\n        let result: CancellablePromiseWithResolvers<T> = { oncancelled: null } as any;\n        result.promise = new CancellablePromise<T>((resolve, reject) => {\n            result.resolve = resolve;\n            result.reject = reject;\n        }, (cause?: any) => { result.oncancelled?.(cause); });\n        return result;\n    }\n}\n\n/**\n * Returns a callback that implements the cancellation algorithm for the given cancellable promise.\n * The promise returned from the resulting function does not reject.\n */\nfunction cancellerFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState) {\n    let cancellationPromise: void | PromiseLike<void> = undefined;\n\n    return (reason: CancelError): void | PromiseLike<void> => {\n        if (!state.settled) {\n            state.settled = true;\n            state.reason = reason;\n            promise.reject(reason);\n\n            // Attach an error handler that ignores this specific rejection reason and nothing else.\n            // In theory, a sane underlying implementation at this point\n            // should always reject with our cancellation reason,\n            // hence the handler will never throw.\n            void Promise.prototype.then.call(promise.promise, undefined, (err) => {\n                if (err !== reason) {\n                    throw err;\n                }\n            });\n        }\n\n        // If reason is not set, the promise resolved regularly, hence we must not call oncancelled.\n        // If oncancelled is unset, no need to go any further.\n        if (!state.reason || !promise.oncancelled) { return; }\n\n        cancellationPromise = new Promise<void>((resolve) => {\n            try {\n                resolve(promise.oncancelled!(state.reason!.cause));\n            } catch (err) {\n                Promise.reject(new CancelledRejectionError(promise.promise, err, \"Unhandled exception in oncancelled callback.\"));\n            }\n        }).catch((reason?) => {\n            Promise.reject(new CancelledRejectionError(promise.promise, reason, \"Unhandled rejection in oncancelled callback.\"));\n        });\n\n        // Unset oncancelled to prevent repeated calls.\n        promise.oncancelled = null;\n\n        return cancellationPromise;\n    }\n}\n\n/**\n * Returns a callback that implements the resolution algorithm for the given cancellable promise.\n */\nfunction resolverFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseResolver<T> {\n    return (value) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (value === promise.promise) {\n            if (state.settled) { return; }\n            state.settled = true;\n            promise.reject(new TypeError(\"A promise cannot be resolved with itself.\"));\n            return;\n        }\n\n        if (value != null && (typeof value === 'object' || typeof value === 'function')) {\n            let then: any;\n            try {\n                then = (value as any).then;\n            } catch (err) {\n                state.settled = true;\n                promise.reject(err);\n                return;\n            }\n\n            if (isCallable(then)) {\n                try {\n                    let cancel = (value as any).cancel;\n                    if (isCallable(cancel)) {\n                        const oncancelled = (cause?: any) => {\n                            Reflect.apply(cancel, value, [cause]);\n                        };\n                        if (state.reason) {\n                            // If already cancelled, propagate cancellation.\n                            // The promise returned from the canceller algorithm does not reject\n                            // so it can be discarded safely.\n                            void cancellerFor({ ...promise, oncancelled }, state)(state.reason);\n                        } else {\n                            promise.oncancelled = oncancelled;\n                        }\n                    }\n                } catch {}\n\n                const newState: CancellablePromiseState = {\n                    root: state.root,\n                    resolving: false,\n                    get settled() { return this.root.settled },\n                    set settled(value) { this.root.settled = value; },\n                    get reason() { return this.root.reason }\n                };\n\n                const rejector = rejectorFor(promise, newState);\n                try {\n                    Reflect.apply(then, value, [resolverFor(promise, newState), rejector]);\n                } catch (err) {\n                    rejector(err);\n                }\n                return; // IMPORTANT!\n            }\n        }\n\n        if (state.settled) { return; }\n        state.settled = true;\n        promise.resolve(value);\n    };\n}\n\n/**\n * Returns a callback that implements the rejection algorithm for the given cancellable promise.\n */\nfunction rejectorFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseRejector {\n    return (reason?) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (state.settled) {\n            try {\n                if (reason instanceof CancelError && state.reason instanceof CancelError && Object.is(reason.cause, state.reason.cause)) {\n                    // Swallow late rejections that are CancelErrors whose cancellation cause is the same as ours.\n                    return;\n                }\n            } catch {}\n\n            void Promise.reject(new CancelledRejectionError(promise.promise, reason));\n        } else {\n            state.settled = true;\n            promise.reject(reason);\n        }\n    }\n}\n\n/**\n * Cancels all values in an array that look like cancellable thenables.\n * Returns a promise that fulfills once all cancellation procedures for the given values have settled.\n */\nfunction cancelAll(parent: CancellablePromise<unknown>, values: any[], cause?: any): Promise<void> {\n    const results: Promise<void>[] = [];\n\n    for (const value of values) {\n        let cancel: CancellablePromiseCanceller;\n        try {\n            if (!isCallable(value.then)) { continue; }\n            cancel = value.cancel;\n            if (!isCallable(cancel)) { continue; }\n        } catch { continue; }\n\n        let result: void | PromiseLike<void>;\n        try {\n            result = Reflect.apply(cancel, value, [cause]);\n        } catch (err) {\n            Promise.reject(new CancelledRejectionError(parent, err, \"Unhandled exception in cancel method.\"));\n            continue;\n        }\n\n        if (!result) { continue; }\n        results.push(\n            (result instanceof Promise  ? result : Promise.resolve(result)).catch((reason?) => {\n                Promise.reject(new CancelledRejectionError(parent, reason, \"Unhandled rejection in cancel method.\"));\n            })\n        );\n    }\n\n    return Promise.all(results) as any;\n}\n\n/**\n * Returns its argument.\n */\nfunction identity<T>(x: T): T {\n    return x;\n}\n\n/**\n * Throws its argument.\n */\nfunction thrower(reason?: any): never {\n    throw reason;\n}\n\n/**\n * Attempts various strategies to convert an error to a string.\n */\nfunction errorMessage(err: any): string {\n    try {\n        if (err instanceof Error || typeof err !== 'object' || err.toString !== Object.prototype.toString) {\n            return \"\" + err;\n        }\n    } catch {}\n\n    try {\n        return JSON.stringify(err);\n    } catch {}\n\n    try {\n        return Object.prototype.toString.call(err);\n    } catch {}\n\n    return \"<could not convert error to string>\";\n}\n\n/**\n * Gets the current barrier promise for the given cancellable promise. If necessary, initialises the barrier.\n */\nfunction currentBarrier<T>(promise: CancellablePromise<T>): Promise<void> {\n    let pwr: Partial<PromiseWithResolvers<void>> = promise[barrierSym] ?? {};\n    if (!('promise' in pwr)) {\n        Object.assign(pwr, promiseWithResolvers<void>());\n    }\n    if (promise[barrierSym] == null) {\n        pwr.resolve!();\n        promise[barrierSym] = pwr;\n    }\n    return pwr.promise!;\n}\n\n// Polyfill Promise.withResolvers.\nlet promiseWithResolvers = Promise.withResolvers;\nif (promiseWithResolvers && typeof promiseWithResolvers === 'function') {\n    promiseWithResolvers = promiseWithResolvers.bind(Promise);\n} else {\n    promiseWithResolvers = function <T>(): PromiseWithResolvers<T> {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });\n        return { promise, resolve, reject };\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Clipboard);\n\nconst ClipboardSetText = 0;\nconst ClipboardText = 1;\n\n/**\n * Sets the text to the Clipboard.\n *\n * @param text - The text to be set to the Clipboard.\n * @return A Promise that resolves when the operation is successful.\n */\nexport function SetText(text: string): Promise<void> {\n    return call(ClipboardSetText, {text});\n}\n\n/**\n * Get the Clipboard text\n *\n * @returns A promise that resolves with the text from the Clipboard.\n */\nexport function Text(): Promise<string> {\n    return call(ClipboardText);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nexport interface Size {\n    /** The width of a rectangular area. */\n    Width: number;\n    /** The height of a rectangular area. */\n    Height: number;\n}\n\nexport interface Rect {\n    /** The X coordinate of the origin. */\n    X: number;\n    /** The Y coordinate of the origin. */\n    Y: number;\n    /** The width of the rectangle. */\n    Width: number;\n    /** The height of the rectangle. */\n    Height: number;\n}\n\nexport interface Screen {\n    /** Unique identifier for the screen. */\n    ID: string;\n    /** Human-readable name of the screen. */\n    Name: string;\n    /** The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc. */\n    ScaleFactor: number;\n    /** The X coordinate of the screen. */\n    X: number;\n    /** The Y coordinate of the screen. */\n    Y: number;\n    /** Contains the width and height of the screen. */\n    Size: Size;\n    /** Contains the bounds of the screen in terms of X, Y, Width, and Height. */\n    Bounds: Rect;\n    /** Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling). */\n    PhysicalBounds: Rect;\n    /** Contains the area of the screen that is actually usable (excluding taskbar and other system UI). */\n    WorkArea: Rect;\n    /** Contains the physical WorkArea of the screen (before scaling). */\n    PhysicalWorkArea: Rect;\n    /** True if this is the primary monitor selected by the user in the operating system. */\n    IsPrimary: boolean;\n    /** The rotation of the screen. */\n    Rotation: number;\n}\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Screens);\n\nconst getAll = 0;\nconst getPrimary = 1;\nconst getCurrent = 2;\n\n/**\n * Gets all screens.\n *\n * @returns A promise that resolves to an array of Screen objects.\n */\nexport function GetAll(): Promise<Screen[]> {\n    return call(getAll);\n}\n\n/**\n * Gets the primary screen.\n *\n * @returns A promise that resolves to the primary screen.\n */\nexport function GetPrimary(): Promise<Screen> {\n    return call(getPrimary);\n}\n\n/**\n * Gets the current active screen.\n *\n * @returns A promise that resolves with the current active screen.\n */\nexport function GetCurrent(): Promise<Screen> {\n    return call(getCurrent);\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.IOS);\n\n// Method IDs\nconst HapticsImpact = 0;\nconst DeviceInfo = 1;\n\nexport namespace Haptics {\n    export type ImpactStyle = \"light\"|\"medium\"|\"heavy\"|\"soft\"|\"rigid\";\n    export function Impact(style: ImpactStyle = \"medium\"): Promise<void> {\n        return call(HapticsImpact, { style });\n    }\n}\n\nexport namespace Device {\n    export interface Info {\n        model: string;\n        systemName: string;\n        systemVersion: string;\n        isSimulator: boolean;\n    }\n    export function Info(): Promise<Info> {\n        return call(DeviceInfo);\n    }\n}\n"],
  "mappings": "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",
  "names": ["_a", "Error", "call", "Error", "_a", "Array", "Map", "Array", "Map", "key", "call", "_a", "_a", "resizable", "_a", "call", "_a", "call", "_a", "call", "HideMethod", "ShowMethod", "isDocumentDotAll", "_a", "reason", "value", "call", "call", "call", "call", "Haptics", "Device", "Info"]
}
 diff --git a/v3/internal/assetserver/bundledassets/runtime.js b/v3/internal/assetserver/bundledassets/runtime.js index fca1b0e81..e4cf264cc 100644 --- a/v3/internal/assetserver/bundledassets/runtime.js +++ b/v3/internal/assetserver/bundledassets/runtime.js @@ -1 +1 @@ -var Ze=Object.defineProperty,hn=Object.defineProperties;var bn=Object.getOwnPropertyDescriptors;var He=Object.getOwnPropertySymbols;var vn=Object.prototype.hasOwnProperty,yn=Object.prototype.propertyIsEnumerable;var Ve=(n,e,i)=>e in n?Ze(n,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):n[e]=i,Ge=(n,e)=>{for(var i in e||(e={}))vn.call(e,i)&&Ve(n,i,e[i]);if(He)for(var i of He(e))yn.call(e,i)&&Ve(n,i,e[i]);return n},Ke=(n,e)=>hn(n,bn(e));var p=(n,e)=>{for(var i in e)Ze(n,i,{get:e[i],enumerable:!0})};var pe={};p(pe,{Application:()=>Se,Browser:()=>ie,Call:()=>Le,CancelError:()=>O,CancellablePromise:()=>N,CancelledRejectionError:()=>b,Clipboard:()=>Ie,Create:()=>re,Dialogs:()=>te,Events:()=>le,Flags:()=>he,IOS:()=>je,Screens:()=>Ue,System:()=>We,WML:()=>we,Window:()=>M,clientId:()=>ee,getTransport:()=>Xe,objectNames:()=>c,setTransport:()=>Ye});var we={};p(we,{Enable:()=>ue,Reload:()=>tn});var ie={};p(ie,{OpenURL:()=>ne});var Cn="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";function j(n=21){let e="",i=n|0;for(;i--;)e+=Cn[Math.random()*64|0];return e}var Dn=window.location.origin+"/wails/runtime";var c=Object.freeze({Call:0,Clipboard:1,Application:2,Events:3,ContextMenu:4,Dialog:5,Window:6,Screens:7,System:8,Browser:9,CancelCall:10,IOS:11}),ee=j(),H=null;function Ye(n){H=n}function Xe(){return H}function m(n,e=""){return function(i,o=null){return Pn(n,i,e,o)}}async function Pn(n,e,i,o){var d,w;if(H)return H.call(n,e,i,o);let t=new URL(Dn),a={object:n,method:e};o!=null&&(a.args=o);let s={"x-wails-client-id":ee,"Content-Type":"application/json"};i&&(s["x-wails-window-name"]=i);let l=await fetch(t,{method:"POST",headers:s,body:JSON.stringify(a)});if(!l.ok)throw new Error(await l.text());return((w=(d=l.headers.get("Content-Type"))==null?void 0:d.indexOf("application/json"))!=null?w:-1)!==-1?l.json():l.text()}var Tn=m(c.Browser),Mn=0;function ne(n){return Tn(Mn,{url:n.toString()})}var te={};p(te,{Error:()=>In,Info:()=>kn,OpenFile:()=>zn,Question:()=>oe,SaveFile:()=>Un,Warning:()=>Ln});window._wails=window._wails||{};var Sn=m(c.Dialog),En=0,xn=1,An=2,Rn=3,Fn=4,On=5;function P(n,e={}){return Sn(n,e)}function kn(n){return P(En,n)}function Ln(n){return P(xn,n)}function In(n){return P(An,n)}function oe(n){return P(Rn,n)}function zn(n){var e;return(e=P(Fn,n))!=null?e:[]}function Un(n){return P(On,n)}var le={};p(le,{Emit:()=>se,Off:()=>Qn,OffAll:()=>qn,On:()=>Xn,OnMultiple:()=>ae,Once:()=>$n,Types:()=>Zn,WailsEvent:()=>k});var g=new Map,V=class{constructor(e,i,o){this.eventName=e,this.callback=i,this.maxCallbacks=o||-1}dispatch(e){try{this.callback(e)}catch(i){}return this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0)}};function $e(n){let e=g.get(n.eventName);e&&(e=e.filter(i=>i!==n),e.length===0?g.delete(n.eventName):g.set(n.eventName,e))}var re={};p(re,{Any:()=>v,Array:()=>Bn,ByteSlice:()=>Nn,Events:()=>Z,Map:()=>jn,Nullable:()=>Hn,Struct:()=>Vn});function v(n){return n}function Nn(n){return n==null?"":n}function Bn(n){return n===v?e=>e===null?[]:e:e=>{if(e===null)return[];for(let i=0;ii===null?{}:i:i=>{if(i===null)return{};for(let o in i)i[o]=e(i[o]);return i}}function Hn(n){return n===v?v:e=>e===null?null:n(e)}function Vn(n){let e=!0;for(let i in n)if(n[i]!==v){e=!1;break}return e?v:i=>{for(let o in n)o in i&&(i[o]=n[o](i[o]));return i}}var Z={};var Zn=Object.freeze({Windows:Object.freeze({APMPowerSettingChange:"windows:APMPowerSettingChange",APMPowerStatusChange:"windows:APMPowerStatusChange",APMResumeAutomatic:"windows:APMResumeAutomatic",APMResumeSuspend:"windows:APMResumeSuspend",APMSuspend:"windows:APMSuspend",ApplicationStarted:"windows:ApplicationStarted",SystemThemeChanged:"windows:SystemThemeChanged",WebViewNavigationCompleted:"windows:WebViewNavigationCompleted",WindowActive:"windows:WindowActive",WindowBackgroundErase:"windows:WindowBackgroundErase",WindowClickActive:"windows:WindowClickActive",WindowClosing:"windows:WindowClosing",WindowDidMove:"windows:WindowDidMove",WindowDidResize:"windows:WindowDidResize",WindowDPIChanged:"windows:WindowDPIChanged",WindowDragDrop:"windows:WindowDragDrop",WindowDragEnter:"windows:WindowDragEnter",WindowDragLeave:"windows:WindowDragLeave",WindowDragOver:"windows:WindowDragOver",WindowEndMove:"windows:WindowEndMove",WindowEndResize:"windows:WindowEndResize",WindowFullscreen:"windows:WindowFullscreen",WindowHide:"windows:WindowHide",WindowInactive:"windows:WindowInactive",WindowKeyDown:"windows:WindowKeyDown",WindowKeyUp:"windows:WindowKeyUp",WindowKillFocus:"windows:WindowKillFocus",WindowNonClientHit:"windows:WindowNonClientHit",WindowNonClientMouseDown:"windows:WindowNonClientMouseDown",WindowNonClientMouseLeave:"windows:WindowNonClientMouseLeave",WindowNonClientMouseMove:"windows:WindowNonClientMouseMove",WindowNonClientMouseUp:"windows:WindowNonClientMouseUp",WindowPaint:"windows:WindowPaint",WindowRestore:"windows:WindowRestore",WindowSetFocus:"windows:WindowSetFocus",WindowShow:"windows:WindowShow",WindowStartMove:"windows:WindowStartMove",WindowStartResize:"windows:WindowStartResize",WindowUnFullscreen:"windows:WindowUnFullscreen",WindowZOrderChanged:"windows:WindowZOrderChanged",WindowMinimise:"windows:WindowMinimise",WindowUnMinimise:"windows:WindowUnMinimise",WindowMaximise:"windows:WindowMaximise",WindowUnMaximise:"windows:WindowUnMaximise"}),Mac:Object.freeze({ApplicationDidBecomeActive:"mac:ApplicationDidBecomeActive",ApplicationDidChangeBackingProperties:"mac:ApplicationDidChangeBackingProperties",ApplicationDidChangeEffectiveAppearance:"mac:ApplicationDidChangeEffectiveAppearance",ApplicationDidChangeIcon:"mac:ApplicationDidChangeIcon",ApplicationDidChangeOcclusionState:"mac:ApplicationDidChangeOcclusionState",ApplicationDidChangeScreenParameters:"mac:ApplicationDidChangeScreenParameters",ApplicationDidChangeStatusBarFrame:"mac:ApplicationDidChangeStatusBarFrame",ApplicationDidChangeStatusBarOrientation:"mac:ApplicationDidChangeStatusBarOrientation",ApplicationDidChangeTheme:"mac:ApplicationDidChangeTheme",ApplicationDidFinishLaunching:"mac:ApplicationDidFinishLaunching",ApplicationDidHide:"mac:ApplicationDidHide",ApplicationDidResignActive:"mac:ApplicationDidResignActive",ApplicationDidUnhide:"mac:ApplicationDidUnhide",ApplicationDidUpdate:"mac:ApplicationDidUpdate",ApplicationShouldHandleReopen:"mac:ApplicationShouldHandleReopen",ApplicationWillBecomeActive:"mac:ApplicationWillBecomeActive",ApplicationWillFinishLaunching:"mac:ApplicationWillFinishLaunching",ApplicationWillHide:"mac:ApplicationWillHide",ApplicationWillResignActive:"mac:ApplicationWillResignActive",ApplicationWillTerminate:"mac:ApplicationWillTerminate",ApplicationWillUnhide:"mac:ApplicationWillUnhide",ApplicationWillUpdate:"mac:ApplicationWillUpdate",MenuDidAddItem:"mac:MenuDidAddItem",MenuDidBeginTracking:"mac:MenuDidBeginTracking",MenuDidClose:"mac:MenuDidClose",MenuDidDisplayItem:"mac:MenuDidDisplayItem",MenuDidEndTracking:"mac:MenuDidEndTracking",MenuDidHighlightItem:"mac:MenuDidHighlightItem",MenuDidOpen:"mac:MenuDidOpen",MenuDidPopUp:"mac:MenuDidPopUp",MenuDidRemoveItem:"mac:MenuDidRemoveItem",MenuDidSendAction:"mac:MenuDidSendAction",MenuDidSendActionToItem:"mac:MenuDidSendActionToItem",MenuDidUpdate:"mac:MenuDidUpdate",MenuWillAddItem:"mac:MenuWillAddItem",MenuWillBeginTracking:"mac:MenuWillBeginTracking",MenuWillDisplayItem:"mac:MenuWillDisplayItem",MenuWillEndTracking:"mac:MenuWillEndTracking",MenuWillHighlightItem:"mac:MenuWillHighlightItem",MenuWillOpen:"mac:MenuWillOpen",MenuWillPopUp:"mac:MenuWillPopUp",MenuWillRemoveItem:"mac:MenuWillRemoveItem",MenuWillSendAction:"mac:MenuWillSendAction",MenuWillSendActionToItem:"mac:MenuWillSendActionToItem",MenuWillUpdate:"mac:MenuWillUpdate",WebViewDidCommitNavigation:"mac:WebViewDidCommitNavigation",WebViewDidFinishNavigation:"mac:WebViewDidFinishNavigation",WebViewDidReceiveServerRedirectForProvisionalNavigation:"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation",WebViewDidStartProvisionalNavigation:"mac:WebViewDidStartProvisionalNavigation",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",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",WindowDidZoom:"mac:WindowDidZoom",WindowFileDraggingEntered:"mac:WindowFileDraggingEntered",WindowFileDraggingExited:"mac:WindowFileDraggingExited",WindowFileDraggingPerformed:"mac:WindowFileDraggingPerformed",WindowHide:"mac:WindowHide",WindowMaximise:"mac:WindowMaximise",WindowUnMaximise:"mac:WindowUnMaximise",WindowMinimise:"mac:WindowMinimise",WindowUnMinimise:"mac:WindowUnMinimise",WindowShouldClose:"mac:WindowShouldClose",WindowShow:"mac:WindowShow",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",WindowZoomIn:"mac:WindowZoomIn",WindowZoomOut:"mac:WindowZoomOut",WindowZoomReset:"mac:WindowZoomReset"}),Linux:Object.freeze({ApplicationStartup:"linux:ApplicationStartup",SystemThemeChanged:"linux:SystemThemeChanged",WindowDeleteEvent:"linux:WindowDeleteEvent",WindowDidMove:"linux:WindowDidMove",WindowDidResize:"linux:WindowDidResize",WindowFocusIn:"linux:WindowFocusIn",WindowFocusOut:"linux:WindowFocusOut",WindowLoadStarted:"linux:WindowLoadStarted",WindowLoadRedirected:"linux:WindowLoadRedirected",WindowLoadCommitted:"linux:WindowLoadCommitted",WindowLoadFinished:"linux:WindowLoadFinished"}),iOS:Object.freeze({ApplicationDidBecomeActive:"ios:ApplicationDidBecomeActive",ApplicationDidEnterBackground:"ios:ApplicationDidEnterBackground",ApplicationDidFinishLaunching:"ios:ApplicationDidFinishLaunching",ApplicationDidReceiveMemoryWarning:"ios:ApplicationDidReceiveMemoryWarning",ApplicationWillEnterForeground:"ios:ApplicationWillEnterForeground",ApplicationWillResignActive:"ios:ApplicationWillResignActive",ApplicationWillTerminate:"ios:ApplicationWillTerminate",WindowDidLoad:"ios:WindowDidLoad",WindowWillAppear:"ios:WindowWillAppear",WindowDidAppear:"ios:WindowDidAppear",WindowWillDisappear:"ios:WindowWillDisappear",WindowDidDisappear:"ios:WindowDidDisappear",WindowSafeAreaInsetsChanged:"ios:WindowSafeAreaInsetsChanged",WindowOrientationChanged:"ios:WindowOrientationChanged",WindowTouchBegan:"ios:WindowTouchBegan",WindowTouchMoved:"ios:WindowTouchMoved",WindowTouchEnded:"ios:WindowTouchEnded",WindowTouchCancelled:"ios:WindowTouchCancelled",WebViewDidStartNavigation:"ios:WebViewDidStartNavigation",WebViewDidFinishNavigation:"ios:WebViewDidFinishNavigation",WebViewDidFailNavigation:"ios:WebViewDidFailNavigation",WebViewDecidePolicyForNavigationAction:"ios:WebViewDecidePolicyForNavigationAction"}),Common:Object.freeze({ApplicationOpenedWithFile:"common:ApplicationOpenedWithFile",ApplicationStarted:"common:ApplicationStarted",ApplicationLaunchedWithUrl:"common:ApplicationLaunchedWithUrl",ThemeChanged:"common:ThemeChanged",WindowClosing:"common:WindowClosing",WindowDidMove:"common:WindowDidMove",WindowDidResize:"common:WindowDidResize",WindowDPIChanged:"common:WindowDPIChanged",WindowFilesDropped:"common:WindowFilesDropped",WindowFocus:"common:WindowFocus",WindowFullscreen:"common:WindowFullscreen",WindowHide:"common:WindowHide",WindowLostFocus:"common:WindowLostFocus",WindowMaximise:"common:WindowMaximise",WindowMinimise:"common:WindowMinimise",WindowToggleFrameless:"common:WindowToggleFrameless",WindowRestore:"common:WindowRestore",WindowRuntimeReady:"common:WindowRuntimeReady",WindowShow:"common:WindowShow",WindowUnFullscreen:"common:WindowUnFullscreen",WindowUnMaximise:"common:WindowUnMaximise",WindowUnMinimise:"common:WindowUnMinimise",WindowZoom:"common:WindowZoom",WindowZoomIn:"common:WindowZoomIn",WindowZoomOut:"common:WindowZoomOut",WindowZoomReset:"common:WindowZoomReset",WindowDropZoneFilesDropped:"common:WindowDropZoneFilesDropped"})});window._wails=window._wails||{};window._wails.dispatchWailsEvent=Yn;var Gn=m(c.Events),Kn=0,k=class{constructor(e,i){this.name=e,this.data=i!=null?i:null}};function Yn(n){let e=g.get(n.name);if(!e)return;let i=new k(n.name,n.name in Z?Z[n.name](n.data):n.data);"sender"in n&&(i.sender=n.sender),e=e.filter(o=>!o.dispatch(i)),e.length===0?g.delete(n.name):g.set(n.name,e)}function ae(n,e,i){let o=g.get(n)||[],t=new V(n,e,i);return o.push(t),g.set(n,o),()=>$e(t)}function Xn(n,e){return ae(n,e,-1)}function $n(n,e){return ae(n,e,1)}function Qn(...n){n.forEach(e=>g.delete(e))}function qn(){g.clear()}function se(n,e){return Gn(Kn,new k(n,e))}function Qe(){return new MouseEvent("mousedown").buttons===0}function qe(){if(!EventTarget||!AbortSignal||!AbortController)return!1;let n=!0,e=new EventTarget,i=new AbortController;return e.addEventListener("test",()=>{n=!1},{signal:i.signal}),i.abort(),e.dispatchEvent(new CustomEvent("test")),n}function G(n){var e;return n.target instanceof HTMLElement?n.target:!(n.target instanceof HTMLElement)&&n.target instanceof Node&&(e=n.target.parentElement)!=null?e:document.body}var _e=!1;document.addEventListener("DOMContentLoaded",()=>{_e=!0});function Je(n){_e||document.readyState==="complete"?n():document.addEventListener("DOMContentLoaded",n)}var _n="data-wails-dropzone",T="wails-dropzone-hover",u=null,Jn=0,ei=1,ni=2,ii=3,oi=4,ti=5,ri=6,ai=7,si=8,li=9,di=10,ci=11,mi=12,ui=13,wi=14,pi=15,fi=16,gi=17,Wi=18,hi=19,bi=20,vi=21,yi=22,Ci=23,Di=24,Pi=25,Ti=26,Mi=27,Si=28,Ei=29,xi=30,Ai=31,Ri=32,Fi=33,Oi=34,ki=35,Li=36,Ii=37,zi=38,Ui=39,Ni=40,Bi=41,ji=42,Hi=43,Vi=44,Zi=45,Gi=46,Ki=47,Yi=48,Xi=49,$i=50,Qi=51;function en(n){return n?n.closest("[".concat(_n,"]")):null}var r=Symbol("caller"),K=class K{constructor(e=""){this[r]=m(c.Window,e);for(let i of Object.getOwnPropertyNames(K.prototype))i!=="constructor"&&typeof this[i]=="function"&&(this[i]=this[i].bind(this))}Get(e){return new K(e)}Position(){return this[r](Jn)}Center(){return this[r](ei)}Close(){return this[r](ni)}DisableSizeConstraints(){return this[r](ii)}EnableSizeConstraints(){return this[r](oi)}Focus(){return this[r](ti)}ForceReload(){return this[r](ri)}Fullscreen(){return this[r](ai)}GetScreen(){return this[r](si)}GetZoom(){return this[r](li)}Height(){return this[r](di)}Hide(){return this[r](ci)}IsFocused(){return this[r](mi)}IsFullscreen(){return this[r](ui)}IsMaximised(){return this[r](wi)}IsMinimised(){return this[r](pi)}Maximise(){return this[r](fi)}Minimise(){return this[r](gi)}Name(){return this[r](Wi)}OpenDevTools(){return this[r](hi)}RelativePosition(){return this[r](bi)}Reload(){return this[r](vi)}Resizable(){return this[r](yi)}Restore(){return this[r](Ci)}SetPosition(e,i){return this[r](Di,{x:e,y:i})}SetAlwaysOnTop(e){return this[r](Pi,{alwaysOnTop:e})}SetBackgroundColour(e,i,o,t){return this[r](Ti,{r:e,g:i,b:o,a:t})}SetFrameless(e){return this[r](Mi,{frameless:e})}SetFullscreenButtonEnabled(e){return this[r](Si,{enabled:e})}SetMaxSize(e,i){return this[r](Ei,{width:e,height:i})}SetMinSize(e,i){return this[r](xi,{width:e,height:i})}SetRelativePosition(e,i){return this[r](Ai,{x:e,y:i})}SetResizable(e){return this[r](Ri,{resizable:e})}SetSize(e,i){return this[r](Fi,{width:e,height:i})}SetTitle(e){return this[r](Oi,{title:e})}SetZoom(e){return this[r](ki,{zoom:e})}Show(){return this[r](Li)}Size(){return this[r](Ii)}ToggleFullscreen(){return this[r](zi)}ToggleMaximise(){return this[r](Ui)}ToggleFrameless(){return this[r](Ni)}UnFullscreen(){return this[r](Bi)}UnMaximise(){return this[r](ji)}UnMinimise(){return this[r](Hi)}Width(){return this[r](Vi)}Zoom(){return this[r](Zi)}ZoomIn(){return this[r](Gi)}ZoomOut(){return this[r](Ki)}ZoomReset(){return this[r](Yi)}HandlePlatformFileDrop(e,i,o){let t=document.elementFromPoint(i,o),a=en(t);if(!a)return;let s={id:a.id,classList:Array.from(a.classList),attributes:{}};for(let d=0;d{if(i.preventDefault(),i.dataTransfer&&i.dataTransfer.types.includes("Files")){e++;let o=document.elementFromPoint(i.clientX,i.clientY),t=en(o);u&&u!==t&&u.classList.remove(T),t?(t.classList.add(T),i.dataTransfer.dropEffect="copy",u=t):(i.dataTransfer.dropEffect="none",u=null)}},!1),n.addEventListener("dragover",i=>{i.preventDefault(),i.dataTransfer&&i.dataTransfer.types.includes("Files")&&(u?(u.classList.contains(T)||u.classList.add(T),i.dataTransfer.dropEffect="copy"):i.dataTransfer.dropEffect="none")},!1),n.addEventListener("dragleave",i=>{i.preventDefault(),i.dataTransfer&&i.dataTransfer.types.includes("Files")&&(e--,(e===0||i.relatedTarget===null||u&&!u.contains(i.relatedTarget))&&(u&&(u.classList.remove(T),u=null),e=0))},!1),n.addEventListener("drop",i=>{i.preventDefault(),e=0,u&&(u.classList.remove(T),u=null)},!1)}typeof window<"u"&&typeof document<"u"&&_i();var M=qi;function Ji(n,e=null){se(n,e)}function eo(n,e){let i=M.Get(n),o=i[e];if(typeof o=="function")try{o.call(i)}catch(t){}}function nn(n){let e=n.currentTarget;function i(t="Yes"){if(t!=="Yes")return;let a=e.getAttribute("wml-event")||e.getAttribute("data-wml-event"),s=e.getAttribute("wml-target-window")||e.getAttribute("data-wml-target-window")||"",l=e.getAttribute("wml-window")||e.getAttribute("data-wml-window"),d=e.getAttribute("wml-openurl")||e.getAttribute("data-wml-openurl");a!==null&&Ji(a),l!==null&&eo(s,l),d!==null&&ne(d)}let o=e.getAttribute("wml-confirm")||e.getAttribute("data-wml-confirm");o?oe({Title:"Confirm",Message:o,Detached:!1,Buttons:[{Label:"Yes"},{Label:"No",IsDefault:!0}]}).then(i):i()}var L=Symbol("controller"),S=Symbol("triggerMap"),y=Symbol("elementCount"),ce=class{constructor(){this[L]=new AbortController}set(e,i){return{signal:this[L].signal}}reset(){this[L].abort(),this[L]=new AbortController}},me=class{constructor(){this[S]=new WeakMap,this[y]=0}set(e,i){return this[S].has(e)||this[y]++,this[S].set(e,i),{}}reset(){if(!(this[y]<=0)){for(let e of document.body.querySelectorAll("*")){if(this[y]<=0)break;let i=this[S].get(e);i!=null&&this[y]--;for(let o of i||[])e.removeEventListener(o,nn)}this[S]=new WeakMap,this[y]=0}}},on=qe()?new ce:new me;function no(n){let e=/\S+/g,i=n.getAttribute("wml-trigger")||n.getAttribute("data-wml-trigger")||"click",o=[],t;for(;(t=e.exec(i))!==null;)o.push(t[0]);let a=on.set(n,o);for(let s of o)n.addEventListener(s,nn,a)}function ue(){Je(tn)}function tn(){on.reset(),document.body.querySelectorAll("[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]").forEach(no)}window.wails=pe;ue();var We={};p(We,{Capabilities:()=>so,Environment:()=>lo,HandlePlatformFileDrop:()=>fo,IsAMD64:()=>uo,IsARM:()=>wo,IsARM64:()=>po,IsDarkMode:()=>ao,IsDebug:()=>ge,IsLinux:()=>co,IsMac:()=>mo,IsWindows:()=>X,invoke:()=>C});var Y=m(c.System),io=0,oo=1,to=2,ro=100,fe=(function(){var n,e,i,o,t,a;try{if((e=(n=window.chrome)==null?void 0:n.webview)!=null&&e.postMessage)return window.chrome.webview.postMessage.bind(window.chrome.webview);if((t=(o=(i=window.webkit)==null?void 0:i.messageHandlers)==null?void 0:o.external)!=null&&t.postMessage)return window.webkit.messageHandlers.external.postMessage.bind(window.webkit.messageHandlers.external);if((a=window.wails)!=null&&a.invoke)return s=>window.wails.invoke(typeof s=="string"?s:JSON.stringify(s))}catch(s){}return null})();function C(n){fe==null||fe(n)}function ao(){return Y(io)}async function so(){return Y(to)}function lo(){return Y(oo)}function X(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="windows"}function co(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="linux"}function mo(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="darwin"}function uo(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="amd64"}function wo(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="arm"}function po(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="arm64"}function ge(){var n,e;return!!((e=(n=window._wails)==null?void 0:n.environment)!=null&&e.Debug)}function fo(n,e,i){let o=document.elementFromPoint(e,i),t=o?o.id:"",a=o?Array.from(o.classList):[];Y(ro,{filenames:n,x:e,y:i,elementId:t,classList:a}).then(()=>{}).catch(l=>{})}window.addEventListener("contextmenu",bo);var go=m(c.ContextMenu),Wo=0;function ho(n,e,i,o){go(Wo,{id:n,x:e,y:i,data:o})}function bo(n){let e=G(n),i=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu").trim();if(i){n.preventDefault();let o=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu-data");ho(i,n.clientX,n.clientY,o)}else vo(n,e)}function vo(n,e){if(ge())return;switch(window.getComputedStyle(e).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":n.preventDefault();return}if(e.isContentEditable)return;let i=window.getSelection(),o=i&&i.toString().length>0;if(o)for(let t=0;tI});function I(n){try{return window._wails.flags[n]}catch(e){throw new Error("Unable to retrieve flag '"+n+"': "+e,{cause:e})}}var z=!1,U=!1,De=!1,x=!1,A=!1,D="",rn="auto",E=0,be=Qe();window._wails=window._wails||{};window._wails.setResizable=n=>{De=n,De||(x=A=!1,f())};var Pe=!1;function yo(){var i,o;let n=(o=(i=window._wails)==null?void 0:i.environment)==null?void 0:o.OS;if(n==="ios"||n==="android")return!0;let e=navigator.userAgent||navigator.vendor||window.opera||"";return/android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(e)}function Te(){if(!Pe&&!yo()){window.addEventListener("mousedown",Ce,{capture:!0}),window.addEventListener("mousemove",Ce,{capture:!0}),window.addEventListener("mouseup",Ce,{capture:!0});for(let n of["click","contextmenu","dblclick"])window.addEventListener(n,Do,{capture:!0});Pe=!0}}Te();document.addEventListener("DOMContentLoaded",Te,{once:!0});var Co=0,an=window.setInterval(()=>{if(Pe){window.clearInterval(an);return}Te(),++Co>100&&window.clearInterval(an)},50);function Do(n){(U||A)&&(n.stopImmediatePropagation(),n.stopPropagation(),n.preventDefault())}var ve=0,Po=1,ye=2;function Ce(n){let e,i=n.buttons;switch(n.type){case"mousedown":e=ve,be||(i=E|1<Fo,Quit:()=>ko,Show:()=>Oo});var Me=m(c.Application),xo=0,Ao=1,Ro=2;function Fo(){return Me(xo)}function Oo(){return Me(Ao)}function ko(){return Me(Ro)}var Le={};p(Le,{ByID:()=>et,ByName:()=>Jo,Call:()=>ke,RuntimeError:()=>Oe});var ln=Function.prototype.toString,R=typeof Reflect=="object"&&Reflect!==null&&Reflect.apply,Ee,$;if(typeof R=="function"&&typeof Object.defineProperty=="function")try{Ee=Object.defineProperty({},"length",{get:function(){throw $}}),$={},R(function(){throw 42},null,Ee)}catch(n){n!==$&&(R=null)}else R=null;var Lo=/^\s*class\b/,Ae=function(e){try{var i=ln.call(e);return Lo.test(i)}catch(o){return!1}},xe=function(e){try{return Ae(e)?!1:(ln.call(e),!0)}catch(i){return!1}},Q=Object.prototype.toString,Io="[object Object]",zo="[object Function]",Uo="[object GeneratorFunction]",No="[object HTMLAllCollection]",Bo="[object HTML document.all class]",jo="[object HTMLCollection]",Ho=typeof Symbol=="function"&&!!Symbol.toStringTag,Vo=!(0 in[,]),Re=function(){return!1};typeof document=="object"&&(sn=document.all,Q.call(sn)===Q.call(document.all)&&(Re=function(e){if((Vo||!e)&&(typeof e>"u"||typeof e=="object"))try{var i=Q.call(e);return(i===No||i===Bo||i===jo||i===Io)&&e("")==null}catch(o){}return!1}));var sn;function Zo(n){if(Re(n))return!0;if(!n||typeof n!="function"&&typeof n!="object")return!1;try{R(n,null,Ee)}catch(e){if(e!==$)return!1}return!Ae(n)&&xe(n)}function Go(n){if(Re(n))return!0;if(!n||typeof n!="function"&&typeof n!="object")return!1;if(Ho)return xe(n);if(Ae(n))return!1;var e=Q.call(n);return e!==zo&&e!==Uo&&!/^\[object HTML/.test(e)?!1:xe(n)}var h=R?Zo:Go;var O=class extends Error{constructor(e,i){super(e,i),this.name="CancelError"}},b=class extends Error{constructor(e,i,o){super((o!=null?o:"Unhandled rejection in cancelled promise.")+" Reason: "+Ko(i),{cause:i}),this.promise=e,this.name="CancelledRejectionError"}},W=Symbol("barrier"),Fe=Symbol("cancelImpl"),un,dn=(un=Symbol.species)!=null?un:Symbol("speciesPolyfill"),N=class n extends Promise{constructor(e,i){let o,t;if(super((d,w)=>{o=d,t=w}),this.constructor[dn]!==Promise)throw new TypeError("CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.");let a={promise:this,resolve:o,reject:t,get oncancelled(){return i!=null?i:null},set oncancelled(d){i=d!=null?d:void 0}},s={get root(){return s},resolving:!1,settled:!1};Object.defineProperties(this,{[W]:{configurable:!1,enumerable:!1,writable:!0,value:null},[Fe]:{configurable:!1,enumerable:!1,writable:!1,value:wn(a,s)}});let l=fn(a,s);try{e(pn(a,s),l)}catch(d){s.resolving||l(d)}}cancel(e){return new n(i=>{Promise.all([this[Fe](new O("Promise cancelled.",{cause:e})),Yo(this)]).then(()=>i(),()=>i())})}cancelOn(e){return e.aborted?this.cancel(e.reason):e.addEventListener("abort",()=>{this.cancel(e.reason)},{capture:!0}),this}then(e,i,o){if(!(this instanceof n))throw new TypeError("CancellablePromise.prototype.then called on an invalid object.");if(h(e)||(e=cn),h(i)||(i=mn),e===cn&&i==mn)return new n(a=>a(this));let t={};return this[W]=t,new n((a,s)=>{super.then(l=>{var d;this[W]===t&&(this[W]=null),(d=t.resolve)==null||d.call(t);try{a(e(l))}catch(w){s(w)}},l=>{var d;this[W]===t&&(this[W]=null),(d=t.resolve)==null||d.call(t);try{a(i(l))}catch(w){s(w)}})},async a=>{try{return o==null?void 0:o(a)}finally{await this.cancel(a)}})}catch(e,i){return this.then(void 0,e,i)}finally(e,i){if(!(this instanceof n))throw new TypeError("CancellablePromise.prototype.finally called on an invalid object.");return h(e)?this.then(o=>n.resolve(e()).then(()=>o),o=>n.resolve(e()).then(()=>{throw o}),i):this.then(e,e,i)}static get[(W,Fe,dn)](){return Promise}static all(e){let i=Array.from(e),o=i.length===0?n.resolve(i):new n((t,a)=>{Promise.all(i).then(t,a)},t=>q(o,i,t));return o}static allSettled(e){let i=Array.from(e),o=i.length===0?n.resolve(i):new n((t,a)=>{Promise.allSettled(i).then(t,a)},t=>q(o,i,t));return o}static any(e){let i=Array.from(e),o=i.length===0?n.resolve(i):new n((t,a)=>{Promise.any(i).then(t,a)},t=>q(o,i,t));return o}static race(e){let i=Array.from(e),o=new n((t,a)=>{Promise.race(i).then(t,a)},t=>q(o,i,t));return o}static cancel(e){let i=new n(()=>{});return i.cancel(e),i}static timeout(e,i){let o=new n(()=>{});return AbortSignal&&typeof AbortSignal=="function"&&AbortSignal.timeout&&typeof AbortSignal.timeout=="function"?AbortSignal.timeout(e).addEventListener("abort",()=>{o.cancel(i)}):setTimeout(()=>{o.cancel(i)},e),o}static sleep(e,i){return new n(o=>{setTimeout(()=>o(i),e)})}static reject(e){return new n((i,o)=>o(e))}static resolve(e){return e instanceof n?e:new n(i=>i(e))}static withResolvers(){let e={oncancelled:null};return e.promise=new n((i,o)=>{e.resolve=i,e.reject=o},i=>{var o;(o=e.oncancelled)==null||o.call(e,i)}),e}};function wn(n,e){let i;return o=>{if(e.settled||(e.settled=!0,e.reason=o,n.reject(o),Promise.prototype.then.call(n.promise,void 0,t=>{if(t!==o)throw t})),!(!e.reason||!n.oncancelled))return i=new Promise(t=>{try{t(n.oncancelled(e.reason.cause))}catch(a){Promise.reject(new b(n.promise,a,"Unhandled exception in oncancelled callback."))}}).catch(t=>{Promise.reject(new b(n.promise,t,"Unhandled rejection in oncancelled callback."))}),n.oncancelled=null,i}}function pn(n,e){return i=>{if(!e.resolving){if(e.resolving=!0,i===n.promise){if(e.settled)return;e.settled=!0,n.reject(new TypeError("A promise cannot be resolved with itself."));return}if(i!=null&&(typeof i=="object"||typeof i=="function")){let o;try{o=i.then}catch(t){e.settled=!0,n.reject(t);return}if(h(o)){try{let s=i.cancel;if(h(s)){let l=d=>{Reflect.apply(s,i,[d])};e.reason?wn(Ke(Ge({},n),{oncancelled:l}),e)(e.reason):n.oncancelled=l}}catch(s){}let t={root:e.root,resolving:!1,get settled(){return this.root.settled},set settled(s){this.root.settled=s},get reason(){return this.root.reason}},a=fn(n,t);try{Reflect.apply(o,i,[pn(n,t),a])}catch(s){a(s)}return}}e.settled||(e.settled=!0,n.resolve(i))}}}function fn(n,e){return i=>{if(!e.resolving)if(e.resolving=!0,e.settled){try{if(i instanceof O&&e.reason instanceof O&&Object.is(i.cause,e.reason.cause))return}catch(o){}Promise.reject(new b(n.promise,i))}else e.settled=!0,n.reject(i)}}function q(n,e,i){let o=[];for(let t of e){let a;try{if(!h(t.then)||(a=t.cancel,!h(a)))continue}catch(l){continue}let s;try{s=Reflect.apply(a,t,[i])}catch(l){Promise.reject(new b(n,l,"Unhandled exception in cancel method."));continue}s&&o.push((s instanceof Promise?s:Promise.resolve(s)).catch(l=>{Promise.reject(new b(n,l,"Unhandled rejection in cancel method."))}))}return Promise.all(o)}function cn(n){return n}function mn(n){throw n}function Ko(n){try{if(n instanceof Error||typeof n!="object"||n.toString!==Object.prototype.toString)return""+n}catch(e){}try{return JSON.stringify(n)}catch(e){}try{return Object.prototype.toString.call(n)}catch(e){}return""}function Yo(n){var i;let e=(i=n[W])!=null?i:{};return"promise"in e||Object.assign(e,F()),n[W]==null&&(e.resolve(),n[W]=e),e.promise}var F=Promise.withResolvers;F&&typeof F=="function"?F=F.bind(Promise):F=function(){let n,e;return{promise:new Promise((o,t)=>{n=o,e=t}),resolve:n,reject:e}};window._wails=window._wails||{};var Xo=m(c.Call),$o=m(c.CancelCall),B=new Map,Qo=0,qo=0,Oe=class extends Error{constructor(e,i){super(e,i),this.name="RuntimeError"}};function _o(){let n;do n=j();while(B.has(n));return n}function ke(n){let e=_o(),i=N.withResolvers();B.set(e,{resolve:i.resolve,reject:i.reject});let o=Xo(Qo,Object.assign({"call-id":e},n)),t=!0;o.then(s=>{t=!1,B.delete(e),i.resolve(s)},s=>{t=!1,B.delete(e),i.reject(s)});let a=()=>(B.delete(e),$o(qo,{"call-id":e}).catch(s=>{}));return i.oncancelled=()=>t?a():o.then(a),i.promise}function Jo(n,...e){return ke({methodName:n,args:e})}function et(n,...e){return ke({methodID:n,args:e})}var Ie={};p(Ie,{SetText:()=>ot,Text:()=>tt});var gn=m(c.Clipboard),nt=0,it=1;function ot(n){return gn(nt,{text:n})}function tt(){return gn(it)}var Ue={};p(Ue,{GetAll:()=>lt,GetCurrent:()=>ct,GetPrimary:()=>dt});var ze=m(c.Screens),rt=0,at=1,st=2;function lt(){return ze(rt)}function dt(){return ze(at)}function ct(){return ze(st)}var je={};p(je,{Device:()=>Be,Haptics:()=>Ne});var Wn=m(c.IOS),mt=0,ut=1,Ne;(e=>{function n(i="medium"){return Wn(mt,{style:i})}e.Impact=n})(Ne||(Ne={}));var Be;(e=>{function n(){return Wn(ut)}e.Info=n})(Be||(Be={}));window._wails=window._wails||{};window._wails.invoke=C;window._wails.handlePlatformFileDrop=M.HandlePlatformFileDrop.bind(M);C("wails:runtime:ready");export{Se as Application,ie as Browser,Le as Call,O as CancelError,N as CancellablePromise,b as CancelledRejectionError,Ie as Clipboard,re as Create,te as Dialogs,le as Events,he as Flags,je as IOS,Ue as Screens,We as System,we as WML,M as Window,ee as clientId,Xe as getTransport,c as objectNames,Ye as setTransport}; +var Ge=Object.defineProperty,Cn=Object.defineProperties;var Pn=Object.getOwnPropertyDescriptors;var Ze=Object.getOwnPropertySymbols;var Tn=Object.prototype.hasOwnProperty,Mn=Object.prototype.propertyIsEnumerable;var _e=(n,e,i)=>e in n?Ge(n,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):n[e]=i,Ke=(n,e)=>{for(var i in e||(e={}))Tn.call(e,i)&&_e(n,i,e[i]);if(Ze)for(var i of Ze(e))Mn.call(e,i)&&_e(n,i,e[i]);return n},Ye=(n,e)=>Cn(n,Pn(e));var p=(n,e)=>{for(var i in e)Ge(n,i,{get:e[i],enumerable:!0})};var fe={};p(fe,{Application:()=>xe,Browser:()=>ie,Call:()=>Ue,CancelError:()=>L,CancellablePromise:()=>B,CancelledRejectionError:()=>v,Clipboard:()=>ze,Create:()=>re,Dialogs:()=>te,Events:()=>le,Flags:()=>ve,IOS:()=>Ve,Screens:()=>je,System:()=>be,WML:()=>pe,Window:()=>E,clientId:()=>ee,getTransport:()=>Qe,objectNames:()=>m,setTransport:()=>Xe});var pe={};p(pe,{Enable:()=>we,Reload:()=>dn});var ie={};p(ie,{OpenURL:()=>ne});var Sn="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";function V(n=21){let e="",i=n|0;for(;i--;)e+=Sn[Math.random()*64|0];return e}var En=window.location.origin+"/wails/runtime";var m=Object.freeze({Call:0,Clipboard:1,Application:2,Events:3,ContextMenu:4,Dialog:5,Window:6,Screens:7,System:8,Browser:9,CancelCall:10,IOS:11}),ee=V(),Z=null;function Xe(n){Z=n}function Qe(){return Z}function u(n,e=""){return function(i,o=null){return xn(n,i,e,o)}}async function xn(n,e,i,o){var d,w;if(Z)return Z.call(n,e,i,o);let t=new URL(En),r={object:n,method:e};o!=null&&(r.args=o);let a={"x-wails-client-id":ee,"Content-Type":"application/json"};i&&(a["x-wails-window-name"]=i);let l=await fetch(t,{method:"POST",headers:a,body:JSON.stringify(r)});if(!l.ok)throw new Error(await l.text());return((w=(d=l.headers.get("Content-Type"))==null?void 0:d.indexOf("application/json"))!=null?w:-1)!==-1?l.json():l.text()}var An=u(m.Browser),Rn=0;function ne(n){return An(Rn,{url:n.toString()})}var te={};p(te,{Error:()=>Bn,Info:()=>Nn,OpenFile:()=>Hn,Question:()=>oe,SaveFile:()=>Vn,Warning:()=>jn});window._wails=window._wails||{};var Fn=u(m.Dialog),On=0,kn=1,Ln=2,In=3,Un=4,zn=5;function S(n,e={}){return Fn(n,e)}function Nn(n){return S(On,n)}function jn(n){return S(kn,n)}function Bn(n){return S(Ln,n)}function oe(n){return S(In,n)}function Hn(n){var e;return(e=S(Un,n))!=null?e:[]}function Vn(n){return S(zn,n)}var le={};p(le,{Emit:()=>se,Off:()=>ni,OffAll:()=>ii,On:()=>Jn,OnMultiple:()=>ae,Once:()=>ei,Types:()=>Xn,WailsEvent:()=>I});var g=new Map,_=class{constructor(e,i,o){this.eventName=e,this.callback=i,this.maxCallbacks=o||-1}dispatch(e){try{this.callback(e)}catch(i){}return this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0)}};function qe(n){let e=g.get(n.eventName);e&&(e=e.filter(i=>i!==n),e.length===0?g.delete(n.eventName):g.set(n.eventName,e))}var re={};p(re,{Any:()=>D,Array:()=>_n,ByteSlice:()=>Zn,Events:()=>G,Map:()=>Gn,Nullable:()=>Kn,Struct:()=>Yn});function D(n){return n}function Zn(n){return n==null?"":n}function _n(n){return n===D?e=>e===null?[]:e:e=>{if(e===null)return[];for(let i=0;ii===null?{}:i:i=>{if(i===null)return{};for(let o in i)i[o]=e(i[o]);return i}}function Kn(n){return n===D?D:e=>e===null?null:n(e)}function Yn(n){let e=!0;for(let i in n)if(n[i]!==D){e=!1;break}return e?D:i=>{for(let o in n)o in i&&(i[o]=n[o](i[o]));return i}}var G={};var Xn=Object.freeze({Windows:Object.freeze({APMPowerSettingChange:"windows:APMPowerSettingChange",APMPowerStatusChange:"windows:APMPowerStatusChange",APMResumeAutomatic:"windows:APMResumeAutomatic",APMResumeSuspend:"windows:APMResumeSuspend",APMSuspend:"windows:APMSuspend",ApplicationStarted:"windows:ApplicationStarted",SystemThemeChanged:"windows:SystemThemeChanged",WebViewNavigationCompleted:"windows:WebViewNavigationCompleted",WindowActive:"windows:WindowActive",WindowBackgroundErase:"windows:WindowBackgroundErase",WindowClickActive:"windows:WindowClickActive",WindowClosing:"windows:WindowClosing",WindowDidMove:"windows:WindowDidMove",WindowDidResize:"windows:WindowDidResize",WindowDPIChanged:"windows:WindowDPIChanged",WindowDragDrop:"windows:WindowDragDrop",WindowDragEnter:"windows:WindowDragEnter",WindowDragLeave:"windows:WindowDragLeave",WindowDragOver:"windows:WindowDragOver",WindowEndMove:"windows:WindowEndMove",WindowEndResize:"windows:WindowEndResize",WindowFullscreen:"windows:WindowFullscreen",WindowHide:"windows:WindowHide",WindowInactive:"windows:WindowInactive",WindowKeyDown:"windows:WindowKeyDown",WindowKeyUp:"windows:WindowKeyUp",WindowKillFocus:"windows:WindowKillFocus",WindowNonClientHit:"windows:WindowNonClientHit",WindowNonClientMouseDown:"windows:WindowNonClientMouseDown",WindowNonClientMouseLeave:"windows:WindowNonClientMouseLeave",WindowNonClientMouseMove:"windows:WindowNonClientMouseMove",WindowNonClientMouseUp:"windows:WindowNonClientMouseUp",WindowPaint:"windows:WindowPaint",WindowRestore:"windows:WindowRestore",WindowSetFocus:"windows:WindowSetFocus",WindowShow:"windows:WindowShow",WindowStartMove:"windows:WindowStartMove",WindowStartResize:"windows:WindowStartResize",WindowUnFullscreen:"windows:WindowUnFullscreen",WindowZOrderChanged:"windows:WindowZOrderChanged",WindowMinimise:"windows:WindowMinimise",WindowUnMinimise:"windows:WindowUnMinimise",WindowMaximise:"windows:WindowMaximise",WindowUnMaximise:"windows:WindowUnMaximise"}),Mac:Object.freeze({ApplicationDidBecomeActive:"mac:ApplicationDidBecomeActive",ApplicationDidChangeBackingProperties:"mac:ApplicationDidChangeBackingProperties",ApplicationDidChangeEffectiveAppearance:"mac:ApplicationDidChangeEffectiveAppearance",ApplicationDidChangeIcon:"mac:ApplicationDidChangeIcon",ApplicationDidChangeOcclusionState:"mac:ApplicationDidChangeOcclusionState",ApplicationDidChangeScreenParameters:"mac:ApplicationDidChangeScreenParameters",ApplicationDidChangeStatusBarFrame:"mac:ApplicationDidChangeStatusBarFrame",ApplicationDidChangeStatusBarOrientation:"mac:ApplicationDidChangeStatusBarOrientation",ApplicationDidChangeTheme:"mac:ApplicationDidChangeTheme",ApplicationDidFinishLaunching:"mac:ApplicationDidFinishLaunching",ApplicationDidHide:"mac:ApplicationDidHide",ApplicationDidResignActive:"mac:ApplicationDidResignActive",ApplicationDidUnhide:"mac:ApplicationDidUnhide",ApplicationDidUpdate:"mac:ApplicationDidUpdate",ApplicationShouldHandleReopen:"mac:ApplicationShouldHandleReopen",ApplicationWillBecomeActive:"mac:ApplicationWillBecomeActive",ApplicationWillFinishLaunching:"mac:ApplicationWillFinishLaunching",ApplicationWillHide:"mac:ApplicationWillHide",ApplicationWillResignActive:"mac:ApplicationWillResignActive",ApplicationWillTerminate:"mac:ApplicationWillTerminate",ApplicationWillUnhide:"mac:ApplicationWillUnhide",ApplicationWillUpdate:"mac:ApplicationWillUpdate",MenuDidAddItem:"mac:MenuDidAddItem",MenuDidBeginTracking:"mac:MenuDidBeginTracking",MenuDidClose:"mac:MenuDidClose",MenuDidDisplayItem:"mac:MenuDidDisplayItem",MenuDidEndTracking:"mac:MenuDidEndTracking",MenuDidHighlightItem:"mac:MenuDidHighlightItem",MenuDidOpen:"mac:MenuDidOpen",MenuDidPopUp:"mac:MenuDidPopUp",MenuDidRemoveItem:"mac:MenuDidRemoveItem",MenuDidSendAction:"mac:MenuDidSendAction",MenuDidSendActionToItem:"mac:MenuDidSendActionToItem",MenuDidUpdate:"mac:MenuDidUpdate",MenuWillAddItem:"mac:MenuWillAddItem",MenuWillBeginTracking:"mac:MenuWillBeginTracking",MenuWillDisplayItem:"mac:MenuWillDisplayItem",MenuWillEndTracking:"mac:MenuWillEndTracking",MenuWillHighlightItem:"mac:MenuWillHighlightItem",MenuWillOpen:"mac:MenuWillOpen",MenuWillPopUp:"mac:MenuWillPopUp",MenuWillRemoveItem:"mac:MenuWillRemoveItem",MenuWillSendAction:"mac:MenuWillSendAction",MenuWillSendActionToItem:"mac:MenuWillSendActionToItem",MenuWillUpdate:"mac:MenuWillUpdate",WebViewDidCommitNavigation:"mac:WebViewDidCommitNavigation",WebViewDidFinishNavigation:"mac:WebViewDidFinishNavigation",WebViewDidReceiveServerRedirectForProvisionalNavigation:"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation",WebViewDidStartProvisionalNavigation:"mac:WebViewDidStartProvisionalNavigation",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",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",WindowDidZoom:"mac:WindowDidZoom",WindowFileDraggingEntered:"mac:WindowFileDraggingEntered",WindowFileDraggingExited:"mac:WindowFileDraggingExited",WindowFileDraggingPerformed:"mac:WindowFileDraggingPerformed",WindowHide:"mac:WindowHide",WindowMaximise:"mac:WindowMaximise",WindowUnMaximise:"mac:WindowUnMaximise",WindowMinimise:"mac:WindowMinimise",WindowUnMinimise:"mac:WindowUnMinimise",WindowShouldClose:"mac:WindowShouldClose",WindowShow:"mac:WindowShow",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",WindowZoomIn:"mac:WindowZoomIn",WindowZoomOut:"mac:WindowZoomOut",WindowZoomReset:"mac:WindowZoomReset"}),Linux:Object.freeze({ApplicationStartup:"linux:ApplicationStartup",SystemThemeChanged:"linux:SystemThemeChanged",WindowDeleteEvent:"linux:WindowDeleteEvent",WindowDidMove:"linux:WindowDidMove",WindowDidResize:"linux:WindowDidResize",WindowFocusIn:"linux:WindowFocusIn",WindowFocusOut:"linux:WindowFocusOut",WindowLoadStarted:"linux:WindowLoadStarted",WindowLoadRedirected:"linux:WindowLoadRedirected",WindowLoadCommitted:"linux:WindowLoadCommitted",WindowLoadFinished:"linux:WindowLoadFinished"}),iOS:Object.freeze({ApplicationDidBecomeActive:"ios:ApplicationDidBecomeActive",ApplicationDidEnterBackground:"ios:ApplicationDidEnterBackground",ApplicationDidFinishLaunching:"ios:ApplicationDidFinishLaunching",ApplicationDidReceiveMemoryWarning:"ios:ApplicationDidReceiveMemoryWarning",ApplicationWillEnterForeground:"ios:ApplicationWillEnterForeground",ApplicationWillResignActive:"ios:ApplicationWillResignActive",ApplicationWillTerminate:"ios:ApplicationWillTerminate",WindowDidLoad:"ios:WindowDidLoad",WindowWillAppear:"ios:WindowWillAppear",WindowDidAppear:"ios:WindowDidAppear",WindowWillDisappear:"ios:WindowWillDisappear",WindowDidDisappear:"ios:WindowDidDisappear",WindowSafeAreaInsetsChanged:"ios:WindowSafeAreaInsetsChanged",WindowOrientationChanged:"ios:WindowOrientationChanged",WindowTouchBegan:"ios:WindowTouchBegan",WindowTouchMoved:"ios:WindowTouchMoved",WindowTouchEnded:"ios:WindowTouchEnded",WindowTouchCancelled:"ios:WindowTouchCancelled",WebViewDidStartNavigation:"ios:WebViewDidStartNavigation",WebViewDidFinishNavigation:"ios:WebViewDidFinishNavigation",WebViewDidFailNavigation:"ios:WebViewDidFailNavigation",WebViewDecidePolicyForNavigationAction:"ios:WebViewDecidePolicyForNavigationAction"}),Common:Object.freeze({ApplicationOpenedWithFile:"common:ApplicationOpenedWithFile",ApplicationStarted:"common:ApplicationStarted",ApplicationLaunchedWithUrl:"common:ApplicationLaunchedWithUrl",ThemeChanged:"common:ThemeChanged",WindowClosing:"common:WindowClosing",WindowDidMove:"common:WindowDidMove",WindowDidResize:"common:WindowDidResize",WindowDPIChanged:"common:WindowDPIChanged",WindowFilesDropped:"common:WindowFilesDropped",WindowFocus:"common:WindowFocus",WindowFullscreen:"common:WindowFullscreen",WindowHide:"common:WindowHide",WindowLostFocus:"common:WindowLostFocus",WindowMaximise:"common:WindowMaximise",WindowMinimise:"common:WindowMinimise",WindowToggleFrameless:"common:WindowToggleFrameless",WindowRestore:"common:WindowRestore",WindowRuntimeReady:"common:WindowRuntimeReady",WindowShow:"common:WindowShow",WindowUnFullscreen:"common:WindowUnFullscreen",WindowUnMaximise:"common:WindowUnMaximise",WindowUnMinimise:"common:WindowUnMinimise",WindowZoom:"common:WindowZoom",WindowZoomIn:"common:WindowZoomIn",WindowZoomOut:"common:WindowZoomOut",WindowZoomReset:"common:WindowZoomReset"})});window._wails=window._wails||{};window._wails.dispatchWailsEvent=$n;var Qn=u(m.Events),qn=0,I=class{constructor(e,i){this.name=e,this.data=i!=null?i:null}};function $n(n){let e=g.get(n.name);if(!e)return;let i=new I(n.name,n.name in G?G[n.name](n.data):n.data);"sender"in n&&(i.sender=n.sender),e=e.filter(o=>!o.dispatch(i)),e.length===0?g.delete(n.name):g.set(n.name,e)}function ae(n,e,i){let o=g.get(n)||[],t=new _(n,e,i);return o.push(t),g.set(n,o),()=>qe(t)}function Jn(n,e){return ae(n,e,-1)}function ei(n,e){return ae(n,e,1)}function ni(...n){n.forEach(e=>g.delete(e))}function ii(){g.clear()}function se(n,e){return Qn(qn,new I(n,e))}function $e(){return new MouseEvent("mousedown").buttons===0}function Je(){if(!EventTarget||!AbortSignal||!AbortController)return!1;let n=!0,e=new EventTarget,i=new AbortController;return e.addEventListener("test",()=>{n=!1},{signal:i.signal}),i.abort(),e.dispatchEvent(new CustomEvent("test")),n}function K(n){var e;return n.target instanceof HTMLElement?n.target:!(n.target instanceof HTMLElement)&&n.target instanceof Node&&(e=n.target.parentElement)!=null?e:document.body}var en=!1;document.addEventListener("DOMContentLoaded",()=>{en=!0});function nn(n){en||document.readyState==="complete"?n():document.addEventListener("DOMContentLoaded",n)}var oi="data-file-drop-target",h="file-drop-target-active",c=null,ti=0,ri=1,ai=2,si=3,li=4,di=5,ci=6,mi=7,ui=8,wi=9,pi=10,fi=11,gi=12,hi=13,Wi=14,bi=15,vi=16,yi=17,Di=18,Ci=19,Pi=20,Ti=21,Mi=22,Si=23,Ei=24,xi=25,Ai=26,Ri=27,Fi=28,Oi=29,ki=30,Li=31,Ii=32,Ui=33,zi=34,Ni=35,ji=36,Bi=37,Hi=38,Vi=39,Zi=40,_i=41,Gi=42,Ki=43,Yi=44,Xi=45,Qi=46,qi=47,$i=48,Ji=49,eo=50,no=51;function Y(n){return n?n.closest("[".concat(oi,"]")):null}function io(){var n,e,i,o;return((e=(n=window.chrome)==null?void 0:n.webview)==null?void 0:e.postMessageWithAdditionalObjects)==null?!1:((o=(i=window._wails)==null?void 0:i.flags)==null?void 0:o.enableFileDrop)===!0}function oo(n,e,i){var o,t;(t=(o=window.chrome)==null?void 0:o.webview)!=null&&t.postMessageWithAdditionalObjects&&window.chrome.webview.postMessageWithAdditionalObjects("file:drop:".concat(n,":").concat(e),i)}var ce=!1;function on(){ce=!1,c&&(c.classList.remove(h),c=null)}function tn(){var n,e;((e=(n=window._wails)==null?void 0:n.flags)==null?void 0:e.enableFileDrop)!==!1&&(ce=!0)}function rn(){on()}function an(n,e){var t,r;if(!ce||((r=(t=window._wails)==null?void 0:t.flags)==null?void 0:r.enableFileDrop)===!1)return;let i=document.elementFromPoint(n,e),o=Y(i);c&&c!==o&&c.classList.remove(h),o?(o.classList.add(h),c=o):c=null}var s=Symbol("caller"),X=class X{constructor(e=""){this[s]=u(m.Window,e);for(let i of Object.getOwnPropertyNames(X.prototype))i!=="constructor"&&typeof this[i]=="function"&&(this[i]=this[i].bind(this))}Get(e){return new X(e)}Position(){return this[s](ti)}Center(){return this[s](ri)}Close(){return this[s](ai)}DisableSizeConstraints(){return this[s](si)}EnableSizeConstraints(){return this[s](li)}Focus(){return this[s](di)}ForceReload(){return this[s](ci)}Fullscreen(){return this[s](mi)}GetScreen(){return this[s](ui)}GetZoom(){return this[s](wi)}Height(){return this[s](pi)}Hide(){return this[s](fi)}IsFocused(){return this[s](gi)}IsFullscreen(){return this[s](hi)}IsMaximised(){return this[s](Wi)}IsMinimised(){return this[s](bi)}Maximise(){return this[s](vi)}Minimise(){return this[s](yi)}Name(){return this[s](Di)}OpenDevTools(){return this[s](Ci)}RelativePosition(){return this[s](Pi)}Reload(){return this[s](Ti)}Resizable(){return this[s](Mi)}Restore(){return this[s](Si)}SetPosition(e,i){return this[s](Ei,{x:e,y:i})}SetAlwaysOnTop(e){return this[s](xi,{alwaysOnTop:e})}SetBackgroundColour(e,i,o,t){return this[s](Ai,{r:e,g:i,b:o,a:t})}SetFrameless(e){return this[s](Ri,{frameless:e})}SetFullscreenButtonEnabled(e){return this[s](Fi,{enabled:e})}SetMaxSize(e,i){return this[s](Oi,{width:e,height:i})}SetMinSize(e,i){return this[s](ki,{width:e,height:i})}SetRelativePosition(e,i){return this[s](Li,{x:e,y:i})}SetResizable(e){return this[s](Ii,{resizable:e})}SetSize(e,i){return this[s](Ui,{width:e,height:i})}SetTitle(e){return this[s](zi,{title:e})}SetZoom(e){return this[s](Ni,{zoom:e})}Show(){return this[s](ji)}Size(){return this[s](Bi)}ToggleFullscreen(){return this[s](Hi)}ToggleMaximise(){return this[s](Vi)}ToggleFrameless(){return this[s](Zi)}UnFullscreen(){return this[s](_i)}UnMaximise(){return this[s](Gi)}UnMinimise(){return this[s](Ki)}Width(){return this[s](Yi)}Zoom(){return this[s](Xi)}ZoomIn(){return this[s](Qi)}ZoomOut(){return this[s](qi)}ZoomReset(){return this[s]($i)}HandlePlatformFileDrop(e,i,o){var d,w;if(((w=(d=window._wails)==null?void 0:d.flags)==null?void 0:w.enableFileDrop)===!1)return;let t=document.elementFromPoint(i,o),r=Y(t);if(!r)return;let a={id:r.id,classList:Array.from(r.classList),attributes:{}};for(let y=0;y{var r,a,l;if(!((r=i.dataTransfer)!=null&&r.types.includes("Files")))return;if(i.preventDefault(),((l=(a=window._wails)==null?void 0:a.flags)==null?void 0:l.enableFileDrop)===!1){i.dataTransfer.dropEffect="none";return}e++;let o=document.elementFromPoint(i.clientX,i.clientY),t=Y(o);c&&c!==t&&c.classList.remove(h),t?(t.classList.add(h),i.dataTransfer.dropEffect="copy",c=t):(i.dataTransfer.dropEffect="none",c=null)},!1),n.addEventListener("dragover",i=>{var r,a,l;if(!((r=i.dataTransfer)!=null&&r.types.includes("Files")))return;if(i.preventDefault(),((l=(a=window._wails)==null?void 0:a.flags)==null?void 0:l.enableFileDrop)===!1){i.dataTransfer.dropEffect="none";return}let o=document.elementFromPoint(i.clientX,i.clientY),t=Y(o);c&&c!==t&&c.classList.remove(h),t?(t.classList.contains(h)||t.classList.add(h),i.dataTransfer.dropEffect="copy",c=t):(i.dataTransfer.dropEffect="none",c=null)},!1),n.addEventListener("dragleave",i=>{var o,t,r;(o=i.dataTransfer)!=null&&o.types.includes("Files")&&(i.preventDefault(),((r=(t=window._wails)==null?void 0:t.flags)==null?void 0:r.enableFileDrop)!==!1&&i.relatedTarget!==null&&(e--,(e===0||c&&!c.contains(i.relatedTarget))&&(c&&(c.classList.remove(h),c=null),e=0)))},!1),n.addEventListener("drop",i=>{var o,t,r;if((o=i.dataTransfer)!=null&&o.types.includes("Files")&&(i.preventDefault(),((r=(t=window._wails)==null?void 0:t.flags)==null?void 0:r.enableFileDrop)!==!1&&(e=0,c&&(c.classList.remove(h),c=null),io()))){let a=[];if(i.dataTransfer.items){for(let l of i.dataTransfer.items)if(l.kind==="file"){let d=l.getAsFile();d&&a.push(d)}}else if(i.dataTransfer.files)for(let l of i.dataTransfer.files)a.push(l);a.length>0&&oo(i.clientX,i.clientY,a)}},!1)}typeof window<"u"&&typeof document<"u"&&ro();var E=to;function ao(n,e=null){se(n,e)}function so(n,e){let i=E.Get(n),o=i[e];if(typeof o=="function")try{o.call(i)}catch(t){}}function sn(n){let e=n.currentTarget;function i(t="Yes"){if(t!=="Yes")return;let r=e.getAttribute("wml-event")||e.getAttribute("data-wml-event"),a=e.getAttribute("wml-target-window")||e.getAttribute("data-wml-target-window")||"",l=e.getAttribute("wml-window")||e.getAttribute("data-wml-window"),d=e.getAttribute("wml-openurl")||e.getAttribute("data-wml-openurl");r!==null&&ao(r),l!==null&&so(a,l),d!==null&&ne(d)}let o=e.getAttribute("wml-confirm")||e.getAttribute("data-wml-confirm");o?oe({Title:"Confirm",Message:o,Detached:!1,Buttons:[{Label:"Yes"},{Label:"No",IsDefault:!0}]}).then(i):i()}var U=Symbol("controller"),x=Symbol("triggerMap"),C=Symbol("elementCount"),me=class{constructor(){this[U]=new AbortController}set(e,i){return{signal:this[U].signal}}reset(){this[U].abort(),this[U]=new AbortController}},ue=class{constructor(){this[x]=new WeakMap,this[C]=0}set(e,i){return this[x].has(e)||this[C]++,this[x].set(e,i),{}}reset(){if(!(this[C]<=0)){for(let e of document.body.querySelectorAll("*")){if(this[C]<=0)break;let i=this[x].get(e);i!=null&&this[C]--;for(let o of i||[])e.removeEventListener(o,sn)}this[x]=new WeakMap,this[C]=0}}},ln=Je()?new me:new ue;function lo(n){let e=/\S+/g,i=n.getAttribute("wml-trigger")||n.getAttribute("data-wml-trigger")||"click",o=[],t;for(;(t=e.exec(i))!==null;)o.push(t[0]);let r=ln.set(n,o);for(let a of o)n.addEventListener(a,sn,r)}function we(){nn(dn)}function dn(){ln.reset(),document.body.querySelectorAll("[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]").forEach(lo)}window.wails=fe;we();var be={};p(be,{Capabilities:()=>po,Environment:()=>fo,IsAMD64:()=>Wo,IsARM:()=>bo,IsARM64:()=>vo,IsDarkMode:()=>wo,IsDebug:()=>We,IsLinux:()=>go,IsMac:()=>ho,IsWindows:()=>Q,invoke:()=>P});var he=u(m.System),co=0,mo=1,uo=2,ge=(function(){var n,e,i,o,t,r;try{if((e=(n=window.chrome)==null?void 0:n.webview)!=null&&e.postMessage)return window.chrome.webview.postMessage.bind(window.chrome.webview);if((t=(o=(i=window.webkit)==null?void 0:i.messageHandlers)==null?void 0:o.external)!=null&&t.postMessage)return window.webkit.messageHandlers.external.postMessage.bind(window.webkit.messageHandlers.external);if((r=window.wails)!=null&&r.invoke)return a=>window.wails.invoke(typeof a=="string"?a:JSON.stringify(a))}catch(a){}return null})();function P(n){ge==null||ge(n)}function wo(){return he(co)}async function po(){return he(uo)}function fo(){return he(mo)}function Q(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="windows"}function go(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="linux"}function ho(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="darwin"}function Wo(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="amd64"}function bo(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="arm"}function vo(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="arm64"}function We(){var n,e;return!!((e=(n=window._wails)==null?void 0:n.environment)!=null&&e.Debug)}window.addEventListener("contextmenu",Po);var yo=u(m.ContextMenu),Do=0;function Co(n,e,i,o){yo(Do,{id:n,x:e,y:i,data:o})}function Po(n){let e=K(n),i=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu").trim();if(i){n.preventDefault();let o=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu-data");Co(i,n.clientX,n.clientY,o)}else To(n,e)}function To(n,e){if(We())return;switch(window.getComputedStyle(e).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":n.preventDefault();return}if(e.isContentEditable)return;let i=window.getSelection(),o=i&&i.toString().length>0;if(o)for(let t=0;tz});function z(n){try{return window._wails.flags[n]}catch(e){throw new Error("Unable to retrieve flag '"+n+"': "+e,{cause:e})}}var N=!1,j=!1,Te=!1,R=!1,F=!1,T="",cn="auto",A=0,ye=$e();window._wails=window._wails||{};window._wails.setResizable=n=>{Te=n,Te||(R=F=!1,f())};var Me=!1;function Mo(){var i,o;let n=(o=(i=window._wails)==null?void 0:i.environment)==null?void 0:o.OS;if(n==="ios"||n==="android")return!0;let e=navigator.userAgent||navigator.vendor||window.opera||"";return/android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(e)}function Se(){if(!Me&&!Mo()){window.addEventListener("mousedown",Pe,{capture:!0}),window.addEventListener("mousemove",Pe,{capture:!0}),window.addEventListener("mouseup",Pe,{capture:!0});for(let n of["click","contextmenu","dblclick"])window.addEventListener(n,Eo,{capture:!0});Me=!0}}Se();document.addEventListener("DOMContentLoaded",Se,{once:!0});var So=0,mn=window.setInterval(()=>{if(Me){window.clearInterval(mn);return}Se(),++So>100&&window.clearInterval(mn)},50);function Eo(n){(j||F)&&(n.stopImmediatePropagation(),n.stopPropagation(),n.preventDefault())}var De=0,xo=1,Ce=2;function Pe(n){let e,i=n.buttons;switch(n.type){case"mousedown":e=De,ye||(i=A|1<Uo,Quit:()=>No,Show:()=>zo});var Ee=u(m.Application),ko=0,Lo=1,Io=2;function Uo(){return Ee(ko)}function zo(){return Ee(Lo)}function No(){return Ee(Io)}var Ue={};p(Ue,{ByID:()=>rt,ByName:()=>tt,Call:()=>Ie,RuntimeError:()=>Le});var wn=Function.prototype.toString,O=typeof Reflect=="object"&&Reflect!==null&&Reflect.apply,Ae,q;if(typeof O=="function"&&typeof Object.defineProperty=="function")try{Ae=Object.defineProperty({},"length",{get:function(){throw q}}),q={},O(function(){throw 42},null,Ae)}catch(n){n!==q&&(O=null)}else O=null;var jo=/^\s*class\b/,Fe=function(e){try{var i=wn.call(e);return jo.test(i)}catch(o){return!1}},Re=function(e){try{return Fe(e)?!1:(wn.call(e),!0)}catch(i){return!1}},$=Object.prototype.toString,Bo="[object Object]",Ho="[object Function]",Vo="[object GeneratorFunction]",Zo="[object HTMLAllCollection]",_o="[object HTML document.all class]",Go="[object HTMLCollection]",Ko=typeof Symbol=="function"&&!!Symbol.toStringTag,Yo=!(0 in[,]),Oe=function(){return!1};typeof document=="object"&&(un=document.all,$.call(un)===$.call(document.all)&&(Oe=function(e){if((Yo||!e)&&(typeof e>"u"||typeof e=="object"))try{var i=$.call(e);return(i===Zo||i===_o||i===Go||i===Bo)&&e("")==null}catch(o){}return!1}));var un;function Xo(n){if(Oe(n))return!0;if(!n||typeof n!="function"&&typeof n!="object")return!1;try{O(n,null,Ae)}catch(e){if(e!==q)return!1}return!Fe(n)&&Re(n)}function Qo(n){if(Oe(n))return!0;if(!n||typeof n!="function"&&typeof n!="object")return!1;if(Ko)return Re(n);if(Fe(n))return!1;var e=$.call(n);return e!==Ho&&e!==Vo&&!/^\[object HTML/.test(e)?!1:Re(n)}var b=O?Xo:Qo;var L=class extends Error{constructor(e,i){super(e,i),this.name="CancelError"}},v=class extends Error{constructor(e,i,o){super((o!=null?o:"Unhandled rejection in cancelled promise.")+" Reason: "+qo(i),{cause:i}),this.promise=e,this.name="CancelledRejectionError"}},W=Symbol("barrier"),ke=Symbol("cancelImpl"),hn,pn=(hn=Symbol.species)!=null?hn:Symbol("speciesPolyfill"),B=class n extends Promise{constructor(e,i){let o,t;if(super((d,w)=>{o=d,t=w}),this.constructor[pn]!==Promise)throw new TypeError("CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.");let r={promise:this,resolve:o,reject:t,get oncancelled(){return i!=null?i:null},set oncancelled(d){i=d!=null?d:void 0}},a={get root(){return a},resolving:!1,settled:!1};Object.defineProperties(this,{[W]:{configurable:!1,enumerable:!1,writable:!0,value:null},[ke]:{configurable:!1,enumerable:!1,writable:!1,value:Wn(r,a)}});let l=vn(r,a);try{e(bn(r,a),l)}catch(d){a.resolving||l(d)}}cancel(e){return new n(i=>{Promise.all([this[ke](new L("Promise cancelled.",{cause:e})),$o(this)]).then(()=>i(),()=>i())})}cancelOn(e){return e.aborted?this.cancel(e.reason):e.addEventListener("abort",()=>{this.cancel(e.reason)},{capture:!0}),this}then(e,i,o){if(!(this instanceof n))throw new TypeError("CancellablePromise.prototype.then called on an invalid object.");if(b(e)||(e=fn),b(i)||(i=gn),e===fn&&i==gn)return new n(r=>r(this));let t={};return this[W]=t,new n((r,a)=>{super.then(l=>{var d;this[W]===t&&(this[W]=null),(d=t.resolve)==null||d.call(t);try{r(e(l))}catch(w){a(w)}},l=>{var d;this[W]===t&&(this[W]=null),(d=t.resolve)==null||d.call(t);try{r(i(l))}catch(w){a(w)}})},async r=>{try{return o==null?void 0:o(r)}finally{await this.cancel(r)}})}catch(e,i){return this.then(void 0,e,i)}finally(e,i){if(!(this instanceof n))throw new TypeError("CancellablePromise.prototype.finally called on an invalid object.");return b(e)?this.then(o=>n.resolve(e()).then(()=>o),o=>n.resolve(e()).then(()=>{throw o}),i):this.then(e,e,i)}static get[(W,ke,pn)](){return Promise}static all(e){let i=Array.from(e),o=i.length===0?n.resolve(i):new n((t,r)=>{Promise.all(i).then(t,r)},t=>J(o,i,t));return o}static allSettled(e){let i=Array.from(e),o=i.length===0?n.resolve(i):new n((t,r)=>{Promise.allSettled(i).then(t,r)},t=>J(o,i,t));return o}static any(e){let i=Array.from(e),o=i.length===0?n.resolve(i):new n((t,r)=>{Promise.any(i).then(t,r)},t=>J(o,i,t));return o}static race(e){let i=Array.from(e),o=new n((t,r)=>{Promise.race(i).then(t,r)},t=>J(o,i,t));return o}static cancel(e){let i=new n(()=>{});return i.cancel(e),i}static timeout(e,i){let o=new n(()=>{});return AbortSignal&&typeof AbortSignal=="function"&&AbortSignal.timeout&&typeof AbortSignal.timeout=="function"?AbortSignal.timeout(e).addEventListener("abort",()=>{o.cancel(i)}):setTimeout(()=>{o.cancel(i)},e),o}static sleep(e,i){return new n(o=>{setTimeout(()=>o(i),e)})}static reject(e){return new n((i,o)=>o(e))}static resolve(e){return e instanceof n?e:new n(i=>i(e))}static withResolvers(){let e={oncancelled:null};return e.promise=new n((i,o)=>{e.resolve=i,e.reject=o},i=>{var o;(o=e.oncancelled)==null||o.call(e,i)}),e}};function Wn(n,e){let i;return o=>{if(e.settled||(e.settled=!0,e.reason=o,n.reject(o),Promise.prototype.then.call(n.promise,void 0,t=>{if(t!==o)throw t})),!(!e.reason||!n.oncancelled))return i=new Promise(t=>{try{t(n.oncancelled(e.reason.cause))}catch(r){Promise.reject(new v(n.promise,r,"Unhandled exception in oncancelled callback."))}}).catch(t=>{Promise.reject(new v(n.promise,t,"Unhandled rejection in oncancelled callback."))}),n.oncancelled=null,i}}function bn(n,e){return i=>{if(!e.resolving){if(e.resolving=!0,i===n.promise){if(e.settled)return;e.settled=!0,n.reject(new TypeError("A promise cannot be resolved with itself."));return}if(i!=null&&(typeof i=="object"||typeof i=="function")){let o;try{o=i.then}catch(t){e.settled=!0,n.reject(t);return}if(b(o)){try{let a=i.cancel;if(b(a)){let l=d=>{Reflect.apply(a,i,[d])};e.reason?Wn(Ye(Ke({},n),{oncancelled:l}),e)(e.reason):n.oncancelled=l}}catch(a){}let t={root:e.root,resolving:!1,get settled(){return this.root.settled},set settled(a){this.root.settled=a},get reason(){return this.root.reason}},r=vn(n,t);try{Reflect.apply(o,i,[bn(n,t),r])}catch(a){r(a)}return}}e.settled||(e.settled=!0,n.resolve(i))}}}function vn(n,e){return i=>{if(!e.resolving)if(e.resolving=!0,e.settled){try{if(i instanceof L&&e.reason instanceof L&&Object.is(i.cause,e.reason.cause))return}catch(o){}Promise.reject(new v(n.promise,i))}else e.settled=!0,n.reject(i)}}function J(n,e,i){let o=[];for(let t of e){let r;try{if(!b(t.then)||(r=t.cancel,!b(r)))continue}catch(l){continue}let a;try{a=Reflect.apply(r,t,[i])}catch(l){Promise.reject(new v(n,l,"Unhandled exception in cancel method."));continue}a&&o.push((a instanceof Promise?a:Promise.resolve(a)).catch(l=>{Promise.reject(new v(n,l,"Unhandled rejection in cancel method."))}))}return Promise.all(o)}function fn(n){return n}function gn(n){throw n}function qo(n){try{if(n instanceof Error||typeof n!="object"||n.toString!==Object.prototype.toString)return""+n}catch(e){}try{return JSON.stringify(n)}catch(e){}try{return Object.prototype.toString.call(n)}catch(e){}return""}function $o(n){var i;let e=(i=n[W])!=null?i:{};return"promise"in e||Object.assign(e,k()),n[W]==null&&(e.resolve(),n[W]=e),e.promise}var k=Promise.withResolvers;k&&typeof k=="function"?k=k.bind(Promise):k=function(){let n,e;return{promise:new Promise((o,t)=>{n=o,e=t}),resolve:n,reject:e}};window._wails=window._wails||{};var Jo=u(m.Call),et=u(m.CancelCall),H=new Map,nt=0,it=0,Le=class extends Error{constructor(e,i){super(e,i),this.name="RuntimeError"}};function ot(){let n;do n=V();while(H.has(n));return n}function Ie(n){let e=ot(),i=B.withResolvers();H.set(e,{resolve:i.resolve,reject:i.reject});let o=Jo(nt,Object.assign({"call-id":e},n)),t=!0;o.then(a=>{t=!1,H.delete(e),i.resolve(a)},a=>{t=!1,H.delete(e),i.reject(a)});let r=()=>(H.delete(e),et(it,{"call-id":e}).catch(a=>{}));return i.oncancelled=()=>t?r():o.then(r),i.promise}function tt(n,...e){return Ie({methodName:n,args:e})}function rt(n,...e){return Ie({methodID:n,args:e})}var ze={};p(ze,{SetText:()=>lt,Text:()=>dt});var yn=u(m.Clipboard),at=0,st=1;function lt(n){return yn(at,{text:n})}function dt(){return yn(st)}var je={};p(je,{GetAll:()=>wt,GetCurrent:()=>ft,GetPrimary:()=>pt});var Ne=u(m.Screens),ct=0,mt=1,ut=2;function wt(){return Ne(ct)}function pt(){return Ne(mt)}function ft(){return Ne(ut)}var Ve={};p(Ve,{Device:()=>He,Haptics:()=>Be});var Dn=u(m.IOS),gt=0,ht=1,Be;(e=>{function n(i="medium"){return Dn(gt,{style:i})}e.Impact=n})(Be||(Be={}));var He;(e=>{function n(){return Dn(ht)}e.Info=n})(He||(He={}));window._wails=window._wails||{};window._wails.invoke=P;window._wails.handlePlatformFileDrop=E.HandlePlatformFileDrop.bind(E);window._wails.handleDragEnter=tn;window._wails.handleDragLeave=rn;window._wails.handleDragOver=an;P("wails:runtime:ready");export{xe as Application,ie as Browser,Ue as Call,L as CancelError,B as CancellablePromise,v as CancelledRejectionError,ze as Clipboard,re as Create,te as Dialogs,le as Events,ve as Flags,Ve as IOS,je as Screens,be as System,pe as WML,E as Window,ee as clientId,Qe as getTransport,m as objectNames,Xe as setTransport}; diff --git a/v3/internal/generator/collect/known_events.go b/v3/internal/generator/collect/known_events.go index 111c36b7f..857071585 100644 --- a/v3/internal/generator/collect/known_events.go +++ b/v3/internal/generator/collect/known_events.go @@ -6,218 +6,217 @@ func IsKnownEvent(name string) bool { } var knownEvents = map[string]struct{}{ - "common:ApplicationOpenedWithFile": {}, - "common:ApplicationStarted": {}, - "common:ApplicationLaunchedWithUrl": {}, - "common:ThemeChanged": {}, - "common:WindowClosing": {}, - "common:WindowDidMove": {}, - "common:WindowDidResize": {}, - "common:WindowDPIChanged": {}, - "common:WindowFilesDropped": {}, - "common:WindowFocus": {}, - "common:WindowFullscreen": {}, - "common:WindowHide": {}, - "common:WindowLostFocus": {}, - "common:WindowMaximise": {}, - "common:WindowMinimise": {}, - "common:WindowToggleFrameless": {}, - "common:WindowRestore": {}, - "common:WindowRuntimeReady": {}, - "common:WindowShow": {}, - "common:WindowUnFullscreen": {}, - "common:WindowUnMaximise": {}, - "common:WindowUnMinimise": {}, - "common:WindowZoom": {}, - "common:WindowZoomIn": {}, - "common:WindowZoomOut": {}, - "common:WindowZoomReset": {}, - "common:WindowDropZoneFilesDropped": {}, - "linux:ApplicationStartup": {}, - "linux:SystemThemeChanged": {}, - "linux:WindowDeleteEvent": {}, - "linux:WindowDidMove": {}, - "linux:WindowDidResize": {}, - "linux:WindowFocusIn": {}, - "linux:WindowFocusOut": {}, - "linux:WindowLoadStarted": {}, - "linux:WindowLoadRedirected": {}, - "linux:WindowLoadCommitted": {}, - "linux:WindowLoadFinished": {}, - "mac:ApplicationDidBecomeActive": {}, - "mac:ApplicationDidChangeBackingProperties": {}, - "mac:ApplicationDidChangeEffectiveAppearance": {}, - "mac:ApplicationDidChangeIcon": {}, - "mac:ApplicationDidChangeOcclusionState": {}, - "mac:ApplicationDidChangeScreenParameters": {}, - "mac:ApplicationDidChangeStatusBarFrame": {}, - "mac:ApplicationDidChangeStatusBarOrientation": {}, - "mac:ApplicationDidChangeTheme": {}, - "mac:ApplicationDidFinishLaunching": {}, - "mac:ApplicationDidHide": {}, - "mac:ApplicationDidResignActive": {}, - "mac:ApplicationDidUnhide": {}, - "mac:ApplicationDidUpdate": {}, - "mac:ApplicationShouldHandleReopen": {}, - "mac:ApplicationWillBecomeActive": {}, - "mac:ApplicationWillFinishLaunching": {}, - "mac:ApplicationWillHide": {}, - "mac:ApplicationWillResignActive": {}, - "mac:ApplicationWillTerminate": {}, - "mac:ApplicationWillUnhide": {}, - "mac:ApplicationWillUpdate": {}, - "mac:MenuDidAddItem": {}, - "mac:MenuDidBeginTracking": {}, - "mac:MenuDidClose": {}, - "mac:MenuDidDisplayItem": {}, - "mac:MenuDidEndTracking": {}, - "mac:MenuDidHighlightItem": {}, - "mac:MenuDidOpen": {}, - "mac:MenuDidPopUp": {}, - "mac:MenuDidRemoveItem": {}, - "mac:MenuDidSendAction": {}, - "mac:MenuDidSendActionToItem": {}, - "mac:MenuDidUpdate": {}, - "mac:MenuWillAddItem": {}, - "mac:MenuWillBeginTracking": {}, - "mac:MenuWillDisplayItem": {}, - "mac:MenuWillEndTracking": {}, - "mac:MenuWillHighlightItem": {}, - "mac:MenuWillOpen": {}, - "mac:MenuWillPopUp": {}, - "mac:MenuWillRemoveItem": {}, - "mac:MenuWillSendAction": {}, - "mac:MenuWillSendActionToItem": {}, - "mac:MenuWillUpdate": {}, - "mac:WebViewDidCommitNavigation": {}, - "mac:WebViewDidFinishNavigation": {}, + "common:ApplicationOpenedWithFile": {}, + "common:ApplicationStarted": {}, + "common:ApplicationLaunchedWithUrl": {}, + "common:ThemeChanged": {}, + "common:WindowClosing": {}, + "common:WindowDidMove": {}, + "common:WindowDidResize": {}, + "common:WindowDPIChanged": {}, + "common:WindowFilesDropped": {}, + "common:WindowFocus": {}, + "common:WindowFullscreen": {}, + "common:WindowHide": {}, + "common:WindowLostFocus": {}, + "common:WindowMaximise": {}, + "common:WindowMinimise": {}, + "common:WindowToggleFrameless": {}, + "common:WindowRestore": {}, + "common:WindowRuntimeReady": {}, + "common:WindowShow": {}, + "common:WindowUnFullscreen": {}, + "common:WindowUnMaximise": {}, + "common:WindowUnMinimise": {}, + "common:WindowZoom": {}, + "common:WindowZoomIn": {}, + "common:WindowZoomOut": {}, + "common:WindowZoomReset": {}, + "linux:ApplicationStartup": {}, + "linux:SystemThemeChanged": {}, + "linux:WindowDeleteEvent": {}, + "linux:WindowDidMove": {}, + "linux:WindowDidResize": {}, + "linux:WindowFocusIn": {}, + "linux:WindowFocusOut": {}, + "linux:WindowLoadStarted": {}, + "linux:WindowLoadRedirected": {}, + "linux:WindowLoadCommitted": {}, + "linux:WindowLoadFinished": {}, + "mac:ApplicationDidBecomeActive": {}, + "mac:ApplicationDidChangeBackingProperties": {}, + "mac:ApplicationDidChangeEffectiveAppearance": {}, + "mac:ApplicationDidChangeIcon": {}, + "mac:ApplicationDidChangeOcclusionState": {}, + "mac:ApplicationDidChangeScreenParameters": {}, + "mac:ApplicationDidChangeStatusBarFrame": {}, + "mac:ApplicationDidChangeStatusBarOrientation": {}, + "mac:ApplicationDidChangeTheme": {}, + "mac:ApplicationDidFinishLaunching": {}, + "mac:ApplicationDidHide": {}, + "mac:ApplicationDidResignActive": {}, + "mac:ApplicationDidUnhide": {}, + "mac:ApplicationDidUpdate": {}, + "mac:ApplicationShouldHandleReopen": {}, + "mac:ApplicationWillBecomeActive": {}, + "mac:ApplicationWillFinishLaunching": {}, + "mac:ApplicationWillHide": {}, + "mac:ApplicationWillResignActive": {}, + "mac:ApplicationWillTerminate": {}, + "mac:ApplicationWillUnhide": {}, + "mac:ApplicationWillUpdate": {}, + "mac:MenuDidAddItem": {}, + "mac:MenuDidBeginTracking": {}, + "mac:MenuDidClose": {}, + "mac:MenuDidDisplayItem": {}, + "mac:MenuDidEndTracking": {}, + "mac:MenuDidHighlightItem": {}, + "mac:MenuDidOpen": {}, + "mac:MenuDidPopUp": {}, + "mac:MenuDidRemoveItem": {}, + "mac:MenuDidSendAction": {}, + "mac:MenuDidSendActionToItem": {}, + "mac:MenuDidUpdate": {}, + "mac:MenuWillAddItem": {}, + "mac:MenuWillBeginTracking": {}, + "mac:MenuWillDisplayItem": {}, + "mac:MenuWillEndTracking": {}, + "mac:MenuWillHighlightItem": {}, + "mac:MenuWillOpen": {}, + "mac:MenuWillPopUp": {}, + "mac:MenuWillRemoveItem": {}, + "mac:MenuWillSendAction": {}, + "mac:MenuWillSendActionToItem": {}, + "mac:MenuWillUpdate": {}, + "mac:WebViewDidCommitNavigation": {}, + "mac:WebViewDidFinishNavigation": {}, "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation": {}, - "mac:WebViewDidStartProvisionalNavigation": {}, - "mac:WindowDidBecomeKey": {}, - "mac:WindowDidBecomeMain": {}, - "mac:WindowDidBeginSheet": {}, - "mac:WindowDidChangeAlpha": {}, - "mac:WindowDidChangeBackingLocation": {}, - "mac:WindowDidChangeBackingProperties": {}, - "mac:WindowDidChangeCollectionBehavior": {}, - "mac:WindowDidChangeEffectiveAppearance": {}, - "mac:WindowDidChangeOcclusionState": {}, - "mac:WindowDidChangeOrderingMode": {}, - "mac:WindowDidChangeScreen": {}, - "mac:WindowDidChangeScreenParameters": {}, - "mac:WindowDidChangeScreenProfile": {}, - "mac:WindowDidChangeScreenSpace": {}, - "mac:WindowDidChangeScreenSpaceProperties": {}, - "mac:WindowDidChangeSharingType": {}, - "mac:WindowDidChangeSpace": {}, - "mac:WindowDidChangeSpaceOrderingMode": {}, - "mac:WindowDidChangeTitle": {}, - "mac:WindowDidChangeToolbar": {}, - "mac:WindowDidDeminiaturize": {}, - "mac:WindowDidEndSheet": {}, - "mac:WindowDidEnterFullScreen": {}, - "mac:WindowDidEnterVersionBrowser": {}, - "mac:WindowDidExitFullScreen": {}, - "mac:WindowDidExitVersionBrowser": {}, - "mac:WindowDidExpose": {}, - "mac:WindowDidFocus": {}, - "mac:WindowDidMiniaturize": {}, - "mac:WindowDidMove": {}, - "mac:WindowDidOrderOffScreen": {}, - "mac:WindowDidOrderOnScreen": {}, - "mac:WindowDidResignKey": {}, - "mac:WindowDidResignMain": {}, - "mac:WindowDidResize": {}, - "mac:WindowDidUpdate": {}, - "mac:WindowDidUpdateAlpha": {}, - "mac:WindowDidUpdateCollectionBehavior": {}, - "mac:WindowDidUpdateCollectionProperties": {}, - "mac:WindowDidUpdateShadow": {}, - "mac:WindowDidUpdateTitle": {}, - "mac:WindowDidUpdateToolbar": {}, - "mac:WindowDidZoom": {}, - "mac:WindowFileDraggingEntered": {}, - "mac:WindowFileDraggingExited": {}, - "mac:WindowFileDraggingPerformed": {}, - "mac:WindowHide": {}, - "mac:WindowMaximise": {}, - "mac:WindowUnMaximise": {}, - "mac:WindowMinimise": {}, - "mac:WindowUnMinimise": {}, - "mac:WindowShouldClose": {}, - "mac:WindowShow": {}, - "mac:WindowWillBecomeKey": {}, - "mac:WindowWillBecomeMain": {}, - "mac:WindowWillBeginSheet": {}, - "mac:WindowWillChangeOrderingMode": {}, - "mac:WindowWillClose": {}, - "mac:WindowWillDeminiaturize": {}, - "mac:WindowWillEnterFullScreen": {}, - "mac:WindowWillEnterVersionBrowser": {}, - "mac:WindowWillExitFullScreen": {}, - "mac:WindowWillExitVersionBrowser": {}, - "mac:WindowWillFocus": {}, - "mac:WindowWillMiniaturize": {}, - "mac:WindowWillMove": {}, - "mac:WindowWillOrderOffScreen": {}, - "mac:WindowWillOrderOnScreen": {}, - "mac:WindowWillResignMain": {}, - "mac:WindowWillResize": {}, - "mac:WindowWillUnfocus": {}, - "mac:WindowWillUpdate": {}, - "mac:WindowWillUpdateAlpha": {}, - "mac:WindowWillUpdateCollectionBehavior": {}, - "mac:WindowWillUpdateCollectionProperties": {}, - "mac:WindowWillUpdateShadow": {}, - "mac:WindowWillUpdateTitle": {}, - "mac:WindowWillUpdateToolbar": {}, - "mac:WindowWillUpdateVisibility": {}, - "mac:WindowWillUseStandardFrame": {}, - "mac:WindowZoomIn": {}, - "mac:WindowZoomOut": {}, - "mac:WindowZoomReset": {}, - "windows:APMPowerSettingChange": {}, - "windows:APMPowerStatusChange": {}, - "windows:APMResumeAutomatic": {}, - "windows:APMResumeSuspend": {}, - "windows:APMSuspend": {}, - "windows:ApplicationStarted": {}, - "windows:SystemThemeChanged": {}, - "windows:WebViewNavigationCompleted": {}, - "windows:WindowActive": {}, - "windows:WindowBackgroundErase": {}, - "windows:WindowClickActive": {}, - "windows:WindowClosing": {}, - "windows:WindowDidMove": {}, - "windows:WindowDidResize": {}, - "windows:WindowDPIChanged": {}, - "windows:WindowDragDrop": {}, - "windows:WindowDragEnter": {}, - "windows:WindowDragLeave": {}, - "windows:WindowDragOver": {}, - "windows:WindowEndMove": {}, - "windows:WindowEndResize": {}, - "windows:WindowFullscreen": {}, - "windows:WindowHide": {}, - "windows:WindowInactive": {}, - "windows:WindowKeyDown": {}, - "windows:WindowKeyUp": {}, - "windows:WindowKillFocus": {}, - "windows:WindowNonClientHit": {}, - "windows:WindowNonClientMouseDown": {}, - "windows:WindowNonClientMouseLeave": {}, - "windows:WindowNonClientMouseMove": {}, - "windows:WindowNonClientMouseUp": {}, - "windows:WindowPaint": {}, - "windows:WindowRestore": {}, - "windows:WindowSetFocus": {}, - "windows:WindowShow": {}, - "windows:WindowStartMove": {}, - "windows:WindowStartResize": {}, - "windows:WindowUnFullscreen": {}, - "windows:WindowZOrderChanged": {}, - "windows:WindowMinimise": {}, - "windows:WindowUnMinimise": {}, - "windows:WindowMaximise": {}, - "windows:WindowUnMaximise": {}, + "mac:WebViewDidStartProvisionalNavigation": {}, + "mac:WindowDidBecomeKey": {}, + "mac:WindowDidBecomeMain": {}, + "mac:WindowDidBeginSheet": {}, + "mac:WindowDidChangeAlpha": {}, + "mac:WindowDidChangeBackingLocation": {}, + "mac:WindowDidChangeBackingProperties": {}, + "mac:WindowDidChangeCollectionBehavior": {}, + "mac:WindowDidChangeEffectiveAppearance": {}, + "mac:WindowDidChangeOcclusionState": {}, + "mac:WindowDidChangeOrderingMode": {}, + "mac:WindowDidChangeScreen": {}, + "mac:WindowDidChangeScreenParameters": {}, + "mac:WindowDidChangeScreenProfile": {}, + "mac:WindowDidChangeScreenSpace": {}, + "mac:WindowDidChangeScreenSpaceProperties": {}, + "mac:WindowDidChangeSharingType": {}, + "mac:WindowDidChangeSpace": {}, + "mac:WindowDidChangeSpaceOrderingMode": {}, + "mac:WindowDidChangeTitle": {}, + "mac:WindowDidChangeToolbar": {}, + "mac:WindowDidDeminiaturize": {}, + "mac:WindowDidEndSheet": {}, + "mac:WindowDidEnterFullScreen": {}, + "mac:WindowDidEnterVersionBrowser": {}, + "mac:WindowDidExitFullScreen": {}, + "mac:WindowDidExitVersionBrowser": {}, + "mac:WindowDidExpose": {}, + "mac:WindowDidFocus": {}, + "mac:WindowDidMiniaturize": {}, + "mac:WindowDidMove": {}, + "mac:WindowDidOrderOffScreen": {}, + "mac:WindowDidOrderOnScreen": {}, + "mac:WindowDidResignKey": {}, + "mac:WindowDidResignMain": {}, + "mac:WindowDidResize": {}, + "mac:WindowDidUpdate": {}, + "mac:WindowDidUpdateAlpha": {}, + "mac:WindowDidUpdateCollectionBehavior": {}, + "mac:WindowDidUpdateCollectionProperties": {}, + "mac:WindowDidUpdateShadow": {}, + "mac:WindowDidUpdateTitle": {}, + "mac:WindowDidUpdateToolbar": {}, + "mac:WindowDidZoom": {}, + "mac:WindowFileDraggingEntered": {}, + "mac:WindowFileDraggingExited": {}, + "mac:WindowFileDraggingPerformed": {}, + "mac:WindowHide": {}, + "mac:WindowMaximise": {}, + "mac:WindowUnMaximise": {}, + "mac:WindowMinimise": {}, + "mac:WindowUnMinimise": {}, + "mac:WindowShouldClose": {}, + "mac:WindowShow": {}, + "mac:WindowWillBecomeKey": {}, + "mac:WindowWillBecomeMain": {}, + "mac:WindowWillBeginSheet": {}, + "mac:WindowWillChangeOrderingMode": {}, + "mac:WindowWillClose": {}, + "mac:WindowWillDeminiaturize": {}, + "mac:WindowWillEnterFullScreen": {}, + "mac:WindowWillEnterVersionBrowser": {}, + "mac:WindowWillExitFullScreen": {}, + "mac:WindowWillExitVersionBrowser": {}, + "mac:WindowWillFocus": {}, + "mac:WindowWillMiniaturize": {}, + "mac:WindowWillMove": {}, + "mac:WindowWillOrderOffScreen": {}, + "mac:WindowWillOrderOnScreen": {}, + "mac:WindowWillResignMain": {}, + "mac:WindowWillResize": {}, + "mac:WindowWillUnfocus": {}, + "mac:WindowWillUpdate": {}, + "mac:WindowWillUpdateAlpha": {}, + "mac:WindowWillUpdateCollectionBehavior": {}, + "mac:WindowWillUpdateCollectionProperties": {}, + "mac:WindowWillUpdateShadow": {}, + "mac:WindowWillUpdateTitle": {}, + "mac:WindowWillUpdateToolbar": {}, + "mac:WindowWillUpdateVisibility": {}, + "mac:WindowWillUseStandardFrame": {}, + "mac:WindowZoomIn": {}, + "mac:WindowZoomOut": {}, + "mac:WindowZoomReset": {}, + "windows:APMPowerSettingChange": {}, + "windows:APMPowerStatusChange": {}, + "windows:APMResumeAutomatic": {}, + "windows:APMResumeSuspend": {}, + "windows:APMSuspend": {}, + "windows:ApplicationStarted": {}, + "windows:SystemThemeChanged": {}, + "windows:WebViewNavigationCompleted": {}, + "windows:WindowActive": {}, + "windows:WindowBackgroundErase": {}, + "windows:WindowClickActive": {}, + "windows:WindowClosing": {}, + "windows:WindowDidMove": {}, + "windows:WindowDidResize": {}, + "windows:WindowDPIChanged": {}, + "windows:WindowDragDrop": {}, + "windows:WindowDragEnter": {}, + "windows:WindowDragLeave": {}, + "windows:WindowDragOver": {}, + "windows:WindowEndMove": {}, + "windows:WindowEndResize": {}, + "windows:WindowFullscreen": {}, + "windows:WindowHide": {}, + "windows:WindowInactive": {}, + "windows:WindowKeyDown": {}, + "windows:WindowKeyUp": {}, + "windows:WindowKillFocus": {}, + "windows:WindowNonClientHit": {}, + "windows:WindowNonClientMouseDown": {}, + "windows:WindowNonClientMouseLeave": {}, + "windows:WindowNonClientMouseMove": {}, + "windows:WindowNonClientMouseUp": {}, + "windows:WindowPaint": {}, + "windows:WindowRestore": {}, + "windows:WindowSetFocus": {}, + "windows:WindowShow": {}, + "windows:WindowStartMove": {}, + "windows:WindowStartResize": {}, + "windows:WindowUnFullscreen": {}, + "windows:WindowZOrderChanged": {}, + "windows:WindowMinimise": {}, + "windows:WindowUnMinimise": {}, + "windows:WindowMaximise": {}, + "windows:WindowUnMaximise": {}, } diff --git a/v3/internal/runtime/Taskfile.yaml b/v3/internal/runtime/Taskfile.yaml index 2bc433213..4a2a2ccf3 100644 --- a/v3/internal/runtime/Taskfile.yaml +++ b/v3/internal/runtime/Taskfile.yaml @@ -35,14 +35,38 @@ tasks: cmds: - npx esbuild@latest desktop/@wailsio/runtime/src/index.ts --inject:desktop/compiled/main.js --format=esm --target=safari11 --bundle --ignore-annotations --tree-shaking=true --minify --outfile=../assetserver/bundledassets/runtime.js --define:DEBUG=false --drop:console - build:all: + build:docs: + internal: true + dir: desktop/@wailsio/runtime + deps: + - install-deps + cmds: + - npm run build:docs + + build:docs:md: + internal: true + dir: desktop/@wailsio/runtime + deps: + - install-deps + cmds: + - npm run build:docs:md + + build:runtime: internal: true deps: - build:debug - build:production cmds: - - cmd: echo "Build Complete." + - cmd: echo "Runtime build complete." + + build:all: + internal: true + cmds: + - task: generate:events + - task: build:docs + - task: build:runtime + - echo "Build Complete." build: deps: @@ -50,8 +74,39 @@ tasks: cmds: - task: build:all + docs: + summary: Generate TypeDoc documentation for the runtime + dir: desktop/@wailsio/runtime + deps: + - install-deps + cmds: + - npm run build:docs + - echo "Documentation generated at desktop/@wailsio/runtime/docs/" + + docs:md: + summary: Generate markdown documentation for the runtime + dir: desktop/@wailsio/runtime + deps: + - install-deps + cmds: + - npm run build:docs:md + - echo "Markdown documentation generated" + generate:events: dir: ../../tasks/events cmds: - go run generate.go - go fmt ../../pkg/events/events.go + + clean: + summary: Clean built artifacts and documentation + dir: desktop/@wailsio/runtime + cmds: + - npm run clean + - echo "Cleaned runtime artifacts" + + generate: + summary: Generate events only (use runtime:build to rebuild everything) + cmds: + - task: generate:events + - echo "Events generated. Run 'wails3 task runtime:build' to rebuild runtime with updated documentation" diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json b/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json index 87d3dc6da..23919ec7b 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json +++ b/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json @@ -1584,6 +1584,7 @@ "integrity": "sha512-HL26ajjMVe/wr3xlzjF0sCPCiAKaZJcIRFZHmG4yKHRJp4YAkHPG5X6GfWxCeDTpOmuHhNiOyNKUoZjjnm0tjw==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "webidl-conversions": "^7.0.0", "whatwg-mimetype": "^3.0.0" @@ -2561,6 +2562,7 @@ "integrity": "sha512-/z585740YHURLl9DN2jCWe6OW7zKYm6VoQ93H0sxZ1cwHQEQrUn5BJrEnkWhfzUdyO+BLGjnKUZ9iz9hKloFDw==", "dev": true, "license": "Apache-2.0", + "peer": true, "dependencies": { "@gerrit0/mini-shiki": "^1.24.0", "lunr": "^2.3.9", @@ -2633,6 +2635,7 @@ "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==", "dev": true, "license": "Apache-2.0", + "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -2661,6 +2664,7 @@ "integrity": "sha512-EK5cY7Q1D8JNhSaPKVK4pwBFvaTmZxEnoKXLG/U9gmdDcihQGNzFlgIvaxezFR4glP1LsuiedwMBqCXH3wZccA==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "esbuild": "^0.21.3", "postcss": "^8.4.43", diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/event_types.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/event_types.ts index e5b00e014..db381077d 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/event_types.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/event_types.ts @@ -256,6 +256,5 @@ export const Types = Object.freeze({ WindowZoomIn: "common:WindowZoomIn", WindowZoomOut: "common:WindowZoomOut", WindowZoomReset: "common:WindowZoomReset", - WindowDropZoneFilesDropped: "common:WindowDropZoneFilesDropped", }), }); diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/index.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/index.ts index 4a6f74c46..1ea862e31 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/index.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/index.ts @@ -26,7 +26,7 @@ import * as Flags from "./flags.js"; import * as Screens from "./screens.js"; import * as System from "./system.js"; import * as IOS from "./ios.js"; -import Window from "./window.js"; +import Window, { handleDragEnter, handleDragLeave, handleDragOver } from "./window.js"; import * as WML from "./wml.js"; export { @@ -70,4 +70,9 @@ window._wails.invoke = System.invoke; // Binding ensures 'this' correctly refers to the current window instance window._wails.handlePlatformFileDrop = Window.HandlePlatformFileDrop.bind(Window); +// Linux-specific drag handlers (GTK intercepts DOM drag events) +window._wails.handleDragEnter = handleDragEnter; +window._wails.handleDragLeave = handleDragLeave; +window._wails.handleDragOver = handleDragOver; + System.invoke("wails:runtime:ready"); diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/system.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/system.ts index 660ed5c33..c4fdd6cfe 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/system.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/system.ts @@ -15,7 +15,6 @@ const call = newRuntimeCaller(objectNames.System); const SystemIsDarkMode = 0; const SystemEnvironment = 1; const SystemCapabilities = 2; -const ApplicationFilesDroppedWithContext = 100; // New method ID for enriched drop event const _invoke = (function () { try { @@ -158,35 +157,3 @@ export function IsDebug(): boolean { return Boolean((window as any)._wails?.environment?.Debug); } -/** - * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop). - * Gathers information about the drop target element and sends it back to the Go backend. - * - * @param filenames - An array of file paths (strings) that were dropped. - * @param x - The x-coordinate of the drop event. - * @param y - The y-coordinate of the drop event. - */ -export function HandlePlatformFileDrop(filenames: string[], x: number, y: number): void { - const element = document.elementFromPoint(x, y); - const elementId = element ? element.id : ''; - const classList = element ? Array.from(element.classList) : []; - - const payload = { - filenames, - x, - y, - elementId, - classList, - }; - - call(ApplicationFilesDroppedWithContext, payload) - .then(() => { - // Optional: Log success or handle if needed - console.log("Platform file drop processed and sent to Go."); - }) - .catch(err => { - // Optional: Log error - console.error("Error sending platform file drop to Go:", err); - }); -} - diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/window.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/window.ts index 69d70b442..7a80fc17a 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/window.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/window.ts @@ -11,10 +11,10 @@ The electron alternative for Go import {newRuntimeCaller, objectNames} from "./runtime.js"; import type { Screen } from "./screens.js"; -// NEW: Dropzone constants -const DROPZONE_ATTRIBUTE = 'data-wails-dropzone'; -const DROPZONE_HOVER_CLASS = 'wails-dropzone-hover'; // User can style this class -let currentHoveredDropzone: Element | null = null; +// Drop target constants +const DROP_TARGET_ATTRIBUTE = 'data-file-drop-target'; +const DROP_TARGET_ACTIVE_CLASS = 'file-drop-target-active'; +let currentDropTarget: Element | null = null; const PositionMethod = 0; const CenterMethod = 1; @@ -66,17 +66,108 @@ const ZoomInMethod = 46; const ZoomOutMethod = 47; const ZoomResetMethod = 48; const SnapAssistMethod = 49; -const WindowDropZoneDropped = 50; +const FilesDropped = 50; const PrintMethod = 51; -function getDropzoneElement(element: Element | null): Element | null { +/** + * Finds the nearest drop target element by walking up the DOM tree. + */ +function getDropTargetElement(element: Element | null): Element | null { if (!element) { return null; } - // Allow dropzone attribute to be on the element itself or any parent - return element.closest(`[${DROPZONE_ATTRIBUTE}]`); + return element.closest(`[${DROP_TARGET_ATTRIBUTE}]`); } +/** + * Check if we can use WebView2's postMessageWithAdditionalObjects (Windows) + * Also checks that EnableFileDrop is true for this window. + */ +function canResolveFilePaths(): boolean { + // Must have WebView2's postMessageWithAdditionalObjects API (Windows only) + if ((window as any).chrome?.webview?.postMessageWithAdditionalObjects == null) { + return false; + } + // Must have EnableFileDrop set to true for this window + // This flag is set by the Go backend during runtime initialization + return (window as any)._wails?.flags?.enableFileDrop === true; +} + +/** + * Send file drop to backend via WebView2 (Windows only) + */ +function resolveFilePaths(x: number, y: number, files: File[]): void { + if ((window as any).chrome?.webview?.postMessageWithAdditionalObjects) { + (window as any).chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files); + } +} + +// Native drag state (Linux/macOS intercept DOM drag events) +let nativeDragActive = false; + +/** + * Cleans up native drag state and hover effects. + * Called on drop or when drag leaves the window. + */ +function cleanupNativeDrag(): void { + nativeDragActive = false; + if (currentDropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + currentDropTarget = null; + } +} + +/** + * Called from Go when a file drag enters the window on Linux/macOS. + */ +function handleDragEnter(): void { + // Check if file drops are enabled for this window + if ((window as any)._wails?.flags?.enableFileDrop === false) { + return; // File drops disabled, don't activate drag state + } + nativeDragActive = true; +} + +/** + * Called from Go when a file drag leaves the window on Linux/macOS. + */ +function handleDragLeave(): void { + cleanupNativeDrag(); +} + +/** + * Called from Go during file drag to update hover state on Linux/macOS. + * @param x - X coordinate in CSS pixels + * @param y - Y coordinate in CSS pixels + */ +function handleDragOver(x: number, y: number): void { + if (!nativeDragActive) return; + + // Check if file drops are enabled for this window + if ((window as any)._wails?.flags?.enableFileDrop === false) { + return; // File drops disabled, don't show hover effects + } + + const targetElement = document.elementFromPoint(x, y); + const dropTarget = getDropTargetElement(targetElement); + + if (currentDropTarget && currentDropTarget !== dropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + } + + if (dropTarget) { + dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS); + currentDropTarget = dropTarget; + } else { + currentDropTarget = null; + } +} + + + +// Export the handlers for use by Go via index.ts +export { handleDragEnter, handleDragLeave, handleDragOver }; + /** * A record describing the position of a window. */ @@ -536,33 +627,34 @@ class Window { } /** - * Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop). + * Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop). * Gathers information about the drop target element and sends it back to the Go backend. * * @param filenames - An array of file paths (strings) that were dropped. - * @param x - The x-coordinate of the drop event. - * @param y - The y-coordinate of the drop event. + * @param x - The x-coordinate of the drop event (CSS pixels). + * @param y - The y-coordinate of the drop event (CSS pixels). */ HandlePlatformFileDrop(filenames: string[], x: number, y: number): void { + // Check if file drops are enabled for this window + if ((window as any)._wails?.flags?.enableFileDrop === false) { + return; // File drops disabled, ignore the drop + } + const element = document.elementFromPoint(x, y); + const dropTarget = getDropTargetElement(element); - // NEW: Check if the drop target is a valid dropzone - const dropzoneTarget = getDropzoneElement(element); - - if (!dropzoneTarget) { - console.log(`Wails Runtime: Drop on element (or no element) at ${x},${y} which is not a designated dropzone. Ignoring. Element:`, element); - // No need to call backend if not a valid dropzone target + if (!dropTarget) { + // Drop was not on a designated drop target - ignore return; } - console.log(`Wails Runtime: Drop on designated dropzone. Element at (${x}, ${y}):`, element, 'Effective dropzone:', dropzoneTarget); const elementDetails = { - id: dropzoneTarget.id, - classList: Array.from(dropzoneTarget.classList), + id: dropTarget.id, + classList: Array.from(dropTarget.classList), attributes: {} as { [key: string]: string }, }; - for (let i = 0; i < dropzoneTarget.attributes.length; i++) { - const attr = dropzoneTarget.attributes[i]; + for (let i = 0; i < dropTarget.attributes.length; i++) { + const attr = dropTarget.attributes[i]; elementDetails.attributes[attr.name] = attr.value; } @@ -573,7 +665,10 @@ class Window { elementDetails, }; - this[callerSym](WindowDropZoneDropped, payload); + this[callerSym](FilesDropped, payload); + + // Clean up native drag state after drop + cleanupNativeDrag(); } /* Triggers Windows 11 Snap Assist feature (Windows only). @@ -596,81 +691,146 @@ class Window { */ const thisWindow = new Window(''); -// NEW: Global Drag Event Listeners -function setupGlobalDropzoneListeners() { +/** + * Sets up global drag and drop event listeners for file drops. + * Handles visual feedback (hover state) and file drop processing. + */ +function setupDropTargetListeners() { const docElement = document.documentElement; - let dragEnterCounter = 0; // To handle dragenter/dragleave on child elements + let dragEnterCounter = 0; docElement.addEventListener('dragenter', (event) => { - event.preventDefault(); - if (event.dataTransfer && event.dataTransfer.types.includes('Files')) { - dragEnterCounter++; - const targetElement = document.elementFromPoint(event.clientX, event.clientY); - const dropzone = getDropzoneElement(targetElement); + if (!event.dataTransfer?.types.includes('Files')) { + return; // Only handle file drags, let other drags pass through + } + event.preventDefault(); // Always prevent default to stop browser navigation + // On Windows, check if file drops are enabled for this window + if ((window as any)._wails?.flags?.enableFileDrop === false) { + event.dataTransfer.dropEffect = 'none'; // Show "no drop" cursor + return; // File drops disabled, don't show hover effects + } + dragEnterCounter++; + + const targetElement = document.elementFromPoint(event.clientX, event.clientY); + const dropTarget = getDropTargetElement(targetElement); - // Clear previous hover regardless, then apply new if valid - if (currentHoveredDropzone && currentHoveredDropzone !== dropzone) { - currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS); - } + // Update hover state + if (currentDropTarget && currentDropTarget !== dropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + } - if (dropzone) { - dropzone.classList.add(DROPZONE_HOVER_CLASS); - event.dataTransfer.dropEffect = 'copy'; - currentHoveredDropzone = dropzone; - } else { - event.dataTransfer.dropEffect = 'none'; - currentHoveredDropzone = null; // Ensure it's cleared if no dropzone found - } + if (dropTarget) { + dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS); + event.dataTransfer.dropEffect = 'copy'; + currentDropTarget = dropTarget; + } else { + event.dataTransfer.dropEffect = 'none'; + currentDropTarget = null; } }, false); docElement.addEventListener('dragover', (event) => { - event.preventDefault(); // Necessary to allow drop - if (event.dataTransfer && event.dataTransfer.types.includes('Files')) { - // No need to query elementFromPoint again if already handled by dragenter correctly - // Just ensure dropEffect is continuously set based on currentHoveredDropzone - if (currentHoveredDropzone) { - // Re-apply class just in case it was removed by some other JS - if(!currentHoveredDropzone.classList.contains(DROPZONE_HOVER_CLASS)) { - currentHoveredDropzone.classList.add(DROPZONE_HOVER_CLASS); - } - event.dataTransfer.dropEffect = 'copy'; - } else { - event.dataTransfer.dropEffect = 'none'; + if (!event.dataTransfer?.types.includes('Files')) { + return; // Only handle file drags + } + event.preventDefault(); // Always prevent default to stop browser navigation + // On Windows, check if file drops are enabled for this window + if ((window as any)._wails?.flags?.enableFileDrop === false) { + event.dataTransfer.dropEffect = 'none'; // Show "no drop" cursor + return; // File drops disabled, don't show hover effects + } + + // Update drop target as cursor moves + const targetElement = document.elementFromPoint(event.clientX, event.clientY); + const dropTarget = getDropTargetElement(targetElement); + + if (currentDropTarget && currentDropTarget !== dropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + } + + if (dropTarget) { + if (!dropTarget.classList.contains(DROP_TARGET_ACTIVE_CLASS)) { + dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS); } + event.dataTransfer.dropEffect = 'copy'; + currentDropTarget = dropTarget; + } else { + event.dataTransfer.dropEffect = 'none'; + currentDropTarget = null; } }, false); docElement.addEventListener('dragleave', (event) => { - event.preventDefault(); - if (event.dataTransfer && event.dataTransfer.types.includes('Files')) { - dragEnterCounter--; - // Only remove hover if drag truly left the window or the last dropzone - if (dragEnterCounter === 0 || event.relatedTarget === null || (currentHoveredDropzone && !currentHoveredDropzone.contains(event.relatedTarget as Node))) { - if (currentHoveredDropzone) { - currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS); - currentHoveredDropzone = null; - } - dragEnterCounter = 0; // Reset counter if it went negative or left window + if (!event.dataTransfer?.types.includes('Files')) { + return; + } + event.preventDefault(); // Always prevent default to stop browser navigation + // On Windows, check if file drops are enabled for this window + if ((window as any)._wails?.flags?.enableFileDrop === false) { + return; + } + + // On Linux/WebKitGTK and macOS, dragleave fires immediately with relatedTarget=null when native + // drag handling is involved. Ignore these spurious events - we'll clean up on drop instead. + if (event.relatedTarget === null) { + return; + } + + dragEnterCounter--; + + if (dragEnterCounter === 0 || + (currentDropTarget && !currentDropTarget.contains(event.relatedTarget as Node))) { + if (currentDropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + currentDropTarget = null; } + dragEnterCounter = 0; } }, false); docElement.addEventListener('drop', (event) => { - event.preventDefault(); // Prevent default browser file handling - dragEnterCounter = 0; // Reset counter - if (currentHoveredDropzone) { - currentHoveredDropzone.classList.remove(DROPZONE_HOVER_CLASS); - currentHoveredDropzone = null; + if (!event.dataTransfer?.types.includes('Files')) { + return; // Only handle file drops + } + event.preventDefault(); // Always prevent default to stop browser navigation + // On Windows, check if file drops are enabled for this window + if ((window as any)._wails?.flags?.enableFileDrop === false) { + return; + } + dragEnterCounter = 0; + + if (currentDropTarget) { + currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS); + currentDropTarget = null; + } + + // On Windows, handle file drops via JavaScript + // On macOS/Linux, native code will call HandlePlatformFileDrop + if (canResolveFilePaths()) { + const files: File[] = []; + if (event.dataTransfer.items) { + for (const item of event.dataTransfer.items) { + if (item.kind === 'file') { + const file = item.getAsFile(); + if (file) files.push(file); + } + } + } else if (event.dataTransfer.files) { + for (const file of event.dataTransfer.files) { + files.push(file); + } + } + + if (files.length > 0) { + resolveFilePaths(event.clientX, event.clientY, files); + } } - // The actual drop processing is initiated by the native side calling HandlePlatformFileDrop - // HandlePlatformFileDrop will then check if the drop was on a valid zone. }, false); } // Initialize listeners when the script loads if (typeof window !== "undefined" && typeof document !== "undefined") { - setupGlobalDropzoneListeners(); + setupDropTargetListeners(); } export default thisWindow; diff --git a/v3/internal/runtime/runtime.go b/v3/internal/runtime/runtime.go index 04b29fd4d..42fed010d 100644 --- a/v3/internal/runtime/runtime.go +++ b/v3/internal/runtime/runtime.go @@ -6,7 +6,7 @@ import ( json "github.com/goccy/go-json" ) -var runtimeInit = `window._wails=window._wails||{};window.wails=window.wails||{};` +var runtimeInit = `window._wails=window._wails||{};window._wails.flags=window._wails.flags||{};window.wails=window.wails||{};` func Core(flags map[string]any) string { flagsStr := "" diff --git a/v3/pkg/application/application.go b/v3/pkg/application/application.go index 5a8c6f068..b4d5b9cb7 100644 --- a/v3/pkg/application/application.go +++ b/v3/pkg/application/application.go @@ -239,9 +239,9 @@ type OriginInfo struct { var windowMessageBuffer = make(chan *windowMessage, 5) -// DropZoneDetails contains information about the HTML element -// at the location of a file drop. -type DropZoneDetails struct { +// DropTargetDetails contains information about the HTML element +// where files were dropped (the element with data-file-drop-target attribute). +type DropTargetDetails struct { X int `json:"x"` Y int `json:"y"` ElementID string `json:"id"` @@ -250,20 +250,20 @@ type DropZoneDetails struct { } type dragAndDropMessage struct { - windowId uint - filenames []string - X int - Y int - DropZone *DropZoneDetails + windowId uint + filenames []string + X int + Y int + DropTarget *DropTargetDetails } var windowDragAndDropBuffer = make(chan *dragAndDropMessage, 5) -func addDragAndDropMessage(windowId uint, filenames []string, dropZone *DropZoneDetails) { +func addDragAndDropMessage(windowId uint, filenames []string, dropTarget *DropTargetDetails) { windowDragAndDropBuffer <- &dragAndDropMessage{ - windowId: windowId, - filenames: filenames, - DropZone: dropZone, + windowId: windowId, + filenames: filenames, + DropTarget: dropTarget, } } @@ -619,11 +619,6 @@ func (a *App) Run() error { go func() { for { dragAndDropMessage := <-windowDragAndDropBuffer - a.Logger.Debug( - "[DragDropDebug] App.Run: Received message from windowDragAndDropBuffer", - "message", - fmt.Sprintf("%+v", dragAndDropMessage), - ) go a.handleDragAndDropMessage(dragAndDropMessage) } }() @@ -715,13 +710,7 @@ func (a *App) shutdownServices() { } func (a *App) handleDragAndDropMessage(event *dragAndDropMessage) { - a.Logger.Debug( - "[DragDropDebug] App.handleDragAndDropMessage: Called with event", - "event", - fmt.Sprintf("%+v", event), - ) defer handlePanic() - // Get window from window map a.windowsLock.Lock() window, ok := a.windows[event.windowId] a.windowsLock.Unlock() @@ -729,13 +718,7 @@ func (a *App) handleDragAndDropMessage(event *dragAndDropMessage) { a.warning("WebviewWindow #%d not found", event.windowId) return } - // Get callback from window - a.Logger.Debug( - "[DragDropDebug] App.handleDragAndDropMessage: Calling window.HandleDragAndDropMessage", - "windowID", - event.windowId, - ) - window.HandleDragAndDropMessage(event.filenames, event.DropZone) + window.handleDragAndDropMessage(event.filenames, event.DropTarget) } func (a *App) handleWindowMessage(event *windowMessage) { diff --git a/v3/pkg/application/application_darwin.go b/v3/pkg/application/application_darwin.go index 7393035c3..e6e0b080a 100644 --- a/v3/pkg/application/application_darwin.go +++ b/v3/pkg/application/application_darwin.go @@ -196,6 +196,8 @@ static void startSingleInstanceListener(const char *uniqueID) { */ import "C" import ( + "sync" + "time" "unsafe" json "github.com/goccy/go-json" @@ -414,6 +416,254 @@ func processDragItems(windowID C.uint, arr **C.char, length C.int, x C.int, y C. targetWindow.InitiateFrontendDropProcessing(filenames, int(x), int(y)) } +//export macosOnDragEnter +func macosOnDragEnter(windowID C.uint) { + window, ok := globalApplication.Window.GetByID(uint(windowID)) + if !ok || window == nil { + return + } + + // Call JavaScript to show drag entered state + window.ExecJS("window._wails.handleDragEnter();") +} + +//export macosOnDragExit +func macosOnDragExit(windowID C.uint) { + window, ok := globalApplication.Window.GetByID(uint(windowID)) + if !ok || window == nil { + return + } + + // Call JavaScript to clean up drag state + window.ExecJS("window._wails.handleDragLeave();") +} + +var ( + // Pre-allocated buffer for drag JS calls to avoid allocations + dragOverJSBuffer = make([]byte, 128) // Increased for safety + dragOverJSMutex sync.Mutex // Protects dragOverJSBuffer + dragOverJSPrefix = []byte("window._wails.handleDragOver(") + + // Cache window references to avoid repeated lookups + windowImplCache sync.Map // windowID -> *macosWebviewWindow + + // Per-window drag throttle state + dragThrottle sync.Map // windowID -> *dragThrottleState +) + +type dragThrottleState struct { + mu sync.Mutex // Protects all fields below + lastX, lastY int + timer *time.Timer + pendingX int + pendingY int + hasPending bool +} + +// clearWindowDragCache removes cached references for a window +func clearWindowDragCache(windowID uint) { + windowImplCache.Delete(windowID) + + // Cancel any pending timer + if throttleVal, ok := dragThrottle.Load(windowID); ok { + if throttle, ok := throttleVal.(*dragThrottleState); ok { + throttle.mu.Lock() + if throttle.timer != nil { + throttle.timer.Stop() + } + throttle.mu.Unlock() + } + } + dragThrottle.Delete(windowID) +} + +// writeInt writes an integer to a byte slice and returns the number of bytes written +func writeInt(buf []byte, n int) int { + if n < 0 { + if len(buf) == 0 { + return 0 + } + buf[0] = '-' + return 1 + writeInt(buf[1:], -n) + } + if n == 0 { + if len(buf) == 0 { + return 0 + } + buf[0] = '0' + return 1 + } + + // Count digits + tmp := n + digits := 0 + for tmp > 0 { + digits++ + tmp /= 10 + } + + // Bounds check + if digits > len(buf) { + return 0 + } + + // Write digits in reverse + for i := digits - 1; i >= 0; i-- { + buf[i] = byte('0' + n%10) + n /= 10 + } + return digits +} + +//export macosOnDragOver +func macosOnDragOver(windowID C.uint, x C.int, y C.int) { + winID := uint(windowID) + intX, intY := int(x), int(y) + + // Get or create throttle state + throttleKey := winID + throttleVal, _ := dragThrottle.LoadOrStore(throttleKey, &dragThrottleState{ + lastX: intX, + lastY: intY, + }) + throttle := throttleVal.(*dragThrottleState) + + throttle.mu.Lock() + + // Update pending position + throttle.pendingX = intX + throttle.pendingY = intY + throttle.hasPending = true + + // If timer is already running, just update the pending position + if throttle.timer != nil { + throttle.mu.Unlock() + return + } + + // Apply 5-pixel threshold for immediate update + dx := intX - throttle.lastX + dy := intY - throttle.lastY + if dx < 0 { + dx = -dx + } + if dy < 0 { + dy = -dy + } + + // Check if we should send an immediate update + shouldSendNow := dx >= 5 || dy >= 5 + + if shouldSendNow { + // Update last position + throttle.lastX = intX + throttle.lastY = intY + throttle.hasPending = false + + // Send this update immediately (unlock before JS call to avoid deadlock) + throttle.mu.Unlock() + sendDragUpdate(winID, intX, intY) + throttle.mu.Lock() + } + + // Start 50ms timer for next update (whether we sent now or not) + throttle.timer = time.AfterFunc(50*time.Millisecond, func() { + // Execute on main thread to ensure UI updates + InvokeSync(func() { + throttle.mu.Lock() + // Clear timer reference + throttle.timer = nil + + // Send pending update if any + if throttle.hasPending { + pendingX, pendingY := throttle.pendingX, throttle.pendingY + throttle.lastX = pendingX + throttle.lastY = pendingY + throttle.hasPending = false + throttle.mu.Unlock() + sendDragUpdate(winID, pendingX, pendingY) + } else { + throttle.mu.Unlock() + } + }) + }) + throttle.mu.Unlock() +} + +// sendDragUpdate sends the actual drag update to JavaScript +func sendDragUpdate(winID uint, x, y int) { + // Try cached implementation first + var darwinImpl *macosWebviewWindow + var needsExecJS bool + + if cached, found := windowImplCache.Load(winID); found { + darwinImpl = cached.(*macosWebviewWindow) + if darwinImpl != nil && darwinImpl.nsWindow != nil { + needsExecJS = true + } else { + // Invalid cache entry, remove it + windowImplCache.Delete(winID) + } + } + + if !needsExecJS { + // Fallback to full lookup + window, ok := globalApplication.Window.GetByID(winID) + if !ok || window == nil { + return + } + + // Type assert to WebviewWindow + webviewWindow, ok := window.(*WebviewWindow) + if !ok || webviewWindow == nil { + return + } + + // Get implementation + darwinImpl, ok = webviewWindow.impl.(*macosWebviewWindow) + if !ok { + return + } + + // Cache for next time + windowImplCache.Store(winID, darwinImpl) + needsExecJS = true + } + + if !needsExecJS || darwinImpl == nil { + return + } + + // Protect shared buffer access + dragOverJSMutex.Lock() + + // Build JS string with zero allocations + // Format: "window._wails.handleDragOver(X,Y)" + // Max length with int32 coords: 30 + 11 + 1 + 11 + 1 + 1 = 55 bytes + n := copy(dragOverJSBuffer[:], dragOverJSPrefix) + n += writeInt(dragOverJSBuffer[n:], x) + if n < len(dragOverJSBuffer) { + dragOverJSBuffer[n] = ',' + n++ + } + n += writeInt(dragOverJSBuffer[n:], y) + if n < len(dragOverJSBuffer) { + dragOverJSBuffer[n] = ')' + n++ + } + if n < len(dragOverJSBuffer) { + dragOverJSBuffer[n] = 0 // null terminate for C + } else { + // Buffer overflow - this should not happen with 128 byte buffer + dragOverJSMutex.Unlock() + return + } + + // Call JavaScript with zero allocations + darwinImpl.execJSDragOver(dragOverJSBuffer[:n+1]) // Include null terminator + dragOverJSMutex.Unlock() +} + //export processMenuItemClick func processMenuItemClick(menuID C.uint) { menuItemClicked <- uint(menuID) diff --git a/v3/pkg/application/context_window_event.go b/v3/pkg/application/context_window_event.go index a40ff9d48..ad4a97a8a 100644 --- a/v3/pkg/application/context_window_event.go +++ b/v3/pkg/application/context_window_event.go @@ -3,8 +3,8 @@ package application var blankWindowEventContext = &WindowEventContext{} const ( - droppedFiles = "droppedFiles" - dropZoneDetailsKey = "dropZoneDetails" + droppedFiles = "droppedFiles" + dropTargetDetailsKey = "dropTargetDetails" ) type WindowEventContext struct { @@ -42,33 +42,31 @@ func (c WindowEventContext) setCoordinates(x, y int) { c.data["y"] = y } -func (c WindowEventContext) setDropZoneDetails(details *DropZoneDetails) { +func (c WindowEventContext) setDropTargetDetails(details *DropTargetDetails) { if c.data == nil { c.data = make(map[string]any) } if details == nil { - c.data[dropZoneDetailsKey] = nil + c.data[dropTargetDetailsKey] = nil return } - c.data[dropZoneDetailsKey] = details + c.data[dropTargetDetailsKey] = details } -// DropZoneDetails retrieves the detailed drop zone information, if available. -func (c WindowEventContext) DropZoneDetails() *DropZoneDetails { +// DropTargetDetails retrieves information about the drop target element. +func (c WindowEventContext) DropTargetDetails() *DropTargetDetails { if c.data == nil { c.data = make(map[string]any) } - details, ok := c.data[dropZoneDetailsKey] + details, ok := c.data[dropTargetDetailsKey] if !ok { return nil } - // Explicitly type assert, handle if it's nil (though setDropZoneDetails should handle it) if details == nil { return nil } - result, ok := details.(*DropZoneDetails) + result, ok := details.(*DropTargetDetails) if !ok { - // This case indicates a programming error if data was set incorrectly return nil } return result diff --git a/v3/pkg/application/linux_cgo.go b/v3/pkg/application/linux_cgo.go index 476636ade..81706597a 100644 --- a/v3/pkg/application/linux_cgo.go +++ b/v3/pkg/application/linux_cgo.go @@ -23,11 +23,9 @@ import ( #include #include #include -#ifdef G_APPLICATION_DEFAULT_FLAGS - #define APPLICATION_DEFAULT_FLAGS G_APPLICATION_DEFAULT_FLAGS -#else - #define APPLICATION_DEFAULT_FLAGS G_APPLICATION_FLAGS_NONE -#endif +// Use NON_UNIQUE to allow multiple instances of the application to run. +// This matches the behavior of gtk_init/gtk_main used in v2. +#define APPLICATION_DEFAULT_FLAGS G_APPLICATION_NON_UNIQUE typedef struct CallbackID { @@ -87,6 +85,9 @@ void handleClick(void*); extern gboolean onButtonEvent(GtkWidget *widget, GdkEventButton *event, uintptr_t user_data); extern gboolean onMenuButtonEvent(GtkWidget *widget, GdkEventButton *event, uintptr_t user_data); extern void onUriList(char **extracted, gint x, gint y, gpointer data); +extern void onDragEnter(gpointer data); +extern void onDragLeave(gpointer data); +extern void onDragOver(gint x, gint y, gpointer data); extern gboolean onKeyPressEvent (GtkWidget *widget, GdkEventKey *event, uintptr_t user_data); extern void onProcessRequest(WebKitURISchemeRequest *request, uintptr_t user_data); extern void sendMessageToBackend(WebKitUserContentManager *contentManager, WebKitJavascriptResult *result, void *data); @@ -224,34 +225,204 @@ static int GetNumScreens(){ return 0; } -static void on_data_received(GtkWidget *widget, GdkDragContext *context, gint x, gint y, +// Handle file drops from the OS - called when drag data is received +static void on_drag_data_received(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint target_type, guint time, gpointer data) { - gint length = gtk_selection_data_get_length(selection_data); - - if (length < 0) - { - g_print("DnD failed!\n"); - gtk_drag_finish(context, FALSE, FALSE, time); + // Only process target_type 2 which is our text/uri-list + // Other target types are from internal WebKit drags + if (target_type != 2) { + return; // Don't interfere with internal drags } - gchar *uri_data = (gchar *)gtk_selection_data_get_data(selection_data); - gchar **uri_list = g_uri_list_extract_uris(uri_data); + // Check if we have valid data + if (selection_data == NULL || gtk_selection_data_get_length(selection_data) <= 0) { + gtk_drag_finish(context, FALSE, FALSE, time); + return; + } - onUriList(uri_list, x, y, data); + const gchar *uri_data = (const gchar *)gtk_selection_data_get_data(selection_data); + gchar **filenames = g_uri_list_extract_uris(uri_data); + if (filenames == NULL || filenames[0] == NULL) { + if (filenames) g_strfreev(filenames); + gtk_drag_finish(context, FALSE, FALSE, time); + return; + } - g_strfreev(uri_list); - gtk_drag_finish(context, TRUE, TRUE, time); + // Build file array for Go + GPtrArray *file_array = g_ptr_array_new(); + int iter = 0; + while (filenames[iter] != NULL) { + char *filename = g_filename_from_uri(filenames[iter], NULL, NULL); + if (filename != NULL) { + g_ptr_array_add(file_array, filename); + } + iter++; + } + g_strfreev(filenames); + + if (file_array->len > 0) { + // Get stored drop coordinates and data pointer + gint drop_x = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "drop-x")); + gint drop_y = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "drop-y")); + gpointer drop_data = g_object_get_data(G_OBJECT(widget), "drop-data"); + + // Add NULL terminator and call Go + g_ptr_array_add(file_array, NULL); + onUriList((gchar **)file_array->pdata, drop_x, drop_y, drop_data); + } + + // Cleanup + for (guint i = 0; i < file_array->len; i++) { + gpointer item = g_ptr_array_index(file_array, i); + if (item) g_free(item); + } + g_ptr_array_free(file_array, TRUE); + + // Finish the drag successfully to prevent WebKit from opening the file + gtk_drag_finish(context, TRUE, FALSE, time); } -// drag and drop tutorial: https://wiki.gnome.org/Newcomers/OldDragNDropTutorial +// Track if we've notified about drag entering +static gboolean drag_entered = FALSE; + +// Track if a drag started from within the webview (internal HTML5 drag) +static gboolean internal_drag_active = FALSE; + +// Called when a drag starts FROM this widget (internal drag) +static void on_drag_begin(GtkWidget *widget, GdkDragContext *context, gpointer data) +{ + internal_drag_active = TRUE; +} + +// Called when a drag that started from this widget ends +static void on_drag_end(GtkWidget *widget, GdkDragContext *context, gpointer data) +{ + internal_drag_active = FALSE; +} + +// Check if a drag context contains file URIs (external drop) +// Returns TRUE only for external file manager drops, FALSE for internal HTML5 drags +static gboolean is_file_drag(GdkDragContext *context) +{ + GList *targets = gdk_drag_context_list_targets(context); + + // Internal HTML5 drags have WebKit-specific targets, external file drops have text/uri-list + for (GList *l = targets; l != NULL; l = l->next) { + GdkAtom atom = GDK_POINTER_TO_ATOM(l->data); + gchar *name = gdk_atom_name(atom); + if (name) { + gboolean is_uri = g_strcmp0(name, "text/uri-list") == 0; + g_free(name); + if (is_uri) { + return TRUE; + } + } + } + return FALSE; +} + +// Handle the actual drop - called when user releases mouse button +static gboolean on_drag_drop(GtkWidget *widget, GdkDragContext *context, gint x, gint y, + guint time, gpointer data) +{ + // Only handle external file drops, let WebKit handle internal HTML5 drags + if (!is_file_drag(context)) { + return FALSE; + } + + // Reset drag entered state + drag_entered = FALSE; + + // Store coordinates for use in drag-data-received + g_object_set_data(G_OBJECT(widget), "drop-x", GINT_TO_POINTER(x)); + g_object_set_data(G_OBJECT(widget), "drop-y", GINT_TO_POINTER(y)); + g_object_set_data(G_OBJECT(widget), "drop-data", data); + + // Request the file data - this triggers drag-data-received + GdkAtom target = gdk_atom_intern("text/uri-list", FALSE); + gtk_drag_get_data(widget, context, target, time); + + return TRUE; +} + +// Handle drag-motion for hover effects on external file drags +static gboolean on_drag_motion(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time, gpointer data) +{ + // Don't handle internal HTML5 drags + if (internal_drag_active || !is_file_drag(context)) { + return FALSE; + } + + gdk_drag_status(context, GDK_ACTION_COPY, time); + + // Notify JS once when drag enters + if (!drag_entered) { + drag_entered = TRUE; + onDragEnter(data); + } + + // Send position to JS for hover effects (Go side throttles this) + onDragOver(x, y, data); + + return TRUE; +} + +// Handle drag-leave - drag exited the window +static void on_drag_leave(GtkWidget *widget, GdkDragContext *context, guint time, gpointer data) +{ + // Don't handle internal HTML5 drags + if (internal_drag_active || !is_file_drag(context)) { + return; + } + + if (drag_entered) { + drag_entered = FALSE; + onDragLeave(data); + } +} + +// Set up drag and drop handlers for external file drops with hover effects static void enableDND(GtkWidget *widget, gpointer data) { - GtkTargetEntry *target = gtk_target_entry_new("text/uri-list", 0, 0); - gtk_drag_dest_set(widget, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, target, 1, GDK_ACTION_COPY); + // Core handlers for file drop + g_signal_connect(G_OBJECT(widget), "drag-data-received", G_CALLBACK(on_drag_data_received), data); + g_signal_connect(G_OBJECT(widget), "drag-drop", G_CALLBACK(on_drag_drop), data); - signal_connect(widget, "drag-data-received", on_data_received, data); + // Hover effect handlers - return FALSE for internal drags to let WebKit handle them + g_signal_connect(G_OBJECT(widget), "drag-motion", G_CALLBACK(on_drag_motion), data); + g_signal_connect(G_OBJECT(widget), "drag-leave", G_CALLBACK(on_drag_leave), data); +} + +// Block external file drops - consume the events to prevent WebKit from navigating to files +// Returns TRUE for file drags to consume them, FALSE for internal HTML5 drags to let WebKit handle +static gboolean on_drag_drop_blocked(GtkWidget *widget, GdkDragContext *context, gint x, gint y, + guint time, gpointer data) +{ + if (!is_file_drag(context)) { + return FALSE; // Let WebKit handle internal HTML5 drags + } + // Block external file drops by finishing with failure + gtk_drag_finish(context, FALSE, FALSE, time); + return TRUE; +} + +static gboolean on_drag_motion_blocked(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time, gpointer data) +{ + if (internal_drag_active || !is_file_drag(context)) { + return FALSE; // Let WebKit handle internal HTML5 drags + } + // Show "no drop" cursor for external file drags + gdk_drag_status(context, 0, time); + return TRUE; +} + +// Set up handlers that block external file drops while allowing internal HTML5 drag-and-drop +static void disableDND(GtkWidget *widget, gpointer data) +{ + g_signal_connect(G_OBJECT(widget), "drag-drop", G_CALLBACK(on_drag_drop_blocked), data); + g_signal_connect(G_OBJECT(widget), "drag-motion", G_CALLBACK(on_drag_motion_blocked), data); } */ import "C" @@ -848,10 +1019,15 @@ func (w *linuxWebviewWindow) close() { } func (w *linuxWebviewWindow) enableDND() { - C.gtk_drag_dest_unset((*C.GtkWidget)(w.webview)) + // Pass window ID as pointer value (not pointer to ID) - same pattern as other signal handlers + winID := unsafe.Pointer(uintptr(w.parent.id)) + C.enableDND((*C.GtkWidget)(w.webview), C.gpointer(winID)) +} - windowId := C.uint(w.parent.id) - C.enableDND((*C.GtkWidget)(w.vbox), C.gpointer(&windowId)) +func (w *linuxWebviewWindow) disableDND() { + // Block external file drops while allowing internal HTML5 drag-and-drop + winID := unsafe.Pointer(uintptr(w.parent.id)) + C.disableDND((*C.GtkWidget)(w.webview), C.gpointer(winID)) } func (w *linuxWebviewWindow) execJS(js string) { @@ -869,6 +1045,61 @@ func (w *linuxWebviewWindow) execJS(js string) { }) } +// Preallocated buffer for drag-over JS calls to avoid allocations +// "window._wails.handleDragOver(XXXXX,YYYYY)" is max ~45 chars +var dragOverJSBuffer = C.CString(strings.Repeat(" ", 64)) +var emptyWorldName = C.CString("") + +// execJSDragOver executes JS for drag-over events with zero Go allocations. +// It directly writes to a preallocated C buffer. Must be called from main thread. +func (w *linuxWebviewWindow) execJSDragOver(x, y int) { + // Format: "window._wails.handleDragOver(X,Y)" + // Write directly to C buffer + buf := (*[64]byte)(unsafe.Pointer(dragOverJSBuffer)) + n := copy(buf[:], "window._wails.handleDragOver(") + n += writeInt(buf[n:], x) + buf[n] = ',' + n++ + n += writeInt(buf[n:], y) + buf[n] = ')' + n++ + buf[n] = 0 // null terminate + + C.webkit_web_view_evaluate_javascript(w.webKitWebView(), + dragOverJSBuffer, + C.long(n), + nil, + emptyWorldName, + nil, + nil, + nil) +} + +// writeInt writes an integer to a byte slice and returns the number of bytes written +func writeInt(buf []byte, n int) int { + if n < 0 { + buf[0] = '-' + return 1 + writeInt(buf[1:], -n) + } + if n == 0 { + buf[0] = '0' + return 1 + } + // Count digits + tmp := n + digits := 0 + for tmp > 0 { + digits++ + tmp /= 10 + } + // Write digits in reverse + for i := digits - 1; i >= 0; i-- { + buf[i] = byte('0' + n%10) + n /= 10 + } + return digits +} + func getMousePosition() (int, int, *Screen) { var x, y C.gint var screen *C.GdkScreen @@ -1568,6 +1799,45 @@ func onMenuButtonEvent(_ *C.GtkWidget, event *C.GdkEventButton, data C.uintptr_t return C.gboolean(0) } +//export onDragEnter +func onDragEnter(data unsafe.Pointer) { + windowId := uint(uintptr(data)) + targetWindow, ok := globalApplication.Window.GetByID(windowId) + if !ok || targetWindow == nil { + return + } + // HandleDragEnter is Linux-specific (GTK intercepts drag events) + if w, ok := targetWindow.(*WebviewWindow); ok { + w.HandleDragEnter() + } +} + +//export onDragLeave +func onDragLeave(data unsafe.Pointer) { + windowId := uint(uintptr(data)) + targetWindow, ok := globalApplication.Window.GetByID(windowId) + if !ok || targetWindow == nil { + return + } + // HandleDragLeave is Linux-specific (GTK intercepts drag events) + if w, ok := targetWindow.(*WebviewWindow); ok { + w.HandleDragLeave() + } +} + +//export onDragOver +func onDragOver(x C.gint, y C.gint, data unsafe.Pointer) { + windowId := uint(uintptr(data)) + targetWindow, ok := globalApplication.Window.GetByID(windowId) + if !ok || targetWindow == nil { + return + } + // HandleDragOver is Linux-specific (GTK intercepts drag events) + if w, ok := targetWindow.(*WebviewWindow); ok { + w.HandleDragOver(int(x), int(y)) + } +} + //export onUriList func onUriList(extracted **C.char, x C.gint, y C.gint, data unsafe.Pointer) { // Credit: https://groups.google.com/g/golang-nuts/c/bI17Bpck8K4/m/DVDa7EMtDAAJ @@ -1578,12 +1848,17 @@ func onUriList(extracted **C.char, x C.gint, y C.gint, data unsafe.Pointer) { extracted = (**C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(extracted)) + offset)) } - windowDragAndDropBuffer <- &dragAndDropMessage{ - windowId: uint(*((*C.uint)(data))), - filenames: filenames, - X: int(x), - Y: int(y), + // Window ID is stored as the pointer value itself (not pointing to memory) + // Same pattern as other signal handlers in this file + windowId := uint(uintptr(data)) + targetWindow, ok := globalApplication.Window.GetByID(windowId) + if !ok || targetWindow == nil { + globalApplication.error("onUriList could not find window with ID: %d", windowId) + return } + + // Send to frontend for drop target detection and filtering + targetWindow.InitiateFrontendDropProcessing(filenames, int(x), int(y)) } var debounceTimer *time.Timer diff --git a/v3/pkg/application/linux_purego.go b/v3/pkg/application/linux_purego.go index 5d6c1cd95..7520de4d3 100644 --- a/v3/pkg/application/linux_purego.go +++ b/v3/pkg/application/linux_purego.go @@ -393,12 +393,15 @@ func appName() string { } func appNew(name string) pointer { - GApplicationDefaultFlags := uint(0) + // Use NON_UNIQUE to allow multiple instances of the application to run + // This matches the behavior of gtk_init/gtk_main used in v2 + // G_APPLICATION_NON_UNIQUE = (1 << 5) = 32 + GApplicationNonUnique := uint(32) // Name is already sanitized by sanitizeAppName() in application_linux.go identifier := fmt.Sprintf("org.wails.%s", name) - return pointer(gtkApplicationNew(identifier, GApplicationDefaultFlags)) + return pointer(gtkApplicationNew(identifier, GApplicationNonUnique)) } func appRun(application pointer) error { diff --git a/v3/pkg/application/messageprocessor_window.go b/v3/pkg/application/messageprocessor_window.go index 1b3134c4e..85095e866 100644 --- a/v3/pkg/application/messageprocessor_window.go +++ b/v3/pkg/application/messageprocessor_window.go @@ -2,7 +2,6 @@ package application import ( "fmt" - "log/slog" "github.com/wailsapp/wails/v3/pkg/errs" ) @@ -58,7 +57,7 @@ const ( WindowZoomOut = 47 WindowZoomReset = 48 WindowSnapAssist = 49 - WindowDropZoneDropped = 50 + WindowFilesDropped = 50 WindowPrint = 51 ) @@ -112,7 +111,7 @@ var windowMethodNames = map[int]string{ WindowZoomIn: "ZoomIn", WindowZoomOut: "ZoomOut", WindowZoomReset: "ZoomReset", - WindowDropZoneDropped: "DropZoneDropped", + WindowFilesDropped: "FilesDropped", WindowSnapAssist: "SnapAssist", WindowPrint: "Print", } @@ -354,18 +353,11 @@ func (m *MessageProcessor) processWindowMethod( case WindowZoomReset: window.ZoomReset() return unit, nil - case WindowDropZoneDropped: - m.Info( - "[DragDropDebug] processWindowMethod: Entered WindowDropZoneDropped case", - ) - - slog.Info("[DragDropDebug] Raw 'args' payload string:", "data", string(req.Args.rawData)) - + case WindowFilesDropped: var payload fileDropPayload - err := req.Args.ToStruct(&payload) if err != nil { - return nil, errs.WrapInvalidWindowCallErrorf(err, "Error decoding file drop payload from 'args' parameter") + return nil, errs.WrapInvalidWindowCallErrorf(err, "error decoding file drop payload") } m.Info( "[DragDropDebug] processWindowMethod: Decoded payload from 'args'", @@ -373,30 +365,24 @@ func (m *MessageProcessor) processWindowMethod( fmt.Sprintf("%+v", payload), ) - dropDetails := &DropZoneDetails{ + dropTarget := &DropTargetDetails{ X: payload.X, Y: payload.Y, ElementID: payload.ElementDetails.ID, ClassList: payload.ElementDetails.ClassList, - Attributes: payload.ElementDetails.Attributes, // Assumes DropZoneDetails struct is updated to include this field + Attributes: payload.ElementDetails.Attributes, } wvWindow, ok := window.(*WebviewWindow) if !ok { - return nil, errs.NewInvalidWindowCallErrorf("Error: Target window is not a WebviewWindow for FilesDroppedWithContext") + return nil, errs.NewInvalidWindowCallErrorf("target window is not a WebviewWindow") } msg := &dragAndDropMessage{ - windowId: wvWindow.id, - filenames: payload.Filenames, - DropZone: dropDetails, + windowId: wvWindow.id, + filenames: payload.Filenames, + DropTarget: dropTarget, } - - m.Info( - "[DragDropDebug] processApplicationMethod: Sending message to windowDragAndDropBuffer", - "message", - fmt.Sprintf("%+v", msg), - ) windowDragAndDropBuffer <- msg return unit, nil case WindowSnapAssist: diff --git a/v3/pkg/application/webview_window.go b/v3/pkg/application/webview_window.go index 95102c048..08d21ebb3 100644 --- a/v3/pkg/application/webview_window.go +++ b/v3/pkg/application/webview_window.go @@ -1180,7 +1180,7 @@ func (w *WebviewWindow) SetFrameless(frameless bool) Window { } func (w *WebviewWindow) DispatchWailsEvent(event *CustomEvent) { - msg := fmt.Sprintf("_wails.dispatchWailsEvent(%s);", event.ToJSON()) + msg := fmt.Sprintf("window._wails.dispatchWailsEvent(%s);", event.ToJSON()) w.ExecJS(msg) } @@ -1205,37 +1205,16 @@ func (w *WebviewWindow) Error(message string, args ...any) { globalApplication.error("in window '%s': "+message, args...) } -func (w *WebviewWindow) HandleDragAndDropMessage(filenames []string, dropZone *DropZoneDetails) { - globalApplication.debug( - "[DragDropDebug] HandleDragAndDropMessage called", - "files", filenames, - "dropZone", dropZone, - ) +func (w *WebviewWindow) handleDragAndDropMessage(filenames []string, dropTarget *DropTargetDetails) { thisEvent := NewWindowEvent() - globalApplication.debug( - "[DragDropDebug] HandleDragAndDropMessage: thisEvent created", - "ctx", thisEvent.ctx, - ) ctx := newWindowEventContext() ctx.setDroppedFiles(filenames) - if dropZone != nil { // Check if dropZone details are available - ctx.setDropZoneDetails(dropZone) + if dropTarget != nil { + ctx.setDropTargetDetails(dropTarget) } thisEvent.ctx = ctx - globalApplication.debug( - "[DragDropDebug] HandleDragAndDropMessage: thisEvent.ctx assigned", - "thisEvent.ctx", thisEvent.ctx, - "ctx", ctx, - ) - listeners := w.eventListeners[uint(events.Common.WindowDropZoneFilesDropped)] - globalApplication.debug( - "[DragDropDebug] HandleDragAndDropMessage: Found listeners for WindowDropZoneFilesDropped", - "count", len(listeners), - ) - globalApplication.debug( - "[DragDropDebug] HandleDragAndDropMessage: Before calling listeners", - "thisEvent.ctx", thisEvent.ctx, - ) + + listeners := w.eventListeners[uint(events.Common.WindowFilesDropped)] for _, listener := range listeners { if listener == nil { continue @@ -1454,11 +1433,6 @@ func (w *WebviewWindow) ToggleMenuBar() { } func (w *WebviewWindow) InitiateFrontendDropProcessing(filenames []string, x int, y int) { - globalApplication.debug( - "[DragDropDebug] InitiateFrontendDropProcessing called", - "x", x, - "y", y, - ) if w.impl == nil || w.isDestroyed() { return } @@ -1470,7 +1444,7 @@ func (w *WebviewWindow) InitiateFrontendDropProcessing(filenames []string, x int } jsCall := fmt.Sprintf( - "window._wails.handlePlatformFileDrop(%s, %d, %d);", + "window.wails.Window.HandlePlatformFileDrop(%s, %d, %d);", string(filenamesJSON), x, y, @@ -1487,6 +1461,65 @@ func (w *WebviewWindow) InitiateFrontendDropProcessing(filenames []string, x int }) } +// HandleDragEnter is called when drag enters the window (Linux only, since GTK intercepts drag events) +func (w *WebviewWindow) HandleDragEnter() { + if w.impl == nil || w.isDestroyed() || !w.runtimeLoaded { + return + } + + // Reset drag hover state for new drag session + dragHover.lastSentX = 0 + dragHover.lastSentY = 0 + + w.impl.execJS("window._wails.handleDragEnter();") +} + +// Drag hover throttle state +var dragHover struct { + lastSentX int + lastSentY int +} + +// HandleDragOver is called during drag-motion to update hover state in JS +// This is called from the GTK main thread, so we can call execJS directly +func (w *WebviewWindow) HandleDragOver(x int, y int) { + if w.impl == nil || w.isDestroyed() || !w.runtimeLoaded { + return + } + + // Throttle: only send if moved at least 5 pixels + dx := x - dragHover.lastSentX + dy := y - dragHover.lastSentY + if dx < 0 { + dx = -dx + } + if dy < 0 { + dy = -dy + } + if dx < 5 && dy < 5 { + return + } + dragHover.lastSentX = x + dragHover.lastSentY = y + + // Use platform-specific zero-alloc implementation if available + if impl, ok := w.impl.(interface{ execJSDragOver(x, y int) }); ok { + impl.execJSDragOver(x, y) + } else { + w.impl.execJS(fmt.Sprintf("window._wails.handleDragOver(%d,%d)", x, y)) + } +} + +// HandleDragLeave is called when drag leaves the window +func (w *WebviewWindow) HandleDragLeave() { + if w.impl == nil || w.isDestroyed() || !w.runtimeLoaded { + return + } + + // Don't use InvokeSync - execJS already handles main thread dispatch internally + w.impl.execJS("window._wails.handleDragLeave();") +} + // SnapAssist triggers the Windows Snap Assist feature by simulating Win+Z key combination. // On Windows, this opens the snap layout options. On Linux and macOS, this is a no-op. func (w *WebviewWindow) SnapAssist() { diff --git a/v3/pkg/application/webview_window_darwin.go b/v3/pkg/application/webview_window_darwin.go index fc81974bf..baf40556c 100644 --- a/v3/pkg/application/webview_window_darwin.go +++ b/v3/pkg/application/webview_window_darwin.go @@ -352,6 +352,12 @@ void windowExecJS(void* nsWindow, const char* js) { free((void*)js); } +// Execute JS without allocation - buffer is NOT freed +void windowExecJSNoAlloc(void* nsWindow, const char* js) { + WebviewWindow* window = (WebviewWindow*)nsWindow; + [window.webView evaluateJavaScript:[NSString stringWithUTF8String:js] completionHandler:nil]; +} + // Make NSWindow backdrop translucent void windowSetTranslucent(void* nsWindow) { // Get window @@ -847,6 +853,7 @@ static void setContentProtection(void *nsWindow, bool enabled) { */ import "C" import ( + "fmt" "sync" "sync/atomic" "unsafe" @@ -1094,6 +1101,17 @@ func (w *macosWebviewWindow) execJS(js string) { }) } +// execJSDragOver executes JS for drag-over events with zero allocations +// Must be called from main thread +func (w *macosWebviewWindow) execJSDragOver(buffer []byte) { + if w.nsWindow == nil { + return + } + // Pass buffer directly to C without allocation + // Buffer must be null-terminated + C.windowExecJSNoAlloc(w.nsWindow, (*C.char)(unsafe.Pointer(&buffer[0]))) +} + func (w *macosWebviewWindow) setURL(uri string) { C.navigationLoadURL(w.nsWindow, C.CString(uri)) } @@ -1107,7 +1125,10 @@ func newWindowImpl(parent *WebviewWindow) *macosWebviewWindow { parent: parent, } result.parent.RegisterHook(events.Mac.WebViewDidFinishNavigation, func(event *WindowEvent) { - result.execJS(runtime.Core(globalApplication.impl.GetFlags(globalApplication.options))) + // Inject runtime core + js := runtime.Core(globalApplication.impl.GetFlags(globalApplication.options)) + js += fmt.Sprintf("window._wails.flags.enableFileDrop=%v;", result.parent.options.EnableFileDrop) + result.execJS(js) }) return result } @@ -1241,7 +1262,7 @@ func (w *macosWebviewWindow) run() { C.int(options.Height), C.bool(macOptions.EnableFraudulentWebsiteWarnings), C.bool(options.Frameless), - C.bool(options.EnableDragAndDrop), + C.bool(options.EnableFileDrop), w.getWebviewPreferences(), ) w.setTitle(options.Title) @@ -1477,6 +1498,8 @@ func (w *macosWebviewWindow) setPhysicalBounds(physicalBounds Rect) { func (w *macosWebviewWindow) destroy() { w.parent.markAsDestroyed() + // Clear caches for this window + clearWindowDragCache(w.parent.id) C.windowDestroy(w.nsWindow) } diff --git a/v3/pkg/application/webview_window_darwin.m b/v3/pkg/application/webview_window_darwin.m index 752e3675a..7b47ffbbd 100644 --- a/v3/pkg/application/webview_window_darwin.m +++ b/v3/pkg/application/webview_window_darwin.m @@ -196,7 +196,6 @@ typedef NS_ENUM(NSInteger, MacLiquidGlassStyle) { [super setDelegate: delegate]; // If the delegate is our WebviewWindowDelegate (which handles NSDraggingDestination) if ([delegate isKindOfClass:[WebviewWindowDelegate class]]) { - NSLog(@"WebviewWindow: setDelegate - Registering window for dragged types (NSFilenamesPboardType) because WebviewWindowDelegate is being set."); [self registerForDraggedTypes:@[NSFilenamesPboardType]]; // 'self' is the WebviewWindow instance } } @@ -246,53 +245,40 @@ typedef NS_ENUM(NSInteger, MacLiquidGlassStyle) { @end @implementation WebviewWindowDelegate - (NSDragOperation)draggingEntered:(id)sender { - NSLog(@"WebviewWindowDelegate: draggingEntered called. WindowID: %u", self.windowId); NSPasteboard *pasteboard = [sender draggingPasteboard]; if ([[pasteboard types] containsObject:NSFilenamesPboardType]) { - NSLog(@"WebviewWindowDelegate: draggingEntered - Found NSFilenamesPboardType. Firing EventWindowFileDraggingEntered."); - // We need to ensure processWindowEvent is available or adapt this part - // For now, let's assume it's available globally or via an import if (hasListeners(EventWindowFileDraggingEntered)) { processWindowEvent(self.windowId, EventWindowFileDraggingEntered); } return NSDragOperationCopy; } - NSLog(@"WebviewWindowDelegate: draggingEntered - NSFilenamesPboardType NOT found."); return NSDragOperationNone; } - (void)draggingExited:(id)sender { - NSLog(@"WebviewWindowDelegate: draggingExited called. WindowID: %u", self.windowId); if (hasListeners(EventWindowFileDraggingExited)) { processWindowEvent(self.windowId, EventWindowFileDraggingExited); } } - (BOOL)prepareForDragOperation:(id)sender { - NSLog(@"WebviewWindowDelegate: prepareForDragOperation called. WindowID: %u", self.windowId); return YES; } - (BOOL)performDragOperation:(id)sender { - NSLog(@"WebviewWindowDelegate: performDragOperation called. WindowID: %u", self.windowId); NSPasteboard *pasteboard = [sender draggingPasteboard]; if (hasListeners(EventWindowFileDraggingPerformed)) { processWindowEvent(self.windowId, EventWindowFileDraggingPerformed); } if ([[pasteboard types] containsObject:NSFilenamesPboardType]) { - NSLog(@"WebviewWindowDelegate: performDragOperation - Found NSFilenamesPboardType."); NSArray *files = [pasteboard propertyListForType:NSFilenamesPboardType]; NSUInteger count = [files count]; - NSLog(@"WebviewWindowDelegate: performDragOperation - File count: %lu", (unsigned long)count); if (count == 0) { - NSLog(@"WebviewWindowDelegate: performDragOperation - No files found in pasteboard, though type was present."); return NO; } char** cArray = (char**)malloc(count * sizeof(char*)); if (cArray == NULL) { - NSLog(@"WebviewWindowDelegate: performDragOperation - Failed to allocate memory for file array."); return NO; } for (NSUInteger i = 0; i < count; i++) { NSString* str = files[i]; - NSLog(@"WebviewWindowDelegate: performDragOperation - File %lu: %@", (unsigned long)i, str); cArray[i] = (char*)[str UTF8String]; } // Get the WebviewWindow instance, which is the dragging destination @@ -303,14 +289,10 @@ typedef NS_ENUM(NSInteger, MacLiquidGlassStyle) { CGFloat viewHeight = webView.frame.size.height; int x = (int)dropPointInView.x; int y = (int)(viewHeight - dropPointInView.y); // Flip Y for web coordinate system - NSLog(@"WebviewWindowDelegate: performDragOperation - Coords: x=%d, y=%d. ViewHeight: %f", x, y, viewHeight); - NSLog(@"WebviewWindowDelegate: performDragOperation - Calling processDragItems for windowId %u.", self.windowId); processDragItems(self.windowId, cArray, (int)count, x, y); // self.windowId is from the delegate free(cArray); - NSLog(@"WebviewWindowDelegate: performDragOperation - Returned from processDragItems."); return NO; } - NSLog(@"WebviewWindowDelegate: performDragOperation - NSFilenamesPboardType NOT found. Returning NO."); return NO; } // Original WebviewWindowDelegate methods continue here... diff --git a/v3/pkg/application/webview_window_darwin_drag.m b/v3/pkg/application/webview_window_darwin_drag.m index e5fcdc579..fb185ef98 100644 --- a/v3/pkg/application/webview_window_darwin_drag.m +++ b/v3/pkg/application/webview_window_darwin_drag.m @@ -7,6 +7,9 @@ #import "../events/events_darwin.h" extern void processDragItems(unsigned int windowId, char** arr, int length, int x, int y); +extern void macosOnDragEnter(unsigned int windowId); +extern void macosOnDragExit(unsigned int windowId); +extern void macosOnDragOver(unsigned int windowId, int x, int y); @implementation WebviewDrag @@ -14,7 +17,6 @@ extern void processDragItems(unsigned int windowId, char** arr, int length, int - (instancetype)initWithFrame:(NSRect)frameRect { self = [super initWithFrame:frameRect]; if (self) { - NSLog(@"WebviewDrag: initWithFrame - Registering for dragged types. WindowID (at init if available, might be set later): %u", self.windowId); // self.windowId might not be set here yet. [self registerForDraggedTypes:@[NSFilenamesPboardType]]; } return self; @@ -22,47 +24,65 @@ extern void processDragItems(unsigned int windowId, char** arr, int length, int // draggingEntered: - (NSDragOperation)draggingEntered:(id)sender { - NSLog(@"WebviewDrag: draggingEntered called. WindowID: %u", self.windowId); NSPasteboard *pasteboard = [sender draggingPasteboard]; if ([[pasteboard types] containsObject:NSFilenamesPboardType]) { - NSLog(@"WebviewDrag: draggingEntered - Found NSFilenamesPboardType. Firing EventWindowFileDraggingEntered."); processWindowEvent(self.windowId, EventWindowFileDraggingEntered); + // Notify JS for hover effects + macosOnDragEnter(self.windowId); + return NSDragOperationCopy; + } + return NSDragOperationNone; +} + +// draggingUpdated: +- (NSDragOperation)draggingUpdated:(id)sender { + NSPasteboard *pasteboard = [sender draggingPasteboard]; + if ([[pasteboard types] containsObject:NSFilenamesPboardType]) { + // Get the current mouse position + NSPoint dropPointInWindow = [sender draggingLocation]; + NSPoint dropPointInView = [self convertPoint:dropPointInWindow fromView:nil]; + + // Get the window's content view height for coordinate conversion + NSView *contentView = [self.window contentView]; + CGFloat contentHeight = contentView.frame.size.height; + + int x = (int)dropPointInView.x; + int y = (int)(contentHeight - dropPointInView.y); + + // Notify JS for hover effects + macosOnDragOver(self.windowId, x, y); + return NSDragOperationCopy; } - NSLog(@"WebviewDrag: draggingEntered - NSFilenamesPboardType NOT found."); return NSDragOperationNone; } // draggingExited: - (void)draggingExited:(id)sender { - NSLog(@"WebviewDrag: draggingExited called. WindowID: %u", self.windowId); // Added log processWindowEvent(self.windowId, EventWindowFileDraggingExited); + // Notify JS to clean up hover effects + macosOnDragExit(self.windowId); } // prepareForDragOperation: - (BOOL)prepareForDragOperation:(id)sender { - NSLog(@"WebviewDrag: prepareForDragOperation called. WindowID: %u", self.windowId); // Added log return YES; } // performDragOperation: - (BOOL)performDragOperation:(id)sender { - NSLog(@"WebviewDrag: performDragOperation called. WindowID: %u", self.windowId); NSPasteboard *pasteboard = [sender draggingPasteboard]; processWindowEvent(self.windowId, EventWindowFileDraggingPerformed); if ([[pasteboard types] containsObject:NSFilenamesPboardType]) { NSArray *files = [pasteboard propertyListForType:NSFilenamesPboardType]; NSUInteger count = [files count]; - NSLog(@"WebviewDrag: performDragOperation - File count: %lu", (unsigned long)count); if (count == 0) { - NSLog(@"WebviewDrag: performDragOperation - No files found in pasteboard, though type was present."); return NO; } char** cArray = (char**)malloc(count * sizeof(char*)); for (NSUInteger i = 0; i < count; i++) { NSString* str = files[i]; - NSLog(@"WebviewDrag: performDragOperation - File %lu: %@", (unsigned long)i, str); cArray[i] = (char*)[str UTF8String]; } @@ -73,18 +93,14 @@ extern void processDragItems(unsigned int windowId, char** arr, int length, int NSView *contentView = [self.window contentView]; CGFloat contentHeight = contentView.frame.size.height; - NSLog(@"WebviewDrag: Self height: %.2f, Content view height: %.2f", self.frame.size.height, contentHeight); - int x = (int)dropPointInView.x; // Use the content view height for conversion int y = (int)(contentHeight - dropPointInView.y); processDragItems(self.windowId, cArray, (int)count, x, y); free(cArray); - NSLog(@"WebviewDrag: performDragOperation - Returned from processDragItems."); return YES; } - NSLog(@"WebviewDrag: performDragOperation - NSFilenamesPboardType NOT found. Returning NO."); return NO; } diff --git a/v3/pkg/application/webview_window_linux.go b/v3/pkg/application/webview_window_linux.go index 859306d05..0400bc726 100644 --- a/v3/pkg/application/webview_window_linux.go +++ b/v3/pkg/application/webview_window_linux.go @@ -282,8 +282,10 @@ func (w *linuxWebviewWindow) run() { w.window, w.webview, w.vbox = windowNew(app.application, w.gtkmenu, w.parent.id, w.parent.options.Linux.WebviewGpuPolicy) app.registerWindow(w.window, w.parent.id) // record our mapping w.connectSignals() - if w.parent.options.EnableDragAndDrop { + if w.parent.options.EnableFileDrop { w.enableDND() + } else { + w.disableDND() } w.setTitle(w.parent.options.Title) w.setIcon(app.icon) @@ -352,7 +354,10 @@ func (w *linuxWebviewWindow) run() { }) w.parent.RegisterHook(events.Linux.WindowLoadFinished, func(e *WindowEvent) { - w.execJS(runtime.Core(globalApplication.impl.GetFlags(globalApplication.options))) + // Inject runtime core and EnableFileDrop flag together + js := runtime.Core(globalApplication.impl.GetFlags(globalApplication.options)) + js += fmt.Sprintf("window._wails.flags.enableFileDrop=%v;", w.parent.options.EnableFileDrop) + w.execJS(js) }) if w.parent.options.HTML != "" { w.setHTML(w.parent.options.HTML) diff --git a/v3/pkg/application/webview_window_options.go b/v3/pkg/application/webview_window_options.go index 8ca629559..3ae49157d 100644 --- a/v3/pkg/application/webview_window_options.go +++ b/v3/pkg/application/webview_window_options.go @@ -104,8 +104,10 @@ type WebviewWindowOptions struct { // ZoomControlEnabled will enable the zoom control. ZoomControlEnabled bool - // EnableDragAndDrop will enable drag and drop. - EnableDragAndDrop bool + // EnableFileDrop enables drag and drop of files onto the window. + // When enabled, files dragged from the OS onto elements with the + // `data-file-drop-target` attribute will trigger a FilesDropped event. + EnableFileDrop bool // OpenInspectorOnStartup will open the inspector when the window is first shown. OpenInspectorOnStartup bool @@ -182,20 +184,6 @@ const ( /******* Windows Options *******/ type BackdropType int32 -type DragEffect int32 - -const ( - // DragEffectNone is used to indicate that the drop target cannot accept the data. - DragEffectNone DragEffect = 1 - // DragEffectCopy is used to indicate that the data is copied to the drop target. - DragEffectCopy DragEffect = 2 - // DragEffectMove is used to indicate that the data is removed from the drag source. - DragEffectMove DragEffect = 3 - // DragEffectLink is used to indicate that a link to the original data is established. - DragEffectLink DragEffect = 4 - // DragEffectScroll is used to indicate that the target can be scrolled while dragging to locate a drop position that is not currently visible in the target. - -) const ( Auto BackdropType = 0 @@ -281,10 +269,6 @@ type WindowsWindow struct { // Menu is the menu to use for the window. Menu *Menu - // Drag Cursor Effects - OnEnterEffect DragEffect - OnOverEffect DragEffect - // Permissions map for WebView2. If empty, default permissions will be granted. Permissions map[CoreWebView2PermissionKind]CoreWebView2PermissionState diff --git a/v3/pkg/application/webview_window_options_test.go b/v3/pkg/application/webview_window_options_test.go index 309f3f542..4d43e123e 100644 --- a/v3/pkg/application/webview_window_options_test.go +++ b/v3/pkg/application/webview_window_options_test.go @@ -82,21 +82,6 @@ func TestBackdropType_Constants(t *testing.T) { } } -func TestDragEffect_Constants(t *testing.T) { - if DragEffectNone != 1 { - t.Error("DragEffectNone should be 1") - } - if DragEffectCopy != 2 { - t.Error("DragEffectCopy should be 2") - } - if DragEffectMove != 3 { - t.Error("DragEffectMove should be 3") - } - if DragEffectLink != 4 { - t.Error("DragEffectLink should be 4") - } -} - func TestTheme_Constants(t *testing.T) { if SystemDefault != 0 { t.Error("SystemDefault should be 0") diff --git a/v3/pkg/application/webview_window_windows.go b/v3/pkg/application/webview_window_windows.go index abc759d7b..85cd1f950 100644 --- a/v3/pkg/application/webview_window_windows.go +++ b/v3/pkg/application/webview_window_windows.go @@ -10,7 +10,6 @@ import ( "strings" "sync" "sync/atomic" - "syscall" "time" "unsafe" @@ -67,7 +66,6 @@ type windowsWebviewWindow struct { resizeBorderWidth int32 resizeBorderHeight int32 focusingChromium bool - dropTarget *w32.DropTarget onceDo sync.Once // Window move debouncer @@ -721,9 +719,6 @@ func (w *windowsWebviewWindow) setRelativePosition(x int, y int) { func (w *windowsWebviewWindow) destroy() { w.parent.markAsDestroyed() - if w.dropTarget != nil { - w.dropTarget.Release() - } // destroy the window w32.DestroyWindow(w.hwnd) } @@ -1977,66 +1972,20 @@ func (w *windowsWebviewWindow) setupChromium() { } } - if w.parent.options.EnableDragAndDrop { - if chromium.HasCapability(edge.AllowExternalDrop) { - err := chromium.AllowExternalDrag(false) - if err != nil { - globalApplication.handleFatalError(err) - } - } - - // Initialize OLE for drag-and-drop operations - w32.OleInitialise() - - w.dropTarget = w32.NewDropTarget() - w.dropTarget.OnDrop = func(files []string, x int, y int) { - w.parent.emit(events.Windows.WindowDragDrop) - globalApplication.debug("[DragDropDebug] Windows DropTarget OnDrop: Raw screen coordinates", "x", x, "y", y) - - // Convert screen coordinates to window-relative coordinates first - // Windows DropTarget gives us screen coordinates, but we need window-relative coordinates - windowRect := w32.GetWindowRect(w.hwnd) - windowRelativeX := x - int(windowRect.Left) - windowRelativeY := y - int(windowRect.Top) - - globalApplication.debug("[DragDropDebug] Windows DropTarget OnDrop: After screen-to-window conversion", "windowRelativeX", windowRelativeX, "windowRelativeY", windowRelativeY) - - // Convert window-relative coordinates to webview-relative coordinates - webviewX, webviewY := w.convertWindowToWebviewCoordinates(windowRelativeX, windowRelativeY) - globalApplication.debug("[DragDropDebug] Windows DropTarget OnDrop: Final webview coordinates", "webviewX", webviewX, "webviewY", webviewY) - w.parent.InitiateFrontendDropProcessing(files, webviewX, webviewY) - } - if opts.OnEnterEffect != 0 { - w.dropTarget.OnEnterEffect = convertEffect(opts.OnEnterEffect) - } - if opts.OnOverEffect != 0 { - w.dropTarget.OnOverEffect = convertEffect(opts.OnOverEffect) - } - w.dropTarget.OnEnter = func() { - w.parent.emit(events.Windows.WindowDragEnter) - } - w.dropTarget.OnLeave = func() { - w.parent.emit(events.Windows.WindowDragLeave) - } - w.dropTarget.OnOver = func() { - w.parent.emit(events.Windows.WindowDragOver) - } - // Enumerate all the child windows for this window and register them as drop targets - w32.EnumChildWindows(w.hwnd, func(hwnd w32.HWND, lparam w32.LPARAM) w32.LRESULT { - // Check if the window class is "Chrome_RenderWidgetHostHWND" - // If it is, then we register it as a drop target - //windowName := w32.GetClassName(hwnd) - //println(windowName) - //if windowName == "Chrome_RenderWidgetHostHWND" { - err := w32.RegisterDragDrop(hwnd, w.dropTarget) - if err != nil && !errors.Is(err, syscall.Errno(w32.DRAGDROP_E_ALREADYREGISTERED)) { - globalApplication.error("error registering drag and drop: %w", err) - } - //} - return 1 - }) - - } + // File drop handling on Windows: + // WebView2's AllowExternalDrop controls ALL drag-and-drop (both external file drops + // AND internal HTML5 drag-and-drop). We cannot disable it without breaking HTML5 DnD. + // + // When EnableFileDrop is true: + // - JS dragenter/dragover/drop events fire for external file drags + // - JS calls preventDefault() to stop the browser from navigating to the file + // - JS uses chrome.webview.postMessageWithAdditionalObjects to send file paths to Go + // - Go receives paths via processMessageWithAdditionalObjects + // + // When EnableFileDrop is false: + // - We cannot use AllowExternalDrag(false) as it breaks HTML5 internal drag-and-drop + // - JS runtime checks window._wails.flags.enableFileDrop and shows "no drop" cursor + // - The enableFileDrop flag is injected in navigationCompleted callback err = chromium.PutIsGeneralAutofillEnabled(opts.GeneralAutofillEnabled) if err != nil { @@ -2151,19 +2100,6 @@ func (w *windowsWebviewWindow) fullscreenChanged( } } -func convertEffect(effect DragEffect) w32.DWORD { - switch effect { - case DragEffectCopy: - return w32.DROPEFFECT_COPY - case DragEffectMove: - return w32.DROPEFFECT_MOVE - case DragEffectLink: - return w32.DROPEFFECT_LINK - default: - return w32.DROPEFFECT_NONE - } -} - func (w *windowsWebviewWindow) flash(enabled bool) { w32.FlashWindow(w.hwnd, enabled) } @@ -2176,6 +2112,10 @@ func (w *windowsWebviewWindow) navigationCompleted( // Install the runtime core w.execJS(runtime.Core(globalApplication.impl.GetFlags(globalApplication.options))) + // Set the EnableFileDrop flag for this window (Windows-specific) + // The JS runtime checks this before processing file drops + w.execJS(fmt.Sprintf("window._wails.flags.enableFileDrop = %v;", w.parent.options.EnableFileDrop)) + // EmitEvent DomReady ApplicationEvent windowEvents <- &windowEvent{EventID: uint(events.Windows.WebViewNavigationCompleted), WindowID: w.parent.id} @@ -2277,7 +2217,7 @@ func (w *windowsWebviewWindow) processMessageWithAdditionalObjects( sender *edge.ICoreWebView2, args *edge.ICoreWebView2WebMessageReceivedEventArgs, ) { - if strings.HasPrefix(message, "FilesDropped") { + if strings.HasPrefix(message, "file:drop:") { objs, err := args.GetAdditionalObjects() if err != nil { globalApplication.handleError(err) @@ -2319,14 +2259,14 @@ func (w *windowsWebviewWindow) processMessageWithAdditionalObjects( filenames = append(filenames, filepath) } - // Extract X/Y coordinates from message - format should be "FilesDropped:x:y" + // Extract X/Y coordinates from message - format is "file:drop:x:y" var x, y int parts := strings.Split(message, ":") - if len(parts) >= 3 { - if parsedX, err := strconv.Atoi(parts[1]); err == nil { + if len(parts) >= 4 { + if parsedX, err := strconv.Atoi(parts[2]); err == nil { x = parsedX } - if parsedY, err := strconv.Atoi(parts[2]); err == nil { + if parsedY, err := strconv.Atoi(parts[3]); err == nil { y = parsedY } } diff --git a/v3/pkg/application/window.go b/v3/pkg/application/window.go index 0e7407d8c..3f4949b16 100644 --- a/v3/pkg/application/window.go +++ b/v3/pkg/application/window.go @@ -21,7 +21,7 @@ type Window interface { GetBorderSizes() *LRTB GetScreen() (*Screen, error) GetZoom() float64 - HandleDragAndDropMessage(filenames []string, dropZone *DropZoneDetails) + handleDragAndDropMessage(filenames []string, dropTarget *DropTargetDetails) InitiateFrontendDropProcessing(filenames []string, x int, y int) HandleMessage(message string) HandleWindowEvent(id uint) diff --git a/v3/pkg/events/events.go b/v3/pkg/events/events.go index 3641b69c7..20bfcbeaa 100644 --- a/v3/pkg/events/events.go +++ b/v3/pkg/events/events.go @@ -32,7 +32,6 @@ type commonEvents struct { WindowZoomIn WindowEventType WindowZoomOut WindowEventType WindowZoomReset WindowEventType - WindowDropZoneFilesDropped WindowEventType } func newCommonEvents() commonEvents { @@ -63,7 +62,6 @@ func newCommonEvents() commonEvents { WindowZoomIn: 1047, WindowZoomOut: 1048, WindowZoomReset: 1049, - WindowDropZoneFilesDropped: 1050, } } @@ -85,17 +83,17 @@ type linuxEvents struct { func newLinuxEvents() linuxEvents { return linuxEvents{ - ApplicationStartup: 1051, - SystemThemeChanged: 1052, - WindowDeleteEvent: 1053, - WindowDidMove: 1054, - WindowDidResize: 1055, - WindowFocusIn: 1056, - WindowFocusOut: 1057, - WindowLoadStarted: 1058, - WindowLoadRedirected: 1059, - WindowLoadCommitted: 1060, - WindowLoadFinished: 1061, + ApplicationStartup: 1050, + SystemThemeChanged: 1051, + WindowDeleteEvent: 1052, + WindowDidMove: 1053, + WindowDidResize: 1054, + WindowFocusIn: 1055, + WindowFocusOut: 1056, + WindowLoadStarted: 1057, + WindowLoadRedirected: 1058, + WindowLoadCommitted: 1059, + WindowLoadFinished: 1060, } } @@ -238,138 +236,138 @@ type macEvents struct { func newMacEvents() macEvents { return macEvents{ - ApplicationDidBecomeActive: 1062, - ApplicationDidChangeBackingProperties: 1063, - ApplicationDidChangeEffectiveAppearance: 1064, - ApplicationDidChangeIcon: 1065, - ApplicationDidChangeOcclusionState: 1066, - ApplicationDidChangeScreenParameters: 1067, - ApplicationDidChangeStatusBarFrame: 1068, - ApplicationDidChangeStatusBarOrientation: 1069, - ApplicationDidChangeTheme: 1070, - ApplicationDidFinishLaunching: 1071, - ApplicationDidHide: 1072, - ApplicationDidResignActive: 1073, - ApplicationDidUnhide: 1074, - ApplicationDidUpdate: 1075, - ApplicationShouldHandleReopen: 1076, - ApplicationWillBecomeActive: 1077, - ApplicationWillFinishLaunching: 1078, - ApplicationWillHide: 1079, - ApplicationWillResignActive: 1080, - ApplicationWillTerminate: 1081, - ApplicationWillUnhide: 1082, - ApplicationWillUpdate: 1083, - MenuDidAddItem: 1084, - MenuDidBeginTracking: 1085, - MenuDidClose: 1086, - MenuDidDisplayItem: 1087, - MenuDidEndTracking: 1088, - MenuDidHighlightItem: 1089, - MenuDidOpen: 1090, - MenuDidPopUp: 1091, - MenuDidRemoveItem: 1092, - MenuDidSendAction: 1093, - MenuDidSendActionToItem: 1094, - MenuDidUpdate: 1095, - MenuWillAddItem: 1096, - MenuWillBeginTracking: 1097, - MenuWillDisplayItem: 1098, - MenuWillEndTracking: 1099, - MenuWillHighlightItem: 1100, - MenuWillOpen: 1101, - MenuWillPopUp: 1102, - MenuWillRemoveItem: 1103, - MenuWillSendAction: 1104, - MenuWillSendActionToItem: 1105, - MenuWillUpdate: 1106, - WebViewDidCommitNavigation: 1107, - WebViewDidFinishNavigation: 1108, - WebViewDidReceiveServerRedirectForProvisionalNavigation: 1109, - WebViewDidStartProvisionalNavigation: 1110, - WindowDidBecomeKey: 1111, - WindowDidBecomeMain: 1112, - WindowDidBeginSheet: 1113, - WindowDidChangeAlpha: 1114, - WindowDidChangeBackingLocation: 1115, - WindowDidChangeBackingProperties: 1116, - WindowDidChangeCollectionBehavior: 1117, - WindowDidChangeEffectiveAppearance: 1118, - WindowDidChangeOcclusionState: 1119, - WindowDidChangeOrderingMode: 1120, - WindowDidChangeScreen: 1121, - WindowDidChangeScreenParameters: 1122, - WindowDidChangeScreenProfile: 1123, - WindowDidChangeScreenSpace: 1124, - WindowDidChangeScreenSpaceProperties: 1125, - WindowDidChangeSharingType: 1126, - WindowDidChangeSpace: 1127, - WindowDidChangeSpaceOrderingMode: 1128, - WindowDidChangeTitle: 1129, - WindowDidChangeToolbar: 1130, - WindowDidDeminiaturize: 1131, - WindowDidEndSheet: 1132, - WindowDidEnterFullScreen: 1133, - WindowDidEnterVersionBrowser: 1134, - WindowDidExitFullScreen: 1135, - WindowDidExitVersionBrowser: 1136, - WindowDidExpose: 1137, - WindowDidFocus: 1138, - WindowDidMiniaturize: 1139, - WindowDidMove: 1140, - WindowDidOrderOffScreen: 1141, - WindowDidOrderOnScreen: 1142, - WindowDidResignKey: 1143, - WindowDidResignMain: 1144, - WindowDidResize: 1145, - WindowDidUpdate: 1146, - WindowDidUpdateAlpha: 1147, - WindowDidUpdateCollectionBehavior: 1148, - WindowDidUpdateCollectionProperties: 1149, - WindowDidUpdateShadow: 1150, - WindowDidUpdateTitle: 1151, - WindowDidUpdateToolbar: 1152, - WindowDidZoom: 1153, - WindowFileDraggingEntered: 1154, - WindowFileDraggingExited: 1155, - WindowFileDraggingPerformed: 1156, - WindowHide: 1157, - WindowMaximise: 1158, - WindowUnMaximise: 1159, - WindowMinimise: 1160, - WindowUnMinimise: 1161, - WindowShouldClose: 1162, - WindowShow: 1163, - WindowWillBecomeKey: 1164, - WindowWillBecomeMain: 1165, - WindowWillBeginSheet: 1166, - WindowWillChangeOrderingMode: 1167, - WindowWillClose: 1168, - WindowWillDeminiaturize: 1169, - WindowWillEnterFullScreen: 1170, - WindowWillEnterVersionBrowser: 1171, - WindowWillExitFullScreen: 1172, - WindowWillExitVersionBrowser: 1173, - WindowWillFocus: 1174, - WindowWillMiniaturize: 1175, - WindowWillMove: 1176, - WindowWillOrderOffScreen: 1177, - WindowWillOrderOnScreen: 1178, - WindowWillResignMain: 1179, - WindowWillResize: 1180, - WindowWillUnfocus: 1181, - WindowWillUpdate: 1182, - WindowWillUpdateAlpha: 1183, - WindowWillUpdateCollectionBehavior: 1184, - WindowWillUpdateCollectionProperties: 1185, - WindowWillUpdateShadow: 1186, - WindowWillUpdateTitle: 1187, - WindowWillUpdateToolbar: 1188, - WindowWillUpdateVisibility: 1189, - WindowWillUseStandardFrame: 1190, - WindowZoomIn: 1191, - WindowZoomOut: 1192, - WindowZoomReset: 1193, + ApplicationDidBecomeActive: 1061, + ApplicationDidChangeBackingProperties: 1062, + ApplicationDidChangeEffectiveAppearance: 1063, + ApplicationDidChangeIcon: 1064, + ApplicationDidChangeOcclusionState: 1065, + ApplicationDidChangeScreenParameters: 1066, + ApplicationDidChangeStatusBarFrame: 1067, + ApplicationDidChangeStatusBarOrientation: 1068, + ApplicationDidChangeTheme: 1069, + ApplicationDidFinishLaunching: 1070, + ApplicationDidHide: 1071, + ApplicationDidResignActive: 1072, + ApplicationDidUnhide: 1073, + ApplicationDidUpdate: 1074, + ApplicationShouldHandleReopen: 1075, + ApplicationWillBecomeActive: 1076, + ApplicationWillFinishLaunching: 1077, + ApplicationWillHide: 1078, + ApplicationWillResignActive: 1079, + ApplicationWillTerminate: 1080, + ApplicationWillUnhide: 1081, + ApplicationWillUpdate: 1082, + MenuDidAddItem: 1083, + MenuDidBeginTracking: 1084, + MenuDidClose: 1085, + MenuDidDisplayItem: 1086, + MenuDidEndTracking: 1087, + MenuDidHighlightItem: 1088, + MenuDidOpen: 1089, + MenuDidPopUp: 1090, + MenuDidRemoveItem: 1091, + MenuDidSendAction: 1092, + MenuDidSendActionToItem: 1093, + MenuDidUpdate: 1094, + MenuWillAddItem: 1095, + MenuWillBeginTracking: 1096, + MenuWillDisplayItem: 1097, + MenuWillEndTracking: 1098, + MenuWillHighlightItem: 1099, + MenuWillOpen: 1100, + MenuWillPopUp: 1101, + MenuWillRemoveItem: 1102, + MenuWillSendAction: 1103, + MenuWillSendActionToItem: 1104, + MenuWillUpdate: 1105, + WebViewDidCommitNavigation: 1106, + WebViewDidFinishNavigation: 1107, + WebViewDidReceiveServerRedirectForProvisionalNavigation: 1108, + WebViewDidStartProvisionalNavigation: 1109, + WindowDidBecomeKey: 1110, + WindowDidBecomeMain: 1111, + WindowDidBeginSheet: 1112, + WindowDidChangeAlpha: 1113, + WindowDidChangeBackingLocation: 1114, + WindowDidChangeBackingProperties: 1115, + WindowDidChangeCollectionBehavior: 1116, + WindowDidChangeEffectiveAppearance: 1117, + WindowDidChangeOcclusionState: 1118, + WindowDidChangeOrderingMode: 1119, + WindowDidChangeScreen: 1120, + WindowDidChangeScreenParameters: 1121, + WindowDidChangeScreenProfile: 1122, + WindowDidChangeScreenSpace: 1123, + WindowDidChangeScreenSpaceProperties: 1124, + WindowDidChangeSharingType: 1125, + WindowDidChangeSpace: 1126, + WindowDidChangeSpaceOrderingMode: 1127, + WindowDidChangeTitle: 1128, + WindowDidChangeToolbar: 1129, + WindowDidDeminiaturize: 1130, + WindowDidEndSheet: 1131, + WindowDidEnterFullScreen: 1132, + WindowDidEnterVersionBrowser: 1133, + WindowDidExitFullScreen: 1134, + WindowDidExitVersionBrowser: 1135, + WindowDidExpose: 1136, + WindowDidFocus: 1137, + WindowDidMiniaturize: 1138, + WindowDidMove: 1139, + WindowDidOrderOffScreen: 1140, + WindowDidOrderOnScreen: 1141, + WindowDidResignKey: 1142, + WindowDidResignMain: 1143, + WindowDidResize: 1144, + WindowDidUpdate: 1145, + WindowDidUpdateAlpha: 1146, + WindowDidUpdateCollectionBehavior: 1147, + WindowDidUpdateCollectionProperties: 1148, + WindowDidUpdateShadow: 1149, + WindowDidUpdateTitle: 1150, + WindowDidUpdateToolbar: 1151, + WindowDidZoom: 1152, + WindowFileDraggingEntered: 1153, + WindowFileDraggingExited: 1154, + WindowFileDraggingPerformed: 1155, + WindowHide: 1156, + WindowMaximise: 1157, + WindowUnMaximise: 1158, + WindowMinimise: 1159, + WindowUnMinimise: 1160, + WindowShouldClose: 1161, + WindowShow: 1162, + WindowWillBecomeKey: 1163, + WindowWillBecomeMain: 1164, + WindowWillBeginSheet: 1165, + WindowWillChangeOrderingMode: 1166, + WindowWillClose: 1167, + WindowWillDeminiaturize: 1168, + WindowWillEnterFullScreen: 1169, + WindowWillEnterVersionBrowser: 1170, + WindowWillExitFullScreen: 1171, + WindowWillExitVersionBrowser: 1172, + WindowWillFocus: 1173, + WindowWillMiniaturize: 1174, + WindowWillMove: 1175, + WindowWillOrderOffScreen: 1176, + WindowWillOrderOnScreen: 1177, + WindowWillResignMain: 1178, + WindowWillResize: 1179, + WindowWillUnfocus: 1180, + WindowWillUpdate: 1181, + WindowWillUpdateAlpha: 1182, + WindowWillUpdateCollectionBehavior: 1183, + WindowWillUpdateCollectionProperties: 1184, + WindowWillUpdateShadow: 1185, + WindowWillUpdateTitle: 1186, + WindowWillUpdateToolbar: 1187, + WindowWillUpdateVisibility: 1188, + WindowWillUseStandardFrame: 1189, + WindowZoomIn: 1190, + WindowZoomOut: 1191, + WindowZoomReset: 1192, } } @@ -424,50 +422,50 @@ type windowsEvents struct { func newWindowsEvents() windowsEvents { return windowsEvents{ - APMPowerSettingChange: 1194, - APMPowerStatusChange: 1195, - APMResumeAutomatic: 1196, - APMResumeSuspend: 1197, - APMSuspend: 1198, - ApplicationStarted: 1199, - SystemThemeChanged: 1200, - WebViewNavigationCompleted: 1201, - WindowActive: 1202, - WindowBackgroundErase: 1203, - WindowClickActive: 1204, - WindowClosing: 1205, - WindowDidMove: 1206, - WindowDidResize: 1207, - WindowDPIChanged: 1208, - WindowDragDrop: 1209, - WindowDragEnter: 1210, - WindowDragLeave: 1211, - WindowDragOver: 1212, - WindowEndMove: 1213, - WindowEndResize: 1214, - WindowFullscreen: 1215, - WindowHide: 1216, - WindowInactive: 1217, - WindowKeyDown: 1218, - WindowKeyUp: 1219, - WindowKillFocus: 1220, - WindowNonClientHit: 1221, - WindowNonClientMouseDown: 1222, - WindowNonClientMouseLeave: 1223, - WindowNonClientMouseMove: 1224, - WindowNonClientMouseUp: 1225, - WindowPaint: 1226, - WindowRestore: 1227, - WindowSetFocus: 1228, - WindowShow: 1229, - WindowStartMove: 1230, - WindowStartResize: 1231, - WindowUnFullscreen: 1232, - WindowZOrderChanged: 1233, - WindowMinimise: 1234, - WindowUnMinimise: 1235, - WindowMaximise: 1236, - WindowUnMaximise: 1237, + APMPowerSettingChange: 1193, + APMPowerStatusChange: 1194, + APMResumeAutomatic: 1195, + APMResumeSuspend: 1196, + APMSuspend: 1197, + ApplicationStarted: 1198, + SystemThemeChanged: 1199, + WebViewNavigationCompleted: 1200, + WindowActive: 1201, + WindowBackgroundErase: 1202, + WindowClickActive: 1203, + WindowClosing: 1204, + WindowDidMove: 1205, + WindowDidResize: 1206, + WindowDPIChanged: 1207, + WindowDragDrop: 1208, + WindowDragEnter: 1209, + WindowDragLeave: 1210, + WindowDragOver: 1211, + WindowEndMove: 1212, + WindowEndResize: 1213, + WindowFullscreen: 1214, + WindowHide: 1215, + WindowInactive: 1216, + WindowKeyDown: 1217, + WindowKeyUp: 1218, + WindowKillFocus: 1219, + WindowNonClientHit: 1220, + WindowNonClientMouseDown: 1221, + WindowNonClientMouseLeave: 1222, + WindowNonClientMouseMove: 1223, + WindowNonClientMouseUp: 1224, + WindowPaint: 1225, + WindowRestore: 1226, + WindowSetFocus: 1227, + WindowShow: 1228, + WindowStartMove: 1229, + WindowStartResize: 1230, + WindowUnFullscreen: 1231, + WindowZOrderChanged: 1232, + WindowMinimise: 1233, + WindowUnMinimise: 1234, + WindowMaximise: 1235, + WindowUnMaximise: 1236, } } @@ -500,28 +498,28 @@ type iosEvents struct { func newIOSEvents() iosEvents { return iosEvents{ - ApplicationDidBecomeActive: 1238, - ApplicationDidEnterBackground: 1239, - ApplicationDidFinishLaunching: 1240, - ApplicationDidReceiveMemoryWarning: 1241, - ApplicationWillEnterForeground: 1242, - ApplicationWillResignActive: 1243, - ApplicationWillTerminate: 1244, - WindowDidLoad: 1245, - WindowWillAppear: 1246, - WindowDidAppear: 1247, - WindowWillDisappear: 1248, - WindowDidDisappear: 1249, - WindowSafeAreaInsetsChanged: 1250, - WindowOrientationChanged: 1251, - WindowTouchBegan: 1252, - WindowTouchMoved: 1253, - WindowTouchEnded: 1254, - WindowTouchCancelled: 1255, - WebViewDidStartNavigation: 1256, - WebViewDidFinishNavigation: 1257, - WebViewDidFailNavigation: 1258, - WebViewDecidePolicyForNavigationAction: 1259, + ApplicationDidBecomeActive: 1237, + ApplicationDidEnterBackground: 1238, + ApplicationDidFinishLaunching: 1239, + ApplicationDidReceiveMemoryWarning: 1240, + ApplicationWillEnterForeground: 1241, + ApplicationWillResignActive: 1242, + ApplicationWillTerminate: 1243, + WindowDidLoad: 1244, + WindowWillAppear: 1245, + WindowDidAppear: 1246, + WindowWillDisappear: 1247, + WindowDidDisappear: 1248, + WindowSafeAreaInsetsChanged: 1249, + WindowOrientationChanged: 1250, + WindowTouchBegan: 1251, + WindowTouchMoved: 1252, + WindowTouchEnded: 1253, + WindowTouchCancelled: 1254, + WebViewDidStartNavigation: 1255, + WebViewDidFinishNavigation: 1256, + WebViewDidFailNavigation: 1257, + WebViewDecidePolicyForNavigationAction: 1258, } } @@ -556,214 +554,213 @@ var eventToJS = map[uint]string{ 1047: "common:WindowZoomIn", 1048: "common:WindowZoomOut", 1049: "common:WindowZoomReset", - 1050: "common:WindowDropZoneFilesDropped", - 1051: "linux:ApplicationStartup", - 1052: "linux:SystemThemeChanged", - 1053: "linux:WindowDeleteEvent", - 1054: "linux:WindowDidMove", - 1055: "linux:WindowDidResize", - 1056: "linux:WindowFocusIn", - 1057: "linux:WindowFocusOut", - 1058: "linux:WindowLoadStarted", - 1059: "linux:WindowLoadRedirected", - 1060: "linux:WindowLoadCommitted", - 1061: "linux:WindowLoadFinished", - 1062: "mac:ApplicationDidBecomeActive", - 1063: "mac:ApplicationDidChangeBackingProperties", - 1064: "mac:ApplicationDidChangeEffectiveAppearance", - 1065: "mac:ApplicationDidChangeIcon", - 1066: "mac:ApplicationDidChangeOcclusionState", - 1067: "mac:ApplicationDidChangeScreenParameters", - 1068: "mac:ApplicationDidChangeStatusBarFrame", - 1069: "mac:ApplicationDidChangeStatusBarOrientation", - 1070: "mac:ApplicationDidChangeTheme", - 1071: "mac:ApplicationDidFinishLaunching", - 1072: "mac:ApplicationDidHide", - 1073: "mac:ApplicationDidResignActive", - 1074: "mac:ApplicationDidUnhide", - 1075: "mac:ApplicationDidUpdate", - 1076: "mac:ApplicationShouldHandleReopen", - 1077: "mac:ApplicationWillBecomeActive", - 1078: "mac:ApplicationWillFinishLaunching", - 1079: "mac:ApplicationWillHide", - 1080: "mac:ApplicationWillResignActive", - 1081: "mac:ApplicationWillTerminate", - 1082: "mac:ApplicationWillUnhide", - 1083: "mac:ApplicationWillUpdate", - 1084: "mac:MenuDidAddItem", - 1085: "mac:MenuDidBeginTracking", - 1086: "mac:MenuDidClose", - 1087: "mac:MenuDidDisplayItem", - 1088: "mac:MenuDidEndTracking", - 1089: "mac:MenuDidHighlightItem", - 1090: "mac:MenuDidOpen", - 1091: "mac:MenuDidPopUp", - 1092: "mac:MenuDidRemoveItem", - 1093: "mac:MenuDidSendAction", - 1094: "mac:MenuDidSendActionToItem", - 1095: "mac:MenuDidUpdate", - 1096: "mac:MenuWillAddItem", - 1097: "mac:MenuWillBeginTracking", - 1098: "mac:MenuWillDisplayItem", - 1099: "mac:MenuWillEndTracking", - 1100: "mac:MenuWillHighlightItem", - 1101: "mac:MenuWillOpen", - 1102: "mac:MenuWillPopUp", - 1103: "mac:MenuWillRemoveItem", - 1104: "mac:MenuWillSendAction", - 1105: "mac:MenuWillSendActionToItem", - 1106: "mac:MenuWillUpdate", - 1107: "mac:WebViewDidCommitNavigation", - 1108: "mac:WebViewDidFinishNavigation", - 1109: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation", - 1110: "mac:WebViewDidStartProvisionalNavigation", - 1111: "mac:WindowDidBecomeKey", - 1112: "mac:WindowDidBecomeMain", - 1113: "mac:WindowDidBeginSheet", - 1114: "mac:WindowDidChangeAlpha", - 1115: "mac:WindowDidChangeBackingLocation", - 1116: "mac:WindowDidChangeBackingProperties", - 1117: "mac:WindowDidChangeCollectionBehavior", - 1118: "mac:WindowDidChangeEffectiveAppearance", - 1119: "mac:WindowDidChangeOcclusionState", - 1120: "mac:WindowDidChangeOrderingMode", - 1121: "mac:WindowDidChangeScreen", - 1122: "mac:WindowDidChangeScreenParameters", - 1123: "mac:WindowDidChangeScreenProfile", - 1124: "mac:WindowDidChangeScreenSpace", - 1125: "mac:WindowDidChangeScreenSpaceProperties", - 1126: "mac:WindowDidChangeSharingType", - 1127: "mac:WindowDidChangeSpace", - 1128: "mac:WindowDidChangeSpaceOrderingMode", - 1129: "mac:WindowDidChangeTitle", - 1130: "mac:WindowDidChangeToolbar", - 1131: "mac:WindowDidDeminiaturize", - 1132: "mac:WindowDidEndSheet", - 1133: "mac:WindowDidEnterFullScreen", - 1134: "mac:WindowDidEnterVersionBrowser", - 1135: "mac:WindowDidExitFullScreen", - 1136: "mac:WindowDidExitVersionBrowser", - 1137: "mac:WindowDidExpose", - 1138: "mac:WindowDidFocus", - 1139: "mac:WindowDidMiniaturize", - 1140: "mac:WindowDidMove", - 1141: "mac:WindowDidOrderOffScreen", - 1142: "mac:WindowDidOrderOnScreen", - 1143: "mac:WindowDidResignKey", - 1144: "mac:WindowDidResignMain", - 1145: "mac:WindowDidResize", - 1146: "mac:WindowDidUpdate", - 1147: "mac:WindowDidUpdateAlpha", - 1148: "mac:WindowDidUpdateCollectionBehavior", - 1149: "mac:WindowDidUpdateCollectionProperties", - 1150: "mac:WindowDidUpdateShadow", - 1151: "mac:WindowDidUpdateTitle", - 1152: "mac:WindowDidUpdateToolbar", - 1153: "mac:WindowDidZoom", - 1154: "mac:WindowFileDraggingEntered", - 1155: "mac:WindowFileDraggingExited", - 1156: "mac:WindowFileDraggingPerformed", - 1157: "mac:WindowHide", - 1158: "mac:WindowMaximise", - 1159: "mac:WindowUnMaximise", - 1160: "mac:WindowMinimise", - 1161: "mac:WindowUnMinimise", - 1162: "mac:WindowShouldClose", - 1163: "mac:WindowShow", - 1164: "mac:WindowWillBecomeKey", - 1165: "mac:WindowWillBecomeMain", - 1166: "mac:WindowWillBeginSheet", - 1167: "mac:WindowWillChangeOrderingMode", - 1168: "mac:WindowWillClose", - 1169: "mac:WindowWillDeminiaturize", - 1170: "mac:WindowWillEnterFullScreen", - 1171: "mac:WindowWillEnterVersionBrowser", - 1172: "mac:WindowWillExitFullScreen", - 1173: "mac:WindowWillExitVersionBrowser", - 1174: "mac:WindowWillFocus", - 1175: "mac:WindowWillMiniaturize", - 1176: "mac:WindowWillMove", - 1177: "mac:WindowWillOrderOffScreen", - 1178: "mac:WindowWillOrderOnScreen", - 1179: "mac:WindowWillResignMain", - 1180: "mac:WindowWillResize", - 1181: "mac:WindowWillUnfocus", - 1182: "mac:WindowWillUpdate", - 1183: "mac:WindowWillUpdateAlpha", - 1184: "mac:WindowWillUpdateCollectionBehavior", - 1185: "mac:WindowWillUpdateCollectionProperties", - 1186: "mac:WindowWillUpdateShadow", - 1187: "mac:WindowWillUpdateTitle", - 1188: "mac:WindowWillUpdateToolbar", - 1189: "mac:WindowWillUpdateVisibility", - 1190: "mac:WindowWillUseStandardFrame", - 1191: "mac:WindowZoomIn", - 1192: "mac:WindowZoomOut", - 1193: "mac:WindowZoomReset", - 1194: "windows:APMPowerSettingChange", - 1195: "windows:APMPowerStatusChange", - 1196: "windows:APMResumeAutomatic", - 1197: "windows:APMResumeSuspend", - 1198: "windows:APMSuspend", - 1199: "windows:ApplicationStarted", - 1200: "windows:SystemThemeChanged", - 1201: "windows:WebViewNavigationCompleted", - 1202: "windows:WindowActive", - 1203: "windows:WindowBackgroundErase", - 1204: "windows:WindowClickActive", - 1205: "windows:WindowClosing", - 1206: "windows:WindowDidMove", - 1207: "windows:WindowDidResize", - 1208: "windows:WindowDPIChanged", - 1209: "windows:WindowDragDrop", - 1210: "windows:WindowDragEnter", - 1211: "windows:WindowDragLeave", - 1212: "windows:WindowDragOver", - 1213: "windows:WindowEndMove", - 1214: "windows:WindowEndResize", - 1215: "windows:WindowFullscreen", - 1216: "windows:WindowHide", - 1217: "windows:WindowInactive", - 1218: "windows:WindowKeyDown", - 1219: "windows:WindowKeyUp", - 1220: "windows:WindowKillFocus", - 1221: "windows:WindowNonClientHit", - 1222: "windows:WindowNonClientMouseDown", - 1223: "windows:WindowNonClientMouseLeave", - 1224: "windows:WindowNonClientMouseMove", - 1225: "windows:WindowNonClientMouseUp", - 1226: "windows:WindowPaint", - 1227: "windows:WindowRestore", - 1228: "windows:WindowSetFocus", - 1229: "windows:WindowShow", - 1230: "windows:WindowStartMove", - 1231: "windows:WindowStartResize", - 1232: "windows:WindowUnFullscreen", - 1233: "windows:WindowZOrderChanged", - 1234: "windows:WindowMinimise", - 1235: "windows:WindowUnMinimise", - 1236: "windows:WindowMaximise", - 1237: "windows:WindowUnMaximise", - 1238: "ios:ApplicationDidBecomeActive", - 1239: "ios:ApplicationDidEnterBackground", - 1240: "ios:ApplicationDidFinishLaunching", - 1241: "ios:ApplicationDidReceiveMemoryWarning", - 1242: "ios:ApplicationWillEnterForeground", - 1243: "ios:ApplicationWillResignActive", - 1244: "ios:ApplicationWillTerminate", - 1245: "ios:WindowDidLoad", - 1246: "ios:WindowWillAppear", - 1247: "ios:WindowDidAppear", - 1248: "ios:WindowWillDisappear", - 1249: "ios:WindowDidDisappear", - 1250: "ios:WindowSafeAreaInsetsChanged", - 1251: "ios:WindowOrientationChanged", - 1252: "ios:WindowTouchBegan", - 1253: "ios:WindowTouchMoved", - 1254: "ios:WindowTouchEnded", - 1255: "ios:WindowTouchCancelled", - 1256: "ios:WebViewDidStartNavigation", - 1257: "ios:WebViewDidFinishNavigation", - 1258: "ios:WebViewDidFailNavigation", - 1259: "ios:WebViewDecidePolicyForNavigationAction", + 1050: "linux:ApplicationStartup", + 1051: "linux:SystemThemeChanged", + 1052: "linux:WindowDeleteEvent", + 1053: "linux:WindowDidMove", + 1054: "linux:WindowDidResize", + 1055: "linux:WindowFocusIn", + 1056: "linux:WindowFocusOut", + 1057: "linux:WindowLoadStarted", + 1058: "linux:WindowLoadRedirected", + 1059: "linux:WindowLoadCommitted", + 1060: "linux:WindowLoadFinished", + 1061: "mac:ApplicationDidBecomeActive", + 1062: "mac:ApplicationDidChangeBackingProperties", + 1063: "mac:ApplicationDidChangeEffectiveAppearance", + 1064: "mac:ApplicationDidChangeIcon", + 1065: "mac:ApplicationDidChangeOcclusionState", + 1066: "mac:ApplicationDidChangeScreenParameters", + 1067: "mac:ApplicationDidChangeStatusBarFrame", + 1068: "mac:ApplicationDidChangeStatusBarOrientation", + 1069: "mac:ApplicationDidChangeTheme", + 1070: "mac:ApplicationDidFinishLaunching", + 1071: "mac:ApplicationDidHide", + 1072: "mac:ApplicationDidResignActive", + 1073: "mac:ApplicationDidUnhide", + 1074: "mac:ApplicationDidUpdate", + 1075: "mac:ApplicationShouldHandleReopen", + 1076: "mac:ApplicationWillBecomeActive", + 1077: "mac:ApplicationWillFinishLaunching", + 1078: "mac:ApplicationWillHide", + 1079: "mac:ApplicationWillResignActive", + 1080: "mac:ApplicationWillTerminate", + 1081: "mac:ApplicationWillUnhide", + 1082: "mac:ApplicationWillUpdate", + 1083: "mac:MenuDidAddItem", + 1084: "mac:MenuDidBeginTracking", + 1085: "mac:MenuDidClose", + 1086: "mac:MenuDidDisplayItem", + 1087: "mac:MenuDidEndTracking", + 1088: "mac:MenuDidHighlightItem", + 1089: "mac:MenuDidOpen", + 1090: "mac:MenuDidPopUp", + 1091: "mac:MenuDidRemoveItem", + 1092: "mac:MenuDidSendAction", + 1093: "mac:MenuDidSendActionToItem", + 1094: "mac:MenuDidUpdate", + 1095: "mac:MenuWillAddItem", + 1096: "mac:MenuWillBeginTracking", + 1097: "mac:MenuWillDisplayItem", + 1098: "mac:MenuWillEndTracking", + 1099: "mac:MenuWillHighlightItem", + 1100: "mac:MenuWillOpen", + 1101: "mac:MenuWillPopUp", + 1102: "mac:MenuWillRemoveItem", + 1103: "mac:MenuWillSendAction", + 1104: "mac:MenuWillSendActionToItem", + 1105: "mac:MenuWillUpdate", + 1106: "mac:WebViewDidCommitNavigation", + 1107: "mac:WebViewDidFinishNavigation", + 1108: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation", + 1109: "mac:WebViewDidStartProvisionalNavigation", + 1110: "mac:WindowDidBecomeKey", + 1111: "mac:WindowDidBecomeMain", + 1112: "mac:WindowDidBeginSheet", + 1113: "mac:WindowDidChangeAlpha", + 1114: "mac:WindowDidChangeBackingLocation", + 1115: "mac:WindowDidChangeBackingProperties", + 1116: "mac:WindowDidChangeCollectionBehavior", + 1117: "mac:WindowDidChangeEffectiveAppearance", + 1118: "mac:WindowDidChangeOcclusionState", + 1119: "mac:WindowDidChangeOrderingMode", + 1120: "mac:WindowDidChangeScreen", + 1121: "mac:WindowDidChangeScreenParameters", + 1122: "mac:WindowDidChangeScreenProfile", + 1123: "mac:WindowDidChangeScreenSpace", + 1124: "mac:WindowDidChangeScreenSpaceProperties", + 1125: "mac:WindowDidChangeSharingType", + 1126: "mac:WindowDidChangeSpace", + 1127: "mac:WindowDidChangeSpaceOrderingMode", + 1128: "mac:WindowDidChangeTitle", + 1129: "mac:WindowDidChangeToolbar", + 1130: "mac:WindowDidDeminiaturize", + 1131: "mac:WindowDidEndSheet", + 1132: "mac:WindowDidEnterFullScreen", + 1133: "mac:WindowDidEnterVersionBrowser", + 1134: "mac:WindowDidExitFullScreen", + 1135: "mac:WindowDidExitVersionBrowser", + 1136: "mac:WindowDidExpose", + 1137: "mac:WindowDidFocus", + 1138: "mac:WindowDidMiniaturize", + 1139: "mac:WindowDidMove", + 1140: "mac:WindowDidOrderOffScreen", + 1141: "mac:WindowDidOrderOnScreen", + 1142: "mac:WindowDidResignKey", + 1143: "mac:WindowDidResignMain", + 1144: "mac:WindowDidResize", + 1145: "mac:WindowDidUpdate", + 1146: "mac:WindowDidUpdateAlpha", + 1147: "mac:WindowDidUpdateCollectionBehavior", + 1148: "mac:WindowDidUpdateCollectionProperties", + 1149: "mac:WindowDidUpdateShadow", + 1150: "mac:WindowDidUpdateTitle", + 1151: "mac:WindowDidUpdateToolbar", + 1152: "mac:WindowDidZoom", + 1153: "mac:WindowFileDraggingEntered", + 1154: "mac:WindowFileDraggingExited", + 1155: "mac:WindowFileDraggingPerformed", + 1156: "mac:WindowHide", + 1157: "mac:WindowMaximise", + 1158: "mac:WindowUnMaximise", + 1159: "mac:WindowMinimise", + 1160: "mac:WindowUnMinimise", + 1161: "mac:WindowShouldClose", + 1162: "mac:WindowShow", + 1163: "mac:WindowWillBecomeKey", + 1164: "mac:WindowWillBecomeMain", + 1165: "mac:WindowWillBeginSheet", + 1166: "mac:WindowWillChangeOrderingMode", + 1167: "mac:WindowWillClose", + 1168: "mac:WindowWillDeminiaturize", + 1169: "mac:WindowWillEnterFullScreen", + 1170: "mac:WindowWillEnterVersionBrowser", + 1171: "mac:WindowWillExitFullScreen", + 1172: "mac:WindowWillExitVersionBrowser", + 1173: "mac:WindowWillFocus", + 1174: "mac:WindowWillMiniaturize", + 1175: "mac:WindowWillMove", + 1176: "mac:WindowWillOrderOffScreen", + 1177: "mac:WindowWillOrderOnScreen", + 1178: "mac:WindowWillResignMain", + 1179: "mac:WindowWillResize", + 1180: "mac:WindowWillUnfocus", + 1181: "mac:WindowWillUpdate", + 1182: "mac:WindowWillUpdateAlpha", + 1183: "mac:WindowWillUpdateCollectionBehavior", + 1184: "mac:WindowWillUpdateCollectionProperties", + 1185: "mac:WindowWillUpdateShadow", + 1186: "mac:WindowWillUpdateTitle", + 1187: "mac:WindowWillUpdateToolbar", + 1188: "mac:WindowWillUpdateVisibility", + 1189: "mac:WindowWillUseStandardFrame", + 1190: "mac:WindowZoomIn", + 1191: "mac:WindowZoomOut", + 1192: "mac:WindowZoomReset", + 1193: "windows:APMPowerSettingChange", + 1194: "windows:APMPowerStatusChange", + 1195: "windows:APMResumeAutomatic", + 1196: "windows:APMResumeSuspend", + 1197: "windows:APMSuspend", + 1198: "windows:ApplicationStarted", + 1199: "windows:SystemThemeChanged", + 1200: "windows:WebViewNavigationCompleted", + 1201: "windows:WindowActive", + 1202: "windows:WindowBackgroundErase", + 1203: "windows:WindowClickActive", + 1204: "windows:WindowClosing", + 1205: "windows:WindowDidMove", + 1206: "windows:WindowDidResize", + 1207: "windows:WindowDPIChanged", + 1208: "windows:WindowDragDrop", + 1209: "windows:WindowDragEnter", + 1210: "windows:WindowDragLeave", + 1211: "windows:WindowDragOver", + 1212: "windows:WindowEndMove", + 1213: "windows:WindowEndResize", + 1214: "windows:WindowFullscreen", + 1215: "windows:WindowHide", + 1216: "windows:WindowInactive", + 1217: "windows:WindowKeyDown", + 1218: "windows:WindowKeyUp", + 1219: "windows:WindowKillFocus", + 1220: "windows:WindowNonClientHit", + 1221: "windows:WindowNonClientMouseDown", + 1222: "windows:WindowNonClientMouseLeave", + 1223: "windows:WindowNonClientMouseMove", + 1224: "windows:WindowNonClientMouseUp", + 1225: "windows:WindowPaint", + 1226: "windows:WindowRestore", + 1227: "windows:WindowSetFocus", + 1228: "windows:WindowShow", + 1229: "windows:WindowStartMove", + 1230: "windows:WindowStartResize", + 1231: "windows:WindowUnFullscreen", + 1232: "windows:WindowZOrderChanged", + 1233: "windows:WindowMinimise", + 1234: "windows:WindowUnMinimise", + 1235: "windows:WindowMaximise", + 1236: "windows:WindowUnMaximise", + 1237: "ios:ApplicationDidBecomeActive", + 1238: "ios:ApplicationDidEnterBackground", + 1239: "ios:ApplicationDidFinishLaunching", + 1240: "ios:ApplicationDidReceiveMemoryWarning", + 1241: "ios:ApplicationWillEnterForeground", + 1242: "ios:ApplicationWillResignActive", + 1243: "ios:ApplicationWillTerminate", + 1244: "ios:WindowDidLoad", + 1245: "ios:WindowWillAppear", + 1246: "ios:WindowDidAppear", + 1247: "ios:WindowWillDisappear", + 1248: "ios:WindowDidDisappear", + 1249: "ios:WindowSafeAreaInsetsChanged", + 1250: "ios:WindowOrientationChanged", + 1251: "ios:WindowTouchBegan", + 1252: "ios:WindowTouchMoved", + 1253: "ios:WindowTouchEnded", + 1254: "ios:WindowTouchCancelled", + 1255: "ios:WebViewDidStartNavigation", + 1256: "ios:WebViewDidFinishNavigation", + 1257: "ios:WebViewDidFailNavigation", + 1258: "ios:WebViewDecidePolicyForNavigationAction", } diff --git a/v3/pkg/events/events.txt b/v3/pkg/events/events.txt index e4d99f5b4..9a6c5fd6d 100644 --- a/v3/pkg/events/events.txt +++ b/v3/pkg/events/events.txt @@ -24,7 +24,6 @@ common:WindowZoom common:WindowZoomIn common:WindowZoomOut common:WindowZoomReset -common:WindowDropZoneFilesDropped linux:ApplicationStartup linux:SystemThemeChanged linux:WindowDeleteEvent diff --git a/v3/pkg/events/events_darwin.h b/v3/pkg/events/events_darwin.h index 1ab2cc300..1547779ce 100644 --- a/v3/pkg/events/events_darwin.h +++ b/v3/pkg/events/events_darwin.h @@ -6,140 +6,140 @@ extern void processApplicationEvent(unsigned int, void* data); extern void processWindowEvent(unsigned int, unsigned int); -#define EventApplicationDidBecomeActive 1062 -#define EventApplicationDidChangeBackingProperties 1063 -#define EventApplicationDidChangeEffectiveAppearance 1064 -#define EventApplicationDidChangeIcon 1065 -#define EventApplicationDidChangeOcclusionState 1066 -#define EventApplicationDidChangeScreenParameters 1067 -#define EventApplicationDidChangeStatusBarFrame 1068 -#define EventApplicationDidChangeStatusBarOrientation 1069 -#define EventApplicationDidChangeTheme 1070 -#define EventApplicationDidFinishLaunching 1071 -#define EventApplicationDidHide 1072 -#define EventApplicationDidResignActive 1073 -#define EventApplicationDidUnhide 1074 -#define EventApplicationDidUpdate 1075 -#define EventApplicationShouldHandleReopen 1076 -#define EventApplicationWillBecomeActive 1077 -#define EventApplicationWillFinishLaunching 1078 -#define EventApplicationWillHide 1079 -#define EventApplicationWillResignActive 1080 -#define EventApplicationWillTerminate 1081 -#define EventApplicationWillUnhide 1082 -#define EventApplicationWillUpdate 1083 -#define EventMenuDidAddItem 1084 -#define EventMenuDidBeginTracking 1085 -#define EventMenuDidClose 1086 -#define EventMenuDidDisplayItem 1087 -#define EventMenuDidEndTracking 1088 -#define EventMenuDidHighlightItem 1089 -#define EventMenuDidOpen 1090 -#define EventMenuDidPopUp 1091 -#define EventMenuDidRemoveItem 1092 -#define EventMenuDidSendAction 1093 -#define EventMenuDidSendActionToItem 1094 -#define EventMenuDidUpdate 1095 -#define EventMenuWillAddItem 1096 -#define EventMenuWillBeginTracking 1097 -#define EventMenuWillDisplayItem 1098 -#define EventMenuWillEndTracking 1099 -#define EventMenuWillHighlightItem 1100 -#define EventMenuWillOpen 1101 -#define EventMenuWillPopUp 1102 -#define EventMenuWillRemoveItem 1103 -#define EventMenuWillSendAction 1104 -#define EventMenuWillSendActionToItem 1105 -#define EventMenuWillUpdate 1106 -#define EventWebViewDidCommitNavigation 1107 -#define EventWebViewDidFinishNavigation 1108 -#define EventWebViewDidReceiveServerRedirectForProvisionalNavigation 1109 -#define EventWebViewDidStartProvisionalNavigation 1110 -#define EventWindowDidBecomeKey 1111 -#define EventWindowDidBecomeMain 1112 -#define EventWindowDidBeginSheet 1113 -#define EventWindowDidChangeAlpha 1114 -#define EventWindowDidChangeBackingLocation 1115 -#define EventWindowDidChangeBackingProperties 1116 -#define EventWindowDidChangeCollectionBehavior 1117 -#define EventWindowDidChangeEffectiveAppearance 1118 -#define EventWindowDidChangeOcclusionState 1119 -#define EventWindowDidChangeOrderingMode 1120 -#define EventWindowDidChangeScreen 1121 -#define EventWindowDidChangeScreenParameters 1122 -#define EventWindowDidChangeScreenProfile 1123 -#define EventWindowDidChangeScreenSpace 1124 -#define EventWindowDidChangeScreenSpaceProperties 1125 -#define EventWindowDidChangeSharingType 1126 -#define EventWindowDidChangeSpace 1127 -#define EventWindowDidChangeSpaceOrderingMode 1128 -#define EventWindowDidChangeTitle 1129 -#define EventWindowDidChangeToolbar 1130 -#define EventWindowDidDeminiaturize 1131 -#define EventWindowDidEndSheet 1132 -#define EventWindowDidEnterFullScreen 1133 -#define EventWindowDidEnterVersionBrowser 1134 -#define EventWindowDidExitFullScreen 1135 -#define EventWindowDidExitVersionBrowser 1136 -#define EventWindowDidExpose 1137 -#define EventWindowDidFocus 1138 -#define EventWindowDidMiniaturize 1139 -#define EventWindowDidMove 1140 -#define EventWindowDidOrderOffScreen 1141 -#define EventWindowDidOrderOnScreen 1142 -#define EventWindowDidResignKey 1143 -#define EventWindowDidResignMain 1144 -#define EventWindowDidResize 1145 -#define EventWindowDidUpdate 1146 -#define EventWindowDidUpdateAlpha 1147 -#define EventWindowDidUpdateCollectionBehavior 1148 -#define EventWindowDidUpdateCollectionProperties 1149 -#define EventWindowDidUpdateShadow 1150 -#define EventWindowDidUpdateTitle 1151 -#define EventWindowDidUpdateToolbar 1152 -#define EventWindowDidZoom 1153 -#define EventWindowFileDraggingEntered 1154 -#define EventWindowFileDraggingExited 1155 -#define EventWindowFileDraggingPerformed 1156 -#define EventWindowHide 1157 -#define EventWindowMaximise 1158 -#define EventWindowUnMaximise 1159 -#define EventWindowMinimise 1160 -#define EventWindowUnMinimise 1161 -#define EventWindowShouldClose 1162 -#define EventWindowShow 1163 -#define EventWindowWillBecomeKey 1164 -#define EventWindowWillBecomeMain 1165 -#define EventWindowWillBeginSheet 1166 -#define EventWindowWillChangeOrderingMode 1167 -#define EventWindowWillClose 1168 -#define EventWindowWillDeminiaturize 1169 -#define EventWindowWillEnterFullScreen 1170 -#define EventWindowWillEnterVersionBrowser 1171 -#define EventWindowWillExitFullScreen 1172 -#define EventWindowWillExitVersionBrowser 1173 -#define EventWindowWillFocus 1174 -#define EventWindowWillMiniaturize 1175 -#define EventWindowWillMove 1176 -#define EventWindowWillOrderOffScreen 1177 -#define EventWindowWillOrderOnScreen 1178 -#define EventWindowWillResignMain 1179 -#define EventWindowWillResize 1180 -#define EventWindowWillUnfocus 1181 -#define EventWindowWillUpdate 1182 -#define EventWindowWillUpdateAlpha 1183 -#define EventWindowWillUpdateCollectionBehavior 1184 -#define EventWindowWillUpdateCollectionProperties 1185 -#define EventWindowWillUpdateShadow 1186 -#define EventWindowWillUpdateTitle 1187 -#define EventWindowWillUpdateToolbar 1188 -#define EventWindowWillUpdateVisibility 1189 -#define EventWindowWillUseStandardFrame 1190 -#define EventWindowZoomIn 1191 -#define EventWindowZoomOut 1192 -#define EventWindowZoomReset 1193 +#define EventApplicationDidBecomeActive 1061 +#define EventApplicationDidChangeBackingProperties 1062 +#define EventApplicationDidChangeEffectiveAppearance 1063 +#define EventApplicationDidChangeIcon 1064 +#define EventApplicationDidChangeOcclusionState 1065 +#define EventApplicationDidChangeScreenParameters 1066 +#define EventApplicationDidChangeStatusBarFrame 1067 +#define EventApplicationDidChangeStatusBarOrientation 1068 +#define EventApplicationDidChangeTheme 1069 +#define EventApplicationDidFinishLaunching 1070 +#define EventApplicationDidHide 1071 +#define EventApplicationDidResignActive 1072 +#define EventApplicationDidUnhide 1073 +#define EventApplicationDidUpdate 1074 +#define EventApplicationShouldHandleReopen 1075 +#define EventApplicationWillBecomeActive 1076 +#define EventApplicationWillFinishLaunching 1077 +#define EventApplicationWillHide 1078 +#define EventApplicationWillResignActive 1079 +#define EventApplicationWillTerminate 1080 +#define EventApplicationWillUnhide 1081 +#define EventApplicationWillUpdate 1082 +#define EventMenuDidAddItem 1083 +#define EventMenuDidBeginTracking 1084 +#define EventMenuDidClose 1085 +#define EventMenuDidDisplayItem 1086 +#define EventMenuDidEndTracking 1087 +#define EventMenuDidHighlightItem 1088 +#define EventMenuDidOpen 1089 +#define EventMenuDidPopUp 1090 +#define EventMenuDidRemoveItem 1091 +#define EventMenuDidSendAction 1092 +#define EventMenuDidSendActionToItem 1093 +#define EventMenuDidUpdate 1094 +#define EventMenuWillAddItem 1095 +#define EventMenuWillBeginTracking 1096 +#define EventMenuWillDisplayItem 1097 +#define EventMenuWillEndTracking 1098 +#define EventMenuWillHighlightItem 1099 +#define EventMenuWillOpen 1100 +#define EventMenuWillPopUp 1101 +#define EventMenuWillRemoveItem 1102 +#define EventMenuWillSendAction 1103 +#define EventMenuWillSendActionToItem 1104 +#define EventMenuWillUpdate 1105 +#define EventWebViewDidCommitNavigation 1106 +#define EventWebViewDidFinishNavigation 1107 +#define EventWebViewDidReceiveServerRedirectForProvisionalNavigation 1108 +#define EventWebViewDidStartProvisionalNavigation 1109 +#define EventWindowDidBecomeKey 1110 +#define EventWindowDidBecomeMain 1111 +#define EventWindowDidBeginSheet 1112 +#define EventWindowDidChangeAlpha 1113 +#define EventWindowDidChangeBackingLocation 1114 +#define EventWindowDidChangeBackingProperties 1115 +#define EventWindowDidChangeCollectionBehavior 1116 +#define EventWindowDidChangeEffectiveAppearance 1117 +#define EventWindowDidChangeOcclusionState 1118 +#define EventWindowDidChangeOrderingMode 1119 +#define EventWindowDidChangeScreen 1120 +#define EventWindowDidChangeScreenParameters 1121 +#define EventWindowDidChangeScreenProfile 1122 +#define EventWindowDidChangeScreenSpace 1123 +#define EventWindowDidChangeScreenSpaceProperties 1124 +#define EventWindowDidChangeSharingType 1125 +#define EventWindowDidChangeSpace 1126 +#define EventWindowDidChangeSpaceOrderingMode 1127 +#define EventWindowDidChangeTitle 1128 +#define EventWindowDidChangeToolbar 1129 +#define EventWindowDidDeminiaturize 1130 +#define EventWindowDidEndSheet 1131 +#define EventWindowDidEnterFullScreen 1132 +#define EventWindowDidEnterVersionBrowser 1133 +#define EventWindowDidExitFullScreen 1134 +#define EventWindowDidExitVersionBrowser 1135 +#define EventWindowDidExpose 1136 +#define EventWindowDidFocus 1137 +#define EventWindowDidMiniaturize 1138 +#define EventWindowDidMove 1139 +#define EventWindowDidOrderOffScreen 1140 +#define EventWindowDidOrderOnScreen 1141 +#define EventWindowDidResignKey 1142 +#define EventWindowDidResignMain 1143 +#define EventWindowDidResize 1144 +#define EventWindowDidUpdate 1145 +#define EventWindowDidUpdateAlpha 1146 +#define EventWindowDidUpdateCollectionBehavior 1147 +#define EventWindowDidUpdateCollectionProperties 1148 +#define EventWindowDidUpdateShadow 1149 +#define EventWindowDidUpdateTitle 1150 +#define EventWindowDidUpdateToolbar 1151 +#define EventWindowDidZoom 1152 +#define EventWindowFileDraggingEntered 1153 +#define EventWindowFileDraggingExited 1154 +#define EventWindowFileDraggingPerformed 1155 +#define EventWindowHide 1156 +#define EventWindowMaximise 1157 +#define EventWindowUnMaximise 1158 +#define EventWindowMinimise 1159 +#define EventWindowUnMinimise 1160 +#define EventWindowShouldClose 1161 +#define EventWindowShow 1162 +#define EventWindowWillBecomeKey 1163 +#define EventWindowWillBecomeMain 1164 +#define EventWindowWillBeginSheet 1165 +#define EventWindowWillChangeOrderingMode 1166 +#define EventWindowWillClose 1167 +#define EventWindowWillDeminiaturize 1168 +#define EventWindowWillEnterFullScreen 1169 +#define EventWindowWillEnterVersionBrowser 1170 +#define EventWindowWillExitFullScreen 1171 +#define EventWindowWillExitVersionBrowser 1172 +#define EventWindowWillFocus 1173 +#define EventWindowWillMiniaturize 1174 +#define EventWindowWillMove 1175 +#define EventWindowWillOrderOffScreen 1176 +#define EventWindowWillOrderOnScreen 1177 +#define EventWindowWillResignMain 1178 +#define EventWindowWillResize 1179 +#define EventWindowWillUnfocus 1180 +#define EventWindowWillUpdate 1181 +#define EventWindowWillUpdateAlpha 1182 +#define EventWindowWillUpdateCollectionBehavior 1183 +#define EventWindowWillUpdateCollectionProperties 1184 +#define EventWindowWillUpdateShadow 1185 +#define EventWindowWillUpdateTitle 1186 +#define EventWindowWillUpdateToolbar 1187 +#define EventWindowWillUpdateVisibility 1188 +#define EventWindowWillUseStandardFrame 1189 +#define EventWindowZoomIn 1190 +#define EventWindowZoomOut 1191 +#define EventWindowZoomReset 1192 -#define MAX_EVENTS 1194 +#define MAX_EVENTS 1193 #endif \ No newline at end of file diff --git a/v3/pkg/events/events_ios.h b/v3/pkg/events/events_ios.h index 92f4e05a1..db5853708 100644 --- a/v3/pkg/events/events_ios.h +++ b/v3/pkg/events/events_ios.h @@ -6,30 +6,30 @@ extern void processApplicationEvent(unsigned int, void* data); extern void processWindowEvent(unsigned int, unsigned int); -#define EventApplicationDidBecomeActive 1238 -#define EventApplicationDidEnterBackground 1239 -#define EventApplicationDidFinishLaunching 1240 -#define EventApplicationDidReceiveMemoryWarning 1241 -#define EventApplicationWillEnterForeground 1242 -#define EventApplicationWillResignActive 1243 -#define EventApplicationWillTerminate 1244 -#define EventWindowDidLoad 1245 -#define EventWindowWillAppear 1246 -#define EventWindowDidAppear 1247 -#define EventWindowWillDisappear 1248 -#define EventWindowDidDisappear 1249 -#define EventWindowSafeAreaInsetsChanged 1250 -#define EventWindowOrientationChanged 1251 -#define EventWindowTouchBegan 1252 -#define EventWindowTouchMoved 1253 -#define EventWindowTouchEnded 1254 -#define EventWindowTouchCancelled 1255 -#define EventWebViewDidStartNavigation 1256 -#define EventWebViewDidFinishNavigation 1257 -#define EventWebViewDidFailNavigation 1258 -#define EventWebViewDecidePolicyForNavigationAction 1259 +#define EventApplicationDidBecomeActive 1237 +#define EventApplicationDidEnterBackground 1238 +#define EventApplicationDidFinishLaunching 1239 +#define EventApplicationDidReceiveMemoryWarning 1240 +#define EventApplicationWillEnterForeground 1241 +#define EventApplicationWillResignActive 1242 +#define EventApplicationWillTerminate 1243 +#define EventWindowDidLoad 1244 +#define EventWindowWillAppear 1245 +#define EventWindowDidAppear 1246 +#define EventWindowWillDisappear 1247 +#define EventWindowDidDisappear 1248 +#define EventWindowSafeAreaInsetsChanged 1249 +#define EventWindowOrientationChanged 1250 +#define EventWindowTouchBegan 1251 +#define EventWindowTouchMoved 1252 +#define EventWindowTouchEnded 1253 +#define EventWindowTouchCancelled 1254 +#define EventWebViewDidStartNavigation 1255 +#define EventWebViewDidFinishNavigation 1256 +#define EventWebViewDidFailNavigation 1257 +#define EventWebViewDecidePolicyForNavigationAction 1258 -#define MAX_EVENTS 1260 +#define MAX_EVENTS 1259 #endif \ No newline at end of file diff --git a/v3/pkg/events/events_linux.h b/v3/pkg/events/events_linux.h index 176b6340e..40ebc95c5 100644 --- a/v3/pkg/events/events_linux.h +++ b/v3/pkg/events/events_linux.h @@ -6,19 +6,19 @@ extern void processApplicationEvent(unsigned int, void* data); extern void processWindowEvent(unsigned int, unsigned int); -#define EventApplicationStartup 1051 -#define EventSystemThemeChanged 1052 -#define EventWindowDeleteEvent 1053 -#define EventWindowDidMove 1054 -#define EventWindowDidResize 1055 -#define EventWindowFocusIn 1056 -#define EventWindowFocusOut 1057 -#define EventWindowLoadStarted 1058 -#define EventWindowLoadRedirected 1059 -#define EventWindowLoadCommitted 1060 -#define EventWindowLoadFinished 1061 +#define EventApplicationStartup 1050 +#define EventSystemThemeChanged 1051 +#define EventWindowDeleteEvent 1052 +#define EventWindowDidMove 1053 +#define EventWindowDidResize 1054 +#define EventWindowFocusIn 1055 +#define EventWindowFocusOut 1056 +#define EventWindowLoadStarted 1057 +#define EventWindowLoadRedirected 1058 +#define EventWindowLoadCommitted 1059 +#define EventWindowLoadFinished 1060 -#define MAX_EVENTS 1062 +#define MAX_EVENTS 1061 #endif \ No newline at end of file diff --git a/v3/pkg/events/known_events.go b/v3/pkg/events/known_events.go index 4f944d3b7..c3d23e038 100644 --- a/v3/pkg/events/known_events.go +++ b/v3/pkg/events/known_events.go @@ -6,218 +6,217 @@ func IsKnownEvent(name string) bool { } var knownEvents = map[string]struct{}{ - "common:ApplicationOpenedWithFile": {}, - "common:ApplicationStarted": {}, - "common:ApplicationLaunchedWithUrl": {}, - "common:ThemeChanged": {}, - "common:WindowClosing": {}, - "common:WindowDidMove": {}, - "common:WindowDidResize": {}, - "common:WindowDPIChanged": {}, - "common:WindowFilesDropped": {}, - "common:WindowFocus": {}, - "common:WindowFullscreen": {}, - "common:WindowHide": {}, - "common:WindowLostFocus": {}, - "common:WindowMaximise": {}, - "common:WindowMinimise": {}, - "common:WindowToggleFrameless": {}, - "common:WindowRestore": {}, - "common:WindowRuntimeReady": {}, - "common:WindowShow": {}, - "common:WindowUnFullscreen": {}, - "common:WindowUnMaximise": {}, - "common:WindowUnMinimise": {}, - "common:WindowZoom": {}, - "common:WindowZoomIn": {}, - "common:WindowZoomOut": {}, - "common:WindowZoomReset": {}, - "common:WindowDropZoneFilesDropped": {}, - "linux:ApplicationStartup": {}, - "linux:SystemThemeChanged": {}, - "linux:WindowDeleteEvent": {}, - "linux:WindowDidMove": {}, - "linux:WindowDidResize": {}, - "linux:WindowFocusIn": {}, - "linux:WindowFocusOut": {}, - "linux:WindowLoadStarted": {}, - "linux:WindowLoadRedirected": {}, - "linux:WindowLoadCommitted": {}, - "linux:WindowLoadFinished": {}, - "mac:ApplicationDidBecomeActive": {}, - "mac:ApplicationDidChangeBackingProperties": {}, - "mac:ApplicationDidChangeEffectiveAppearance": {}, - "mac:ApplicationDidChangeIcon": {}, - "mac:ApplicationDidChangeOcclusionState": {}, - "mac:ApplicationDidChangeScreenParameters": {}, - "mac:ApplicationDidChangeStatusBarFrame": {}, - "mac:ApplicationDidChangeStatusBarOrientation": {}, - "mac:ApplicationDidChangeTheme": {}, - "mac:ApplicationDidFinishLaunching": {}, - "mac:ApplicationDidHide": {}, - "mac:ApplicationDidResignActive": {}, - "mac:ApplicationDidUnhide": {}, - "mac:ApplicationDidUpdate": {}, - "mac:ApplicationShouldHandleReopen": {}, - "mac:ApplicationWillBecomeActive": {}, - "mac:ApplicationWillFinishLaunching": {}, - "mac:ApplicationWillHide": {}, - "mac:ApplicationWillResignActive": {}, - "mac:ApplicationWillTerminate": {}, - "mac:ApplicationWillUnhide": {}, - "mac:ApplicationWillUpdate": {}, - "mac:MenuDidAddItem": {}, - "mac:MenuDidBeginTracking": {}, - "mac:MenuDidClose": {}, - "mac:MenuDidDisplayItem": {}, - "mac:MenuDidEndTracking": {}, - "mac:MenuDidHighlightItem": {}, - "mac:MenuDidOpen": {}, - "mac:MenuDidPopUp": {}, - "mac:MenuDidRemoveItem": {}, - "mac:MenuDidSendAction": {}, - "mac:MenuDidSendActionToItem": {}, - "mac:MenuDidUpdate": {}, - "mac:MenuWillAddItem": {}, - "mac:MenuWillBeginTracking": {}, - "mac:MenuWillDisplayItem": {}, - "mac:MenuWillEndTracking": {}, - "mac:MenuWillHighlightItem": {}, - "mac:MenuWillOpen": {}, - "mac:MenuWillPopUp": {}, - "mac:MenuWillRemoveItem": {}, - "mac:MenuWillSendAction": {}, - "mac:MenuWillSendActionToItem": {}, - "mac:MenuWillUpdate": {}, - "mac:WebViewDidCommitNavigation": {}, - "mac:WebViewDidFinishNavigation": {}, + "common:ApplicationOpenedWithFile": {}, + "common:ApplicationStarted": {}, + "common:ApplicationLaunchedWithUrl": {}, + "common:ThemeChanged": {}, + "common:WindowClosing": {}, + "common:WindowDidMove": {}, + "common:WindowDidResize": {}, + "common:WindowDPIChanged": {}, + "common:WindowFilesDropped": {}, + "common:WindowFocus": {}, + "common:WindowFullscreen": {}, + "common:WindowHide": {}, + "common:WindowLostFocus": {}, + "common:WindowMaximise": {}, + "common:WindowMinimise": {}, + "common:WindowToggleFrameless": {}, + "common:WindowRestore": {}, + "common:WindowRuntimeReady": {}, + "common:WindowShow": {}, + "common:WindowUnFullscreen": {}, + "common:WindowUnMaximise": {}, + "common:WindowUnMinimise": {}, + "common:WindowZoom": {}, + "common:WindowZoomIn": {}, + "common:WindowZoomOut": {}, + "common:WindowZoomReset": {}, + "linux:ApplicationStartup": {}, + "linux:SystemThemeChanged": {}, + "linux:WindowDeleteEvent": {}, + "linux:WindowDidMove": {}, + "linux:WindowDidResize": {}, + "linux:WindowFocusIn": {}, + "linux:WindowFocusOut": {}, + "linux:WindowLoadStarted": {}, + "linux:WindowLoadRedirected": {}, + "linux:WindowLoadCommitted": {}, + "linux:WindowLoadFinished": {}, + "mac:ApplicationDidBecomeActive": {}, + "mac:ApplicationDidChangeBackingProperties": {}, + "mac:ApplicationDidChangeEffectiveAppearance": {}, + "mac:ApplicationDidChangeIcon": {}, + "mac:ApplicationDidChangeOcclusionState": {}, + "mac:ApplicationDidChangeScreenParameters": {}, + "mac:ApplicationDidChangeStatusBarFrame": {}, + "mac:ApplicationDidChangeStatusBarOrientation": {}, + "mac:ApplicationDidChangeTheme": {}, + "mac:ApplicationDidFinishLaunching": {}, + "mac:ApplicationDidHide": {}, + "mac:ApplicationDidResignActive": {}, + "mac:ApplicationDidUnhide": {}, + "mac:ApplicationDidUpdate": {}, + "mac:ApplicationShouldHandleReopen": {}, + "mac:ApplicationWillBecomeActive": {}, + "mac:ApplicationWillFinishLaunching": {}, + "mac:ApplicationWillHide": {}, + "mac:ApplicationWillResignActive": {}, + "mac:ApplicationWillTerminate": {}, + "mac:ApplicationWillUnhide": {}, + "mac:ApplicationWillUpdate": {}, + "mac:MenuDidAddItem": {}, + "mac:MenuDidBeginTracking": {}, + "mac:MenuDidClose": {}, + "mac:MenuDidDisplayItem": {}, + "mac:MenuDidEndTracking": {}, + "mac:MenuDidHighlightItem": {}, + "mac:MenuDidOpen": {}, + "mac:MenuDidPopUp": {}, + "mac:MenuDidRemoveItem": {}, + "mac:MenuDidSendAction": {}, + "mac:MenuDidSendActionToItem": {}, + "mac:MenuDidUpdate": {}, + "mac:MenuWillAddItem": {}, + "mac:MenuWillBeginTracking": {}, + "mac:MenuWillDisplayItem": {}, + "mac:MenuWillEndTracking": {}, + "mac:MenuWillHighlightItem": {}, + "mac:MenuWillOpen": {}, + "mac:MenuWillPopUp": {}, + "mac:MenuWillRemoveItem": {}, + "mac:MenuWillSendAction": {}, + "mac:MenuWillSendActionToItem": {}, + "mac:MenuWillUpdate": {}, + "mac:WebViewDidCommitNavigation": {}, + "mac:WebViewDidFinishNavigation": {}, "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation": {}, - "mac:WebViewDidStartProvisionalNavigation": {}, - "mac:WindowDidBecomeKey": {}, - "mac:WindowDidBecomeMain": {}, - "mac:WindowDidBeginSheet": {}, - "mac:WindowDidChangeAlpha": {}, - "mac:WindowDidChangeBackingLocation": {}, - "mac:WindowDidChangeBackingProperties": {}, - "mac:WindowDidChangeCollectionBehavior": {}, - "mac:WindowDidChangeEffectiveAppearance": {}, - "mac:WindowDidChangeOcclusionState": {}, - "mac:WindowDidChangeOrderingMode": {}, - "mac:WindowDidChangeScreen": {}, - "mac:WindowDidChangeScreenParameters": {}, - "mac:WindowDidChangeScreenProfile": {}, - "mac:WindowDidChangeScreenSpace": {}, - "mac:WindowDidChangeScreenSpaceProperties": {}, - "mac:WindowDidChangeSharingType": {}, - "mac:WindowDidChangeSpace": {}, - "mac:WindowDidChangeSpaceOrderingMode": {}, - "mac:WindowDidChangeTitle": {}, - "mac:WindowDidChangeToolbar": {}, - "mac:WindowDidDeminiaturize": {}, - "mac:WindowDidEndSheet": {}, - "mac:WindowDidEnterFullScreen": {}, - "mac:WindowDidEnterVersionBrowser": {}, - "mac:WindowDidExitFullScreen": {}, - "mac:WindowDidExitVersionBrowser": {}, - "mac:WindowDidExpose": {}, - "mac:WindowDidFocus": {}, - "mac:WindowDidMiniaturize": {}, - "mac:WindowDidMove": {}, - "mac:WindowDidOrderOffScreen": {}, - "mac:WindowDidOrderOnScreen": {}, - "mac:WindowDidResignKey": {}, - "mac:WindowDidResignMain": {}, - "mac:WindowDidResize": {}, - "mac:WindowDidUpdate": {}, - "mac:WindowDidUpdateAlpha": {}, - "mac:WindowDidUpdateCollectionBehavior": {}, - "mac:WindowDidUpdateCollectionProperties": {}, - "mac:WindowDidUpdateShadow": {}, - "mac:WindowDidUpdateTitle": {}, - "mac:WindowDidUpdateToolbar": {}, - "mac:WindowDidZoom": {}, - "mac:WindowFileDraggingEntered": {}, - "mac:WindowFileDraggingExited": {}, - "mac:WindowFileDraggingPerformed": {}, - "mac:WindowHide": {}, - "mac:WindowMaximise": {}, - "mac:WindowUnMaximise": {}, - "mac:WindowMinimise": {}, - "mac:WindowUnMinimise": {}, - "mac:WindowShouldClose": {}, - "mac:WindowShow": {}, - "mac:WindowWillBecomeKey": {}, - "mac:WindowWillBecomeMain": {}, - "mac:WindowWillBeginSheet": {}, - "mac:WindowWillChangeOrderingMode": {}, - "mac:WindowWillClose": {}, - "mac:WindowWillDeminiaturize": {}, - "mac:WindowWillEnterFullScreen": {}, - "mac:WindowWillEnterVersionBrowser": {}, - "mac:WindowWillExitFullScreen": {}, - "mac:WindowWillExitVersionBrowser": {}, - "mac:WindowWillFocus": {}, - "mac:WindowWillMiniaturize": {}, - "mac:WindowWillMove": {}, - "mac:WindowWillOrderOffScreen": {}, - "mac:WindowWillOrderOnScreen": {}, - "mac:WindowWillResignMain": {}, - "mac:WindowWillResize": {}, - "mac:WindowWillUnfocus": {}, - "mac:WindowWillUpdate": {}, - "mac:WindowWillUpdateAlpha": {}, - "mac:WindowWillUpdateCollectionBehavior": {}, - "mac:WindowWillUpdateCollectionProperties": {}, - "mac:WindowWillUpdateShadow": {}, - "mac:WindowWillUpdateTitle": {}, - "mac:WindowWillUpdateToolbar": {}, - "mac:WindowWillUpdateVisibility": {}, - "mac:WindowWillUseStandardFrame": {}, - "mac:WindowZoomIn": {}, - "mac:WindowZoomOut": {}, - "mac:WindowZoomReset": {}, - "windows:APMPowerSettingChange": {}, - "windows:APMPowerStatusChange": {}, - "windows:APMResumeAutomatic": {}, - "windows:APMResumeSuspend": {}, - "windows:APMSuspend": {}, - "windows:ApplicationStarted": {}, - "windows:SystemThemeChanged": {}, - "windows:WebViewNavigationCompleted": {}, - "windows:WindowActive": {}, - "windows:WindowBackgroundErase": {}, - "windows:WindowClickActive": {}, - "windows:WindowClosing": {}, - "windows:WindowDidMove": {}, - "windows:WindowDidResize": {}, - "windows:WindowDPIChanged": {}, - "windows:WindowDragDrop": {}, - "windows:WindowDragEnter": {}, - "windows:WindowDragLeave": {}, - "windows:WindowDragOver": {}, - "windows:WindowEndMove": {}, - "windows:WindowEndResize": {}, - "windows:WindowFullscreen": {}, - "windows:WindowHide": {}, - "windows:WindowInactive": {}, - "windows:WindowKeyDown": {}, - "windows:WindowKeyUp": {}, - "windows:WindowKillFocus": {}, - "windows:WindowNonClientHit": {}, - "windows:WindowNonClientMouseDown": {}, - "windows:WindowNonClientMouseLeave": {}, - "windows:WindowNonClientMouseMove": {}, - "windows:WindowNonClientMouseUp": {}, - "windows:WindowPaint": {}, - "windows:WindowRestore": {}, - "windows:WindowSetFocus": {}, - "windows:WindowShow": {}, - "windows:WindowStartMove": {}, - "windows:WindowStartResize": {}, - "windows:WindowUnFullscreen": {}, - "windows:WindowZOrderChanged": {}, - "windows:WindowMinimise": {}, - "windows:WindowUnMinimise": {}, - "windows:WindowMaximise": {}, - "windows:WindowUnMaximise": {}, + "mac:WebViewDidStartProvisionalNavigation": {}, + "mac:WindowDidBecomeKey": {}, + "mac:WindowDidBecomeMain": {}, + "mac:WindowDidBeginSheet": {}, + "mac:WindowDidChangeAlpha": {}, + "mac:WindowDidChangeBackingLocation": {}, + "mac:WindowDidChangeBackingProperties": {}, + "mac:WindowDidChangeCollectionBehavior": {}, + "mac:WindowDidChangeEffectiveAppearance": {}, + "mac:WindowDidChangeOcclusionState": {}, + "mac:WindowDidChangeOrderingMode": {}, + "mac:WindowDidChangeScreen": {}, + "mac:WindowDidChangeScreenParameters": {}, + "mac:WindowDidChangeScreenProfile": {}, + "mac:WindowDidChangeScreenSpace": {}, + "mac:WindowDidChangeScreenSpaceProperties": {}, + "mac:WindowDidChangeSharingType": {}, + "mac:WindowDidChangeSpace": {}, + "mac:WindowDidChangeSpaceOrderingMode": {}, + "mac:WindowDidChangeTitle": {}, + "mac:WindowDidChangeToolbar": {}, + "mac:WindowDidDeminiaturize": {}, + "mac:WindowDidEndSheet": {}, + "mac:WindowDidEnterFullScreen": {}, + "mac:WindowDidEnterVersionBrowser": {}, + "mac:WindowDidExitFullScreen": {}, + "mac:WindowDidExitVersionBrowser": {}, + "mac:WindowDidExpose": {}, + "mac:WindowDidFocus": {}, + "mac:WindowDidMiniaturize": {}, + "mac:WindowDidMove": {}, + "mac:WindowDidOrderOffScreen": {}, + "mac:WindowDidOrderOnScreen": {}, + "mac:WindowDidResignKey": {}, + "mac:WindowDidResignMain": {}, + "mac:WindowDidResize": {}, + "mac:WindowDidUpdate": {}, + "mac:WindowDidUpdateAlpha": {}, + "mac:WindowDidUpdateCollectionBehavior": {}, + "mac:WindowDidUpdateCollectionProperties": {}, + "mac:WindowDidUpdateShadow": {}, + "mac:WindowDidUpdateTitle": {}, + "mac:WindowDidUpdateToolbar": {}, + "mac:WindowDidZoom": {}, + "mac:WindowFileDraggingEntered": {}, + "mac:WindowFileDraggingExited": {}, + "mac:WindowFileDraggingPerformed": {}, + "mac:WindowHide": {}, + "mac:WindowMaximise": {}, + "mac:WindowUnMaximise": {}, + "mac:WindowMinimise": {}, + "mac:WindowUnMinimise": {}, + "mac:WindowShouldClose": {}, + "mac:WindowShow": {}, + "mac:WindowWillBecomeKey": {}, + "mac:WindowWillBecomeMain": {}, + "mac:WindowWillBeginSheet": {}, + "mac:WindowWillChangeOrderingMode": {}, + "mac:WindowWillClose": {}, + "mac:WindowWillDeminiaturize": {}, + "mac:WindowWillEnterFullScreen": {}, + "mac:WindowWillEnterVersionBrowser": {}, + "mac:WindowWillExitFullScreen": {}, + "mac:WindowWillExitVersionBrowser": {}, + "mac:WindowWillFocus": {}, + "mac:WindowWillMiniaturize": {}, + "mac:WindowWillMove": {}, + "mac:WindowWillOrderOffScreen": {}, + "mac:WindowWillOrderOnScreen": {}, + "mac:WindowWillResignMain": {}, + "mac:WindowWillResize": {}, + "mac:WindowWillUnfocus": {}, + "mac:WindowWillUpdate": {}, + "mac:WindowWillUpdateAlpha": {}, + "mac:WindowWillUpdateCollectionBehavior": {}, + "mac:WindowWillUpdateCollectionProperties": {}, + "mac:WindowWillUpdateShadow": {}, + "mac:WindowWillUpdateTitle": {}, + "mac:WindowWillUpdateToolbar": {}, + "mac:WindowWillUpdateVisibility": {}, + "mac:WindowWillUseStandardFrame": {}, + "mac:WindowZoomIn": {}, + "mac:WindowZoomOut": {}, + "mac:WindowZoomReset": {}, + "windows:APMPowerSettingChange": {}, + "windows:APMPowerStatusChange": {}, + "windows:APMResumeAutomatic": {}, + "windows:APMResumeSuspend": {}, + "windows:APMSuspend": {}, + "windows:ApplicationStarted": {}, + "windows:SystemThemeChanged": {}, + "windows:WebViewNavigationCompleted": {}, + "windows:WindowActive": {}, + "windows:WindowBackgroundErase": {}, + "windows:WindowClickActive": {}, + "windows:WindowClosing": {}, + "windows:WindowDidMove": {}, + "windows:WindowDidResize": {}, + "windows:WindowDPIChanged": {}, + "windows:WindowDragDrop": {}, + "windows:WindowDragEnter": {}, + "windows:WindowDragLeave": {}, + "windows:WindowDragOver": {}, + "windows:WindowEndMove": {}, + "windows:WindowEndResize": {}, + "windows:WindowFullscreen": {}, + "windows:WindowHide": {}, + "windows:WindowInactive": {}, + "windows:WindowKeyDown": {}, + "windows:WindowKeyUp": {}, + "windows:WindowKillFocus": {}, + "windows:WindowNonClientHit": {}, + "windows:WindowNonClientMouseDown": {}, + "windows:WindowNonClientMouseLeave": {}, + "windows:WindowNonClientMouseMove": {}, + "windows:WindowNonClientMouseUp": {}, + "windows:WindowPaint": {}, + "windows:WindowRestore": {}, + "windows:WindowSetFocus": {}, + "windows:WindowShow": {}, + "windows:WindowStartMove": {}, + "windows:WindowStartResize": {}, + "windows:WindowUnFullscreen": {}, + "windows:WindowZOrderChanged": {}, + "windows:WindowMinimise": {}, + "windows:WindowUnMinimise": {}, + "windows:WindowMaximise": {}, + "windows:WindowUnMaximise": {}, } From 722717a11e38497eca8de1b69152982f46ee1161 Mon Sep 17 00:00:00 2001 From: GitHub Actions Date: Sun, 4 Jan 2026 00:09:35 +0000 Subject: [PATCH 19/40] [skip ci] Publish @wailsio/runtime v3.0.0-alpha.78 --- .../@wailsio/runtime/docs/assets/hierarchy.js | 2 +- .../runtime/docs/assets/navigation.js | 2 +- .../@wailsio/runtime/docs/assets/search.js | 2 +- .../runtime/docs/classes/CancelError.html | 2 +- .../docs/classes/CancellablePromise.html | 2 +- .../docs/classes/CancelledRejectionError.html | 2 +- .../docs/classes/_internal_.Window.html | 110 +++++++++--------- .../docs/functions/System.Capabilities.html | 2 +- .../docs/functions/System.Environment.html | 2 +- .../System.HandlePlatformFileDrop.html | 6 - .../docs/functions/System.IsAMD64.html | 2 +- .../runtime/docs/functions/System.IsARM.html | 2 +- .../docs/functions/System.IsARM64.html | 2 +- .../docs/functions/System.IsDarkMode.html | 2 +- .../docs/functions/System.IsDebug.html | 2 +- .../docs/functions/System.IsLinux.html | 2 +- .../runtime/docs/functions/System.IsMac.html | 2 +- .../docs/functions/System.IsWindows.html | 2 +- .../runtime/docs/functions/System.invoke.html | 2 +- .../@wailsio/runtime/docs/hierarchy.html | 2 +- .../interfaces/System.EnvironmentInfo.html | 12 +- .../docs/interfaces/System.OSInfo.html | 10 +- .../docs/interfaces/_internal_.Position.html | 6 +- .../docs/interfaces/_internal_.Size.html | 6 +- .../@wailsio/runtime/docs/modules/System.html | 2 +- .../runtime/docs/variables/Events.Types.html | 2 +- .../runtime/docs/variables/Window.html | 2 +- .../@wailsio/runtime/package-lock.json | 8 +- .../desktop/@wailsio/runtime/package.json | 2 +- 29 files changed, 96 insertions(+), 106 deletions(-) delete mode 100644 v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.HandlePlatformFileDrop.html diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/hierarchy.js b/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/hierarchy.js index c6854a4ae..286659795 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/hierarchy.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/hierarchy.js @@ -1 +1 @@ -window.hierarchyData = "eJylj8EKgzAQRP9lztGi2KC59tpD70Uk1RWDa4QkPYn/XrRUerCl0NMuO8zOmwluHIOHusosEUWalwKOWqY6mNF6qAkyS5Zh9UBQOGlbE7O+MV3cOBhPZ9MTBHpjG6j0KAXujqFgbCDX6pr8Yd8Ud2FgCNSsvYdC8E20fIk25yJ2hhtHdiGUWTkLSJl95dlYkjR/sawRuyAfIZ6HWaBI87e830tX6241V/G/pef5ASffjm8=" \ No newline at end of file +window.hierarchyData = "eJylj8EKwjAQRP9lzrFiSkKbq1cP3kVKbFca3CaQxJP03yWK4kFF8LTLDrPz5oIYQk4wO10r0Uq5F4h0ZOqzCz7BXKBrVYa3E8FgbX1PzPbAtI1hcok27kQQODk/wEilBc6RYeB8pni0PaXle1M15okh0LNNCQY5DYvyZfF0FnF0PETyhVA1+1lAq+Yrz5NlJZsHyy3iLchHiPthFmilfMn7vXR3273lrvq39DxfASprjnI=" \ No newline at end of file diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/navigation.js b/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/navigation.js index 42de49abe..bbb7f2347 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/navigation.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/navigation.js @@ -1 +1 @@ -window.navigationData = "eJylmW1v5CYQx7+LXydtk+bSNqoqJdk8Sdluur5qX5xOJ9ZmExoMFuBN9qp+9woDNrbx4N28SrTzn98MmGEw/vJvovC7Si6S3wlTWDBE/0iOkhKpl+QiKXheUSx//OZs3354UQVNjpJXwvLk4vQoyV4IzQVmycWXBrUiLOdvLSajSMouxki6tJPTX/87aiA3QnCxKBXhTLaomrBBWZfma3sZfjo/MvGTi0TJ/JjIY/xu/BIv2oPCAq0pjkVyusOiPHFJdJKxKE43iOKzBC+IxLcV3RBKcb7EsqIqSg56HTgaw3okr9Fp86QfirXE/+BM7TnYrtOH4q+IelliyekWi+iqDPkcFj0l36NTrDXQerl8Q0ThvMWoXdklWEUP8tNvv5x8Op2U5jViGaZU14cdu/0FCyAs4BVMBQx4846zSvH94jmn/cOZpbVnOOd0SDizjPYMZ5xi4Z6QUARRgG0Vhy8Qm1GKlQrsWMN4AfnhwZcY5ZzRHRDQST4SJOMCKjIjODxAupMKFzdbzNSfqMBApJ4y/Pi/+jtEWVKSoW6DckcAz9glnYXPAPck95LbVCyru3OHozVd2PmZl89fFVExhNYAiPTFP4eEEVozQPjzciX4m/SLzs2JNUyaj0WJ2d/Lx1AyDmMlYC7XiNJhIvrXSVksK6ZIgevz0vB8VmN8CXQ+0+LB8cwswprj2WM7z9XuYRaamJqjjcATvtp1y2DgPVz7Hf/uhPa8h/PafxyUlGuO/IpvnokzTXowKVaf9X+hTBqQFQGjiTOCAH9IM4Iof5bDAVnDpOFcVUqNHHMdxkigE8stofiWUOWXXgDUyiDYHEuJnrFxgl4rHDbkAAXQ1atTmR4h6AGFSNEW7xci6AGF6O0M7QpyxMC+0FmBD2zDIX9tB9zdnEAIpwFbB5bdPjbEOA3UPuz0QRinATArJBhhzxDFSsDKrFt5oDDN75PqcoUIlbV+uPtbTCsBd/9KKl70M/JWoKX5OmjdtVH1nrtG2Wu/qQzSc8JYd2k9ZkihKFaLpiNDZ7ABcvz45e3c2rUlbZEg+gzf0Gp7F/Kz739ThA9L1l2bobLbbADnxWYD+16Ge2jrfhnoox4hWKfOGyrQBcuCxdn4ZlBdLti8ooqU4QJvGE4EFuctRaGmWf88qTTvsNLiUCYGYgVgFg+LdJjDwyKdlMEMb4k/nb6/sU3CdDuAtyV4nGEX6G4HY12khzg+AWfjHpWKZIGnojHWOG1IRYkylaodHRS7j/JksXI30rEhdoGBMfqjTDOBMQuM0hqmvRjgLHyd5iBaAJ5Nah2IMH9ByNg9V4OIXHLdYTWyFzmCUQCbwh1W15UQnRYZxFgVjHoSpEBiF0FZFbiYzet84CnXv096yDdsSwRnBWZqtEgtricFD75pDGYUEOMalWhNKFHEb4LeXBmQLwPm3UsegHkqgHWPWE7xE0Vqw0VRn6UFLwFs2AGIQNiWvwY7kCUaAXTmlpfz2fkZgLAKmLGcw4TlPOYfy0ErQMYMidc5D98cNRgngkl4XQWbaYvRCpDxSFj1DjJqBciYowwkzFEG+psPZVBRNBpw+1jNH4d7x2r+OHHj6H4ba3PQBGMFRrHElKN8zN1YI7de+lJ79NaqMcL3Vf2L8TGUr5lA1DfT+kKfcAZmOBDul+3oZ7awFN5t+x7x71oRHyicvVH8LBCTJRfhc0ZfBAEzSnRf8lZU+7rkbMCrEl/rp6BfyoIvXJ4ZgPS/cbf+oU/bHddnrAJz0RaFbweqSkYwEsJ8/R+gZOex" \ No newline at end of file +window.navigationData = "eJylmVFv2zYQx7+LnpNtydJsC4oBSeykAeI5s1r4oSgKWqZjLhQpkJQTd9h3HyiSEiVRR9l5SuD73++OFI9HUV//TRR+U8lV8pEwhQVD9M/kJCmQ2iZXSc7XJcXy5+/O9v2nrcppcpK8ELZOrs5PkmxL6Fpgllx9rVFLwtb8tcFkFEnZxhhJm3Z2/vt/JzVkKgQX80IRzmSDqggblLVpvraT4YfLExM/uUqUXJ8SeYrfjF/iRXtQWKAVxbFITndclCcuiU4yFsXpelF8luA5kfiupBtCKV4vsCypipKDXkeOxrAeyUt02jzpu2It8D84UwcOtu30rvhLorYLLDndYRFdlSGf46Kn5Ed0irUGWi/Xr4govG4wal+0CVbRgfzyx29nH85HpXmLWIYp1fVhx25/wQIIC3gFUwEDTt9wVip+WDzndHg4s7QODOecjglnltGB4YxTLNwTEoogCrCt4vgFYjNKsVKBHasfLyA/PvgCozVndA8EdJL3BMm4gIrMCI4PkO6lwvl0h5n6C+UYiNRRhh//N3+HKApKMtRuUO4I4BnbpIvwGeATWXvJbUqWVd25xdGaNuzywsvn75KoGEJrAES69c8hYYTW9BD+vNwI/ir9onNzYg2j5mNeYPZl8RhKxmGsBMzlFlHaT0T/OiqLRckUyXF1XuqfzyqML4HOZ1rcO56ZRVhxPHts57nZP0xCE1NxtBF4wjf7dhn0vPtrv+XfntCOd39eu4+DkmLFkV/x9TNxplEPJsXqs/4vlEkNsiJgNHFGEOAPaUIQ5c+yPyBrGDWcm1KpgWOuwxgJdGK5IxTfEar80guAGhkEm2Ep0TM2TtBrhcOGHKAAunp1KuMjBD2gECna4cNCBD2gEJ2doVlBjhjYF1or8IFtOOSv7YC7mxMI4TRg68Cy3cf6GKeB2oedPgjjNABmiQQj7BmiWAlYmVUrDxSm+X1UXS4RobLS93d/i2kk4O5fSsXzbkbeCrQ0Xwetuyaq3nNXKHvpNpVeek4Y6y6NxwQpFMVq0Xhk6AzWQw4fv7ydW7s2pB0SRJ/ha1plb0N+9f2nefiwZN21GSq7zQZwnm82sO91uIc27teBPuoRgnXqvKECnbMsWJy1bwbV5ZzNSqpIES7wmuFEYHHeURRqmtXPo0rzHistDmViIFYAZvEwT/s5PMzTURlM8I740+n7G9soTLsDeFuCx+l3gfZ2MNRFOojTM3A2PqFCkSzwVDTGGscNKS9QplK1p71i91GeLFbuRjo0xDYwMEZ/lGkmMGaBUVrDuBcDnIWv0xxEC8CzSaUDEeYvCBm656oRkUuue6wG9iJHMApgU7jH6rYUotUigxirglFPguRI7CMoqwIXs3mdDzzl6vdRD3nKdkRwlmOmBovU4jpS8OCbxmBGATFuUYFWhBJF/CbozZUB+TJg3r3kAZinAliE7fhLsD9YjBFAJ2J5PZtcXgAIq4AZixlMWMxi/rEctAJkTJB4mfHwvU6NcSKYhFdlsNU1GK0AGY+ElW8go1KAjBnKQMIMZaC/+YwFLdlaAxb3cvbYr+zl7HFkWbe/XDU5aIKxAqNYYMrResjdWCN3UvrKefBOqTbCt0nda+shlK8ZQdT3xvq6nXAGZtgTHpbt4EewsBTeC7se8a9OER8onL3v+ywQkwUX4VNAVwQBM0p01/BWVPMy42zAiwxf6aegX5mCr0OeGYB0v0A3/qEPzy3XZ6wCc9EUhW8HqkpGMBLCfPsftSXExw==" \ No newline at end of file diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/search.js b/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/search.js index 5b4416f34..db0533722 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/search.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/search.js @@ -1 +1 @@ -window.searchData = "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"; \ No newline at end of file +window.searchData = "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"; \ No newline at end of file diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancelError.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancelError.html index f1ae69413..1d49a3101 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancelError.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancelError.html @@ -2,7 +2,7 @@ in case a CancellablePromise is cancelled successfully.

            The value of the name property is the string "CancelError". The value of the cause property is the cause passed to the cancel method, if any.

            -

            Hierarchy

            Constructors

            constructor +

            Hierarchy

            Constructors

            constructor

            Properties

            cause? message name diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancellablePromise.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancellablePromise.html index 7084e82a5..fcc068fc8 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancellablePromise.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancellablePromise.html @@ -35,7 +35,7 @@ This might be reconsidered in case the proposal is retired.

            and is compliant with the Promises/A+ specification (it passes the compliance suite) if so is the underlying implementation.

            -

            Type Parameters

            • T

            Hierarchy

            Implements

            Constructors

            constructor +

            Type Parameters

            • T

            Hierarchy

            Implements

            Constructors

            constructor

            Properties

            [toStringTag]

            Methods

            cancel cancelOn diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancelledRejectionError.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancelledRejectionError.html index 6e18c34d9..48f30a330 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancelledRejectionError.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/CancelledRejectionError.html @@ -6,7 +6,7 @@ The value of the promise property holds a reference to the original promise.

            -

            Hierarchy

            • Error
              • CancelledRejectionError

            Constructors

            constructor +

            Hierarchy

            • Error
              • CancelledRejectionError

            Constructors

            constructor

            Properties

            cause? message name diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/_internal_.Window.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/_internal_.Window.html index 23541adeb..af1191e71 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/_internal_.Window.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/_internal_.Window.html @@ -1,4 +1,4 @@ -Window | @wailsio/runtime

            Class Window

            Methods

            Center +Window | @wailsio/runtime

            Class Window

            Methods

            Center Close DisableSizeConstraints EnableSizeConstraints @@ -52,94 +52,94 @@ ZoomOut ZoomReset

            Methods

            Center

            Close

            DisableSizeConstraints

            EnableSizeConstraints

            Focus

            ForceReload

            Fullscreen

            Get

            Close

            DisableSizeConstraints

            EnableSizeConstraints

            Focus

            ForceReload

            Fullscreen

            Get

            • Get(name: string): Window

              Gets the specified window.

              Parameters

              • name: string

                The name of the window to get.

              Returns Window

              The corresponding window object.

              -

            GetScreen

            GetScreen

            GetZoom

            GetZoom

            HandlePlatformFileDrop

            • HandlePlatformFileDrop(filenames: string[], x: number, y: number): void

              Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop). +

            HandlePlatformFileDrop

            • HandlePlatformFileDrop(filenames: string[], x: number, y: number): void

              Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop). Gathers information about the drop target element and sends it back to the Go backend.

              Parameters

              • filenames: string[]

                An array of file paths (strings) that were dropped.

                -
              • x: number

                The x-coordinate of the drop event.

                -
              • y: number

                The y-coordinate of the drop event.

                -

              Returns void

            Height

            • Height(): Promise<number>

              Returns the height of the window.

              +
            • x: number

              The x-coordinate of the drop event (CSS pixels).

              +
            • y: number

              The y-coordinate of the drop event (CSS pixels).

              +

            Returns void

            Height

            Hide

            IsFocused

            Hide

            IsFocused

            • IsFocused(): Promise<boolean>

              Returns true if the window is focused.

              Returns Promise<boolean>

              Whether the window is currently focused.

              -

            IsFullscreen

            IsFullscreen

            • IsFullscreen(): Promise<boolean>

              Returns true if the window is fullscreen.

              Returns Promise<boolean>

              Whether the window is currently fullscreen.

              -

            IsMaximised

            IsMaximised

            • IsMaximised(): Promise<boolean>

              Returns true if the window is maximised.

              Returns Promise<boolean>

              Whether the window is currently maximised.

              -

            IsMinimised

            IsMinimised

            • IsMinimised(): Promise<boolean>

              Returns true if the window is minimised.

              Returns Promise<boolean>

              Whether the window is currently minimised.

              -

            Maximise

            Minimise

            Name

            Maximise

            Minimise

            Name

            OpenDevTools

            Position

            OpenDevTools

            Position

            Print

            RelativePosition

            Print

            RelativePosition

            Reload

            Resizable

            Reload

            Resizable

            • Resizable(): Promise<boolean>

              Returns true if the window is resizable.

              Returns Promise<boolean>

              Whether the window is currently resizable.

              -

            Restore

            • Restore(): Promise<void>

              Restores the window to its previous state if it was previously minimised, maximised or fullscreen.

              -

              Returns Promise<void>

            SetAlwaysOnTop

            Restore

            • Restore(): Promise<void>

              Restores the window to its previous state if it was previously minimised, maximised or fullscreen.

              +

              Returns Promise<void>

            SetAlwaysOnTop

            • SetAlwaysOnTop(alwaysOnTop: boolean): Promise<void>

              Sets the window to be always on top.

              Parameters

              • alwaysOnTop: boolean

                Whether the window should stay on top.

                -

              Returns Promise<void>

            SetBackgroundColour

            • SetBackgroundColour(r: number, g: number, b: number, a: number): Promise<void>

              Sets the background colour of the window.

              +

            Returns Promise<void>

            SetBackgroundColour

            • SetBackgroundColour(r: number, g: number, b: number, a: number): Promise<void>

              Sets the background colour of the window.

              Parameters

              • r: number

                The desired red component of the window background.

              • g: number

                The desired green component of the window background.

              • b: number

                The desired blue component of the window background.

              • a: number

                The desired alpha component of the window background.

                -

              Returns Promise<void>

            SetFrameless

            • SetFrameless(frameless: boolean): Promise<void>

              Removes the window frame and title bar.

              +

            Returns Promise<void>

            SetFrameless

            • SetFrameless(frameless: boolean): Promise<void>

              Removes the window frame and title bar.

              Parameters

              • frameless: boolean

                Whether the window should be frameless.

                -

              Returns Promise<void>

            SetFullscreenButtonEnabled

            • SetFullscreenButtonEnabled(enabled: boolean): Promise<void>

              Disables the system fullscreen button.

              +

            Returns Promise<void>

            SetFullscreenButtonEnabled

            • SetFullscreenButtonEnabled(enabled: boolean): Promise<void>

              Disables the system fullscreen button.

              Parameters

              • enabled: boolean

                Whether the fullscreen button should be enabled.

                -

              Returns Promise<void>

            SetMaxSize

            • SetMaxSize(width: number, height: number): Promise<void>

              Sets the maximum size of the window.

              +

            Returns Promise<void>

            SetMaxSize

            • SetMaxSize(width: number, height: number): Promise<void>

              Sets the maximum size of the window.

              Parameters

              • width: number

                The desired maximum width of the window.

              • height: number

                The desired maximum height of the window.

                -

              Returns Promise<void>

            SetMinSize

            • SetMinSize(width: number, height: number): Promise<void>

              Sets the minimum size of the window.

              +

            Returns Promise<void>

            SetMinSize

            • SetMinSize(width: number, height: number): Promise<void>

              Sets the minimum size of the window.

              Parameters

              • width: number

                The desired minimum width of the window.

              • height: number

                The desired minimum height of the window.

                -

              Returns Promise<void>

            SetPosition

            • SetPosition(x: number, y: number): Promise<void>

              Sets the absolute position of the window.

              +

            Returns Promise<void>

            SetPosition

            • SetPosition(x: number, y: number): Promise<void>

              Sets the absolute position of the window.

              Parameters

              • x: number

                The desired horizontal absolute position of the window.

              • y: number

                The desired vertical absolute position of the window.

                -

              Returns Promise<void>

            SetRelativePosition

            • SetRelativePosition(x: number, y: number): Promise<void>

              Sets the relative position of the window to the screen.

              +

            Returns Promise<void>

            SetRelativePosition

            • SetRelativePosition(x: number, y: number): Promise<void>

              Sets the relative position of the window to the screen.

              Parameters

              • x: number

                The desired horizontal relative position of the window.

              • y: number

                The desired vertical relative position of the window.

                -

              Returns Promise<void>

            SetResizable

            • SetResizable(resizable: boolean): Promise<void>

              Sets whether the window is resizable.

              +

            Returns Promise<void>

            SetResizable

            • SetResizable(resizable: boolean): Promise<void>

              Sets whether the window is resizable.

              Parameters

              • resizable: boolean

                Whether the window should be resizable.

                -

              Returns Promise<void>

            SetSize

            • SetSize(width: number, height: number): Promise<void>

              Sets the size of the window.

              +

            Returns Promise<void>

            SetSize

            • SetSize(width: number, height: number): Promise<void>

              Sets the size of the window.

              Parameters

              • width: number

                The desired width of the window.

              • height: number

                The desired height of the window.

                -

              Returns Promise<void>

            SetTitle

            • SetTitle(title: string): Promise<void>

              Sets the title of the window.

              +

            Returns Promise<void>

            SetTitle

            • SetTitle(title: string): Promise<void>

              Sets the title of the window.

              Parameters

              • title: string

                The desired title of the window.

                -

              Returns Promise<void>

            SetZoom

            • SetZoom(zoom: number): Promise<void>

              Sets the zoom level of the window.

              +

            Returns Promise<void>

            SetZoom

            • SetZoom(zoom: number): Promise<void>

              Sets the zoom level of the window.

              Parameters

              • zoom: number

                The desired zoom level.

                -

              Returns Promise<void>

            Show

            Size

            Returns Promise<void>

            Show

            Size

            SnapAssist

            ToggleFrameless

            ToggleFullscreen

            ToggleMaximise

            UnFullscreen

            UnMaximise

            UnMinimise

            Width

            SnapAssist

            ToggleFrameless

            ToggleFullscreen

            ToggleMaximise

            UnFullscreen

            UnMaximise

            UnMinimise

            Width

            Zoom

            ZoomIn

            ZoomOut

            ZoomReset

            Settings

            Member Visibility

            On This Page

            Methods
            +

            Zoom

            ZoomIn

            ZoomOut

            ZoomReset

            Settings

            Member Visibility

            On This Page

            Methods
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.Capabilities.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.Capabilities.html index a1a7d4346..d8b16a640 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.Capabilities.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.Capabilities.html @@ -1,3 +1,3 @@ Capabilities | @wailsio/runtime

            Function Capabilities

            • Capabilities(): Promise<Record<string, any>>

              Fetches the capabilities of the application from the server.

              Returns Promise<Record<string, any>>

              A promise that resolves to an object containing the capabilities.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.Environment.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.Environment.html index 47e1891f1..83e16aed1 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.Environment.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.Environment.html @@ -1,3 +1,3 @@ Environment | @wailsio/runtime

            Function Environment

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.HandlePlatformFileDrop.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.HandlePlatformFileDrop.html deleted file mode 100644 index 6beac984d..000000000 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.HandlePlatformFileDrop.html +++ /dev/null @@ -1,6 +0,0 @@ -HandlePlatformFileDrop | @wailsio/runtime

            Function HandlePlatformFileDrop

            • HandlePlatformFileDrop(filenames: string[], x: number, y: number): void

              Handles file drops originating from platform-specific code (e.g., macOS native drag-and-drop). -Gathers information about the drop target element and sends it back to the Go backend.

              -

              Parameters

              • filenames: string[]

                An array of file paths (strings) that were dropped.

                -
              • x: number

                The x-coordinate of the drop event.

                -
              • y: number

                The y-coordinate of the drop event.

                -

              Returns void

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsAMD64.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsAMD64.html index 8adb43b2f..8463205b4 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsAMD64.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsAMD64.html @@ -1,3 +1,3 @@ IsAMD64 | @wailsio/runtime

            Function IsAMD64

            • IsAMD64(): boolean

              Checks if the current environment architecture is AMD64.

              Returns boolean

              True if the current environment architecture is AMD64, false otherwise.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsARM.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsARM.html index e60f1118f..4e85b9117 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsARM.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsARM.html @@ -1,3 +1,3 @@ IsARM | @wailsio/runtime

            Function IsARM

            • IsARM(): boolean

              Checks if the current architecture is ARM.

              Returns boolean

              True if the current architecture is ARM, false otherwise.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsARM64.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsARM64.html index 61a332039..8b6f9a174 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsARM64.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsARM64.html @@ -1,3 +1,3 @@ IsARM64 | @wailsio/runtime

            Function IsARM64

            • IsARM64(): boolean

              Checks if the current environment is ARM64 architecture.

              Returns boolean

              Returns true if the environment is ARM64 architecture, otherwise returns false.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsDarkMode.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsDarkMode.html index 480e901d0..461dc8e2e 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsDarkMode.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsDarkMode.html @@ -1,3 +1,3 @@ IsDarkMode | @wailsio/runtime

            Function IsDarkMode

            • IsDarkMode(): Promise<boolean>

              Retrieves the system dark mode status.

              Returns Promise<boolean>

              A promise that resolves to a boolean value indicating if the system is in dark mode.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsDebug.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsDebug.html index 04f19b050..f9fa983df 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsDebug.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsDebug.html @@ -1,3 +1,3 @@ IsDebug | @wailsio/runtime

            Function IsDebug

            • IsDebug(): boolean

              Reports whether the app is being run in debug mode.

              Returns boolean

              True if the app is being run in debug mode.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsLinux.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsLinux.html index cee1a14fe..98a91aeb2 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsLinux.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsLinux.html @@ -1,3 +1,3 @@ IsLinux | @wailsio/runtime

            Function IsLinux

            • IsLinux(): boolean

              Checks if the current operating system is Linux.

              Returns boolean

              Returns true if the current operating system is Linux, false otherwise.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsMac.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsMac.html index 059804d90..ec0843efc 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsMac.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsMac.html @@ -1,3 +1,3 @@ IsMac | @wailsio/runtime

            Function IsMac

            • IsMac(): boolean

              Checks if the current environment is a macOS operating system.

              Returns boolean

              True if the environment is macOS, false otherwise.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsWindows.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsWindows.html index dccf2541c..658f88991 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsWindows.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.IsWindows.html @@ -1,3 +1,3 @@ IsWindows | @wailsio/runtime

            Function IsWindows

            • IsWindows(): boolean

              Checks if the current operating system is Windows.

              Returns boolean

              True if the operating system is Windows, otherwise false.

              -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.invoke.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.invoke.html index c5e46e105..5a660b237 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.invoke.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/System.invoke.html @@ -1 +1 @@ -invoke | @wailsio/runtime

            Function invoke

            Settings

            Member Visibility
            +invoke | @wailsio/runtime

            Function invoke

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/hierarchy.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/hierarchy.html index eead3c931..4ee5aac30 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/hierarchy.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/hierarchy.html @@ -1 +1 @@ -@wailsio/runtime

            @wailsio/runtime

            Hierarchy Summary

            Settings

            Member Visibility
            +@wailsio/runtime

            @wailsio/runtime

            Hierarchy Summary

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/System.EnvironmentInfo.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/System.EnvironmentInfo.html index 185e9eaf9..16b194a24 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/System.EnvironmentInfo.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/System.EnvironmentInfo.html @@ -1,11 +1,11 @@ -EnvironmentInfo | @wailsio/runtime

            Interface EnvironmentInfo

            interface EnvironmentInfo {
                Arch: string;
                Debug: boolean;
                OS: string;
                OSInfo: OSInfo;
                PlatformInfo: Record<string, any>;
            }

            Properties

            Arch +EnvironmentInfo | @wailsio/runtime

            Interface EnvironmentInfo

            interface EnvironmentInfo {
                Arch: string;
                Debug: boolean;
                OS: string;
                OSInfo: OSInfo;
                PlatformInfo: Record<string, any>;
            }

            Properties

            Arch Debug OS OSInfo PlatformInfo

            Properties

            Arch

            Arch: string

            The architecture of the system.

            -

            Debug

            Debug: boolean

            True if the application is running in debug mode, otherwise false.

            -

            OS

            OS: string

            The operating system in use.

            -

            OSInfo

            OSInfo: OSInfo

            Details of the operating system.

            -

            PlatformInfo

            PlatformInfo: Record<string, any>

            Additional platform information.

            -

            Settings

            Member Visibility

            On This Page

            Properties
            +

            Debug

            Debug: boolean

            True if the application is running in debug mode, otherwise false.

            +

            OS

            OS: string

            The operating system in use.

            +

            OSInfo

            OSInfo: OSInfo

            Details of the operating system.

            +

            PlatformInfo

            PlatformInfo: Record<string, any>

            Additional platform information.

            +

            Settings

            Member Visibility

            On This Page

            Properties
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/System.OSInfo.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/System.OSInfo.html index 94ae84b8d..a008978cf 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/System.OSInfo.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/System.OSInfo.html @@ -1,9 +1,9 @@ -OSInfo | @wailsio/runtime

            Interface OSInfo

            interface OSInfo {
                Branding: string;
                ID: string;
                Name: string;
                Version: string;
            }

            Properties

            Branding +OSInfo | @wailsio/runtime

            Interface OSInfo

            interface OSInfo {
                Branding: string;
                ID: string;
                Name: string;
                Version: string;
            }

            Properties

            Branding ID Name Version

            Properties

            Branding

            Branding: string

            The branding of the OS.

            -

            ID

            ID: string

            The ID of the OS.

            -

            Name

            Name: string

            The name of the OS.

            -

            Version

            Version: string

            The version of the OS.

            -

            Settings

            Member Visibility

            On This Page

            Properties
            +

            ID

            ID: string

            The ID of the OS.

            +

            Name

            Name: string

            The name of the OS.

            +

            Version

            Version: string

            The version of the OS.

            +

            Settings

            Member Visibility

            On This Page

            Properties
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/_internal_.Position.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/_internal_.Position.html index 9a3cbd2e2..8cbcc9c3a 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/_internal_.Position.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/_internal_.Position.html @@ -1,6 +1,6 @@ Position | @wailsio/runtime

            Interface Position

            A record describing the position of a window.

            -
            interface Position {
                x: number;
                y: number;
            }

            Properties

            x +
            interface Position {
                x: number;
                y: number;
            }

            Properties

            x y

            Properties

            x

            x: number

            The horizontal position of the window.

            -

            y

            y: number

            The vertical position of the window.

            -

            Settings

            Member Visibility

            On This Page

            Properties
            +

            y

            y: number

            The vertical position of the window.

            +

            Settings

            Member Visibility

            On This Page

            Properties
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/_internal_.Size.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/_internal_.Size.html index dcfaf60bc..e7b5f32de 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/_internal_.Size.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/_internal_.Size.html @@ -1,6 +1,6 @@ Size | @wailsio/runtime

            Interface Size

            A record describing the size of a window.

            -
            interface Size {
                height: number;
                width: number;
            }

            Properties

            height +
            interface Size {
                height: number;
                width: number;
            }

            Properties

            height width

            Properties

            height

            height: number

            The height of the window.

            -

            width

            width: number

            The width of the window.

            -

            Settings

            Member Visibility

            On This Page

            Properties
            +

            width

            width: number

            The width of the window.

            +

            Settings

            Member Visibility

            On This Page

            Properties
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/modules/System.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/modules/System.html index c9043eddd..bc891a645 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/modules/System.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/modules/System.html @@ -1 +1 @@ -System | @wailsio/runtime

            Namespace System

            Interfaces

            EnvironmentInfo
            OSInfo

            Functions

            Capabilities
            Environment
            HandlePlatformFileDrop
            invoke
            IsAMD64
            IsARM
            IsARM64
            IsDarkMode
            IsDebug
            IsLinux
            IsMac
            IsWindows

            Settings

            Member Visibility

            On This Page

            Interfaces
            Functions
            +System | @wailsio/runtime

            Namespace System

            Interfaces

            EnvironmentInfo
            OSInfo

            Functions

            Capabilities
            Environment
            invoke
            IsAMD64
            IsARM
            IsARM64
            IsDarkMode
            IsDebug
            IsLinux
            IsMac
            IsWindows

            Settings

            Member Visibility

            On This Page

            Interfaces
            Functions
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Events.Types.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Events.Types.html index 5d0e94277..564d38e84 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Events.Types.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Events.Types.html @@ -1 +1 @@ -Types | @wailsio/runtime

            Variable TypesConst

            Types: Readonly<
                {
                    Common: Readonly<
                        {
                            ApplicationLaunchedWithUrl: "common:ApplicationLaunchedWithUrl";
                            ApplicationOpenedWithFile: "common:ApplicationOpenedWithFile";
                            ApplicationStarted: "common:ApplicationStarted";
                            ThemeChanged: "common:ThemeChanged";
                            WindowClosing: "common:WindowClosing";
                            WindowDidMove: "common:WindowDidMove";
                            WindowDidResize: "common:WindowDidResize";
                            WindowDPIChanged: "common:WindowDPIChanged";
                            WindowDropZoneFilesDropped: "common:WindowDropZoneFilesDropped";
                            WindowFilesDropped: "common:WindowFilesDropped";
                            WindowFocus: "common:WindowFocus";
                            WindowFullscreen: "common:WindowFullscreen";
                            WindowHide: "common:WindowHide";
                            WindowLostFocus: "common:WindowLostFocus";
                            WindowMaximise: "common:WindowMaximise";
                            WindowMinimise: "common:WindowMinimise";
                            WindowRestore: "common:WindowRestore";
                            WindowRuntimeReady: "common:WindowRuntimeReady";
                            WindowShow: "common:WindowShow";
                            WindowToggleFrameless: "common:WindowToggleFrameless";
                            WindowUnFullscreen: "common:WindowUnFullscreen";
                            WindowUnMaximise: "common:WindowUnMaximise";
                            WindowUnMinimise: "common:WindowUnMinimise";
                            WindowZoom: "common:WindowZoom";
                            WindowZoomIn: "common:WindowZoomIn";
                            WindowZoomOut: "common:WindowZoomOut";
                            WindowZoomReset: "common:WindowZoomReset";
                        },
                    >;
                    iOS: Readonly<
                        {
                            ApplicationDidBecomeActive: "ios:ApplicationDidBecomeActive";
                            ApplicationDidEnterBackground: "ios:ApplicationDidEnterBackground";
                            ApplicationDidFinishLaunching: "ios:ApplicationDidFinishLaunching";
                            ApplicationDidReceiveMemoryWarning: "ios:ApplicationDidReceiveMemoryWarning";
                            ApplicationWillEnterForeground: "ios:ApplicationWillEnterForeground";
                            ApplicationWillResignActive: "ios:ApplicationWillResignActive";
                            ApplicationWillTerminate: "ios:ApplicationWillTerminate";
                            WebViewDecidePolicyForNavigationAction: "ios:WebViewDecidePolicyForNavigationAction";
                            WebViewDidFailNavigation: "ios:WebViewDidFailNavigation";
                            WebViewDidFinishNavigation: "ios:WebViewDidFinishNavigation";
                            WebViewDidStartNavigation: "ios:WebViewDidStartNavigation";
                            WindowDidAppear: "ios:WindowDidAppear";
                            WindowDidDisappear: "ios:WindowDidDisappear";
                            WindowDidLoad: "ios:WindowDidLoad";
                            WindowOrientationChanged: "ios:WindowOrientationChanged";
                            WindowSafeAreaInsetsChanged: "ios:WindowSafeAreaInsetsChanged";
                            WindowTouchBegan: "ios:WindowTouchBegan";
                            WindowTouchCancelled: "ios:WindowTouchCancelled";
                            WindowTouchEnded: "ios:WindowTouchEnded";
                            WindowTouchMoved: "ios:WindowTouchMoved";
                            WindowWillAppear: "ios:WindowWillAppear";
                            WindowWillDisappear: "ios:WindowWillDisappear";
                        },
                    >;
                    Linux: Readonly<
                        {
                            ApplicationStartup: "linux:ApplicationStartup";
                            SystemThemeChanged: "linux:SystemThemeChanged";
                            WindowDeleteEvent: "linux:WindowDeleteEvent";
                            WindowDidMove: "linux:WindowDidMove";
                            WindowDidResize: "linux:WindowDidResize";
                            WindowFocusIn: "linux:WindowFocusIn";
                            WindowFocusOut: "linux:WindowFocusOut";
                            WindowLoadCommitted: "linux:WindowLoadCommitted";
                            WindowLoadFinished: "linux:WindowLoadFinished";
                            WindowLoadRedirected: "linux:WindowLoadRedirected";
                            WindowLoadStarted: "linux:WindowLoadStarted";
                        },
                    >;
                    Mac: Readonly<
                        {
                            ApplicationDidBecomeActive: "mac:ApplicationDidBecomeActive";
                            ApplicationDidChangeBackingProperties: "mac:ApplicationDidChangeBackingProperties";
                            ApplicationDidChangeEffectiveAppearance: "mac:ApplicationDidChangeEffectiveAppearance";
                            ApplicationDidChangeIcon: "mac:ApplicationDidChangeIcon";
                            ApplicationDidChangeOcclusionState: "mac:ApplicationDidChangeOcclusionState";
                            ApplicationDidChangeScreenParameters: "mac:ApplicationDidChangeScreenParameters";
                            ApplicationDidChangeStatusBarFrame: "mac:ApplicationDidChangeStatusBarFrame";
                            ApplicationDidChangeStatusBarOrientation: "mac:ApplicationDidChangeStatusBarOrientation";
                            ApplicationDidChangeTheme: "mac:ApplicationDidChangeTheme";
                            ApplicationDidFinishLaunching: "mac:ApplicationDidFinishLaunching";
                            ApplicationDidHide: "mac:ApplicationDidHide";
                            ApplicationDidResignActive: "mac:ApplicationDidResignActive";
                            ApplicationDidUnhide: "mac:ApplicationDidUnhide";
                            ApplicationDidUpdate: "mac:ApplicationDidUpdate";
                            ApplicationShouldHandleReopen: "mac:ApplicationShouldHandleReopen";
                            ApplicationWillBecomeActive: "mac:ApplicationWillBecomeActive";
                            ApplicationWillFinishLaunching: "mac:ApplicationWillFinishLaunching";
                            ApplicationWillHide: "mac:ApplicationWillHide";
                            ApplicationWillResignActive: "mac:ApplicationWillResignActive";
                            ApplicationWillTerminate: "mac:ApplicationWillTerminate";
                            ApplicationWillUnhide: "mac:ApplicationWillUnhide";
                            ApplicationWillUpdate: "mac:ApplicationWillUpdate";
                            MenuDidAddItem: "mac:MenuDidAddItem";
                            MenuDidBeginTracking: "mac:MenuDidBeginTracking";
                            MenuDidClose: "mac:MenuDidClose";
                            MenuDidDisplayItem: "mac:MenuDidDisplayItem";
                            MenuDidEndTracking: "mac:MenuDidEndTracking";
                            MenuDidHighlightItem: "mac:MenuDidHighlightItem";
                            MenuDidOpen: "mac:MenuDidOpen";
                            MenuDidPopUp: "mac:MenuDidPopUp";
                            MenuDidRemoveItem: "mac:MenuDidRemoveItem";
                            MenuDidSendAction: "mac:MenuDidSendAction";
                            MenuDidSendActionToItem: "mac:MenuDidSendActionToItem";
                            MenuDidUpdate: "mac:MenuDidUpdate";
                            MenuWillAddItem: "mac:MenuWillAddItem";
                            MenuWillBeginTracking: "mac:MenuWillBeginTracking";
                            MenuWillDisplayItem: "mac:MenuWillDisplayItem";
                            MenuWillEndTracking: "mac:MenuWillEndTracking";
                            MenuWillHighlightItem: "mac:MenuWillHighlightItem";
                            MenuWillOpen: "mac:MenuWillOpen";
                            MenuWillPopUp: "mac:MenuWillPopUp";
                            MenuWillRemoveItem: "mac:MenuWillRemoveItem";
                            MenuWillSendAction: "mac:MenuWillSendAction";
                            MenuWillSendActionToItem: "mac:MenuWillSendActionToItem";
                            MenuWillUpdate: "mac:MenuWillUpdate";
                            WebViewDidCommitNavigation: "mac:WebViewDidCommitNavigation";
                            WebViewDidFinishNavigation: "mac:WebViewDidFinishNavigation";
                            WebViewDidReceiveServerRedirectForProvisionalNavigation: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation";
                            WebViewDidStartProvisionalNavigation: "mac:WebViewDidStartProvisionalNavigation";
                            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";
                            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";
                            WindowDidZoom: "mac:WindowDidZoom";
                            WindowFileDraggingEntered: "mac:WindowFileDraggingEntered";
                            WindowFileDraggingExited: "mac:WindowFileDraggingExited";
                            WindowFileDraggingPerformed: "mac:WindowFileDraggingPerformed";
                            WindowHide: "mac:WindowHide";
                            WindowMaximise: "mac:WindowMaximise";
                            WindowMinimise: "mac:WindowMinimise";
                            WindowShouldClose: "mac:WindowShouldClose";
                            WindowShow: "mac:WindowShow";
                            WindowUnMaximise: "mac:WindowUnMaximise";
                            WindowUnMinimise: "mac:WindowUnMinimise";
                            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";
                            WindowZoomIn: "mac:WindowZoomIn";
                            WindowZoomOut: "mac:WindowZoomOut";
                            WindowZoomReset: "mac:WindowZoomReset";
                        },
                    >;
                    Windows: Readonly<
                        {
                            APMPowerSettingChange: "windows:APMPowerSettingChange";
                            APMPowerStatusChange: "windows:APMPowerStatusChange";
                            APMResumeAutomatic: "windows:APMResumeAutomatic";
                            APMResumeSuspend: "windows:APMResumeSuspend";
                            APMSuspend: "windows:APMSuspend";
                            ApplicationStarted: "windows:ApplicationStarted";
                            SystemThemeChanged: "windows:SystemThemeChanged";
                            WebViewNavigationCompleted: "windows:WebViewNavigationCompleted";
                            WindowActive: "windows:WindowActive";
                            WindowBackgroundErase: "windows:WindowBackgroundErase";
                            WindowClickActive: "windows:WindowClickActive";
                            WindowClosing: "windows:WindowClosing";
                            WindowDidMove: "windows:WindowDidMove";
                            WindowDidResize: "windows:WindowDidResize";
                            WindowDPIChanged: "windows:WindowDPIChanged";
                            WindowDragDrop: "windows:WindowDragDrop";
                            WindowDragEnter: "windows:WindowDragEnter";
                            WindowDragLeave: "windows:WindowDragLeave";
                            WindowDragOver: "windows:WindowDragOver";
                            WindowEndMove: "windows:WindowEndMove";
                            WindowEndResize: "windows:WindowEndResize";
                            WindowFullscreen: "windows:WindowFullscreen";
                            WindowHide: "windows:WindowHide";
                            WindowInactive: "windows:WindowInactive";
                            WindowKeyDown: "windows:WindowKeyDown";
                            WindowKeyUp: "windows:WindowKeyUp";
                            WindowKillFocus: "windows:WindowKillFocus";
                            WindowMaximise: "windows:WindowMaximise";
                            WindowMinimise: "windows:WindowMinimise";
                            WindowNonClientHit: "windows:WindowNonClientHit";
                            WindowNonClientMouseDown: "windows:WindowNonClientMouseDown";
                            WindowNonClientMouseLeave: "windows:WindowNonClientMouseLeave";
                            WindowNonClientMouseMove: "windows:WindowNonClientMouseMove";
                            WindowNonClientMouseUp: "windows:WindowNonClientMouseUp";
                            WindowPaint: "windows:WindowPaint";
                            WindowRestore: "windows:WindowRestore";
                            WindowSetFocus: "windows:WindowSetFocus";
                            WindowShow: "windows:WindowShow";
                            WindowStartMove: "windows:WindowStartMove";
                            WindowStartResize: "windows:WindowStartResize";
                            WindowUnFullscreen: "windows:WindowUnFullscreen";
                            WindowUnMaximise: "windows:WindowUnMaximise";
                            WindowUnMinimise: "windows:WindowUnMinimise";
                            WindowZOrderChanged: "windows:WindowZOrderChanged";
                        },
                    >;
                },
            > = ...

            Settings

            Member Visibility
            +Types | @wailsio/runtime

            Variable TypesConst

            Types: Readonly<
                {
                    Common: Readonly<
                        {
                            ApplicationLaunchedWithUrl: "common:ApplicationLaunchedWithUrl";
                            ApplicationOpenedWithFile: "common:ApplicationOpenedWithFile";
                            ApplicationStarted: "common:ApplicationStarted";
                            ThemeChanged: "common:ThemeChanged";
                            WindowClosing: "common:WindowClosing";
                            WindowDidMove: "common:WindowDidMove";
                            WindowDidResize: "common:WindowDidResize";
                            WindowDPIChanged: "common:WindowDPIChanged";
                            WindowFilesDropped: "common:WindowFilesDropped";
                            WindowFocus: "common:WindowFocus";
                            WindowFullscreen: "common:WindowFullscreen";
                            WindowHide: "common:WindowHide";
                            WindowLostFocus: "common:WindowLostFocus";
                            WindowMaximise: "common:WindowMaximise";
                            WindowMinimise: "common:WindowMinimise";
                            WindowRestore: "common:WindowRestore";
                            WindowRuntimeReady: "common:WindowRuntimeReady";
                            WindowShow: "common:WindowShow";
                            WindowToggleFrameless: "common:WindowToggleFrameless";
                            WindowUnFullscreen: "common:WindowUnFullscreen";
                            WindowUnMaximise: "common:WindowUnMaximise";
                            WindowUnMinimise: "common:WindowUnMinimise";
                            WindowZoom: "common:WindowZoom";
                            WindowZoomIn: "common:WindowZoomIn";
                            WindowZoomOut: "common:WindowZoomOut";
                            WindowZoomReset: "common:WindowZoomReset";
                        },
                    >;
                    iOS: Readonly<
                        {
                            ApplicationDidBecomeActive: "ios:ApplicationDidBecomeActive";
                            ApplicationDidEnterBackground: "ios:ApplicationDidEnterBackground";
                            ApplicationDidFinishLaunching: "ios:ApplicationDidFinishLaunching";
                            ApplicationDidReceiveMemoryWarning: "ios:ApplicationDidReceiveMemoryWarning";
                            ApplicationWillEnterForeground: "ios:ApplicationWillEnterForeground";
                            ApplicationWillResignActive: "ios:ApplicationWillResignActive";
                            ApplicationWillTerminate: "ios:ApplicationWillTerminate";
                            WebViewDecidePolicyForNavigationAction: "ios:WebViewDecidePolicyForNavigationAction";
                            WebViewDidFailNavigation: "ios:WebViewDidFailNavigation";
                            WebViewDidFinishNavigation: "ios:WebViewDidFinishNavigation";
                            WebViewDidStartNavigation: "ios:WebViewDidStartNavigation";
                            WindowDidAppear: "ios:WindowDidAppear";
                            WindowDidDisappear: "ios:WindowDidDisappear";
                            WindowDidLoad: "ios:WindowDidLoad";
                            WindowOrientationChanged: "ios:WindowOrientationChanged";
                            WindowSafeAreaInsetsChanged: "ios:WindowSafeAreaInsetsChanged";
                            WindowTouchBegan: "ios:WindowTouchBegan";
                            WindowTouchCancelled: "ios:WindowTouchCancelled";
                            WindowTouchEnded: "ios:WindowTouchEnded";
                            WindowTouchMoved: "ios:WindowTouchMoved";
                            WindowWillAppear: "ios:WindowWillAppear";
                            WindowWillDisappear: "ios:WindowWillDisappear";
                        },
                    >;
                    Linux: Readonly<
                        {
                            ApplicationStartup: "linux:ApplicationStartup";
                            SystemThemeChanged: "linux:SystemThemeChanged";
                            WindowDeleteEvent: "linux:WindowDeleteEvent";
                            WindowDidMove: "linux:WindowDidMove";
                            WindowDidResize: "linux:WindowDidResize";
                            WindowFocusIn: "linux:WindowFocusIn";
                            WindowFocusOut: "linux:WindowFocusOut";
                            WindowLoadCommitted: "linux:WindowLoadCommitted";
                            WindowLoadFinished: "linux:WindowLoadFinished";
                            WindowLoadRedirected: "linux:WindowLoadRedirected";
                            WindowLoadStarted: "linux:WindowLoadStarted";
                        },
                    >;
                    Mac: Readonly<
                        {
                            ApplicationDidBecomeActive: "mac:ApplicationDidBecomeActive";
                            ApplicationDidChangeBackingProperties: "mac:ApplicationDidChangeBackingProperties";
                            ApplicationDidChangeEffectiveAppearance: "mac:ApplicationDidChangeEffectiveAppearance";
                            ApplicationDidChangeIcon: "mac:ApplicationDidChangeIcon";
                            ApplicationDidChangeOcclusionState: "mac:ApplicationDidChangeOcclusionState";
                            ApplicationDidChangeScreenParameters: "mac:ApplicationDidChangeScreenParameters";
                            ApplicationDidChangeStatusBarFrame: "mac:ApplicationDidChangeStatusBarFrame";
                            ApplicationDidChangeStatusBarOrientation: "mac:ApplicationDidChangeStatusBarOrientation";
                            ApplicationDidChangeTheme: "mac:ApplicationDidChangeTheme";
                            ApplicationDidFinishLaunching: "mac:ApplicationDidFinishLaunching";
                            ApplicationDidHide: "mac:ApplicationDidHide";
                            ApplicationDidResignActive: "mac:ApplicationDidResignActive";
                            ApplicationDidUnhide: "mac:ApplicationDidUnhide";
                            ApplicationDidUpdate: "mac:ApplicationDidUpdate";
                            ApplicationShouldHandleReopen: "mac:ApplicationShouldHandleReopen";
                            ApplicationWillBecomeActive: "mac:ApplicationWillBecomeActive";
                            ApplicationWillFinishLaunching: "mac:ApplicationWillFinishLaunching";
                            ApplicationWillHide: "mac:ApplicationWillHide";
                            ApplicationWillResignActive: "mac:ApplicationWillResignActive";
                            ApplicationWillTerminate: "mac:ApplicationWillTerminate";
                            ApplicationWillUnhide: "mac:ApplicationWillUnhide";
                            ApplicationWillUpdate: "mac:ApplicationWillUpdate";
                            MenuDidAddItem: "mac:MenuDidAddItem";
                            MenuDidBeginTracking: "mac:MenuDidBeginTracking";
                            MenuDidClose: "mac:MenuDidClose";
                            MenuDidDisplayItem: "mac:MenuDidDisplayItem";
                            MenuDidEndTracking: "mac:MenuDidEndTracking";
                            MenuDidHighlightItem: "mac:MenuDidHighlightItem";
                            MenuDidOpen: "mac:MenuDidOpen";
                            MenuDidPopUp: "mac:MenuDidPopUp";
                            MenuDidRemoveItem: "mac:MenuDidRemoveItem";
                            MenuDidSendAction: "mac:MenuDidSendAction";
                            MenuDidSendActionToItem: "mac:MenuDidSendActionToItem";
                            MenuDidUpdate: "mac:MenuDidUpdate";
                            MenuWillAddItem: "mac:MenuWillAddItem";
                            MenuWillBeginTracking: "mac:MenuWillBeginTracking";
                            MenuWillDisplayItem: "mac:MenuWillDisplayItem";
                            MenuWillEndTracking: "mac:MenuWillEndTracking";
                            MenuWillHighlightItem: "mac:MenuWillHighlightItem";
                            MenuWillOpen: "mac:MenuWillOpen";
                            MenuWillPopUp: "mac:MenuWillPopUp";
                            MenuWillRemoveItem: "mac:MenuWillRemoveItem";
                            MenuWillSendAction: "mac:MenuWillSendAction";
                            MenuWillSendActionToItem: "mac:MenuWillSendActionToItem";
                            MenuWillUpdate: "mac:MenuWillUpdate";
                            WebViewDidCommitNavigation: "mac:WebViewDidCommitNavigation";
                            WebViewDidFinishNavigation: "mac:WebViewDidFinishNavigation";
                            WebViewDidReceiveServerRedirectForProvisionalNavigation: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation";
                            WebViewDidStartProvisionalNavigation: "mac:WebViewDidStartProvisionalNavigation";
                            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";
                            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";
                            WindowDidZoom: "mac:WindowDidZoom";
                            WindowFileDraggingEntered: "mac:WindowFileDraggingEntered";
                            WindowFileDraggingExited: "mac:WindowFileDraggingExited";
                            WindowFileDraggingPerformed: "mac:WindowFileDraggingPerformed";
                            WindowHide: "mac:WindowHide";
                            WindowMaximise: "mac:WindowMaximise";
                            WindowMinimise: "mac:WindowMinimise";
                            WindowShouldClose: "mac:WindowShouldClose";
                            WindowShow: "mac:WindowShow";
                            WindowUnMaximise: "mac:WindowUnMaximise";
                            WindowUnMinimise: "mac:WindowUnMinimise";
                            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";
                            WindowZoomIn: "mac:WindowZoomIn";
                            WindowZoomOut: "mac:WindowZoomOut";
                            WindowZoomReset: "mac:WindowZoomReset";
                        },
                    >;
                    Windows: Readonly<
                        {
                            APMPowerSettingChange: "windows:APMPowerSettingChange";
                            APMPowerStatusChange: "windows:APMPowerStatusChange";
                            APMResumeAutomatic: "windows:APMResumeAutomatic";
                            APMResumeSuspend: "windows:APMResumeSuspend";
                            APMSuspend: "windows:APMSuspend";
                            ApplicationStarted: "windows:ApplicationStarted";
                            SystemThemeChanged: "windows:SystemThemeChanged";
                            WebViewNavigationCompleted: "windows:WebViewNavigationCompleted";
                            WindowActive: "windows:WindowActive";
                            WindowBackgroundErase: "windows:WindowBackgroundErase";
                            WindowClickActive: "windows:WindowClickActive";
                            WindowClosing: "windows:WindowClosing";
                            WindowDidMove: "windows:WindowDidMove";
                            WindowDidResize: "windows:WindowDidResize";
                            WindowDPIChanged: "windows:WindowDPIChanged";
                            WindowDragDrop: "windows:WindowDragDrop";
                            WindowDragEnter: "windows:WindowDragEnter";
                            WindowDragLeave: "windows:WindowDragLeave";
                            WindowDragOver: "windows:WindowDragOver";
                            WindowEndMove: "windows:WindowEndMove";
                            WindowEndResize: "windows:WindowEndResize";
                            WindowFullscreen: "windows:WindowFullscreen";
                            WindowHide: "windows:WindowHide";
                            WindowInactive: "windows:WindowInactive";
                            WindowKeyDown: "windows:WindowKeyDown";
                            WindowKeyUp: "windows:WindowKeyUp";
                            WindowKillFocus: "windows:WindowKillFocus";
                            WindowMaximise: "windows:WindowMaximise";
                            WindowMinimise: "windows:WindowMinimise";
                            WindowNonClientHit: "windows:WindowNonClientHit";
                            WindowNonClientMouseDown: "windows:WindowNonClientMouseDown";
                            WindowNonClientMouseLeave: "windows:WindowNonClientMouseLeave";
                            WindowNonClientMouseMove: "windows:WindowNonClientMouseMove";
                            WindowNonClientMouseUp: "windows:WindowNonClientMouseUp";
                            WindowPaint: "windows:WindowPaint";
                            WindowRestore: "windows:WindowRestore";
                            WindowSetFocus: "windows:WindowSetFocus";
                            WindowShow: "windows:WindowShow";
                            WindowStartMove: "windows:WindowStartMove";
                            WindowStartResize: "windows:WindowStartResize";
                            WindowUnFullscreen: "windows:WindowUnFullscreen";
                            WindowUnMaximise: "windows:WindowUnMaximise";
                            WindowUnMinimise: "windows:WindowUnMinimise";
                            WindowZOrderChanged: "windows:WindowZOrderChanged";
                        },
                    >;
                },
            > = ...

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Window.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Window.html index ee1c89b56..8b7134654 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Window.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Window.html @@ -1,2 +1,2 @@ Window | @wailsio/runtime

            Variable WindowConst

            Window: Window = ...

            The window within which the script is running.

            -

            Settings

            Member Visibility
            +

            Settings

            Member Visibility
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json b/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json index 23919ec7b..decb9300b 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json +++ b/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json @@ -1,12 +1,12 @@ { "name": "@wailsio/runtime", - "version": "3.0.0-alpha.77", + "version": "3.0.0-alpha.78", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@wailsio/runtime", - "version": "3.0.0-alpha.77", + "version": "3.0.0-alpha.78", "license": "MIT", "devDependencies": { "happy-dom": "^17.1.1", @@ -1584,7 +1584,6 @@ "integrity": "sha512-HL26ajjMVe/wr3xlzjF0sCPCiAKaZJcIRFZHmG4yKHRJp4YAkHPG5X6GfWxCeDTpOmuHhNiOyNKUoZjjnm0tjw==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "webidl-conversions": "^7.0.0", "whatwg-mimetype": "^3.0.0" @@ -2562,7 +2561,6 @@ "integrity": "sha512-/z585740YHURLl9DN2jCWe6OW7zKYm6VoQ93H0sxZ1cwHQEQrUn5BJrEnkWhfzUdyO+BLGjnKUZ9iz9hKloFDw==", "dev": true, "license": "Apache-2.0", - "peer": true, "dependencies": { "@gerrit0/mini-shiki": "^1.24.0", "lunr": "^2.3.9", @@ -2635,7 +2633,6 @@ "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==", "dev": true, "license": "Apache-2.0", - "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -2664,7 +2661,6 @@ "integrity": "sha512-EK5cY7Q1D8JNhSaPKVK4pwBFvaTmZxEnoKXLG/U9gmdDcihQGNzFlgIvaxezFR4glP1LsuiedwMBqCXH3wZccA==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "esbuild": "^0.21.3", "postcss": "^8.4.43", diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/package.json b/v3/internal/runtime/desktop/@wailsio/runtime/package.json index d2aec346e..bbbc94976 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/package.json +++ b/v3/internal/runtime/desktop/@wailsio/runtime/package.json @@ -1,7 +1,7 @@ { "name": "@wailsio/runtime", "type": "module", - "version": "3.0.0-alpha.77", + "version": "3.0.0-alpha.78", "description": "Wails Runtime", "types": "types/index.d.ts", "exports": { From f1a4ffe72dc7bc2fa6bf4f020b51a8d9fb86ef26 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Sun, 4 Jan 2026 11:59:22 +1100 Subject: [PATCH 20/40] feat(linux): add libpath package for finding native library paths (#4847) * feat(linux): add libpath package for finding native library paths Add a new internal/libpath package that locates shared libraries (.so files) on Linux systems. Supports multiple distributions and package managers. Features: - Multi-tier search: pkg-config -> ldconfig -> filesystem scanning - Parallel search using goroutines for faster lookups - Cached dynamic path discovery for Flatpak, Snap, and Nix - Support for Debian/Ubuntu, Fedora/RHEL, Arch, openSUSE, NixOS - Context-aware cancellation for graceful shutdown Performance: - Library found: ~1.4ms (parallel search) - Library not found: ~46ms (was 84ms sequential) - Cached path discovery: 14ns (was 15ms uncached) * feat(libpath): add multi-library parallel search functions Add functions to search for multiple library candidates in parallel: - FindFirstLibrary: Search multiple libs in parallel, return first found - FindFirstLibraryOrdered: Search in order of preference (for version priority) - FindAllLibraries: Find all available libraries from a list Useful when the exact library version is unknown, e.g.: match, _ := FindFirstLibrary("webkit2gtk-4.1", "webkit2gtk-4.0", "webkit2gtk-6.0") Also adds findLibraryPathCtx for context-aware searching used by the multi-library functions. * refactor(libpath): split into separate files and fix race condition Split libpath_linux.go into smaller, focused files: - cache_linux.go: Path cache with thread-safe init/invalidate - flatpak_linux.go: Flatpak runtime path discovery - snap_linux.go: Snap package path discovery - nix_linux.go: Nix/NixOS path discovery - libpath_linux.go: Core search functions Fixes: - Fix data race between init() and invalidate() by holding mutex during cache writes inside sync.Once.Do (CodeRabbit review) - Fix FindLibraryPathWithOptions not searching dynamic paths (Flatpak/Snap/Nix) - now uses GetAllLibPaths() (CodeRabbit review) --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/internal/libpath/cache_linux.go | 79 +++ v3/internal/libpath/flatpak_linux.go | 53 ++ v3/internal/libpath/libpath.go | 104 +++ v3/internal/libpath/libpath_linux.go | 551 ++++++++++++++++ v3/internal/libpath/libpath_linux_test.go | 769 ++++++++++++++++++++++ v3/internal/libpath/libpath_other.go | 73 ++ v3/internal/libpath/nix_linux.go | 28 + v3/internal/libpath/snap_linux.go | 42 ++ 9 files changed, 1700 insertions(+) create mode 100644 v3/internal/libpath/cache_linux.go create mode 100644 v3/internal/libpath/flatpak_linux.go create mode 100644 v3/internal/libpath/libpath.go create mode 100644 v3/internal/libpath/libpath_linux.go create mode 100644 v3/internal/libpath/libpath_linux_test.go create mode 100644 v3/internal/libpath/libpath_other.go create mode 100644 v3/internal/libpath/nix_linux.go create mode 100644 v3/internal/libpath/snap_linux.go diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 61496656d..82ca3d975 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -17,6 +17,7 @@ After processing, the content will be moved to the main changelog and this file ## Added +- Add `internal/libpath` package for finding native library paths on Linux with parallel search, caching, and support for Flatpak/Snap/Nix ## Changed diff --git a/v3/internal/libpath/cache_linux.go b/v3/internal/libpath/cache_linux.go new file mode 100644 index 000000000..5591c6833 --- /dev/null +++ b/v3/internal/libpath/cache_linux.go @@ -0,0 +1,79 @@ +//go:build linux + +package libpath + +import "sync" + +// pathCache holds cached dynamic library paths to avoid repeated +// expensive filesystem and subprocess operations. +type pathCache struct { + mu sync.RWMutex + flatpak []string + snap []string + nix []string + initOnce sync.Once + inited bool +} + +var cache pathCache + +// init populates the cache with dynamic paths from package managers. +// This is called lazily on first access. +func (c *pathCache) init() { + c.initOnce.Do(func() { + // Discover paths without holding the lock + flatpak := discoverFlatpakLibPaths() + snap := discoverSnapLibPaths() + nix := discoverNixLibPaths() + + // Hold lock only while updating the cache + c.mu.Lock() + c.flatpak = flatpak + c.snap = snap + c.nix = nix + c.inited = true + c.mu.Unlock() + }) +} + +// getFlatpak returns cached Flatpak library paths. +func (c *pathCache) getFlatpak() []string { + c.init() + c.mu.RLock() + defer c.mu.RUnlock() + return c.flatpak +} + +// getSnap returns cached Snap library paths. +func (c *pathCache) getSnap() []string { + c.init() + c.mu.RLock() + defer c.mu.RUnlock() + return c.snap +} + +// getNix returns cached Nix library paths. +func (c *pathCache) getNix() []string { + c.init() + c.mu.RLock() + defer c.mu.RUnlock() + return c.nix +} + +// invalidate clears the cache and forces re-discovery on next access. +func (c *pathCache) invalidate() { + c.mu.Lock() + defer c.mu.Unlock() + c.flatpak = nil + c.snap = nil + c.nix = nil + c.initOnce = sync.Once{} // Reset so init() runs again + c.inited = false +} + +// InvalidateCache clears the cached dynamic library paths. +// Call this if packages are installed or removed during runtime +// and you need to re-discover library paths. +func InvalidateCache() { + cache.invalidate() +} diff --git a/v3/internal/libpath/flatpak_linux.go b/v3/internal/libpath/flatpak_linux.go new file mode 100644 index 000000000..ce83c08c6 --- /dev/null +++ b/v3/internal/libpath/flatpak_linux.go @@ -0,0 +1,53 @@ +//go:build linux + +package libpath + +import ( + "os" + "os/exec" + "path/filepath" + "strings" +) + +// getFlatpakLibPaths returns cached library paths from installed Flatpak runtimes. +func getFlatpakLibPaths() []string { + return cache.getFlatpak() +} + +// discoverFlatpakLibPaths scans for Flatpak runtime library directories. +// Uses `flatpak --installations` and scans for runtime lib directories. +func discoverFlatpakLibPaths() []string { + var paths []string + + // Get system and user installation directories + installDirs := []string{ + "/var/lib/flatpak", // System default + os.ExpandEnv("$HOME/.local/share/flatpak"), // User default + } + + // Try to get actual installation path from flatpak + if out, err := exec.Command("flatpak", "--installations").Output(); err == nil { + for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") { + if line != "" { + installDirs = append(installDirs, line) + } + } + } + + // Scan for runtime lib directories + for _, installDir := range installDirs { + runtimeDir := filepath.Join(installDir, "runtime") + if _, err := os.Stat(runtimeDir); err != nil { + continue + } + + // Look for lib directories in runtimes + // Structure: runtime/////files/lib + matches, err := filepath.Glob(filepath.Join(runtimeDir, "*", "*", "*", "*", "files", "lib")) + if err == nil { + paths = append(paths, matches...) + } + } + + return paths +} diff --git a/v3/internal/libpath/libpath.go b/v3/internal/libpath/libpath.go new file mode 100644 index 000000000..4c32ce518 --- /dev/null +++ b/v3/internal/libpath/libpath.go @@ -0,0 +1,104 @@ +// Package libpath provides utilities for finding native library paths on Linux. +// +// # Overview +// +// This package helps locate shared libraries (.so files) on Linux systems, +// supporting multiple distributions and package managers. It's particularly +// useful for applications that need to link against libraries like GTK, +// WebKit2GTK, or other system libraries at runtime. +// +// # Search Strategy +// +// The package uses a multi-tier search strategy, trying each method in order +// until a library is found: +// +// 1. pkg-config: Queries the pkg-config database for library paths +// 2. ldconfig: Searches the dynamic linker cache +// 3. Filesystem: Scans common library directories +// +// # Supported Distributions +// +// The package includes default search paths for: +// +// - Debian/Ubuntu (multiarch paths like /usr/lib/x86_64-linux-gnu) +// - Fedora/RHEL/CentOS (/usr/lib64, /usr/lib64/gtk-*) +// - Arch Linux (/usr/lib/webkit2gtk-*, /usr/lib/gtk-*) +// - openSUSE (/usr/lib64/gcc/x86_64-suse-linux) +// - NixOS and Nix package manager +// +// # Package Manager Support +// +// Dynamic paths are discovered from: +// +// - Flatpak: Scans runtime directories via `flatpak --installations` +// - Snap: Globs /snap/*/current/usr/lib* directories +// - Nix: Checks ~/.nix-profile/lib and /run/current-system/sw/lib +// +// # Caching +// +// Dynamic path discovery (Flatpak, Snap, Nix) is cached for performance. +// The cache is populated on first access and persists for the process lifetime. +// Use [InvalidateCache] to force re-discovery if packages are installed/removed +// during runtime. +// +// # Security +// +// The current directory (".") is never included in search paths by default, +// as this is a security risk. Use [FindLibraryPathWithOptions] with +// IncludeCurrentDir if you explicitly need this behavior (not recommended +// for production). +// +// # Performance +// +// Typical lookup times (cached): +// +// - Found via pkg-config: ~2ms (spawns external process) +// - Found via ldconfig: ~1.3ms (spawns external process) +// - Found via filesystem: ~0.1ms (uses cached paths) +// - Not found (worst case): ~20ms (searches all paths) +// +// # Example Usage +// +// // Find a library by its pkg-config name +// path, err := libpath.FindLibraryPath("webkit2gtk-4.1") +// if err != nil { +// log.Fatal("WebKit2GTK not found:", err) +// } +// fmt.Println("Found at:", path) +// +// // Find a specific .so file +// soPath, err := libpath.FindLibraryFile("libgtk-3.so") +// if err != nil { +// log.Fatal("GTK3 library file not found:", err) +// } +// fmt.Println("Library file:", soPath) +// +// // Get all library search paths +// for _, p := range libpath.GetAllLibPaths() { +// fmt.Println(p) +// } +// +// # Multi-Library Search +// +// When you don't know which version of a library is installed, use the +// multi-library search functions: +// +// // Find any available WebKit2GTK version (first found wins) +// match, err := libpath.FindFirstLibrary("webkit2gtk-4.1", "webkit2gtk-4.0", "webkit2gtk-6.0") +// if err != nil { +// log.Fatal("No WebKit2GTK found") +// } +// fmt.Printf("Found %s at %s\n", match.Name, match.Path) +// +// // Prefer newer versions (ordered search) +// match, err := libpath.FindFirstLibraryOrdered("gtk4", "gtk+-3.0") +// +// // Discover all available versions +// matches := libpath.FindAllLibraries("gtk+-3.0", "gtk4", "webkit2gtk-4.0", "webkit2gtk-4.1") +// for _, m := range matches { +// fmt.Printf("Available: %s at %s\n", m.Name, m.Path) +// } +// +// On non-Linux platforms, stub implementations are provided that always +// return [LibraryNotFoundError]. +package libpath diff --git a/v3/internal/libpath/libpath_linux.go b/v3/internal/libpath/libpath_linux.go new file mode 100644 index 000000000..9b908d405 --- /dev/null +++ b/v3/internal/libpath/libpath_linux.go @@ -0,0 +1,551 @@ +//go:build linux + +package libpath + +import ( + "context" + "os" + "os/exec" + "path/filepath" + "strings" + "sync" +) + +// Common library search paths on Linux systems +var defaultLibPaths = []string{ + // Standard paths + "/usr/lib", + "/usr/lib64", + "/lib", + "/lib64", + + // Debian/Ubuntu multiarch + "/usr/lib/x86_64-linux-gnu", + "/usr/lib/aarch64-linux-gnu", + "/usr/lib/i386-linux-gnu", + "/usr/lib/arm-linux-gnueabihf", + "/lib/x86_64-linux-gnu", + "/lib/aarch64-linux-gnu", + + // Fedora/RHEL/CentOS + "/usr/lib64/gtk-3.0", + "/usr/lib64/gtk-4.0", + "/usr/lib/gcc/x86_64-redhat-linux", + "/usr/lib/gcc/aarch64-redhat-linux", + + // Arch Linux + "/usr/lib/webkit2gtk-4.0", + "/usr/lib/webkit2gtk-4.1", + "/usr/lib/gtk-3.0", + "/usr/lib/gtk-4.0", + + // openSUSE + "/usr/lib64/gcc/x86_64-suse-linux", + + // Local installations + "/usr/local/lib", + "/usr/local/lib64", +} + +// searchResult holds the result from a parallel search goroutine. +type searchResult struct { + path string + source string // for debugging: "pkg-config", "ldconfig", "filesystem" +} + +// FindLibraryPath attempts to find the path to a library using multiple methods +// in parallel. It searches via pkg-config, ldconfig, and filesystem simultaneously, +// returning as soon as any method finds the library. +// +// The libName should be the pkg-config name (e.g., "gtk+-3.0", "webkit2gtk-4.1"). +// Returns the library directory path and any error encountered. +func FindLibraryPath(libName string) (string, error) { + return findLibraryPathCtx(context.Background(), libName) +} + +// FindLibraryPathSequential is the original sequential implementation. +// Use this if you need deterministic search order (pkg-config → ldconfig → filesystem). +func FindLibraryPathSequential(libName string) (string, error) { + // Try pkg-config first (most reliable when available) + if path, err := findWithPkgConfig(libName); err == nil { + return path, nil + } + + // Try ldconfig cache + if path, err := findWithLdconfig(libName); err == nil { + return path, nil + } + + // Fall back to searching common paths + return findInCommonPaths(libName) +} + +// FindLibraryFile finds the full path to a specific library file (e.g., "libgtk-3.so"). +func FindLibraryFile(fileName string) (string, error) { + // Try ldconfig first + if path, err := findFileWithLdconfig(fileName); err == nil { + return path, nil + } + + // Search all paths including dynamic ones + for _, dir := range GetAllLibPaths() { + // Check exact match + fullPath := filepath.Join(dir, fileName) + if _, err := os.Stat(fullPath); err == nil { + return fullPath, nil + } + + // Check with .so suffix variations + matches, err := filepath.Glob(filepath.Join(dir, fileName+"*")) + if err == nil && len(matches) > 0 { + return matches[0], nil + } + } + + return "", &LibraryNotFoundError{Name: fileName} +} + +// findWithPkgConfig uses pkg-config to find library paths. +func findWithPkgConfig(libName string) (string, error) { + return findWithPkgConfigCtx(context.Background(), libName) +} + +// findWithPkgConfigCtx uses pkg-config to find library paths with context support. +func findWithPkgConfigCtx(ctx context.Context, libName string) (string, error) { + // Check if already cancelled + select { + case <-ctx.Done(): + return "", ctx.Err() + default: + } + + cmd := exec.CommandContext(ctx, "pkg-config", "--libs-only-L", libName) + output, err := cmd.Output() + if err != nil { + return "", err + } + + // Parse -L flags from output + parts := strings.Fields(string(output)) + for _, part := range parts { + if strings.HasPrefix(part, "-L") { + path := strings.TrimPrefix(part, "-L") + if _, err := os.Stat(path); err == nil { + return path, nil + } + } + } + + // Check context before second command + select { + case <-ctx.Done(): + return "", ctx.Err() + default: + } + + // If no -L flag, try --variable=libdir + cmd = exec.CommandContext(ctx, "pkg-config", "--variable=libdir", libName) + output, err = cmd.Output() + if err != nil { + return "", err + } + + path := strings.TrimSpace(string(output)) + if path != "" { + if _, err := os.Stat(path); err == nil { + return path, nil + } + } + + return "", &LibraryNotFoundError{Name: libName} +} + +// findWithLdconfig searches the ldconfig cache for library paths. +func findWithLdconfig(libName string) (string, error) { + return findWithLdconfigCtx(context.Background(), libName) +} + +// findWithLdconfigCtx searches the ldconfig cache for library paths with context support. +func findWithLdconfigCtx(ctx context.Context, libName string) (string, error) { + // Check if already cancelled + select { + case <-ctx.Done(): + return "", ctx.Err() + default: + } + + // Convert pkg-config name to library name pattern + // e.g., "gtk+-3.0" -> "libgtk-3", "webkit2gtk-4.1" -> "libwebkit2gtk-4.1" + searchName := pkgConfigToLibName(libName) + + cmd := exec.CommandContext(ctx, "ldconfig", "-p") + output, err := cmd.Output() + if err != nil { + return "", err + } + + for _, line := range strings.Split(string(output), "\n") { + if strings.Contains(line, searchName) { + // Line format: " libname.so.X (libc6,x86-64) => /path/to/lib" + parts := strings.Split(line, "=>") + if len(parts) == 2 { + libPath := strings.TrimSpace(parts[1]) + return filepath.Dir(libPath), nil + } + } + } + + return "", &LibraryNotFoundError{Name: libName} +} + +// findFileWithLdconfig finds a specific library file using ldconfig. +func findFileWithLdconfig(fileName string) (string, error) { + cmd := exec.Command("ldconfig", "-p") + output, err := cmd.Output() + if err != nil { + return "", err + } + + baseName := strings.TrimSuffix(fileName, ".so") + for _, line := range strings.Split(string(output), "\n") { + if strings.Contains(line, baseName) { + parts := strings.Split(line, "=>") + if len(parts) == 2 { + return strings.TrimSpace(parts[1]), nil + } + } + } + + return "", &LibraryNotFoundError{Name: fileName} +} + +// findInCommonPaths searches common library directories including +// dynamically discovered Flatpak, Snap, and Nix paths. +func findInCommonPaths(libName string) (string, error) { + return findInCommonPathsCtx(context.Background(), libName) +} + +// findInCommonPathsCtx searches common library directories with context support. +func findInCommonPathsCtx(ctx context.Context, libName string) (string, error) { + searchName := pkgConfigToLibName(libName) + + // Search all paths including dynamic ones + allPaths := GetAllLibPaths() + + for _, dir := range allPaths { + // Check if cancelled periodically + select { + case <-ctx.Done(): + return "", ctx.Err() + default: + } + + if _, err := os.Stat(dir); err != nil { + continue + } + + // Look for the library file + pattern := filepath.Join(dir, searchName+"*.so*") + matches, err := filepath.Glob(pattern) + if err == nil && len(matches) > 0 { + return dir, nil + } + + // Also check pkgconfig subdirectory for .pc files + pcPath := filepath.Join(dir, "pkgconfig", libName+".pc") + if _, err := os.Stat(pcPath); err == nil { + return dir, nil + } + } + + return "", &LibraryNotFoundError{Name: libName} +} + +// pkgConfigToLibName converts a pkg-config package name to a library name pattern. +func pkgConfigToLibName(pkgName string) string { + // Common transformations + name := pkgName + + // Remove version suffix like "-3.0", "-4.1" + // but keep it for webkit2gtk-4.1 style names + if strings.HasPrefix(name, "gtk+-") { + // gtk+-3.0 -> libgtk-3 + name = "libgtk-" + strings.TrimPrefix(name, "gtk+-") + name = strings.Split(name, ".")[0] + } else if strings.HasPrefix(name, "webkit2gtk-") { + // webkit2gtk-4.1 -> libwebkit2gtk-4.1 + name = "lib" + name + } else if !strings.HasPrefix(name, "lib") { + name = "lib" + name + } + + return name +} + +// GetAllLibPaths returns all library paths from LD_LIBRARY_PATH, default paths, +// and dynamically discovered paths from Flatpak, Snap, and Nix. +// It does NOT include the current directory for security reasons. +func GetAllLibPaths() []string { + var paths []string + + // Add LD_LIBRARY_PATH entries first (highest priority) + if ldPath := os.Getenv("LD_LIBRARY_PATH"); ldPath != "" { + for _, p := range strings.Split(ldPath, ":") { + if p != "" { + paths = append(paths, p) + } + } + } + + // Add default system paths + paths = append(paths, defaultLibPaths...) + + // Add dynamically discovered paths from package managers + paths = append(paths, getFlatpakLibPaths()...) + paths = append(paths, getSnapLibPaths()...) + paths = append(paths, getNixLibPaths()...) + + return paths +} + +// FindOptions controls library search behavior. +type FindOptions struct { + // IncludeCurrentDir includes "." in the search path. + // WARNING: This is a security risk and should only be used for development. + IncludeCurrentDir bool + + // ExtraPaths are additional paths to search before the defaults. + ExtraPaths []string +} + +// FindLibraryPathWithOptions attempts to find the path to a library with custom options. +func FindLibraryPathWithOptions(libName string, opts FindOptions) (string, error) { + // Try pkg-config first (most reliable when available) + if path, err := findWithPkgConfig(libName); err == nil { + return path, nil + } + + // Try ldconfig cache + if path, err := findWithLdconfig(libName); err == nil { + return path, nil + } + + // Build search paths - include all dynamic paths too + allPaths := GetAllLibPaths() + searchPaths := make([]string, 0, len(opts.ExtraPaths)+len(allPaths)+1) + + if opts.IncludeCurrentDir { + if cwd, err := os.Getwd(); err == nil { + searchPaths = append(searchPaths, cwd) + } + } + + searchPaths = append(searchPaths, opts.ExtraPaths...) + searchPaths = append(searchPaths, allPaths...) + + // Search the paths + searchName := pkgConfigToLibName(libName) + for _, dir := range searchPaths { + if _, err := os.Stat(dir); err != nil { + continue + } + + pattern := filepath.Join(dir, searchName+"*.so*") + matches, err := filepath.Glob(pattern) + if err == nil && len(matches) > 0 { + return dir, nil + } + + pcPath := filepath.Join(dir, "pkgconfig", libName+".pc") + if _, err := os.Stat(pcPath); err == nil { + return dir, nil + } + } + + return "", &LibraryNotFoundError{Name: libName} +} + +// LibraryNotFoundError is returned when a library cannot be found. +type LibraryNotFoundError struct { + Name string +} + +func (e *LibraryNotFoundError) Error() string { + return "library not found: " + e.Name +} + +// LibraryMatch holds information about a found library. +type LibraryMatch struct { + // Name is the pkg-config name that was searched for. + Name string + // Path is the directory containing the library. + Path string +} + +// FindFirstLibrary searches for multiple libraries in parallel and returns +// the first one found. This is useful when you don't know the exact version +// of a library installed (e.g., gtk+-3.0 vs gtk+-4.0). +// +// The search order among candidates is non-deterministic - whichever is found +// first wins. If you need a specific preference order, list preferred libraries +// first and use FindFirstLibraryOrdered instead. +// +// Example: +// +// match, err := FindFirstLibrary("webkit2gtk-4.1", "webkit2gtk-4.0", "webkit2gtk-6.0") +// if err != nil { +// log.Fatal("No WebKit2GTK found") +// } +// fmt.Printf("Found %s at %s\n", match.Name, match.Path) +func FindFirstLibrary(libNames ...string) (*LibraryMatch, error) { + if len(libNames) == 0 { + return nil, &LibraryNotFoundError{Name: "no libraries specified"} + } + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + results := make(chan *LibraryMatch, len(libNames)) + var wg sync.WaitGroup + + for _, name := range libNames { + wg.Add(1) + go func(libName string) { + defer wg.Done() + if path, err := findLibraryPathCtx(ctx, libName); err == nil { + select { + case results <- &LibraryMatch{Name: libName, Path: path}: + case <-ctx.Done(): + } + } + }(name) + } + + // Close results when all goroutines complete + go func() { + wg.Wait() + close(results) + }() + + if result := <-results; result != nil { + return result, nil + } + + return nil, &LibraryNotFoundError{Name: strings.Join(libNames, ", ")} +} + +// FindFirstLibraryOrdered searches for libraries in order of preference, +// returning the first one found. Unlike FindFirstLibrary, this respects +// the order of candidates - earlier entries are preferred. +// +// This is useful when you want to prefer newer library versions: +// +// match, err := FindFirstLibraryOrdered("gtk+-4.0", "gtk+-3.0") +// // Will return gtk+-4.0 if available, otherwise gtk+-3.0 +func FindFirstLibraryOrdered(libNames ...string) (*LibraryMatch, error) { + if len(libNames) == 0 { + return nil, &LibraryNotFoundError{Name: "no libraries specified"} + } + + for _, name := range libNames { + if path, err := FindLibraryPath(name); err == nil { + return &LibraryMatch{Name: name, Path: path}, nil + } + } + + return nil, &LibraryNotFoundError{Name: strings.Join(libNames, ", ")} +} + +// FindAllLibraries searches for multiple libraries in parallel and returns +// all that are found. This is useful for discovering which library versions +// are available on the system. +// +// Example: +// +// matches := FindAllLibraries("gtk+-3.0", "gtk+-4.0", "webkit2gtk-4.0", "webkit2gtk-4.1") +// for _, m := range matches { +// fmt.Printf("Found %s at %s\n", m.Name, m.Path) +// } +func FindAllLibraries(libNames ...string) []LibraryMatch { + if len(libNames) == 0 { + return nil + } + + results := make(chan *LibraryMatch, len(libNames)) + var wg sync.WaitGroup + + for _, name := range libNames { + wg.Add(1) + go func(libName string) { + defer wg.Done() + if path, err := FindLibraryPath(libName); err == nil { + results <- &LibraryMatch{Name: libName, Path: path} + } + }(name) + } + + // Close results when all goroutines complete + go func() { + wg.Wait() + close(results) + }() + + var matches []LibraryMatch + for result := range results { + matches = append(matches, *result) + } + + return matches +} + +// findLibraryPathCtx is FindLibraryPath with context support. +func findLibraryPathCtx(ctx context.Context, libName string) (string, error) { + // Create a child context for this search + ctx, cancel := context.WithCancel(ctx) + defer cancel() + + results := make(chan searchResult, 3) + var wg sync.WaitGroup + wg.Add(3) + + go func() { + defer wg.Done() + if path, err := findWithPkgConfigCtx(ctx, libName); err == nil { + select { + case results <- searchResult{path: path, source: "pkg-config"}: + case <-ctx.Done(): + } + } + }() + + go func() { + defer wg.Done() + if path, err := findWithLdconfigCtx(ctx, libName); err == nil { + select { + case results <- searchResult{path: path, source: "ldconfig"}: + case <-ctx.Done(): + } + } + }() + + go func() { + defer wg.Done() + if path, err := findInCommonPathsCtx(ctx, libName); err == nil { + select { + case results <- searchResult{path: path, source: "filesystem"}: + case <-ctx.Done(): + } + } + }() + + go func() { + wg.Wait() + close(results) + }() + + if result, ok := <-results; ok { + return result.path, nil + } + + return "", &LibraryNotFoundError{Name: libName} +} diff --git a/v3/internal/libpath/libpath_linux_test.go b/v3/internal/libpath/libpath_linux_test.go new file mode 100644 index 000000000..0f2e91bef --- /dev/null +++ b/v3/internal/libpath/libpath_linux_test.go @@ -0,0 +1,769 @@ +//go:build linux + +package libpath + +import ( + "os" + "os/exec" + "path/filepath" + "strings" + "testing" +) + +func TestPkgConfigToLibName(t *testing.T) { + tests := []struct { + input string + expected string + }{ + {"gtk+-3.0", "libgtk-3"}, + {"gtk+-4.0", "libgtk-4"}, + {"webkit2gtk-4.1", "libwebkit2gtk-4.1"}, + {"webkit2gtk-4.0", "libwebkit2gtk-4.0"}, + {"glib-2.0", "libglib-2.0"}, + {"libsoup-3.0", "libsoup-3.0"}, + {"cairo", "libcairo"}, + } + + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + result := pkgConfigToLibName(tt.input) + if result != tt.expected { + t.Errorf("pkgConfigToLibName(%q) = %q, want %q", tt.input, result, tt.expected) + } + }) + } +} + +func TestGetAllLibPaths(t *testing.T) { + paths := GetAllLibPaths() + + if len(paths) == 0 { + t.Error("GetAllLibPaths() returned empty slice") + } + + // Check that default paths are included + hasUsrLib := false + for _, p := range paths { + if p == "/usr/lib" || p == "/usr/lib64" { + hasUsrLib = true + break + } + } + if !hasUsrLib { + t.Error("GetAllLibPaths() should include /usr/lib or /usr/lib64") + } +} + +func TestGetAllLibPaths_WithLDPath(t *testing.T) { + // Save and restore LD_LIBRARY_PATH + original := os.Getenv("LD_LIBRARY_PATH") + defer os.Setenv("LD_LIBRARY_PATH", original) + + testPath := "/test/custom/lib:/another/path" + os.Setenv("LD_LIBRARY_PATH", testPath) + + paths := GetAllLibPaths() + + // First paths should be from LD_LIBRARY_PATH + if len(paths) < 2 { + t.Fatal("Expected at least 2 paths") + } + if paths[0] != "/test/custom/lib" { + t.Errorf("First path should be /test/custom/lib, got %s", paths[0]) + } + if paths[1] != "/another/path" { + t.Errorf("Second path should be /another/path, got %s", paths[1]) + } +} + +func TestLibraryNotFoundError(t *testing.T) { + err := &LibraryNotFoundError{Name: "testlib"} + expected := "library not found: testlib" + if err.Error() != expected { + t.Errorf("Error() = %q, want %q", err.Error(), expected) + } +} + +func TestFindLibraryPath_NotFound(t *testing.T) { + _, err := FindLibraryPath("nonexistent-library-xyz-123") + if err == nil { + t.Error("Expected error for nonexistent library") + } + + var notFoundErr *LibraryNotFoundError + if _, ok := err.(*LibraryNotFoundError); !ok { + t.Errorf("Expected LibraryNotFoundError, got %T", err) + } else { + notFoundErr = err.(*LibraryNotFoundError) + if notFoundErr.Name != "nonexistent-library-xyz-123" { + t.Errorf("Error name = %q, want %q", notFoundErr.Name, "nonexistent-library-xyz-123") + } + } +} + +func TestFindLibraryFile_NotFound(t *testing.T) { + _, err := FindLibraryFile("libnonexistent-xyz-123.so") + if err == nil { + t.Error("Expected error for nonexistent library file") + } +} + +// Integration tests - these depend on system state +// They're skipped if the required tools/libraries aren't available + +func TestFindLibraryPath_WithPkgConfig(t *testing.T) { + // Skip if pkg-config is not available + if _, err := exec.LookPath("pkg-config"); err != nil { + t.Skip("pkg-config not available") + } + + // Try to find a common library that's likely installed + commonLibs := []string{"glib-2.0", "zlib"} + + for _, lib := range commonLibs { + // Check if pkg-config knows about this library + cmd := exec.Command("pkg-config", "--exists", lib) + if cmd.Run() != nil { + continue + } + + t.Run(lib, func(t *testing.T) { + path, err := FindLibraryPath(lib) + if err != nil { + t.Errorf("FindLibraryPath(%q) failed: %v", lib, err) + return + } + + // Verify the path exists + if _, err := os.Stat(path); err != nil { + t.Errorf("Returned path %q does not exist", path) + } + }) + return // Only need to test one + } + + t.Skip("No common libraries found via pkg-config") +} + +func TestFindLibraryFile_Integration(t *testing.T) { + // Try to find libc which should exist on any Linux system + libcNames := []string{"libc.so.6", "libc.so"} + + for _, name := range libcNames { + path, err := FindLibraryFile(name) + if err == nil { + // Verify the path exists + if _, err := os.Stat(path); err != nil { + t.Errorf("Returned path %q does not exist", path) + } + return + } + } + + t.Skip("Could not find libc.so - unusual system configuration") +} + +func TestFindInCommonPaths(t *testing.T) { + // Create a temporary directory structure for testing + tmpDir := t.TempDir() + + // Create a fake library directory with a fake .so file + libDir := filepath.Join(tmpDir, "lib") + if err := os.MkdirAll(libDir, 0755); err != nil { + t.Fatal(err) + } + + // Create a fake library file + fakeLib := filepath.Join(libDir, "libfaketest.so.1") + if err := os.WriteFile(fakeLib, []byte{}, 0644); err != nil { + t.Fatal(err) + } + + // Temporarily add our test dir to defaultLibPaths + originalPaths := defaultLibPaths + defaultLibPaths = append([]string{libDir}, defaultLibPaths...) + defer func() { defaultLibPaths = originalPaths }() + + // Now test finding it + path, err := findInCommonPaths("faketest") + if err != nil { + t.Errorf("findInCommonPaths(\"faketest\") failed: %v", err) + return + } + + if path != libDir { + t.Errorf("findInCommonPaths(\"faketest\") = %q, want %q", path, libDir) + } +} + +func TestFindWithLdconfig(t *testing.T) { + // Skip if ldconfig is not available + if _, err := exec.LookPath("ldconfig"); err != nil { + t.Skip("ldconfig not available") + } + + // Check if we can run ldconfig -p + cmd := exec.Command("ldconfig", "-p") + output, err := cmd.Output() + if err != nil { + t.Skip("ldconfig -p failed") + } + + // Find any library from the output to test with + lines := strings.Split(string(output), "\n") + for _, line := range lines { + if strings.Contains(line, "=>") && strings.Contains(line, "libc.so") { + // We found libc, try to find it + path, err := findWithLdconfig("glib-2.0") // Common library + if err == nil { + if _, statErr := os.Stat(path); statErr != nil { + t.Errorf("Returned path %q does not exist", path) + } + return + } + // If glib not found, that's okay - just means it's not installed + break + } + } +} + +func TestFindLibraryPathWithOptions_IncludeCurrentDir(t *testing.T) { + // Create a temporary directory and change to it + tmpDir := t.TempDir() + + // Create a fake library file in the temp dir + fakeLib := filepath.Join(tmpDir, "libcwdtest.so.1") + if err := os.WriteFile(fakeLib, []byte{}, 0644); err != nil { + t.Fatal(err) + } + + // Save current directory + origDir, err := os.Getwd() + if err != nil { + t.Fatal(err) + } + defer os.Chdir(origDir) + + // Change to temp directory + if err := os.Chdir(tmpDir); err != nil { + t.Fatal(err) + } + + // Without IncludeCurrentDir, should not find it + _, err = FindLibraryPathWithOptions("cwdtest", FindOptions{IncludeCurrentDir: false}) + if err == nil { + t.Error("Expected error without IncludeCurrentDir") + } + + // With IncludeCurrentDir, should find it + path, err := FindLibraryPathWithOptions("cwdtest", FindOptions{IncludeCurrentDir: true}) + if err != nil { + t.Errorf("FindLibraryPathWithOptions with IncludeCurrentDir failed: %v", err) + return + } + + if path != tmpDir { + t.Errorf("Expected path %q, got %q", tmpDir, path) + } +} + +func TestFindLibraryPathWithOptions_ExtraPaths(t *testing.T) { + // Create a temporary directory with a fake library + tmpDir := t.TempDir() + + fakeLib := filepath.Join(tmpDir, "libextratest.so.1") + if err := os.WriteFile(fakeLib, []byte{}, 0644); err != nil { + t.Fatal(err) + } + + // Should find it with ExtraPaths + path, err := FindLibraryPathWithOptions("extratest", FindOptions{ + ExtraPaths: []string{tmpDir}, + }) + if err != nil { + t.Errorf("FindLibraryPathWithOptions with ExtraPaths failed: %v", err) + return + } + + if path != tmpDir { + t.Errorf("Expected path %q, got %q", tmpDir, path) + } +} + +func TestDefaultLibPaths_ContainsDistros(t *testing.T) { + // Verify that paths for various distros are included + expectedPaths := map[string][]string{ + "Debian/Ubuntu": {"/usr/lib/x86_64-linux-gnu", "/usr/lib/aarch64-linux-gnu"}, + "Fedora/RHEL": {"/usr/lib64/gtk-3.0", "/usr/lib64/gtk-4.0"}, + "Arch": {"/usr/lib/webkit2gtk-4.0", "/usr/lib/webkit2gtk-4.1"}, + "openSUSE": {"/usr/lib64/gcc/x86_64-suse-linux"}, + "Local": {"/usr/local/lib", "/usr/local/lib64"}, + } + + for distro, paths := range expectedPaths { + for _, path := range paths { + found := false + for _, defaultPath := range defaultLibPaths { + if defaultPath == path { + found = true + break + } + } + if !found { + t.Errorf("Missing %s path: %s", distro, path) + } + } + } +} + +func TestGetFlatpakLibPaths(t *testing.T) { + // This test just ensures the function doesn't panic + // Actual paths depend on system state + paths := getFlatpakLibPaths() + t.Logf("Found %d Flatpak lib paths", len(paths)) + for _, p := range paths { + t.Logf(" %s", p) + } +} + +func TestGetSnapLibPaths(t *testing.T) { + // This test just ensures the function doesn't panic + // Actual paths depend on system state + paths := getSnapLibPaths() + t.Logf("Found %d Snap lib paths", len(paths)) + for _, p := range paths { + t.Logf(" %s", p) + } +} + +func TestGetNixLibPaths(t *testing.T) { + // This test just ensures the function doesn't panic + paths := getNixLibPaths() + t.Logf("Found %d Nix lib paths", len(paths)) + for _, p := range paths { + t.Logf(" %s", p) + } +} + +func TestGetAllLibPaths_IncludesDynamicPaths(t *testing.T) { + paths := GetAllLibPaths() + + // Should have at least the default paths + if len(paths) < len(defaultLibPaths) { + t.Errorf("GetAllLibPaths returned fewer paths (%d) than defaultLibPaths (%d)", + len(paths), len(defaultLibPaths)) + } + + // Log all paths for debugging + t.Logf("Total paths: %d", len(paths)) +} + +func TestGetAllLibPaths_DoesNotIncludeCurrentDir(t *testing.T) { + paths := GetAllLibPaths() + + for _, p := range paths { + if p == "." { + t.Error("GetAllLibPaths should not include '.' for security reasons") + } + } +} + +func TestInvalidateCache(t *testing.T) { + // First call populates cache + paths1 := GetAllLibPaths() + + // Invalidate and call again + InvalidateCache() + paths2 := GetAllLibPaths() + + // Should get same results (assuming no system changes) + if len(paths1) != len(paths2) { + t.Logf("Path counts differ after invalidation: %d vs %d", len(paths1), len(paths2)) + // This is not necessarily an error, just informational + } + + // Verify cache is working by checking getFlatpakLibPaths is fast + // (would be slow if cache wasn't working) + for i := 0; i < 100; i++ { + _ = getFlatpakLibPaths() + } +} + +func TestFindLibraryPath_ParallelConsistency(t *testing.T) { + // Skip if pkg-config is not available + if _, err := exec.LookPath("pkg-config"); err != nil { + t.Skip("pkg-config not available") + } + + // Check if glib-2.0 is available + cmd := exec.Command("pkg-config", "--exists", "glib-2.0") + if cmd.Run() != nil { + t.Skip("glib-2.0 not installed") + } + + // Run parallel and sequential versions multiple times + // to ensure they return consistent results + for i := 0; i < 10; i++ { + parallelPath, parallelErr := FindLibraryPath("glib-2.0") + seqPath, seqErr := FindLibraryPathSequential("glib-2.0") + + if parallelErr != nil && seqErr == nil { + t.Errorf("Parallel failed but sequential succeeded: %v", parallelErr) + } + if parallelErr == nil && seqErr != nil { + t.Errorf("Sequential failed but parallel succeeded: %v", seqErr) + } + + // Both should find the library (path might differ if found by different methods) + if parallelErr != nil { + t.Errorf("Iteration %d: parallel search failed: %v", i, parallelErr) + } + if seqErr != nil { + t.Errorf("Iteration %d: sequential search failed: %v", i, seqErr) + } + + // Log paths for debugging + t.Logf("Iteration %d: parallel=%s, sequential=%s", i, parallelPath, seqPath) + } +} + +func TestFindLibraryPath_ParallelNotFound(t *testing.T) { + // Both parallel and sequential should return the same error for non-existent libs + _, parallelErr := FindLibraryPath("nonexistent-library-xyz-123") + _, seqErr := FindLibraryPathSequential("nonexistent-library-xyz-123") + + if parallelErr == nil { + t.Error("Parallel search should fail for nonexistent library") + } + if seqErr == nil { + t.Error("Sequential search should fail for nonexistent library") + } + + // Both should return LibraryNotFoundError + if _, ok := parallelErr.(*LibraryNotFoundError); !ok { + t.Errorf("Parallel: expected LibraryNotFoundError, got %T", parallelErr) + } + if _, ok := seqErr.(*LibraryNotFoundError); !ok { + t.Errorf("Sequential: expected LibraryNotFoundError, got %T", seqErr) + } +} + +// Benchmarks + +// BenchmarkFindLibraryPath benchmarks finding a library via the full search chain. +func BenchmarkFindLibraryPath(b *testing.B) { + // Test with glib-2.0 which is commonly installed + if _, err := exec.LookPath("pkg-config"); err != nil { + b.Skip("pkg-config not available") + } + cmd := exec.Command("pkg-config", "--exists", "glib-2.0") + if cmd.Run() != nil { + b.Skip("glib-2.0 not installed") + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindLibraryPath("glib-2.0") + } +} + +// BenchmarkFindLibraryPath_NotFound benchmarks the worst case (library not found). +func BenchmarkFindLibraryPath_NotFound(b *testing.B) { + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindLibraryPath("nonexistent-library-xyz-123") + } +} + +// BenchmarkFindLibraryFile benchmarks finding a specific library file. +func BenchmarkFindLibraryFile(b *testing.B) { + // libc.so.6 should exist on any Linux system + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindLibraryFile("libc.so.6") + } +} + +// BenchmarkGetAllLibPaths benchmarks collecting all library paths. +func BenchmarkGetAllLibPaths(b *testing.B) { + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = GetAllLibPaths() + } +} + +// BenchmarkFindWithPkgConfig benchmarks pkg-config lookup directly. +func BenchmarkFindWithPkgConfig(b *testing.B) { + if _, err := exec.LookPath("pkg-config"); err != nil { + b.Skip("pkg-config not available") + } + cmd := exec.Command("pkg-config", "--exists", "glib-2.0") + if cmd.Run() != nil { + b.Skip("glib-2.0 not installed") + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = findWithPkgConfig("glib-2.0") + } +} + +// BenchmarkFindWithLdconfig benchmarks ldconfig lookup directly. +func BenchmarkFindWithLdconfig(b *testing.B) { + if _, err := exec.LookPath("ldconfig"); err != nil { + b.Skip("ldconfig not available") + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = findWithLdconfig("glib-2.0") + } +} + +// BenchmarkFindInCommonPaths benchmarks filesystem scanning. +func BenchmarkFindInCommonPaths(b *testing.B) { + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = findInCommonPaths("glib-2.0") + } +} + +// BenchmarkGetFlatpakLibPaths benchmarks Flatpak path discovery. +func BenchmarkGetFlatpakLibPaths(b *testing.B) { + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = getFlatpakLibPaths() + } +} + +// BenchmarkGetSnapLibPaths benchmarks Snap path discovery. +func BenchmarkGetSnapLibPaths(b *testing.B) { + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = getSnapLibPaths() + } +} + +// BenchmarkGetNixLibPaths benchmarks Nix path discovery. +func BenchmarkGetNixLibPaths(b *testing.B) { + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = getNixLibPaths() + } +} + +// BenchmarkPkgConfigToLibName benchmarks the name conversion function. +func BenchmarkPkgConfigToLibName(b *testing.B) { + names := []string{"gtk+-3.0", "webkit2gtk-4.1", "glib-2.0", "cairo", "libsoup-3.0"} + + b.ResetTimer() + for i := 0; i < b.N; i++ { + for _, name := range names { + _ = pkgConfigToLibName(name) + } + } +} + +// BenchmarkFindLibraryPathSequential benchmarks the sequential search. +func BenchmarkFindLibraryPathSequential(b *testing.B) { + if _, err := exec.LookPath("pkg-config"); err != nil { + b.Skip("pkg-config not available") + } + cmd := exec.Command("pkg-config", "--exists", "glib-2.0") + if cmd.Run() != nil { + b.Skip("glib-2.0 not installed") + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindLibraryPathSequential("glib-2.0") + } +} + +// BenchmarkFindLibraryPathSequential_NotFound benchmarks the sequential worst case. +func BenchmarkFindLibraryPathSequential_NotFound(b *testing.B) { + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindLibraryPathSequential("nonexistent-library-xyz-123") + } +} + +// BenchmarkFindLibraryPathParallel explicitly tests parallel performance. +func BenchmarkFindLibraryPathParallel(b *testing.B) { + if _, err := exec.LookPath("pkg-config"); err != nil { + b.Skip("pkg-config not available") + } + cmd := exec.Command("pkg-config", "--exists", "glib-2.0") + if cmd.Run() != nil { + b.Skip("glib-2.0 not installed") + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindLibraryPath("glib-2.0") + } +} + +// Tests for multi-library search functions + +func TestFindFirstLibrary(t *testing.T) { + if _, err := exec.LookPath("pkg-config"); err != nil { + t.Skip("pkg-config not available") + } + + // Test with a mix of existing and non-existing libraries + match, err := FindFirstLibrary("nonexistent-xyz", "glib-2.0", "also-nonexistent") + if err != nil { + t.Skipf("glib-2.0 not installed: %v", err) + } + + if match.Name != "glib-2.0" { + t.Errorf("Expected glib-2.0, got %s", match.Name) + } + if match.Path == "" { + t.Error("Expected non-empty path") + } +} + +func TestFindFirstLibrary_AllNotFound(t *testing.T) { + _, err := FindFirstLibrary("nonexistent-1", "nonexistent-2", "nonexistent-3") + if err == nil { + t.Error("Expected error for all non-existent libraries") + } +} + +func TestFindFirstLibrary_Empty(t *testing.T) { + _, err := FindFirstLibrary() + if err == nil { + t.Error("Expected error for empty library list") + } +} + +func TestFindFirstLibraryOrdered(t *testing.T) { + if _, err := exec.LookPath("pkg-config"); err != nil { + t.Skip("pkg-config not available") + } + + // glib-2.0 should be found, and since it's first, it should be returned + match, err := FindFirstLibraryOrdered("glib-2.0", "nonexistent-xyz") + if err != nil { + t.Skipf("glib-2.0 not installed: %v", err) + } + + if match.Name != "glib-2.0" { + t.Errorf("Expected glib-2.0, got %s", match.Name) + } +} + +func TestFindFirstLibraryOrdered_PreferFirst(t *testing.T) { + if _, err := exec.LookPath("pkg-config"); err != nil { + t.Skip("pkg-config not available") + } + + // Check what GTK versions are available + gtk4Available := exec.Command("pkg-config", "--exists", "gtk4").Run() == nil + gtk3Available := exec.Command("pkg-config", "--exists", "gtk+-3.0").Run() == nil + + if !gtk4Available && !gtk3Available { + t.Skip("Neither GTK3 nor GTK4 installed") + } + + // If both available, test that order is respected + if gtk4Available && gtk3Available { + match, err := FindFirstLibraryOrdered("gtk4", "gtk+-3.0") + if err != nil { + t.Fatalf("Unexpected error: %v", err) + } + if match.Name != "gtk4" { + t.Errorf("Expected gtk4 (first in order), got %s", match.Name) + } + + // Reverse order + match, err = FindFirstLibraryOrdered("gtk+-3.0", "gtk4") + if err != nil { + t.Fatalf("Unexpected error: %v", err) + } + if match.Name != "gtk+-3.0" { + t.Errorf("Expected gtk+-3.0 (first in order), got %s", match.Name) + } + } +} + +func TestFindAllLibraries(t *testing.T) { + if _, err := exec.LookPath("pkg-config"); err != nil { + t.Skip("pkg-config not available") + } + + matches := FindAllLibraries("glib-2.0", "nonexistent-xyz", "zlib") + + // Should find at least glib-2.0 on most systems + if len(matches) == 0 { + t.Skip("No common libraries found") + } + + t.Logf("Found %d libraries:", len(matches)) + for _, m := range matches { + t.Logf(" %s at %s", m.Name, m.Path) + } + + // Verify no duplicates and no nonexistent library + seen := make(map[string]bool) + for _, m := range matches { + if m.Name == "nonexistent-xyz" { + t.Error("Should not have found nonexistent library") + } + if seen[m.Name] { + t.Errorf("Duplicate match for %s", m.Name) + } + seen[m.Name] = true + } +} + +func TestFindAllLibraries_Empty(t *testing.T) { + matches := FindAllLibraries() + if len(matches) != 0 { + t.Error("Expected empty result for empty input") + } +} + +func TestFindAllLibraries_AllNotFound(t *testing.T) { + matches := FindAllLibraries("nonexistent-1", "nonexistent-2") + if len(matches) != 0 { + t.Errorf("Expected empty result, got %d matches", len(matches)) + } +} + +// Benchmarks for multi-library search + +func BenchmarkFindFirstLibrary(b *testing.B) { + if _, err := exec.LookPath("pkg-config"); err != nil { + b.Skip("pkg-config not available") + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindFirstLibrary("nonexistent-1", "glib-2.0", "nonexistent-2") + } +} + +func BenchmarkFindFirstLibraryOrdered(b *testing.B) { + if _, err := exec.LookPath("pkg-config"); err != nil { + b.Skip("pkg-config not available") + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _ = FindFirstLibraryOrdered("nonexistent-1", "glib-2.0", "nonexistent-2") + } +} + +func BenchmarkFindAllLibraries(b *testing.B) { + if _, err := exec.LookPath("pkg-config"); err != nil { + b.Skip("pkg-config not available") + } + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = FindAllLibraries("glib-2.0", "zlib", "nonexistent-xyz") + } +} diff --git a/v3/internal/libpath/libpath_other.go b/v3/internal/libpath/libpath_other.go new file mode 100644 index 000000000..d1c7bc77d --- /dev/null +++ b/v3/internal/libpath/libpath_other.go @@ -0,0 +1,73 @@ +//go:build !linux + +package libpath + +// FindLibraryPath is a stub for non-Linux platforms. +func FindLibraryPath(libName string) (string, error) { + return "", &LibraryNotFoundError{Name: libName} +} + +// FindLibraryFile is a stub for non-Linux platforms. +func FindLibraryFile(fileName string) (string, error) { + return "", &LibraryNotFoundError{Name: fileName} +} + +// GetAllLibPaths returns an empty slice on non-Linux platforms. +func GetAllLibPaths() []string { + return nil +} + +// InvalidateCache is a no-op on non-Linux platforms. +func InvalidateCache() {} + +// FindOptions controls library search behavior. +type FindOptions struct { + IncludeCurrentDir bool + ExtraPaths []string +} + +// FindLibraryPathWithOptions is a stub for non-Linux platforms. +func FindLibraryPathWithOptions(libName string, opts FindOptions) (string, error) { + return "", &LibraryNotFoundError{Name: libName} +} + +// LibraryNotFoundError is returned when a library cannot be found. +type LibraryNotFoundError struct { + Name string +} + +func (e *LibraryNotFoundError) Error() string { + return "library not found: " + e.Name +} + +// LibraryMatch holds information about a found library. +type LibraryMatch struct { + Name string + Path string +} + +// FindFirstLibrary is a stub for non-Linux platforms. +func FindFirstLibrary(libNames ...string) (*LibraryMatch, error) { + if len(libNames) == 0 { + return nil, &LibraryNotFoundError{Name: "no libraries specified"} + } + return nil, &LibraryNotFoundError{Name: libNames[0]} +} + +// FindFirstLibraryOrdered is a stub for non-Linux platforms. +func FindFirstLibraryOrdered(libNames ...string) (*LibraryMatch, error) { + if len(libNames) == 0 { + return nil, &LibraryNotFoundError{Name: "no libraries specified"} + } + return nil, &LibraryNotFoundError{Name: libNames[0]} +} + +// FindAllLibraries is a stub for non-Linux platforms. +func FindAllLibraries(libNames ...string) []LibraryMatch { + return nil +} + +// FindLibraryPathSequential is a stub for non-Linux platforms. +func FindLibraryPathSequential(libName string) (string, error) { + return "", &LibraryNotFoundError{Name: libName} +} diff --git a/v3/internal/libpath/nix_linux.go b/v3/internal/libpath/nix_linux.go new file mode 100644 index 000000000..74d8487a9 --- /dev/null +++ b/v3/internal/libpath/nix_linux.go @@ -0,0 +1,28 @@ +//go:build linux + +package libpath + +import "os" + +// getNixLibPaths returns cached library paths for Nix/NixOS installations. +func getNixLibPaths() []string { + return cache.getNix() +} + +// discoverNixLibPaths scans for Nix library paths. +func discoverNixLibPaths() []string { + var paths []string + + nixProfileLib := os.ExpandEnv("$HOME/.nix-profile/lib") + if _, err := os.Stat(nixProfileLib); err == nil { + paths = append(paths, nixProfileLib) + } + + // System Nix store - packages expose libs through profiles + nixStoreLib := "/run/current-system/sw/lib" + if _, err := os.Stat(nixStoreLib); err == nil { + paths = append(paths, nixStoreLib) + } + + return paths +} diff --git a/v3/internal/libpath/snap_linux.go b/v3/internal/libpath/snap_linux.go new file mode 100644 index 000000000..99def76ac --- /dev/null +++ b/v3/internal/libpath/snap_linux.go @@ -0,0 +1,42 @@ +//go:build linux + +package libpath + +import ( + "os" + "path/filepath" +) + +// getSnapLibPaths returns cached library paths from installed Snap packages. +func getSnapLibPaths() []string { + return cache.getSnap() +} + +// discoverSnapLibPaths scans for Snap package library directories. +// Scans /snap/*/current/usr/lib* directories. +func discoverSnapLibPaths() []string { + var paths []string + + snapDir := "/snap" + if _, err := os.Stat(snapDir); err != nil { + return paths + } + + // Find all snap packages with lib directories + patterns := []string{ + filepath.Join(snapDir, "*", "current", "usr", "lib"), + filepath.Join(snapDir, "*", "current", "usr", "lib64"), + filepath.Join(snapDir, "*", "current", "usr", "lib", "*-linux-gnu"), + filepath.Join(snapDir, "*", "current", "lib"), + filepath.Join(snapDir, "*", "current", "lib", "*-linux-gnu"), + } + + for _, pattern := range patterns { + matches, err := filepath.Glob(pattern) + if err == nil { + paths = append(paths, matches...) + } + } + + return paths +} From d0aa2a6e1fd448bd9b20b926b233f89c24330cdb Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Sun, 4 Jan 2026 13:35:28 +1100 Subject: [PATCH 21/40] fix(docs): escape MDX special characters in changelog and linux guide (#4849) - Wrap `<=8` in backticks in changelog.mdx to prevent MDX interpreting `<` as JSX element start - Remove unsupported {#custom-id} syntax from heading in linux.mdx as Starlight/Astro auto-generates heading IDs This fixes the docs build failure in the Deploy to GitHub Pages workflow. --- docs/src/content/docs/changelog.mdx | 2 +- docs/src/content/docs/guides/build/linux.mdx | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index 15463dde6..255dde1b7 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -35,7 +35,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## Changed - Switch to goccy/go-json for all runtime JSON processing (method bindings, events, webview requests, notifications, kvstore), improving performance by 21-63% and reducing memory allocations by 40-60% - Optimize BoundMethod struct layout and cache isVariadic flag to reduce per-call overhead -- Use stack-allocated argument buffer for methods with <=8 arguments to avoid heap allocations +- Use stack-allocated argument buffer for methods with `<=8` arguments to avoid heap allocations - Optimize result collection in method calls to avoid slice allocation for single return values - Use sync.Map for MIME type cache to improve concurrent performance - Use buffer pool for HTTP transport request body reading diff --git a/docs/src/content/docs/guides/build/linux.mdx b/docs/src/content/docs/guides/build/linux.mdx index 773db73cf..18666c2aa 100644 --- a/docs/src/content/docs/guides/build/linux.mdx +++ b/docs/src/content/docs/guides/build/linux.mdx @@ -146,7 +146,7 @@ sudo pacman -S base-devel Alternatively, run `wails3 task setup:docker` and the build system will use Docker automatically. -### AppImage strip compatibility {#appimage-strip-compatibility} +### AppImage strip compatibility On modern Linux distributions (Arch Linux, Fedora 39+, Ubuntu 24.04+), system libraries are compiled with `.relr.dyn` ELF sections for more efficient relocations. The `linuxdeploy` tool used to create AppImages bundles an older `strip` binary that cannot process these modern sections. From a1dd1f4d195894e1931d244f5a5b78dfc013e804 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 4 Jan 2026 02:54:09 +0000 Subject: [PATCH 22/40] chore(v3): bump to v3.0.0-alpha.56 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 24 ++++++++++++++++++++++++ v3/UNRELEASED_CHANGELOG.md | 14 -------------- v3/internal/version/version.txt | 2 +- 3 files changed, 25 insertions(+), 15 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index 255dde1b7..34ee2368d 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.56 - 2026-01-04 + +## Added +- Add `internal/libpath` package for finding native library paths on Linux with parallel search, caching, and support for Flatpak/Snap/Nix + +## Changed +- **BREAKING:** Rename `EnableDragAndDrop` to `EnableFileDrop` in window options +- **BREAKING:** Rename `DropZoneDetails` to `DropTargetDetails` in event context +- **BREAKING:** Rename `DropZoneDetails()` method to `DropTargetDetails()` on `WindowEventContext` +- **BREAKING:** Remove `WindowDropZoneFilesDropped` event, use `WindowFilesDropped` instead +- **BREAKING:** Change HTML attribute from `data-wails-dropzone` to `data-file-drop-target` +- **BREAKING:** Change CSS hover class from `wails-dropzone-hover` to `file-drop-target-active` +- **BREAKING:** Remove `DragEffect`, `OnEnterEffect`, `OnOverEffect` options from Windows (were part of removed IDropTarget) + +## Fixed +- Fix file drag-and-drop on Windows not working at non-100% display scaling +- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Windows +- Fix file drop coordinates being in wrong pixel space on Windows (physical vs CSS pixels) +- Fix file drag-and-drop on Linux not working reliably with hover effects +- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Linux + +## Removed +- Remove native `IDropTarget` implementation on Windows in favor of JavaScript-based approach (matches v2 behavior) + ## v3.0.0-alpha.55 - 2026-01-02 ## Changed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 82ca3d975..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -17,32 +17,18 @@ After processing, the content will be moved to the main changelog and this file ## Added -- Add `internal/libpath` package for finding native library paths on Linux with parallel search, caching, and support for Flatpak/Snap/Nix ## Changed -- **BREAKING:** Rename `EnableDragAndDrop` to `EnableFileDrop` in window options -- **BREAKING:** Rename `DropZoneDetails` to `DropTargetDetails` in event context -- **BREAKING:** Rename `DropZoneDetails()` method to `DropTargetDetails()` on `WindowEventContext` -- **BREAKING:** Remove `WindowDropZoneFilesDropped` event, use `WindowFilesDropped` instead -- **BREAKING:** Change HTML attribute from `data-wails-dropzone` to `data-file-drop-target` -- **BREAKING:** Change CSS hover class from `wails-dropzone-hover` to `file-drop-target-active` -- **BREAKING:** Remove `DragEffect`, `OnEnterEffect`, `OnOverEffect` options from Windows (were part of removed IDropTarget) ## Fixed -- Fix file drag-and-drop on Windows not working at non-100% display scaling -- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Windows -- Fix file drop coordinates being in wrong pixel space on Windows (physical vs CSS pixels) -- Fix file drag-and-drop on Linux not working reliably with hover effects -- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Linux ## Deprecated ## Removed -- Remove native `IDropTarget` implementation on Windows in favor of JavaScript-based approach (matches v2 behavior) ## Security diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 8b6038c41..5e74e2d46 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.55 \ No newline at end of file +v3.0.0-alpha.56 \ No newline at end of file From 9039051fd332757e5cc77727821e2f44b02e9675 Mon Sep 17 00:00:00 2001 From: samstanier Date: Sun, 4 Jan 2026 03:40:10 +0000 Subject: [PATCH 23/40] [v3] Fix save dialog filename not pre-populated on Linux (#4841) (#4842) The SaveFileDialog.SetFilename() option had no effect on Linux because the filename was never passed to the GTK file chooser. This adds a currentName parameter to runChooserDialog and calls gtk_file_chooser_set_current_name() for save dialogs when a filename is specified. Changes: - linux_cgo.go: Add currentName parameter and GTK call - linux_purego.go: Add gtkFileChooserSetCurrentName binding and same fix Fixes the Linux implementation to match the behaviour on Windows and macOS. Co-authored-by: sas229 Co-authored-by: Lea Anthony --- v3/UNRELEASED_CHANGELOG.md | 6 ++++++ v3/pkg/application/linux_cgo.go | 17 ++++++++++++++--- v3/pkg/application/linux_purego.go | 16 +++++++++++++--- 3 files changed, 33 insertions(+), 6 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..a617517a7 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,6 +23,12 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Fix SaveFileDialog.SetFilename() having no effect on Linux (#4841) by @samstanier +- Fix file drag-and-drop on Windows not working at non-100% display scaling +- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Windows +- Fix file drop coordinates being in wrong pixel space on Windows (physical vs CSS pixels) +- Fix file drag-and-drop on Linux not working reliably with hover effects +- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Linux ## Deprecated diff --git a/v3/pkg/application/linux_cgo.go b/v3/pkg/application/linux_cgo.go index 81706597a..bd8dc7071 100644 --- a/v3/pkg/application/linux_cgo.go +++ b/v3/pkg/application/linux_cgo.go @@ -1997,7 +1997,7 @@ func messageDialogCB(button C.int) { fmt.Println("messageDialogCB", button) } -func runChooserDialog(window pointer, allowMultiple, createFolders, showHidden bool, currentFolder, title string, action int, acceptLabel string, filters []FileFilter) (chan string, error) { +func runChooserDialog(window pointer, allowMultiple, createFolders, showHidden bool, currentFolder, title string, action int, acceptLabel string, filters []FileFilter, currentName string) (chan string, error) { titleStr := C.CString(title) defer C.free(unsafe.Pointer(titleStr)) cancelStr := C.CString("_Cancel") @@ -2047,6 +2047,15 @@ func runChooserDialog(window pointer, allowMultiple, createFolders, showHidden b C.free(unsafe.Pointer(path)) } + // Set the current name for save dialogs to pre-populate the filename + if currentName != "" && action == C.GTK_FILE_CHOOSER_ACTION_SAVE { + nameStr := C.CString(currentName) + C.gtk_file_chooser_set_current_name( + (*C.GtkFileChooser)(fc), + nameStr) + C.free(unsafe.Pointer(nameStr)) + } + // FIXME: This should be consolidated - duplicate exists in linux_purego.go buildStringAndFree := func(s C.gpointer) string { bytes := []byte{} @@ -2120,7 +2129,8 @@ func runOpenFileDialog(dialog *OpenFileDialogStruct) (chan string, error) { dialog.title, action, buttonText, - dialog.filters) + dialog.filters, + "") } func runQuestionDialog(parent pointer, options *MessageDialog) int { @@ -2202,7 +2212,8 @@ func runSaveFileDialog(dialog *SaveFileDialogStruct) (chan string, error) { dialog.title, C.GTK_FILE_CHOOSER_ACTION_SAVE, buttonText, - dialog.filters) + dialog.filters, + dialog.filename) return results, err } diff --git a/v3/pkg/application/linux_purego.go b/v3/pkg/application/linux_purego.go index 7520de4d3..5bfe97af0 100644 --- a/v3/pkg/application/linux_purego.go +++ b/v3/pkg/application/linux_purego.go @@ -152,6 +152,7 @@ var ( gtkFileChooserSetAction func(pointer, int) gtkFileChooserSetCreateFolders func(pointer, bool) gtkFileChooserSetCurrentFolder func(pointer, string) + gtkFileChooserSetCurrentName func(pointer, string) gtkFileChooserSetSelectMultiple func(pointer, bool) gtkFileChooserSetShowHidden func(pointer, bool) gtkFileFilterAddPattern func(pointer, string) @@ -305,6 +306,7 @@ func init() { purego.RegisterLibFunc(>kFileChooserSetAction, gtk, "gtk_file_chooser_set_action") purego.RegisterLibFunc(>kFileChooserSetCreateFolders, gtk, "gtk_file_chooser_set_create_folders") purego.RegisterLibFunc(>kFileChooserSetCurrentFolder, gtk, "gtk_file_chooser_set_current_folder") + purego.RegisterLibFunc(>kFileChooserSetCurrentName, gtk, "gtk_file_chooser_set_current_name") purego.RegisterLibFunc(>kFileChooserSetSelectMultiple, gtk, "gtk_file_chooser_set_select_multiple") purego.RegisterLibFunc(>kFileChooserSetShowHidden, gtk, "gtk_file_chooser_set_show_hidden") purego.RegisterLibFunc(>kFileFilterAddPattern, gtk, "gtk_file_filter_add_pattern") @@ -1027,7 +1029,7 @@ func windowMove(window pointer, x, y int) { gtkWindowMove(window, x, y) } -func runChooserDialog(window pointer, allowMultiple, createFolders, showHidden bool, currentFolder, title string, action int, acceptLabel string, filters []FileFilter) ([]string, error) { +func runChooserDialog(window pointer, allowMultiple, createFolders, showHidden bool, currentFolder, title string, action int, acceptLabel string, filters []FileFilter, currentName string) ([]string, error) { GtkResponseCancel := 0 GtkResponseAccept := 1 @@ -1059,6 +1061,12 @@ func runChooserDialog(window pointer, allowMultiple, createFolders, showHidden b gtkFileChooserSetCurrentFolder(fc, currentFolder) } + // Set the current name for save dialogs to pre-populate the filename + const GtkFileChooserActionSave = 1 + if currentName != "" && action == GtkFileChooserActionSave { + gtkFileChooserSetCurrentName(fc, currentName) + } + buildStringAndFree := func(s pointer) string { bytes := []byte{} p := unsafe.Pointer(s) @@ -1128,7 +1136,8 @@ func runOpenFileDialog(dialog *OpenFileDialogStruct) ([]string, error) { dialog.title, GtkFileChooserActionOpen, buttonText, - dialog.filters) + dialog.filters, + "") } func runQuestionDialog(parent pointer, options *MessageDialog) int { @@ -1209,7 +1218,8 @@ func runSaveFileDialog(dialog *SaveFileDialogStruct) (string, error) { dialog.title, GtkFileChooserActionSave, buttonText, - dialog.filters) + dialog.filters, + dialog.filename) if err != nil || len(results) == 0 { return "", err From ee7e95af52155e541f18482c924766d8203c60bb Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Sun, 4 Jan 2026 15:48:03 +1100 Subject: [PATCH 24/40] fix(v3): fix macOS mkdir brace expansion when APP_NAME contains spaces (#4850) fix(v3): fix macOS mkdir when APP_NAME contains spaces Replace brace expansion {MacOS,Resources} with two separate mkdir commands. Brace expansion doesn't work inside quoted strings and is shell-dependent. Adds integration test to verify mkdir works with spaces in paths. --- v3/UNRELEASED_CHANGELOG.md | 1 + .../commands/build_assets/darwin/Taskfile.yml | 6 +- v3/internal/commands/task_integration_test.go | 61 +++++++++++++++++-- 3 files changed, 62 insertions(+), 6 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index a617517a7..82fe9293a 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -29,6 +29,7 @@ After processing, the content will be moved to the main changelog and this file - Fix file drop coordinates being in wrong pixel space on Windows (physical vs CSS pixels) - Fix file drag-and-drop on Linux not working reliably with hover effects - Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Linux +- Fix macOS app bundle creation failing when APP_NAME contains spaces (brace expansion issue) ## Deprecated diff --git a/v3/internal/commands/build_assets/darwin/Taskfile.yml b/v3/internal/commands/build_assets/darwin/Taskfile.yml index b76d5bae0..50600ced9 100644 --- a/v3/internal/commands/build_assets/darwin/Taskfile.yml +++ b/v3/internal/commands/build_assets/darwin/Taskfile.yml @@ -138,7 +138,8 @@ tasks: create:app:bundle: summary: Creates an `.app` bundle cmds: - - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/{MacOS,Resources}" + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/MacOS" + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/Resources" - cp build/darwin/icons.icns "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/Resources" - cp "{{.BIN_DIR}}/{{.APP_NAME}}" "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/MacOS" - cp build/darwin/Info.plist "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents" @@ -158,7 +159,8 @@ tasks: run: cmds: - - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/{MacOS,Resources}" + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/MacOS" + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Resources" - cp build/darwin/icons.icns "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Resources" - cp "{{.BIN_DIR}}/{{.APP_NAME}}" "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/MacOS" - cp "build/darwin/Info.dev.plist" "{{.BIN_DIR}}/{{.APP_NAME}}.dev.app/Contents/Info.plist" diff --git a/v3/internal/commands/task_integration_test.go b/v3/internal/commands/task_integration_test.go index fc7ff6607..c13d73162 100644 --- a/v3/internal/commands/task_integration_test.go +++ b/v3/internal/commands/task_integration_test.go @@ -4,6 +4,7 @@ import ( "bytes" "os" "path/filepath" + "runtime" "strings" "testing" @@ -156,8 +157,8 @@ func TestCLIParameterFormats(t *testing.T) { }, }, { - name: "Empty value", - otherArgs: []string{"build", "EMPTY=", "KEY=value"}, + name: "Empty value", + otherArgs: []string{"build", "EMPTY=", "KEY=value"}, expectedVars: map[string]string{ "EMPTY": "", "KEY": "value", @@ -224,7 +225,7 @@ func captureTaskOutput(t *testing.T, options *RunTaskOptions, otherArgs []string // Wait for task to complete <-done - + // Check for errors (might be expected in some tests) if taskErr != nil && !strings.Contains(taskErr.Error(), "expected") { t.Logf("Task error (might be expected): %v", taskErr) @@ -286,4 +287,56 @@ func TestBackwardCompatibility(t *testing.T) { } }) } -} \ No newline at end of file +} + +func TestMkdirWithSpacesInPath(t *testing.T) { + if runtime.GOOS != "darwin" { + t.Skip("Skipping: macOS app bundle test only applies to darwin") + } + if os.Getenv("CI") == "true" && os.Getenv("SKIP_INTEGRATION_TESTS") == "true" { + t.Skip("Skipping integration test in CI") + } + + tmpDir, err := os.MkdirTemp("", "wails task test with spaces-*") + require.NoError(t, err) + defer os.RemoveAll(tmpDir) + + taskfileContent := `version: '3' + +vars: + BIN_DIR: "` + tmpDir + `/bin" + APP_NAME: "My App" + +tasks: + create-bundle: + cmds: + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/MacOS" + - mkdir -p "{{.BIN_DIR}}/{{.APP_NAME}}.app/Contents/Resources" +` + + taskfilePath := filepath.Join(tmpDir, "Taskfile.yml") + err = os.WriteFile(taskfilePath, []byte(taskfileContent), 0644) + require.NoError(t, err) + + originalWd, err := os.Getwd() + require.NoError(t, err) + defer os.Chdir(originalWd) + + err = os.Chdir(tmpDir) + require.NoError(t, err) + + err = RunTask(&RunTaskOptions{Name: "create-bundle"}, []string{}) + require.NoError(t, err) + + appContentsDir := filepath.Join(tmpDir, "bin", "My App.app", "Contents") + + macOSDir := filepath.Join(appContentsDir, "MacOS") + info, err := os.Stat(macOSDir) + require.NoError(t, err, "MacOS directory should exist") + assert.True(t, info.IsDir(), "MacOS should be a directory") + + resourcesDir := filepath.Join(appContentsDir, "Resources") + info, err = os.Stat(resourcesDir) + require.NoError(t, err, "Resources directory should exist") + assert.True(t, info.IsDir(), "Resources should be a directory") +} From 23b3424415d882d4c118b78de6966f0671e53ad8 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Mon, 5 Jan 2026 06:51:41 +1100 Subject: [PATCH 25/40] fix(v3): use correct JSON field names for drop coordinates in example (#4858) * fix(v3): use correct JSON field names for drop coordinates in example The DropTargetDetails struct uses lowercase JSON tags (x, y), but the example frontend was accessing uppercase (X, Y). * docs(v3): add coordinates fix to changelog --- v3/UNRELEASED_CHANGELOG.md | 6 +----- v3/examples/drag-n-drop/assets/index.html | 2 +- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 82fe9293a..2f857d519 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -24,11 +24,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed - Fix SaveFileDialog.SetFilename() having no effect on Linux (#4841) by @samstanier -- Fix file drag-and-drop on Windows not working at non-100% display scaling -- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Windows -- Fix file drop coordinates being in wrong pixel space on Windows (physical vs CSS pixels) -- Fix file drag-and-drop on Linux not working reliably with hover effects -- Fix HTML5 internal drag-and-drop being broken when file drop was enabled on Linux +- Fix drop coordinates showing as undefined in drag-n-drop example - Fix macOS app bundle creation failing when APP_NAME contains spaces (brace expansion issue) ## Deprecated diff --git a/v3/examples/drag-n-drop/assets/index.html b/v3/examples/drag-n-drop/assets/index.html index 7843cc057..53af94212 100644 --- a/v3/examples/drag-n-drop/assets/index.html +++ b/v3/examples/drag-n-drop/assets/index.html @@ -359,7 +359,7 @@ let info = `External: ${files.length} file(s) dropped`; if (details) { - info += ` at (${details.X}, ${details.Y})`; + info += ` at (${details.x}, ${details.y})`; } dropDetails.textContent = info; }); From 4dce80d88769e28c2ca90cfa7176b72a64577261 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Mon, 5 Jan 2026 08:26:35 +1100 Subject: [PATCH 26/40] fix(v3): revert goccy/go-json to stdlib encoding/json to fix Windows panic (#4859) * fix(v3): warm up dialog types in go-json cache to prevent Windows panic Add FileFilter, OpenFileDialogOptions, SaveFileDialogOptions, and MessageDialogOptions to the init() warmup to prevent index out of bounds panic on Windows when these types are first unmarshaled. Fixes goccy/go-json#474 for Wails internal dialog types. * fix(v3): revert goccy/go-json to stdlib encoding/json to fix Windows panic goccy/go-json has a type address calculation bug on Windows that causes index out of bounds panic when decoding user-defined types for the first time. This reverts all runtime usages of goccy/go-json back to stdlib encoding/json. Test and benchmark files are left unchanged. Partially reverts PR #4843. --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/go.mod | 10 --- v3/go.sum | 27 -------- .../assetserver/webview/request_darwin.go | 2 +- .../assetserver/webview/request_ios.go | 2 +- .../webview/responsewriter_darwin.go | 2 +- .../assetserver/webview/responsewriter_ios.go | 2 +- v3/internal/capabilities/capabilities.go | 2 +- v3/internal/runtime/runtime.go | 2 +- v3/pkg/application/application_android.go | 2 +- .../application/application_android_nocgo.go | 2 +- v3/pkg/application/application_darwin.go | 2 +- v3/pkg/application/application_ios.go | 2 +- v3/pkg/application/bindings.go | 64 +------------------ v3/pkg/application/events.go | 2 +- v3/pkg/application/ios_runtime_ios.go | 2 +- v3/pkg/application/json_libs_bench_test.go | 4 ++ v3/pkg/application/logger_ios.go | 2 +- v3/pkg/application/messageprocessor_args.go | 2 +- v3/pkg/application/messageprocessor_call.go | 2 +- v3/pkg/application/messageprocessor_events.go | 2 +- v3/pkg/application/single_instance.go | 2 +- v3/pkg/application/transport_http.go | 2 +- v3/pkg/application/webview_window.go | 2 +- v3/pkg/services/kvstore/kvstore.go | 2 +- .../notifications/notifications_darwin.go | 2 +- .../notifications/notifications_linux.go | 2 +- .../notifications/notifications_windows.go | 2 +- 28 files changed, 31 insertions(+), 121 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 2f857d519..cc6c74940 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -26,6 +26,7 @@ After processing, the content will be moved to the main changelog and this file - Fix SaveFileDialog.SetFilename() having no effect on Linux (#4841) by @samstanier - Fix drop coordinates showing as undefined in drag-n-drop example - Fix macOS app bundle creation failing when APP_NAME contains spaces (brace expansion issue) +- Fix index out of bounds panic on Windows when calling service methods (revert goccy/go-json) ## Deprecated diff --git a/v3/go.mod b/v3/go.mod index 407db2905..b5fe8b282 100644 --- a/v3/go.mod +++ b/v3/go.mod @@ -8,14 +8,12 @@ require ( github.com/adrg/xdg v0.5.3 github.com/atterpac/refresh v0.8.6 github.com/bep/debounce v1.2.1 - github.com/bytedance/sonic v1.14.2 github.com/charmbracelet/glamour v0.9.0 github.com/charmbracelet/huh v0.8.0 github.com/ebitengine/purego v0.8.2 github.com/go-git/go-git/v5 v5.13.2 github.com/go-json-experiment/json v0.0.0-20251027170946-4849db3c2f7e github.com/go-ole/go-ole v1.3.0 - github.com/goccy/go-json v0.10.5 github.com/godbus/dbus/v5 v5.1.0 github.com/google/go-cmp v0.7.0 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 @@ -24,7 +22,6 @@ require ( github.com/gorilla/websocket v1.5.3 github.com/jackmordaunt/icns/v2 v2.2.7 github.com/jaypipes/ghw v0.17.0 - github.com/json-iterator/go v1.1.12 github.com/konoui/lipo v0.10.0 github.com/leaanthony/clir v1.7.0 github.com/leaanthony/go-ansi-parser v1.6.1 @@ -55,8 +52,6 @@ require ( al.essio.dev/pkg/shellescape v1.5.1 // indirect atomicgo.dev/schedule v0.1.0 // indirect github.com/atotto/clipboard v0.1.4 // indirect - github.com/bytedance/gopkg v0.1.3 // indirect - github.com/bytedance/sonic/loader v0.4.0 // indirect github.com/catppuccin/go v0.3.0 // indirect github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7 // indirect github.com/charmbracelet/bubbletea v1.3.6 // indirect @@ -64,18 +59,13 @@ require ( github.com/charmbracelet/x/cellbuf v0.0.13 // indirect github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 // indirect github.com/charmbracelet/x/term v0.2.1 // indirect - github.com/cloudwego/base64x v0.1.6 // indirect github.com/danieljoos/wincred v1.2.2 // indirect github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect github.com/konoui/go-qsort v0.1.0 // indirect github.com/mattn/go-localereader v0.0.1 // indirect - github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect - github.com/modern-go/reflect2 v1.0.2 // indirect github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect github.com/ncruces/go-strftime v0.1.9 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/twitchyliquid64/golang-asm v0.15.1 // indirect - golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect ) require ( diff --git a/v3/go.sum b/v3/go.sum index 899e70059..f5bde5f7c 100644 --- a/v3/go.sum +++ b/v3/go.sum @@ -77,12 +77,6 @@ github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY= github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0= github.com/blakesmith/ar v0.0.0-20190502131153-809d4375e1fb h1:m935MPodAbYS46DG4pJSv7WO+VECIWUQ7OJYSoTrMh4= github.com/blakesmith/ar v0.0.0-20190502131153-809d4375e1fb/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI= -github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M= -github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM= -github.com/bytedance/sonic v1.14.2 h1:k1twIoe97C1DtYUo+fZQy865IuHia4PR5RPiuGPPIIE= -github.com/bytedance/sonic v1.14.2/go.mod h1:T80iDELeHiHKSc0C9tubFygiuXoGzrkjKzX2quAx980= -github.com/bytedance/sonic/loader v0.4.0 h1:olZ7lEqcxtZygCK9EKYKADnpQoYkRQxaeY2NYzevs+o= -github.com/bytedance/sonic/loader v0.4.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo= github.com/caarlos0/testfs v0.4.4 h1:3PHvzHi5Lt+g332CiShwS8ogTgS3HjrmzZxCm6JCDr8= github.com/caarlos0/testfs v0.4.4/go.mod h1:bRN55zgG4XCUVVHZCeU+/Tz1Q6AxEJOEJTliBy+1DMk= github.com/catppuccin/go v0.3.0 h1:d+0/YicIq+hSTo5oPuRi5kOpqkVA5tAsU6dNhvRu+aY= @@ -123,8 +117,6 @@ github.com/charmbracelet/x/xpty v0.1.2 h1:Pqmu4TEJ8KeA9uSkISKMU3f+C1F6OGBn8ABuGl github.com/charmbracelet/x/xpty v0.1.2/go.mod h1:XK2Z0id5rtLWcpeNiMYBccNNBrP2IJnzHI0Lq13Xzq4= github.com/cloudflare/circl v1.6.0 h1:cr5JKic4HI+LkINy2lg3W2jF8sHCVTBncJr5gIIq7qk= github.com/cloudflare/circl v1.6.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs= -github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M= -github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU= github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U= github.com/containerd/console v1.0.4 h1:F2g4+oChYvBTsASRTz8NP6iIAi97J3TtSAsLbIFn4ro= github.com/containerd/console v1.0.4/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= @@ -178,15 +170,12 @@ github.com/go-task/template v0.1.0 h1:ym/r2G937RZA1bsgiWedNnY9e5kxDT+3YcoAnuIetT github.com/go-task/template v0.1.0/go.mod h1:RgwRaZK+kni/hJJ7/AaOE2lPQFPbAdji/DyhC6pxo4k= github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y= github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8= -github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= -github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk= github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ= github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd h1:gbpYu9NMq8jhDVbvlGkMFWCjLFlqqEZjEmObmhUy6Vo= github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw= github.com/google/rpmpack v0.6.1-0.20240329070804-c2247cbb881a h1:JJBdjSfqSy3mnDT0940ASQFghwcZ4y4cb6ttjAoXqwE= @@ -228,8 +217,6 @@ github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEE github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= -github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= @@ -298,10 +285,6 @@ github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4 github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE= github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= -github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= @@ -368,24 +351,16 @@ github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cA github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/tc-hib/winres v0.3.1 h1:CwRjEGrKdbi5CvZ4ID+iyVhgyfatxFoizjPhzez9Io4= github.com/tc-hib/winres v0.3.1/go.mod h1:C/JaNhH3KBvhNKVbvdlDWkbMDO9H4fKKDaN7/07SSuk= -github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= -github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc= github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= github.com/wailsapp/go-webview2 v1.0.22 h1:YT61F5lj+GGaat5OB96Aa3b4QA+mybD0Ggq6NZijQ58= @@ -413,8 +388,6 @@ github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0= github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= gitlab.com/digitalxero/go-conventional-commit v1.0.7 h1:8/dO6WWG+98PMhlZowt/YjuiKhqhGlOCwlIV8SqqGh8= gitlab.com/digitalxero/go-conventional-commit v1.0.7/go.mod h1:05Xc2BFsSyC5tKhK0y+P3bs0AwUtNuTp+mTpbCU/DZ0= -golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VAiXCnxFY6NyDX0bHDmkU= -golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= diff --git a/v3/internal/assetserver/webview/request_darwin.go b/v3/internal/assetserver/webview/request_darwin.go index 2b961d781..dd2d0232a 100644 --- a/v3/internal/assetserver/webview/request_darwin.go +++ b/v3/internal/assetserver/webview/request_darwin.go @@ -115,7 +115,7 @@ import ( "net/http" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" ) // NewRequest creates as new WebViewRequest based on a pointer to an `id` diff --git a/v3/internal/assetserver/webview/request_ios.go b/v3/internal/assetserver/webview/request_ios.go index 1a1941c7e..81d23b0bc 100644 --- a/v3/internal/assetserver/webview/request_ios.go +++ b/v3/internal/assetserver/webview/request_ios.go @@ -113,7 +113,7 @@ import ( "net/http" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" ) // NewRequest creates as new WebViewRequest based on a pointer to an `id` diff --git a/v3/internal/assetserver/webview/responsewriter_darwin.go b/v3/internal/assetserver/webview/responsewriter_darwin.go index 4bac699d6..ff29a08bb 100644 --- a/v3/internal/assetserver/webview/responsewriter_darwin.go +++ b/v3/internal/assetserver/webview/responsewriter_darwin.go @@ -71,7 +71,7 @@ import ( "net/http" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" ) var _ ResponseWriter = &responseWriter{} diff --git a/v3/internal/assetserver/webview/responsewriter_ios.go b/v3/internal/assetserver/webview/responsewriter_ios.go index a6284b804..119ef1628 100644 --- a/v3/internal/assetserver/webview/responsewriter_ios.go +++ b/v3/internal/assetserver/webview/responsewriter_ios.go @@ -73,7 +73,7 @@ import ( "strings" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" ) var _ ResponseWriter = &responseWriter{} diff --git a/v3/internal/capabilities/capabilities.go b/v3/internal/capabilities/capabilities.go index 1af25e91a..af9428bb2 100644 --- a/v3/internal/capabilities/capabilities.go +++ b/v3/internal/capabilities/capabilities.go @@ -1,6 +1,6 @@ package capabilities -import json "github.com/goccy/go-json" +import "encoding/json" type Capabilities struct { HasNativeDrag bool diff --git a/v3/internal/runtime/runtime.go b/v3/internal/runtime/runtime.go index 42fed010d..d35ff0552 100644 --- a/v3/internal/runtime/runtime.go +++ b/v3/internal/runtime/runtime.go @@ -3,7 +3,7 @@ package runtime import ( "fmt" - json "github.com/goccy/go-json" + "encoding/json" ) var runtimeInit = `window._wails=window._wails||{};window._wails.flags=window._wails.flags||{};window.wails=window.wails||{};` diff --git a/v3/pkg/application/application_android.go b/v3/pkg/application/application_android.go index e5da744eb..87bb1b2f4 100644 --- a/v3/pkg/application/application_android.go +++ b/v3/pkg/application/application_android.go @@ -148,7 +148,7 @@ import ( "time" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" "github.com/wailsapp/wails/v3/internal/runtime" ) diff --git a/v3/pkg/application/application_android_nocgo.go b/v3/pkg/application/application_android_nocgo.go index cb31203dd..ea769f3e1 100644 --- a/v3/pkg/application/application_android_nocgo.go +++ b/v3/pkg/application/application_android_nocgo.go @@ -7,7 +7,7 @@ import ( "sync" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" ) var ( diff --git a/v3/pkg/application/application_darwin.go b/v3/pkg/application/application_darwin.go index e6e0b080a..f5738f93f 100644 --- a/v3/pkg/application/application_darwin.go +++ b/v3/pkg/application/application_darwin.go @@ -200,7 +200,7 @@ import ( "time" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" "github.com/wailsapp/wails/v3/internal/assetserver/webview" "github.com/wailsapp/wails/v3/internal/operatingsystem" diff --git a/v3/pkg/application/application_ios.go b/v3/pkg/application/application_ios.go index 7b0da7eee..90e896b07 100644 --- a/v3/pkg/application/application_ios.go +++ b/v3/pkg/application/application_ios.go @@ -20,7 +20,7 @@ import ( "time" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" "github.com/wailsapp/wails/v3/internal/assetserver/webview" "github.com/wailsapp/wails/v3/pkg/events" diff --git a/v3/pkg/application/bindings.go b/v3/pkg/application/bindings.go index 42830d07e..e16948399 100644 --- a/v3/pkg/application/bindings.go +++ b/v3/pkg/application/bindings.go @@ -2,75 +2,17 @@ package application import ( "context" + "encoding/json" "errors" "fmt" "reflect" "runtime" "strings" - json "github.com/goccy/go-json" - "github.com/wailsapp/wails/v3/internal/hash" "github.com/wailsapp/wails/v3/internal/sliceutil" ) -// init forces goccy/go-json to initialize its type address cache at program startup. -// This prevents a Windows-specific index out-of-bounds panic that can occur when the decoder is first invoked later (see https://github.com/goccy/go-json/issues/474). -func init() { - // Force goccy/go-json to initialize its type address cache early. - // On Windows, if the decoder is first invoked later (e.g., during tests), - // the type address calculation can fail with an index out of bounds panic. - // See: https://github.com/goccy/go-json/issues/474 - var ( - s string - i int - i8 int8 - i16 int16 - i32 int32 - i64 int64 - u uint - u8 uint8 - u16 uint16 - u32 uint32 - u64 uint64 - f32 float32 - f64 float64 - b bool - bs []byte - ss []string - si []int - sf []float64 - sa []any - msa map[string]any - mss map[string]string - msi map[string]int - rm json.RawMessage - ) - _ = json.Unmarshal([]byte(`""`), &s) - _ = json.Unmarshal([]byte(`0`), &i) - _ = json.Unmarshal([]byte(`0`), &i8) - _ = json.Unmarshal([]byte(`0`), &i16) - _ = json.Unmarshal([]byte(`0`), &i32) - _ = json.Unmarshal([]byte(`0`), &i64) - _ = json.Unmarshal([]byte(`0`), &u) - _ = json.Unmarshal([]byte(`0`), &u8) - _ = json.Unmarshal([]byte(`0`), &u16) - _ = json.Unmarshal([]byte(`0`), &u32) - _ = json.Unmarshal([]byte(`0`), &u64) - _ = json.Unmarshal([]byte(`0`), &f32) - _ = json.Unmarshal([]byte(`0`), &f64) - _ = json.Unmarshal([]byte(`false`), &b) - _ = json.Unmarshal([]byte(`""`), &bs) - _ = json.Unmarshal([]byte(`[]`), &ss) - _ = json.Unmarshal([]byte(`[]`), &si) - _ = json.Unmarshal([]byte(`[]`), &sf) - _ = json.Unmarshal([]byte(`[]`), &sa) - _ = json.Unmarshal([]byte(`{}`), &msa) - _ = json.Unmarshal([]byte(`{}`), &mss) - _ = json.Unmarshal([]byte(`{}`), &msi) - _ = json.Unmarshal([]byte(`""`), &rm) -} - // CallOptions defines the options for a method call. // Field order is optimized to minimize struct padding. type CallOptions struct { @@ -228,7 +170,7 @@ var internalServiceMethods = map[string]bool{ var ctxType = reflect.TypeFor[context.Context]() // getMethods returns the list of BoundMethod descriptors for the methods of the named pointer type provided by value. -// +// // It returns an error if value is not a pointer to a named type, if a function value is supplied (binding functions is deprecated), or if a generic type is supplied. // The returned BoundMethod slice includes only exported methods that are not listed in internalServiceMethods. Each BoundMethod has its FQN, ID (computed from the FQN), Method reflect.Value, Inputs and Outputs populated, isVariadic cached from the method signature, and needsContext set when the first parameter is context.Context. func getMethods(value any) ([]*BoundMethod, error) { @@ -482,4 +424,4 @@ func isNamed(value interface{}) bool { } return rv.Type().Name() != "" -} \ No newline at end of file +} diff --git a/v3/pkg/application/events.go b/v3/pkg/application/events.go index f70d37123..dbe6d20a2 100644 --- a/v3/pkg/application/events.go +++ b/v3/pkg/application/events.go @@ -7,7 +7,7 @@ import ( "sync" "sync/atomic" - json "github.com/goccy/go-json" + "encoding/json" "github.com/wailsapp/wails/v3/pkg/events" ) diff --git a/v3/pkg/application/ios_runtime_ios.go b/v3/pkg/application/ios_runtime_ios.go index 0b4b5b35b..6a388d9a9 100644 --- a/v3/pkg/application/ios_runtime_ios.go +++ b/v3/pkg/application/ios_runtime_ios.go @@ -12,7 +12,7 @@ import "C" import ( "unsafe" - json "github.com/goccy/go-json" + "encoding/json" ) // iosHapticsImpact triggers an iOS haptic impact using the provided style. diff --git a/v3/pkg/application/json_libs_bench_test.go b/v3/pkg/application/json_libs_bench_test.go index 274b29b5f..c3e7e4918 100644 --- a/v3/pkg/application/json_libs_bench_test.go +++ b/v3/pkg/application/json_libs_bench_test.go @@ -1,7 +1,10 @@ //go:build bench +// Disabled: goccy/go-json causes Windows panics. See PR #4859. + package application_test +/* import ( "encoding/json" "testing" @@ -308,3 +311,4 @@ func BenchmarkMarshal_Complex_Sonic(b *testing.B) { _, _ = sonic.Marshal(complexResult) } } +*/ diff --git a/v3/pkg/application/logger_ios.go b/v3/pkg/application/logger_ios.go index ed77d09b5..584e96609 100644 --- a/v3/pkg/application/logger_ios.go +++ b/v3/pkg/application/logger_ios.go @@ -17,7 +17,7 @@ import ( "time" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" ) // iosConsoleHandler implements slog.Handler and forwards records to the WKWebView console. diff --git a/v3/pkg/application/messageprocessor_args.go b/v3/pkg/application/messageprocessor_args.go index 3eeb98701..bb3ffc6d0 100644 --- a/v3/pkg/application/messageprocessor_args.go +++ b/v3/pkg/application/messageprocessor_args.go @@ -3,7 +3,7 @@ package application import ( "fmt" - json "github.com/goccy/go-json" + "encoding/json" ) type Args struct { diff --git a/v3/pkg/application/messageprocessor_call.go b/v3/pkg/application/messageprocessor_call.go index 9b58801da..924acdbf0 100644 --- a/v3/pkg/application/messageprocessor_call.go +++ b/v3/pkg/application/messageprocessor_call.go @@ -4,7 +4,7 @@ import ( "context" "errors" - json "github.com/goccy/go-json" + "encoding/json" "github.com/wailsapp/wails/v3/pkg/errs" ) diff --git a/v3/pkg/application/messageprocessor_events.go b/v3/pkg/application/messageprocessor_events.go index d251c6ace..9de3ae136 100644 --- a/v3/pkg/application/messageprocessor_events.go +++ b/v3/pkg/application/messageprocessor_events.go @@ -1,7 +1,7 @@ package application import ( - json "github.com/goccy/go-json" + "encoding/json" "github.com/wailsapp/wails/v3/pkg/errs" ) diff --git a/v3/pkg/application/single_instance.go b/v3/pkg/application/single_instance.go index 681998874..7f04320eb 100644 --- a/v3/pkg/application/single_instance.go +++ b/v3/pkg/application/single_instance.go @@ -10,7 +10,7 @@ import ( "path/filepath" "sync" - json "github.com/goccy/go-json" + "encoding/json" ) var alreadyRunningError = errors.New("application is already running") diff --git a/v3/pkg/application/transport_http.go b/v3/pkg/application/transport_http.go index d043c9b53..0c2b0fd45 100644 --- a/v3/pkg/application/transport_http.go +++ b/v3/pkg/application/transport_http.go @@ -10,7 +10,7 @@ import ( "strconv" "sync" - json "github.com/goccy/go-json" + "encoding/json" "github.com/wailsapp/wails/v3/pkg/errs" ) diff --git a/v3/pkg/application/webview_window.go b/v3/pkg/application/webview_window.go index 08d21ebb3..dbf7eebcc 100644 --- a/v3/pkg/application/webview_window.go +++ b/v3/pkg/application/webview_window.go @@ -9,7 +9,7 @@ import ( "sync/atomic" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" "github.com/leaanthony/u" "github.com/wailsapp/wails/v3/internal/assetserver" diff --git a/v3/pkg/services/kvstore/kvstore.go b/v3/pkg/services/kvstore/kvstore.go index 94ce6c61f..4d2f511b0 100644 --- a/v3/pkg/services/kvstore/kvstore.go +++ b/v3/pkg/services/kvstore/kvstore.go @@ -5,7 +5,7 @@ import ( "os" "sync" - json "github.com/goccy/go-json" + "encoding/json" "github.com/pkg/errors" "github.com/wailsapp/wails/v3/pkg/application" ) diff --git a/v3/pkg/services/notifications/notifications_darwin.go b/v3/pkg/services/notifications/notifications_darwin.go index 70a505fc9..b9695b3f9 100644 --- a/v3/pkg/services/notifications/notifications_darwin.go +++ b/v3/pkg/services/notifications/notifications_darwin.go @@ -20,7 +20,7 @@ import ( "time" "unsafe" - json "github.com/goccy/go-json" + "encoding/json" "github.com/wailsapp/wails/v3/pkg/application" ) diff --git a/v3/pkg/services/notifications/notifications_linux.go b/v3/pkg/services/notifications/notifications_linux.go index 455f96cdb..23e21433e 100644 --- a/v3/pkg/services/notifications/notifications_linux.go +++ b/v3/pkg/services/notifications/notifications_linux.go @@ -9,7 +9,7 @@ import ( "path/filepath" "sync" - json "github.com/goccy/go-json" + "encoding/json" "github.com/godbus/dbus/v5" "github.com/wailsapp/wails/v3/pkg/application" diff --git a/v3/pkg/services/notifications/notifications_windows.go b/v3/pkg/services/notifications/notifications_windows.go index 6bca1e747..b1063dbf8 100644 --- a/v3/pkg/services/notifications/notifications_windows.go +++ b/v3/pkg/services/notifications/notifications_windows.go @@ -11,7 +11,7 @@ import ( "sync" _ "unsafe" - json "github.com/goccy/go-json" + "encoding/json" "git.sr.ht/~jackmordaunt/go-toast/v2" wintoast "git.sr.ht/~jackmordaunt/go-toast/v2/wintoast" From 93c307b4b27bda704dd4abe96230b8ea8c524561 Mon Sep 17 00:00:00 2001 From: mbaklor <78748463+mbaklor@users.noreply.github.com> Date: Sun, 4 Jan 2026 23:48:29 +0200 Subject: [PATCH 27/40] V3/fix debug logs (#4857) * fix(v3): replace various debug logs from Info to Debug * fix(v3): fixed logging on linux as well as windows * fix(v3): add format directive for warning log argument --------- Co-authored-by: Lea Anthony --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/internal/assetserver/assetserver.go | 2 +- v3/pkg/application/application.go | 10 +++++----- v3/pkg/application/application_linux.go | 12 ++++++------ v3/pkg/application/application_windows.go | 6 +++--- v3/pkg/application/messageprocessor.go | 6 +++--- v3/pkg/application/messageprocessor_call.go | 6 +++--- v3/pkg/application/messageprocessor_window.go | 2 +- v3/pkg/application/webview_window_windows.go | 2 +- 9 files changed, 24 insertions(+), 23 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index cc6c74940..a78adee44 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -20,6 +20,7 @@ After processing, the content will be moved to the main changelog and this file ## Changed +- Replace various debug logs from Info to Debug (by @mbaklor) ## Fixed diff --git a/v3/internal/assetserver/assetserver.go b/v3/internal/assetserver/assetserver.go index 6ff1b169f..60b2fcbfb 100644 --- a/v3/internal/assetserver/assetserver.go +++ b/v3/internal/assetserver/assetserver.go @@ -69,7 +69,7 @@ func (a *AssetServer) ServeHTTP(rw http.ResponseWriter, req *http.Request) { req = req.WithContext(contextWithLogger(req.Context(), a.options.Logger)) a.handler.ServeHTTP(wrapped, req) - a.options.Logger.Info( + a.options.Logger.Debug( "Asset Request:", "windowName", req.Header.Get(webViewRequestHeaderWindowName), "windowID", req.Header.Get(webViewRequestHeaderWindowId), diff --git a/v3/pkg/application/application.go b/v3/pkg/application/application.go index b4d5b9cb7..8483f8166 100644 --- a/v3/pkg/application/application.go +++ b/v3/pkg/application/application.go @@ -151,7 +151,7 @@ func New(appOptions Options) *App { if err != nil { result.fatal("failed to configure transport for serving assets: %w", err) } - result.info("Transport configured to serve assets") + result.debug("Transport configured to serve assets") } result.bindings = NewBindings(appOptions.MarshalError, appOptions.BindAliases) @@ -733,7 +733,7 @@ func (a *App) handleWindowMessage(event *windowMessage) { } a.windowsLock.RUnlock() - a.info("handleWindowMessage: Looking for window", "windowId", event.windowId, "availableIDs", ids) + a.debug("handleWindowMessage: Looking for window", "windowId", event.windowId, "availableIDs", ids) if !ok { a.warning("WebviewWindow #%d not found", event.windowId) @@ -741,7 +741,7 @@ func (a *App) handleWindowMessage(event *windowMessage) { } // Check if the message starts with "wails:" if strings.HasPrefix(event.message, "wails:") { - a.info("handleWindowMessage: Processing wails message", "message", event.message) + a.debug("handleWindowMessage: Processing wails message", "message", event.message) window.HandleMessage(event.message) } else { if a.options.RawMessageHandler != nil { @@ -754,10 +754,10 @@ func (a *App) handleWebViewRequest(request *webViewAssetRequest) { defer handlePanic() // Log that we're processing the request url, _ := request.Request.URL() - a.info("handleWebViewRequest: Processing request", "url", url) + a.debug("handleWebViewRequest: Processing request", "url", url) // IMPORTANT: pass the wrapper request so our injected headers (x-wails-window-id/name) are used a.assets.ServeWebViewRequest(request) - a.info("handleWebViewRequest: Request processing complete", "url", url) + a.debug("handleWebViewRequest: Request processing complete", "url", url) } func (a *App) handleWindowEvent(event *windowEvent) { diff --git a/v3/pkg/application/application_linux.go b/v3/pkg/application/application_linux.go index f0e14f47d..04924a6c9 100644 --- a/v3/pkg/application/application_linux.go +++ b/v3/pkg/application/application_linux.go @@ -144,7 +144,7 @@ func (a *linuxApp) run() error { arg1 := os.Args[1] // Check if the argument is likely a URL from a custom protocol invocation if strings.Contains(arg1, "://") { - a.parent.info("Application launched with argument, potentially a URL from custom protocol", "url", arg1) + a.parent.debug("Application launched with argument, potentially a URL from custom protocol", "url", arg1) eventContext := newApplicationEventContext() eventContext.setURL(arg1) applicationEvents <- &ApplicationEvent{ @@ -156,7 +156,7 @@ func (a *linuxApp) run() error { if a.parent.options.FileAssociations != nil { ext := filepath.Ext(arg1) if slices.Contains(a.parent.options.FileAssociations, ext) { - a.parent.info("File opened via file association", "file", arg1, "extension", ext) + a.parent.debug("File opened via file association", "file", arg1, "extension", ext) eventContext := newApplicationEventContext() eventContext.setOpenedWithFile(arg1) applicationEvents <- &ApplicationEvent{ @@ -166,11 +166,11 @@ func (a *linuxApp) run() error { return nil } } - a.parent.info("Application launched with single argument (not a URL), potential file open?", "arg", arg1) + a.parent.debug("Application launched with single argument (not a URL), potential file open?", "arg", arg1) } } else if len(os.Args) > 2 { // Log if multiple arguments are passed - a.parent.info("Application launched with multiple arguments", "args", os.Args[1:]) + a.parent.debug("Application launched with multiple arguments", "args", os.Args[1:]) } a.parent.Event.OnApplicationEvent(events.Linux.ApplicationStartup, func(evt *ApplicationEvent) { @@ -226,8 +226,8 @@ func (a *linuxApp) monitorThemeChanges() { defer handlePanic() conn, err := dbus.ConnectSessionBus() if err != nil { - a.parent.info( - "[WARNING] Failed to connect to session bus; monitoring for theme changes will not function:", + a.parent.warning( + "[WARNING] Failed to connect to session bus; monitoring for theme changes will not function: %v", err, ) return diff --git a/v3/pkg/application/application_windows.go b/v3/pkg/application/application_windows.go index 364bb902c..7b3298cb3 100644 --- a/v3/pkg/application/application_windows.go +++ b/v3/pkg/application/application_windows.go @@ -160,7 +160,7 @@ func (m *windowsApp) run() error { arg1 := os.Args[1] // Check if the argument is likely a URL from a custom protocol invocation if strings.Contains(arg1, "://") { - m.parent.info("Application launched with argument, potentially a URL from custom protocol", "url", arg1) + m.parent.debug("Application launched with argument, potentially a URL from custom protocol", "url", arg1) eventContext := newApplicationEventContext() eventContext.setURL(arg1) applicationEvents <- &ApplicationEvent{ @@ -172,7 +172,7 @@ func (m *windowsApp) run() error { if m.parent.options.FileAssociations != nil { ext := filepath.Ext(arg1) if slices.Contains(m.parent.options.FileAssociations, ext) { - m.parent.info("Application launched with file via file association", "file", arg1) + m.parent.debug("Application launched with file via file association", "file", arg1) eventContext := newApplicationEventContext() eventContext.setOpenedWithFile(arg1) applicationEvents <- &ApplicationEvent{ @@ -184,7 +184,7 @@ func (m *windowsApp) run() error { } } else if len(os.Args) > 2 { // Log if multiple arguments are passed, though typical protocol/file launch is a single arg. - m.parent.info("Application launched with multiple arguments", "args", os.Args[1:]) + m.parent.debug("Application launched with multiple arguments", "args", os.Args[1:]) } _ = m.runMainLoop() diff --git a/v3/pkg/application/messageprocessor.go b/v3/pkg/application/messageprocessor.go index 3a3802aa5..4829d3dbf 100644 --- a/v3/pkg/application/messageprocessor.go +++ b/v3/pkg/application/messageprocessor.go @@ -158,8 +158,8 @@ func (m *MessageProcessor) Error(message string, args ...any) { m.logger.Error(message, args...) } -func (m *MessageProcessor) Info(message string, args ...any) { - m.logger.Info(message, args...) +func (m *MessageProcessor) Debug(message string, args ...any) { + m.logger.Debug(message, args...) } func (m *MessageProcessor) logRuntimeCall(req *RuntimeRequest) { @@ -195,5 +195,5 @@ func (m *MessageProcessor) logRuntimeCall(req *RuntimeRequest) { methodName = androidMethodNames[req.Method] } - m.Info("Runtime call:", "method", objectName+"."+methodName, "args", req.Args.String()) + m.Debug("Runtime call:", "method", objectName+"."+methodName, "args", req.Args.String()) } diff --git a/v3/pkg/application/messageprocessor_call.go b/v3/pkg/application/messageprocessor_call.go index 924acdbf0..71f60a00e 100644 --- a/v3/pkg/application/messageprocessor_call.go +++ b/v3/pkg/application/messageprocessor_call.go @@ -31,7 +31,7 @@ func (m *MessageProcessor) processCallCancelMethod(req *RuntimeRequest) (any, er if cancel != nil { cancel() - m.Info("Binding call cancelled:", "id", *callID) + m.Debug("Binding call cancelled:", "id", *callID) } return unit, nil } @@ -55,7 +55,7 @@ func (m *MessageProcessor) processCallMethod(ctx context.Context, req *RuntimeRe if options.MethodName == "" { methodRef = options.MethodID } - m.Info("Binding call started:", "id", *callID, "method", methodRef) + m.Debug("Binding call started:", "id", *callID, "method", methodRef) ctx, cancel := context.WithCancel(context.WithoutCancel(ctx)) @@ -108,7 +108,7 @@ func (m *MessageProcessor) processCallMethod(ctx context.Context, req *RuntimeRe defer func() { var jsonResult []byte jsonResult, _ = json.Marshal(result) - m.Info("Binding call complete:", "id", *callID, "method", boundMethod, "args", string(jsonArgs), "result", string(jsonResult)) + m.Debug("Binding call complete:", "id", *callID, "method", boundMethod, "args", string(jsonArgs), "result", string(jsonResult)) }() // Set the context values for the window diff --git a/v3/pkg/application/messageprocessor_window.go b/v3/pkg/application/messageprocessor_window.go index 85095e866..1baf57606 100644 --- a/v3/pkg/application/messageprocessor_window.go +++ b/v3/pkg/application/messageprocessor_window.go @@ -359,7 +359,7 @@ func (m *MessageProcessor) processWindowMethod( if err != nil { return nil, errs.WrapInvalidWindowCallErrorf(err, "error decoding file drop payload") } - m.Info( + m.Debug( "[DragDropDebug] processWindowMethod: Decoded payload from 'args'", "payload", fmt.Sprintf("%+v", payload), diff --git a/v3/pkg/application/webview_window_windows.go b/v3/pkg/application/webview_window_windows.go index 85cd1f950..b2bb3c04d 100644 --- a/v3/pkg/application/webview_window_windows.go +++ b/v3/pkg/application/webview_window_windows.go @@ -1490,7 +1490,7 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp } } case w32.WM_SYSKEYDOWN: - globalApplication.info("w32.WM_SYSKEYDOWN", "wparam", uint(wparam)) + globalApplication.debug("w32.WM_SYSKEYDOWN", "wparam", uint(wparam)) w.parent.emit(events.Windows.WindowKeyDown) if w.processKeyBinding(uint(wparam)) { return 0 From 862e2e8d6cc0fa084ee716bdfcacf682835d4682 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 5 Jan 2026 02:55:08 +0000 Subject: [PATCH 28/40] chore(v3): bump to v3.0.0-alpha.57 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 11 +++++++++++ v3/UNRELEASED_CHANGELOG.md | 5 ----- v3/internal/version/version.txt | 2 +- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index 34ee2368d..ddfa886b8 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.57 - 2026-01-05 + +## Changed +- Replace various debug logs from Info to Debug (by @mbaklor) + +## Fixed +- Fix SaveFileDialog.SetFilename() having no effect on Linux (#4841) by @samstanier +- Fix drop coordinates showing as undefined in drag-n-drop example +- Fix macOS app bundle creation failing when APP_NAME contains spaces (brace expansion issue) +- Fix index out of bounds panic on Windows when calling service methods (revert goccy/go-json) + ## v3.0.0-alpha.56 - 2026-01-04 ## Added diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index a78adee44..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -20,14 +20,9 @@ After processing, the content will be moved to the main changelog and this file ## Changed -- Replace various debug logs from Info to Debug (by @mbaklor) ## Fixed -- Fix SaveFileDialog.SetFilename() having no effect on Linux (#4841) by @samstanier -- Fix drop coordinates showing as undefined in drag-n-drop example -- Fix macOS app bundle creation failing when APP_NAME contains spaces (brace expansion issue) -- Fix index out of bounds panic on Windows when calling service methods (revert goccy/go-json) ## Deprecated diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 5e74e2d46..63ca63748 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.56 \ No newline at end of file +v3.0.0-alpha.57 \ No newline at end of file From 1fb60abdc97660a0e02c5baa0ca029500e7251b7 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Thu, 8 Jan 2026 21:16:45 +1100 Subject: [PATCH 29/40] docs(v3): update API references to new Manager API pattern (#4863) * docs(v3): update API references to new Manager API pattern Update documentation to reflect the Manager API refactoring from alpha.10: Window API: - app.NewWebviewWindow() -> app.Window.New() - app.NewWebviewWindowWithOptions() -> app.Window.NewWithOptions() - app.CurrentWindow() -> app.Window.Current() - app.GetAllWindows() -> app.Window.GetAll() - app.WindowByName() -> app.Window.GetByName() Event API: - app.EmitEvent() -> app.Event.Emit() - app.OnEvent() -> app.Event.On() - app.OnApplicationEvent() -> app.Event.OnApplicationEvent() Dialog API: - app.OpenFileDialog() -> app.Dialog.OpenFile() - app.SaveFileDialog() -> app.Dialog.SaveFile() - app.InfoDialog() -> app.Dialog.Info() - app.ErrorDialog() -> app.Dialog.Error() - app.WarningDialog() -> app.Dialog.Warning() - app.QuestionDialog() -> app.Dialog.Question() Other APIs: - app.NewSystemTray() -> app.SystemTray.New() - app.SetApplicationMenu() -> app.Menu.Set() - app.GetPrimaryScreen() -> app.Screen.GetPrimary() - app.GetAllScreens() -> app.Screen.GetAll() - app.ClipboardGetText() -> app.Clipboard.Text() - app.ClipboardSetText() -> app.Clipboard.SetText() - app.BrowserOpenURL() -> app.Browser.OpenURL() Fixes outdated code examples across 31 documentation files. * chore(v3): add docs fix to unreleased changelog --- .../content/docs/concepts/architecture.mdx | 2 +- docs/src/content/docs/concepts/bridge.mdx | 2 +- .../content/docs/concepts/build-system.mdx | 2 +- .../docs/contributing/runtime-internals.mdx | 2 +- docs/src/content/docs/faq.mdx | 12 +-- .../docs/features/bindings/best-practices.mdx | 2 +- .../docs/features/bindings/methods.mdx | 4 +- .../content/docs/features/bindings/models.mdx | 2 +- .../docs/features/bindings/services.mdx | 6 +- .../docs/features/clipboard/basics.mdx | 6 +- .../content/docs/features/dialogs/custom.mdx | 28 +++---- .../docs/features/drag-and-drop/files.mdx | 2 +- .../content/docs/features/events/system.mdx | 84 +++++++++---------- .../docs/features/menus/application.mdx | 4 +- .../content/docs/features/menus/context.mdx | 2 +- .../content/docs/features/menus/systray.mdx | 18 ++-- .../content/docs/features/screens/info.mdx | 4 +- .../content/docs/features/windows/basics.mdx | 30 +++---- .../content/docs/features/windows/events.mdx | 14 ++-- .../docs/features/windows/frameless.mdx | 20 ++--- .../docs/features/windows/multiple.mdx | 40 ++++----- .../content/docs/features/windows/options.mdx | 16 ++-- .../guides/distribution/custom-protocols.mdx | 8 +- docs/src/content/docs/guides/performance.mdx | 4 +- docs/src/content/docs/guides/raw-messages.mdx | 6 +- docs/src/content/docs/migration/v2-to-v3.mdx | 30 +++---- .../content/docs/reference/application.mdx | 46 +++++----- docs/src/content/docs/reference/events.mdx | 78 ++++++++--------- docs/src/content/docs/reference/menu.mdx | 24 +++--- docs/src/content/docs/reference/overview.mdx | 2 +- docs/src/content/docs/reference/window.mdx | 12 +-- v3/UNRELEASED_CHANGELOG.md | 1 + 32 files changed, 257 insertions(+), 256 deletions(-) diff --git a/docs/src/content/docs/concepts/architecture.mdx b/docs/src/content/docs/concepts/architecture.mdx index 5b4fdd823..d72affe3b 100644 --- a/docs/src/content/docs/concepts/architecture.mdx +++ b/docs/src/content/docs/concepts/architecture.mdx @@ -264,7 +264,7 @@ Frontend2 -> EventBus: "On('data-updated', handler)" **Example:** ```go // Go: Emit an event -app.EmitEvent("user-logged-in", user) +app.Event.Emit("user-logged-in", user) ``` ```javascript diff --git a/docs/src/content/docs/concepts/bridge.mdx b/docs/src/content/docs/concepts/bridge.mdx index 6ee3745d1..7593d896a 100644 --- a/docs/src/content/docs/concepts/bridge.mdx +++ b/docs/src/content/docs/concepts/bridge.mdx @@ -538,7 +538,7 @@ func ProcessLargeFile(path string) error { for scanner.Scan() { lineNum++ // Emit progress events - app.EmitEvent("file-progress", map[string]interface{}{ + app.Event.Emit("file-progress", map[string]interface{}{ "line": lineNum, "text": scanner.Text(), }) diff --git a/docs/src/content/docs/concepts/build-system.mdx b/docs/src/content/docs/concepts/build-system.mdx index 0ac7d435e..f9de52bc5 100644 --- a/docs/src/content/docs/concepts/build-system.mdx +++ b/docs/src/content/docs/concepts/build-system.mdx @@ -325,7 +325,7 @@ func main() { }, }) - app.NewWebviewWindow() + app.Window.New() app.Run() } ``` diff --git a/docs/src/content/docs/contributing/runtime-internals.mdx b/docs/src/content/docs/contributing/runtime-internals.mdx index 7d35ae91b..a56952627 100644 --- a/docs/src/content/docs/contributing/runtime-internals.mdx +++ b/docs/src/content/docs/contributing/runtime-internals.mdx @@ -39,7 +39,7 @@ win := app.Window.New(&application.WebviewWindowOptions{ win.Show() ``` -`NewWebviewWindow` delegates to `internal/runtime/webview_window_*.go` where +`app.Window.New()` delegates to `internal/runtime/webview_window_*.go` where platform-specific constructors live: ``` diff --git a/docs/src/content/docs/faq.mdx b/docs/src/content/docs/faq.mdx index ffa28275c..3e0a6bd17 100644 --- a/docs/src/content/docs/faq.mdx +++ b/docs/src/content/docs/faq.mdx @@ -123,8 +123,8 @@ Use SignTool with your certificate. Yes! Wails v3 has native multi-window support: ```go -window1 := app.NewWebviewWindow() -window2 := app.NewWebviewWindow() +window1 := app.Window.New() +window2 := app.Window.New() ``` ### Does Wails support system tray? @@ -132,7 +132,7 @@ window2 := app.NewWebviewWindow() Yes! Create system tray applications: ```go -tray := app.NewSystemTray() +tray := app.SystemTray.New() tray.SetIcon(iconBytes) tray.SetMenu(menu) ``` @@ -142,7 +142,7 @@ tray.SetMenu(menu) Yes! Wails provides native dialogs: ```go -path, _ := app.OpenFileDialog(). +path, _ := app.Dialog.OpenFile(). SetTitle("Select File"). PromptForSingleSelection() ``` @@ -194,7 +194,7 @@ wails3 generate bindings Check if you called `Show()`: ```go -window := app.NewWebviewWindow() +window := app.Window.New() window.Show() // Don't forget this! ``` @@ -204,7 +204,7 @@ Ensure event names match exactly: ```go // Go -app.EmitEvent("my-event", data) +app.Event.Emit("my-event", data) // JavaScript OnEvent("my-event", handler) // Must match diff --git a/docs/src/content/docs/features/bindings/best-practices.mdx b/docs/src/content/docs/features/bindings/best-practices.mdx index bfaa77f7e..5b2d71d8d 100644 --- a/docs/src/content/docs/features/bindings/best-practices.mdx +++ b/docs/src/content/docs/features/bindings/best-practices.mdx @@ -274,7 +274,7 @@ func (s *Service) ProcessLargeFile(path string) error { processed++ // Emit progress - s.app.EmitEvent("progress", map[string]interface{}{ + s.app.Event.Emit("progress", map[string]interface{}{ "processed": processed, "total": total, "percent": int(float64(processed) / float64(total) * 100), diff --git a/docs/src/content/docs/features/bindings/methods.mdx b/docs/src/content/docs/features/bindings/methods.mdx index b67f0017c..f8348269d 100644 --- a/docs/src/content/docs/features/bindings/methods.mdx +++ b/docs/src/content/docs/features/bindings/methods.mdx @@ -461,7 +461,7 @@ const config = await GetConfig() func ProcessLargeFile(path string) error { // Emit progress events for line := range lines { - app.EmitEvent("progress", line) + app.Event.Emit("progress", line) } return nil } @@ -530,7 +530,7 @@ func main() { }, }) - app.NewWebviewWindow() + app.Window.New() app.Run() } ``` diff --git a/docs/src/content/docs/features/bindings/models.mdx b/docs/src/content/docs/features/bindings/models.mdx index f177545ae..f393eb694 100644 --- a/docs/src/content/docs/features/bindings/models.mdx +++ b/docs/src/content/docs/features/bindings/models.mdx @@ -628,7 +628,7 @@ func main() { }, }) - app.NewWebviewWindow() + app.Window.New() app.Run() } ``` diff --git a/docs/src/content/docs/features/bindings/services.mdx b/docs/src/content/docs/features/bindings/services.mdx index ace565d66..3d95606c3 100644 --- a/docs/src/content/docs/features/bindings/services.mdx +++ b/docs/src/content/docs/features/bindings/services.mdx @@ -438,7 +438,7 @@ func (o *OrderService) CreateOrder(items []Item) (*Order, error) { } // Emit event - o.app.EmitEvent("order-created", order) + o.app.Event.Emit("order-created", order) return order, nil } @@ -485,7 +485,7 @@ func NewNotificationService(app *application.Application) *NotificationService { func (n *NotificationService) Notify(message string) { // Use application to emit events - n.app.EmitEvent("notification", message) + n.app.Event.Emit("notification", message) // Or show system notification n.app.ShowNotification(message) @@ -780,7 +780,7 @@ func main() { }, }) - app.NewWebviewWindow() + app.Window.New() app.Run() } ``` diff --git a/docs/src/content/docs/features/clipboard/basics.mdx b/docs/src/content/docs/features/clipboard/basics.mdx index 3ecba9c0a..b75570aca 100644 --- a/docs/src/content/docs/features/clipboard/basics.mdx +++ b/docs/src/content/docs/features/clipboard/basics.mdx @@ -64,12 +64,12 @@ await CopyToClipboard("Text to copy") ```go func copyWithFeedback(text string) { if app.Clipboard.SetText(text) { - app.InfoDialog(). + app.Dialog.Info(). SetTitle("Copied"). SetMessage("Text copied to clipboard!"). Show() } else { - app.ErrorDialog(). + app.Dialog.Error(). SetTitle("Copy Failed"). SetMessage("Failed to copy to clipboard."). Show() @@ -296,7 +296,7 @@ func (cm *ClipboardMonitor) checkClipboard() { if text != cm.lastText { cm.lastText = text - cm.app.EmitEvent("clipboard-changed", text) + cm.app.Event.Emit("clipboard-changed", text) } } ``` diff --git a/docs/src/content/docs/features/dialogs/custom.mdx b/docs/src/content/docs/features/dialogs/custom.mdx index 8cb354772..591d68db2 100644 --- a/docs/src/content/docs/features/dialogs/custom.mdx +++ b/docs/src/content/docs/features/dialogs/custom.mdx @@ -14,7 +14,7 @@ Create **custom dialog windows** using regular Wails windows with dialog-like be ```go // Create custom dialog window -dialog := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +dialog := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Custom dialog", Width: 400, Height: 300, @@ -48,7 +48,7 @@ func NewCustomdialog(app *application.Application) *Customdialog { result: make(chan string, 1), } - dialog.window = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + dialog.window = app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Custom dialog", Width: 400, Height: 300, @@ -79,7 +79,7 @@ func (d *Customdialog) Close(result string) { ```go func ShowModaldialog(parent *application.WebviewWindow, title string) string { // Create dialog - dialog := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + dialog := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: title, Width: 400, Height: 200, @@ -119,7 +119,7 @@ func NewFormdialog(app *application.Application) *Formdialog { done: make(chan bool, 1), } - fd.window = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + fd.window = app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Enter Information", Width: 500, Height: 400, @@ -156,7 +156,7 @@ func (fd *Formdialog) Cancel() { ```go func ShowConfirmdialog(message string) bool { - dialog := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + dialog := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Confirm", Width: 400, Height: 150, @@ -172,12 +172,12 @@ func ShowConfirmdialog(message string) bool { result := make(chan bool, 1) // Handle responses - app.OnEvent("confirm-yes", func(e *application.CustomEvent) { + app.Event.On("confirm-yes", func(e *application.CustomEvent) { result <- true dialog.Close() }) - app.OnEvent("confirm-no", func(e *application.CustomEvent) { + app.Event.On("confirm-no", func(e *application.CustomEvent) { result <- false dialog.Close() }) @@ -215,7 +215,7 @@ function confirm(result) { ```go func ShowInputdialog(prompt string, defaultValue string) (string, bool) { - dialog := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + dialog := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Input", Width: 400, Height: 150, @@ -234,7 +234,7 @@ func ShowInputdialog(prompt string, defaultValue string) (string, bool) { }) }) - app.OnEvent("input-submit", func(e *application.CustomEvent) { + app.Event.On("input-submit", func(e *application.CustomEvent) { result <- struct { value string ok bool @@ -242,7 +242,7 @@ func ShowInputdialog(prompt string, defaultValue string) (string, bool) { dialog.Close() }) - app.OnEvent("input-cancel", func(e *application.CustomEvent) { + app.Event.On("input-cancel", func(e *application.CustomEvent) { result <- struct { value string ok bool @@ -266,7 +266,7 @@ type Progressdialog struct { func NewProgressdialog(title string) *Progressdialog { pd := &Progressdialog{} - pd.window = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + pd.window = app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: title, Width: 400, Height: 150, @@ -336,7 +336,7 @@ func NewLogindialog(app *application.Application) *Logindialog { }, 1), } - ld.window = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + ld.window = app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Login", Width: 400, Height: 250, @@ -421,7 +421,7 @@ func NewSettingsdialog(app *application.Application, current map[string]interfac done: make(chan bool, 1), } - sd.window = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + sd.window = app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Settings", Width: 600, Height: 500, @@ -470,7 +470,7 @@ func NewWizarddialog(app *application.Application) *Wizarddialog { done: make(chan bool, 1), } - wd.window = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + wd.window = app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Setup Wizard", Width: 600, Height: 400, diff --git a/docs/src/content/docs/features/drag-and-drop/files.mdx b/docs/src/content/docs/features/drag-and-drop/files.mdx index 6d53d7934..ffc75093a 100644 --- a/docs/src/content/docs/features/drag-and-drop/files.mdx +++ b/docs/src/content/docs/features/drag-and-drop/files.mdx @@ -115,7 +115,7 @@ window.OnWindowEvent(events.Common.WindowFilesDropped, func(event *application.W details := event.Context().DropTargetDetails() // Send to frontend - app.EmitEvent("files-dropped", map[string]any{ + app.Event.Emit("files-dropped", map[string]any{ "files": files, "target": details.ElementID, }) diff --git a/docs/src/content/docs/features/events/system.mdx b/docs/src/content/docs/features/events/system.mdx index f55ffca03..259add09c 100644 --- a/docs/src/content/docs/features/events/system.mdx +++ b/docs/src/content/docs/features/events/system.mdx @@ -16,7 +16,7 @@ Wails provides a **unified event system** for pub/sub communication. Emit events **Go (emit):** ```go -app.EmitEvent("user-logged-in", map[string]interface{}{ +app.Event.Emit("user-logged-in", map[string]interface{}{ "userId": 123, "name": "Alice", }) @@ -42,9 +42,9 @@ Your application-specific events: ```go // Emit from Go -app.EmitEvent("order-created", order) -app.EmitEvent("payment-processed", payment) -app.EmitEvent("notification", message) +app.Event.Emit("order-created", order) +app.Event.Emit("payment-processed", payment) +app.Event.Emit("notification", message) ``` ```javascript @@ -62,14 +62,14 @@ Built-in OS and application events: import "github.com/wailsapp/wails/v3/pkg/events" // Theme changes -app.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { if e.Context().IsDarkMode() { app.Logger.Info("Dark mode enabled") } }) // Application lifecycle -app.OnApplicationEvent(events.Common.ApplicationStarted, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(events.Common.ApplicationStarted, func(e *application.ApplicationEvent) { app.Logger.Info("Application started") }) ``` @@ -95,29 +95,29 @@ window.OnWindowEvent(events.Common.WindowClosing, func(e *application.WindowEven **Basic emit:** ```go -app.EmitEvent("event-name", data) +app.Event.Emit("event-name", data) ``` **With different data types:** ```go // String -app.EmitEvent("message", "Hello") +app.Event.Emit("message", "Hello") // Number -app.EmitEvent("count", 42) +app.Event.Emit("count", 42) // Struct -app.EmitEvent("user", User{ID: 1, Name: "Alice"}) +app.Event.Emit("user", User{ID: 1, Name: "Alice"}) // Map -app.EmitEvent("config", map[string]interface{}{ +app.Event.Emit("config", map[string]interface{}{ "theme": "dark", "fontSize": 14, }) // Array -app.EmitEvent("items", []string{"a", "b", "c"}) +app.Event.Emit("items", []string{"a", "b", "c"}) ``` **To specific window:** @@ -145,7 +145,7 @@ Emit("broadcast-message", "Hello everyone") **Application events:** ```go -app.OnEvent("custom-event", func(e *application.CustomEvent) { +app.Event.On("custom-event", func(e *application.CustomEvent) { data := e.Data // Handle event }) @@ -154,7 +154,7 @@ app.OnEvent("custom-event", func(e *application.CustomEvent) { **With type assertion:** ```go -app.OnEvent("user-updated", func(e *application.CustomEvent) { +app.Event.On("user-updated", func(e *application.CustomEvent) { user := e.Data.(User) app.Logger.Info("User updated", "name", user.Name) }) @@ -164,9 +164,9 @@ app.OnEvent("user-updated", func(e *application.CustomEvent) { ```go // All handlers will be called -app.OnEvent("order-created", logOrder) -app.OnEvent("order-created", sendEmail) -app.OnEvent("order-created", updateInventory) +app.Event.On("order-created", logOrder) +app.Event.On("order-created", sendEmail) +app.Event.On("order-created", updateInventory) ``` ### In JavaScript @@ -208,18 +208,18 @@ OnEvent("data-updated", logChange) import "github.com/wailsapp/wails/v3/pkg/events" // Application started -app.OnApplicationEvent(events.Common.ApplicationStarted, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(events.Common.ApplicationStarted, func(e *application.ApplicationEvent) { app.Logger.Info("App started") }) // Theme changed -app.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { isDark := e.Context().IsDarkMode() - app.EmitEvent("theme-changed", isDark) + app.Event.Emit("theme-changed", isDark) }) // File opened -app.OnApplicationEvent(events.Common.ApplicationOpenedWithFile, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(events.Common.ApplicationOpenedWithFile, func(e *application.ApplicationEvent) { filePath := e.Context().OpenedFile() openFile(filePath) }) @@ -231,12 +231,12 @@ app.OnApplicationEvent(events.Common.ApplicationOpenedWithFile, func(e *applicat ```go // Application became active - app.OnApplicationEvent(events.Mac.ApplicationDidBecomeActive, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(events.Mac.ApplicationDidBecomeActive, func(e *application.ApplicationEvent) { app.Logger.Info("App became active") }) // Application will terminate - app.OnApplicationEvent(events.Mac.ApplicationWillTerminate, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(events.Mac.ApplicationWillTerminate, func(e *application.ApplicationEvent) { cleanup() }) ``` @@ -245,12 +245,12 @@ app.OnApplicationEvent(events.Common.ApplicationOpenedWithFile, func(e *applicat ```go // Power status changed - app.OnApplicationEvent(events.Windows.APMPowerStatusChange, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(events.Windows.APMPowerStatusChange, func(e *application.ApplicationEvent) { app.Logger.Info("Power status changed") }) // System suspending - app.OnApplicationEvent(events.Windows.APMSuspend, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(events.Windows.APMSuspend, func(e *application.ApplicationEvent) { saveState() }) ``` @@ -259,12 +259,12 @@ app.OnApplicationEvent(events.Common.ApplicationOpenedWithFile, func(e *applicat ```go // Application startup - app.OnApplicationEvent(events.Linux.ApplicationStartup, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(events.Linux.ApplicationStartup, func(e *application.ApplicationEvent) { app.Logger.Info("App starting") }) // Theme changed - app.OnApplicationEvent(events.Linux.SystemThemeChanged, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(events.Linux.SystemThemeChanged, func(e *application.ApplicationEvent) { updateTheme() }) ``` @@ -347,23 +347,23 @@ func (o *OrderService) CreateOrder(items []Item) (*Order, error) { } // Publish event - o.app.EmitEvent("order-created", order) + o.app.Event.Emit("order-created", order) return order, nil } // Subscribers -app.OnEvent("order-created", func(e *application.CustomEvent) { +app.Event.On("order-created", func(e *application.CustomEvent) { order := e.Data.(*Order) sendConfirmationEmail(order) }) -app.OnEvent("order-created", func(e *application.CustomEvent) { +app.Event.On("order-created", func(e *application.CustomEvent) { order := e.Data.(*Order) updateInventory(order) }) -app.OnEvent("order-created", func(e *application.CustomEvent) { +app.Event.On("order-created", func(e *application.CustomEvent) { order := e.Data.(*Order) logOrder(order) }) @@ -376,14 +376,14 @@ app.OnEvent("order-created", func(e *application.CustomEvent) { Emit("get-user-data", { userId: 123 }) // Backend responds -app.OnEvent("get-user-data", func(e *application.CustomEvent) { +app.Event.On("get-user-data", func(e *application.CustomEvent) { data := e.Data.(map[string]interface{}) userId := int(data["userId"].(float64)) user := getUserFromDB(userId) // Send response - app.EmitEvent("user-data-response", user) + app.Event.Emit("user-data-response", user) }) // Frontend receives response @@ -398,7 +398,7 @@ OnEvent("user-data-response", (user) => { ```go // Broadcast to all windows -app.EmitEvent("global-notification", "System update available") +app.Event.Emit("global-notification", "System update available") // Each window handles it OnEvent("global-notification", (message) => { @@ -422,7 +422,7 @@ func (ea *EventAggregator) Add(event Event) { // Emit batch every 100 events if len(ea.events) >= 100 { - app.EmitEvent("event-batch", ea.events) + app.Event.Emit("event-batch", ea.events) ea.events = nil } } @@ -446,7 +446,7 @@ type NotificationService struct { func (n *NotificationService) Notify(message string) { // Emit to all windows - n.app.EmitEvent("notification", map[string]interface{}{ + n.app.Event.Emit("notification", map[string]interface{}{ "message": message, "timestamp": time.Now(), }) @@ -460,13 +460,13 @@ func main() { notifService := &NotificationService{app: app} // System events - app.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { isDark := e.Context().IsDarkMode() - app.EmitEvent("theme-changed", isDark) + app.Event.Emit("theme-changed", isDark) }) // Custom events from frontend - app.OnEvent("user-action", func(e *application.CustomEvent) { + app.Event.On("user-action", func(e *application.CustomEvent) { data := e.Data.(map[string]interface{}) action := data["action"].(string) @@ -477,15 +477,15 @@ func main() { }) // Window events - window := app.NewWebviewWindow() + window := app.Window.New() window.OnWindowEvent(events.Common.WindowFocus, func(e *application.WindowEvent) { - app.EmitEvent("window-focused", window.Name()) + app.Event.Emit("window-focused", window.Name()) }) window.RegisterHook(events.Common.WindowClosing, func(e *application.WindowEvent) { // Confirm before close - app.EmitEvent("confirm-close", nil) + app.Event.Emit("confirm-close", nil) e.Cancel() // Wait for confirmation }) diff --git a/docs/src/content/docs/features/menus/application.mdx b/docs/src/content/docs/features/menus/application.mdx index 92d9ff74a..9e39e5caf 100644 --- a/docs/src/content/docs/features/menus/application.mdx +++ b/docs/src/content/docs/features/menus/application.mdx @@ -60,7 +60,7 @@ func main() { app.SetMenu(menu) // Create window and run - app.NewWebviewWindow() + app.Window.New() app.Run() } ``` @@ -487,7 +487,7 @@ func main() { createMenu(app) // Create main window - app.NewWebviewWindow() + app.Window.New() app.Run() } diff --git a/docs/src/content/docs/features/menus/context.mdx b/docs/src/content/docs/features/menus/context.mdx index 3321cc85d..ab7eb630a 100644 --- a/docs/src/content/docs/features/menus/context.mdx +++ b/docs/src/content/docs/features/menus/context.mdx @@ -482,7 +482,7 @@ func main() { textMenu := createTextMenu(app) app.RegisterContextMenu("text-menu", textMenu) - app.NewWebviewWindow() + app.Window.New() app.Run() } diff --git a/docs/src/content/docs/features/menus/systray.mdx b/docs/src/content/docs/features/menus/systray.mdx index beb81393d..a0c8a722b 100644 --- a/docs/src/content/docs/features/menus/systray.mdx +++ b/docs/src/content/docs/features/menus/systray.mdx @@ -38,7 +38,7 @@ func main() { }) // Create system tray - systray := app.NewSystemTray() + systray := app.SystemTray.New() systray.SetIcon(icon) systray.SetLabel("My App") @@ -53,7 +53,7 @@ func main() { systray.SetMenu(menu) // Create hidden window - window := app.NewWebviewWindow() + window := app.Window.New() window.Hide() app.Run() @@ -68,7 +68,7 @@ func main() { ```go // Create system tray -systray := app.NewSystemTray() +systray := app.SystemTray.New() // Set icon systray.SetIcon(iconBytes) @@ -95,7 +95,7 @@ func main() { Name: "My App", }) - systray := app.NewSystemTray() + systray := app.SystemTray.New() systray.SetIcon(icon) systray.SetDarkModeIcon(iconDark) // macOS dark mode @@ -162,7 +162,7 @@ Attach a window to the tray icon for automatic show/hide: ```go // Create window -window := app.NewWebviewWindow() +window := app.Window.New() // Attach to tray systray.AttachWindow(window) @@ -181,7 +181,7 @@ systray.SetWindowDebounce(200 * time.Millisecond) // Click debounce **Example: Popup window** ```go -window := app.NewWebviewWindow(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Quick Access", Width: 300, Height: 400, @@ -198,7 +198,7 @@ systray.SetWindowOffset(5) Handle tray icon clicks: ```go -systray := app.NewSystemTray() +systray := app.SystemTray.New() // Left click systray.OnClick(func() { @@ -445,7 +445,7 @@ func main() { func (t *TrayApp) setup() { // Create system tray - t.systray = t.app.NewSystemTray() + t.systray = t.app.SystemTray.New() t.systray.SetIcon(icon) t.systray.SetLabel("Inactive") @@ -453,7 +453,7 @@ func (t *TrayApp) setup() { t.createMenu() // Create window (hidden by default) - t.window = t.app.NewWebviewWindow(application.WebviewWindowOptions{ + t.window = t.app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Tray Application", Width: 400, Height: 600, diff --git a/docs/src/content/docs/features/screens/info.mdx b/docs/src/content/docs/features/screens/info.mdx index 98c744f88..a1ade0a27 100644 --- a/docs/src/content/docs/features/screens/info.mdx +++ b/docs/src/content/docs/features/screens/info.mdx @@ -266,7 +266,7 @@ func (m *MultiMonitorManager) CreateWindowOnScreen(screenIndex int) error { screen := screens[screenIndex] // Create window - window := m.app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := m.app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: fmt.Sprintf("Window on %s", screen.Name), Width: 800, Height: 600, @@ -346,7 +346,7 @@ func createDPIAwareWindow(screen *Screen) *application.WebviewWindow { width := int(float32(baseWidth) * screen.ScaleFactor) height := int(float32(baseHeight) * screen.ScaleFactor) - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "DPI-Aware Window", Width: width, Height: height, diff --git a/docs/src/content/docs/features/windows/basics.mdx b/docs/src/content/docs/features/windows/basics.mdx index 3137111ac..54bbb04fa 100644 --- a/docs/src/content/docs/features/windows/basics.mdx +++ b/docs/src/content/docs/features/windows/basics.mdx @@ -24,7 +24,7 @@ func main() { }) // Create a window - window := app.NewWebviewWindow() + window := app.Window.New() // Configure it window.SetTitle("Hello Wails") @@ -47,7 +47,7 @@ func main() { The simplest way to create a window: ```go -window := app.NewWebviewWindow() +window := app.Window.New() ``` **What you get:** @@ -61,7 +61,7 @@ window := app.NewWebviewWindow() Create a window with custom configuration: ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "My Application", Width: 1200, Height: 800, @@ -101,7 +101,7 @@ window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ Give windows names for easy retrieval: ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "main-window", Title: "Main Application", }) @@ -259,7 +259,7 @@ foundWindow := app.GetWindowByID(id) Get the currently focused window: ```go -current := app.CurrentWindow() +current := app.Window.Current() if current != nil { current.SetTitle("Active Window") } @@ -270,7 +270,7 @@ if current != nil { Get all windows: ```go -windows := app.GetAllWindows() +windows := app.Window.GetAll() fmt.Printf("Total windows: %d\n", len(windows)) for _, w := range windows { @@ -323,7 +323,7 @@ window.OnDestroy(func() { ```go // Main window -mainWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +mainWindow := app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "main", Title: "Main Application", Width: 1200, @@ -331,7 +331,7 @@ mainWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ }) // Settings window -settingsWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +settingsWindow := app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "settings", Title: "Settings", Width: 600, @@ -349,12 +349,12 @@ Windows can communicate via events: ```go // In main window -app.EmitEvent("data-updated", map[string]interface{}{ +app.Event.Emit("data-updated", map[string]interface{}{ "value": 42, }) // In settings window -app.OnEvent("data-updated", func(event *application.WailsEvent) { +app.Event.On("data-updated", func(event *application.WailsEvent) { data := event.Data.(map[string]interface{}) value := data["value"].(int) fmt.Printf("Received: %d\n", value) @@ -367,7 +367,7 @@ app.OnEvent("data-updated", func(event *application.WailsEvent) { ```go // Create child window -childWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +childWindow := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Child Window", Parent: mainWindow, // Set parent }) @@ -413,7 +413,7 @@ childWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ ```go // Transparent title bar - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Mac: application.MacWindow{ TitleBar: application.MacTitleBar{ AppearsTransparent: true, @@ -442,7 +442,7 @@ childWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ ```go // Set window icon - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Linux: application.LinuxOptions{ Icon: iconBytes, }, @@ -467,7 +467,7 @@ childWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ ```go // Create splash screen -splash := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +splash := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Loading...", Width: 400, Height: 300, @@ -493,7 +493,7 @@ var settingsWindow *application.WebviewWindow func showSettings() { if settingsWindow == nil { - settingsWindow = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + settingsWindow = app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "settings", Title: "Settings", Width: 600, diff --git a/docs/src/content/docs/features/windows/events.mdx b/docs/src/content/docs/features/windows/events.mdx index 8d3ba317d..b45c6596c 100644 --- a/docs/src/content/docs/features/windows/events.mdx +++ b/docs/src/content/docs/features/windows/events.mdx @@ -74,7 +74,7 @@ window.OnClose(func() bool { } // Show confirmation dialog - dialog := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + dialog := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Confirm Close", Width: 400, Height: 150, @@ -164,7 +164,7 @@ window.OnFocus(func() { refreshContent() // Notify other windows - app.EmitEvent("window-focused", window.ID()) + app.Event.Emit("window-focused", window.ID()) }) ``` @@ -437,7 +437,7 @@ func main() { } func (mw *ManagedWindow) CreateWindow() { - mw.window = mw.app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + mw.window = mw.app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "main", Title: "Event Demo", Width: 800, @@ -566,11 +566,11 @@ Coordinate between multiple windows: // In main window mainWindow.OnFocus(func() { // Notify all windows - app.EmitEvent("main-window-focused", nil) + app.Event.Emit("main-window-focused", nil) }) // In other windows -app.OnEvent("main-window-focused", func(event *application.WailsEvent) { +app.Event.On("main-window-focused", func(event *application.WailsEvent) { // Update UI updateRelativeToMain() }) @@ -589,7 +589,7 @@ window.OnMaximise(func() { window.EmitEvent("layout-changed", "maximised") // Notify other windows - app.EmitEvent("window-maximised", window.ID()) + app.Event.Emit("window-maximised", window.ID()) }) ``` @@ -656,7 +656,7 @@ window.Destroy() ```go // Register handlers immediately after creation -window := app.NewWebviewWindow() +window := app.Window.New() window.OnClose(func() bool { return true }) ``` diff --git a/docs/src/content/docs/features/windows/frameless.mdx b/docs/src/content/docs/features/windows/frameless.mdx index 4c6b266f8..c13cb9d4d 100644 --- a/docs/src/content/docs/features/windows/frameless.mdx +++ b/docs/src/content/docs/features/windows/frameless.mdx @@ -14,7 +14,7 @@ Wails provides **frameless window support** with CSS-based drag regions and plat ## Quick Start ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Frameless App", Width: 800, Height: 600, @@ -52,7 +52,7 @@ window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ ### Basic Frameless Window ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Frameless: true, Width: 800, Height: 600, @@ -73,7 +73,7 @@ window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ ### With Transparent Background ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Frameless: true, BackgroundType: application.BackgroundTypeTransparent, }) @@ -336,7 +336,7 @@ body { **Windows frameless windows:** ```go - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Frameless: true, Windows: application.WindowsOptions{ DisableFramelessWindowDecorations: false, @@ -371,7 +371,7 @@ body { **macOS frameless windows:** ```go - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Frameless: true, Mac: application.MacOptions{ TitleBarAppearsTransparent: true, @@ -406,7 +406,7 @@ body { **Linux frameless windows:** ```go - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Frameless: true, }) ``` @@ -500,7 +500,7 @@ body { ### Pattern 2: Splash Screen ```go -splash := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +splash := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Loading...", Width: 400, Height: 300, @@ -530,7 +530,7 @@ body { ### Pattern 3: Rounded Window ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Frameless: true, BackgroundType: application.BackgroundTypeTransparent, }) @@ -560,7 +560,7 @@ body { ### Pattern 4: Overlay Window ```go -overlay := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +overlay := app.Window.NewWithOptions(application.WebviewWindowOptions{ Frameless: true, AlwaysOnTop: true, BackgroundType: application.BackgroundTypeTransparent, @@ -602,7 +602,7 @@ func main() { Name: "Frameless App", }) - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Frameless Application", Width: 1000, Height: 700, diff --git a/docs/src/content/docs/features/windows/multiple.mdx b/docs/src/content/docs/features/windows/multiple.mdx index 3fa42abb7..41d5a18fe 100644 --- a/docs/src/content/docs/features/windows/multiple.mdx +++ b/docs/src/content/docs/features/windows/multiple.mdx @@ -32,7 +32,7 @@ func main() { }) // Create main window - app.mainWindow = app.app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + app.mainWindow = app.app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "main", Title: "Main Application", Width: 1200, @@ -40,7 +40,7 @@ func main() { }) // Create settings window (hidden initially) - app.settingsWindow = app.app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + app.settingsWindow = app.app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "settings", Title: "Settings", Width: 600, @@ -71,7 +71,7 @@ func (a *App) ShowSettings() { ### Get All Windows ```go -windows := app.GetAllWindows() +windows := app.Window.GetAll() fmt.Printf("Total windows: %d\n", len(windows)) for _, window := range windows { @@ -92,7 +92,7 @@ if settings != nil { window := app.GetWindowByID(123) // Current (focused) window -current := app.CurrentWindow() +current := app.Window.Current() ``` ### Window Registry Pattern @@ -132,13 +132,13 @@ Windows communicate via the event system: ```go // In main window - emit event -app.EmitEvent("settings-changed", map[string]interface{}{ +app.Event.Emit("settings-changed", map[string]interface{}{ "theme": "dark", "fontSize": 14, }) // In settings window - listen for event -app.OnEvent("settings-changed", func(event *application.WailsEvent) { +app.Event.On("settings-changed", func(event *application.WailsEvent) { data := event.Data.(map[string]interface{}) theme := data["theme"].(string) fontSize := data["fontSize"].(int) @@ -170,7 +170,7 @@ func (s *AppState) SetTheme(theme string) { s.mu.Unlock() // Notify all windows - app.EmitEvent("theme-changed", theme) + app.Event.Emit("theme-changed", theme) } func (s *AppState) GetTheme() string { @@ -204,7 +204,7 @@ var settingsWindow *application.WebviewWindow func ShowSettings(app *application.Application) { // Create if doesn't exist if settingsWindow == nil { - settingsWindow = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + settingsWindow = app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "settings", Title: "Settings", Width: 600, @@ -245,7 +245,7 @@ func OpenDocument(app *application.Application, filePath string) { } // Create new document window - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: filepath.Base(filePath), Width: 800, Height: 600, @@ -275,7 +275,7 @@ Floating windows that stay on top: ```go func CreateToolPalette(app *application.Application) *application.WebviewWindow { - palette := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + palette := app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "tools", Title: "Tools", Width: 200, @@ -294,7 +294,7 @@ Child windows that block parent: ```go func ShowModaldialog(parent *application.WebviewWindow, title string) { - dialog := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + dialog := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: title, Width: 400, Height: 200, @@ -332,7 +332,7 @@ func (e *EditorApp) UpdatePreview(content string) { func (e *EditorApp) TogglePreview() { if e.preview == nil { - e.preview = app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + e.preview = app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "preview", Title: "Preview", Width: 600, @@ -357,7 +357,7 @@ func (e *EditorApp) TogglePreview() { ### Creating Child Windows ```go -childWindow := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +childWindow := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Child Window", Parent: parentWindow, }) @@ -382,7 +382,7 @@ Create modal-like behaviour: ```go func ShowModal(parent *application.WebviewWindow) { - modal := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + modal := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Modal dialog", Width: 400, Height: 200, @@ -463,7 +463,7 @@ Always clean up window references: var windows = make(map[string]*application.WebviewWindow) func CreateWindow(name string) { - window := app.NewWebviewWindow() + window := app.Window.New() windows[name] = window // IMPORTANT: Clean up on destroy @@ -530,7 +530,7 @@ func (wp *WindowPool) Acquire() *application.WebviewWindow { } // Create new window - window := app.NewWebviewWindow() + window := app.Window.New() wp.inUse[window.ID()] = window return window } @@ -598,7 +598,7 @@ type WindowState struct { func SaveLayout() *WindowLayout { layout := &WindowLayout{} - for _, window := range app.GetAllWindows() { + for _, window := range app.Window.GetAll() { x, y := window.Position() width, height := window.Size() @@ -667,7 +667,7 @@ func main() { } func (mwa *MultiWindowApp) CreateMainWindow() { - window := mwa.app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := mwa.app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "main", Title: "Main Application", Width: 1200, @@ -684,7 +684,7 @@ func (mwa *MultiWindowApp) ShowSettings() { return } - window := mwa.app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := mwa.app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "settings", Title: "Settings", Width: 600, @@ -703,7 +703,7 @@ func (mwa *MultiWindowApp) OpenDocument(path string) { return } - window := mwa.app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := mwa.app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: name, Title: path, Width: 800, diff --git a/docs/src/content/docs/features/windows/options.mdx b/docs/src/content/docs/features/windows/options.mdx index d2f338fc9..b7cea7f85 100644 --- a/docs/src/content/docs/features/windows/options.mdx +++ b/docs/src/content/docs/features/windows/options.mdx @@ -86,7 +86,7 @@ Name: "main-window" **Example:** ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "settings-window", }) @@ -161,7 +161,7 @@ Y: 100, // 100px from top edge **Example:** ```go -settings := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +settings := app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "coordinate-window", InitialPosition: application.WindowXY, // use coordinate system X: 100, @@ -171,7 +171,7 @@ settings := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ **Best practice:** Use `Center()` to center the window: ```go -window := app.NewWebviewWindow() +window := app.Window.New() window.Center() ``` @@ -248,7 +248,7 @@ Hidden: true, ```go // Create hidden window -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "main-window", Hidden: true, BackgroundColour: application.RGBA{R: 30, G: 30, B: 30, A: 255}, // Match your theme @@ -264,7 +264,7 @@ window.Show() **Example:** ```go -settings := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +settings := app.Window.NewWithOptions(application.WebviewWindowOptions{ Name: "settings", Hidden: true, }) @@ -574,7 +574,7 @@ When enabled: **Example:** ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "File Uploader", EnableFileDrop: true, }) @@ -635,7 +635,7 @@ ContentProtectionEnabled: true, **Example:** ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Secure Window", ContentProtectionEnabled: true, }) @@ -892,7 +892,7 @@ func main() { Name: "My Application", }) - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ // Identity Name: "main-window", Title: "My Application", diff --git a/docs/src/content/docs/guides/distribution/custom-protocols.mdx b/docs/src/content/docs/guides/distribution/custom-protocols.mdx index 760e8e2d8..39a9b157c 100644 --- a/docs/src/content/docs/guides/distribution/custom-protocols.mdx +++ b/docs/src/content/docs/guides/distribution/custom-protocols.mdx @@ -42,7 +42,7 @@ func main() { }) // Register handler for protocol events - app.OnEvent(application.Events.ApplicationOpenedWithURL, func(event *application.ApplicationEvent) { + app.Event.On(application.Events.ApplicationOpenedWithURL, func(event *application.ApplicationEvent) { url := event.Context().ClickedURL() handleCustomURL(url) }) @@ -62,7 +62,7 @@ func handleCustomURL(url string) { Listen for protocol events to handle incoming URLs: ```go -app.OnEvent(application.Events.ApplicationOpenedWithURL, func(event *application.ApplicationEvent) { +app.Event.On(application.Events.ApplicationOpenedWithURL, func(event *application.ApplicationEvent) { url := event.Context().ClickedURL() // Parse the URL @@ -362,7 +362,7 @@ func main() { func (a *App) setup() { // Create window - a.window = a.app.NewWebviewWindow(application.WebviewWindowOptions{ + a.window = a.app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "DeepLink Demo", Width: 800, Height: 600, @@ -370,7 +370,7 @@ func (a *App) setup() { }) // Handle custom protocol URLs - a.app.OnEvent(application.Events.ApplicationOpenedWithURL, func(event *application.ApplicationEvent) { + a.app.Event.On(application.Events.ApplicationOpenedWithURL, func(event *application.ApplicationEvent) { customURL := event.Context().ClickedURL() a.handleDeepLink(customURL) }) diff --git a/docs/src/content/docs/guides/performance.mdx b/docs/src/content/docs/guides/performance.mdx index 9b4f28064..1d38a1ef4 100644 --- a/docs/src/content/docs/guides/performance.mdx +++ b/docs/src/content/docs/guides/performance.mdx @@ -116,10 +116,10 @@ func (s *Service) ProcessLargeFile(path string) error { go func() { result, err := s.process(path) if err != nil { - s.app.EmitEvent("process-error", err.Error()) + s.app.Event.Emit("process-error", err.Error()) return } - s.app.EmitEvent("process-complete", result) + s.app.Event.Emit("process-complete", result) }() return nil diff --git a/docs/src/content/docs/guides/raw-messages.mdx b/docs/src/content/docs/guides/raw-messages.mdx index 72b067102..5f2a7a653 100644 --- a/docs/src/content/docs/guides/raw-messages.mdx +++ b/docs/src/content/docs/guides/raw-messages.mdx @@ -47,7 +47,7 @@ func main() { }, }) - app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "My App", Name: "main", }) @@ -291,7 +291,7 @@ func main() { }, }) - app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "Raw Message Demo", Name: "main", Width: 400, @@ -382,7 +382,7 @@ RawMessageHandler: func(window application.Window, message string, originInfo *a window.EmitEvent("response", result) // Or broadcast to all windows - app.EmitEvent("broadcast", result) + app.Event.Emit("broadcast", result) } ``` diff --git a/docs/src/content/docs/migration/v2-to-v3.mdx b/docs/src/content/docs/migration/v2-to-v3.mdx index 6fea62912..5eb94ca67 100644 --- a/docs/src/content/docs/migration/v2-to-v3.mdx +++ b/docs/src/content/docs/migration/v2-to-v3.mdx @@ -49,7 +49,7 @@ app := application.New(application.Options{ }, }) -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "My App", Width: 1024, Height: 768, @@ -137,12 +137,12 @@ type MyService struct { } func (s *MyService) UpdateTitle() { - window := s.app.CurrentWindow() + window := s.app.Window.Current() window.SetTitle("New Title") } func (s *MyService) EmitEvent() { - s.app.EmitEvent("event-name", data) + s.app.Event.Emit("event-name", data) } ``` @@ -203,19 +203,19 @@ runtime.EventsEmit(ctx, "event-name", data) **v3:** ```go -app.OnEvent("event-name", func(e *application.CustomEvent) { +app.Event.On("event-name", func(e *application.CustomEvent) { data := e.Data // Handle event }) -app.EmitEvent("event-name", data) +app.Event.Emit("event-name", data) ``` **Why this is better:** - **Type safety**: Events use proper event objects instead of `...interface{}` - **Better debugging**: Event objects contain metadata like event name, making debugging easier -- **Clearer API**: `app.OnEvent()` and `app.EmitEvent()` are more intuitive than runtime functions +- **Clearer API**: `app.Event.On()` and `app.Event.Emit()` are more intuitive than runtime functions - **No context needed**: Events work directly on the app object without threading context - **Simpler handlers**: Event handlers have a clear signature instead of variadic parameters @@ -236,10 +236,10 @@ runtime.WindowSetSize(ctx, 800, 600) ```go // Multiple windows supported -window1 := app.NewWebviewWindow() +window1 := app.Window.New() window1.SetSize(800, 600) -window2 := app.NewWebviewWindow() +window2 := app.Window.New() window2.SetSize(1024, 768) ``` @@ -339,7 +339,7 @@ func main() { }, }) - app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "My App", Width: 1024, Height: 768, @@ -416,10 +416,10 @@ func (a *App) DoSomething() { ```go func (s *MyService) DoSomething() { - window := s.app.CurrentWindow() + window := s.app.Window.Current() window.SetTitle("New Title") - s.app.EmitEvent("update", data) + s.app.Event.Emit("update", data) s.app.Logger.Info("Message") } @@ -510,7 +510,7 @@ selection, err := runtime.OpenFileDialog(ctx, runtime.OpenDialogOptions{ **v3:** ```go -selection, err := app.OpenFileDialog(application.OpenFileDialogOptions{ +selection, err := app.Dialog.OpenFile(application.OpenFileDialogOptions{ Title: "Select File", }) ``` @@ -549,7 +549,7 @@ fileMenu.Add("Quit").OnClick(func(ctx *application.Context) { **v3:** ```go -systray := app.NewSystemTray() +systray := app.SystemTray.New() systray.SetIcon(iconBytes) systray.SetLabel("My App") @@ -602,7 +602,7 @@ func NewMyService(app *application.Application) *MyService { Use window methods directly: ```go -window := s.app.CurrentWindow() +window := s.app.Window.Current() window.SetTitle("New Title") ``` @@ -616,7 +616,7 @@ Check event names match exactly: ```go // Go -app.EmitEvent("my-event", data) +app.Event.Emit("my-event", data) // JavaScript OnEvent("my-event", handler) // Must match exactly diff --git a/docs/src/content/docs/reference/application.mdx b/docs/src/content/docs/reference/application.mdx index 050578a62..0fbc63b02 100644 --- a/docs/src/content/docs/reference/application.mdx +++ b/docs/src/content/docs/reference/application.mdx @@ -80,33 +80,33 @@ fmt.Println("App name:", config.Name) ## Window Management -### NewWebviewWindow() +### app.Window.New() Creates a new webview window with default options. ```go -func (a *App) NewWebviewWindow() *WebviewWindow +func (wm *WindowManager) New() *WebviewWindow ``` **Example:** ```go -window := app.NewWebviewWindow() +window := app.Window.New() window.Show() ``` -### NewWebviewWindowWithOptions() +### app.Window.NewWithOptions() Creates a new webview window with custom options. ```go -func (a *App) NewWebviewWindowWithOptions(options WebviewWindowOptions) *WebviewWindow +func (wm *WindowManager) NewWithOptions(options WebviewWindowOptions) *WebviewWindow ``` **Example:** ```go -window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "My Window", Width: 800, Height: 600, @@ -114,35 +114,35 @@ window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ }) ``` -### GetWindowByName() +### app.Window.GetByName() Gets a window by its name. ```go -func (a *App) GetWindowByName(name string) Window +func (wm *WindowManager) GetByName(name string) Window ``` **Example:** ```go -window := app.GetWindowByName("main") +window := app.Window.GetByName("main") if window != nil { window.Show() } ``` -### GetWindows() +### app.Window.GetAll() Returns all application windows. ```go -func (a *App) GetWindows() []Window +func (wm *WindowManager) GetAll() []Window ``` **Example:** ```go -windows := app.GetWindows() +windows := app.Window.GetAll() for _, window := range windows { fmt.Println("Window:", window.Name()) } @@ -168,7 +168,7 @@ app.Env // Environment variables ```go // Create window -window := app.Window.NewWebviewWindow() +window := app.Window.New() // Show dialog app.Dialog.Info().SetMessage("Hello!").Show() @@ -207,55 +207,55 @@ app.RegisterService(application.NewService(NewMyService(app))) ## Event Management -### EmitEvent() +### app.Event.Emit() Emits a custom event. ```go -func (a *App) EmitEvent(name string, data ...interface{}) +func (em *EventManager) Emit(name string, data ...interface{}) ``` **Example:** ```go // Emit event with data -app.EmitEvent("user-logged-in", map[string]interface{}{ +app.Event.Emit("user-logged-in", map[string]interface{}{ "username": "john", "timestamp": time.Now(), }) ``` -### OnEvent() +### app.Event.On() Listens for custom events. ```go -func (a *App) OnEvent(name string, callback func(*CustomEvent)) +func (em *EventManager) On(name string, callback func(*CustomEvent)) ``` **Example:** ```go -app.OnEvent("user-logged-in", func(e *application.CustomEvent) { +app.Event.On("user-logged-in", func(e *application.CustomEvent) { data := e.Data.(map[string]interface{}) username := data["username"].(string) fmt.Println("User logged in:", username) }) ``` -### OnApplicationEvent() +### app.Event.OnApplicationEvent() Listens for application lifecycle events. ```go -func (a *App) OnApplicationEvent(eventType ApplicationEventType, callback func(*ApplicationEvent)) func() +func (em *EventManager) OnApplicationEvent(eventType ApplicationEventType, callback func(*ApplicationEvent)) func() ``` **Example:** ```go // Listen for shutdown -app.OnApplicationEvent(application.EventApplicationShutdown, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(application.EventApplicationShutdown, func(e *application.ApplicationEvent) { fmt.Println("Application shutting down") // Cleanup }) @@ -415,7 +415,7 @@ func main() { }) // Create main window - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "My App", Width: 1024, Height: 768, diff --git a/docs/src/content/docs/reference/events.mdx b/docs/src/content/docs/reference/events.mdx index a75ea62d5..d6286018e 100644 --- a/docs/src/content/docs/reference/events.mdx +++ b/docs/src/content/docs/reference/events.mdx @@ -24,12 +24,12 @@ The Events API provides methods to emit and listen to events, enabling communica ## Event Methods (Go) -### EmitEvent() +### app.Event.Emit() Emits a custom event to all windows. ```go -func (a *App) EmitEvent(name string, data ...interface{}) +func (em *EventManager) Emit(name string, data ...interface{}) ``` **Parameters:** @@ -39,24 +39,24 @@ func (a *App) EmitEvent(name string, data ...interface{}) **Example:** ```go // Emit simple event -app.EmitEvent("user-logged-in") +app.Event.Emit("user-logged-in") // Emit with data -app.EmitEvent("data-updated", map[string]interface{}{ +app.Event.Emit("data-updated", map[string]interface{}{ "count": 42, "status": "success", }) // Emit multiple values -app.EmitEvent("progress", 75, "Processing files...") +app.Event.Emit("progress", 75, "Processing files...") ``` -### OnEvent() +### app.Event.On() Listens for custom events in Go. ```go -func (a *App) OnEvent(name string, callback func(*CustomEvent)) func() +func (em *EventManager) On(name string, callback func(*CustomEvent)) func() ``` **Parameters:** @@ -68,7 +68,7 @@ func (a *App) OnEvent(name string, callback func(*CustomEvent)) func() **Example:** ```go // Listen for events -cleanup := app.OnEvent("user-action", func(e *application.CustomEvent) { +cleanup := app.Event.On("user-action", func(e *application.CustomEvent) { data := e.Data.(map[string]interface{}) action := data["action"].(string) app.Logger.Info("User action", "action", action) @@ -87,7 +87,7 @@ Emit events to a specific window: window.EmitEvent("notification", "Hello from Go!") // Emit to all windows -app.EmitEvent("global-update", data) +app.Event.Emit("global-update", data) ``` ## Event Methods (Frontend) @@ -187,12 +187,12 @@ OffAll('data-updated') ## Application Events -### OnApplicationEvent() +### app.Event.OnApplicationEvent() Listens for application lifecycle events. ```go -func (a *App) OnApplicationEvent(eventType ApplicationEventType, callback func(*ApplicationEvent)) func() +func (em *EventManager) OnApplicationEvent(eventType ApplicationEventType, callback func(*ApplicationEvent)) func() ``` **Event Types:** @@ -203,13 +203,13 @@ func (a *App) OnApplicationEvent(eventType ApplicationEventType, callback func(* **Example:** ```go // Handle application startup -app.OnApplicationEvent(application.EventApplicationStarted, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(application.EventApplicationStarted, func(e *application.ApplicationEvent) { app.Logger.Info("Application started") // Initialize resources }) // Handle application shutdown -app.OnApplicationEvent(application.EventApplicationShutdown, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(application.EventApplicationShutdown, func(e *application.ApplicationEvent) { app.Logger.Info("Application shutting down") // Cleanup resources, save state database.Close() @@ -268,7 +268,7 @@ func (s *DataService) FetchData(query string) ([]Item, error) { items := fetchFromDatabase(query) // Emit event when done - s.app.EmitEvent("data-fetched", map[string]interface{}{ + s.app.Event.Emit("data-fetched", map[string]interface{}{ "query": query, "count": len(items), }) @@ -309,7 +309,7 @@ func (s *Service) ProcessFiles(files []string) error { processFile(file) // Emit progress event - s.app.EmitEvent("progress", map[string]interface{}{ + s.app.Event.Emit("progress", map[string]interface{}{ "current": i + 1, "total": total, "percent": float64(i+1) / float64(total) * 100, @@ -317,7 +317,7 @@ func (s *Service) ProcessFiles(files []string) error { }) } - s.app.EmitEvent("processing-complete") + s.app.Event.Emit("processing-complete") return nil } ``` @@ -349,7 +349,7 @@ Perfect for applications with multiple windows like settings panels, dashboards, ```go // Broadcast to all windows -app.EmitEvent("theme-changed", "dark") +app.Event.Emit("theme-changed", "dark") // Send to specific window preferencesWindow.EmitEvent("settings-updated", settings) @@ -391,7 +391,7 @@ func (s *StateService) UpdateState(key string, value interface{}) { s.mu.Unlock() // Notify all windows - s.app.EmitEvent("state-updated", map[string]interface{}{ + s.app.Event.Emit("state-updated", map[string]interface{}{ "key": key, "value": value, }) @@ -435,21 +435,21 @@ type NotificationService struct { } func (s *NotificationService) Success(message string) { - s.app.EmitEvent("notification", map[string]interface{}{ + s.app.Event.Emit("notification", map[string]interface{}{ "type": "success", "message": message, }) } func (s *NotificationService) Error(message string) { - s.app.EmitEvent("notification", map[string]interface{}{ + s.app.Event.Emit("notification", map[string]interface{}{ "type": "error", "message": message, }) } func (s *NotificationService) Info(message string) { - s.app.EmitEvent("notification", map[string]interface{}{ + s.app.Event.Emit("notification", map[string]interface{}{ "type": "info", "message": message, }) @@ -498,7 +498,7 @@ func NewEventDemoService(app *application.Application) *EventDemoService { service := &EventDemoService{app: app} // Listen for custom events - app.OnEvent("user-action", func(e *application.CustomEvent) { + app.Event.On("user-action", func(e *application.CustomEvent) { data := e.Data.(map[string]interface{}) app.Logger.Info("User action received", "data", data) }) @@ -508,26 +508,26 @@ func NewEventDemoService(app *application.Application) *EventDemoService { func (s *EventDemoService) StartLongTask() { go func() { - s.app.EmitEvent("task-started") + s.app.Event.Emit("task-started") for i := 1; i <= 10; i++ { time.Sleep(500 * time.Millisecond) - s.app.EmitEvent("task-progress", map[string]interface{}{ + s.app.Event.Emit("task-progress", map[string]interface{}{ "step": i, "total": 10, "percent": i * 10, }) } - s.app.EmitEvent("task-completed", map[string]interface{}{ + s.app.Event.Emit("task-completed", map[string]interface{}{ "message": "Task finished successfully!", }) }() } func (s *EventDemoService) BroadcastMessage(message string) { - s.app.EmitEvent("broadcast", message) + s.app.Event.Emit("broadcast", message) } func main() { @@ -536,11 +536,11 @@ func main() { }) // Handle application lifecycle - app.OnApplicationEvent(application.EventApplicationStarted, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(application.EventApplicationStarted, func(e *application.ApplicationEvent) { app.Logger.Info("Application started!") }) - app.OnApplicationEvent(application.EventApplicationShutdown, func(e *application.ApplicationEvent) { + app.Event.OnApplicationEvent(application.EventApplicationShutdown, func(e *application.ApplicationEvent) { app.Logger.Info("Application shutting down...") }) @@ -549,7 +549,7 @@ func main() { app.RegisterService(application.NewService(service)) // Create window - window := app.NewWebviewWindow() + window := app.Window.New() // Handle window events window.OnWindowEvent(events.Common.WindowFocus, func(e *application.WindowEvent) { @@ -673,11 +673,11 @@ This mapping happens automatically in the background, so when you listen for `ev ```go import "github.com/wailsapp/wails/v3/pkg/events" -app.OnApplicationEvent(events.Common.ApplicationStarted, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(events.Common.ApplicationStarted, func(e *application.ApplicationEvent) { app.Logger.Info("Application ready!") }) -app.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { +app.Event.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { // Update app theme }) ``` @@ -720,7 +720,7 @@ window.OnWindowEvent(events.Common.WindowFocus, func(e *application.WindowEvent) // Cancel window close window.RegisterHook(events.Common.WindowClosing, func(e *application.WindowEvent) { - result, _ := app.QuestionDialog(). + result, _ := app.Dialog.Question(). SetMessage("Close window?"). SetButtons("Yes", "No"). Show() @@ -749,14 +749,14 @@ window.OnWindowEvent(events.Common.WindowRuntimeReady, func(e *application.Windo ```go // Good - descriptive and specific -app.EmitEvent("user:logged-in", user) -app.EmitEvent("data:fetch:complete", results) -app.EmitEvent("ui:theme:changed", theme) +app.Event.Emit("user:logged-in", user) +app.Event.Emit("data:fetch:complete", results) +app.Event.Emit("ui:theme:changed", theme) // Bad - vague and unclear -app.EmitEvent("event1", data) -app.EmitEvent("update", stuff) -app.EmitEvent("e", value) +app.Event.Emit("event1", data) +app.Event.Emit("update", stuff) +app.Event.Emit("e", value) ``` ## Performance Considerations @@ -776,7 +776,7 @@ func (s *Service) EmitWithDebounce(event string, data interface{}) { return // Skip this emission } - s.app.EmitEvent(event, data) + s.app.Event.Emit(event, data) s.lastEmit = now } ``` diff --git a/docs/src/content/docs/reference/menu.mdx b/docs/src/content/docs/reference/menu.mdx index 485357073..f0b9f0640 100644 --- a/docs/src/content/docs/reference/menu.mdx +++ b/docs/src/content/docs/reference/menu.mdx @@ -316,12 +316,12 @@ menu.Update() ## Application Menu -### SetApplicationMenu() +### app.Menu.Set() Sets the application's main menu bar. ```go -func (a *App) SetApplicationMenu(menu *Menu) +func (mm *MenuManager) Set(menu *Menu) ``` **Example:** @@ -347,7 +347,7 @@ editMenu.Add("Cut").SetAccelerator("Ctrl+X").OnClick(cut) editMenu.Add("Copy").SetAccelerator("Ctrl+C").OnClick(copy) editMenu.Add("Paste").SetAccelerator("Ctrl+V").OnClick(paste) -app.SetApplicationMenu(menu) +app.Menu.Set(menu) ``` **Platform notes:** @@ -357,12 +357,12 @@ app.SetApplicationMenu(menu) ## Context Menus -### RegisterContextMenu() +### app.ContextMenu.Add() Registers a context menu (right-click menu) with a specific name. ```go -func (a *App) RegisterContextMenu(name string, menu *Menu) +func (cm *ContextMenuManager) Add(name string, menu *Menu) ``` **Parameters:** @@ -412,17 +412,17 @@ func updateContextMenu() { ## System Tray Menu -### NewSystemTray() +### app.SystemTray.New() Creates a new system tray icon. ```go -func (a *App) NewSystemTray() *SystemTray +func (sm *SystemTrayManager) New() *SystemTray ``` **Example:** ```go -tray := app.NewSystemTray() +tray := app.SystemTray.New() ``` ### SetIcon() @@ -572,9 +572,9 @@ func main() { }) menu := createMenu(app) - app.SetApplicationMenu(menu) + app.Menu.Set(menu) - window := app.NewWebviewWindow() + window := app.Window.New() window.Show() app.Run() @@ -586,7 +586,7 @@ func main() { ```go func setupSystemTray(app *application.Application, window *application.Window) { // Create system tray - tray := app.NewSystemTray() + tray := app.SystemTray.New() // Set icon iconData, _ := os.ReadFile("icon.png") @@ -667,7 +667,7 @@ func (e *Editor) createMenu() { }) e.updateMenuState() - e.app.SetApplicationMenu(e.menu) + e.app.Menu.Set(e.menu) } func (e *Editor) updateMenuState() { diff --git a/docs/src/content/docs/reference/overview.mdx b/docs/src/content/docs/reference/overview.mdx index 44b2a819c..8a3b77bc3 100644 --- a/docs/src/content/docs/reference/overview.mdx +++ b/docs/src/content/docs/reference/overview.mdx @@ -37,7 +37,7 @@ This is the complete API reference for Wails v3. It documents every public type, Most methods that can fail return `error` as the last return value: ```go -window, err := app.NewWebviewWindow() +window, err := app.Window.New() if err != nil { log.Fatal(err) } diff --git a/docs/src/content/docs/reference/window.mdx b/docs/src/content/docs/reference/window.mdx index 33d0a8b55..c376ee426 100644 --- a/docs/src/content/docs/reference/window.mdx +++ b/docs/src/content/docs/reference/window.mdx @@ -30,7 +30,7 @@ func (w *Window) Show() **Example:** ```go -window := app.NewWebviewWindow() +window := app.Window.New() window.Show() ``` @@ -202,7 +202,7 @@ func (w *Window) Centre() **Example:** ```go -window := app.NewWebviewWindow() +window := app.Window.New() window.Centre() window.Show() ``` @@ -441,7 +441,7 @@ func (w *Window) RegisterHook( import "github.com/wailsapp/wails/v3/pkg/events" window.RegisterHook(events.Common.WindowClosing, func(e *application.WindowEvent) { - result, _ := app.QuestionDialog(). + result, _ := app.Dialog.Question(). SetTitle("Confirm Close"). SetMessage("Are you sure you want to close this window?"). SetButtons("Yes", "No"). @@ -457,7 +457,7 @@ window.RegisterHook(events.Common.WindowClosing, func(e *application.WindowEvent ```go window.RegisterHook(events.Common.WindowClosing, func(e *application.WindowEvent) { if hasUnsavedChanges { - result, _ := app.QuestionDialog(). + result, _ := app.Dialog.Question(). SetMessage("Save changes before closing?"). SetButtons("Save", "Don't Save", "Cancel"). Show() @@ -620,7 +620,7 @@ func main() { }) // Create window with options - window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{ + window := app.Window.NewWithOptions(application.WebviewWindowOptions{ Title: "My Application", Width: 1024, Height: 768, @@ -638,7 +638,7 @@ func main() { // Set up event hooks window.RegisterHook(events.Common.WindowClosing, func(e *application.WindowEvent) { // Confirm before closing - result, _ := app.QuestionDialog(). + result, _ := app.Dialog.Question(). SetTitle("Confirm Close"). SetMessage("Are you sure you want to close this window?"). SetButtons("Yes", "No"). diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..ff79bbb3d 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,6 +23,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Fix outdated Manager API references in documentation (31 files updated to use new pattern like `app.Window.New()`, `app.Event.Emit()`, etc.) by @leaanthony ## Deprecated From 0abad1ffb282c804f2c0a1acdd30109944226ac7 Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Thu, 8 Jan 2026 21:20:13 +1100 Subject: [PATCH 30/40] fix(v3/linux): fix crash on panic in JS-bound Go methods (#4856) * fix(v3/linux): fix crash on panic in JS-bound Go methods WebKit2GTK installs signal handlers after gtk_main() starts, overriding our SA_ONSTACK fix. This causes Go panics (e.g., nil pointer dereference) in JS-bound methods to crash with 'non-Go code set up signal handler without SA_ONSTACK flag'. Fix by deferring signal handler installation via g_idle_add() to run after GTK main loop starts, ensuring we fix handlers AFTER WebKit has installed its own. Fixes #3965 * test(v3/linux): add test case for signal handler fix Adds a test application that can trigger panics from JS-bound Go methods to verify the signal handler fix for issue #3965 works correctly. The test app has buttons to: - Trigger a panic in a goroutine - Trigger an immediate panic - Call a safe method Before the fix, clicking 'Trigger Panic' would crash the app. After the fix, panics are recovered and logged. * chore: remove test case from PR * fix(linux): call signal handler fix after WebKit init, not in idle callback Move install_signal_handlers() call to after webkit_web_view_new_with_user_content_manager() to ensure WebKit has finished setting up its signal handlers before we add SA_ONSTACK. The previous g_idle_add approach was still too early - WebKit initialization continues after GTK init. This matches the v2 approach which waits for actual webview creation. Also add documentation about the known Go limitation (golang/go#7227) where signals may still be delivered on the wrong stack in some C interop scenarios. --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/pkg/application/linux_cgo.go | 16 ++++++++++++++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index ff79bbb3d..d7dcab65b 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -24,6 +24,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed - Fix outdated Manager API references in documentation (31 files updated to use new pattern like `app.Window.New()`, `app.Event.Emit()`, etc.) by @leaanthony +- Fix Linux crash on panic in JS-bound Go methods due to WebKit overriding signal handlers (#3965) by @leaanthony ## Deprecated diff --git a/v3/pkg/application/linux_cgo.go b/v3/pkg/application/linux_cgo.go index bd8dc7071..0a21f4c34 100644 --- a/v3/pkg/application/linux_cgo.go +++ b/v3/pkg/application/linux_cgo.go @@ -161,7 +161,16 @@ typedef struct Screen { bool isPrimary; } Screen; +// Signal handler fix for WebKit/GTK compatibility. // CREDIT: https://github.com/rainycape/magick +// +// WebKit/GTK may install signal handlers without SA_ONSTACK, which causes +// Go to crash when handling signals (e.g., during panic recovery). +// This code adds SA_ONSTACK to signal handlers after WebKit initialization. +// +// Known limitation: Due to Go issue #7227 (golang/go#7227), signals may still +// be delivered on the wrong stack in some cases when C libraries are involved. +// This is a fundamental Go runtime limitation that cannot be fully resolved here. #include #include #include @@ -489,6 +498,7 @@ var ( ) var registerURIScheme sync.Once +var fixSignalHandlers sync.Once func init() { gtkSignalToMenuItem = map[uint]*MenuItem{} @@ -553,8 +563,6 @@ func appName() string { } func appNew(name string) pointer { - C.install_signal_handlers() - // Name is already sanitized by sanitizeAppName() in application_linux.go appId := fmt.Sprintf("org.wails.%s", name) nameC := C.CString(appId) @@ -1344,6 +1352,10 @@ func windowNewWebview(parentId uint, gpuPolicy WebviewGpuPolicy) pointer { C.webkit_user_content_manager_register_script_message_handler(manager, c.String("external")) webView := C.webkit_web_view_new_with_user_content_manager(manager) + fixSignalHandlers.Do(func() { + C.install_signal_handlers() + }) + C.save_webview_to_content_manager(unsafe.Pointer(manager), unsafe.Pointer(webView)) // attach window id to both the webview and contentmanager From be0e9bab9b995505a30957d0f6409813621c3ee4 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 9 Jan 2026 02:46:28 +0000 Subject: [PATCH 31/40] chore(v3): bump to v3.0.0-alpha.58 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 6 ++++++ v3/UNRELEASED_CHANGELOG.md | 2 -- v3/internal/version/version.txt | 2 +- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index ddfa886b8..e979a2126 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.58 - 2026-01-09 + +## Fixed +- Fix outdated Manager API references in documentation (31 files updated to use new pattern like `app.Window.New()`, `app.Event.Emit()`, etc.) by @leaanthony +- Fix Linux crash on panic in JS-bound Go methods due to WebKit overriding signal handlers (#3965) by @leaanthony + ## v3.0.0-alpha.57 - 2026-01-05 ## Changed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index d7dcab65b..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,8 +23,6 @@ After processing, the content will be moved to the main changelog and this file ## Fixed -- Fix outdated Manager API references in documentation (31 files updated to use new pattern like `app.Window.New()`, `app.Event.Emit()`, etc.) by @leaanthony -- Fix Linux crash on panic in JS-bound Go methods due to WebKit overriding signal handlers (#3965) by @leaanthony ## Deprecated diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 63ca63748..7a89e4e03 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.57 \ No newline at end of file +v3.0.0-alpha.58 \ No newline at end of file From 897479d52be43b48f372db1fd0ab15c60882185d Mon Sep 17 00:00:00 2001 From: Ndianabasi Udonkang Date: Sat, 10 Jan 2026 10:00:52 +0100 Subject: [PATCH 32/40] Enhance `Drag-N-Drop` README with Internal Drag and Drop Info (#4869) * Enhance README with internal drag and drop info Added details about internal drag and drop functionality. * Update UNRELEASED_CHANGE.md --- v3/UNRELEASED_CHANGELOG.md | 2 +- v3/examples/drag-n-drop/README.md | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..a6eb78f10 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -19,7 +19,7 @@ After processing, the content will be moved to the main changelog and this file ## Changed - +- Update the README for the `Drag N Drop` example and highlights that `Internal Drag and Drop` is demonstrated with the example @ndianabasi ## Fixed diff --git a/v3/examples/drag-n-drop/README.md b/v3/examples/drag-n-drop/README.md index d1a4bfb31..a2cde8844 100644 --- a/v3/examples/drag-n-drop/README.md +++ b/v3/examples/drag-n-drop/README.md @@ -60,9 +60,11 @@ go run main.go Then drag files from your desktop or file manager into the drop zone. -## See also +## HTML5 Drag and Drop API -- [html-dnd-api](../html-dnd-api) - For dragging elements *within* your application (HTML5 Drag and Drop API) +This example also includes a demonstration for dragging elements *within* your application via the HTML5 Drag and Drop API. + +Scroll down to the `Internal Drag and Drop` section within the launched application to interact with the demo. ## Status From 9db2f74c443016aa31c2c25ff326f7e28a81dbc7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 11 Jan 2026 02:54:04 +0000 Subject: [PATCH 33/40] chore(v3): bump to v3.0.0-alpha.59 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 5 +++++ v3/UNRELEASED_CHANGELOG.md | 2 +- v3/internal/version/version.txt | 2 +- 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index e979a2126..292617508 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.59 - 2026-01-11 + +## Changed +- Update the README for the `Drag N Drop` example and highlights that `Internal Drag and Drop` is demonstrated with the example @ndianabasi + ## v3.0.0-alpha.58 - 2026-01-09 ## Fixed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index a6eb78f10..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -19,7 +19,7 @@ After processing, the content will be moved to the main changelog and this file ## Changed -- Update the README for the `Drag N Drop` example and highlights that `Internal Drag and Drop` is demonstrated with the example @ndianabasi + ## Fixed diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 7a89e4e03..0bc1c8b52 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.58 \ No newline at end of file +v3.0.0-alpha.59 \ No newline at end of file From 37fb9b9ba55c203004724e2941b2af0849518d05 Mon Sep 17 00:00:00 2001 From: Zach Botterman <6074435+popaprozac@users.noreply.github.com> Date: Tue, 13 Jan 2026 02:42:09 -0800 Subject: [PATCH 34/40] fix(v3/linux): Fix menu update by clearing menu (#4875) * clear menu * update changelog * free list * register glistfree --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/pkg/application/linux_cgo.go | 18 ++++++++++++++++++ v3/pkg/application/linux_purego.go | 25 ++++++++++++++++++++++++- v3/pkg/application/menu_linux.go | 3 +++ 4 files changed, 46 insertions(+), 1 deletion(-) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..c90953b93 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,6 +23,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Fix menu not clearing children on `menu.Update()` ## Deprecated diff --git a/v3/pkg/application/linux_cgo.go b/v3/pkg/application/linux_cgo.go index 0a21f4c34..4d5ce4c71 100644 --- a/v3/pkg/application/linux_cgo.go +++ b/v3/pkg/application/linux_cgo.go @@ -731,6 +731,24 @@ func menuGetRadioGroup(item *linuxMenuItem) *GSList { return (*GSList)(C.gtk_radio_menu_item_get_group((*C.GtkRadioMenuItem)(item.native))) } +func menuClear(menu *Menu) { + menuShell := (*C.GtkMenuShell)((menu.impl).(*linuxMenu).native) + children := C.gtk_container_get_children((*C.GtkContainer)(unsafe.Pointer(menuShell))) + if children != nil { + // Save the original pointer to free later + originalList := children + // Iterate through all children and remove them + for children != nil { + child := (*C.GtkWidget)(children.data) + if child != nil { + C.gtk_container_remove((*C.GtkContainer)(unsafe.Pointer(menuShell)), child) + } + children = children.next + } + C.g_list_free(originalList) + } +} + //export handleClick func handleClick(idPtr unsafe.Pointer) { ident := C.CString("id") diff --git a/v3/pkg/application/linux_purego.go b/v3/pkg/application/linux_purego.go index 5bfe97af0..d59d74ac9 100644 --- a/v3/pkg/application/linux_purego.go +++ b/v3/pkg/application/linux_purego.go @@ -5,7 +5,6 @@ package application import ( "fmt" "os" - "strings" "unsafe" "github.com/ebitengine/purego" @@ -106,6 +105,7 @@ var ( gBytesUnref func(uintptr) gFree func(pointer) gIdleAdd func(uintptr) + gListFree func(*GList) gObjectRefSink func(pointer) gObjectUnref func(pointer) gSignalConnectData func(pointer, string, uintptr, pointer, bool, int) int @@ -139,6 +139,8 @@ var ( gtkCheckMenuItemNewWithLabel func(string) pointer gtkCheckMenuItemSetActive func(pointer, int) gtkContainerAdd func(pointer, pointer) + gtkContainerGetChildren func(pointer) *GList + gtkContainerRemove func(pointer, pointer) gtkCSSProviderLoadFromData func(pointer, string, int, pointer) gtkCSSProviderNew func() pointer gtkDialogAddButton func(pointer, string, int) @@ -261,6 +263,7 @@ func init() { purego.RegisterLibFunc(&gBytesUnref, gtk, "g_bytes_unref") purego.RegisterLibFunc(&gFree, gtk, "g_free") purego.RegisterLibFunc(&gIdleAdd, gtk, "g_idle_add") + purego.RegisterLibFunc(&gListFree, gtk, "g_list_free") purego.RegisterLibFunc(&gObjectRefSink, gtk, "g_object_ref_sink") purego.RegisterLibFunc(&gObjectUnref, gtk, "g_object_unref") purego.RegisterLibFunc(&gSignalConnectData, gtk, "g_signal_connect_data") @@ -294,6 +297,8 @@ func init() { purego.RegisterLibFunc(>kCheckMenuItemNewWithLabel, gtk, "gtk_check_menu_item_new_with_label") purego.RegisterLibFunc(>kCheckMenuItemSetActive, gtk, "gtk_check_menu_item_set_active") purego.RegisterLibFunc(>kContainerAdd, gtk, "gtk_container_add") + purego.RegisterLibFunc(>kContainerGetChildren, gtk, "gtk_container_get_children") + purego.RegisterLibFunc(>kContainerRemove, gtk, "gtk_container_remove") purego.RegisterLibFunc(>kCSSProviderLoadFromData, gtk, "gtk_css_provider_load_from_data") purego.RegisterLibFunc(>kDialogAddButton, gtk, "gtk_dialog_add_button") purego.RegisterLibFunc(>kDialogGetContentArea, gtk, "gtk_dialog_get_content_area") @@ -521,6 +526,24 @@ func menuGetRadioGroup(item *linuxMenuItem) *GSList { return (*GSList)(gtkRadioMenuItemGetGroup(pointer(item.native))) } +func menuClear(menu *Menu) { + menuShell := pointer((menu.impl).(*linuxMenu).native) + children := gtkContainerGetChildren(menuShell) + if children != nil { + // Save the original pointer to free later + originalList := children + // Iterate through all children and remove them + for children != nil { + child := children.data + if child != nilPointer { + gtkContainerRemove(menuShell, child) + } + children = children.next + } + gListFree(originalList) + } +} + func attachMenuHandler(item *MenuItem) { handleClick := func() { item := item diff --git a/v3/pkg/application/menu_linux.go b/v3/pkg/application/menu_linux.go index b47ad6dd0..0288000cb 100644 --- a/v3/pkg/application/menu_linux.go +++ b/v3/pkg/application/menu_linux.go @@ -29,6 +29,9 @@ func (m *linuxMenu) processMenu(menu *Menu) { menu: menu, native: menuNew(), } + } else { + // Clear existing menu items before rebuilding (prevents appending on Update()) + menuClear(menu) } var currentRadioGroup GSListPointer From d7d6720d5403aff00f1156ddc095ce3ff3e5d878 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 14 Jan 2026 02:50:25 +0000 Subject: [PATCH 35/40] chore(v3): bump to v3.0.0-alpha.60 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 5 +++++ v3/UNRELEASED_CHANGELOG.md | 1 - v3/internal/version/version.txt | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index 292617508..a1d57f665 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.60 - 2026-01-14 + +## Fixed +- Fix menu not clearing children on `menu.Update()` + ## v3.0.0-alpha.59 - 2026-01-11 ## Changed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index c90953b93..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,7 +23,6 @@ After processing, the content will be moved to the main changelog and this file ## Fixed -- Fix menu not clearing children on `menu.Update()` ## Deprecated diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 0bc1c8b52..1ff0a688f 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.59 \ No newline at end of file +v3.0.0-alpha.60 \ No newline at end of file From 9158c49e3032faa7ba2630eaa627cdecf1e32ef1 Mon Sep 17 00:00:00 2001 From: Abdelhadi Seddar <91424903+AbdelhadiSeddar@users.noreply.github.com> Date: Tue, 20 Jan 2026 00:41:46 +0100 Subject: [PATCH 36/40] docs: fixed incorrect tag in Custom Output Directory of Bindings (#4873) * docs: fixed incorrect tag in Custom Output Directory of Bindings After some usage of wails I found out that ```bash wails3 generate bindings -o ./src/bindings ``` does not work and according to ```bash $ wails3 generate bindings --help ``` it uses the `-d string` tag instead * Update UNRELEASED_CHANGELOG.md --------- Co-authored-by: Lea Anthony --- docs/src/content/docs/features/bindings/methods.mdx | 2 +- v3/UNRELEASED_CHANGELOG.md | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/src/content/docs/features/bindings/methods.mdx b/docs/src/content/docs/features/bindings/methods.mdx index f8348269d..76ff55edc 100644 --- a/docs/src/content/docs/features/bindings/methods.mdx +++ b/docs/src/content/docs/features/bindings/methods.mdx @@ -200,7 +200,7 @@ wails3 generate bindings -ts ### Custom Output Directory ```bash -wails3 generate bindings -o ./src/bindings +wails3 generate bindings -d ./src/bindings ``` ### Watch Mode (Development) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..ac2d76430 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,6 +23,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Fix documentation regarding generating custom binding, must use `-d String` instead of `-o String` ## Deprecated From 85980349427085ff2f5ee24442dac6998cb59eda Mon Sep 17 00:00:00 2001 From: Ndianabasi Udonkang Date: Tue, 20 Jan 2026 00:42:54 +0100 Subject: [PATCH 37/40] Change Window Type from `WebviewWindow` to `Window` (#4829) * fix: change window type from WebviewWindow to Window * docs: update `UNRELEASED_CHANGELOG` --------- Co-authored-by: Lea Anthony --- .../docs/features/keyboard/shortcuts.mdx | 56 +++++++++---------- v3/UNRELEASED_CHANGELOG.md | 1 + 2 files changed, 29 insertions(+), 28 deletions(-) diff --git a/docs/src/content/docs/features/keyboard/shortcuts.mdx b/docs/src/content/docs/features/keyboard/shortcuts.mdx index 51ac8ce9e..ba83603f8 100644 --- a/docs/src/content/docs/features/keyboard/shortcuts.mdx +++ b/docs/src/content/docs/features/keyboard/shortcuts.mdx @@ -29,7 +29,7 @@ keyBindings := app.KeyBinding Register a simple keyboard shortcut: ```go -app.KeyBinding.Add("Ctrl+S", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Ctrl+S", func(window application.Window) { // Handle save action app.Logger.Info("Save shortcut triggered") // Perform save operation... @@ -42,12 +42,12 @@ Register multiple shortcuts for common operations: ```go // File operations -app.KeyBinding.Add("Ctrl+N", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Ctrl+N", func(window application.Window) { // New file window.EmitEvent("file:new", nil) }) -app.KeyBinding.Add("Ctrl+O", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Ctrl+O", func(window application.Window) { // Open file dialog := app.Dialog.OpenFile() if file, err := dialog.PromptForSingleSelection(); err == nil { @@ -55,23 +55,23 @@ app.KeyBinding.Add("Ctrl+O", func(window *application.WebviewWindow) { } }) -app.KeyBinding.Add("Ctrl+S", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Ctrl+S", func(window application.Window) { // Save file window.EmitEvent("file:save", nil) }) // Edit operations -app.KeyBinding.Add("Ctrl+Z", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Ctrl+Z", func(window application.Window) { // Undo window.EmitEvent("edit:undo", nil) }) -app.KeyBinding.Add("Ctrl+Y", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Ctrl+Y", func(window application.Window) { // Redo (Windows/Linux) window.EmitEvent("edit:redo", nil) }) -app.KeyBinding.Add("Cmd+Shift+Z", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Cmd+Shift+Z", func(window application.Window) { // Redo (macOS) window.EmitEvent("edit:redo", nil) }) @@ -139,7 +139,7 @@ Remove key bindings when they're no longer needed: app.KeyBinding.Remove("Ctrl+S") // Example: Temporary key binding for a modal -app.KeyBinding.Add("Escape", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Escape", func(window application.Window) { // Close modal window.EmitEvent("modal:close", nil) // Remove this temporary binding @@ -165,7 +165,7 @@ for _, binding := range allBindings { Make key bindings context-aware by checking application state: ```go -app.KeyBinding.Add("Ctrl+S", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Ctrl+S", func(window application.Window) { // Check current application state if isEditMode() { // Save document @@ -184,7 +184,7 @@ app.KeyBinding.Add("Ctrl+S", func(window *application.WebviewWindow) { Key bindings receive the active window, allowing window-specific behavior: ```go -app.KeyBinding.Add("F11", func(window *application.WebviewWindow) { +app.KeyBinding.Add("F11", func(window application.Window) { // Toggle fullscreen for the active window if window.Fullscreen() { window.SetFullscreen(false) @@ -193,7 +193,7 @@ app.KeyBinding.Add("F11", func(window *application.WebviewWindow) { } }) -app.KeyBinding.Add("Ctrl+W", func(window *application.WebviewWindow) { +app.KeyBinding.Add("Ctrl+W", func(window application.Window) { // Close the active window window.Close() }) @@ -206,15 +206,15 @@ Dynamically add and remove key bindings based on application state: ```go func enableEditMode() { // Add edit-specific key bindings - app.KeyBinding.Add("Ctrl+B", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Ctrl+B", func(window application.Window) { window.EmitEvent("format:bold", nil) }) - app.KeyBinding.Add("Ctrl+I", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Ctrl+I", func(window application.Window) { window.EmitEvent("format:italic", nil) }) - app.KeyBinding.Add("Ctrl+U", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Ctrl+U", func(window application.Window) { window.EmitEvent("format:underline", nil) }) } @@ -313,7 +313,7 @@ func disableEditMode() { 2. **Provide Visual Feedback**: Let users know when shortcuts are triggered: ```go - app.KeyBinding.Add("Ctrl+S", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Ctrl+S", func(window application.Window) { saveDocument() // Show brief notification window.EmitEvent("notification:show", "Document saved") @@ -330,7 +330,7 @@ func disableEditMode() { 4. **Document Shortcuts**: Provide help or documentation for available shortcuts: ```go - app.KeyBinding.Add("F1", func(window *application.WebviewWindow) { + app.KeyBinding.Add("F1", func(window application.Window) { // Show help dialog with available shortcuts showKeyboardShortcutsHelp() }) @@ -342,7 +342,7 @@ func disableEditMode() { app.KeyBinding.Add("Escape", exitEditModeHandler) } - func exitEditModeHandler(window *application.WebviewWindow) { + func exitEditModeHandler(window application.Window) { exitEditMode() app.KeyBinding.Remove("Escape") // Clean up temporary binding } @@ -367,33 +367,33 @@ func main() { // File operations if runtime.GOOS == "darwin" { - app.KeyBinding.Add("Cmd+N", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Cmd+N", func(window application.Window) { window.EmitEvent("file:new", nil) }) - app.KeyBinding.Add("Cmd+O", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Cmd+O", func(window application.Window) { openFile(app, window) }) - app.KeyBinding.Add("Cmd+S", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Cmd+S", func(window application.Window) { window.EmitEvent("file:save", nil) }) } else { - app.KeyBinding.Add("Ctrl+N", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Ctrl+N", func(window application.Window) { window.EmitEvent("file:new", nil) }) - app.KeyBinding.Add("Ctrl+O", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Ctrl+O", func(window application.Window) { openFile(app, window) }) - app.KeyBinding.Add("Ctrl+S", func(window *application.WebviewWindow) { + app.KeyBinding.Add("Ctrl+S", func(window application.Window) { window.EmitEvent("file:save", nil) }) } // View operations - app.KeyBinding.Add("F11", func(window *application.WebviewWindow) { + app.KeyBinding.Add("F11", func(window application.Window) { window.SetFullscreen(!window.Fullscreen()) }) - app.KeyBinding.Add("F1", func(window *application.WebviewWindow) { + app.KeyBinding.Add("F1", func(window application.Window) { showKeyboardShortcuts(window) }) @@ -407,7 +407,7 @@ func main() { } } -func openFile(app *application.App, window *application.WebviewWindow) { +func openFile(app *application.App, window application.Window) { dialog := app.Dialog.OpenFile() dialog.AddFilter("Text Files", "*.txt;*.md") @@ -416,7 +416,7 @@ func openFile(app *application.App, window *application.WebviewWindow) { } } -func showKeyboardShortcuts(window *application.WebviewWindow) { +func showKeyboardShortcuts(window application.Window) { shortcuts := ` Keyboard Shortcuts: - Ctrl/Cmd+N: New file @@ -435,4 +435,4 @@ Test your key bindings on all target platforms to ensure they work correctly and :::danger[Warning] Be careful not to override critical system shortcuts. Some key combinations are reserved by the operating system and cannot be captured by applications. -::: \ No newline at end of file +::: diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index ac2d76430..a9ee2e29d 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,6 +23,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Update the docs page for keyboard shortcuts and corrects the type of the callback parameter for `KeyBinding.Add` by @ndianabasi - Fix documentation regarding generating custom binding, must use `-d String` instead of `-o String` ## Deprecated From a0d2e03f6467175218bd3a12cae4a7b234338991 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 20 Jan 2026 02:48:15 +0000 Subject: [PATCH 38/40] chore(v3): bump to v3.0.0-alpha.61 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 6 ++++++ v3/UNRELEASED_CHANGELOG.md | 2 -- v3/internal/version/version.txt | 2 +- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index a1d57f665..6531af533 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.61 - 2026-01-20 + +## Fixed +- Update the docs page for keyboard shortcuts and corrects the type of the callback parameter for `KeyBinding.Add` by @ndianabasi +- Fix documentation regarding generating custom binding, must use `-d String` instead of `-o String` + ## v3.0.0-alpha.60 - 2026-01-14 ## Fixed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index a9ee2e29d..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,8 +23,6 @@ After processing, the content will be moved to the main changelog and this file ## Fixed -- Update the docs page for keyboard shortcuts and corrects the type of the callback parameter for `KeyBinding.Add` by @ndianabasi -- Fix documentation regarding generating custom binding, must use `-d String` instead of `-o String` ## Deprecated diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 1ff0a688f..9b52e2a36 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.60 \ No newline at end of file +v3.0.0-alpha.61 \ No newline at end of file From 8d28e2d06b9a075e230e26158de75059386b9aaf Mon Sep 17 00:00:00 2001 From: Lea Anthony Date: Wed, 21 Jan 2026 19:23:56 +1100 Subject: [PATCH 39/40] fix(windows): skip DPI awareness API call when already set via manifest (#4811) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Check current DPI awareness before calling SetProcessDpiAwarenessContext. Windows only allows setting DPI awareness once per process - either via manifest or API, not both. If already set (e.g., via application manifest in built binaries), skip the API call to avoid "Access is denied" errors. Fixes #4803 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude --- v3/UNRELEASED_CHANGELOG.md | 1 + v3/pkg/application/application_windows.go | 12 ++++++++++++ v3/pkg/w32/shcore.go | 17 +++++++++++++++++ 3 files changed, 30 insertions(+) diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index 8e4648038..af0097c53 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,6 +23,7 @@ After processing, the content will be moved to the main changelog and this file ## Fixed +- Fix SetProcessDpiAwarenessContext "Access is denied" error when DPI awareness is already set via application manifest (#4803) ## Deprecated diff --git a/v3/pkg/application/application_windows.go b/v3/pkg/application/application_windows.go index 7b3298cb3..09dad6acf 100644 --- a/v3/pkg/application/application_windows.go +++ b/v3/pkg/application/application_windows.go @@ -358,6 +358,18 @@ func setupDPIAwareness() error { // https://learn.microsoft.com/en-us/windows/win32/hidpi/setting-the-default-dpi-awareness-for-a-process // https://learn.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows + // Check if DPI awareness has already been set (e.g., via application manifest). + // Windows only allows setting DPI awareness once per process - either via manifest + // or API, not both. If already set, skip the API call to avoid "Access is denied" errors. + // See: https://github.com/wailsapp/wails/issues/4803 + if w32.HasGetProcessDpiAwarenessFunc() { + awareness, err := w32.GetProcessDpiAwareness() + if err == nil && awareness != w32.PROCESS_DPI_UNAWARE { + // DPI awareness already set (likely via manifest), skip API call + return nil + } + } + if w32.HasSetProcessDpiAwarenessContextFunc() { // This is most recent version with the best results // supported beginning with Windows 10, version 1703 diff --git a/v3/pkg/w32/shcore.go b/v3/pkg/w32/shcore.go index f2d6c5516..f83062eb3 100644 --- a/v3/pkg/w32/shcore.go +++ b/v3/pkg/w32/shcore.go @@ -12,9 +12,26 @@ var ( modshcore = syscall.NewLazyDLL("shcore.dll") procGetDpiForMonitor = modshcore.NewProc("GetDpiForMonitor") + procGetProcessDpiAwareness = modshcore.NewProc("GetProcessDpiAwareness") procSetProcessDpiAwareness = modshcore.NewProc("SetProcessDpiAwareness") ) +func HasGetProcessDpiAwarenessFunc() bool { + err := procGetProcessDpiAwareness.Find() + return err == nil +} + +// GetProcessDpiAwareness retrieves the DPI awareness of the current process. +// Returns one of: PROCESS_DPI_UNAWARE, PROCESS_SYSTEM_DPI_AWARE, or PROCESS_PER_MONITOR_DPI_AWARE. +func GetProcessDpiAwareness() (uint, error) { + var awareness uint + status, _, err := procGetProcessDpiAwareness.Call(0, uintptr(unsafe.Pointer(&awareness))) + if status != S_OK { + return 0, fmt.Errorf("GetProcessDpiAwareness failed: %v", err) + } + return awareness, nil +} + func HasSetProcessDpiAwarenessFunc() bool { err := procSetProcessDpiAwareness.Find() return err == nil From 9a131a049db4aa0b195714160bb57b07d1ae35df Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 22 Jan 2026 02:51:17 +0000 Subject: [PATCH 40/40] chore(v3): bump to v3.0.0-alpha.62 and update changelog [skip ci] --- docs/src/content/docs/changelog.mdx | 5 +++++ v3/UNRELEASED_CHANGELOG.md | 1 - v3/internal/version/version.txt | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index 6531af533..997dab63a 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -30,6 +30,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha.62 - 2026-01-22 + +## Fixed +- Fix SetProcessDpiAwarenessContext "Access is denied" error when DPI awareness is already set via application manifest (#4803) + ## v3.0.0-alpha.61 - 2026-01-20 ## Fixed diff --git a/v3/UNRELEASED_CHANGELOG.md b/v3/UNRELEASED_CHANGELOG.md index af0097c53..8e4648038 100644 --- a/v3/UNRELEASED_CHANGELOG.md +++ b/v3/UNRELEASED_CHANGELOG.md @@ -23,7 +23,6 @@ After processing, the content will be moved to the main changelog and this file ## Fixed -- Fix SetProcessDpiAwarenessContext "Access is denied" error when DPI awareness is already set via application manifest (#4803) ## Deprecated diff --git a/v3/internal/version/version.txt b/v3/internal/version/version.txt index 9b52e2a36..d0db23e95 100644 --- a/v3/internal/version/version.txt +++ b/v3/internal/version/version.txt @@ -1 +1 @@ -v3.0.0-alpha.61 \ No newline at end of file +v3.0.0-alpha.62 \ No newline at end of file