diff --git a/v2/go.mod b/v2/go.mod index 2eb753ee2..f1287bde7 100644 --- a/v2/go.mod +++ b/v2/go.mod @@ -51,6 +51,7 @@ require ( atomicgo.dev/keyboard v0.2.9 // indirect atomicgo.dev/schedule v0.1.0 // indirect dario.cat/mergo v1.0.0 // indirect + git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 // indirect github.com/Microsoft/go-winio v0.6.1 // indirect github.com/ProtonMail/go-crypto v1.1.5 // indirect github.com/alecthomas/chroma/v2 v2.14.0 // indirect diff --git a/v2/go.sum b/v2/go.sum index f6df3507e..2cfe9f7ab 100644 --- a/v2/go.sum +++ b/v2/go.sum @@ -8,6 +8,8 @@ atomicgo.dev/schedule v0.1.0 h1:nTthAbhZS5YZmgYbb2+DH8uQIZcTlIrd4eYr3UQxEjs= atomicgo.dev/schedule v0.1.0/go.mod h1:xeUa3oAkiuHYh8bKiQBRojqAMq3PXXbJujjb0hw8pEU= dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 h1:N3IGoHHp9pb6mj1cbXbuaSXV/UMKwmbKLf53nQmtqMA= +git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3/go.mod h1:QtOLZGz8olr4qH2vWK0QH0w0O4T9fEIjMuWpKUsH7nc= github.com/MarvinJWendt/testza v0.1.0/go.mod h1:7AxNvlfeHP7Z/hDQ5JtE3OKYT3XFUeLCDE2DQninSqs= github.com/MarvinJWendt/testza v0.2.1/go.mod h1:God7bhG8n6uQxwdScay+gjm9/LnO4D3kkcZX4hv9Rp8= github.com/MarvinJWendt/testza v0.2.8/go.mod h1:nwIcjmr0Zz+Rcwfh3/4UhBp7ePKVhuBExvZqnKYWlII= diff --git a/v2/internal/frontend/desktop/darwin/Application.h b/v2/internal/frontend/desktop/darwin/Application.h index 4d8bbd37b..c3cd8075a 100644 --- a/v2/internal/frontend/desktop/darwin/Application.h +++ b/v2/internal/frontend/desktop/darwin/Application.h @@ -69,6 +69,21 @@ void UpdateMenuItem(void* nsmenuitem, int checked); void RunMainLoop(void); void ReleaseContext(void *inctx); +/* Notifications */ +bool IsNotificationAvailable(void *inctx); +bool CheckBundleIdentifier(void *inctx); +bool EnsureDelegateInitialized(void *inctx); +void RequestNotificationAuthorization(void *inctx, int channelID); +void CheckNotificationAuthorization(void *inctx, int channelID); +void SendNotification(void *inctx, int channelID, const char *identifier, const char *title, const char *subtitle, const char *body, const char *data_json); +void SendNotificationWithActions(void *inctx, int channelID, const char *identifier, const char *title, const char *subtitle, const char *body, const char *categoryId, const char *actions_json); +void RegisterNotificationCategory(void *inctx, int channelID, const char *categoryId, const char *actions_json, bool hasReplyField, const char *replyPlaceholder, const char *replyButtonTitle); +void RemoveNotificationCategory(void *inctx, int channelID, const char *categoryId); +void RemoveAllPendingNotifications(void *inctx); +void RemovePendingNotification(void *inctx, const char *identifier); +void RemoveAllDeliveredNotifications(void *inctx); +void RemoveDeliveredNotification(void *inctx, const char *identifier); + NSString* safeInit(const char* input); #endif /* Application_h */ diff --git a/v2/internal/frontend/desktop/darwin/Application.m b/v2/internal/frontend/desktop/darwin/Application.m index 38d349c2c..38b2f35ef 100644 --- a/v2/internal/frontend/desktop/darwin/Application.m +++ b/v2/internal/frontend/desktop/darwin/Application.m @@ -367,6 +367,74 @@ void AppendSeparator(void* inMenu) { } +bool IsNotificationAvailable(void *inctx) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + return [ctx IsNotificationAvailable]; +} + +bool CheckBundleIdentifier(void *inctx) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + return [ctx CheckBundleIdentifier]; +} + +bool EnsureDelegateInitialized(void *inctx) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + return [ctx EnsureDelegateInitialized]; +} + +void RequestNotificationAuthorization(void *inctx, int channelID) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + [ctx RequestNotificationAuthorization:channelID]; +} + +void CheckNotificationAuthorization(void *inctx, int channelID) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + [ctx CheckNotificationAuthorization:channelID]; +} + +void SendNotification(void *inctx, int channelID, const char *identifier, const char *title, const char *subtitle, const char *body, const char *data_json) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + [ctx SendNotification:channelID :identifier :title :subtitle :body :data_json]; +} + +void SendNotificationWithActions(void *inctx, int channelID, const char *identifier, const char *title, const char *subtitle, const char *body, const char *categoryId, const char *actions_json) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + + [ctx SendNotificationWithActions:channelID :identifier :title :subtitle :body :categoryId :actions_json]; +} + +void RegisterNotificationCategory(void *inctx, int channelID, const char *categoryId, const char *actions_json, bool hasReplyField, const char *replyPlaceholder, const char *replyButtonTitle) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + + [ctx RegisterNotificationCategory:channelID :categoryId :actions_json :hasReplyField :replyPlaceholder :replyButtonTitle]; +} + +void RemoveNotificationCategory(void *inctx, int channelID, const char *categoryId) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + + [ctx RemoveNotificationCategory:channelID :categoryId]; +} + +void RemoveAllPendingNotifications(void *inctx) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + [ctx RemoveAllPendingNotifications]; +} + +void RemovePendingNotification(void *inctx, const char *identifier) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + [ctx RemovePendingNotification:identifier]; +} + +void RemoveAllDeliveredNotifications(void *inctx) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + [ctx RemoveAllDeliveredNotifications]; +} + +void RemoveDeliveredNotification(void *inctx, const char *identifier) { + WailsContext *ctx = (__bridge WailsContext*)inctx; + [ctx RemoveDeliveredNotification:identifier]; +} + void Run(void *inctx, const char* url) { WailsContext *ctx = (__bridge WailsContext*) inctx; diff --git a/v2/internal/frontend/desktop/darwin/WailsContext.h b/v2/internal/frontend/desktop/darwin/WailsContext.h index 2ec6d8707..aafc3a1d4 100644 --- a/v2/internal/frontend/desktop/darwin/WailsContext.h +++ b/v2/internal/frontend/desktop/darwin/WailsContext.h @@ -92,10 +92,24 @@ struct Preferences { - (void) ShowApplication; - (void) Quit; --(void) MessageDialog :(NSString*)dialogType :(NSString*)title :(NSString*)message :(NSString*)button1 :(NSString*)button2 :(NSString*)button3 :(NSString*)button4 :(NSString*)defaultButton :(NSString*)cancelButton :(void*)iconData :(int)iconDataLength; +- (void) MessageDialog :(NSString*)dialogType :(NSString*)title :(NSString*)message :(NSString*)button1 :(NSString*)button2 :(NSString*)button3 :(NSString*)button4 :(NSString*)defaultButton :(NSString*)cancelButton :(void*)iconData :(int)iconDataLength; - (void) OpenFileDialog :(NSString*)title :(NSString*)defaultFilename :(NSString*)defaultDirectory :(bool)allowDirectories :(bool)allowFiles :(bool)canCreateDirectories :(bool)treatPackagesAsDirectories :(bool)resolveAliases :(bool)showHiddenFiles :(bool)allowMultipleSelection :(NSString*)filters; - (void) SaveFileDialog :(NSString*)title :(NSString*)defaultFilename :(NSString*)defaultDirectory :(bool)canCreateDirectories :(bool)treatPackagesAsDirectories :(bool)showHiddenFiles :(NSString*)filters; +- (bool) IsNotificationAvailable; +- (bool) CheckBundleIdentifier; +- (bool) EnsureDelegateInitialized; +- (void) RequestNotificationAuthorization:(int)channelID; +- (void) CheckNotificationAuthorization:(int)channelID; +- (void) SendNotification:(int)channelID :(const char *)identifier :(const char *)title :(const char *)subtitle :(const char *)body :(const char *)dataJSON; +- (void) SendNotificationWithActions:(int)channelID :(const char *)identifier :(const char *)title :(const char *)subtitle :(const char *)body :(const char *)categoryId :(const char *)actionsJSON; +- (void) RegisterNotificationCategory:(int)channelID :(const char *)categoryId :(const char *)actionsJSON :(bool)hasReplyField :(const char *)replyPlaceholder :(const char *)replyButtonTitle; +- (void) RemoveNotificationCategory:(int)channelID :(const char *)categoryId; +- (void) RemoveAllPendingNotifications; +- (void) RemovePendingNotification:(const char *)identifier; +- (void) RemoveAllDeliveredNotifications; +- (void) RemoveDeliveredNotification:(const char *)identifier; + - (void) loadRequest:(NSString*)url; - (void) ExecJS:(NSString*)script; - (NSScreen*) getCurrentScreen; diff --git a/v2/internal/frontend/desktop/darwin/WailsContext.m b/v2/internal/frontend/desktop/darwin/WailsContext.m index 7c9660d54..51993eda2 100644 --- a/v2/internal/frontend/desktop/darwin/WailsContext.m +++ b/v2/internal/frontend/desktop/darwin/WailsContext.m @@ -5,6 +5,7 @@ // Created by Lea Anthony on 10/10/21. // +#include "Application.h" #import #import #import "WailsContext.h" @@ -36,6 +37,14 @@ typedef void (^schemeTaskCaller)(id); @end +// Notifications +#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 101400 +#import +#endif + +extern void captureResult(int channelID, bool success, const char* error); +extern void didReceiveNotificationResponse(const char *jsonPayload, const char* error); + @implementation WailsContext - (void) SetSize:(int)width :(int)height { @@ -723,6 +732,357 @@ typedef void (^schemeTaskCaller)(id); } +/***** Notifications ******/ +- (bool) IsNotificationAvailable { + if (@available(macOS 10.14, *)) { + return YES; + } else { + return NO; + } +} + +- (bool) CheckBundleIdentifier { + NSBundle *main = [NSBundle mainBundle]; + if (main.bundleIdentifier == nil) { + return NO; + } + return YES; +} + +- (void)userNotificationCenter:(UNUserNotificationCenter *)center + willPresentNotification:(UNNotification *)notification + withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler API_AVAILABLE(macos(10.14)) { + UNNotificationPresentationOptions options = UNNotificationPresentationOptionSound; + + if (@available(macOS 11.0, *)) { + // These options are only available in macOS 11.0+ + options = UNNotificationPresentationOptionList | + UNNotificationPresentationOptionBanner | + UNNotificationPresentationOptionSound; + } + + completionHandler(options); +} + +- (void)userNotificationCenter:(UNUserNotificationCenter *)center +didReceiveNotificationResponse:(UNNotificationResponse *)response + withCompletionHandler:(void (^)(void))completionHandler API_AVAILABLE(macos(10.14)) { + + NSMutableDictionary *payload = [NSMutableDictionary dictionary]; + + [payload setObject:response.notification.request.identifier forKey:@"id"]; + [payload setObject:response.actionIdentifier forKey:@"actionIdentifier"]; + [payload setObject:response.notification.request.content.title ?: @"" forKey:@"title"]; + [payload setObject:response.notification.request.content.body ?: @"" forKey:@"body"]; + + if (response.notification.request.content.categoryIdentifier) { + [payload setObject:response.notification.request.content.categoryIdentifier forKey:@"categoryId"]; + } + + if (response.notification.request.content.subtitle) { + [payload setObject:response.notification.request.content.subtitle forKey:@"subtitle"]; + } + + if (response.notification.request.content.userInfo) { + [payload setObject:response.notification.request.content.userInfo forKey:@"userInfo"]; + } + + if ([response isKindOfClass:[UNTextInputNotificationResponse class]]) { + UNTextInputNotificationResponse *textResponse = (UNTextInputNotificationResponse *)response; + [payload setObject:textResponse.userText forKey:@"userText"]; + } + + NSError *error = nil; + NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload options:0 error:&error]; + if (error) { + NSString *errorMsg = [NSString stringWithFormat:@"Error: %@", [error localizedDescription]]; + didReceiveNotificationResponse(NULL, [errorMsg UTF8String]); + } else { + NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding]; + didReceiveNotificationResponse([jsonString UTF8String], NULL); + } + + completionHandler(); +} + +- (bool) EnsureDelegateInitialized { + if (@available(macOS 10.14, *)) { + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + center.delegate = (id)self; + return YES; + } + return NO; +} + +- (void) RequestNotificationAuthorization :(int)channelID { + if (@available(macOS 10.14, *)) { + if (![self EnsureDelegateInitialized]) { + NSString *errorMsg = @"Notification delegate has been lost. Reinitialize the notification service."; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + UNAuthorizationOptions options = UNAuthorizationOptionAlert | UNAuthorizationOptionSound | UNAuthorizationOptionBadge; + + [center requestAuthorizationWithOptions:options completionHandler:^(BOOL granted, NSError * _Nullable error) { + if (error) { + NSString *errorMsg = [NSString stringWithFormat:@"Error: %@", [error localizedDescription]]; + captureResult(channelID, false, [errorMsg UTF8String]); + } else { + captureResult(channelID, granted, NULL); + } + }]; + } else { + captureResult(channelID, false, "Notifications not available on macOS versions prior to 10.14"); + } +} + +- (void) CheckNotificationAuthorization :(int) channelID { + if (@available(macOS 10.14, *)) { + if (![self EnsureDelegateInitialized]) { + NSString *errorMsg = @"Notification delegate has been lost. Reinitialize the notification service."; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings *settings) { + BOOL isAuthorized = (settings.authorizationStatus == UNAuthorizationStatusAuthorized); + captureResult(channelID, isAuthorized, NULL); + }]; + } else { + captureResult(channelID, false, "Notifications not available on macOS versions prior to 10.14"); + } +} + +- (UNMutableNotificationContent *)createNotificationContent:(const char *)title subtitle:(const char *)subtitle body:(const char *)body dataJSON:(const char *)dataJSON error:(NSError **)contentError API_AVAILABLE(macos(10.14)) { + if (title == NULL) title = ""; + if (body == NULL) body = ""; + + NSString *nsTitle = [NSString stringWithUTF8String:title]; + NSString *nsSubtitle = subtitle ? [NSString stringWithUTF8String:subtitle] : @""; + NSString *nsBody = [NSString stringWithUTF8String:body]; + + UNMutableNotificationContent *content = [[[UNMutableNotificationContent alloc] init] autorelease]; + content.title = nsTitle; + if (![nsSubtitle isEqualToString:@""]) { + content.subtitle = nsSubtitle; + } + content.body = nsBody; + content.sound = [UNNotificationSound defaultSound]; + + // Parse JSON data if provided + if (dataJSON) { + NSString *dataJsonStr = [NSString stringWithUTF8String:dataJSON]; + NSData *jsonData = [dataJsonStr dataUsingEncoding:NSUTF8StringEncoding]; + NSError *error = nil; + NSDictionary *parsedData = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:&error]; + if (!error && parsedData) { + content.userInfo = parsedData; + } else if (error) { + if (contentError) *contentError = error; + } + } + + return content; +} + +- (void) sendNotificationWithRequest:(UNNotificationRequest *)request channelID:(int)channelID API_AVAILABLE(macos(10.14)) { + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + [center addNotificationRequest:request withCompletionHandler:^(NSError * _Nullable error) { + if (error) { + NSString *errorMsg = [NSString stringWithFormat:@"Error: %@", [error localizedDescription]]; + captureResult(channelID, false, [errorMsg UTF8String]); + } else { + captureResult(channelID, true, NULL); + } + }]; +} + +- (void) SendNotification:(int)channelID :(const char *)identifier :(const char *)title :(const char *)subtitle :(const char *)body :(const char *)dataJSON API_AVAILABLE(macos(10.14)) { + if (![self EnsureDelegateInitialized]) { + NSString *errorMsg = @"Notification delegate has been lost. Reinitialize the notification service."; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + + NSString *nsIdentifier = [NSString stringWithUTF8String:identifier]; + + NSError *contentError = nil; + UNMutableNotificationContent *content = [self createNotificationContent:title subtitle:subtitle body:body dataJSON:dataJSON error:&contentError]; + if (contentError) { + NSString *errorMsg = [NSString stringWithFormat:@"Error: %@", [contentError localizedDescription]]; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + + UNTimeIntervalNotificationTrigger *trigger = nil; + UNNotificationRequest *request = [UNNotificationRequest requestWithIdentifier:nsIdentifier content:content trigger:trigger]; + + [self sendNotificationWithRequest:request channelID:channelID]; +} + +- (void) SendNotificationWithActions:(int)channelID :(const char *)identifier :(const char *)title :(const char *)subtitle :(const char *)body :(const char *)categoryId :(const char *)dataJSON API_AVAILABLE(macos(10.14)) { + if (![self EnsureDelegateInitialized]) { + NSString *errorMsg = @"Notification delegate has been lost. Reinitialize the notification service."; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + + NSString *nsIdentifier = [NSString stringWithUTF8String:identifier]; + NSString *nsCategoryId = [NSString stringWithUTF8String:categoryId]; + + NSError *contentError = nil; + UNMutableNotificationContent *content = [self createNotificationContent:title subtitle:subtitle body:body dataJSON:dataJSON error:&contentError]; + if (contentError) { + NSString *errorMsg = [NSString stringWithFormat:@"Error: %@", [contentError localizedDescription]]; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + + content.categoryIdentifier = nsCategoryId; + + UNTimeIntervalNotificationTrigger *trigger = nil; + UNNotificationRequest *request = [UNNotificationRequest requestWithIdentifier:nsIdentifier content:content trigger:trigger]; + + [self sendNotificationWithRequest:request channelID:channelID]; +} + +- (void) RegisterNotificationCategory:(int)channelID :(const char *)categoryId :(const char *)actionsJSON :(bool)hasReplyField :(const char *)replyPlaceholder :(const char *)replyButtonTitle API_AVAILABLE(macos(10.14)) { + if (![self EnsureDelegateInitialized]) { + NSString *errorMsg = @"Notification delegate has been lost. Reinitialize the notification service."; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + + NSString *nsCategoryId = [NSString stringWithUTF8String:categoryId]; + NSString *actionsJsonStr = actionsJSON ? [NSString stringWithUTF8String:actionsJSON] : @"[]"; + + NSData *jsonData = [actionsJsonStr dataUsingEncoding:NSUTF8StringEncoding]; + NSError *error = nil; + NSArray *actionsArray = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:&error]; + + if (error) { + NSString *errorMsg = [NSString stringWithFormat:@"Error: %@", [error localizedDescription]]; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + + NSMutableArray *actions = [NSMutableArray array]; + for (NSDictionary *actionDict in actionsArray) { + NSString *actionId = actionDict[@"id"]; + NSString *actionTitle = actionDict[@"title"]; + BOOL destructive = [actionDict[@"destructive"] boolValue]; + + if (actionId && actionTitle) { + UNNotificationActionOptions options = UNNotificationActionOptionNone; + if (destructive) options |= UNNotificationActionOptionDestructive; + + UNNotificationAction *action = [UNNotificationAction actionWithIdentifier:actionId + title:actionTitle + options:options]; + [actions addObject:action]; + } + } + + if (hasReplyField) { + // Defensive NULL checks: if hasReplyField is true, both strings must be non-NULL + if (!replyPlaceholder || !replyButtonTitle) { + NSString *errorMsg = @"hasReplyField is true but replyPlaceholder or replyButtonTitle is NULL"; + captureResult(channelID, false, [errorMsg UTF8String]); + return; + } + NSString *placeholder = [NSString stringWithUTF8String:replyPlaceholder]; + NSString *buttonTitle = [NSString stringWithUTF8String:replyButtonTitle]; + UNTextInputNotificationAction *textAction = + [UNTextInputNotificationAction actionWithIdentifier:@"TEXT_REPLY" + title:buttonTitle + options:UNNotificationActionOptionNone + textInputButtonTitle:buttonTitle + textInputPlaceholder:placeholder]; + [actions addObject:textAction]; + } + + UNNotificationCategory *newCategory = [UNNotificationCategory categoryWithIdentifier:nsCategoryId + actions:actions + intentIdentifiers:@[] + options:UNNotificationCategoryOptionNone]; + + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + [center getNotificationCategoriesWithCompletionHandler:^(NSSet *categories) { + NSMutableSet *updatedCategories = [NSMutableSet setWithSet:categories]; + + // Remove existing category with same identifier if found + UNNotificationCategory *existingCategory = nil; + for (UNNotificationCategory *category in updatedCategories) { + if ([category.identifier isEqualToString:nsCategoryId]) { + existingCategory = category; + break; + } + } + if (existingCategory) { + [updatedCategories removeObject:existingCategory]; + } + + // Add the new category + [updatedCategories addObject:newCategory]; + [center setNotificationCategories:updatedCategories]; + + captureResult(channelID, true, NULL); + }]; +} + +- (void) RemoveNotificationCategory:(int)channelID :(const char *)categoryId API_AVAILABLE(macos(10.14)) { + NSString *nsCategoryId = [NSString stringWithUTF8String:categoryId]; + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + + [center getNotificationCategoriesWithCompletionHandler:^(NSSet *categories) { + NSMutableSet *updatedCategories = [NSMutableSet setWithSet:categories]; + + // Find and remove the matching category + UNNotificationCategory *categoryToRemove = nil; + for (UNNotificationCategory *category in updatedCategories) { + if ([category.identifier isEqualToString:nsCategoryId]) { + categoryToRemove = category; + break; + } + } + + if (categoryToRemove) { + [updatedCategories removeObject:categoryToRemove]; + [center setNotificationCategories:updatedCategories]; + captureResult(channelID, true, NULL); + } else { + NSString *errorMsg = [NSString stringWithFormat:@"Category '%@' not found", nsCategoryId]; + captureResult(channelID, false, [errorMsg UTF8String]); + } + }]; +} + +- (void) RemoveAllPendingNotifications API_AVAILABLE(macos(10.14)) { + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + [center removeAllPendingNotificationRequests]; +} + +- (void) RemovePendingNotification:(const char *)identifier API_AVAILABLE(macos(10.14)) { + NSString *nsIdentifier = [NSString stringWithUTF8String:identifier]; + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + [center removePendingNotificationRequestsWithIdentifiers:@[nsIdentifier]]; +} + +- (void) RemoveAllDeliveredNotifications API_AVAILABLE(macos(10.14)) { + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + [center removeAllDeliveredNotifications]; +} + +- (void) RemoveDeliveredNotification:(const char *)identifier API_AVAILABLE(macos(10.14)) { + NSString *nsIdentifier = [NSString stringWithUTF8String:identifier]; + UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter]; + [center removeDeliveredNotificationsWithIdentifiers:@[nsIdentifier]]; +} + + - (void) SetAbout :(NSString*)title :(NSString*)description :(void*)imagedata :(int)datalen { self.aboutTitle = title; self.aboutDescription = description; @@ -731,7 +1091,7 @@ typedef void (^schemeTaskCaller)(id); self.aboutImage = [[NSImage alloc] initWithData:imageData]; } --(void) About { +- (void) About { WailsAlert *alert = [WailsAlert new]; [alert setAlertStyle:NSAlertStyleInformational]; diff --git a/v2/internal/frontend/desktop/darwin/notifications.go b/v2/internal/frontend/desktop/darwin/notifications.go new file mode 100644 index 000000000..b788841e0 --- /dev/null +++ b/v2/internal/frontend/desktop/darwin/notifications.go @@ -0,0 +1,465 @@ +//go:build darwin +// +build darwin + +package darwin + +/* +#cgo CFLAGS:-x objective-c +#cgo LDFLAGS: -framework Foundation -framework Cocoa + +#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 110000 +#cgo LDFLAGS: -framework UserNotifications +#endif + +#import "Application.h" +#import "WailsContext.h" +*/ +import "C" +import ( + "context" + "encoding/json" + "fmt" + "os" + "sync" + "time" + "unsafe" + + "github.com/wailsapp/wails/v2/internal/frontend" +) + +// Package-scoped variable only accessible within this file +var ( + currentFrontend *Frontend + frontendMutex sync.RWMutex + // Notification channels + channels map[int]chan notificationChannel + channelsLock sync.Mutex + nextChannelID int + + notificationResultCallback func(result frontend.NotificationResult) + callbackLock sync.RWMutex +) + +const DefaultActionIdentifier = "DEFAULT_ACTION" +const AppleDefaultActionIdentifier = "com.apple.UNNotificationDefaultActionIdentifier" + +// setCurrentFrontend sets the current frontend instance +// This is called when RequestNotificationAuthorization or CheckNotificationAuthorization is called +func setCurrentFrontend(f *Frontend) { + frontendMutex.Lock() + defer frontendMutex.Unlock() + currentFrontend = f +} + +// getCurrentFrontend gets the current frontend instance +func getCurrentFrontend() *Frontend { + frontendMutex.RLock() + defer frontendMutex.RUnlock() + return currentFrontend +} + +type notificationChannel struct { + Success bool + Error error +} + +func (f *Frontend) InitializeNotifications() error { + if !f.IsNotificationAvailable() { + return fmt.Errorf("notifications are not available on this system") + } + if !f.checkBundleIdentifier() { + return fmt.Errorf("notifications require a valid bundle identifier") + } + if !bool(C.EnsureDelegateInitialized(f.mainWindow.context)) { + return fmt.Errorf("failed to initialize notification center delegate") + } + + channels = make(map[int]chan notificationChannel) + nextChannelID = 0 + + setCurrentFrontend(f) + + return nil +} + +// CleanupNotifications is a macOS stub that does nothing. +// (Linux-specific cleanup) +func (f *Frontend) CleanupNotifications() { + // No cleanup needed on macOS +} + +func (f *Frontend) IsNotificationAvailable() bool { + return bool(C.IsNotificationAvailable(f.mainWindow.context)) +} + +func (f *Frontend) checkBundleIdentifier() bool { + return bool(C.CheckBundleIdentifier(f.mainWindow.context)) +} + +func (f *Frontend) RequestNotificationAuthorization() (bool, error) { + ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second) + defer cancel() + + id, resultCh := f.registerChannel() + + C.RequestNotificationAuthorization(f.mainWindow.context, C.int(id)) + + select { + case result := <-resultCh: + close(resultCh) + return result.Success, result.Error + case <-ctx.Done(): + f.cleanupChannel(id) + return false, fmt.Errorf("notification authorization timed out after 3 minutes: %w", ctx.Err()) + } +} + +func (f *Frontend) CheckNotificationAuthorization() (bool, error) { + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + + id, resultCh := f.registerChannel() + + C.CheckNotificationAuthorization(f.mainWindow.context, C.int(id)) + + select { + case result := <-resultCh: + close(resultCh) + return result.Success, result.Error + case <-ctx.Done(): + f.cleanupChannel(id) + return false, fmt.Errorf("notification authorization timed out after 15s: %w", ctx.Err()) + } +} + +// SendNotification sends a basic notification with a unique identifier, title, subtitle, and body. +func (f *Frontend) SendNotification(options frontend.NotificationOptions) error { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + cIdentifier := C.CString(options.ID) + cTitle := C.CString(options.Title) + cSubtitle := C.CString(options.Subtitle) + cBody := C.CString(options.Body) + defer C.free(unsafe.Pointer(cIdentifier)) + defer C.free(unsafe.Pointer(cTitle)) + defer C.free(unsafe.Pointer(cSubtitle)) + defer C.free(unsafe.Pointer(cBody)) + + var cDataJSON *C.char + if options.Data != nil { + jsonData, err := json.Marshal(options.Data) + if err != nil { + return fmt.Errorf("failed to marshal notification data: %w", err) + } + cDataJSON = C.CString(string(jsonData)) + defer C.free(unsafe.Pointer(cDataJSON)) + } + + id, resultCh := f.registerChannel() + C.SendNotification(f.mainWindow.context, C.int(id), cIdentifier, cTitle, cSubtitle, cBody, cDataJSON) + + select { + case result := <-resultCh: + close(resultCh) + if !result.Success { + if result.Error != nil { + return result.Error + } + return fmt.Errorf("sending notification failed") + } + return nil + case <-ctx.Done(): + f.cleanupChannel(id) + return fmt.Errorf("sending notification timed out: %w", ctx.Err()) + } +} + +// SendNotificationWithActions sends a notification with additional actions and inputs. +// A NotificationCategory must be registered with RegisterNotificationCategory first. The `CategoryID` must match the registered category. +// If a NotificationCategory is not registered a basic notification will be sent. +func (f *Frontend) SendNotificationWithActions(options frontend.NotificationOptions) error { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + cIdentifier := C.CString(options.ID) + cTitle := C.CString(options.Title) + cSubtitle := C.CString(options.Subtitle) + cBody := C.CString(options.Body) + cCategoryID := C.CString(options.CategoryID) + defer C.free(unsafe.Pointer(cIdentifier)) + defer C.free(unsafe.Pointer(cTitle)) + defer C.free(unsafe.Pointer(cSubtitle)) + defer C.free(unsafe.Pointer(cBody)) + defer C.free(unsafe.Pointer(cCategoryID)) + + var cDataJSON *C.char + if options.Data != nil { + jsonData, err := json.Marshal(options.Data) + if err != nil { + return fmt.Errorf("failed to marshal notification data: %w", err) + } + cDataJSON = C.CString(string(jsonData)) + defer C.free(unsafe.Pointer(cDataJSON)) + } + + id, resultCh := f.registerChannel() + C.SendNotificationWithActions(f.mainWindow.context, C.int(id), cIdentifier, cTitle, cSubtitle, cBody, cCategoryID, cDataJSON) + + select { + case result := <-resultCh: + close(resultCh) + if !result.Success { + if result.Error != nil { + return result.Error + } + return fmt.Errorf("sending notification failed") + } + return nil + case <-ctx.Done(): + f.cleanupChannel(id) + return fmt.Errorf("sending notification timed out: %w", ctx.Err()) + } +} + +// RegisterNotificationCategory registers a new NotificationCategory to be used with SendNotificationWithActions. +// Registering a category with the same name as a previously registered NotificationCategory will override it. +func (f *Frontend) RegisterNotificationCategory(category frontend.NotificationCategory) error { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + cCategoryID := C.CString(category.ID) + defer C.free(unsafe.Pointer(cCategoryID)) + + actionsJSON, err := json.Marshal(category.Actions) + if err != nil { + return fmt.Errorf("failed to marshal notification category: %w", err) + } + cActionsJSON := C.CString(string(actionsJSON)) + defer C.free(unsafe.Pointer(cActionsJSON)) + + var cReplyPlaceholder, cReplyButtonTitle *C.char + if category.HasReplyField { + cReplyPlaceholder = C.CString(category.ReplyPlaceholder) + cReplyButtonTitle = C.CString(category.ReplyButtonTitle) + defer C.free(unsafe.Pointer(cReplyPlaceholder)) + defer C.free(unsafe.Pointer(cReplyButtonTitle)) + } + + id, resultCh := f.registerChannel() + C.RegisterNotificationCategory(f.mainWindow.context, C.int(id), cCategoryID, cActionsJSON, C.bool(category.HasReplyField), + cReplyPlaceholder, cReplyButtonTitle) + + select { + case result := <-resultCh: + close(resultCh) + if !result.Success { + if result.Error != nil { + return result.Error + } + return fmt.Errorf("category registration failed") + } + return nil + case <-ctx.Done(): + f.cleanupChannel(id) + return fmt.Errorf("category registration timed out: %w", ctx.Err()) + } +} + +// RemoveNotificationCategory remove a previously registered NotificationCategory. +func (f *Frontend) RemoveNotificationCategory(categoryId string) error { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + cCategoryID := C.CString(categoryId) + defer C.free(unsafe.Pointer(cCategoryID)) + + id, resultCh := f.registerChannel() + C.RemoveNotificationCategory(f.mainWindow.context, C.int(id), cCategoryID) + + select { + case result := <-resultCh: + close(resultCh) + if !result.Success { + if result.Error != nil { + return result.Error + } + return fmt.Errorf("category removal failed") + } + return nil + case <-ctx.Done(): + f.cleanupChannel(id) + return fmt.Errorf("category removal timed out: %w", ctx.Err()) + } +} + +// RemoveAllPendingNotifications removes all pending notifications. +func (f *Frontend) RemoveAllPendingNotifications() error { + C.RemoveAllPendingNotifications(f.mainWindow.context) + return nil +} + +// RemovePendingNotification removes a pending notification matching the unique identifier. +func (f *Frontend) RemovePendingNotification(identifier string) error { + cIdentifier := C.CString(identifier) + defer C.free(unsafe.Pointer(cIdentifier)) + C.RemovePendingNotification(f.mainWindow.context, cIdentifier) + return nil +} + +// RemoveAllDeliveredNotifications removes all delivered notifications. +func (f *Frontend) RemoveAllDeliveredNotifications() error { + C.RemoveAllDeliveredNotifications(f.mainWindow.context) + return nil +} + +// RemoveDeliveredNotification removes a delivered notification matching the unique identifier. +func (f *Frontend) RemoveDeliveredNotification(identifier string) error { + cIdentifier := C.CString(identifier) + defer C.free(unsafe.Pointer(cIdentifier)) + C.RemoveDeliveredNotification(f.mainWindow.context, cIdentifier) + return nil +} + +// RemoveNotification is a macOS stub that always returns nil. +// Use one of the following instead: +// RemoveAllPendingNotifications +// RemovePendingNotification +// RemoveAllDeliveredNotifications +// RemoveDeliveredNotification +// (Linux-specific) +func (f *Frontend) RemoveNotification(identifier string) error { + return nil +} + +func (f *Frontend) OnNotificationResponse(callback func(result frontend.NotificationResult)) { + callbackLock.Lock() + notificationResultCallback = callback + callbackLock.Unlock() +} + +//export captureResult +func captureResult(channelID C.int, success C.bool, errorMsg *C.char) { + f := getCurrentFrontend() + if f == nil { + return + } + + resultCh, exists := f.GetChannel(int(channelID)) + if !exists { + return + } + + var err error + if errorMsg != nil { + err = fmt.Errorf("%s", C.GoString(errorMsg)) + } + + resultCh <- notificationChannel{ + Success: bool(success), + Error: err, + } +} + +//export didReceiveNotificationResponse +func didReceiveNotificationResponse(jsonPayload *C.char, err *C.char) { + result := frontend.NotificationResult{} + + if err != nil { + errMsg := C.GoString(err) + result.Error = fmt.Errorf("notification response error: %s", errMsg) + handleNotificationResult(result) + + return + } + + if jsonPayload == nil { + result.Error = fmt.Errorf("received nil JSON payload in notification response") + handleNotificationResult(result) + return + } + + payload := C.GoString(jsonPayload) + + var response frontend.NotificationResponse + if err := json.Unmarshal([]byte(payload), &response); err != nil { + result.Error = fmt.Errorf("failed to unmarshal notification response: %w", err) + handleNotificationResult(result) + return + } + + if response.ActionIdentifier == AppleDefaultActionIdentifier { + response.ActionIdentifier = DefaultActionIdentifier + } + + result.Response = response + handleNotificationResult(result) +} + +func handleNotificationResult(result frontend.NotificationResult) { + callbackLock.Lock() + callback := notificationResultCallback + callbackLock.Unlock() + + if callback != nil { + go func() { + defer func() { + if r := recover(); r != nil { + // Log panic but don't crash the app + fmt.Fprintf(os.Stderr, "panic in notification callback: %v\n", r) + } + }() + callback(result) + }() + } +} + +// Helper methods + +func (f *Frontend) registerChannel() (int, chan notificationChannel) { + channelsLock.Lock() + defer channelsLock.Unlock() + + // Initialize channels map if it's nil + if channels == nil { + channels = make(map[int]chan notificationChannel) + nextChannelID = 0 + } + + id := nextChannelID + nextChannelID++ + + resultCh := make(chan notificationChannel, 1) + + channels[id] = resultCh + return id, resultCh +} + +func (f *Frontend) GetChannel(id int) (chan notificationChannel, bool) { + channelsLock.Lock() + defer channelsLock.Unlock() + + if channels == nil { + return nil, false + } + + ch, exists := channels[id] + if exists { + delete(channels, id) + } + return ch, exists +} + +func (f *Frontend) cleanupChannel(id int) { + channelsLock.Lock() + defer channelsLock.Unlock() + + if channels == nil { + return + } + + if ch, exists := channels[id]; exists { + delete(channels, id) + close(ch) + } +} diff --git a/v2/internal/frontend/desktop/linux/notifications.go b/v2/internal/frontend/desktop/linux/notifications.go new file mode 100644 index 000000000..80f0ae569 --- /dev/null +++ b/v2/internal/frontend/desktop/linux/notifications.go @@ -0,0 +1,594 @@ +//go:build linux +// +build linux + +package linux + +import ( + "context" + "encoding/json" + "fmt" + "os" + "path/filepath" + "sync" + + "github.com/godbus/dbus/v5" + "github.com/wailsapp/wails/v2/internal/frontend" +) + +var ( + conn *dbus.Conn + categories map[string]frontend.NotificationCategory = make(map[string]frontend.NotificationCategory) + categoriesLock sync.RWMutex + notifications map[uint32]*notificationData = make(map[uint32]*notificationData) + notificationsLock sync.RWMutex + notificationResultCallback func(result frontend.NotificationResult) + callbackLock sync.RWMutex + appName string + cancel context.CancelFunc +) + +type notificationData struct { + ID string + Title string + Subtitle string + Body string + CategoryID string + Data map[string]interface{} + DBusID uint32 + ActionMap map[string]string +} + +const ( + dbusNotificationInterface = "org.freedesktop.Notifications" + dbusNotificationPath = "/org/freedesktop/Notifications" + DefaultActionIdentifier = "DEFAULT_ACTION" +) + +// Creates a new Notifications Service. +func (f *Frontend) InitializeNotifications() error { + // Clean up any previous initialization + f.CleanupNotifications() + + exe, err := os.Executable() + if err != nil { + return fmt.Errorf("failed to get executable: %w", err) + } + appName = filepath.Base(exe) + + _conn, err := dbus.ConnectSessionBus() + if err != nil { + return fmt.Errorf("failed to connect to session bus: %w", err) + } + conn = _conn + + if err := f.loadCategories(); err != nil { + f.logger.Warning("Failed to load notification categories: %v", err) + } + + var signalCtx context.Context + signalCtx, cancel = context.WithCancel(context.Background()) + + if err := f.setupSignalHandling(signalCtx); err != nil { + return fmt.Errorf("failed to set up notification signal handling: %w", err) + } + + return nil +} + +// CleanupNotifications cleans up notification resources +func (f *Frontend) CleanupNotifications() { + if cancel != nil { + cancel() + cancel = nil + } + + if conn != nil { + conn.Close() + conn = nil + } +} + +func (f *Frontend) IsNotificationAvailable() bool { + return true +} + +// RequestNotificationAuthorization is a Linux stub that always returns true, nil. +// (authorization is macOS-specific) +func (f *Frontend) RequestNotificationAuthorization() (bool, error) { + return true, nil +} + +// CheckNotificationAuthorization is a Linux stub that always returns true. +// (authorization is macOS-specific) +func (f *Frontend) CheckNotificationAuthorization() (bool, error) { + return true, nil +} + +// SendNotification sends a basic notification with a unique identifier, title, subtitle, and body. +func (f *Frontend) SendNotification(options frontend.NotificationOptions) error { + if conn == nil { + return fmt.Errorf("notifications not initialized") + } + + hints := map[string]dbus.Variant{} + + body := options.Body + if options.Subtitle != "" { + body = options.Subtitle + "\n" + body + } + + defaultActionID := "default" + actions := []string{defaultActionID, "Default"} + + actionMap := map[string]string{ + defaultActionID: DefaultActionIdentifier, + } + + hints["x-notification-id"] = dbus.MakeVariant(options.ID) + + if options.Data != nil { + userData, err := json.Marshal(options.Data) + if err == nil { + hints["x-user-data"] = dbus.MakeVariant(string(userData)) + } + } + + // Call the Notify method on the D-Bus interface + obj := conn.Object(dbusNotificationInterface, dbusNotificationPath) + call := obj.Call( + dbusNotificationInterface+".Notify", + 0, + appName, + uint32(0), + "", // Icon + options.Title, + body, + actions, + hints, + int32(-1), + ) + + if call.Err != nil { + return fmt.Errorf("failed to send notification: %w", call.Err) + } + + var dbusID uint32 + if err := call.Store(&dbusID); err != nil { + return fmt.Errorf("failed to store notification ID: %w", err) + } + + notification := ¬ificationData{ + ID: options.ID, + Title: options.Title, + Subtitle: options.Subtitle, + Body: options.Body, + Data: options.Data, + DBusID: dbusID, + ActionMap: actionMap, + } + + notificationsLock.Lock() + notifications[dbusID] = notification + notificationsLock.Unlock() + + return nil +} + +// SendNotificationWithActions sends a notification with additional actions. +func (f *Frontend) SendNotificationWithActions(options frontend.NotificationOptions) error { + if conn == nil { + return fmt.Errorf("notifications not initialized") + } + + categoriesLock.RLock() + category, exists := categories[options.CategoryID] + categoriesLock.RUnlock() + + if options.CategoryID == "" || !exists { + // Fall back to basic notification + return f.SendNotification(options) + } + + body := options.Body + if options.Subtitle != "" { + body = options.Subtitle + "\n" + body + } + + var actions []string + actionMap := make(map[string]string) + + defaultActionID := "default" + actions = append(actions, defaultActionID, "Default") + actionMap[defaultActionID] = DefaultActionIdentifier + + for _, action := range category.Actions { + actions = append(actions, action.ID, action.Title) + actionMap[action.ID] = action.ID + } + + hints := map[string]dbus.Variant{} + + hints["x-notification-id"] = dbus.MakeVariant(options.ID) + + hints["x-category-id"] = dbus.MakeVariant(options.CategoryID) + + if options.Data != nil { + userData, err := json.Marshal(options.Data) + if err == nil { + hints["x-user-data"] = dbus.MakeVariant(string(userData)) + } + } + + obj := conn.Object(dbusNotificationInterface, dbusNotificationPath) + call := obj.Call( + dbusNotificationInterface+".Notify", + 0, + appName, + uint32(0), + "", // Icon + options.Title, + body, + actions, + hints, + int32(-1), + ) + + if call.Err != nil { + return fmt.Errorf("failed to send notification: %w", call.Err) + } + + var dbusID uint32 + if err := call.Store(&dbusID); err != nil { + return fmt.Errorf("failed to store notification ID: %w", err) + } + + notification := ¬ificationData{ + ID: options.ID, + Title: options.Title, + Subtitle: options.Subtitle, + Body: options.Body, + CategoryID: options.CategoryID, + Data: options.Data, + DBusID: dbusID, + ActionMap: actionMap, + } + + notificationsLock.Lock() + notifications[dbusID] = notification + notificationsLock.Unlock() + + return nil +} + +// RegisterNotificationCategory registers a new NotificationCategory to be used with SendNotificationWithActions. +func (f *Frontend) RegisterNotificationCategory(category frontend.NotificationCategory) error { + categoriesLock.Lock() + categories[category.ID] = category + categoriesLock.Unlock() + + if err := f.saveCategories(); err != nil { + f.logger.Warning("Failed to save notification categories: %v", err) + } + + return nil +} + +// RemoveNotificationCategory removes a previously registered NotificationCategory. +func (f *Frontend) RemoveNotificationCategory(categoryId string) error { + categoriesLock.Lock() + delete(categories, categoryId) + categoriesLock.Unlock() + + if err := f.saveCategories(); err != nil { + f.logger.Warning("Failed to save notification categories: %v", err) + } + + return nil +} + +// RemoveAllPendingNotifications attempts to remove all active notifications. +func (f *Frontend) RemoveAllPendingNotifications() error { + notificationsLock.Lock() + dbusIDs := make([]uint32, 0, len(notifications)) + for id := range notifications { + dbusIDs = append(dbusIDs, id) + } + notificationsLock.Unlock() + + for _, id := range dbusIDs { + f.closeNotification(id) + } + + return nil +} + +// RemovePendingNotification removes a pending notification. +func (f *Frontend) RemovePendingNotification(identifier string) error { + var dbusID uint32 + found := false + + notificationsLock.Lock() + for id, notif := range notifications { + if notif.ID == identifier { + dbusID = id + found = true + break + } + } + notificationsLock.Unlock() + + if !found { + return nil + } + + return f.closeNotification(dbusID) +} + +// RemoveAllDeliveredNotifications functionally equivalent to RemoveAllPendingNotification on Linux. +func (f *Frontend) RemoveAllDeliveredNotifications() error { + return f.RemoveAllPendingNotifications() +} + +// RemoveDeliveredNotification functionally equivalent RemovePendingNotification on Linux. +func (f *Frontend) RemoveDeliveredNotification(identifier string) error { + return f.RemovePendingNotification(identifier) +} + +// RemoveNotification removes a notification by identifier. +func (f *Frontend) RemoveNotification(identifier string) error { + return f.RemovePendingNotification(identifier) +} + +func (f *Frontend) OnNotificationResponse(callback func(result frontend.NotificationResult)) { + callbackLock.Lock() + defer callbackLock.Unlock() + + notificationResultCallback = callback +} + +// Helper method to close a notification. +func (f *Frontend) closeNotification(id uint32) error { + if conn == nil { + return fmt.Errorf("notifications not initialized") + } + + obj := conn.Object(dbusNotificationInterface, dbusNotificationPath) + call := obj.Call(dbusNotificationInterface+".CloseNotification", 0, id) + + if call.Err != nil { + return fmt.Errorf("failed to close notification: %w", call.Err) + } + + return nil +} + +func (f *Frontend) getConfigDir() (string, error) { + configDir, err := os.UserConfigDir() + if err != nil { + return "", fmt.Errorf("failed to get user config directory: %w", err) + } + + appConfigDir := filepath.Join(configDir, appName) + if err := os.MkdirAll(appConfigDir, 0755); err != nil { + return "", fmt.Errorf("failed to create app config directory: %w", err) + } + + return appConfigDir, nil +} + +// Save notification categories. +func (f *Frontend) saveCategories() error { + configDir, err := f.getConfigDir() + if err != nil { + return err + } + + categoriesFile := filepath.Join(configDir, "notification-categories.json") + + categoriesLock.RLock() + categoriesData, err := json.MarshalIndent(categories, "", " ") + categoriesLock.RUnlock() + + if err != nil { + return fmt.Errorf("failed to marshal notification categories: %w", err) + } + + if err := os.WriteFile(categoriesFile, categoriesData, 0644); err != nil { + return fmt.Errorf("failed to write notification categories to disk: %w", err) + } + + return nil +} + +// Load notification categories. +func (f *Frontend) loadCategories() error { + configDir, err := f.getConfigDir() + if err != nil { + return err + } + + categoriesFile := filepath.Join(configDir, "notification-categories.json") + + if _, err := os.Stat(categoriesFile); os.IsNotExist(err) { + return nil + } + + categoriesData, err := os.ReadFile(categoriesFile) + if err != nil { + return fmt.Errorf("failed to read notification categories from disk: %w", err) + } + + _categories := make(map[string]frontend.NotificationCategory) + if err := json.Unmarshal(categoriesData, &_categories); err != nil { + return fmt.Errorf("failed to unmarshal notification categories: %w", err) + } + + categoriesLock.Lock() + categories = _categories + categoriesLock.Unlock() + + return nil +} + +// Setup signal handling for notification actions. +func (f *Frontend) setupSignalHandling(ctx context.Context) error { + if err := conn.AddMatchSignal( + dbus.WithMatchInterface(dbusNotificationInterface), + dbus.WithMatchMember("ActionInvoked"), + ); err != nil { + return err + } + + if err := conn.AddMatchSignal( + dbus.WithMatchInterface(dbusNotificationInterface), + dbus.WithMatchMember("NotificationClosed"), + ); err != nil { + return err + } + + c := make(chan *dbus.Signal, 10) + conn.Signal(c) + + go f.handleSignals(ctx, c) + + return nil +} + +// Handle incoming D-Bus signals. +func (f *Frontend) handleSignals(ctx context.Context, c chan *dbus.Signal) { + for { + select { + case <-ctx.Done(): + return + case signal, ok := <-c: + if !ok { + return + } + + switch signal.Name { + case dbusNotificationInterface + ".ActionInvoked": + f.handleActionInvoked(signal) + case dbusNotificationInterface + ".NotificationClosed": + f.handleNotificationClosed(signal) + } + } + } +} + +// Handle ActionInvoked signal. +func (f *Frontend) handleActionInvoked(signal *dbus.Signal) { + if len(signal.Body) < 2 { + return + } + + dbusID, ok := signal.Body[0].(uint32) + if !ok { + return + } + + actionID, ok := signal.Body[1].(string) + if !ok { + return + } + + notificationsLock.Lock() + notification, exists := notifications[dbusID] + if exists { + delete(notifications, dbusID) + } + notificationsLock.Unlock() + + if !exists { + return + } + + appActionID, ok := notification.ActionMap[actionID] + if !ok { + appActionID = actionID + } + + response := frontend.NotificationResponse{ + ID: notification.ID, + ActionIdentifier: appActionID, + Title: notification.Title, + Subtitle: notification.Subtitle, + Body: notification.Body, + CategoryID: notification.CategoryID, + UserInfo: notification.Data, + } + + result := frontend.NotificationResult{ + Response: response, + } + + handleNotificationResult(result) +} + +func handleNotificationResult(result frontend.NotificationResult) { + callbackLock.Lock() + callback := notificationResultCallback + callbackLock.Unlock() + + if callback != nil { + go func() { + defer func() { + if r := recover(); r != nil { + // Log panic but don't crash the app + fmt.Fprintf(os.Stderr, "panic in notification callback: %v\n", r) + } + }() + callback(result) + }() + } +} + +// Handle NotificationClosed signal. +// Reason codes: +// 1 - expired timeout +// 2 - dismissed by user (click on X) +// 3 - closed by CloseNotification call +// 4 - undefined/reserved +func (f *Frontend) handleNotificationClosed(signal *dbus.Signal) { + if len(signal.Body) < 2 { + return + } + + dbusID, ok := signal.Body[0].(uint32) + if !ok { + return + } + + reason, ok := signal.Body[1].(uint32) + if !ok { + reason = 0 // Unknown reason + } + + notificationsLock.Lock() + notification, exists := notifications[dbusID] + if exists { + delete(notifications, dbusID) + } + notificationsLock.Unlock() + + if !exists { + return + } + + if reason == 2 { + response := frontend.NotificationResponse{ + ID: notification.ID, + ActionIdentifier: DefaultActionIdentifier, + Title: notification.Title, + Subtitle: notification.Subtitle, + Body: notification.Body, + CategoryID: notification.CategoryID, + UserInfo: notification.Data, + } + + result := frontend.NotificationResult{ + Response: response, + } + + handleNotificationResult(result) + } +} diff --git a/v2/internal/frontend/desktop/windows/notifications.go b/v2/internal/frontend/desktop/windows/notifications.go new file mode 100644 index 000000000..0176b7077 --- /dev/null +++ b/v2/internal/frontend/desktop/windows/notifications.go @@ -0,0 +1,489 @@ +//go:build windows +// +build windows + +package windows + +import ( + "encoding/base64" + "encoding/json" + "log" + "sync" + + wintoast "git.sr.ht/~jackmordaunt/go-toast/v2/wintoast" + "github.com/google/uuid" + "github.com/wailsapp/wails/v2/internal/frontend" + "github.com/wailsapp/wails/v2/internal/frontend/desktop/windows/winc" + "github.com/wailsapp/wails/v2/internal/frontend/desktop/windows/winc/w32" + + "fmt" + "os" + "path/filepath" + _ "unsafe" // for go:linkname + + "git.sr.ht/~jackmordaunt/go-toast/v2" + "golang.org/x/sys/windows/registry" +) + +var ( + categories map[string]frontend.NotificationCategory + categoriesLock sync.RWMutex + appName string + appGUID string + iconPath string = "" + exePath string + iconOnce sync.Once + iconErr error + + notificationResultCallback func(result frontend.NotificationResult) + callbackLock sync.RWMutex +) + +const DefaultActionIdentifier = "DEFAULT_ACTION" + +const ( + ToastRegistryPath = `Software\Classes\AppUserModelId\` + ToastRegistryGuidKey = "CustomActivator" + NotificationCategoriesRegistryPath = `SOFTWARE\%s\NotificationCategories` + NotificationCategoriesRegistryKey = "Categories" +) + +// NotificationPayload combines the action ID and user data into a single structure +type NotificationPayload struct { + Action string `json:"action"` + Options frontend.NotificationOptions `json:"payload,omitempty"` +} + +func (f *Frontend) InitializeNotifications() error { + categoriesLock.Lock() + defer categoriesLock.Unlock() + categories = make(map[string]frontend.NotificationCategory) + + exe, err := os.Executable() + if err != nil { + return fmt.Errorf("failed to get executable: %w", err) + } + exePath = exe + appName = filepath.Base(exePath) + + appGUID, err = getGUID() + if err != nil { + return err + } + + iconPath = filepath.Join(os.TempDir(), appName+appGUID+".png") + + // Create the registry key for the toast activator + key, _, err := registry.CreateKey(registry.CURRENT_USER, + `Software\Classes\CLSID\`+appGUID+`\LocalServer32`, registry.ALL_ACCESS) + if err != nil { + return fmt.Errorf("failed to create CLSID key: %w", err) + } + defer key.Close() + + if err := key.SetStringValue("", fmt.Sprintf("\"%s\" %%1", exePath)); err != nil { + return fmt.Errorf("failed to set CLSID server path: %w", err) + } + + toast.SetAppData(toast.AppData{ + AppID: appName, + GUID: appGUID, + IconPath: iconPath, + ActivationExe: exePath, + }) + + toast.SetActivationCallback(func(args string, data []toast.UserData) { + result := frontend.NotificationResult{} + + actionIdentifier, options, err := parseNotificationResponse(args) + + if err != nil { + result.Error = err + } else { + // Subtitle is retained but was not shown with the notification + response := frontend.NotificationResponse{ + ID: options.ID, + ActionIdentifier: actionIdentifier, + Title: options.Title, + Subtitle: options.Subtitle, + Body: options.Body, + CategoryID: options.CategoryID, + UserInfo: options.Data, + } + + if userText, found := getUserText(data); found { + response.UserText = userText + } + + result.Response = response + } + + handleNotificationResult(result) + }) + + // Register the COM class factory for toast activation. + // This is required for Windows to activate the app when users interact with notifications. + // The go-toast library's SetAppData and SetActivationCallback handle the callback setup, + // but the COM class factory registration is not exposed via public APIs, so we use + // go:linkname to access the internal registerClassFactory function. + if err := registerToastClassFactory(wintoast.ClassFactory); err != nil { + return fmt.Errorf("CoRegisterClassObject failed: %w", err) + } + + return loadCategoriesFromRegistry() +} + +// registerToastClassFactory registers the COM class factory required for Windows toast notification activation. +// This function uses go:linkname to access the unexported registerClassFactory function from go-toast. +// The class factory is necessary for Windows COM activation when users click notification actions. +// Without this registration, notification actions will not activate the application. +// +// This is a workaround until go-toast exports this functionality via a public API. +// See: https://git.sr.ht/~jackmordaunt/go-toast +// +//go:linkname registerToastClassFactory git.sr.ht/~jackmordaunt/go-toast/v2/wintoast.registerClassFactory +func registerToastClassFactory(factory *wintoast.IClassFactory) error + +// CleanupNotifications is a Windows stub that does nothing. +// (Linux-specific cleanup) +func (f *Frontend) CleanupNotifications() { + // No cleanup needed on Windows +} + +func (f *Frontend) IsNotificationAvailable() bool { + return true +} + +func (f *Frontend) RequestNotificationAuthorization() (bool, error) { + return true, nil +} + +func (f *Frontend) CheckNotificationAuthorization() (bool, error) { + return true, nil +} + +// SendNotification sends a basic notification with a name, title, and body. All other options are ignored on Windows. +// (subtitle is only available on macOS and Linux) +func (f *Frontend) SendNotification(options frontend.NotificationOptions) error { + if err := f.saveIconToDir(); err != nil { + f.logger.Warning("Error saving icon: %v", err) + } + + n := toast.Notification{ + Title: options.Title, + Body: options.Body, + ActivationType: toast.Foreground, + ActivationArguments: DefaultActionIdentifier, + } + + encodedPayload, err := encodePayload(DefaultActionIdentifier, options) + if err != nil { + return fmt.Errorf("failed to encode notification payload: %w", err) + } + n.ActivationArguments = encodedPayload + + return n.Push() +} + +// SendNotificationWithActions sends a notification with additional actions and inputs. +// A NotificationCategory must be registered with RegisterNotificationCategory first. The `CategoryID` must match the registered category. +// If a NotificationCategory is not registered a basic notification will be sent. +// (subtitle is only available on macOS and Linux) +func (f *Frontend) SendNotificationWithActions(options frontend.NotificationOptions) error { + if err := f.saveIconToDir(); err != nil { + f.logger.Warning("Error saving icon: %v", err) + } + + categoriesLock.RLock() + nCategory, categoryExists := categories[options.CategoryID] + categoriesLock.RUnlock() + + if options.CategoryID == "" || !categoryExists { + f.logger.Warning("Category '%s' not found, sending basic notification without actions", options.CategoryID) + return f.SendNotification(options) + } + + n := toast.Notification{ + Title: options.Title, + Body: options.Body, + ActivationType: toast.Foreground, + ActivationArguments: DefaultActionIdentifier, + } + + for _, action := range nCategory.Actions { + n.Actions = append(n.Actions, toast.Action{ + Content: action.Title, + Arguments: action.ID, + }) + } + + if nCategory.HasReplyField { + n.Inputs = append(n.Inputs, toast.Input{ + ID: "userText", + Placeholder: nCategory.ReplyPlaceholder, + }) + + n.Actions = append(n.Actions, toast.Action{ + Content: nCategory.ReplyButtonTitle, + Arguments: "TEXT_REPLY", + InputID: "userText", + }) + } + + encodedPayload, err := encodePayload(n.ActivationArguments, options) + if err != nil { + return fmt.Errorf("failed to encode notification payload: %w", err) + } + n.ActivationArguments = encodedPayload + + for index := range n.Actions { + encodedPayload, err := encodePayload(n.Actions[index].Arguments, options) + if err != nil { + return fmt.Errorf("failed to encode notification payload: %w", err) + } + n.Actions[index].Arguments = encodedPayload + } + + return n.Push() +} + +// RegisterNotificationCategory registers a new NotificationCategory to be used with SendNotificationWithActions. +// Registering a category with the same name as a previously registered NotificationCategory will override it. +func (f *Frontend) RegisterNotificationCategory(category frontend.NotificationCategory) error { + categoriesLock.Lock() + defer categoriesLock.Unlock() + + categories[category.ID] = frontend.NotificationCategory{ + ID: category.ID, + Actions: category.Actions, + HasReplyField: category.HasReplyField, + ReplyPlaceholder: category.ReplyPlaceholder, + ReplyButtonTitle: category.ReplyButtonTitle, + } + + return saveCategoriesToRegistry() +} + +// RemoveNotificationCategory removes a previously registered NotificationCategory. +func (f *Frontend) RemoveNotificationCategory(categoryId string) error { + categoriesLock.Lock() + defer categoriesLock.Unlock() + + delete(categories, categoryId) + + return saveCategoriesToRegistry() +} + +// RemoveAllPendingNotifications is a Windows stub that always returns nil. +// (macOS and Linux only) +func (f *Frontend) RemoveAllPendingNotifications() error { + return nil +} + +// RemovePendingNotification is a Windows stub that always returns nil. +// (macOS and Linux only) +func (f *Frontend) RemovePendingNotification(_ string) error { + return nil +} + +// RemoveAllDeliveredNotifications is a Windows stub that always returns nil. +// (macOS and Linux only) +func (f *Frontend) RemoveAllDeliveredNotifications() error { + return nil +} + +// RemoveDeliveredNotification is a Windows stub that always returns nil. +// (macOS and Linux only) +func (f *Frontend) RemoveDeliveredNotification(_ string) error { + return nil +} + +// RemoveNotification is a Windows stub that always returns nil. +// (Linux-specific) +func (f *Frontend) RemoveNotification(identifier string) error { + return nil +} + +func (f *Frontend) OnNotificationResponse(callback func(result frontend.NotificationResult)) { + callbackLock.Lock() + defer callbackLock.Unlock() + + notificationResultCallback = callback +} + +func (f *Frontend) saveIconToDir() error { + iconOnce.Do(func() { + hIcon := w32.ExtractIcon(exePath, 0) + if hIcon == 0 { + iconErr = fmt.Errorf("ExtractIcon failed for %s", exePath) + return + } + defer w32.DestroyIcon(hIcon) + iconErr = winc.SaveHIconAsPNG(hIcon, iconPath) + }) + return iconErr +} + +func saveCategoriesToRegistry() error { + // We assume lock is held by caller + + registryPath := fmt.Sprintf(NotificationCategoriesRegistryPath, appName) + + key, _, err := registry.CreateKey( + registry.CURRENT_USER, + registryPath, + registry.ALL_ACCESS, + ) + if err != nil { + return err + } + defer key.Close() + + data, err := json.Marshal(categories) + if err != nil { + return err + } + + return key.SetStringValue(NotificationCategoriesRegistryKey, string(data)) +} + +func loadCategoriesFromRegistry() error { + // We assume lock is held by caller + + registryPath := fmt.Sprintf(NotificationCategoriesRegistryPath, appName) + + key, err := registry.OpenKey( + registry.CURRENT_USER, + registryPath, + registry.QUERY_VALUE, + ) + if err != nil { + if err == registry.ErrNotExist { + // Not an error, no saved categories + return nil + } + return fmt.Errorf("failed to open registry key: %w", err) + } + defer key.Close() + + data, _, err := key.GetStringValue(NotificationCategoriesRegistryKey) + if err != nil { + if err == registry.ErrNotExist { + // No value yet, but key exists + return nil + } + return fmt.Errorf("failed to read categories from registry: %w", err) + } + + _categories := make(map[string]frontend.NotificationCategory) + if err := json.Unmarshal([]byte(data), &_categories); err != nil { + return fmt.Errorf("failed to parse notification categories from registry: %w", err) + } + + categories = _categories + + return nil +} + +func getUserText(data []toast.UserData) (string, bool) { + for _, d := range data { + if d.Key == "userText" { + return d.Value, true + } + } + return "", false +} + +// encodePayload combines an action ID and user data into a single encoded string +func encodePayload(actionID string, options frontend.NotificationOptions) (string, error) { + payload := NotificationPayload{ + Action: actionID, + Options: options, + } + + jsonData, err := json.Marshal(payload) + if err != nil { + return actionID, err + } + + encodedPayload := base64.StdEncoding.EncodeToString(jsonData) + return encodedPayload, nil +} + +// decodePayload extracts the action ID and user data from an encoded payload +func decodePayload(encodedString string) (string, frontend.NotificationOptions, error) { + jsonData, err := base64.StdEncoding.DecodeString(encodedString) + if err != nil { + return encodedString, frontend.NotificationOptions{}, fmt.Errorf("failed to decode base64 payload: %w", err) + } + + var payload NotificationPayload + if err := json.Unmarshal(jsonData, &payload); err != nil { + return encodedString, frontend.NotificationOptions{}, fmt.Errorf("failed to unmarshal notification payload: %w", err) + } + + return payload.Action, payload.Options, nil +} + +// parseNotificationResponse updated to use structured payload decoding +func parseNotificationResponse(response string) (action string, options frontend.NotificationOptions, err error) { + actionID, options, err := decodePayload(response) + + if err != nil { + log.Printf("Warning: Failed to decode notification response: %v", err) + return response, frontend.NotificationOptions{}, err + } + + return actionID, options, nil +} + +func handleNotificationResult(result frontend.NotificationResult) { + callbackLock.RLock() + callback := notificationResultCallback + callbackLock.RUnlock() + + if callback != nil { + go func() { + defer func() { + if r := recover(); r != nil { + // Log panic but don't crash the app + fmt.Fprintf(os.Stderr, "panic in notification callback: %v\n", r) + } + }() + callback(result) + }() + } +} + +// Helper functions + +func getGUID() (string, error) { + keyPath := ToastRegistryPath + appName + + k, err := registry.OpenKey(registry.CURRENT_USER, keyPath, registry.QUERY_VALUE) + if err == nil { + guid, _, err := k.GetStringValue(ToastRegistryGuidKey) + k.Close() + if err == nil && guid != "" { + return guid, nil + } + } + + guid := generateGUID() + + k, _, err = registry.CreateKey(registry.CURRENT_USER, keyPath, registry.WRITE) + if err != nil { + return "", fmt.Errorf("failed to create registry key: %w", err) + } + defer k.Close() + + if err := k.SetStringValue(ToastRegistryGuidKey, guid); err != nil { + return "", fmt.Errorf("failed to write GUID to registry: %w", err) + } + + return guid, nil +} + +func generateGUID() string { + guid := uuid.New() + return fmt.Sprintf("{%s}", guid.String()) +} diff --git a/v2/internal/frontend/desktop/windows/winc/icon.go b/v2/internal/frontend/desktop/windows/winc/icon.go index 6a3e1a391..94e9198d6 100644 --- a/v2/internal/frontend/desktop/windows/winc/icon.go +++ b/v2/internal/frontend/desktop/windows/winc/icon.go @@ -10,11 +10,86 @@ package winc import ( "errors" "fmt" + "image" + "image/png" + "os" "syscall" + "unsafe" "github.com/wailsapp/wails/v2/internal/frontend/desktop/windows/winc/w32" ) +var ( + user32 = syscall.NewLazyDLL("user32.dll") + gdi32 = syscall.NewLazyDLL("gdi32.dll") + procGetIconInfo = user32.NewProc("GetIconInfo") + procDeleteObject = gdi32.NewProc("DeleteObject") + procGetObject = gdi32.NewProc("GetObjectW") + procGetDIBits = gdi32.NewProc("GetDIBits") + procCreateCompatibleDC = gdi32.NewProc("CreateCompatibleDC") + procSelectObject = gdi32.NewProc("SelectObject") + procDeleteDC = gdi32.NewProc("DeleteDC") +) + +func init() { + // Validate DLL loads at initialization time to surface missing APIs early + if err := user32.Load(); err != nil { + panic(fmt.Sprintf("failed to load user32.dll: %v", err)) + } + if err := gdi32.Load(); err != nil { + panic(fmt.Sprintf("failed to load gdi32.dll: %v", err)) + } +} + +// ICONINFO mirrors the Win32 ICONINFO struct +type ICONINFO struct { + FIcon int32 + XHotspot uint32 + YHotspot uint32 + HbmMask uintptr + HbmColor uintptr +} + +// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183376.aspx +type BITMAPINFOHEADER struct { + BiSize uint32 + BiWidth int32 + BiHeight int32 + BiPlanes uint16 + BiBitCount uint16 + BiCompression uint32 + BiSizeImage uint32 + BiXPelsPerMeter int32 + BiYPelsPerMeter int32 + BiClrUsed uint32 + BiClrImportant uint32 +} + +// http://msdn.microsoft.com/en-us/library/windows/desktop/dd162938.aspx +type RGBQUAD struct { + RgbBlue byte + RgbGreen byte + RgbRed byte + RgbReserved byte +} + +// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183375.aspx +type BITMAPINFO struct { + BmiHeader BITMAPINFOHEADER + BmiColors *RGBQUAD +} + +// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183371.aspx +type BITMAP struct { + BmType int32 + BmWidth int32 + BmHeight int32 + BmWidthBytes int32 + BmPlanes uint16 + BmBitsPixel uint16 + BmBits unsafe.Pointer +} + type Icon struct { handle w32.HICON } @@ -46,6 +121,95 @@ func ExtractIcon(fileName string, index int) (*Icon, error) { return ico, err } +func SaveHIconAsPNG(hIcon w32.HICON, filePath string) error { + // Get icon info + var iconInfo ICONINFO + ret, _, err := procGetIconInfo.Call( + uintptr(hIcon), + uintptr(unsafe.Pointer(&iconInfo)), + ) + if ret == 0 { + return err + } + defer procDeleteObject.Call(uintptr(iconInfo.HbmMask)) + defer procDeleteObject.Call(uintptr(iconInfo.HbmColor)) + + // Get bitmap info + var bmp BITMAP + ret, _, err = procGetObject.Call( + uintptr(iconInfo.HbmColor), + unsafe.Sizeof(bmp), + uintptr(unsafe.Pointer(&bmp)), + ) + if ret == 0 { + return err + } + + // Get screen DC for GetDIBits (bitmap must not be selected into a DC) + screenDC := w32.GetDC(0) + if screenDC == 0 { + return fmt.Errorf("failed to get screen DC") + } + defer w32.ReleaseDC(0, screenDC) + + // Prepare bitmap info header + var bi BITMAPINFO + bi.BmiHeader.BiSize = uint32(unsafe.Sizeof(bi.BmiHeader)) + bi.BmiHeader.BiWidth = bmp.BmWidth + bi.BmiHeader.BiHeight = bmp.BmHeight + bi.BmiHeader.BiPlanes = 1 + bi.BmiHeader.BiBitCount = 32 + bi.BmiHeader.BiCompression = w32.BI_RGB + + // Allocate memory for bitmap bits + width, height := int(bmp.BmWidth), int(bmp.BmHeight) + bufferSize := width * height * 4 + bits := make([]byte, bufferSize) + + // Get bitmap bits using screen DC (bitmap must not be selected into any DC) + ret, _, err = procGetDIBits.Call( + uintptr(screenDC), + uintptr(iconInfo.HbmColor), + 0, + uintptr(bmp.BmHeight), + uintptr(unsafe.Pointer(&bits[0])), + uintptr(unsafe.Pointer(&bi)), + w32.DIB_RGB_COLORS, + ) + if ret == 0 { + return fmt.Errorf("failed to get bitmap bits: %w", err) + } + + // Create Go image + img := image.NewRGBA(image.Rect(0, 0, width, height)) + + // Convert DIB to RGBA + for y := 0; y < height; y++ { + for x := 0; x < width; x++ { + // DIB is bottom-up, so we need to invert Y + dibIndex := ((height-1-y)*width + x) * 4 + // RGBA image is top-down + imgIndex := (y*width + x) * 4 + + // BGRA to RGBA + img.Pix[imgIndex] = bits[dibIndex+2] // R + img.Pix[imgIndex+1] = bits[dibIndex+1] // G + img.Pix[imgIndex+2] = bits[dibIndex] // B + img.Pix[imgIndex+3] = bits[dibIndex+3] // A + } + } + + // Create output file + outFile, err := os.Create(filePath) + if err != nil { + return err + } + defer outFile.Close() + + // Encode and save the image + return png.Encode(outFile, img) +} + func (ic *Icon) Destroy() bool { return w32.DestroyIcon(ic.handle) } diff --git a/v2/internal/frontend/dispatcher/systemcalls.go b/v2/internal/frontend/dispatcher/systemcalls.go index b090a416e..a13eb03b9 100644 --- a/v2/internal/frontend/dispatcher/systemcalls.go +++ b/v2/internal/frontend/dispatcher/systemcalls.go @@ -61,6 +61,102 @@ func (d *Dispatcher) processSystemCall(payload callMessage, sender frontend.Fron return false, err } return true, nil + case "InitializeNotifications": + err := sender.InitializeNotifications() + return nil, err + case "CleanupNotifications": + sender.CleanupNotifications() + return nil, nil + case "IsNotificationAvailable": + return sender.IsNotificationAvailable(), nil + case "RequestNotificationAuthorization": + authorized, err := sender.RequestNotificationAuthorization() + if err != nil { + return nil, err + } + return authorized, nil + case "CheckNotificationAuthorization": + authorized, err := sender.CheckNotificationAuthorization() + if err != nil { + return nil, err + } + return authorized, nil + case "SendNotification": + if len(payload.Args) < 1 { + return nil, errors.New("empty argument, cannot send notification") + } + var options frontend.NotificationOptions + if err := json.Unmarshal(payload.Args[0], &options); err != nil { + return nil, err + } + err := sender.SendNotification(options) + return nil, err + case "SendNotificationWithActions": + if len(payload.Args) < 1 { + return nil, errors.New("empty argument, cannot send notification") + } + var options frontend.NotificationOptions + if err := json.Unmarshal(payload.Args[0], &options); err != nil { + return nil, err + } + err := sender.SendNotificationWithActions(options) + return nil, err + case "RegisterNotificationCategory": + if len(payload.Args) < 1 { + return nil, errors.New("empty argument, cannot register category") + } + var category frontend.NotificationCategory + if err := json.Unmarshal(payload.Args[0], &category); err != nil { + return nil, err + } + err := sender.RegisterNotificationCategory(category) + return nil, err + case "RemoveNotificationCategory": + if len(payload.Args) < 1 { + return nil, errors.New("empty argument, cannot remove category") + } + var categoryId string + if err := json.Unmarshal(payload.Args[0], &categoryId); err != nil { + return nil, err + } + err := sender.RemoveNotificationCategory(categoryId) + return nil, err + case "RemoveAllPendingNotifications": + err := sender.RemoveAllPendingNotifications() + return nil, err + case "RemovePendingNotification": + if len(payload.Args) < 1 { + return nil, errors.New("empty argument, cannot remove notification") + } + var identifier string + if err := json.Unmarshal(payload.Args[0], &identifier); err != nil { + return nil, err + } + err := sender.RemovePendingNotification(identifier) + return nil, err + case "RemoveAllDeliveredNotifications": + err := sender.RemoveAllDeliveredNotifications() + return nil, err + case "RemoveDeliveredNotification": + if len(payload.Args) < 1 { + return nil, errors.New("empty argument, cannot remove notification") + } + var identifier string + if err := json.Unmarshal(payload.Args[0], &identifier); err != nil { + return nil, err + } + err := sender.RemoveDeliveredNotification(identifier) + return nil, err + case "RemoveNotification": + if len(payload.Args) < 1 { + return nil, errors.New("empty argument, cannot remove notification") + } + var identifier string + if err := json.Unmarshal(payload.Args[0], &identifier); err != nil { + return nil, err + } + err := sender.RemoveNotification(identifier) + return nil, err default: return nil, fmt.Errorf("unknown systemcall message: %s", payload.Name) } diff --git a/v2/internal/frontend/frontend.go b/v2/internal/frontend/frontend.go index 6b2ccbcae..873b61dc7 100644 --- a/v2/internal/frontend/frontend.go +++ b/v2/internal/frontend/frontend.go @@ -76,6 +76,51 @@ type MessageDialogOptions struct { Icon []byte } +// NotificationOptions contains configuration for a notification. +type NotificationOptions struct { + ID string `json:"id"` + Title string `json:"title"` + Subtitle string `json:"subtitle,omitempty"` // (macOS and Linux only) + Body string `json:"body,omitempty"` + CategoryID string `json:"categoryId,omitempty"` + Data map[string]interface{} `json:"data,omitempty"` +} + +// NotificationAction represents an action button for a notification. +type NotificationAction struct { + ID string `json:"id,omitempty"` + Title string `json:"title,omitempty"` + Destructive bool `json:"destructive,omitempty"` // (macOS-specific) +} + +// NotificationCategory groups actions for notifications. +type NotificationCategory struct { + ID string `json:"id,omitempty"` + Actions []NotificationAction `json:"actions,omitempty"` + HasReplyField bool `json:"hasReplyField,omitempty"` + ReplyPlaceholder string `json:"replyPlaceholder,omitempty"` + ReplyButtonTitle string `json:"replyButtonTitle,omitempty"` +} + +// NotificationResponse represents the response sent by interacting with a notification. +type NotificationResponse struct { + ID string `json:"id,omitempty"` + ActionIdentifier string `json:"actionIdentifier,omitempty"` + CategoryID string `json:"categoryId,omitempty"` // Consistent with NotificationOptions + Title string `json:"title,omitempty"` + Subtitle string `json:"subtitle,omitempty"` // (macOS and Linux only) + Body string `json:"body,omitempty"` + UserText string `json:"userText,omitempty"` + UserInfo map[string]interface{} `json:"userInfo,omitempty"` +} + +// NotificationResult represents the result of a notification response, +// returning the response or any errors that occurred. +type NotificationResult struct { + Response NotificationResponse + Error error +} + type Frontend interface { Run(ctx context.Context) error RunMainLoop() @@ -139,4 +184,21 @@ type Frontend interface { // Clipboard ClipboardGetText() (string, error) ClipboardSetText(text string) error + + // Notifications + InitializeNotifications() error + CleanupNotifications() + IsNotificationAvailable() bool + RequestNotificationAuthorization() (bool, error) + CheckNotificationAuthorization() (bool, error) + OnNotificationResponse(callback func(result NotificationResult)) + SendNotification(options NotificationOptions) error + SendNotificationWithActions(options NotificationOptions) error + RegisterNotificationCategory(category NotificationCategory) error + RemoveNotificationCategory(categoryId string) error + RemoveAllPendingNotifications() error + RemovePendingNotification(identifier string) error + RemoveAllDeliveredNotifications() error + RemoveDeliveredNotification(identifier string) error + RemoveNotification(identifier string) error } diff --git a/v2/internal/frontend/runtime/desktop/main.js b/v2/internal/frontend/runtime/desktop/main.js index 3fda7ef36..405d5f60d 100644 --- a/v2/internal/frontend/runtime/desktop/main.js +++ b/v2/internal/frontend/runtime/desktop/main.js @@ -27,6 +27,7 @@ import * as Browser from "./browser"; import * as Clipboard from "./clipboard"; import * as DragAndDrop from "./draganddrop"; import * as ContextMenu from "./contextmenu"; +import * as Notifications from "./notifications"; export function Quit() { window.WailsInvoke('Q'); @@ -52,6 +53,7 @@ window.runtime = { ...Screen, ...Clipboard, ...DragAndDrop, + ...Notifications, EventsOn, EventsOnce, EventsOnMultiple, diff --git a/v2/internal/frontend/runtime/desktop/notifications.js b/v2/internal/frontend/runtime/desktop/notifications.js new file mode 100644 index 000000000..25c01bb34 --- /dev/null +++ b/v2/internal/frontend/runtime/desktop/notifications.js @@ -0,0 +1,200 @@ +/* + _ __ _ __ +| | / /___ _(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ +/* jshint esversion: 9 */ + +import {Call} from "./calls"; + +/** + * Initialize the notification service for the application. + * This must be called before sending any notifications. + * On macOS, this also ensures the notification delegate is properly initialized. + * + * @export + * @return {Promise} + */ +export function InitializeNotifications() { + return Call(":wails:InitializeNotifications"); +} + +/** + * Clean up notification resources and release any held connections. + * This should be called when shutting down the application to properly release resources + * (primarily needed on Linux to close D-Bus connections). + * + * @export + * @return {Promise} + */ +export function CleanupNotifications() { + return Call(":wails:CleanupNotifications"); +} + +/** + * Check if notifications are available on the current platform. + * + * @export + * @return {Promise} True if notifications are available, false otherwise + */ +export function IsNotificationAvailable() { + return Call(":wails:IsNotificationAvailable"); +} + +/** + * Request notification authorization from the user. + * On macOS, this prompts the user to allow notifications. + * On other platforms, this always returns true. + * + * @export + * @return {Promise} True if authorization was granted, false otherwise + */ +export function RequestNotificationAuthorization() { + return Call(":wails:RequestNotificationAuthorization"); +} + +/** + * Check the current notification authorization status. + * On macOS, this checks if the app has notification permissions. + * On other platforms, this always returns true. + * + * @export + * @return {Promise} True if authorized, false otherwise + */ +export function CheckNotificationAuthorization() { + return Call(":wails:CheckNotificationAuthorization"); +} + +/** + * Send a basic notification with the given options. + * The notification will display with the provided title, subtitle (if supported), and body text. + * + * @export + * @param {Object} options - Notification options + * @param {string} options.id - Unique identifier for the notification + * @param {string} options.title - Notification title + * @param {string} [options.subtitle] - Notification subtitle (macOS and Linux only) + * @param {string} [options.body] - Notification body text + * @param {string} [options.categoryId] - Category ID for action buttons (requires SendNotificationWithActions) + * @param {Object} [options.data] - Additional user data to attach to the notification + * @return {Promise} + */ +export function SendNotification(options) { + return Call(":wails:SendNotification", [options]); +} + +/** + * Send a notification with action buttons. + * A NotificationCategory must be registered first using RegisterNotificationCategory. + * The options.categoryId must match a previously registered category ID. + * If the category is not found, a basic notification will be sent instead. + * + * @export + * @param {Object} options - Notification options + * @param {string} options.id - Unique identifier for the notification + * @param {string} options.title - Notification title + * @param {string} [options.subtitle] - Notification subtitle (macOS and Linux only) + * @param {string} [options.body] - Notification body text + * @param {string} options.categoryId - Category ID that matches a registered category + * @param {Object} [options.data] - Additional user data to attach to the notification + * @return {Promise} + */ +export function SendNotificationWithActions(options) { + return Call(":wails:SendNotificationWithActions", [options]); +} + +/** + * Register a notification category that can be used with SendNotificationWithActions. + * Categories define the action buttons and optional reply fields that will appear on notifications. + * Registering a category with the same ID as a previously registered category will override it. + * + * @export + * @param {Object} category - Notification category definition + * @param {string} category.id - Unique identifier for the category + * @param {Array} [category.actions] - Array of action buttons + * @param {string} category.actions[].id - Unique identifier for the action + * @param {string} category.actions[].title - Display title for the action button + * @param {boolean} [category.actions[].destructive] - Whether the action is destructive (macOS-specific) + * @param {boolean} [category.hasReplyField] - Whether to include a text input field for replies + * @param {string} [category.replyPlaceholder] - Placeholder text for the reply field (required if hasReplyField is true) + * @param {string} [category.replyButtonTitle] - Title for the reply button (required if hasReplyField is true) + * @return {Promise} + */ +export function RegisterNotificationCategory(category) { + return Call(":wails:RegisterNotificationCategory", [category]); +} + +/** + * Remove a previously registered notification category. + * + * @export + * @param {string} categoryId - The ID of the category to remove + * @return {Promise} + */ +export function RemoveNotificationCategory(categoryId) { + return Call(":wails:RemoveNotificationCategory", [categoryId]); +} + +/** + * Remove all pending notifications from the notification center. + * On Windows, this is a no-op as the platform manages notification lifecycle automatically. + * + * @export + * @return {Promise} + */ +export function RemoveAllPendingNotifications() { + return Call(":wails:RemoveAllPendingNotifications"); +} + +/** + * Remove a specific pending notification by its identifier. + * On Windows, this is a no-op as the platform manages notification lifecycle automatically. + * + * @export + * @param {string} identifier - The ID of the notification to remove + * @return {Promise} + */ +export function RemovePendingNotification(identifier) { + return Call(":wails:RemovePendingNotification", [identifier]); +} + +/** + * Remove all delivered notifications from the notification center. + * On Windows, this is a no-op as the platform manages notification lifecycle automatically. + * + * @export + * @return {Promise} + */ +export function RemoveAllDeliveredNotifications() { + return Call(":wails:RemoveAllDeliveredNotifications"); +} + +/** + * Remove a specific delivered notification by its identifier. + * On Windows, this is a no-op as the platform manages notification lifecycle automatically. + * + * @export + * @param {string} identifier - The ID of the notification to remove + * @return {Promise} + */ +export function RemoveDeliveredNotification(identifier) { + return Call(":wails:RemoveDeliveredNotification", [identifier]); +} + +/** + * Remove a notification by its identifier. + * This is a convenience function that works across platforms. + * On macOS, use the more specific RemovePendingNotification or RemoveDeliveredNotification functions. + * + * @export + * @param {string} identifier - The ID of the notification to remove + * @return {Promise} + */ +export function RemoveNotification(identifier) { + return Call(":wails:RemoveNotification", [identifier]); +} + diff --git a/v2/internal/frontend/runtime/ipc_websocket.js b/v2/internal/frontend/runtime/ipc_websocket.js index 1ca048df1..a0d6b4a70 100644 --- a/v2/internal/frontend/runtime/ipc_websocket.js +++ b/v2/internal/frontend/runtime/ipc_websocket.js @@ -1,9 +1,9 @@ (()=>{function D(t){console.log("%c wails dev %c "+t+" ","background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem","background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem")}function _(){}var A=t=>t;function N(t){return t()}function it(){return Object.create(null)}function b(t){t.forEach(N)}function w(t){return typeof t=="function"}function L(t,e){return t!=t?e==e:t!==e||t&&typeof t=="object"||typeof t=="function"}function ot(t){return Object.keys(t).length===0}function rt(t,...e){if(t==null)return _;let n=t.subscribe(...e);return n.unsubscribe?()=>n.unsubscribe():n}function st(t,e,n){t.$$.on_destroy.push(rt(e,n))}var ct=typeof window!="undefined",Ot=ct?()=>window.performance.now():()=>Date.now(),P=ct?t=>requestAnimationFrame(t):_;var x=new Set;function lt(t){x.forEach(e=>{e.c(t)||(x.delete(e),e.f())}),x.size!==0&&P(lt)}function Dt(t){let e;return x.size===0&&P(lt),{promise:new Promise(n=>{x.add(e={c:t,f:n})}),abort(){x.delete(e)}}}var ut=!1;function At(){ut=!0}function Lt(){ut=!1}function Bt(t,e){t.appendChild(e)}function at(t,e,n){let i=R(t);if(!i.getElementById(e)){let o=B("style");o.id=e,o.textContent=n,ft(i,o)}}function R(t){if(!t)return document;let e=t.getRootNode?t.getRootNode():t.ownerDocument;return e&&e.host?e:t.ownerDocument}function Tt(t){let e=B("style");return ft(R(t),e),e.sheet}function ft(t,e){return Bt(t.head||t,e),e.sheet}function W(t,e,n){t.insertBefore(e,n||null)}function S(t){t.parentNode.removeChild(t)}function B(t){return document.createElement(t)}function Jt(t){return document.createTextNode(t)}function dt(){return Jt("")}function ht(t,e,n){n==null?t.removeAttribute(e):t.getAttribute(e)!==n&&t.setAttribute(e,n)}function zt(t){return Array.from(t.childNodes)}function Ht(t,e,{bubbles:n=!1,cancelable:i=!1}={}){let o=document.createEvent("CustomEvent");return o.initCustomEvent(t,n,i,e),o}var T=new Map,J=0;function Gt(t){let e=5381,n=t.length;for(;n--;)e=(e<<5)-e^t.charCodeAt(n);return e>>>0}function qt(t,e){let n={stylesheet:Tt(e),rules:{}};return T.set(t,n),n}function pt(t,e,n,i,o,c,s,l=0){let f=16.666/i,r=`{ `;for(let g=0;g<=1;g+=f){let F=e+(n-e)*c(g);r+=g*100+`%{${s(F,1-F)}} `}let y=r+`100% {${s(n,1-n)}} -}`,a=`__svelte_${Gt(y)}_${l}`,u=R(t),{stylesheet:h,rules:p}=T.get(u)||qt(u,t);p[a]||(p[a]=!0,h.insertRule(`@keyframes ${a} ${y}`,h.cssRules.length));let v=t.style.animation||"";return t.style.animation=`${v?`${v}, `:""}${a} ${i}ms linear ${o}ms 1 both`,J+=1,a}function Kt(t,e){let n=(t.style.animation||"").split(", "),i=n.filter(e?c=>c.indexOf(e)<0:c=>c.indexOf("__svelte")===-1),o=n.length-i.length;o&&(t.style.animation=i.join(", "),J-=o,J||Nt())}function Nt(){P(()=>{J||(T.forEach(t=>{let{ownerNode:e}=t.stylesheet;e&&S(e)}),T.clear())})}var V;function C(t){V=t}var k=[];var _t=[],z=[],mt=[],Pt=Promise.resolve(),U=!1;function Rt(){U||(U=!0,Pt.then(yt))}function $(t){z.push(t)}var X=new Set,H=0;function yt(){let t=V;do{for(;H{E=null})),E}function Z(t,e,n){t.dispatchEvent(Ht(`${e?"intro":"outro"}${n}`))}var G=new Set,m;function gt(){m={r:0,c:[],p:m}}function bt(){m.r||b(m.c),m=m.p}function I(t,e){t&&t.i&&(G.delete(t),t.i(e))}function Q(t,e,n,i){if(t&&t.o){if(G.has(t))return;G.add(t),m.c.push(()=>{G.delete(t),i&&(n&&t.d(1),i())}),t.o(e)}else i&&i()}var Ut={duration:0};function Y(t,e,n,i){let o=e(t,n),c=i?0:1,s=null,l=null,f=null;function r(){f&&Kt(t,f)}function y(u,h){let p=u.b-c;return h*=Math.abs(p),{a:c,b:u.b,d:p,duration:h,start:u.start,end:u.start+h,group:u.group}}function a(u){let{delay:h=0,duration:p=300,easing:v=A,tick:g=_,css:F}=o||Ut,K={start:Ot()+h,b:u};u||(K.group=m,m.r+=1),s||l?l=K:(F&&(r(),f=pt(t,c,u,p,h,v,F)),u&&g(0,1),s=y(K,p),$(()=>Z(t,u,"start")),Dt(O=>{if(l&&O>l.start&&(s=y(l,p),l=null,Z(t,s.b,"start"),F&&(r(),f=pt(t,c,s.b,s.duration,0,v,o.css))),s){if(O>=s.end)g(c=s.b,1-c),Z(t,s.b,"end"),l||(s.b?r():--s.group.r||b(s.group.c)),s=null;else if(O>=s.start){let jt=O-s.start;c=s.a+s.d*v(jt/s.duration),g(c,1-c)}}return!!(s||l)}))}return{run(u){w(o)?Vt().then(()=>{o=o(),a(u)}):a(u)},end(){r(),s=l=null}}}var le=typeof window!="undefined"?window:typeof globalThis!="undefined"?globalThis:global;var ue=new Set(["allowfullscreen","allowpaymentrequest","async","autofocus","autoplay","checked","controls","default","defer","disabled","formnovalidate","hidden","inert","ismap","itemscope","loop","multiple","muted","nomodule","novalidate","open","playsinline","readonly","required","reversed","selected"]);function Xt(t,e,n,i){let{fragment:o,after_update:c}=t.$$;o&&o.m(e,n),i||$(()=>{let s=t.$$.on_mount.map(N).filter(w);t.$$.on_destroy?t.$$.on_destroy.push(...s):b(s),t.$$.on_mount=[]}),c.forEach($)}function wt(t,e){let n=t.$$;n.fragment!==null&&(b(n.on_destroy),n.fragment&&n.fragment.d(e),n.on_destroy=n.fragment=null,n.ctx=[])}function Zt(t,e){t.$$.dirty[0]===-1&&(k.push(t),Rt(),t.$$.dirty.fill(0)),t.$$.dirty[e/31|0]|=1<{let p=h.length?h[0]:u;return r.ctx&&o(r.ctx[a],r.ctx[a]=p)&&(!r.skip_bound&&r.bound[a]&&r.bound[a](p),y&&Zt(t,a)),u}):[],r.update(),y=!0,b(r.before_update),r.fragment=i?i(r.ctx):!1,e.target){if(e.hydrate){At();let a=zt(e.target);r.fragment&&r.fragment.l(a),a.forEach(S)}else r.fragment&&r.fragment.c();e.intro&&I(t.$$.fragment),Xt(t,e.target,e.anchor,e.customElement),Lt(),yt()}C(f)}var Qt;typeof HTMLElement=="function"&&(Qt=class extends HTMLElement{constructor(){super();this.attachShadow({mode:"open"})}connectedCallback(){let{on_mount:t}=this.$$;this.$$.on_disconnect=t.map(N).filter(w);for(let e in this.$$.slotted)this.appendChild(this.$$.slotted[e])}attributeChangedCallback(t,e,n){this[t]=n}disconnectedCallback(){b(this.$$.on_disconnect)}$destroy(){wt(this,1),this.$destroy=_}$on(t,e){if(!w(e))return _;let n=this.$$.callbacks[t]||(this.$$.callbacks[t]=[]);return n.push(e),()=>{let i=n.indexOf(e);i!==-1&&n.splice(i,1)}}$set(t){this.$$set&&!ot(t)&&(this.$$.skip_bound=!0,this.$$set(t),this.$$.skip_bound=!1)}});var tt=class{$destroy(){wt(this,1),this.$destroy=_}$on(e,n){if(!w(n))return _;let i=this.$$.callbacks[e]||(this.$$.callbacks[e]=[]);return i.push(n),()=>{let o=i.indexOf(n);o!==-1&&i.splice(o,1)}}$set(e){this.$$set&&!ot(e)&&(this.$$.skip_bound=!0,this.$$set(e),this.$$.skip_bound=!1)}};var M=[];function Ft(t,e=_){let n,i=new Set;function o(l){if(L(t,l)&&(t=l,n)){let f=!M.length;for(let r of i)r[1](),M.push(r,t);if(f){for(let r=0;r{i.delete(r),i.size===0&&(n(),n=null)}}return{set:o,update:c,subscribe:s}}var q=Ft(!1);function xt(){q.set(!0)}function $t(){q.set(!1)}function et(t,{delay:e=0,duration:n=400,easing:i=A}={}){let o=+getComputedStyle(t).opacity;return{delay:e,duration:n,easing:i,css:c=>`opacity: ${c*o}`}}function Yt(t){at(t,"svelte-181h7z",`.wails-reconnect-overlay.svelte-181h7z{position:fixed;top:0;left:0;width:100%;height:100%;backdrop-filter:blur(2px) saturate(0%) contrast(50%) brightness(25%);z-index:999999\r - }.wails-reconnect-overlay-content.svelte-181h7z{position:relative;top:50%;transform:translateY(-50%);margin:0;background-image:url(data:image/png;base64,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);background-repeat:no-repeat;background-position:center\r - }.wails-reconnect-overlay-loadingspinner.svelte-181h7z{pointer-events:none;width:2.5em;height:2.5em;border:.4em solid transparent;border-color:#f00 #eee0 #f00 #eee0;border-radius:50%;animation:svelte-181h7z-loadingspin 1s linear infinite;margin:auto;padding:2.5em\r +}`,a=`__svelte_${Gt(y)}_${l}`,u=R(t),{stylesheet:h,rules:p}=T.get(u)||qt(u,t);p[a]||(p[a]=!0,h.insertRule(`@keyframes ${a} ${y}`,h.cssRules.length));let v=t.style.animation||"";return t.style.animation=`${v?`${v}, `:""}${a} ${i}ms linear ${o}ms 1 both`,J+=1,a}function Kt(t,e){let n=(t.style.animation||"").split(", "),i=n.filter(e?c=>c.indexOf(e)<0:c=>c.indexOf("__svelte")===-1),o=n.length-i.length;o&&(t.style.animation=i.join(", "),J-=o,J||Nt())}function Nt(){P(()=>{J||(T.forEach(t=>{let{ownerNode:e}=t.stylesheet;e&&S(e)}),T.clear())})}var V;function C(t){V=t}var k=[];var _t=[],z=[],mt=[],Pt=Promise.resolve(),U=!1;function Rt(){U||(U=!0,Pt.then(yt))}function $(t){z.push(t)}var X=new Set,H=0;function yt(){let t=V;do{for(;H{E=null})),E}function Z(t,e,n){t.dispatchEvent(Ht(`${e?"intro":"outro"}${n}`))}var G=new Set,m;function gt(){m={r:0,c:[],p:m}}function bt(){m.r||b(m.c),m=m.p}function I(t,e){t&&t.i&&(G.delete(t),t.i(e))}function Q(t,e,n,i){if(t&&t.o){if(G.has(t))return;G.add(t),m.c.push(()=>{G.delete(t),i&&(n&&t.d(1),i())}),t.o(e)}else i&&i()}var Ut={duration:0};function Y(t,e,n,i){let o=e(t,n),c=i?0:1,s=null,l=null,f=null;function r(){f&&Kt(t,f)}function y(u,h){let p=u.b-c;return h*=Math.abs(p),{a:c,b:u.b,d:p,duration:h,start:u.start,end:u.start+h,group:u.group}}function a(u){let{delay:h=0,duration:p=300,easing:v=A,tick:g=_,css:F}=o||Ut,K={start:Ot()+h,b:u};u||(K.group=m,m.r+=1),s||l?l=K:(F&&(r(),f=pt(t,c,u,p,h,v,F)),u&&g(0,1),s=y(K,p),$(()=>Z(t,u,"start")),Dt(O=>{if(l&&O>l.start&&(s=y(l,p),l=null,Z(t,s.b,"start"),F&&(r(),f=pt(t,c,s.b,s.duration,0,v,o.css))),s){if(O>=s.end)g(c=s.b,1-c),Z(t,s.b,"end"),l||(s.b?r():--s.group.r||b(s.group.c)),s=null;else if(O>=s.start){let jt=O-s.start;c=s.a+s.d*v(jt/s.duration),g(c,1-c)}}return!!(s||l)}))}return{run(u){w(o)?Vt().then(()=>{o=o(),a(u)}):a(u)},end(){r(),s=l=null}}}var le=typeof window!="undefined"?window:typeof globalThis!="undefined"?globalThis:global;var ue=new Set(["allowfullscreen","allowpaymentrequest","async","autofocus","autoplay","checked","controls","default","defer","disabled","formnovalidate","hidden","inert","ismap","itemscope","loop","multiple","muted","nomodule","novalidate","open","playsinline","readonly","required","reversed","selected"]);function Xt(t,e,n,i){let{fragment:o,after_update:c}=t.$$;o&&o.m(e,n),i||$(()=>{let s=t.$$.on_mount.map(N).filter(w);t.$$.on_destroy?t.$$.on_destroy.push(...s):b(s),t.$$.on_mount=[]}),c.forEach($)}function wt(t,e){let n=t.$$;n.fragment!==null&&(b(n.on_destroy),n.fragment&&n.fragment.d(e),n.on_destroy=n.fragment=null,n.ctx=[])}function Zt(t,e){t.$$.dirty[0]===-1&&(k.push(t),Rt(),t.$$.dirty.fill(0)),t.$$.dirty[e/31|0]|=1<{let p=h.length?h[0]:u;return r.ctx&&o(r.ctx[a],r.ctx[a]=p)&&(!r.skip_bound&&r.bound[a]&&r.bound[a](p),y&&Zt(t,a)),u}):[],r.update(),y=!0,b(r.before_update),r.fragment=i?i(r.ctx):!1,e.target){if(e.hydrate){At();let a=zt(e.target);r.fragment&&r.fragment.l(a),a.forEach(S)}else r.fragment&&r.fragment.c();e.intro&&I(t.$$.fragment),Xt(t,e.target,e.anchor,e.customElement),Lt(),yt()}C(f)}var Qt;typeof HTMLElement=="function"&&(Qt=class extends HTMLElement{constructor(){super();this.attachShadow({mode:"open"})}connectedCallback(){let{on_mount:t}=this.$$;this.$$.on_disconnect=t.map(N).filter(w);for(let e in this.$$.slotted)this.appendChild(this.$$.slotted[e])}attributeChangedCallback(t,e,n){this[t]=n}disconnectedCallback(){b(this.$$.on_disconnect)}$destroy(){wt(this,1),this.$destroy=_}$on(t,e){if(!w(e))return _;let n=this.$$.callbacks[t]||(this.$$.callbacks[t]=[]);return n.push(e),()=>{let i=n.indexOf(e);i!==-1&&n.splice(i,1)}}$set(t){this.$$set&&!ot(t)&&(this.$$.skip_bound=!0,this.$$set(t),this.$$.skip_bound=!1)}});var tt=class{$destroy(){wt(this,1),this.$destroy=_}$on(e,n){if(!w(n))return _;let i=this.$$.callbacks[e]||(this.$$.callbacks[e]=[]);return i.push(n),()=>{let o=i.indexOf(n);o!==-1&&i.splice(o,1)}}$set(e){this.$$set&&!ot(e)&&(this.$$.skip_bound=!0,this.$$set(e),this.$$.skip_bound=!1)}};var M=[];function Ft(t,e=_){let n,i=new Set;function o(l){if(L(t,l)&&(t=l,n)){let f=!M.length;for(let r of i)r[1](),M.push(r,t);if(f){for(let r=0;r{i.delete(r),i.size===0&&(n(),n=null)}}return{set:o,update:c,subscribe:s}}var q=Ft(!1);function xt(){q.set(!0)}function $t(){q.set(!1)}function et(t,{delay:e=0,duration:n=400,easing:i=A}={}){let o=+getComputedStyle(t).opacity;return{delay:e,duration:n,easing:i,css:c=>`opacity: ${c*o}`}}function Yt(t){at(t,"svelte-181h7z",`.wails-reconnect-overlay.svelte-181h7z{position:fixed;top:0;left:0;width:100%;height:100%;backdrop-filter:blur(2px) saturate(0%) contrast(50%) brightness(25%);z-index:999999 + }.wails-reconnect-overlay-content.svelte-181h7z{position:relative;top:50%;transform:translateY(-50%);margin:0;background-image:url(data:image/png;base64,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);background-repeat:no-repeat;background-position:center + }.wails-reconnect-overlay-loadingspinner.svelte-181h7z{pointer-events:none;width:2.5em;height:2.5em;border:.4em solid transparent;border-color:#f00 #eee0 #f00 #eee0;border-radius:50%;animation:svelte-181h7z-loadingspin 1s linear infinite;margin:auto;padding:2.5em }@keyframes svelte-181h7z-loadingspin{100%{transform:rotate(360deg)}}`)}function Mt(t){let e,n,i;return{c(){e=B("div"),e.innerHTML='
',ht(e,"class","wails-reconnect-overlay svelte-181h7z")},m(o,c){W(o,e,c),i=!0},i(o){i||($(()=>{n||(n=Y(e,et,{duration:300},!0)),n.run(1)}),i=!0)},o(o){n||(n=Y(e,et,{duration:300},!1)),n.run(0),i=!1},d(o){o&&S(e),o&&n&&n.end()}}}function te(t){let e,n,i=t[0]&&Mt(t);return{c(){i&&i.c(),e=dt()},m(o,c){i&&i.m(o,c),W(o,e,c),n=!0},p(o,[c]){o[0]?i?c&1&&I(i,1):(i=Mt(o),i.c(),I(i,1),i.m(e.parentNode,e)):i&&(gt(),Q(i,1,1,()=>{i=null}),bt())},i(o){n||(I(i),n=!0)},o(o){Q(i),n=!1},d(o){i&&i.d(o),o&&S(e)}}}function ee(t,e,n){let i;return st(t,q,o=>n(0,i=o)),[i]}var St=class extends tt{constructor(e){super();vt(this,e,ee,te,L,{},Yt)}},Ct=St;var ne={},nt=null,j=[];window.WailsInvoke=t=>{if(!nt){console.log("Queueing: "+t),j.push(t);return}nt(t)};window.addEventListener("DOMContentLoaded",()=>{ne.overlay=new Ct({target:document.body,anchor:document.querySelector("#wails-spinner")})});var d=null,kt;window.onbeforeunload=function(){d&&(d.onclose=function(){},d.close(),d=null)};It();function ie(){nt=t=>{d.send(t)};for(let t=0;t CheckNotificationAuthorization, + CleanupNotifications: () => CleanupNotifications, + InitializeNotifications: () => InitializeNotifications, + IsNotificationAvailable: () => IsNotificationAvailable, + RegisterNotificationCategory: () => RegisterNotificationCategory, + RemoveAllDeliveredNotifications: () => RemoveAllDeliveredNotifications, + RemoveAllPendingNotifications: () => RemoveAllPendingNotifications, + RemoveDeliveredNotification: () => RemoveDeliveredNotification, + RemoveNotification: () => RemoveNotification, + RemoveNotificationCategory: () => RemoveNotificationCategory, + RemovePendingNotification: () => RemovePendingNotification, + RequestNotificationAuthorization: () => RequestNotificationAuthorization, + SendNotification: () => SendNotification, + SendNotificationWithActions: () => SendNotificationWithActions + }); + function InitializeNotifications() { + return Call(":wails:InitializeNotifications"); + } + function CleanupNotifications() { + return Call(":wails:CleanupNotifications"); + } + function IsNotificationAvailable() { + return Call(":wails:IsNotificationAvailable"); + } + function RequestNotificationAuthorization() { + return Call(":wails:RequestNotificationAuthorization"); + } + function CheckNotificationAuthorization() { + return Call(":wails:CheckNotificationAuthorization"); + } + function SendNotification(options) { + return Call(":wails:SendNotification", [options]); + } + function SendNotificationWithActions(options) { + return Call(":wails:SendNotificationWithActions", [options]); + } + function RegisterNotificationCategory(category) { + return Call(":wails:RegisterNotificationCategory", [category]); + } + function RemoveNotificationCategory(categoryId) { + return Call(":wails:RemoveNotificationCategory", [categoryId]); + } + function RemoveAllPendingNotifications() { + return Call(":wails:RemoveAllPendingNotifications"); + } + function RemovePendingNotification(identifier) { + return Call(":wails:RemovePendingNotification", [identifier]); + } + function RemoveAllDeliveredNotifications() { + return Call(":wails:RemoveAllDeliveredNotifications"); + } + function RemoveDeliveredNotification(identifier) { + return Call(":wails:RemoveDeliveredNotification", [identifier]); + } + function RemoveNotification(identifier) { + return Call(":wails:RemoveNotification", [identifier]); + } + // desktop/main.js function Quit() { window.WailsInvoke("Q"); @@ -644,6 +705,7 @@ ...screen_exports, ...clipboard_exports, ...draganddrop_exports, + ...notifications_exports, EventsOn, EventsOnce, EventsOnMultiple, @@ -789,4 +851,4 @@ }); window.WailsInvoke("runtime:ready"); })(); -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/log.js", "desktop/events.js", "desktop/calls.js", "desktop/bindings.js", "desktop/window.js", "desktop/screen.js", "desktop/browser.js", "desktop/clipboard.js", "desktop/draganddrop.js", "desktop/contextmenu.js", "desktop/main.js"],
  "sourcesContent": ["/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 6 */\r\n\r\n/**\r\n * Sends a log message to the backend with the given level + message\r\n *\r\n * @param {string} level\r\n * @param {string} message\r\n */\r\nfunction sendLogMessage(level, message) {\r\n\r\n\t// Log Message format:\r\n\t// l[type][message]\r\n\twindow.WailsInvoke('L' + level + message);\r\n}\r\n\r\n/**\r\n * Log the given trace message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogTrace(message) {\r\n\tsendLogMessage('T', message);\r\n}\r\n\r\n/**\r\n * Log the given message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogPrint(message) {\r\n\tsendLogMessage('P', message);\r\n}\r\n\r\n/**\r\n * Log the given debug message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogDebug(message) {\r\n\tsendLogMessage('D', message);\r\n}\r\n\r\n/**\r\n * Log the given info message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogInfo(message) {\r\n\tsendLogMessage('I', message);\r\n}\r\n\r\n/**\r\n * Log the given warning message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogWarning(message) {\r\n\tsendLogMessage('W', message);\r\n}\r\n\r\n/**\r\n * Log the given error message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogError(message) {\r\n\tsendLogMessage('E', message);\r\n}\r\n\r\n/**\r\n * Log the given fatal message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogFatal(message) {\r\n\tsendLogMessage('F', message);\r\n}\r\n\r\n/**\r\n * Sets the Log level to the given log level\r\n *\r\n * @export\r\n * @param {number} loglevel\r\n */\r\nexport function SetLogLevel(loglevel) {\r\n\tsendLogMessage('S', loglevel);\r\n}\r\n\r\n// Log levels\r\nexport const LogLevel = {\r\n\tTRACE: 1,\r\n\tDEBUG: 2,\r\n\tINFO: 3,\r\n\tWARNING: 4,\r\n\tERROR: 5,\r\n};\r\n", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\n// Defines a single listener with a maximum number of times to callback\r\n\r\n/**\r\n * The Listener class defines a listener! :-)\r\n *\r\n * @class Listener\r\n */\r\nclass Listener {\r\n    /**\r\n     * Creates an instance of Listener.\r\n     * @param {string} eventName\r\n     * @param {function} callback\r\n     * @param {number} maxCallbacks\r\n     * @memberof Listener\r\n     */\r\n    constructor(eventName, callback, maxCallbacks) {\r\n        this.eventName = eventName;\r\n        // Default of -1 means infinite\r\n        this.maxCallbacks = maxCallbacks || -1;\r\n        // Callback invokes the callback with the given data\r\n        // Returns true if this listener should be destroyed\r\n        this.Callback = (data) => {\r\n            callback.apply(null, data);\r\n            // If maxCallbacks is infinite, return false (do not destroy)\r\n            if (this.maxCallbacks === -1) {\r\n                return false;\r\n            }\r\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\r\n            this.maxCallbacks -= 1;\r\n            return this.maxCallbacks === 0;\r\n        };\r\n    }\r\n}\r\n\r\nexport const eventListeners = {};\r\n\r\n/**\r\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n * @param {number} maxCallbacks\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function EventsOnMultiple(eventName, callback, maxCallbacks) {\r\n    eventListeners[eventName] = eventListeners[eventName] || [];\r\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\r\n    eventListeners[eventName].push(thisListener);\r\n    return () => listenerOff(thisListener);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked every time the event is emitted\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function EventsOn(eventName, callback) {\r\n    return EventsOnMultiple(eventName, callback, -1);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked once then destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n * @returns {function} A function to cancel the listener\r\n */\r\nexport function EventsOnce(eventName, callback) {\r\n    return EventsOnMultiple(eventName, callback, 1);\r\n}\r\n\r\nfunction notifyListeners(eventData) {\r\n\r\n    // Get the event name\r\n    let eventName = eventData.name;\r\n\r\n    // Keep a list of listener indexes to destroy\r\n    const newEventListenerList = eventListeners[eventName]?.slice() || [];\r\n\r\n    // Check if we have any listeners for this event\r\n    if (newEventListenerList.length) {\r\n\r\n        // Iterate listeners\r\n        for (let count = newEventListenerList.length - 1; count >= 0; count -= 1) {\r\n\r\n            // Get next listener\r\n            const listener = newEventListenerList[count];\r\n\r\n            let data = eventData.data;\r\n\r\n            // Do the callback\r\n            const destroy = listener.Callback(data);\r\n            if (destroy) {\r\n                // if the listener indicated to destroy itself, add it to the destroy list\r\n                newEventListenerList.splice(count, 1);\r\n            }\r\n        }\r\n\r\n        // Update callbacks with new list of listeners\r\n        if (newEventListenerList.length === 0) {\r\n            removeListener(eventName);\r\n        } else {\r\n            eventListeners[eventName] = newEventListenerList;\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Notify informs frontend listeners that an event was emitted with the given data\r\n *\r\n * @export\r\n * @param {string} notifyMessage - encoded notification message\r\n\r\n */\r\nexport function EventsNotify(notifyMessage) {\r\n    // Parse the message\r\n    let message;\r\n    try {\r\n        message = JSON.parse(notifyMessage);\r\n    } catch (e) {\r\n        const error = 'Invalid JSON passed to Notify: ' + notifyMessage;\r\n        throw new Error(error);\r\n    }\r\n    notifyListeners(message);\r\n}\r\n\r\n/**\r\n * Emit an event with the given name and data\r\n *\r\n * @export\r\n * @param {string} eventName\r\n */\r\nexport function EventsEmit(eventName) {\r\n\r\n    const payload = {\r\n        name: eventName,\r\n        data: [].slice.apply(arguments).slice(1),\r\n    };\r\n\r\n    // Notify JS listeners\r\n    notifyListeners(payload);\r\n\r\n    // Notify Go listeners\r\n    window.WailsInvoke('EE' + JSON.stringify(payload));\r\n}\r\n\r\nfunction removeListener(eventName) {\r\n    // Remove local listeners\r\n    delete eventListeners[eventName];\r\n\r\n    // Notify Go listeners\r\n    window.WailsInvoke('EX' + eventName);\r\n}\r\n\r\n/**\r\n * Off unregisters a listener previously registered with On,\r\n * optionally multiple listeneres can be unregistered via `additionalEventNames`\r\n *\r\n * @param {string} eventName\r\n * @param  {...string} additionalEventNames\r\n */\r\nexport function EventsOff(eventName, ...additionalEventNames) {\r\n    removeListener(eventName)\r\n\r\n    if (additionalEventNames.length > 0) {\r\n        additionalEventNames.forEach(eventName => {\r\n            removeListener(eventName)\r\n        })\r\n    }\r\n}\r\n\r\n/**\r\n * Off unregisters all event listeners previously registered with On\r\n */\r\n export function EventsOffAll() {\r\n    const eventNames = Object.keys(eventListeners);\r\n    eventNames.forEach(eventName => {\r\n        removeListener(eventName)\r\n    })\r\n}\r\n\r\n/**\r\n * listenerOff unregisters a listener previously registered with EventsOn\r\n *\r\n * @param {Listener} listener\r\n */\r\n function listenerOff(listener) {\r\n    const eventName = listener.eventName;\r\n    if (eventListeners[eventName] === undefined) return;\r\n\r\n    // Remove local listener\r\n    eventListeners[eventName] = eventListeners[eventName].filter(l => l !== listener);\r\n\r\n    // Clean up if there are no event listeners left\r\n    if (eventListeners[eventName].length === 0) {\r\n        removeListener(eventName);\r\n    }\r\n}\r\n", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nexport const callbacks = {};\r\n\r\n/**\r\n * Returns a number from the native browser random function\r\n *\r\n * @returns number\r\n */\r\nfunction cryptoRandom() {\r\n\tvar array = new Uint32Array(1);\r\n\treturn window.crypto.getRandomValues(array)[0];\r\n}\r\n\r\n/**\r\n * Returns a number using da old-skool Math.Random\r\n * I likes to call it LOLRandom\r\n *\r\n * @returns number\r\n */\r\nfunction basicRandom() {\r\n\treturn Math.random() * 9007199254740991;\r\n}\r\n\r\n// Pick a random number function based on browser capability\r\nvar randomFunc;\r\nif (window.crypto) {\r\n\trandomFunc = cryptoRandom;\r\n} else {\r\n\trandomFunc = basicRandom;\r\n}\r\n\r\n\r\n/**\r\n * Call sends a message to the backend to call the binding with the\r\n * given data. A promise is returned and will be completed when the\r\n * backend responds. This will be resolved when the call was successful\r\n * or rejected if an error is passed back.\r\n * There is a timeout mechanism. If the call doesn't respond in the given\r\n * time (in milliseconds) then the promise is rejected.\r\n *\r\n * @export\r\n * @param {string} name\r\n * @param {any=} args\r\n * @param {number=} timeout\r\n * @returns\r\n */\r\nexport function Call(name, args, timeout) {\r\n\r\n\t// Timeout infinite by default\r\n\tif (timeout == null) {\r\n\t\ttimeout = 0;\r\n\t}\r\n\r\n\t// Create a promise\r\n\treturn new Promise(function (resolve, reject) {\r\n\r\n\t\t// Create a unique callbackID\r\n\t\tvar callbackID;\r\n\t\tdo {\r\n\t\t\tcallbackID = name + '-' + randomFunc();\r\n\t\t} while (callbacks[callbackID]);\r\n\r\n\t\tvar timeoutHandle;\r\n\t\t// Set timeout\r\n\t\tif (timeout > 0) {\r\n\t\t\ttimeoutHandle = setTimeout(function () {\r\n\t\t\t\treject(Error('Call to ' + name + ' timed out. Request ID: ' + callbackID));\r\n\t\t\t}, timeout);\r\n\t\t}\r\n\r\n\t\t// Store callback\r\n\t\tcallbacks[callbackID] = {\r\n\t\t\ttimeoutHandle: timeoutHandle,\r\n\t\t\treject: reject,\r\n\t\t\tresolve: resolve\r\n\t\t};\r\n\r\n\t\ttry {\r\n\t\t\tconst payload = {\r\n\t\t\t\tname,\r\n\t\t\t\targs,\r\n\t\t\t\tcallbackID,\r\n\t\t\t};\r\n\r\n            // Make the call\r\n            window.WailsInvoke('C' + JSON.stringify(payload));\r\n        } catch (e) {\r\n            // eslint-disable-next-line\r\n            console.error(e);\r\n        }\r\n    });\r\n}\r\n\r\nwindow.ObfuscatedCall = (id, args, timeout) => {\r\n\r\n    // Timeout infinite by default\r\n    if (timeout == null) {\r\n        timeout = 0;\r\n    }\r\n\r\n    // Create a promise\r\n    return new Promise(function (resolve, reject) {\r\n\r\n        // Create a unique callbackID\r\n        var callbackID;\r\n        do {\r\n            callbackID = id + '-' + randomFunc();\r\n        } while (callbacks[callbackID]);\r\n\r\n        var timeoutHandle;\r\n        // Set timeout\r\n        if (timeout > 0) {\r\n            timeoutHandle = setTimeout(function () {\r\n                reject(Error('Call to method ' + id + ' timed out. Request ID: ' + callbackID));\r\n            }, timeout);\r\n        }\r\n\r\n        // Store callback\r\n        callbacks[callbackID] = {\r\n            timeoutHandle: timeoutHandle,\r\n            reject: reject,\r\n            resolve: resolve\r\n        };\r\n\r\n        try {\r\n            const payload = {\r\n\t\t\t\tid,\r\n\t\t\t\targs,\r\n\t\t\t\tcallbackID,\r\n\t\t\t};\r\n\r\n            // Make the call\r\n            window.WailsInvoke('c' + JSON.stringify(payload));\r\n        } catch (e) {\r\n            // eslint-disable-next-line\r\n            console.error(e);\r\n        }\r\n    });\r\n};\r\n\r\n\r\n/**\r\n * Called by the backend to return data to a previously called\r\n * binding invocation\r\n *\r\n * @export\r\n * @param {string} incomingMessage\r\n */\r\nexport function Callback(incomingMessage) {\r\n\t// Parse the message\r\n\tlet message;\r\n\ttry {\r\n\t\tmessage = JSON.parse(incomingMessage);\r\n\t} catch (e) {\r\n\t\tconst error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`;\r\n\t\truntime.LogDebug(error);\r\n\t\tthrow new Error(error);\r\n\t}\r\n\tlet callbackID = message.callbackid;\r\n\tlet callbackData = callbacks[callbackID];\r\n\tif (!callbackData) {\r\n\t\tconst error = `Callback '${callbackID}' not registered!!!`;\r\n\t\tconsole.error(error); // eslint-disable-line\r\n\t\tthrow new Error(error);\r\n\t}\r\n\tclearTimeout(callbackData.timeoutHandle);\r\n\r\n\tdelete callbacks[callbackID];\r\n\r\n\tif (message.error) {\r\n\t\tcallbackData.reject(message.error);\r\n\t} else {\r\n\t\tcallbackData.resolve(message.result);\r\n\t}\r\n}\r\n", "/*\r\n _       __      _ __    \r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  ) \r\n|__/|__/\\__,_/_/_/____/  \r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nimport {Call} from './calls';\r\n\r\n// This is where we bind go method wrappers\r\nwindow.go = {};\r\n\r\nexport function SetBindings(bindingsMap) {\r\n\ttry {\r\n\t\tbindingsMap = JSON.parse(bindingsMap);\r\n\t} catch (e) {\r\n\t\tconsole.error(e);\r\n\t}\r\n\r\n\t// Initialise the bindings map\r\n\twindow.go = window.go || {};\r\n\r\n\t// Iterate package names\r\n\tObject.keys(bindingsMap).forEach((packageName) => {\r\n\r\n\t\t// Create inner map if it doesn't exist\r\n\t\twindow.go[packageName] = window.go[packageName] || {};\r\n\r\n\t\t// Iterate struct names\r\n\t\tObject.keys(bindingsMap[packageName]).forEach((structName) => {\r\n\r\n\t\t\t// Create inner map if it doesn't exist\r\n\t\t\twindow.go[packageName][structName] = window.go[packageName][structName] || {};\r\n\r\n\t\t\tObject.keys(bindingsMap[packageName][structName]).forEach((methodName) => {\r\n\r\n\t\t\t\twindow.go[packageName][structName][methodName] = function () {\r\n\r\n\t\t\t\t\t// No timeout by default\r\n\t\t\t\t\tlet timeout = 0;\r\n\r\n\t\t\t\t\t// Actual function\r\n\t\t\t\t\tfunction dynamic() {\r\n\t\t\t\t\t\tconst args = [].slice.call(arguments);\r\n\t\t\t\t\t\treturn Call([packageName, structName, methodName].join('.'), args, timeout);\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Allow setting timeout to function\r\n\t\t\t\t\tdynamic.setTimeout = function (newTimeout) {\r\n\t\t\t\t\t\ttimeout = newTimeout;\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\t// Allow getting timeout to function\r\n\t\t\t\t\tdynamic.getTimeout = function () {\r\n\t\t\t\t\t\treturn timeout;\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\treturn dynamic;\r\n\t\t\t\t}();\r\n\t\t\t});\r\n\t\t});\r\n\t});\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n\r\nimport {Call} from \"./calls\";\r\n\r\nexport function WindowReload() {\r\n    window.location.reload();\r\n}\r\n\r\nexport function WindowReloadApp() {\r\n    window.WailsInvoke('WR');\r\n}\r\n\r\nexport function WindowSetSystemDefaultTheme() {\r\n    window.WailsInvoke('WASDT');\r\n}\r\n\r\nexport function WindowSetLightTheme() {\r\n    window.WailsInvoke('WALT');\r\n}\r\n\r\nexport function WindowSetDarkTheme() {\r\n    window.WailsInvoke('WADT');\r\n}\r\n\r\n/**\r\n * Place the window in the center of the screen\r\n *\r\n * @export\r\n */\r\nexport function WindowCenter() {\r\n    window.WailsInvoke('Wc');\r\n}\r\n\r\n/**\r\n * Sets the window title\r\n *\r\n * @param {string} title\r\n * @export\r\n */\r\nexport function WindowSetTitle(title) {\r\n    window.WailsInvoke('WT' + title);\r\n}\r\n\r\n/**\r\n * Makes the window go fullscreen\r\n *\r\n * @export\r\n */\r\nexport function WindowFullscreen() {\r\n    window.WailsInvoke('WF');\r\n}\r\n\r\n/**\r\n * Reverts the window from fullscreen\r\n *\r\n * @export\r\n */\r\nexport function WindowUnfullscreen() {\r\n    window.WailsInvoke('Wf');\r\n}\r\n\r\n/**\r\n * Returns the state of the window, i.e. whether the window is in full screen mode or not.\r\n *\r\n * @export\r\n * @return {Promise<boolean>} The state of the window\r\n */\r\nexport function WindowIsFullscreen() {\r\n    return Call(\":wails:WindowIsFullscreen\");\r\n}\r\n\r\n/**\r\n * Set the Size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetSize(width, height) {\r\n    window.WailsInvoke('Ws:' + width + ':' + height);\r\n}\r\n\r\n/**\r\n * Get the Size of the window\r\n *\r\n * @export\r\n * @return {Promise<{w: number, h: number}>} The size of the window\r\n\r\n */\r\nexport function WindowGetSize() {\r\n    return Call(\":wails:WindowGetSize\");\r\n}\r\n\r\n/**\r\n * Set the maximum size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetMaxSize(width, height) {\r\n    window.WailsInvoke('WZ:' + width + ':' + height);\r\n}\r\n\r\n/**\r\n * Set the minimum size of the window\r\n *\r\n * @export\r\n * @param {number} width\r\n * @param {number} height\r\n */\r\nexport function WindowSetMinSize(width, height) {\r\n    window.WailsInvoke('Wz:' + width + ':' + height);\r\n}\r\n\r\n\r\n\r\n/**\r\n * Set the window AlwaysOnTop or not on top\r\n *\r\n * @export\r\n */\r\nexport function WindowSetAlwaysOnTop(b) {\r\n\r\n    window.WailsInvoke('WATP:' + (b ? '1' : '0'));\r\n}\r\n\r\n\r\n\r\n\r\n/**\r\n * Set the Position of the window\r\n *\r\n * @export\r\n * @param {number} x\r\n * @param {number} y\r\n */\r\nexport function WindowSetPosition(x, y) {\r\n    window.WailsInvoke('Wp:' + x + ':' + y);\r\n}\r\n\r\n/**\r\n * Get the Position of the window\r\n *\r\n * @export\r\n * @return {Promise<{x: number, y: number}>} The position of the window\r\n */\r\nexport function WindowGetPosition() {\r\n    return Call(\":wails:WindowGetPos\");\r\n}\r\n\r\n/**\r\n * Hide the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowHide() {\r\n    window.WailsInvoke('WH');\r\n}\r\n\r\n/**\r\n * Show the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowShow() {\r\n    window.WailsInvoke('WS');\r\n}\r\n\r\n/**\r\n * Maximise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowMaximise() {\r\n    window.WailsInvoke('WM');\r\n}\r\n\r\n/**\r\n * Toggle the Maximise of the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowToggleMaximise() {\r\n    window.WailsInvoke('Wt');\r\n}\r\n\r\n/**\r\n * Unmaximise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowUnmaximise() {\r\n    window.WailsInvoke('WU');\r\n}\r\n\r\n/**\r\n * Returns the state of the window, i.e. whether the window is maximised or not.\r\n *\r\n * @export\r\n * @return {Promise<boolean>} The state of the window\r\n */\r\nexport function WindowIsMaximised() {\r\n    return Call(\":wails:WindowIsMaximised\");\r\n}\r\n\r\n/**\r\n * Minimise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowMinimise() {\r\n    window.WailsInvoke('Wm');\r\n}\r\n\r\n/**\r\n * Unminimise the Window\r\n *\r\n * @export\r\n */\r\nexport function WindowUnminimise() {\r\n    window.WailsInvoke('Wu');\r\n}\r\n\r\n/**\r\n * Returns the state of the window, i.e. whether the window is minimised or not.\r\n *\r\n * @export\r\n * @return {Promise<boolean>} The state of the window\r\n */\r\nexport function WindowIsMinimised() {\r\n    return Call(\":wails:WindowIsMinimised\");\r\n}\r\n\r\n/**\r\n * Returns the state of the window, i.e. whether the window is normal or not.\r\n *\r\n * @export\r\n * @return {Promise<boolean>} The state of the window\r\n */\r\nexport function WindowIsNormal() {\r\n    return Call(\":wails:WindowIsNormal\");\r\n}\r\n\r\n/**\r\n * Sets the background colour of the window\r\n *\r\n * @export\r\n * @param {number} R Red\r\n * @param {number} G Green\r\n * @param {number} B Blue\r\n * @param {number} A Alpha\r\n */\r\nexport function WindowSetBackgroundColour(R, G, B, A) {\r\n    let rgba = JSON.stringify({r: R || 0, g: G || 0, b: B || 0, a: A || 255});\r\n    window.WailsInvoke('Wr:' + rgba);\r\n}\r\n\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\n\r\nimport {Call} from \"./calls\";\r\n\r\n\r\n/**\r\n * Gets the all screens. Call this anew each time you want to refresh data from the underlying windowing system.\r\n * @export\r\n * @typedef {import('../wrapper/runtime').Screen} Screen\r\n * @return {Promise<{Screen[]}>} The screens\r\n */\r\nexport function ScreenGetAll() {\r\n    return Call(\":wails:ScreenGetAll\");\r\n}\r\n", "/**\r\n * @description: Use the system default browser to open the url\r\n * @param {string} url \r\n * @return {void}\r\n */\r\nexport function BrowserOpenURL(url) {\r\n  window.WailsInvoke('BO:' + url);\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {Call} from \"./calls\";\r\n\r\n/**\r\n * Set the Size of the window\r\n *\r\n * @export\r\n * @param {string} text\r\n */\r\nexport function ClipboardSetText(text) {\r\n    return Call(\":wails:ClipboardSetText\", [text]);\r\n}\r\n\r\n/**\r\n * Get the text content of the clipboard\r\n *\r\n * @export\r\n * @return {Promise<{string}>} Text content of the clipboard\r\n\r\n */\r\nexport function ClipboardGetText() {\r\n    return Call(\":wails:ClipboardGetText\");\r\n}", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 9 */\r\n\r\nimport {EventsOn, EventsOff} from \"./events\";\r\n\r\nconst flags = {\r\n    registered: false,\r\n    defaultUseDropTarget: true,\r\n    useDropTarget: true,\r\n    nextDeactivate: null,\r\n    nextDeactivateTimeout: null,\r\n};\r\n\r\nconst DROP_TARGET_ACTIVE = \"wails-drop-target-active\";\r\n\r\n/**\r\n * checkStyleDropTarget checks if the style has the drop target attribute\r\n * \r\n * @param {CSSStyleDeclaration} style \r\n * @returns \r\n */\r\nfunction checkStyleDropTarget(style) {\r\n    const cssDropValue = style.getPropertyValue(window.wails.flags.cssDropProperty).trim();\r\n    if (cssDropValue) {\r\n        if (cssDropValue === window.wails.flags.cssDropValue) {\r\n            return true;\r\n        }\r\n        // if the element has the drop target attribute, but \r\n        // the value is not correct, terminate finding process.\r\n        // This can be useful to block some child elements from being drop targets.\r\n        return false;\r\n    }\r\n    return false;\r\n}\r\n\r\n/**\r\n * onDragOver is called when the dragover event is emitted.\r\n * @param {DragEvent} e\r\n * @returns\r\n */\r\nfunction onDragOver(e) {\r\n    // Check if this is an external file drop or internal HTML drag\r\n    // External file drops will have \"Files\" in the types array\r\n    // Internal HTML drags typically have \"text/plain\", \"text/html\" or custom types\r\n    const isFileDrop = e.dataTransfer.types.includes(\"Files\");\r\n\r\n    // Only handle external file drops, let internal HTML5 drag-and-drop work normally\r\n    if (!isFileDrop) {\r\n        return;\r\n    }\r\n\r\n    // ALWAYS prevent default for file drops to stop browser navigation\r\n    e.preventDefault();\r\n    e.dataTransfer.dropEffect = 'copy';\r\n\r\n    if (!window.wails.flags.enableWailsDragAndDrop) {\r\n        return;\r\n    }\r\n\r\n    if (!flags.useDropTarget) {\r\n        return;\r\n    }\r\n\r\n    const element = e.target;\r\n\r\n    // Trigger debounce function to deactivate drop targets\r\n    if(flags.nextDeactivate) flags.nextDeactivate();\r\n\r\n    // if the element is null or element is not child of drop target element\r\n    if (!element || !checkStyleDropTarget(getComputedStyle(element))) {\r\n        return;\r\n    }\r\n\r\n    let currentElement = element;\r\n    while (currentElement) {\r\n        // check if currentElement is drop target element\r\n        if (checkStyleDropTarget(getComputedStyle(currentElement))) {\r\n            currentElement.classList.add(DROP_TARGET_ACTIVE);\r\n        }\r\n        currentElement = currentElement.parentElement;\r\n    }\r\n}\r\n\r\n/**\r\n * onDragLeave is called when the dragleave event is emitted.\r\n * @param {DragEvent} e\r\n * @returns\r\n */\r\nfunction onDragLeave(e) {\r\n    // Check if this is an external file drop or internal HTML drag\r\n    const isFileDrop = e.dataTransfer.types.includes(\"Files\");\r\n\r\n    // Only handle external file drops, let internal HTML5 drag-and-drop work normally\r\n    if (!isFileDrop) {\r\n        return;\r\n    }\r\n\r\n    // ALWAYS prevent default for file drops to stop browser navigation\r\n    e.preventDefault();\r\n\r\n    if (!window.wails.flags.enableWailsDragAndDrop) {\r\n        return;\r\n    }\r\n\r\n    if (!flags.useDropTarget) {\r\n        return;\r\n    }\r\n\r\n    // Find the close drop target element\r\n    if (!e.target || !checkStyleDropTarget(getComputedStyle(e.target))) {\r\n        return null;\r\n    }\r\n\r\n    // Trigger debounce function to deactivate drop targets\r\n    if(flags.nextDeactivate) flags.nextDeactivate();\r\n    \r\n    // Use debounce technique to tacle dragleave events on overlapping elements and drop target elements\r\n    flags.nextDeactivate = () => {\r\n        // Deactivate all drop targets, new drop target will be activated on next dragover event\r\n        Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach(el => el.classList.remove(DROP_TARGET_ACTIVE));\r\n        // Reset nextDeactivate\r\n        flags.nextDeactivate = null;\r\n        // Clear timeout\r\n        if (flags.nextDeactivateTimeout) {\r\n            clearTimeout(flags.nextDeactivateTimeout);\r\n            flags.nextDeactivateTimeout = null;\r\n        }\r\n    }\r\n\r\n    // Set timeout to deactivate drop targets if not triggered by next drag event\r\n    flags.nextDeactivateTimeout = setTimeout(() => {\r\n        if(flags.nextDeactivate) flags.nextDeactivate();\r\n    }, 50);\r\n}\r\n\r\n/**\r\n * onDrop is called when the drop event is emitted.\r\n * @param {DragEvent} e\r\n * @returns\r\n */\r\nfunction onDrop(e) {\r\n    // Check if this is an external file drop or internal HTML drag\r\n    const isFileDrop = e.dataTransfer.types.includes(\"Files\");\r\n\r\n    // Only handle external file drops, let internal HTML5 drag-and-drop work normally\r\n    if (!isFileDrop) {\r\n        return;\r\n    }\r\n\r\n    // ALWAYS prevent default for file drops to stop browser navigation\r\n    e.preventDefault();\r\n\r\n    if (!window.wails.flags.enableWailsDragAndDrop) {\r\n        return;\r\n    }\r\n\r\n    if (CanResolveFilePaths()) {\r\n        // process files\r\n        let files = [];\r\n        if (e.dataTransfer.items) {\r\n            files = [...e.dataTransfer.items].map((item, i) => {\r\n                if (item.kind === 'file') {\r\n                    return item.getAsFile();\r\n                }\r\n            });\r\n        } else {\r\n            files = [...e.dataTransfer.files];\r\n        }\r\n        window.runtime.ResolveFilePaths(e.x, e.y, files);\r\n    }\r\n\r\n    if (!flags.useDropTarget) {\r\n        return;\r\n    }\r\n\r\n    // Trigger debounce function to deactivate drop targets\r\n    if(flags.nextDeactivate) flags.nextDeactivate();\r\n\r\n    // Deactivate all drop targets\r\n    Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach(el => el.classList.remove(DROP_TARGET_ACTIVE));\r\n}\r\n\r\n/**\r\n * postMessageWithAdditionalObjects checks the browser's capability of sending postMessageWithAdditionalObjects\r\n *\r\n * @returns {boolean}\r\n * @constructor\r\n */\r\nexport function CanResolveFilePaths() {\r\n    return window.chrome?.webview?.postMessageWithAdditionalObjects != null;\r\n}\r\n\r\n/**\r\n * ResolveFilePaths sends drop events to the GO side to resolve file paths on windows.\r\n *\r\n * @param {number} x\r\n * @param {number} y\r\n * @param {any[]} files\r\n * @constructor\r\n */\r\nexport function ResolveFilePaths(x, y, files) {\r\n    // Only for windows webview2 >= 1.0.1774.30\r\n    // https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/icorewebview2webmessagereceivedeventargs2?view=webview2-1.0.1823.32#applies-to\r\n    if (window.chrome?.webview?.postMessageWithAdditionalObjects) {\r\n        chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files);\r\n    }\r\n}\r\n\r\n/**\r\n * Callback for OnFileDrop returns a slice of file path strings when a drop is finished.\r\n *\r\n * @export\r\n * @callback OnFileDropCallback\r\n * @param {number} x - x coordinate of the drop\r\n * @param {number} y - y coordinate of the drop\r\n * @param {string[]} paths - A list of file paths.\r\n */\r\n\r\n/**\r\n * OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings.\r\n *\r\n * @export\r\n * @param {OnFileDropCallback} callback - Callback for OnFileDrop returns a slice of file path strings when a drop is finished.\r\n * @param {boolean} [useDropTarget=true] - Only call the callback when the drop finished on an element that has the drop target style. (--wails-drop-target)\r\n */\r\nexport function OnFileDrop(callback, useDropTarget) {\r\n    if (typeof callback !== \"function\") {\r\n        console.error(\"DragAndDropCallback is not a function\");\r\n        return;\r\n    }\r\n\r\n    if (flags.registered) {\r\n        return;\r\n    }\r\n    flags.registered = true;\r\n\r\n    const uDTPT = typeof useDropTarget;\r\n    flags.useDropTarget = uDTPT === \"undefined\" || uDTPT !== \"boolean\" ? flags.defaultUseDropTarget : useDropTarget;\r\n    window.addEventListener('dragover', onDragOver);\r\n    window.addEventListener('dragleave', onDragLeave);\r\n    window.addEventListener('drop', onDrop);\r\n\r\n    let cb = callback;\r\n    if (flags.useDropTarget) {\r\n        cb = function (x, y, paths) {\r\n            const element = document.elementFromPoint(x, y)\r\n            // if the element is null or element is not child of drop target element, return null\r\n            if (!element || !checkStyleDropTarget(getComputedStyle(element))) {\r\n                return null;\r\n            }\r\n            callback(x, y, paths);\r\n        }\r\n    }\r\n\r\n    EventsOn(\"wails:file-drop\", cb);\r\n}\r\n\r\n/**\r\n * OnFileDropOff removes the drag and drop listeners and handlers.\r\n */\r\nexport function OnFileDropOff() {\r\n    window.removeEventListener('dragover', onDragOver);\r\n    window.removeEventListener('dragleave', onDragLeave);\r\n    window.removeEventListener('drop', onDrop);\r\n    EventsOff(\"wails:file-drop\");\r\n    flags.registered = false;\r\n}\r\n", "/*\r\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\r\n--default-contextmenu: show; will always show the default context menu\r\n--default-contextmenu: hide; will always hide the default context menu\r\n\r\nThis rule is inherited like normal CSS rules, so nesting works as expected\r\n*/\r\nexport function processDefaultContextMenu(event) {\r\n    // Process default context menu\r\n    const element = event.target;\r\n    const computedStyle = window.getComputedStyle(element);\r\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\r\n    switch (defaultContextMenuAction) {\r\n        case \"show\":\r\n            return;\r\n        case \"hide\":\r\n            event.preventDefault();\r\n            return;\r\n        default:\r\n            // Check if contentEditable is true\r\n            if (element.isContentEditable) {\r\n                return;\r\n            }\r\n\r\n            // Check if text has been selected and action is on the selected elements\r\n            const selection = window.getSelection();\r\n            const hasSelection = (selection.toString().length > 0)\r\n            if (hasSelection) {\r\n                for (let i = 0; i < selection.rangeCount; i++) {\r\n                    const range = selection.getRangeAt(i);\r\n                    const rects = range.getClientRects();\r\n                    for (let j = 0; j < rects.length; j++) {\r\n                        const rect = rects[j];\r\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\r\n                            return;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // Check if tagname is input or textarea\r\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\r\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\r\n                    return;\r\n                }\r\n            }\r\n\r\n            // hide default context menu\r\n            event.preventDefault();\r\n    }\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe electron alternative for Go\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 9 */\r\nimport * as Log from './log';\r\nimport {\r\n  eventListeners,\r\n  EventsEmit,\r\n  EventsNotify,\r\n  EventsOff,\r\n  EventsOffAll,\r\n  EventsOn,\r\n  EventsOnce,\r\n  EventsOnMultiple,\r\n} from \"./events\";\r\nimport { Call, Callback, callbacks } from './calls';\r\nimport { SetBindings } from \"./bindings\";\r\nimport * as Window from \"./window\";\r\nimport * as Screen from \"./screen\";\r\nimport * as Browser from \"./browser\";\r\nimport * as Clipboard from \"./clipboard\";\r\nimport * as DragAndDrop from \"./draganddrop\";\r\nimport * as ContextMenu from \"./contextmenu\";\r\n\r\nexport function Quit() {\r\n    window.WailsInvoke('Q');\r\n}\r\n\r\nexport function Show() {\r\n    window.WailsInvoke('S');\r\n}\r\n\r\nexport function Hide() {\r\n    window.WailsInvoke('H');\r\n}\r\n\r\nexport function Environment() {\r\n    return Call(\":wails:Environment\");\r\n}\r\n\r\n// The JS runtime\r\nwindow.runtime = {\r\n    ...Log,\r\n    ...Window,\r\n    ...Browser,\r\n    ...Screen,\r\n    ...Clipboard,\r\n    ...DragAndDrop,\r\n    EventsOn,\r\n    EventsOnce,\r\n    EventsOnMultiple,\r\n    EventsEmit,\r\n    EventsOff,\r\n    EventsOffAll,\r\n    Environment,\r\n    Show,\r\n    Hide,\r\n    Quit\r\n};\r\n\r\n// Internal wails endpoints\r\nwindow.wails = {\r\n    Callback,\r\n    EventsNotify,\r\n    SetBindings,\r\n    eventListeners,\r\n    callbacks,\r\n    flags: {\r\n        disableScrollbarDrag: false,\r\n        disableDefaultContextMenu: false,\r\n        enableResize: false,\r\n        defaultCursor: null,\r\n        borderThickness: 6,\r\n        shouldDrag: false,\r\n        deferDragToMouseMove: true,\r\n        cssDragProperty: \"--wails-draggable\",\r\n        cssDragValue: \"drag\",\r\n        cssDropProperty: \"--wails-drop-target\",\r\n        cssDropValue: \"drop\",\r\n        enableWailsDragAndDrop: false,\r\n    }\r\n};\r\n\r\n// Set the bindings\r\nif (window.wailsbindings) {\r\n    window.wails.SetBindings(window.wailsbindings);\r\n    delete window.wails.SetBindings;\r\n}\r\n\r\n// (bool) This is evaluated at build time in package.json\r\nif (!DEBUG) {\r\n    delete window.wailsbindings;\r\n}\r\n\r\nlet dragTest = function(e) {\r\n    var val = window.getComputedStyle(e.target).getPropertyValue(window.wails.flags.cssDragProperty);\r\n    if (val) {\r\n        val = val.trim();\r\n    }\r\n\r\n    if (val !== window.wails.flags.cssDragValue) {\r\n        return false;\r\n    }\r\n\r\n    if (e.buttons !== 1) {\r\n        // Do not start dragging if not the primary button has been clicked.\r\n        return false;\r\n    }\r\n\r\n    if (e.detail !== 1) {\r\n        // Do not start dragging if more than once has been clicked, e.g. when double clicking\r\n        return false;\r\n    }\r\n\r\n    return true;\r\n};\r\n\r\nwindow.wails.setCSSDragProperties = function(property, value) {\r\n    window.wails.flags.cssDragProperty = property;\r\n    window.wails.flags.cssDragValue = value;\r\n}\r\n\r\nwindow.wails.setCSSDropProperties = function(property, value) {\r\n    window.wails.flags.cssDropProperty = property;\r\n    window.wails.flags.cssDropValue = value;\r\n}\r\n\r\nwindow.addEventListener('mousedown', (e) => {\r\n    // Check for resizing\r\n    if (window.wails.flags.resizeEdge) {\r\n        window.WailsInvoke(\"resize:\" + window.wails.flags.resizeEdge);\r\n        e.preventDefault();\r\n        return;\r\n    }\r\n\r\n    if (dragTest(e)) {\r\n        if (window.wails.flags.disableScrollbarDrag) {\r\n            // This checks for clicks on the scroll bar\r\n            if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\r\n                return;\r\n            }\r\n        }\r\n        if (window.wails.flags.deferDragToMouseMove) {\r\n            window.wails.flags.shouldDrag = true;\r\n        } else {\r\n            e.preventDefault()\r\n            window.WailsInvoke(\"drag\");\r\n        }\r\n        return;\r\n    } else {\r\n        window.wails.flags.shouldDrag = false;\r\n    }\r\n});\r\n\r\nwindow.addEventListener('mouseup', () => {\r\n    window.wails.flags.shouldDrag = false;\r\n});\r\n\r\nfunction setResize(cursor) {\r\n    document.documentElement.style.cursor = cursor || window.wails.flags.defaultCursor;\r\n    window.wails.flags.resizeEdge = cursor;\r\n}\r\n\r\nwindow.addEventListener('mousemove', function(e) {\r\n    if (window.wails.flags.shouldDrag) {\r\n        window.wails.flags.shouldDrag = false;\r\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\r\n        if (mousePressed > 0) {\r\n            window.WailsInvoke(\"drag\");\r\n            return;\r\n        }\r\n    }\r\n    if (!window.wails.flags.enableResize) {\r\n        return;\r\n    }\r\n    if (window.wails.flags.defaultCursor == null) {\r\n        window.wails.flags.defaultCursor = document.documentElement.style.cursor;\r\n    }\r\n    if (window.outerWidth - e.clientX < window.wails.flags.borderThickness && window.outerHeight - e.clientY < window.wails.flags.borderThickness) {\r\n        document.documentElement.style.cursor = \"se-resize\";\r\n    }\r\n    let rightBorder = window.outerWidth - e.clientX < window.wails.flags.borderThickness;\r\n    let leftBorder = e.clientX < window.wails.flags.borderThickness;\r\n    let topBorder = e.clientY < window.wails.flags.borderThickness;\r\n    let bottomBorder = window.outerHeight - e.clientY < window.wails.flags.borderThickness;\r\n\r\n    // If we aren't on an edge, but were, reset the cursor to default\r\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && window.wails.flags.resizeEdge !== undefined) {\r\n        setResize();\r\n    } else if (rightBorder && bottomBorder) setResize(\"se-resize\");\r\n    else if (leftBorder && bottomBorder) setResize(\"sw-resize\");\r\n    else if (leftBorder && topBorder) setResize(\"nw-resize\");\r\n    else if (topBorder && rightBorder) setResize(\"ne-resize\");\r\n    else if (leftBorder) setResize(\"w-resize\");\r\n    else if (topBorder) setResize(\"n-resize\");\r\n    else if (bottomBorder) setResize(\"s-resize\");\r\n    else if (rightBorder) setResize(\"e-resize\");\r\n\r\n});\r\n\r\n// Setup context menu hook\r\nwindow.addEventListener('contextmenu', function(e) {\r\n    // always show the contextmenu in debug & dev\r\n    if (DEBUG) return;\r\n\r\n    if (window.wails.flags.disableDefaultContextMenu) {\r\n        e.preventDefault();\r\n    } else {\r\n        ContextMenu.processDefaultContextMenu(e);\r\n    }\r\n});\r\n\r\nwindow.WailsInvoke(\"runtime:ready\");"],
  "mappings": "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",
  "names": ["eventName"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/log.js", "desktop/events.js", "desktop/calls.js", "desktop/bindings.js", "desktop/window.js", "desktop/screen.js", "desktop/browser.js", "desktop/clipboard.js", "desktop/draganddrop.js", "desktop/contextmenu.js", "desktop/notifications.js", "desktop/main.js"],
  "sourcesContent": ["/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 6 */\n\n/**\n * Sends a log message to the backend with the given level + message\n *\n * @param {string} level\n * @param {string} message\n */\nfunction sendLogMessage(level, message) {\n\n\t// Log Message format:\n\t// l[type][message]\n\twindow.WailsInvoke('L' + level + message);\n}\n\n/**\n * Log the given trace message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogTrace(message) {\n\tsendLogMessage('T', message);\n}\n\n/**\n * Log the given message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogPrint(message) {\n\tsendLogMessage('P', message);\n}\n\n/**\n * Log the given debug message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogDebug(message) {\n\tsendLogMessage('D', message);\n}\n\n/**\n * Log the given info message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogInfo(message) {\n\tsendLogMessage('I', message);\n}\n\n/**\n * Log the given warning message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogWarning(message) {\n\tsendLogMessage('W', message);\n}\n\n/**\n * Log the given error message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogError(message) {\n\tsendLogMessage('E', message);\n}\n\n/**\n * Log the given fatal message with the backend\n *\n * @export\n * @param {string} message\n */\nexport function LogFatal(message) {\n\tsendLogMessage('F', message);\n}\n\n/**\n * Sets the Log level to the given log level\n *\n * @export\n * @param {number} loglevel\n */\nexport function SetLogLevel(loglevel) {\n\tsendLogMessage('S', loglevel);\n}\n\n// Log levels\nexport const LogLevel = {\n\tTRACE: 1,\n\tDEBUG: 2,\n\tINFO: 3,\n\tWARNING: 4,\n\tERROR: 5,\n};\n", "/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\n// Defines a single listener with a maximum number of times to callback\n\n/**\n * The Listener class defines a listener! :-)\n *\n * @class Listener\n */\nclass Listener {\n    /**\n     * Creates an instance of Listener.\n     * @param {string} eventName\n     * @param {function} callback\n     * @param {number} maxCallbacks\n     * @memberof Listener\n     */\n    constructor(eventName, callback, maxCallbacks) {\n        this.eventName = eventName;\n        // Default of -1 means infinite\n        this.maxCallbacks = maxCallbacks || -1;\n        // Callback invokes the callback with the given data\n        // Returns true if this listener should be destroyed\n        this.Callback = (data) => {\n            callback.apply(null, data);\n            // If maxCallbacks is infinite, return false (do not destroy)\n            if (this.maxCallbacks === -1) {\n                return false;\n            }\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\n            this.maxCallbacks -= 1;\n            return this.maxCallbacks === 0;\n        };\n    }\n}\n\nexport const eventListeners = {};\n\n/**\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @param {number} maxCallbacks\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOnMultiple(eventName, callback, maxCallbacks) {\n    eventListeners[eventName] = eventListeners[eventName] || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    eventListeners[eventName].push(thisListener);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers an event listener that will be invoked every time the event is emitted\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOn(eventName, callback) {\n    return EventsOnMultiple(eventName, callback, -1);\n}\n\n/**\n * Registers an event listener that will be invoked once then destroyed\n *\n * @export\n * @param {string} eventName\n * @param {function} callback\n * @returns {function} A function to cancel the listener\n */\nexport function EventsOnce(eventName, callback) {\n    return EventsOnMultiple(eventName, callback, 1);\n}\n\nfunction notifyListeners(eventData) {\n\n    // Get the event name\n    let eventName = eventData.name;\n\n    // Keep a list of listener indexes to destroy\n    const newEventListenerList = eventListeners[eventName]?.slice() || [];\n\n    // Check if we have any listeners for this event\n    if (newEventListenerList.length) {\n\n        // Iterate listeners\n        for (let count = newEventListenerList.length - 1; count >= 0; count -= 1) {\n\n            // Get next listener\n            const listener = newEventListenerList[count];\n\n            let data = eventData.data;\n\n            // Do the callback\n            const destroy = listener.Callback(data);\n            if (destroy) {\n                // if the listener indicated to destroy itself, add it to the destroy list\n                newEventListenerList.splice(count, 1);\n            }\n        }\n\n        // Update callbacks with new list of listeners\n        if (newEventListenerList.length === 0) {\n            removeListener(eventName);\n        } else {\n            eventListeners[eventName] = newEventListenerList;\n        }\n    }\n}\n\n/**\n * Notify informs frontend listeners that an event was emitted with the given data\n *\n * @export\n * @param {string} notifyMessage - encoded notification message\n\n */\nexport function EventsNotify(notifyMessage) {\n    // Parse the message\n    let message;\n    try {\n        message = JSON.parse(notifyMessage);\n    } catch (e) {\n        const error = 'Invalid JSON passed to Notify: ' + notifyMessage;\n        throw new Error(error);\n    }\n    notifyListeners(message);\n}\n\n/**\n * Emit an event with the given name and data\n *\n * @export\n * @param {string} eventName\n */\nexport function EventsEmit(eventName) {\n\n    const payload = {\n        name: eventName,\n        data: [].slice.apply(arguments).slice(1),\n    };\n\n    // Notify JS listeners\n    notifyListeners(payload);\n\n    // Notify Go listeners\n    window.WailsInvoke('EE' + JSON.stringify(payload));\n}\n\nfunction removeListener(eventName) {\n    // Remove local listeners\n    delete eventListeners[eventName];\n\n    // Notify Go listeners\n    window.WailsInvoke('EX' + eventName);\n}\n\n/**\n * Off unregisters a listener previously registered with On,\n * optionally multiple listeneres can be unregistered via `additionalEventNames`\n *\n * @param {string} eventName\n * @param  {...string} additionalEventNames\n */\nexport function EventsOff(eventName, ...additionalEventNames) {\n    removeListener(eventName)\n\n    if (additionalEventNames.length > 0) {\n        additionalEventNames.forEach(eventName => {\n            removeListener(eventName)\n        })\n    }\n}\n\n/**\n * Off unregisters all event listeners previously registered with On\n */\n export function EventsOffAll() {\n    const eventNames = Object.keys(eventListeners);\n    eventNames.forEach(eventName => {\n        removeListener(eventName)\n    })\n}\n\n/**\n * listenerOff unregisters a listener previously registered with EventsOn\n *\n * @param {Listener} listener\n */\n function listenerOff(listener) {\n    const eventName = listener.eventName;\n    if (eventListeners[eventName] === undefined) return;\n\n    // Remove local listener\n    eventListeners[eventName] = eventListeners[eventName].filter(l => l !== listener);\n\n    // Clean up if there are no event listeners left\n    if (eventListeners[eventName].length === 0) {\n        removeListener(eventName);\n    }\n}\n", "/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\nexport const callbacks = {};\n\n/**\n * Returns a number from the native browser random function\n *\n * @returns number\n */\nfunction cryptoRandom() {\n\tvar array = new Uint32Array(1);\n\treturn window.crypto.getRandomValues(array)[0];\n}\n\n/**\n * Returns a number using da old-skool Math.Random\n * I likes to call it LOLRandom\n *\n * @returns number\n */\nfunction basicRandom() {\n\treturn Math.random() * 9007199254740991;\n}\n\n// Pick a random number function based on browser capability\nvar randomFunc;\nif (window.crypto) {\n\trandomFunc = cryptoRandom;\n} else {\n\trandomFunc = basicRandom;\n}\n\n\n/**\n * Call sends a message to the backend to call the binding with the\n * given data. A promise is returned and will be completed when the\n * backend responds. This will be resolved when the call was successful\n * or rejected if an error is passed back.\n * There is a timeout mechanism. If the call doesn't respond in the given\n * time (in milliseconds) then the promise is rejected.\n *\n * @export\n * @param {string} name\n * @param {any=} args\n * @param {number=} timeout\n * @returns\n */\nexport function Call(name, args, timeout) {\n\n\t// Timeout infinite by default\n\tif (timeout == null) {\n\t\ttimeout = 0;\n\t}\n\n\t// Create a promise\n\treturn new Promise(function (resolve, reject) {\n\n\t\t// Create a unique callbackID\n\t\tvar callbackID;\n\t\tdo {\n\t\t\tcallbackID = name + '-' + randomFunc();\n\t\t} while (callbacks[callbackID]);\n\n\t\tvar timeoutHandle;\n\t\t// Set timeout\n\t\tif (timeout > 0) {\n\t\t\ttimeoutHandle = setTimeout(function () {\n\t\t\t\treject(Error('Call to ' + name + ' timed out. Request ID: ' + callbackID));\n\t\t\t}, timeout);\n\t\t}\n\n\t\t// Store callback\n\t\tcallbacks[callbackID] = {\n\t\t\ttimeoutHandle: timeoutHandle,\n\t\t\treject: reject,\n\t\t\tresolve: resolve\n\t\t};\n\n\t\ttry {\n\t\t\tconst payload = {\n\t\t\t\tname,\n\t\t\t\targs,\n\t\t\t\tcallbackID,\n\t\t\t};\n\n            // Make the call\n            window.WailsInvoke('C' + JSON.stringify(payload));\n        } catch (e) {\n            // eslint-disable-next-line\n            console.error(e);\n        }\n    });\n}\n\nwindow.ObfuscatedCall = (id, args, timeout) => {\n\n    // Timeout infinite by default\n    if (timeout == null) {\n        timeout = 0;\n    }\n\n    // Create a promise\n    return new Promise(function (resolve, reject) {\n\n        // Create a unique callbackID\n        var callbackID;\n        do {\n            callbackID = id + '-' + randomFunc();\n        } while (callbacks[callbackID]);\n\n        var timeoutHandle;\n        // Set timeout\n        if (timeout > 0) {\n            timeoutHandle = setTimeout(function () {\n                reject(Error('Call to method ' + id + ' timed out. Request ID: ' + callbackID));\n            }, timeout);\n        }\n\n        // Store callback\n        callbacks[callbackID] = {\n            timeoutHandle: timeoutHandle,\n            reject: reject,\n            resolve: resolve\n        };\n\n        try {\n            const payload = {\n\t\t\t\tid,\n\t\t\t\targs,\n\t\t\t\tcallbackID,\n\t\t\t};\n\n            // Make the call\n            window.WailsInvoke('c' + JSON.stringify(payload));\n        } catch (e) {\n            // eslint-disable-next-line\n            console.error(e);\n        }\n    });\n};\n\n\n/**\n * Called by the backend to return data to a previously called\n * binding invocation\n *\n * @export\n * @param {string} incomingMessage\n */\nexport function Callback(incomingMessage) {\n\t// Parse the message\n\tlet message;\n\ttry {\n\t\tmessage = JSON.parse(incomingMessage);\n\t} catch (e) {\n\t\tconst error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`;\n\t\truntime.LogDebug(error);\n\t\tthrow new Error(error);\n\t}\n\tlet callbackID = message.callbackid;\n\tlet callbackData = callbacks[callbackID];\n\tif (!callbackData) {\n\t\tconst error = `Callback '${callbackID}' not registered!!!`;\n\t\tconsole.error(error); // eslint-disable-line\n\t\tthrow new Error(error);\n\t}\n\tclearTimeout(callbackData.timeoutHandle);\n\n\tdelete callbacks[callbackID];\n\n\tif (message.error) {\n\t\tcallbackData.reject(message.error);\n\t} else {\n\t\tcallbackData.resolve(message.result);\n\t}\n}\n", "/*\n _       __      _ __    \n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  ) \n|__/|__/\\__,_/_/_/____/  \nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 6 */\n\nimport {Call} from './calls';\n\n// This is where we bind go method wrappers\nwindow.go = {};\n\nexport function SetBindings(bindingsMap) {\n\ttry {\n\t\tbindingsMap = JSON.parse(bindingsMap);\n\t} catch (e) {\n\t\tconsole.error(e);\n\t}\n\n\t// Initialise the bindings map\n\twindow.go = window.go || {};\n\n\t// Iterate package names\n\tObject.keys(bindingsMap).forEach((packageName) => {\n\n\t\t// Create inner map if it doesn't exist\n\t\twindow.go[packageName] = window.go[packageName] || {};\n\n\t\t// Iterate struct names\n\t\tObject.keys(bindingsMap[packageName]).forEach((structName) => {\n\n\t\t\t// Create inner map if it doesn't exist\n\t\t\twindow.go[packageName][structName] = window.go[packageName][structName] || {};\n\n\t\t\tObject.keys(bindingsMap[packageName][structName]).forEach((methodName) => {\n\n\t\t\t\twindow.go[packageName][structName][methodName] = function () {\n\n\t\t\t\t\t// No timeout by default\n\t\t\t\t\tlet timeout = 0;\n\n\t\t\t\t\t// Actual function\n\t\t\t\t\tfunction dynamic() {\n\t\t\t\t\t\tconst args = [].slice.call(arguments);\n\t\t\t\t\t\treturn Call([packageName, structName, methodName].join('.'), args, timeout);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Allow setting timeout to function\n\t\t\t\t\tdynamic.setTimeout = function (newTimeout) {\n\t\t\t\t\t\ttimeout = newTimeout;\n\t\t\t\t\t};\n\n\t\t\t\t\t// Allow getting timeout to function\n\t\t\t\t\tdynamic.getTimeout = function () {\n\t\t\t\t\t\treturn timeout;\n\t\t\t\t\t};\n\n\t\t\t\t\treturn dynamic;\n\t\t\t\t}();\n\t\t\t});\n\t\t});\n\t});\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n\nimport {Call} from \"./calls\";\n\nexport function WindowReload() {\n    window.location.reload();\n}\n\nexport function WindowReloadApp() {\n    window.WailsInvoke('WR');\n}\n\nexport function WindowSetSystemDefaultTheme() {\n    window.WailsInvoke('WASDT');\n}\n\nexport function WindowSetLightTheme() {\n    window.WailsInvoke('WALT');\n}\n\nexport function WindowSetDarkTheme() {\n    window.WailsInvoke('WADT');\n}\n\n/**\n * Place the window in the center of the screen\n *\n * @export\n */\nexport function WindowCenter() {\n    window.WailsInvoke('Wc');\n}\n\n/**\n * Sets the window title\n *\n * @param {string} title\n * @export\n */\nexport function WindowSetTitle(title) {\n    window.WailsInvoke('WT' + title);\n}\n\n/**\n * Makes the window go fullscreen\n *\n * @export\n */\nexport function WindowFullscreen() {\n    window.WailsInvoke('WF');\n}\n\n/**\n * Reverts the window from fullscreen\n *\n * @export\n */\nexport function WindowUnfullscreen() {\n    window.WailsInvoke('Wf');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is in full screen mode or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsFullscreen() {\n    return Call(\":wails:WindowIsFullscreen\");\n}\n\n/**\n * Set the Size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetSize(width, height) {\n    window.WailsInvoke('Ws:' + width + ':' + height);\n}\n\n/**\n * Get the Size of the window\n *\n * @export\n * @return {Promise<{w: number, h: number}>} The size of the window\n\n */\nexport function WindowGetSize() {\n    return Call(\":wails:WindowGetSize\");\n}\n\n/**\n * Set the maximum size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetMaxSize(width, height) {\n    window.WailsInvoke('WZ:' + width + ':' + height);\n}\n\n/**\n * Set the minimum size of the window\n *\n * @export\n * @param {number} width\n * @param {number} height\n */\nexport function WindowSetMinSize(width, height) {\n    window.WailsInvoke('Wz:' + width + ':' + height);\n}\n\n\n\n/**\n * Set the window AlwaysOnTop or not on top\n *\n * @export\n */\nexport function WindowSetAlwaysOnTop(b) {\n\n    window.WailsInvoke('WATP:' + (b ? '1' : '0'));\n}\n\n\n\n\n/**\n * Set the Position of the window\n *\n * @export\n * @param {number} x\n * @param {number} y\n */\nexport function WindowSetPosition(x, y) {\n    window.WailsInvoke('Wp:' + x + ':' + y);\n}\n\n/**\n * Get the Position of the window\n *\n * @export\n * @return {Promise<{x: number, y: number}>} The position of the window\n */\nexport function WindowGetPosition() {\n    return Call(\":wails:WindowGetPos\");\n}\n\n/**\n * Hide the Window\n *\n * @export\n */\nexport function WindowHide() {\n    window.WailsInvoke('WH');\n}\n\n/**\n * Show the Window\n *\n * @export\n */\nexport function WindowShow() {\n    window.WailsInvoke('WS');\n}\n\n/**\n * Maximise the Window\n *\n * @export\n */\nexport function WindowMaximise() {\n    window.WailsInvoke('WM');\n}\n\n/**\n * Toggle the Maximise of the Window\n *\n * @export\n */\nexport function WindowToggleMaximise() {\n    window.WailsInvoke('Wt');\n}\n\n/**\n * Unmaximise the Window\n *\n * @export\n */\nexport function WindowUnmaximise() {\n    window.WailsInvoke('WU');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is maximised or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsMaximised() {\n    return Call(\":wails:WindowIsMaximised\");\n}\n\n/**\n * Minimise the Window\n *\n * @export\n */\nexport function WindowMinimise() {\n    window.WailsInvoke('Wm');\n}\n\n/**\n * Unminimise the Window\n *\n * @export\n */\nexport function WindowUnminimise() {\n    window.WailsInvoke('Wu');\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is minimised or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsMinimised() {\n    return Call(\":wails:WindowIsMinimised\");\n}\n\n/**\n * Returns the state of the window, i.e. whether the window is normal or not.\n *\n * @export\n * @return {Promise<boolean>} The state of the window\n */\nexport function WindowIsNormal() {\n    return Call(\":wails:WindowIsNormal\");\n}\n\n/**\n * Sets the background colour of the window\n *\n * @export\n * @param {number} R Red\n * @param {number} G Green\n * @param {number} B Blue\n * @param {number} A Alpha\n */\nexport function WindowSetBackgroundColour(R, G, B, A) {\n    let rgba = JSON.stringify({r: R || 0, g: G || 0, b: B || 0, a: A || 255});\n    window.WailsInvoke('Wr:' + rgba);\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/* jshint esversion: 9 */\n\n\nimport {Call} from \"./calls\";\n\n\n/**\n * Gets the all screens. Call this anew each time you want to refresh data from the underlying windowing system.\n * @export\n * @typedef {import('../wrapper/runtime').Screen} Screen\n * @return {Promise<{Screen[]}>} The screens\n */\nexport function ScreenGetAll() {\n    return Call(\":wails:ScreenGetAll\");\n}\n", "/**\n * @description: Use the system default browser to open the url\n * @param {string} url \n * @return {void}\n */\nexport function BrowserOpenURL(url) {\n  window.WailsInvoke('BO:' + url);\n}", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {Call} from \"./calls\";\n\n/**\n * Set the Size of the window\n *\n * @export\n * @param {string} text\n */\nexport function ClipboardSetText(text) {\n    return Call(\":wails:ClipboardSetText\", [text]);\n}\n\n/**\n * Get the text content of the clipboard\n *\n * @export\n * @return {Promise<{string}>} Text content of the clipboard\n\n */\nexport function ClipboardGetText() {\n    return Call(\":wails:ClipboardGetText\");\n}", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {EventsOn, EventsOff} from \"./events\";\n\nconst flags = {\n    registered: false,\n    defaultUseDropTarget: true,\n    useDropTarget: true,\n    nextDeactivate: null,\n    nextDeactivateTimeout: null,\n};\n\nconst DROP_TARGET_ACTIVE = \"wails-drop-target-active\";\n\n/**\n * checkStyleDropTarget checks if the style has the drop target attribute\n * \n * @param {CSSStyleDeclaration} style \n * @returns \n */\nfunction checkStyleDropTarget(style) {\n    const cssDropValue = style.getPropertyValue(window.wails.flags.cssDropProperty).trim();\n    if (cssDropValue) {\n        if (cssDropValue === window.wails.flags.cssDropValue) {\n            return true;\n        }\n        // if the element has the drop target attribute, but \n        // the value is not correct, terminate finding process.\n        // This can be useful to block some child elements from being drop targets.\n        return false;\n    }\n    return false;\n}\n\n/**\n * onDragOver is called when the dragover event is emitted.\n * @param {DragEvent} e\n * @returns\n */\nfunction onDragOver(e) {\n    // Check if this is an external file drop or internal HTML drag\n    // External file drops will have \"Files\" in the types array\n    // Internal HTML drags typically have \"text/plain\", \"text/html\" or custom types\n    const isFileDrop = e.dataTransfer.types.includes(\"Files\");\n\n    // Only handle external file drops, let internal HTML5 drag-and-drop work normally\n    if (!isFileDrop) {\n        return;\n    }\n\n    // ALWAYS prevent default for file drops to stop browser navigation\n    e.preventDefault();\n    e.dataTransfer.dropEffect = 'copy';\n\n    if (!window.wails.flags.enableWailsDragAndDrop) {\n        return;\n    }\n\n    if (!flags.useDropTarget) {\n        return;\n    }\n\n    const element = e.target;\n\n    // Trigger debounce function to deactivate drop targets\n    if(flags.nextDeactivate) flags.nextDeactivate();\n\n    // if the element is null or element is not child of drop target element\n    if (!element || !checkStyleDropTarget(getComputedStyle(element))) {\n        return;\n    }\n\n    let currentElement = element;\n    while (currentElement) {\n        // check if currentElement is drop target element\n        if (checkStyleDropTarget(getComputedStyle(currentElement))) {\n            currentElement.classList.add(DROP_TARGET_ACTIVE);\n        }\n        currentElement = currentElement.parentElement;\n    }\n}\n\n/**\n * onDragLeave is called when the dragleave event is emitted.\n * @param {DragEvent} e\n * @returns\n */\nfunction onDragLeave(e) {\n    // Check if this is an external file drop or internal HTML drag\n    const isFileDrop = e.dataTransfer.types.includes(\"Files\");\n\n    // Only handle external file drops, let internal HTML5 drag-and-drop work normally\n    if (!isFileDrop) {\n        return;\n    }\n\n    // ALWAYS prevent default for file drops to stop browser navigation\n    e.preventDefault();\n\n    if (!window.wails.flags.enableWailsDragAndDrop) {\n        return;\n    }\n\n    if (!flags.useDropTarget) {\n        return;\n    }\n\n    // Find the close drop target element\n    if (!e.target || !checkStyleDropTarget(getComputedStyle(e.target))) {\n        return null;\n    }\n\n    // Trigger debounce function to deactivate drop targets\n    if(flags.nextDeactivate) flags.nextDeactivate();\n    \n    // Use debounce technique to tacle dragleave events on overlapping elements and drop target elements\n    flags.nextDeactivate = () => {\n        // Deactivate all drop targets, new drop target will be activated on next dragover event\n        Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach(el => el.classList.remove(DROP_TARGET_ACTIVE));\n        // Reset nextDeactivate\n        flags.nextDeactivate = null;\n        // Clear timeout\n        if (flags.nextDeactivateTimeout) {\n            clearTimeout(flags.nextDeactivateTimeout);\n            flags.nextDeactivateTimeout = null;\n        }\n    }\n\n    // Set timeout to deactivate drop targets if not triggered by next drag event\n    flags.nextDeactivateTimeout = setTimeout(() => {\n        if(flags.nextDeactivate) flags.nextDeactivate();\n    }, 50);\n}\n\n/**\n * onDrop is called when the drop event is emitted.\n * @param {DragEvent} e\n * @returns\n */\nfunction onDrop(e) {\n    // Check if this is an external file drop or internal HTML drag\n    const isFileDrop = e.dataTransfer.types.includes(\"Files\");\n\n    // Only handle external file drops, let internal HTML5 drag-and-drop work normally\n    if (!isFileDrop) {\n        return;\n    }\n\n    // ALWAYS prevent default for file drops to stop browser navigation\n    e.preventDefault();\n\n    if (!window.wails.flags.enableWailsDragAndDrop) {\n        return;\n    }\n\n    if (CanResolveFilePaths()) {\n        // process files\n        let files = [];\n        if (e.dataTransfer.items) {\n            files = [...e.dataTransfer.items].map((item, i) => {\n                if (item.kind === 'file') {\n                    return item.getAsFile();\n                }\n            });\n        } else {\n            files = [...e.dataTransfer.files];\n        }\n        window.runtime.ResolveFilePaths(e.x, e.y, files);\n    }\n\n    if (!flags.useDropTarget) {\n        return;\n    }\n\n    // Trigger debounce function to deactivate drop targets\n    if(flags.nextDeactivate) flags.nextDeactivate();\n\n    // Deactivate all drop targets\n    Array.from(document.getElementsByClassName(DROP_TARGET_ACTIVE)).forEach(el => el.classList.remove(DROP_TARGET_ACTIVE));\n}\n\n/**\n * postMessageWithAdditionalObjects checks the browser's capability of sending postMessageWithAdditionalObjects\n *\n * @returns {boolean}\n * @constructor\n */\nexport function CanResolveFilePaths() {\n    return window.chrome?.webview?.postMessageWithAdditionalObjects != null;\n}\n\n/**\n * ResolveFilePaths sends drop events to the GO side to resolve file paths on windows.\n *\n * @param {number} x\n * @param {number} y\n * @param {any[]} files\n * @constructor\n */\nexport function ResolveFilePaths(x, y, files) {\n    // Only for windows webview2 >= 1.0.1774.30\n    // https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/icorewebview2webmessagereceivedeventargs2?view=webview2-1.0.1823.32#applies-to\n    if (window.chrome?.webview?.postMessageWithAdditionalObjects) {\n        chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files);\n    }\n}\n\n/**\n * Callback for OnFileDrop returns a slice of file path strings when a drop is finished.\n *\n * @export\n * @callback OnFileDropCallback\n * @param {number} x - x coordinate of the drop\n * @param {number} y - y coordinate of the drop\n * @param {string[]} paths - A list of file paths.\n */\n\n/**\n * OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings.\n *\n * @export\n * @param {OnFileDropCallback} callback - Callback for OnFileDrop returns a slice of file path strings when a drop is finished.\n * @param {boolean} [useDropTarget=true] - Only call the callback when the drop finished on an element that has the drop target style. (--wails-drop-target)\n */\nexport function OnFileDrop(callback, useDropTarget) {\n    if (typeof callback !== \"function\") {\n        console.error(\"DragAndDropCallback is not a function\");\n        return;\n    }\n\n    if (flags.registered) {\n        return;\n    }\n    flags.registered = true;\n\n    const uDTPT = typeof useDropTarget;\n    flags.useDropTarget = uDTPT === \"undefined\" || uDTPT !== \"boolean\" ? flags.defaultUseDropTarget : useDropTarget;\n    window.addEventListener('dragover', onDragOver);\n    window.addEventListener('dragleave', onDragLeave);\n    window.addEventListener('drop', onDrop);\n\n    let cb = callback;\n    if (flags.useDropTarget) {\n        cb = function (x, y, paths) {\n            const element = document.elementFromPoint(x, y)\n            // if the element is null or element is not child of drop target element, return null\n            if (!element || !checkStyleDropTarget(getComputedStyle(element))) {\n                return null;\n            }\n            callback(x, y, paths);\n        }\n    }\n\n    EventsOn(\"wails:file-drop\", cb);\n}\n\n/**\n * OnFileDropOff removes the drag and drop listeners and handlers.\n */\nexport function OnFileDropOff() {\n    window.removeEventListener('dragover', onDragOver);\n    window.removeEventListener('dragleave', onDragLeave);\n    window.removeEventListener('drop', onDrop);\n    EventsOff(\"wails:file-drop\");\n    flags.registered = false;\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*/\nexport function processDefaultContextMenu(event) {\n    // Process default context menu\n    const element = event.target;\n    const computedStyle = window.getComputedStyle(element);\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\n    switch (defaultContextMenuAction) {\n        case \"show\":\n            return;\n        case \"hide\":\n            event.preventDefault();\n            return;\n        default:\n            // Check if contentEditable is true\n            if (element.isContentEditable) {\n                return;\n            }\n\n            // Check if text has been selected and action is on the selected elements\n            const selection = window.getSelection();\n            const hasSelection = (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) === element) {\n                            return;\n                        }\n                    }\n                }\n            }\n            // Check if tagname is input or textarea\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\n                    return;\n                }\n            }\n\n            // hide default context menu\n            event.preventDefault();\n    }\n}\n", "/*\n _       __      _ __\n| |     / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 9 */\n\nimport {Call} from \"./calls\";\n\n/**\n * Initialize the notification service for the application.\n * This must be called before sending any notifications.\n * On macOS, this also ensures the notification delegate is properly initialized.\n *\n * @export\n * @return {Promise<void>}\n */\nexport function InitializeNotifications() {\n    return Call(\":wails:InitializeNotifications\");\n}\n\n/**\n * Clean up notification resources and release any held connections.\n * This should be called when shutting down the application to properly release resources\n * (primarily needed on Linux to close D-Bus connections).\n *\n * @export\n * @return {Promise<void>}\n */\nexport function CleanupNotifications() {\n    return Call(\":wails:CleanupNotifications\");\n}\n\n/**\n * Check if notifications are available on the current platform.\n *\n * @export\n * @return {Promise<boolean>} True if notifications are available, false otherwise\n */\nexport function IsNotificationAvailable() {\n    return Call(\":wails:IsNotificationAvailable\");\n}\n\n/**\n * Request notification authorization from the user.\n * On macOS, this prompts the user to allow notifications.\n * On other platforms, this always returns true.\n *\n * @export\n * @return {Promise<boolean>} True if authorization was granted, false otherwise\n */\nexport function RequestNotificationAuthorization() {\n    return Call(\":wails:RequestNotificationAuthorization\");\n}\n\n/**\n * Check the current notification authorization status.\n * On macOS, this checks if the app has notification permissions.\n * On other platforms, this always returns true.\n *\n * @export\n * @return {Promise<boolean>} True if authorized, false otherwise\n */\nexport function CheckNotificationAuthorization() {\n    return Call(\":wails:CheckNotificationAuthorization\");\n}\n\n/**\n * Send a basic notification with the given options.\n * The notification will display with the provided title, subtitle (if supported), and body text.\n *\n * @export\n * @param {Object} options - Notification options\n * @param {string} options.id - Unique identifier for the notification\n * @param {string} options.title - Notification title\n * @param {string} [options.subtitle] - Notification subtitle (macOS and Linux only)\n * @param {string} [options.body] - Notification body text\n * @param {string} [options.categoryId] - Category ID for action buttons (requires SendNotificationWithActions)\n * @param {Object<string, any>} [options.data] - Additional user data to attach to the notification\n * @return {Promise<void>}\n */\nexport function SendNotification(options) {\n    return Call(\":wails:SendNotification\", [options]);\n}\n\n/**\n * Send a notification with action buttons.\n * A NotificationCategory must be registered first using RegisterNotificationCategory.\n * The options.categoryId must match a previously registered category ID.\n * If the category is not found, a basic notification will be sent instead.\n *\n * @export\n * @param {Object} options - Notification options\n * @param {string} options.id - Unique identifier for the notification\n * @param {string} options.title - Notification title\n * @param {string} [options.subtitle] - Notification subtitle (macOS and Linux only)\n * @param {string} [options.body] - Notification body text\n * @param {string} options.categoryId - Category ID that matches a registered category\n * @param {Object<string, any>} [options.data] - Additional user data to attach to the notification\n * @return {Promise<void>}\n */\nexport function SendNotificationWithActions(options) {\n    return Call(\":wails:SendNotificationWithActions\", [options]);\n}\n\n/**\n * Register a notification category that can be used with SendNotificationWithActions.\n * Categories define the action buttons and optional reply fields that will appear on notifications.\n * Registering a category with the same ID as a previously registered category will override it.\n *\n * @export\n * @param {Object} category - Notification category definition\n * @param {string} category.id - Unique identifier for the category\n * @param {Array<Object>} [category.actions] - Array of action buttons\n * @param {string} category.actions[].id - Unique identifier for the action\n * @param {string} category.actions[].title - Display title for the action button\n * @param {boolean} [category.actions[].destructive] - Whether the action is destructive (macOS-specific)\n * @param {boolean} [category.hasReplyField] - Whether to include a text input field for replies\n * @param {string} [category.replyPlaceholder] - Placeholder text for the reply field (required if hasReplyField is true)\n * @param {string} [category.replyButtonTitle] - Title for the reply button (required if hasReplyField is true)\n * @return {Promise<void>}\n */\nexport function RegisterNotificationCategory(category) {\n    return Call(\":wails:RegisterNotificationCategory\", [category]);\n}\n\n/**\n * Remove a previously registered notification category.\n *\n * @export\n * @param {string} categoryId - The ID of the category to remove\n * @return {Promise<void>}\n */\nexport function RemoveNotificationCategory(categoryId) {\n    return Call(\":wails:RemoveNotificationCategory\", [categoryId]);\n}\n\n/**\n * Remove all pending notifications from the notification center.\n * On Windows, this is a no-op as the platform manages notification lifecycle automatically.\n *\n * @export\n * @return {Promise<void>}\n */\nexport function RemoveAllPendingNotifications() {\n    return Call(\":wails:RemoveAllPendingNotifications\");\n}\n\n/**\n * Remove a specific pending notification by its identifier.\n * On Windows, this is a no-op as the platform manages notification lifecycle automatically.\n *\n * @export\n * @param {string} identifier - The ID of the notification to remove\n * @return {Promise<void>}\n */\nexport function RemovePendingNotification(identifier) {\n    return Call(\":wails:RemovePendingNotification\", [identifier]);\n}\n\n/**\n * Remove all delivered notifications from the notification center.\n * On Windows, this is a no-op as the platform manages notification lifecycle automatically.\n *\n * @export\n * @return {Promise<void>}\n */\nexport function RemoveAllDeliveredNotifications() {\n    return Call(\":wails:RemoveAllDeliveredNotifications\");\n}\n\n/**\n * Remove a specific delivered notification by its identifier.\n * On Windows, this is a no-op as the platform manages notification lifecycle automatically.\n *\n * @export\n * @param {string} identifier - The ID of the notification to remove\n * @return {Promise<void>}\n */\nexport function RemoveDeliveredNotification(identifier) {\n    return Call(\":wails:RemoveDeliveredNotification\", [identifier]);\n}\n\n/**\n * Remove a notification by its identifier.\n * This is a convenience function that works across platforms.\n * On macOS, use the more specific RemovePendingNotification or RemoveDeliveredNotification functions.\n *\n * @export\n * @param {string} identifier - The ID of the notification to remove\n * @return {Promise<void>}\n */\nexport function RemoveNotification(identifier) {\n    return Call(\":wails:RemoveNotification\", [identifier]);\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n/* jshint esversion: 9 */\nimport * as Log from './log';\nimport {\n  eventListeners,\n  EventsEmit,\n  EventsNotify,\n  EventsOff,\n  EventsOffAll,\n  EventsOn,\n  EventsOnce,\n  EventsOnMultiple,\n} from \"./events\";\nimport { Call, Callback, callbacks } from './calls';\nimport { SetBindings } from \"./bindings\";\nimport * as Window from \"./window\";\nimport * as Screen from \"./screen\";\nimport * as Browser from \"./browser\";\nimport * as Clipboard from \"./clipboard\";\nimport * as DragAndDrop from \"./draganddrop\";\nimport * as ContextMenu from \"./contextmenu\";\nimport * as Notifications from \"./notifications\";\n\nexport function Quit() {\n    window.WailsInvoke('Q');\n}\n\nexport function Show() {\n    window.WailsInvoke('S');\n}\n\nexport function Hide() {\n    window.WailsInvoke('H');\n}\n\nexport function Environment() {\n    return Call(\":wails:Environment\");\n}\n\n// The JS runtime\nwindow.runtime = {\n    ...Log,\n    ...Window,\n    ...Browser,\n    ...Screen,\n    ...Clipboard,\n    ...DragAndDrop,\n    ...Notifications,\n    EventsOn,\n    EventsOnce,\n    EventsOnMultiple,\n    EventsEmit,\n    EventsOff,\n    EventsOffAll,\n    Environment,\n    Show,\n    Hide,\n    Quit\n};\n\n// Internal wails endpoints\nwindow.wails = {\n    Callback,\n    EventsNotify,\n    SetBindings,\n    eventListeners,\n    callbacks,\n    flags: {\n        disableScrollbarDrag: false,\n        disableDefaultContextMenu: false,\n        enableResize: false,\n        defaultCursor: null,\n        borderThickness: 6,\n        shouldDrag: false,\n        deferDragToMouseMove: true,\n        cssDragProperty: \"--wails-draggable\",\n        cssDragValue: \"drag\",\n        cssDropProperty: \"--wails-drop-target\",\n        cssDropValue: \"drop\",\n        enableWailsDragAndDrop: false,\n    }\n};\n\n// Set the bindings\nif (window.wailsbindings) {\n    window.wails.SetBindings(window.wailsbindings);\n    delete window.wails.SetBindings;\n}\n\n// (bool) This is evaluated at build time in package.json\nif (!DEBUG) {\n    delete window.wailsbindings;\n}\n\nlet dragTest = function(e) {\n    var val = window.getComputedStyle(e.target).getPropertyValue(window.wails.flags.cssDragProperty);\n    if (val) {\n        val = val.trim();\n    }\n\n    if (val !== window.wails.flags.cssDragValue) {\n        return false;\n    }\n\n    if (e.buttons !== 1) {\n        // Do not start dragging if not the primary button has been clicked.\n        return false;\n    }\n\n    if (e.detail !== 1) {\n        // Do not start dragging if more than once has been clicked, e.g. when double clicking\n        return false;\n    }\n\n    return true;\n};\n\nwindow.wails.setCSSDragProperties = function(property, value) {\n    window.wails.flags.cssDragProperty = property;\n    window.wails.flags.cssDragValue = value;\n}\n\nwindow.wails.setCSSDropProperties = function(property, value) {\n    window.wails.flags.cssDropProperty = property;\n    window.wails.flags.cssDropValue = value;\n}\n\nwindow.addEventListener('mousedown', (e) => {\n    // Check for resizing\n    if (window.wails.flags.resizeEdge) {\n        window.WailsInvoke(\"resize:\" + window.wails.flags.resizeEdge);\n        e.preventDefault();\n        return;\n    }\n\n    if (dragTest(e)) {\n        if (window.wails.flags.disableScrollbarDrag) {\n            // This checks for clicks on the scroll bar\n            if (e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight) {\n                return;\n            }\n        }\n        if (window.wails.flags.deferDragToMouseMove) {\n            window.wails.flags.shouldDrag = true;\n        } else {\n            e.preventDefault()\n            window.WailsInvoke(\"drag\");\n        }\n        return;\n    } else {\n        window.wails.flags.shouldDrag = false;\n    }\n});\n\nwindow.addEventListener('mouseup', () => {\n    window.wails.flags.shouldDrag = false;\n});\n\nfunction setResize(cursor) {\n    document.documentElement.style.cursor = cursor || window.wails.flags.defaultCursor;\n    window.wails.flags.resizeEdge = cursor;\n}\n\nwindow.addEventListener('mousemove', function(e) {\n    if (window.wails.flags.shouldDrag) {\n        window.wails.flags.shouldDrag = false;\n        let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n        if (mousePressed > 0) {\n            window.WailsInvoke(\"drag\");\n            return;\n        }\n    }\n    if (!window.wails.flags.enableResize) {\n        return;\n    }\n    if (window.wails.flags.defaultCursor == null) {\n        window.wails.flags.defaultCursor = document.documentElement.style.cursor;\n    }\n    if (window.outerWidth - e.clientX < window.wails.flags.borderThickness && window.outerHeight - e.clientY < window.wails.flags.borderThickness) {\n        document.documentElement.style.cursor = \"se-resize\";\n    }\n    let rightBorder = window.outerWidth - e.clientX < window.wails.flags.borderThickness;\n    let leftBorder = e.clientX < window.wails.flags.borderThickness;\n    let topBorder = e.clientY < window.wails.flags.borderThickness;\n    let bottomBorder = window.outerHeight - e.clientY < window.wails.flags.borderThickness;\n\n    // If we aren't on an edge, but were, reset the cursor to default\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && window.wails.flags.resizeEdge !== undefined) {\n        setResize();\n    } else if (rightBorder && bottomBorder) setResize(\"se-resize\");\n    else if (leftBorder && bottomBorder) setResize(\"sw-resize\");\n    else if (leftBorder && topBorder) setResize(\"nw-resize\");\n    else if (topBorder && rightBorder) setResize(\"ne-resize\");\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\n});\n\n// Setup context menu hook\nwindow.addEventListener('contextmenu', function(e) {\n    // always show the contextmenu in debug & dev\n    if (DEBUG) return;\n\n    if (window.wails.flags.disableDefaultContextMenu) {\n        e.preventDefault();\n    } else {\n        ContextMenu.processDefaultContextMenu(e);\n    }\n});\n\nwindow.WailsInvoke(\"runtime:ready\");"],
  "mappings": "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",
  "names": ["eventName"]
}
 diff --git a/v2/internal/frontend/runtime/runtime_prod_desktop.js b/v2/internal/frontend/runtime/runtime_prod_desktop.js index 3d38924f7..c285fa642 100644 --- a/v2/internal/frontend/runtime/runtime_prod_desktop.js +++ b/v2/internal/frontend/runtime/runtime_prod_desktop.js @@ -1 +1 @@ -(()=>{var j=Object.defineProperty;var p=(e,t)=>{for(var n in t)j(e,n,{get:t[n],enumerable:!0})};var b={};p(b,{LogDebug:()=>$,LogError:()=>Q,LogFatal:()=>_,LogInfo:()=>Y,LogLevel:()=>K,LogPrint:()=>X,LogTrace:()=>J,LogWarning:()=>q,SetLogLevel:()=>Z});function u(e,t){window.WailsInvoke("L"+e+t)}function J(e){u("T",e)}function X(e){u("P",e)}function $(e){u("D",e)}function Y(e){u("I",e)}function q(e){u("W",e)}function Q(e){u("E",e)}function _(e){u("F",e)}function Z(e){u("S",e)}var K={TRACE:1,DEBUG:2,INFO:3,WARNING:4,ERROR:5};var y=class{constructor(t,n,o){this.eventName=t,this.maxCallbacks=o||-1,this.Callback=i=>(n.apply(null,i),this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0))}},w={};function v(e,t,n){w[e]=w[e]||[];let o=new y(e,t,n);return w[e].push(o),()=>ee(o)}function W(e,t){return v(e,t,-1)}function A(e,t){return v(e,t,1)}function P(e){let t=e.name,n=w[t]?.slice()||[];if(n.length){for(let o=n.length-1;o>=0;o-=1){let i=n[o],r=e.data;i.Callback(r)&&n.splice(o,1)}n.length===0?g(t):w[t]=n}}function F(e){let t;try{t=JSON.parse(e)}catch{let o="Invalid JSON passed to Notify: "+e;throw new Error(o)}P(t)}function R(e){let t={name:e,data:[].slice.apply(arguments).slice(1)};P(t),window.WailsInvoke("EE"+JSON.stringify(t))}function g(e){delete w[e],window.WailsInvoke("EX"+e)}function x(e,...t){g(e),t.length>0&&t.forEach(n=>{g(n)})}function M(){Object.keys(w).forEach(t=>{g(t)})}function ee(e){let t=e.eventName;w[t]!==void 0&&(w[t]=w[t].filter(n=>n!==e),w[t].length===0&&g(t))}var c={};function te(){var e=new Uint32Array(1);return window.crypto.getRandomValues(e)[0]}function ne(){return Math.random()*9007199254740991}var D;window.crypto?D=te:D=ne;function a(e,t,n){return n==null&&(n=0),new Promise(function(o,i){var r;do r=e+"-"+D();while(c[r]);var l;n>0&&(l=setTimeout(function(){i(Error("Call to "+e+" timed out. Request ID: "+r))},n)),c[r]={timeoutHandle:l,reject:i,resolve:o};try{let d={name:e,args:t,callbackID:r};window.WailsInvoke("C"+JSON.stringify(d))}catch(d){console.error(d)}})}window.ObfuscatedCall=(e,t,n)=>(n==null&&(n=0),new Promise(function(o,i){var r;do r=e+"-"+D();while(c[r]);var l;n>0&&(l=setTimeout(function(){i(Error("Call to method "+e+" timed out. Request ID: "+r))},n)),c[r]={timeoutHandle:l,reject:i,resolve:o};try{let d={id:e,args:t,callbackID:r};window.WailsInvoke("c"+JSON.stringify(d))}catch(d){console.error(d)}}));function z(e){let t;try{t=JSON.parse(e)}catch(i){let r=`Invalid JSON passed to callback: ${i.message}. Message: ${e}`;throw runtime.LogDebug(r),new Error(r)}let n=t.callbackid,o=c[n];if(!o){let i=`Callback '${n}' not registered!!!`;throw console.error(i),new Error(i)}clearTimeout(o.timeoutHandle),delete c[n],t.error?o.reject(t.error):o.resolve(t.result)}window.go={};function B(e){try{e=JSON.parse(e)}catch(t){console.error(t)}window.go=window.go||{},Object.keys(e).forEach(t=>{window.go[t]=window.go[t]||{},Object.keys(e[t]).forEach(n=>{window.go[t][n]=window.go[t][n]||{},Object.keys(e[t][n]).forEach(o=>{window.go[t][n][o]=function(){let i=0;function r(){let l=[].slice.call(arguments);return a([t,n,o].join("."),l,i)}return r.setTimeout=function(l){i=l},r.getTimeout=function(){return i},r}()})})})}var T={};p(T,{WindowCenter:()=>ae,WindowFullscreen:()=>de,WindowGetPosition:()=>xe,WindowGetSize:()=>pe,WindowHide:()=>De,WindowIsFullscreen:()=>ue,WindowIsMaximised:()=>Te,WindowIsMinimised:()=>Ce,WindowIsNormal:()=>Ie,WindowMaximise:()=>Ee,WindowMinimise:()=>Se,WindowReload:()=>oe,WindowReloadApp:()=>ie,WindowSetAlwaysOnTop:()=>ve,WindowSetBackgroundColour:()=>Oe,WindowSetDarkTheme:()=>le,WindowSetLightTheme:()=>se,WindowSetMaxSize:()=>ge,WindowSetMinSize:()=>me,WindowSetPosition:()=>We,WindowSetSize:()=>ce,WindowSetSystemDefaultTheme:()=>re,WindowSetTitle:()=>we,WindowShow:()=>he,WindowToggleMaximise:()=>be,WindowUnfullscreen:()=>fe,WindowUnmaximise:()=>ye,WindowUnminimise:()=>ke});function oe(){window.location.reload()}function ie(){window.WailsInvoke("WR")}function re(){window.WailsInvoke("WASDT")}function se(){window.WailsInvoke("WALT")}function le(){window.WailsInvoke("WADT")}function ae(){window.WailsInvoke("Wc")}function we(e){window.WailsInvoke("WT"+e)}function de(){window.WailsInvoke("WF")}function fe(){window.WailsInvoke("Wf")}function ue(){return a(":wails:WindowIsFullscreen")}function ce(e,t){window.WailsInvoke("Ws:"+e+":"+t)}function pe(){return a(":wails:WindowGetSize")}function ge(e,t){window.WailsInvoke("WZ:"+e+":"+t)}function me(e,t){window.WailsInvoke("Wz:"+e+":"+t)}function ve(e){window.WailsInvoke("WATP:"+(e?"1":"0"))}function We(e,t){window.WailsInvoke("Wp:"+e+":"+t)}function xe(){return a(":wails:WindowGetPos")}function De(){window.WailsInvoke("WH")}function he(){window.WailsInvoke("WS")}function Ee(){window.WailsInvoke("WM")}function be(){window.WailsInvoke("Wt")}function ye(){window.WailsInvoke("WU")}function Te(){return a(":wails:WindowIsMaximised")}function Se(){window.WailsInvoke("Wm")}function ke(){window.WailsInvoke("Wu")}function Ce(){return a(":wails:WindowIsMinimised")}function Ie(){return a(":wails:WindowIsNormal")}function Oe(e,t,n,o){let i=JSON.stringify({r:e||0,g:t||0,b:n||0,a:o||255});window.WailsInvoke("Wr:"+i)}var S={};p(S,{ScreenGetAll:()=>Le});function Le(){return a(":wails:ScreenGetAll")}var k={};p(k,{BrowserOpenURL:()=>Ae});function Ae(e){window.WailsInvoke("BO:"+e)}var C={};p(C,{ClipboardGetText:()=>Fe,ClipboardSetText:()=>Pe});function Pe(e){return a(":wails:ClipboardSetText",[e])}function Fe(){return a(":wails:ClipboardGetText")}var I={};p(I,{CanResolveFilePaths:()=>V,OnFileDrop:()=>Me,OnFileDropOff:()=>ze,ResolveFilePaths:()=>Re});var s={registered:!1,defaultUseDropTarget:!0,useDropTarget:!0,nextDeactivate:null,nextDeactivateTimeout:null},m="wails-drop-target-active";function h(e){let t=e.getPropertyValue(window.wails.flags.cssDropProperty).trim();return t?t===window.wails.flags.cssDropValue:!1}function G(e){if(!e.dataTransfer.types.includes("Files")||(e.preventDefault(),e.dataTransfer.dropEffect="copy",!window.wails.flags.enableWailsDragAndDrop)||!s.useDropTarget)return;let n=e.target;if(s.nextDeactivate&&s.nextDeactivate(),!n||!h(getComputedStyle(n)))return;let o=n;for(;o;)h(getComputedStyle(o))&&o.classList.add(m),o=o.parentElement}function H(e){if(!!e.dataTransfer.types.includes("Files")&&(e.preventDefault(),!!window.wails.flags.enableWailsDragAndDrop&&!!s.useDropTarget)){if(!e.target||!h(getComputedStyle(e.target)))return null;s.nextDeactivate&&s.nextDeactivate(),s.nextDeactivate=()=>{Array.from(document.getElementsByClassName(m)).forEach(n=>n.classList.remove(m)),s.nextDeactivate=null,s.nextDeactivateTimeout&&(clearTimeout(s.nextDeactivateTimeout),s.nextDeactivateTimeout=null)},s.nextDeactivateTimeout=setTimeout(()=>{s.nextDeactivate&&s.nextDeactivate()},50)}}function U(e){if(!!e.dataTransfer.types.includes("Files")&&(e.preventDefault(),!!window.wails.flags.enableWailsDragAndDrop)){if(V()){let n=[];e.dataTransfer.items?n=[...e.dataTransfer.items].map((o,i)=>{if(o.kind==="file")return o.getAsFile()}):n=[...e.dataTransfer.files],window.runtime.ResolveFilePaths(e.x,e.y,n)}!s.useDropTarget||(s.nextDeactivate&&s.nextDeactivate(),Array.from(document.getElementsByClassName(m)).forEach(n=>n.classList.remove(m)))}}function V(){return window.chrome?.webview?.postMessageWithAdditionalObjects!=null}function Re(e,t,n){window.chrome?.webview?.postMessageWithAdditionalObjects&&chrome.webview.postMessageWithAdditionalObjects(`file:drop:${e}:${t}`,n)}function Me(e,t){if(typeof e!="function"){console.error("DragAndDropCallback is not a function");return}if(s.registered)return;s.registered=!0;let n=typeof t;s.useDropTarget=n==="undefined"||n!=="boolean"?s.defaultUseDropTarget:t,window.addEventListener("dragover",G),window.addEventListener("dragleave",H),window.addEventListener("drop",U);let o=e;s.useDropTarget&&(o=function(i,r,l){let d=document.elementFromPoint(i,r);if(!d||!h(getComputedStyle(d)))return null;e(i,r,l)}),W("wails:file-drop",o)}function ze(){window.removeEventListener("dragover",G),window.removeEventListener("dragleave",H),window.removeEventListener("drop",U),x("wails:file-drop"),s.registered=!1}function N(e){let t=e.target;switch(window.getComputedStyle(t).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":e.preventDefault();return;default:if(t.isContentEditable)return;let i=window.getSelection(),r=i.toString().length>0;if(r)for(let l=0;l{if(window.wails.flags.resizeEdge){window.WailsInvoke("resize:"+window.wails.flags.resizeEdge),e.preventDefault();return}if(Ne(e)){if(window.wails.flags.disableScrollbarDrag&&(e.offsetX>e.target.clientWidth||e.offsetY>e.target.clientHeight))return;window.wails.flags.deferDragToMouseMove?window.wails.flags.shouldDrag=!0:(e.preventDefault(),window.WailsInvoke("drag"));return}else window.wails.flags.shouldDrag=!1});window.addEventListener("mouseup",()=>{window.wails.flags.shouldDrag=!1});function f(e){document.documentElement.style.cursor=e||window.wails.flags.defaultCursor,window.wails.flags.resizeEdge=e}window.addEventListener("mousemove",function(e){if(window.wails.flags.shouldDrag&&(window.wails.flags.shouldDrag=!1,(e.buttons!==void 0?e.buttons:e.which)>0)){window.WailsInvoke("drag");return}if(!window.wails.flags.enableResize)return;window.wails.flags.defaultCursor==null&&(window.wails.flags.defaultCursor=document.documentElement.style.cursor),window.outerWidth-e.clientX{var J=Object.defineProperty;var p=(e,t)=>{for(var n in t)J(e,n,{get:t[n],enumerable:!0})};var y={};p(y,{LogDebug:()=>q,LogError:()=>_,LogFatal:()=>Z,LogInfo:()=>Y,LogLevel:()=>ee,LogPrint:()=>$,LogTrace:()=>X,LogWarning:()=>Q,SetLogLevel:()=>K});function u(e,t){window.WailsInvoke("L"+e+t)}function X(e){u("T",e)}function $(e){u("P",e)}function q(e){u("D",e)}function Y(e){u("I",e)}function Q(e){u("W",e)}function _(e){u("E",e)}function Z(e){u("F",e)}function K(e){u("S",e)}var ee={TRACE:1,DEBUG:2,INFO:3,WARNING:4,ERROR:5};var b=class{constructor(t,n,i){this.eventName=t,this.maxCallbacks=i||-1,this.Callback=o=>(n.apply(null,o),this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0))}},f={};function v(e,t,n){f[e]=f[e]||[];let i=new b(e,t,n);return f[e].push(i),()=>te(i)}function x(e,t){return v(e,t,-1)}function N(e,t){return v(e,t,1)}function L(e){let t=e.name,n=f[t]?.slice()||[];if(n.length){for(let i=n.length-1;i>=0;i-=1){let o=n[i],s=e.data;o.Callback(s)&&n.splice(i,1)}n.length===0?g(t):f[t]=n}}function P(e){let t;try{t=JSON.parse(e)}catch{let i="Invalid JSON passed to Notify: "+e;throw new Error(i)}L(t)}function z(e){let t={name:e,data:[].slice.apply(arguments).slice(1)};L(t),window.WailsInvoke("EE"+JSON.stringify(t))}function g(e){delete f[e],window.WailsInvoke("EX"+e)}function D(e,...t){g(e),t.length>0&&t.forEach(n=>{g(n)})}function F(){Object.keys(f).forEach(t=>{g(t)})}function te(e){let t=e.eventName;f[t]!==void 0&&(f[t]=f[t].filter(n=>n!==e),f[t].length===0&&g(t))}var c={};function ne(){var e=new Uint32Array(1);return window.crypto.getRandomValues(e)[0]}function ie(){return Math.random()*9007199254740991}var W;window.crypto?W=ne:W=ie;function r(e,t,n){return n==null&&(n=0),new Promise(function(i,o){var s;do s=e+"-"+W();while(c[s]);var l;n>0&&(l=setTimeout(function(){o(Error("Call to "+e+" timed out. Request ID: "+s))},n)),c[s]={timeoutHandle:l,reject:o,resolve:i};try{let w={name:e,args:t,callbackID:s};window.WailsInvoke("C"+JSON.stringify(w))}catch(w){console.error(w)}})}window.ObfuscatedCall=(e,t,n)=>(n==null&&(n=0),new Promise(function(i,o){var s;do s=e+"-"+W();while(c[s]);var l;n>0&&(l=setTimeout(function(){o(Error("Call to method "+e+" timed out. Request ID: "+s))},n)),c[s]={timeoutHandle:l,reject:o,resolve:i};try{let w={id:e,args:t,callbackID:s};window.WailsInvoke("c"+JSON.stringify(w))}catch(w){console.error(w)}}));function M(e){let t;try{t=JSON.parse(e)}catch(o){let s=`Invalid JSON passed to callback: ${o.message}. Message: ${e}`;throw runtime.LogDebug(s),new Error(s)}let n=t.callbackid,i=c[n];if(!i){let o=`Callback '${n}' not registered!!!`;throw console.error(o),new Error(o)}clearTimeout(i.timeoutHandle),delete c[n],t.error?i.reject(t.error):i.resolve(t.result)}window.go={};function B(e){try{e=JSON.parse(e)}catch(t){console.error(t)}window.go=window.go||{},Object.keys(e).forEach(t=>{window.go[t]=window.go[t]||{},Object.keys(e[t]).forEach(n=>{window.go[t][n]=window.go[t][n]||{},Object.keys(e[t][n]).forEach(i=>{window.go[t][n][i]=function(){let o=0;function s(){let l=[].slice.call(arguments);return r([t,n,i].join("."),l,o)}return s.setTimeout=function(l){o=l},s.getTimeout=function(){return o},s}()})})})}var C={};p(C,{WindowCenter:()=>fe,WindowFullscreen:()=>de,WindowGetPosition:()=>We,WindowGetSize:()=>ge,WindowHide:()=>he,WindowIsFullscreen:()=>ce,WindowIsMaximised:()=>Se,WindowIsMinimised:()=>Ie,WindowIsNormal:()=>Ae,WindowMaximise:()=>ye,WindowMinimise:()=>Te,WindowReload:()=>oe,WindowReloadApp:()=>re,WindowSetAlwaysOnTop:()=>xe,WindowSetBackgroundColour:()=>Oe,WindowSetDarkTheme:()=>le,WindowSetLightTheme:()=>ae,WindowSetMaxSize:()=>me,WindowSetMinSize:()=>ve,WindowSetPosition:()=>De,WindowSetSize:()=>pe,WindowSetSystemDefaultTheme:()=>se,WindowSetTitle:()=>we,WindowShow:()=>Ee,WindowToggleMaximise:()=>be,WindowUnfullscreen:()=>ue,WindowUnmaximise:()=>Ce,WindowUnminimise:()=>ke});function oe(){window.location.reload()}function re(){window.WailsInvoke("WR")}function se(){window.WailsInvoke("WASDT")}function ae(){window.WailsInvoke("WALT")}function le(){window.WailsInvoke("WADT")}function fe(){window.WailsInvoke("Wc")}function we(e){window.WailsInvoke("WT"+e)}function de(){window.WailsInvoke("WF")}function ue(){window.WailsInvoke("Wf")}function ce(){return r(":wails:WindowIsFullscreen")}function pe(e,t){window.WailsInvoke("Ws:"+e+":"+t)}function ge(){return r(":wails:WindowGetSize")}function me(e,t){window.WailsInvoke("WZ:"+e+":"+t)}function ve(e,t){window.WailsInvoke("Wz:"+e+":"+t)}function xe(e){window.WailsInvoke("WATP:"+(e?"1":"0"))}function De(e,t){window.WailsInvoke("Wp:"+e+":"+t)}function We(){return r(":wails:WindowGetPos")}function he(){window.WailsInvoke("WH")}function Ee(){window.WailsInvoke("WS")}function ye(){window.WailsInvoke("WM")}function be(){window.WailsInvoke("Wt")}function Ce(){window.WailsInvoke("WU")}function Se(){return r(":wails:WindowIsMaximised")}function Te(){window.WailsInvoke("Wm")}function ke(){window.WailsInvoke("Wu")}function Ie(){return r(":wails:WindowIsMinimised")}function Ae(){return r(":wails:WindowIsNormal")}function Oe(e,t,n,i){let o=JSON.stringify({r:e||0,g:t||0,b:n||0,a:i||255});window.WailsInvoke("Wr:"+o)}var S={};p(S,{ScreenGetAll:()=>Re});function Re(){return r(":wails:ScreenGetAll")}var T={};p(T,{BrowserOpenURL:()=>Ne});function Ne(e){window.WailsInvoke("BO:"+e)}var k={};p(k,{ClipboardGetText:()=>Pe,ClipboardSetText:()=>Le});function Le(e){return r(":wails:ClipboardSetText",[e])}function Pe(){return r(":wails:ClipboardGetText")}var I={};p(I,{CanResolveFilePaths:()=>V,OnFileDrop:()=>Fe,OnFileDropOff:()=>Me,ResolveFilePaths:()=>ze});var a={registered:!1,defaultUseDropTarget:!0,useDropTarget:!0,nextDeactivate:null,nextDeactivateTimeout:null},m="wails-drop-target-active";function h(e){let t=e.getPropertyValue(window.wails.flags.cssDropProperty).trim();return t?t===window.wails.flags.cssDropValue:!1}function G(e){if(!e.dataTransfer.types.includes("Files")||(e.preventDefault(),e.dataTransfer.dropEffect="copy",!window.wails.flags.enableWailsDragAndDrop)||!a.useDropTarget)return;let n=e.target;if(a.nextDeactivate&&a.nextDeactivate(),!n||!h(getComputedStyle(n)))return;let i=n;for(;i;)h(getComputedStyle(i))&&i.classList.add(m),i=i.parentElement}function H(e){if(!!e.dataTransfer.types.includes("Files")&&(e.preventDefault(),!!window.wails.flags.enableWailsDragAndDrop&&!!a.useDropTarget)){if(!e.target||!h(getComputedStyle(e.target)))return null;a.nextDeactivate&&a.nextDeactivate(),a.nextDeactivate=()=>{Array.from(document.getElementsByClassName(m)).forEach(n=>n.classList.remove(m)),a.nextDeactivate=null,a.nextDeactivateTimeout&&(clearTimeout(a.nextDeactivateTimeout),a.nextDeactivateTimeout=null)},a.nextDeactivateTimeout=setTimeout(()=>{a.nextDeactivate&&a.nextDeactivate()},50)}}function U(e){if(!!e.dataTransfer.types.includes("Files")&&(e.preventDefault(),!!window.wails.flags.enableWailsDragAndDrop)){if(V()){let n=[];e.dataTransfer.items?n=[...e.dataTransfer.items].map((i,o)=>{if(i.kind==="file")return i.getAsFile()}):n=[...e.dataTransfer.files],window.runtime.ResolveFilePaths(e.x,e.y,n)}!a.useDropTarget||(a.nextDeactivate&&a.nextDeactivate(),Array.from(document.getElementsByClassName(m)).forEach(n=>n.classList.remove(m)))}}function V(){return window.chrome?.webview?.postMessageWithAdditionalObjects!=null}function ze(e,t,n){window.chrome?.webview?.postMessageWithAdditionalObjects&&chrome.webview.postMessageWithAdditionalObjects(`file:drop:${e}:${t}`,n)}function Fe(e,t){if(typeof e!="function"){console.error("DragAndDropCallback is not a function");return}if(a.registered)return;a.registered=!0;let n=typeof t;a.useDropTarget=n==="undefined"||n!=="boolean"?a.defaultUseDropTarget:t,window.addEventListener("dragover",G),window.addEventListener("dragleave",H),window.addEventListener("drop",U);let i=e;a.useDropTarget&&(i=function(o,s,l){let w=document.elementFromPoint(o,s);if(!w||!h(getComputedStyle(w)))return null;e(o,s,l)}),x("wails:file-drop",i)}function Me(){window.removeEventListener("dragover",G),window.removeEventListener("dragleave",H),window.removeEventListener("drop",U),D("wails:file-drop"),a.registered=!1}function j(e){let t=e.target;switch(window.getComputedStyle(t).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":e.preventDefault();return;default:if(t.isContentEditable)return;let o=window.getSelection(),s=o.toString().length>0;if(s)for(let l=0;lje,CleanupNotifications:()=>He,InitializeNotifications:()=>Ge,IsNotificationAvailable:()=>Ue,RegisterNotificationCategory:()=>$e,RemoveAllDeliveredNotifications:()=>_e,RemoveAllPendingNotifications:()=>Ye,RemoveDeliveredNotification:()=>Ze,RemoveNotification:()=>Ke,RemoveNotificationCategory:()=>qe,RemovePendingNotification:()=>Qe,RequestNotificationAuthorization:()=>Ve,SendNotification:()=>Je,SendNotificationWithActions:()=>Xe});function Ge(){return r(":wails:InitializeNotifications")}function He(){return r(":wails:CleanupNotifications")}function Ue(){return r(":wails:IsNotificationAvailable")}function Ve(){return r(":wails:RequestNotificationAuthorization")}function je(){return r(":wails:CheckNotificationAuthorization")}function Je(e){return r(":wails:SendNotification",[e])}function Xe(e){return r(":wails:SendNotificationWithActions",[e])}function $e(e){return r(":wails:RegisterNotificationCategory",[e])}function qe(e){return r(":wails:RemoveNotificationCategory",[e])}function Ye(){return r(":wails:RemoveAllPendingNotifications")}function Qe(e){return r(":wails:RemovePendingNotification",[e])}function _e(){return r(":wails:RemoveAllDeliveredNotifications")}function Ze(e){return r(":wails:RemoveDeliveredNotification",[e])}function Ke(e){return r(":wails:RemoveNotification",[e])}function et(){window.WailsInvoke("Q")}function tt(){window.WailsInvoke("S")}function nt(){window.WailsInvoke("H")}function it(){return r(":wails:Environment")}window.runtime={...y,...C,...T,...S,...k,...I,...A,EventsOn:x,EventsOnce:N,EventsOnMultiple:v,EventsEmit:z,EventsOff:D,EventsOffAll:F,Environment:it,Show:tt,Hide:nt,Quit:et};window.wails={Callback:M,EventsNotify:P,SetBindings:B,eventListeners:f,callbacks:c,flags:{disableScrollbarDrag:!1,disableDefaultContextMenu:!1,enableResize:!1,defaultCursor:null,borderThickness:6,shouldDrag:!1,deferDragToMouseMove:!0,cssDragProperty:"--wails-draggable",cssDragValue:"drag",cssDropProperty:"--wails-drop-target",cssDropValue:"drop",enableWailsDragAndDrop:!1}};window.wailsbindings&&(window.wails.SetBindings(window.wailsbindings),delete window.wails.SetBindings);delete window.wailsbindings;var ot=function(e){var t=window.getComputedStyle(e.target).getPropertyValue(window.wails.flags.cssDragProperty);return t&&(t=t.trim()),!(t!==window.wails.flags.cssDragValue||e.buttons!==1||e.detail!==1)};window.wails.setCSSDragProperties=function(e,t){window.wails.flags.cssDragProperty=e,window.wails.flags.cssDragValue=t};window.wails.setCSSDropProperties=function(e,t){window.wails.flags.cssDropProperty=e,window.wails.flags.cssDropValue=t};window.addEventListener("mousedown",e=>{if(window.wails.flags.resizeEdge){window.WailsInvoke("resize:"+window.wails.flags.resizeEdge),e.preventDefault();return}if(ot(e)){if(window.wails.flags.disableScrollbarDrag&&(e.offsetX>e.target.clientWidth||e.offsetY>e.target.clientHeight))return;window.wails.flags.deferDragToMouseMove?window.wails.flags.shouldDrag=!0:(e.preventDefault(),window.WailsInvoke("drag"));return}else window.wails.flags.shouldDrag=!1});window.addEventListener("mouseup",()=>{window.wails.flags.shouldDrag=!1});function d(e){document.documentElement.style.cursor=e||window.wails.flags.defaultCursor,window.wails.flags.resizeEdge=e}window.addEventListener("mousemove",function(e){if(window.wails.flags.shouldDrag&&(window.wails.flags.shouldDrag=!1,(e.buttons!==void 0?e.buttons:e.which)>0)){window.WailsInvoke("drag");return}if(!window.wails.flags.enableResize)return;window.wails.flags.defaultCursor==null&&(window.wails.flags.defaultCursor=document.documentElement.style.cursor),window.outerWidth-e.clientX; + +// [CleanupNotifications](https://wails.io/docs/reference/runtime/notification#cleanupnotifications) +// Cleans up notification resources and releases any held connections. +export function CleanupNotifications(): Promise; + +// [IsNotificationAvailable](https://wails.io/docs/reference/runtime/notification#isnotificationavailable) +// Checks if notifications are available on the current platform. +export function IsNotificationAvailable(): Promise; + +// [RequestNotificationAuthorization](https://wails.io/docs/reference/runtime/notification#requestnotificationauthorization) +// Requests notification authorization from the user (macOS only). +export function RequestNotificationAuthorization(): Promise; + +// [CheckNotificationAuthorization](https://wails.io/docs/reference/runtime/notification#checknotificationauthorization) +// Checks the current notification authorization status (macOS only). +export function CheckNotificationAuthorization(): Promise; + +// [SendNotification](https://wails.io/docs/reference/runtime/notification#sendnotification) +// Sends a basic notification with the given options. +export function SendNotification(options: NotificationOptions): Promise; + +// [SendNotificationWithActions](https://wails.io/docs/reference/runtime/notification#sendnotificationwithactions) +// Sends a notification with action buttons. Requires a registered category. +export function SendNotificationWithActions(options: NotificationOptions): Promise; + +// [RegisterNotificationCategory](https://wails.io/docs/reference/runtime/notification#registernotificationcategory) +// Registers a notification category that can be used with SendNotificationWithActions. +export function RegisterNotificationCategory(category: NotificationCategory): Promise; + +// [RemoveNotificationCategory](https://wails.io/docs/reference/runtime/notification#removenotificationcategory) +// Removes a previously registered notification category. +export function RemoveNotificationCategory(categoryId: string): Promise; + +// [RemoveAllPendingNotifications](https://wails.io/docs/reference/runtime/notification#removeallpendingnotifications) +// Removes all pending notifications from the notification center. +export function RemoveAllPendingNotifications(): Promise; + +// [RemovePendingNotification](https://wails.io/docs/reference/runtime/notification#removependingnotification) +// Removes a specific pending notification by its identifier. +export function RemovePendingNotification(identifier: string): Promise; + +// [RemoveAllDeliveredNotifications](https://wails.io/docs/reference/runtime/notification#removealldeliverednotifications) +// Removes all delivered notifications from the notification center. +export function RemoveAllDeliveredNotifications(): Promise; + +// [RemoveDeliveredNotification](https://wails.io/docs/reference/runtime/notification#removedeliverednotification) +// Removes a specific delivered notification by its identifier. +export function RemoveDeliveredNotification(identifier: string): Promise; + +// [RemoveNotification](https://wails.io/docs/reference/runtime/notification#removenotification) +// Removes a notification by its identifier (cross-platform convenience function). +export function RemoveNotification(identifier: string): Promise; \ No newline at end of file diff --git a/v2/internal/frontend/runtime/wrapper/runtime.js b/v2/internal/frontend/runtime/wrapper/runtime.js index 7cb89d750..556621eeb 100644 --- a/v2/internal/frontend/runtime/wrapper/runtime.js +++ b/v2/internal/frontend/runtime/wrapper/runtime.js @@ -239,4 +239,60 @@ export function CanResolveFilePaths() { export function ResolveFilePaths(files) { return window.runtime.ResolveFilePaths(files); +} + +export function InitializeNotifications() { + return window.runtime.InitializeNotifications(); +} + +export function CleanupNotifications() { + return window.runtime.CleanupNotifications(); +} + +export function IsNotificationAvailable() { + return window.runtime.IsNotificationAvailable(); +} + +export function RequestNotificationAuthorization() { + return window.runtime.RequestNotificationAuthorization(); +} + +export function CheckNotificationAuthorization() { + return window.runtime.CheckNotificationAuthorization(); +} + +export function SendNotification(options) { + return window.runtime.SendNotification(options); +} + +export function SendNotificationWithActions(options) { + return window.runtime.SendNotificationWithActions(options); +} + +export function RegisterNotificationCategory(category) { + return window.runtime.RegisterNotificationCategory(category); +} + +export function RemoveNotificationCategory(categoryId) { + return window.runtime.RemoveNotificationCategory(categoryId); +} + +export function RemoveAllPendingNotifications() { + return window.runtime.RemoveAllPendingNotifications(); +} + +export function RemovePendingNotification(identifier) { + return window.runtime.RemovePendingNotification(identifier); +} + +export function RemoveAllDeliveredNotifications() { + return window.runtime.RemoveAllDeliveredNotifications(); +} + +export function RemoveDeliveredNotification(identifier) { + return window.runtime.RemoveDeliveredNotification(identifier); +} + +export function RemoveNotification(identifier) { + return window.runtime.RemoveNotification(identifier); } \ No newline at end of file diff --git a/v2/pkg/commands/build/build.go b/v2/pkg/commands/build/build.go index 7263f63ae..491a57801 100644 --- a/v2/pkg/commands/build/build.go +++ b/v2/pkg/commands/build/build.go @@ -3,6 +3,7 @@ package build import ( "fmt" "os" + "os/exec" "path/filepath" "runtime" "strings" @@ -357,6 +358,16 @@ func execBuildApplication(builder Builder, options *Options) (string, error) { pterm.Println("Done.") } + if runtime.GOOS == "darwin" && options.Platform == "darwin" { + // On macOS, self-sign the .app bundle so notifications work + printBulletPoint("Self-signing application: ") + cmd := exec.Command("/usr/bin/codesign", "--force", "--deep", "--sign", "-", options.CompiledBinary) + if out, err := cmd.CombinedOutput(); err != nil { + return "", fmt.Errorf("codesign failed: %v – %s", err, out) + } + pterm.Println("Done.") + } + if options.Platform == "windows" { const nativeWebView2Loader = "native_webview2loader" diff --git a/v2/pkg/runtime/notifications.go b/v2/pkg/runtime/notifications.go new file mode 100644 index 000000000..46ae09fac --- /dev/null +++ b/v2/pkg/runtime/notifications.go @@ -0,0 +1,136 @@ +package runtime + +import ( + "context" + + "github.com/wailsapp/wails/v2/internal/frontend" +) + +// NotificationOptions contains configuration for a notification. +type NotificationOptions = frontend.NotificationOptions + +// NotificationAction represents an action button for a notification. +type NotificationAction = frontend.NotificationAction + +// NotificationCategory groups actions for notifications. +type NotificationCategory = frontend.NotificationCategory + +// NotificationResponse represents the response sent by interacting with a notification. +type NotificationResponse = frontend.NotificationResponse + +// NotificationResult represents the result of a notification response, +// returning the response or any errors that occurred. +type NotificationResult = frontend.NotificationResult + +// InitializeNotifications initializes the notification service for the application. +// This must be called before sending any notifications. On macOS, this also ensures +// the notification delegate is properly initialized. +func InitializeNotifications(ctx context.Context) error { + fe := getFrontend(ctx) + return fe.InitializeNotifications() +} + +// CleanupNotifications cleans up notification resources and releases any held connections. +// This should be called when shutting down the application to properly release resources +// (primarily needed on Linux to close D-Bus connections). +func CleanupNotifications(ctx context.Context) { + fe := getFrontend(ctx) + fe.CleanupNotifications() +} + +// IsNotificationAvailable checks if notifications are available on the current platform. +func IsNotificationAvailable(ctx context.Context) bool { + fe := getFrontend(ctx) + return fe.IsNotificationAvailable() +} + +// RequestNotificationAuthorization requests notification authorization from the user. +// On macOS, this prompts the user to allow notifications. On other platforms, this +// always returns true. Returns true if authorization was granted, false otherwise. +func RequestNotificationAuthorization(ctx context.Context) (bool, error) { + fe := getFrontend(ctx) + return fe.RequestNotificationAuthorization() +} + +// CheckNotificationAuthorization checks the current notification authorization status. +// On macOS, this checks if the app has notification permissions. On other platforms, +// this always returns true. +func CheckNotificationAuthorization(ctx context.Context) (bool, error) { + fe := getFrontend(ctx) + return fe.CheckNotificationAuthorization() +} + +// SendNotification sends a basic notification with the given options. +// The notification will display with the provided title, subtitle (if supported), +// and body text. +func SendNotification(ctx context.Context, options NotificationOptions) error { + fe := getFrontend(ctx) + return fe.SendNotification(options) +} + +// SendNotificationWithActions sends a notification with action buttons. +// A NotificationCategory must be registered first using RegisterNotificationCategory. +// The options.CategoryID must match a previously registered category ID. +// If the category is not found, a basic notification will be sent instead. +func SendNotificationWithActions(ctx context.Context, options NotificationOptions) error { + fe := getFrontend(ctx) + return fe.SendNotificationWithActions(options) +} + +// RegisterNotificationCategory registers a notification category that can be used +// with SendNotificationWithActions. Categories define the action buttons and optional +// reply fields that will appear on notifications. +func RegisterNotificationCategory(ctx context.Context, category NotificationCategory) error { + fe := getFrontend(ctx) + return fe.RegisterNotificationCategory(category) +} + +// RemoveNotificationCategory removes a previously registered notification category. +func RemoveNotificationCategory(ctx context.Context, categoryId string) error { + fe := getFrontend(ctx) + return fe.RemoveNotificationCategory(categoryId) +} + +// RemoveAllPendingNotifications removes all pending notifications from the notification center. +// On Windows, this is a no-op as the platform manages notification lifecycle automatically. +func RemoveAllPendingNotifications(ctx context.Context) error { + fe := getFrontend(ctx) + return fe.RemoveAllPendingNotifications() +} + +// RemovePendingNotification removes a specific pending notification by its identifier. +// On Windows, this is a no-op as the platform manages notification lifecycle automatically. +func RemovePendingNotification(ctx context.Context, identifier string) error { + fe := getFrontend(ctx) + return fe.RemovePendingNotification(identifier) +} + +// RemoveAllDeliveredNotifications removes all delivered notifications from the notification center. +// On Windows, this is a no-op as the platform manages notification lifecycle automatically. +func RemoveAllDeliveredNotifications(ctx context.Context) error { + fe := getFrontend(ctx) + return fe.RemoveAllDeliveredNotifications() +} + +// RemoveDeliveredNotification removes a specific delivered notification by its identifier. +// On Windows, this is a no-op as the platform manages notification lifecycle automatically. +func RemoveDeliveredNotification(ctx context.Context, identifier string) error { + fe := getFrontend(ctx) + return fe.RemoveDeliveredNotification(identifier) +} + +// RemoveNotification removes a notification by its identifier. +// This is a convenience function that works across platforms. On macOS, use the +// more specific RemovePendingNotification or RemoveDeliveredNotification functions. +func RemoveNotification(ctx context.Context, identifier string) error { + fe := getFrontend(ctx) + return fe.RemoveNotification(identifier) +} + +// OnNotificationResponse registers a callback function that will be invoked when +// a user interacts with a notification (e.g., clicks an action button or the notification itself). +// The callback receives a NotificationResult containing the response details or any errors. +func OnNotificationResponse(ctx context.Context, callback func(result NotificationResult)) { + fe := getFrontend(ctx) + fe.OnNotificationResponse(callback) +} diff --git a/website/docs/guides/notifications.mdx b/website/docs/guides/notifications.mdx new file mode 100644 index 000000000..50d16cb50 --- /dev/null +++ b/website/docs/guides/notifications.mdx @@ -0,0 +1,233 @@ +# Notifications + +Wails provides a comprehensive cross-platform notification system for desktop applications. This runtime allows you to display native system notifications with support for interactive elements like action buttons and text input fields. + +:::info JavaScript + +Notifications are currently unsupported in the JS runtime. + +::: + +## Basic Usage + +### Initializing Notifications + +First, initialize the notification system. This should be called during app startup (typically in `OnStartup`): + +```go +err := runtime.InitializeNotifications(a.ctx) +if err != nil { + // Handle initialization error + // On macOS, this may fail if bundle identifier is not set +} +``` + +Then, check if notifications are available on the current platform: + +```go +if runtime.IsNotificationAvailable(a.ctx) { + // Notifications are supported + // On macOS, this checks for macOS 10.14+ + // On Windows and Linux, this always returns true +} +``` + +On macOS, you'll need to request permission before sending notifications: + +```go +authorized, err := runtime.CheckNotificationAuthorization(a.ctx) +if err != nil { + // Handle authorization error +} + +if !authorized { + authorized, err = runtime.RequestNotificationAuthorization(a.ctx) + if err != nil || !authorized { + // Handle permission denial + } +} +``` + +On Windows and Linux, authorization is not required as these platforms don't have permission systems. + +### Sending Basic Notifications + +Send a basic notification with a unique ID, title, optional subtitle (macOS and Linux), and body text: + +```go +err := runtime.SendNotification(a.ctx, runtime.NotificationOptions{ + ID: "calendar-invite-001", + Title: "New Calendar Invite", + Subtitle: "From: Jane Doe", // Optional - macOS and Linux only + Body: "Tap to view the event", +}) +if err != nil { + // Handle error +} +``` + +## Interactive Notifications + +Interactive notifications allow users to respond with button actions or text input. You must first register a notification category that defines the available actions. + +### Creating Notification Categories + +Define a category with action buttons and optional text input: + +```go +categoryID := "message-category" + +category := runtime.NotificationCategory{ + ID: categoryID, + Actions: []runtime.NotificationAction{ + { + ID: "OPEN", + Title: "Open", + }, + { + ID: "ARCHIVE", + Title: "Archive", + Destructive: true, // macOS-specific - shows as red button + }, + }, + HasReplyField: true, + ReplyPlaceholder: "Type your reply...", + ReplyButtonTitle: "Reply", +} + +err := runtime.RegisterNotificationCategory(a.ctx, category) +if err != nil { + // Handle error +} +``` + +### Sending Interactive Notifications + +Send an interactive notification using the registered category. If the category is not found or `CategoryID` is empty, a basic notification will be sent instead: + +```go +err := runtime.SendNotificationWithActions(a.ctx, runtime.NotificationOptions{ + ID: "message-001", + Title: "New Message", + Subtitle: "From: John Smith", // Optional - macOS and Linux only + Body: "Hey, are you free for lunch?", + CategoryID: categoryID, +}) +if err != nil { + // Handle error +} +``` + +## Handling Notification Responses + +Listen for user interactions with notifications by registering a callback: + +```go +runtime.OnNotificationResponse(a.ctx, func(result runtime.NotificationResult) { + if result.Error != nil { + // Handle response error + return + } + + response := result.Response + fmt.Printf("Notification %s was actioned with: %s\n", + response.ID, response.ActionIdentifier) + + if response.ActionIdentifier == "TEXT_REPLY" { + fmt.Printf("User replied: %s\n", response.UserText) + } + + // You can also emit events to the frontend + runtime.EventsEmit(a.ctx, "notification", response) +}) +``` + +## Adding Custom Data + +Basic and interactive notifications can include custom data that will be returned in the response: + +```go +err := runtime.SendNotification(a.ctx, runtime.NotificationOptions{ + ID: "event-001", + Title: "Team Meeting", + Subtitle: "In 30 minutes", + Body: "Don't forget your presentation materials!", + Data: map[string]interface{}{ + "eventId": "meeting-123", + "startTime": "2024-01-15T14:00:00Z", + "attendees": []string{"john@company.com", "jane@company.com"}, + "priority": "high", + }, +}) + +// In the response handler: +runtime.OnNotificationResponse(a.ctx, func(result runtime.NotificationResult) { + response := result.Response + if eventId, ok := response.UserInfo["eventId"].(string); ok { + fmt.Printf("Event ID: %s\n", eventId) + } +}) +``` + +## Managing Notifications + +### Removing Notification Categories + +Remove a previously registered notification category: + +```go +err := runtime.RemoveNotificationCategory(a.ctx, "message-category") +``` + +### Managing Notifications Lifecycle + +Control notification visibility: + +```go +// Remove a specific pending notification (macOS and Linux only) +err := runtime.RemovePendingNotification(a.ctx, "notification-id") + +// Remove all pending notifications (macOS and Linux only) +err = runtime.RemoveAllPendingNotifications(a.ctx) + +// Remove a specific delivered notification (macOS and Linux only) +err = runtime.RemoveDeliveredNotification(a.ctx, "notification-id") + +// Remove all delivered notifications (macOS and Linux only) +err = runtime.RemoveAllDeliveredNotifications(a.ctx) + +// Remove a notification (Linux-specific) +err = runtime.RemoveNotification(a.ctx, "notification-id") +``` + +## Platform Considerations + +### macOS + +- **Authorization Required**: Apps must request notification permission +- **Notarization**: Required for app distribution on macOS +- **Features**: Supports subtitles, user text input, destructive actions, dark/light mode +- **Behavior**: Notifications appear in the system notification center + +### Windows + +- **No Authorization**: No permission system required +- **Features**: Supports user text input, high DPI displays, Windows theme adaptation +- **Limitations**: Does not support subtitles +- **Behavior**: Uses Windows toast notifications + +### Linux + +- **Desktop Environment Dependent**: Behavior varies by DE (GNOME, KDE, etc.) +- **Features**: Supports subtitles and themes +- **Limitations**: Does not support user text input +- **Behavior**: Uses native notification system when available + +## Best Practices + +1. **Check Platform Support**: Always verify notifications are available before using them +2. **Handle Authorization**: Properly request and check permissions on macOS +3. **Use Descriptive Content**: Provide clear titles, subtitles, and action button labels +4. **Handle Responses**: Always implement proper error handling for notification responses +5. **Test Across Platforms**: Verify functionality on your target platforms +6. **Clean Up**: Remove old notification categories when they're no longer needed \ No newline at end of file diff --git a/website/docs/reference/runtime/notification.mdx b/website/docs/reference/runtime/notification.mdx new file mode 100644 index 000000000..e9890ce59 --- /dev/null +++ b/website/docs/reference/runtime/notification.mdx @@ -0,0 +1,601 @@ +--- +sidebar_position: 6 +--- + +# Notification + +This part of the runtime provides access to native system notifications with support for interactive elements like action buttons and text input fields. + +### InitializeNotifications + +Initializes the notification system. It should be called during app startup. + +**Go:** `InitializeNotifications(ctx context.Context) error` + +**JavaScript:** `InitializeNotifications(): Promise` + +Returns: Error if initialization fails + +**Example:** +```go +err := runtime.InitializeNotifications(ctx) +if err != nil { + log.Fatal(err) +} +``` + +```javascript +await runtime.InitializeNotifications(); +``` + +### IsNotificationAvailable + +Checks if notifications are supported on the current platform. + +**Go:** `IsNotificationAvailable(ctx context.Context) bool` + +**JavaScript:** `IsNotificationAvailable(): Promise` + +Returns: `true` if notifications are supported, `false` otherwise + +**Example:** +```go +if !runtime.IsNotificationAvailable(ctx) { + log.Println("Notifications not available on this platform") +} +``` + +```javascript +const available = await runtime.IsNotificationAvailable(); +if (!available) { + console.log("Notifications not available on this platform"); +} +``` + +### RequestNotificationAuthorization + +Requests permission to display notifications (macOS only). On Windows and Linux, this always returns `true`. + +**Go:** `RequestNotificationAuthorization(ctx context.Context) (bool, error)` + +**JavaScript:** `RequestNotificationAuthorization(): Promise` + +Returns: Authorization status and error + +**Example:** +```go +authorized, err := runtime.RequestNotificationAuthorization(ctx) +``` + +```javascript +const authorized = await runtime.RequestNotificationAuthorization(); +``` + +### CheckNotificationAuthorization + +Checks the current notification authorization status (macOS only). On Windows and Linux, this always returns `true`. + +**Go:** `CheckNotificationAuthorization(ctx context.Context) (bool, error)` + +**JavaScript:** `CheckNotificationAuthorization(): Promise` + +Returns: Authorization status and error + +**Example:** +```go +authorized, err := runtime.CheckNotificationAuthorization(ctx) +``` + +```javascript +const authorized = await runtime.CheckNotificationAuthorization(); +``` + +### CleanupNotifications + +Cleans up notification resources and releases any held connections. This should be called when shutting down the application, particularly on Linux where it closes the D-Bus connection. + +**Go:** `CleanupNotifications(ctx context.Context)` + +**JavaScript:** `CleanupNotifications(): Promise` + +**Example:** +```go +runtime.CleanupNotifications(ctx) +``` + +```javascript +await runtime.CleanupNotifications(); +``` + +### SendNotification + +Sends a basic notification to the system. + +**Go:** `SendNotification(ctx context.Context, options NotificationOptions) error` + +**JavaScript:** `SendNotification(options: NotificationOptions): Promise` + +Returns: Error if the notification fails to send + +**Example:** +```go +err := runtime.SendNotification(ctx, runtime.NotificationOptions{ + ID: "notif-1", + Title: "Hello", + Body: "This is a notification", +}) +``` + +```javascript +await runtime.SendNotification({ + id: "notif-1", + title: "Hello", + body: "This is a notification" +}); +``` + +### SendNotificationWithActions + +Sends an interactive notification with predefined actions. Requires a registered notification category. If the category is not found or `CategoryID` is empty, a basic notification will be sent instead. + +**Go:** `SendNotificationWithActions(ctx context.Context, options NotificationOptions) error` + +**JavaScript:** `SendNotificationWithActions(options: NotificationOptions): Promise` + +Returns: Error if the notification fails to send + +**Example:** +```go +err := runtime.SendNotificationWithActions(ctx, runtime.NotificationOptions{ + ID: "notif-2", + Title: "Task Reminder", + Body: "Complete your task", + CategoryID: "TASK_CATEGORY", +}) +``` + +```javascript +await runtime.SendNotificationWithActions({ + id: "notif-2", + title: "Task Reminder", + body: "Complete your task", + categoryId: "TASK_CATEGORY" +}); +``` + +### RegisterNotificationCategory + +Registers a notification category that can be used with interactive notifications. Registering a category with the same ID as a previously registered category will override it. + +**Go:** `RegisterNotificationCategory(ctx context.Context, category NotificationCategory) error` + +**JavaScript:** `RegisterNotificationCategory(category: NotificationCategory): Promise` + +Returns: Error if registration fails + +**Example:** +```go +err := runtime.RegisterNotificationCategory(ctx, runtime.NotificationCategory{ + ID: "TASK_CATEGORY", + Actions: []runtime.NotificationAction{ + {ID: "COMPLETE", Title: "Complete"}, + {ID: "CANCEL", Title: "Cancel"}, + }, +}) +``` + +```javascript +await runtime.RegisterNotificationCategory({ + id: "TASK_CATEGORY", + actions: [ + {id: "COMPLETE", title: "Complete"}, + {id: "CANCEL", title: "Cancel"} + ] +}); +``` + +### RemoveNotificationCategory + +Removes a previously registered notification category. + +**Go:** `RemoveNotificationCategory(ctx context.Context, categoryId string) error` + +**JavaScript:** `RemoveNotificationCategory(categoryId: string): Promise` + +Returns: Error if removal fails + +**Example:** +```go +err := runtime.RemoveNotificationCategory(ctx, "TASK_CATEGORY") +``` + +```javascript +await runtime.RemoveNotificationCategory("TASK_CATEGORY"); +``` + +### RemoveAllPendingNotifications + +Removes all pending notifications (macOS and Linux only). + +**Go:** `RemoveAllPendingNotifications(ctx context.Context) error` + +**JavaScript:** `RemoveAllPendingNotifications(): Promise` + +Returns: Error if removal fails + +**Example:** +```go +err := runtime.RemoveAllPendingNotifications(ctx) +``` + +```javascript +await runtime.RemoveAllPendingNotifications(); +``` + +### RemovePendingNotification + +Removes a specific pending notification (macOS and Linux only). + +**Go:** `RemovePendingNotification(ctx context.Context, identifier string) error` + +**JavaScript:** `RemovePendingNotification(identifier: string): Promise` + +Returns: Error if removal fails + +**Example:** +```go +err := runtime.RemovePendingNotification(ctx, "notif-1") +``` + +```javascript +await runtime.RemovePendingNotification("notif-1"); +``` + +### RemoveAllDeliveredNotifications + +Removes all delivered notifications (macOS and Linux only). + +**Go:** `RemoveAllDeliveredNotifications(ctx context.Context) error` + +**JavaScript:** `RemoveAllDeliveredNotifications(): Promise` + +Returns: Error if removal fails + +**Example:** +```go +err := runtime.RemoveAllDeliveredNotifications(ctx) +``` + +```javascript +await runtime.RemoveAllDeliveredNotifications(); +``` + +### RemoveDeliveredNotification + +Removes a specific delivered notification (macOS and Linux only). + +**Go:** `RemoveDeliveredNotification(ctx context.Context, identifier string) error` + +**JavaScript:** `RemoveDeliveredNotification(identifier: string): Promise` + +Returns: Error if removal fails + +**Example:** +```go +err := runtime.RemoveDeliveredNotification(ctx, "notif-1") +``` + +```javascript +await runtime.RemoveDeliveredNotification("notif-1"); +``` + +### RemoveNotification + +Removes a notification by identifier (Linux only). On macOS and Windows, this is a stub that always returns `nil`. + +**Go:** `RemoveNotification(ctx context.Context, identifier string) error` + +**JavaScript:** `RemoveNotification(identifier: string): Promise` + +Returns: Error if removal fails + +**Example:** +```go +err := runtime.RemoveNotification(ctx, "notif-1") +``` + +```javascript +await runtime.RemoveNotification("notif-1"); +``` + +### OnNotificationResponse + +Registers a callback function to handle notification responses when users interact with notifications. + +**Go:** `OnNotificationResponse(ctx context.Context, callback func(result NotificationResult))` + +:::note JavaScript + +`OnNotificationResponse` is not available in the JavaScript runtime. Instead, JavaScript applications should use the [Events API](/docs/reference/runtime/events) to listen for notification responses. From your Go callback, emit an event that your JavaScript code can listen to. + +**Example:** +```go +runtime.OnNotificationResponse(ctx, func(result runtime.NotificationResult) { + if result.Error != nil { + return + } + // Emit an event that JavaScript can listen to + runtime.EventsEmit(ctx, "notification-response", result.Response) +}) +``` + +```javascript +runtime.EventsOn("notification-response", (response) => { + console.log("Notification response:", response); + switch (response.actionIdentifier) { + case "COMPLETE": + // Handle complete action + break; + case "CANCEL": + // Handle cancel action + break; + } +}); +``` + +::: + +## Options + +### NotificationOptions + +**Go:** +```go +type NotificationOptions struct { + ID string `json:"id"` + Title string `json:"title"` + Subtitle string `json:"subtitle,omitempty"` // (macOS and Linux only) + Body string `json:"body,omitempty"` + CategoryID string `json:"categoryId,omitempty"` + Data map[string]interface{} `json:"data,omitempty"` +} +``` + +**TypeScript:** +```typescript +interface NotificationOptions { + id: string; + title: string; + subtitle?: string; // macOS and Linux only + body?: string; + categoryId?: string; + data?: { [key: string]: any }; +} +``` + +| Field | Description | Win | Mac | Lin | +|-------------|------------------------------------------------|-----|-----|-----| +| ID | Unique identifier for the notification | ✅ | ✅ | ✅ | +| Title | Main notification title | ✅ | ✅ | ✅ | +| Subtitle | Subtitle text (macOS and Linux only) | | ✅ | ✅ | +| Body | Main notification content | ✅ | ✅ | ✅ | +| CategoryID | Category identifier for interactive notifications | ✅ | ✅ | ✅ | +| Data | Custom data to associate with the notification | ✅ | ✅ | ✅ | + +### NotificationCategory + +**Go:** +```go +type NotificationCategory struct { + ID string `json:"id,omitempty"` + Actions []NotificationAction `json:"actions,omitempty"` + HasReplyField bool `json:"hasReplyField,omitempty"` + ReplyPlaceholder string `json:"replyPlaceholder,omitempty"` + ReplyButtonTitle string `json:"replyButtonTitle,omitempty"` +} +``` + +**TypeScript:** +```typescript +interface NotificationCategory { + id?: string; + actions?: NotificationAction[]; + hasReplyField?: boolean; + replyPlaceholder?: string; + replyButtonTitle?: string; +} +``` + +| Field | Description | Win | Mac | Lin | +|------------------|------------------------------------------------|-----|-----|-----| +| ID | Unique identifier for the category | ✅ | ✅ | ✅ | +| Actions | Array of action buttons | ✅ | ✅ | ✅ | +| HasReplyField | Whether to include a text input field | ✅ | ✅ | | +| ReplyPlaceholder | Placeholder text for the input field | ✅ | ✅ | | +| ReplyButtonTitle | Text for the reply button | ✅ | ✅ | | + +### NotificationAction + +**Go:** +```go +type NotificationAction struct { + ID string `json:"id,omitempty"` + Title string `json:"title,omitempty"` + Destructive bool `json:"destructive,omitempty"` // (macOS-specific) +} +``` + +**TypeScript:** +```typescript +interface NotificationAction { + id?: string; + title?: string; + destructive?: boolean; // macOS-specific +} +``` + +| Field | Description | Win | Mac | Lin | +|-------------|------------------------------------------------|----------------|-----|-----| +| ID | Unique identifier for the action | ✅ | ✅ | ✅ | +| Title | Button text | ✅ | ✅ | ✅ | +| Destructive | Whether the action is destructive (macOS-only) | | ✅ | | + +#### macOS-specific Behavior + +On macOS, the `Destructive` flag causes the action button to appear in red, indicating it's a destructive action (like delete or cancel). On Windows and Linux, this flag is ignored. + +Example: +```go +actions := []runtime.NotificationAction{ + {ID: "SAVE", Title: "Save"}, + {ID: "DELETE", Title: "Delete", Destructive: true}, // Shows as red button on macOS +} +``` + +### NotificationResponse + +```go +type NotificationResponse struct { + ID string `json:"id,omitempty"` + ActionIdentifier string `json:"actionIdentifier,omitempty"` + CategoryID string `json:"categoryId,omitempty"` // Consistent with NotificationOptions + Title string `json:"title,omitempty"` + Subtitle string `json:"subtitle,omitempty"` // (macOS and Linux only) + Body string `json:"body,omitempty"` + UserText string `json:"userText,omitempty"` + UserInfo map[string]interface{} `json:"userInfo,omitempty"` +} +``` + +| Field | Description | Win | Mac | Lin | +|------------------|------------------------------------------------|-----|-----|-----| +| ID | Notification identifier | ✅ | ✅ | ✅ | +| ActionIdentifier | Action that was triggered | ✅ | ✅ | ✅ | +| CategoryID | Category of the notification | ✅ | ✅ | ✅ | +| Title | Title of the notification | ✅ | ✅ | ✅ | +| Subtitle | Subtitle of the notification (macOS and Linux only) | | ✅ | ✅ | +| Body | Body text of the notification | ✅ | ✅ | ✅ | +| UserText | Text entered by the user | ✅ | ✅ | | +| UserInfo | Custom data from the notification | ✅ | ✅ | ✅ | + +### NotificationResult + +```go +type NotificationResult struct { + Response NotificationResponse + Error error +} +``` + +| Field | Description | +|----------|------------------------------------------------| +| Response | The notification response data | +| Error | Any error that occurred during the interaction | + +## Platform-Specific Behavior + +### macOS + +- **Authorization Required**: Apps must request notification permission before sending notifications +- **Notarization**: Apps must be notarized for distribution +- **Features**: All features supported including subtitles, text input, and destructive actions +- **Styling**: Automatically adapts to system dark/light mode +- **Center**: Notifications appear in macOS Notification Center + +**Example:** +```go +// Check and request authorization +authorized, err := runtime.CheckNotificationAuthorization(ctx) +if err != nil { + return err +} + +if !authorized { + authorized, err = runtime.RequestNotificationAuthorization(ctx) + if err != nil || !authorized { + return fmt.Errorf("notification authorization denied") + } +} + +// Now send notifications +``` + +```javascript +// Check and request authorization +let authorized = await runtime.CheckNotificationAuthorization(); +if (!authorized) { + authorized = await runtime.RequestNotificationAuthorization(); + if (!authorized) { + throw new Error("Notification authorization denied"); + } +} + +// Now send notifications +``` + +### Windows + +- **No Authorization**: Permission system not required +- **Features**: Supports text input and high DPI displays +- **Limitations**: Subtitle not supported +- **Styling**: Adapts to Windows theme settings +- **Behavior**: Uses Windows toast notification system + +### Linux + +- **Desktop Environment Dependent**: Behavior varies by DE (GNOME, KDE, XFCE, etc.) +- **Features**: Supports subtitles +- **Limitations**: User text input not supported +- **Styling**: Follows desktop environment theme +- **Behavior**: Uses native notification system when available + +**Example:** +```go +// Check system support +if !runtime.IsNotificationAvailable(ctx) { + return fmt.Errorf("notifications not supported on this Linux desktop") +} + +// Linux notifications may not support text input +// Only use actions that don't require user text +``` + +```javascript +// Check system support +const available = await runtime.IsNotificationAvailable(); +if (!available) { + throw new Error("Notifications not supported on this Linux desktop"); +} + +// Linux notifications may not support text input +// Only use actions that don't require user text +``` + +## Action Identifiers + +When handling notification responses, these special action identifiers may be present: + +- `DEFAULT_ACTION`: Triggered when the user clicks the notification itself (not an action button) +- `TEXT_REPLY`: Triggered when the user submits text via the reply field + +Example response handling: +```go +runtime.OnNotificationResponse(ctx, func(result runtime.NotificationResult) { + if result.Error != nil { + fmt.Printf("Response error: %v\n", result.Error) + return + } + + response := result.Response + switch response.ActionIdentifier { + case "DEFAULT_ACTION": + fmt.Println("User clicked the notification") + case "TEXT_REPLY": + fmt.Printf("User replied: %s\n", response.UserText) + case "COMPLETE": + fmt.Println("User clicked Complete button") + case "CANCEL": + fmt.Println("User clicked Cancel button") + } +}) +``` diff --git a/website/src/pages/changelog.mdx b/website/src/pages/changelog.mdx index 50208109b..ef0052c1c 100644 --- a/website/src/pages/changelog.mdx +++ b/website/src/pages/changelog.mdx @@ -40,6 +40,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Added `build:tags` to project specification for automatically adding compilation tags by @symball in [PR](https://github.com/wailsapp/wails/pull/4439) - Support for binding generics in [PR](https://github.dev/wailsapp/wails/pull/3626) by @ktsivkov - Add universal link support for macOS by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/4693) +- Notifications API in [PR](https://github.com/wailsapp/wails/pull/4256) by @popaprozac ### Fixed - Added url validation for BrowserOpenURL by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/4484)