@stacksjs/desktop 0.61.24 → 0.63.0

package/dist/index.js

@@ -13,51 +13,23 @@ var __export = (target, all) => {
 // ../../../../node_modules/@tauri-apps/api/shell.js
 var exports_shell = {};
 __export(exports_shell, {
-  open: () => {
-    {
-      return open;
-    }
-  },
-  EventEmitter: () => {
-    {
-      return EventEmitter;
-    }
-  },
-  Command: () => {
-    {
-      return Command;
-    }
-  },
-  Child: () => {
-    {
-      return Child;
-    }
-  }
+  open: () => open,
+  EventEmitter: () => EventEmitter,
+  Command: () => Command,
+  Child: () => Child
 });
 
 // ../../../../node_modules/@tauri-apps/api/tauri.js
 var exports_tauri = {};
 __export(exports_tauri, {
-  transformCallback: () => {
-    {
-      return transformCallback;
-    }
-  },
-  invoke: () => {
-    {
-      return invoke;
-    }
-  },
-  convertFileSrc: () => {
-    {
-      return convertFileSrc;
-    }
-  }
+  transformCallback: () => transformCallback,
+  invoke: () => invoke,
+  convertFileSrc: () => convertFileSrc
 });
-var uid = function() {
+function uid() {
   return window.crypto.getRandomValues(new Uint32Array(1))[0];
-};
-var transformCallback = function(callback, once = false) {
+}
+function transformCallback(callback, once = false) {
   const identifier = uid();
   const prop = `_${identifier}`;
   Object.defineProperty(window, prop, {
@@ -71,7 +43,7 @@ var transformCallback = function(callback, once = false) {
     configurable: true
   });
   return identifier;
-};
+}
 async function invoke(cmd, args = {}) {
   return new Promise((resolve, reject) => {
     const callback = transformCallback((e) => {
@@ -90,9 +62,9 @@ async function invoke(cmd, args = {}) {
     });
   });
 }
-var convertFileSrc = function(filePath, protocol = "asset") {
+function convertFileSrc(filePath, protocol = "asset") {
   return window.__TAURI__.convertFileSrc(filePath, protocol);
-};
+}
 
 // ../../../../node_modules/@tauri-apps/api/helpers/tauri.js
 async function invokeTauriCommand(command) {
@@ -100,21 +72,6 @@ async function invokeTauriCommand(command) {
 }
 
 // ../../../../node_modules/@tauri-apps/api/shell.js
-async function execute(onEvent, program, args = [], options) {
-  if (typeof args === "object") {
-    Object.freeze(args);
-  }
-  return invokeTauriCommand({
-    __tauriModule: "Shell",
-    message: {
-      cmd: "execute",
-      program,
-      args,
-      options,
-      onEventFn: transformCallback(onEvent)
-    }
-  });
-}
 async function open(path, openWith) {
   return invokeTauriCommand({
     __tauriModule: "Shell",
@@ -236,7 +193,13 @@ class Command extends EventEmitter {
     return instance;
   }
   async spawn() {
-    return execute((event) => {
+    const program = this.program;
+    const args = this.args;
+    const options = this.options;
+    if (typeof args === "object") {
+      Object.freeze(args);
+    }
+    const onEvent = (event) => {
       switch (event.event) {
         case "Error":
           this.emit("error", event.payload);
@@ -251,28 +214,33 @@ class Command extends EventEmitter {
           this.stderr.emit("data", event.payload);
           break;
       }
-    }, this.program, this.args, this.options).then((pid) => new Child(pid));
+    };
+    return invokeTauriCommand({
+      __tauriModule: "Shell",
+      message: {
+        cmd: "execute",
+        program,
+        args,
+        options,
+        onEventFn: transformCallback(onEvent)
+      }
+    }).then((pid) => new Child(pid));
   }
   async execute() {
-    return new Promise((resolve, reject) => {
-      this.on("error", reject);
-      const stdout = [];
-      const stderr = [];
-      this.stdout.on("data", (line) => {
-        stdout.push(line);
-      });
-      this.stderr.on("data", (line) => {
-        stderr.push(line);
-      });
-      this.on("close", (payload) => {
-        resolve({
-          code: payload.code,
-          signal: payload.signal,
-          stdout: stdout.join("\n"),
-          stderr: stderr.join("\n")
-        });
-      });
-      this.spawn().catch(reject);
+    const program = this.program;
+    const args = this.args;
+    const options = this.options;
+    if (typeof args === "object") {
+      Object.freeze(args);
+    }
+    return invokeTauriCommand({
+      __tauriModule: "Shell",
+      message: {
+        cmd: "executeAndReturn",
+        program,
+        args,
+        options
+      }
     });
   }
 }
@@ -280,31 +248,11 @@ class Command extends EventEmitter {
 // ../../../../node_modules/@tauri-apps/api/app.js
 var exports_app = {};
 __export(exports_app, {
-  show: () => {
-    {
-      return show;
-    }
-  },
-  hide: () => {
-    {
-      return hide;
-    }
-  },
-  getVersion: () => {
-    {
-      return getVersion;
-    }
-  },
-  getTauriVersion: () => {
-    {
-      return getTauriVersion;
-    }
-  },
-  getName: () => {
-    {
-      return getName;
-    }
-  }
+  show: () => show,
+  hide: () => hide,
+  getVersion: () => getVersion,
+  getTauriVersion: () => getTauriVersion,
+  getName: () => getName
 });
 async function getVersion() {
   return invokeTauriCommand({
@@ -350,16 +298,8 @@ async function hide() {
 // ../../../../node_modules/@tauri-apps/api/clipboard.js
 var exports_clipboard = {};
 __export(exports_clipboard, {
-  writeText: () => {
-    {
-      return writeText;
-    }
-  },
-  readText: () => {
-    {
-      return readText;
-    }
-  }
+  writeText: () => writeText,
+  readText: () => readText
 });
 async function writeText(text) {
   return invokeTauriCommand({
@@ -383,31 +323,11 @@ async function readText() {
 // ../../../../node_modules/@tauri-apps/api/dialog.js
 var exports_dialog = {};
 __export(exports_dialog, {
-  save: () => {
-    {
-      return save;
-    }
-  },
-  open: () => {
-    {
-      return open2;
-    }
-  },
-  message: () => {
-    {
-      return message;
-    }
-  },
-  confirm: () => {
-    {
-      return confirm;
-    }
-  },
-  ask: () => {
-    {
-      return ask;
-    }
-  }
+  save: () => save,
+  open: () => open2,
+  message: () => message,
+  confirm: () => confirm,
+  ask: () => ask
 });
 async function open2(options = {}) {
   if (typeof options === "object") {
@@ -485,26 +405,10 @@ async function confirm(message2, options) {
 // ../../../../node_modules/@tauri-apps/api/event.js
 var exports_event = {};
 __export(exports_event, {
-  once: () => {
-    {
-      return once2;
-    }
-  },
-  listen: () => {
-    {
-      return listen2;
-    }
-  },
-  emit: () => {
-    {
-      return emit2;
-    }
-  },
-  TauriEvent: () => {
-    {
-      return TauriEvent;
-    }
-  }
+  once: () => once2,
+  listen: () => listen2,
+  emit: () => emit2,
+  TauriEvent: () => TauriEvent
 });
 
 // ../../../../node_modules/@tauri-apps/api/helpers/event.js
@@ -585,76 +489,20 @@ var TauriEvent;
 // ../../../../node_modules/@tauri-apps/api/fs.js
 var exports_fs = {};
 __export(exports_fs, {
-  writeTextFile: () => {
-    {
-      return writeTextFile;
-    }
-  },
-  writeFile: () => {
-    {
-      return writeTextFile;
-    }
-  },
-  writeBinaryFile: () => {
-    {
-      return writeBinaryFile;
-    }
-  },
-  renameFile: () => {
-    {
-      return renameFile;
-    }
-  },
-  removeFile: () => {
-    {
-      return removeFile;
-    }
-  },
-  removeDir: () => {
-    {
-      return removeDir;
-    }
-  },
-  readTextFile: () => {
-    {
-      return readTextFile;
-    }
-  },
-  readDir: () => {
-    {
-      return readDir;
-    }
-  },
-  readBinaryFile: () => {
-    {
-      return readBinaryFile;
-    }
-  },
-  exists: () => {
-    {
-      return exists;
-    }
-  },
-  createDir: () => {
-    {
-      return createDir;
-    }
-  },
-  copyFile: () => {
-    {
-      return copyFile;
-    }
-  },
-  Dir: () => {
-    {
-      return BaseDirectory;
-    }
-  },
-  BaseDirectory: () => {
-    {
-      return BaseDirectory;
-    }
-  }
+  writeTextFile: () => writeTextFile,
+  writeFile: () => writeTextFile,
+  writeBinaryFile: () => writeBinaryFile,
+  renameFile: () => renameFile,
+  removeFile: () => removeFile,
+  removeDir: () => removeDir,
+  readTextFile: () => readTextFile,
+  readDir: () => readDir,
+  readBinaryFile: () => readBinaryFile,
+  exists: () => exists,
+  createDir: () => createDir,
+  copyFile: () => copyFile,
+  Dir: () => BaseDirectory,
+  BaseDirectory: () => BaseDirectory
 });
 async function readTextFile(filePath, options = {}) {
   return invokeTauriCommand({
@@ -841,31 +689,11 @@ var BaseDirectory;
 // ../../../../node_modules/@tauri-apps/api/globalShortcut.js
 var exports_globalShortcut = {};
 __export(exports_globalShortcut, {
-  unregisterAll: () => {
-    {
-      return unregisterAll;
-    }
-  },
-  unregister: () => {
-    {
-      return unregister;
-    }
-  },
-  registerAll: () => {
-    {
-      return registerAll;
-    }
-  },
-  register: () => {
-    {
-      return register;
-    }
-  },
-  isRegistered: () => {
-    {
-      return isRegistered;
-    }
-  }
+  unregisterAll: () => unregisterAll,
+  unregister: () => unregister,
+  registerAll: () => registerAll,
+  register: () => register,
+  isRegistered: () => isRegistered
 });
 async function register(shortcut, handler) {
   return invokeTauriCommand({
@@ -917,36 +745,12 @@ async function unregisterAll() {
 // ../../../../node_modules/@tauri-apps/api/http.js
 var exports_http = {};
 __export(exports_http, {
-  getClient: () => {
-    {
-      return getClient;
-    }
-  },
-  fetch: () => {
-    {
-      return fetch;
-    }
-  },
-  ResponseType: () => {
-    {
-      return ResponseType;
-    }
-  },
-  Response: () => {
-    {
-      return Response;
-    }
-  },
-  Client: () => {
-    {
-      return Client;
-    }
-  },
-  Body: () => {
-    {
-      return Body;
-    }
-  }
+  getClient: () => getClient,
+  fetch: () => fetch,
+  ResponseType: () => ResponseType,
+  Response: () => Response,
+  Client: () => Client,
+  Body: () => Body
 });
 async function formBody(data) {
   const form = {};
@@ -1129,28 +933,12 @@ var defaultClient = null;
 // ../../../../node_modules/@tauri-apps/api/mocks.js
 var exports_mocks = {};
 __export(exports_mocks, {
-  mockWindows: () => {
-    {
-      return mockWindows;
-    }
-  },
-  mockIPC: () => {
-    {
-      return mockIPC;
-    }
-  },
-  mockConvertFileSrc: () => {
-    {
-      return mockConvertFileSrc;
-    }
-  },
-  clearMocks: () => {
-    {
-      return clearMocks;
-    }
-  }
+  mockWindows: () => mockWindows,
+  mockIPC: () => mockIPC,
+  mockConvertFileSrc: () => mockConvertFileSrc,
+  clearMocks: () => clearMocks
 });
-var mockIPC = function(cb) {
+function mockIPC(cb) {
   window.__TAURI_IPC__ = async ({ cmd, callback, error, ...args }) => {
     try {
       window[`_${callback}`](await cb(cmd, args));
@@ -1158,22 +946,22 @@ var mockIPC = function(cb) {
       window[`_${error}`](err);
     }
   };
-};
-var mockWindows = function(current, ...additionalWindows) {
+}
+function mockWindows(current, ...additionalWindows) {
   window.__TAURI_METADATA__ = {
     __windows: [current, ...additionalWindows].map((label) => ({ label })),
     __currentWindow: { label: current }
   };
-};
-var mockConvertFileSrc = function(osName, windowsProtocolScheme = "https") {
+}
+function mockConvertFileSrc(osName, windowsProtocolScheme = "https") {
   var _a;
   window.__TAURI__ = (_a = window.__TAURI__) !== null && _a !== undefined ? _a : {};
   window.__TAURI__.convertFileSrc = function(filePath, protocol = "asset") {
     const path = encodeURIComponent(filePath);
     return osName === "windows" ? `${windowsProtocolScheme}://${protocol}.localhost/${path}` : `${protocol}://localhost/${path}`;
   };
-};
-var clearMocks = function() {
+}
+function clearMocks() {
   var _a;
   if ((_a = window.__TAURI__) === null || _a === undefined ? undefined : _a.convertFileSrc)
     delete window.__TAURI__.convertFileSrc;
@@ -1181,26 +969,14 @@ var clearMocks = function() {
     delete window.__TAURI_IPC__;
   if (window.__TAURI_METADATA__)
     delete window.__TAURI_METADATA__;
-};
+}
 
 // ../../../../node_modules/@tauri-apps/api/notification.js
 var exports_notification = {};
 __export(exports_notification, {
-  sendNotification: () => {
-    {
-      return sendNotification;
-    }
-  },
-  requestPermission: () => {
-    {
-      return requestPermission;
-    }
-  },
-  isPermissionGranted: () => {
-    {
-      return isPermissionGranted;
-    }
-  }
+  sendNotification: () => sendNotification,
+  requestPermission: () => requestPermission,
+  isPermissionGranted: () => isPermissionGranted
 });
 async function isPermissionGranted() {
   if (window.Notification.permission !== "default") {
@@ -1216,58 +992,30 @@ async function isPermissionGranted() {
 async function requestPermission() {
   return window.Notification.requestPermission();
 }
-var sendNotification = function(options) {
+function sendNotification(options) {
   if (typeof options === "string") {
     new window.Notification(options);
   } else {
     new window.Notification(options.title, options);
   }
-};
+}
 
 // ../../../../node_modules/@tauri-apps/api/os.js
 var exports_os = {};
 __export(exports_os, {
-  version: () => {
-    {
-      return version;
-    }
-  },
-  type: () => {
-    {
-      return type;
-    }
-  },
-  tempdir: () => {
-    {
-      return tempdir;
-    }
-  },
-  platform: () => {
-    {
-      return platform;
-    }
-  },
-  locale: () => {
-    {
-      return locale;
-    }
-  },
-  arch: () => {
-    {
-      return arch;
-    }
-  },
-  EOL: () => {
-    {
-      return EOL;
-    }
-  }
+  version: () => version,
+  type: () => type,
+  tempdir: () => tempdir,
+  platform: () => platform,
+  locale: () => locale,
+  arch: () => arch,
+  EOL: () => EOL
 });
 
 // ../../../../node_modules/@tauri-apps/api/helpers/os-check.js
-var isWindows = function() {
+function isWindows() {
   return navigator.appVersion.includes("Win");
-};
+}
 
 // ../../../../node_modules/@tauri-apps/api/os.js
 async function platform() {
@@ -1323,181 +1071,41 @@ var EOL = isWindows() ? "\r\n" : "\n";
 // ../../../../node_modules/@tauri-apps/api/path.js
 var exports_path = {};
 __export(exports_path, {
-  videoDir: () => {
-    {
-      return videoDir;
-    }
-  },
-  templateDir: () => {
-    {
-      return templateDir;
-    }
-  },
-  sep: () => {
-    {
-      return sep;
-    }
-  },
-  runtimeDir: () => {
-    {
-      return runtimeDir;
-    }
-  },
-  resourceDir: () => {
-    {
-      return resourceDir;
-    }
-  },
-  resolveResource: () => {
-    {
-      return resolveResource;
-    }
-  },
-  resolve: () => {
-    {
-      return resolve;
-    }
-  },
-  publicDir: () => {
-    {
-      return publicDir;
-    }
-  },
-  pictureDir: () => {
-    {
-      return pictureDir;
-    }
-  },
-  normalize: () => {
-    {
-      return normalize;
-    }
-  },
-  logDir: () => {
-    {
-      return logDir;
-    }
-  },
-  localDataDir: () => {
-    {
-      return localDataDir;
-    }
-  },
-  join: () => {
-    {
-      return join;
-    }
-  },
-  isAbsolute: () => {
-    {
-      return isAbsolute;
-    }
-  },
-  homeDir: () => {
-    {
-      return homeDir;
-    }
-  },
-  fontDir: () => {
-    {
-      return fontDir;
-    }
-  },
-  extname: () => {
-    {
-      return extname;
-    }
-  },
-  executableDir: () => {
-    {
-      return executableDir;
-    }
-  },
-  downloadDir: () => {
-    {
-      return downloadDir;
-    }
-  },
-  documentDir: () => {
-    {
-      return documentDir;
-    }
-  },
-  dirname: () => {
-    {
-      return dirname;
-    }
-  },
-  desktopDir: () => {
-    {
-      return desktopDir;
-    }
-  },
-  delimiter: () => {
-    {
-      return delimiter;
-    }
-  },
-  dataDir: () => {
-    {
-      return dataDir;
-    }
-  },
-  configDir: () => {
-    {
-      return configDir;
-    }
-  },
-  cacheDir: () => {
-    {
-      return cacheDir;
-    }
-  },
-  basename: () => {
-    {
-      return basename;
-    }
-  },
-  audioDir: () => {
-    {
-      return audioDir;
-    }
-  },
-  appLogDir: () => {
-    {
-      return appLogDir;
-    }
-  },
-  appLocalDataDir: () => {
-    {
-      return appLocalDataDir;
-    }
-  },
-  appDir: () => {
-    {
-      return appDir;
-    }
-  },
-  appDataDir: () => {
-    {
-      return appDataDir;
-    }
-  },
-  appConfigDir: () => {
-    {
-      return appConfigDir;
-    }
-  },
-  appCacheDir: () => {
-    {
-      return appCacheDir;
-    }
-  },
-  BaseDirectory: () => {
-    {
-      return BaseDirectory;
-    }
-  }
+  videoDir: () => videoDir,
+  templateDir: () => templateDir,
+  sep: () => sep,
+  runtimeDir: () => runtimeDir,
+  resourceDir: () => resourceDir,
+  resolveResource: () => resolveResource,
+  resolve: () => resolve,
+  publicDir: () => publicDir,
+  pictureDir: () => pictureDir,
+  normalize: () => normalize,
+  logDir: () => logDir,
+  localDataDir: () => localDataDir,
+  join: () => join,
+  isAbsolute: () => isAbsolute,
+  homeDir: () => homeDir,
+  fontDir: () => fontDir,
+  extname: () => extname,
+  executableDir: () => executableDir,
+  downloadDir: () => downloadDir,
+  documentDir: () => documentDir,
+  dirname: () => dirname,
+  desktopDir: () => desktopDir,
+  delimiter: () => delimiter,
+  dataDir: () => dataDir,
+  configDir: () => configDir,
+  cacheDir: () => cacheDir,
+  basename: () => basename,
+  audioDir: () => audioDir,
+  appLogDir: () => appLogDir,
+  appLocalDataDir: () => appLocalDataDir,
+  appDir: () => appDir,
+  appDataDir: () => appDataDir,
+  appConfigDir: () => appConfigDir,
+  appCacheDir: () => appCacheDir,
+  BaseDirectory: () => BaseDirectory
 });
 async function appDir() {
   return appConfigDir();
@@ -1805,16 +1413,8 @@ var delimiter = isWindows() ? ";" : ":";
 // ../../../../node_modules/@tauri-apps/api/process.js
 var exports_process = {};
 __export(exports_process, {
-  relaunch: () => {
-    {
-      return relaunch;
-    }
-  },
-  exit: () => {
-    {
-      return exit;
-    }
-  }
+  relaunch: () => relaunch,
+  exit: () => exit
 });
 async function exit(exitCode = 0) {
   return invokeTauriCommand({
@@ -1837,21 +1437,9 @@ async function relaunch() {
 // ../../../../node_modules/@tauri-apps/api/updater.js
 var exports_updater = {};
 __export(exports_updater, {
-  onUpdaterEvent: () => {
-    {
-      return onUpdaterEvent;
-    }
-  },
-  installUpdate: () => {
-    {
-      return installUpdate;
-    }
-  },
-  checkUpdate: () => {
-    {
-      return checkUpdate;
-    }
-  }
+  onUpdaterEvent: () => onUpdaterEvent,
+  installUpdate: () => installUpdate,
+  checkUpdate: () => checkUpdate
 });
 async function onUpdaterEvent(handler) {
   return listen2(TauriEvent.STATUS_UPDATE, (data) => {
@@ -1941,106 +1529,46 @@ async function checkUpdate() {
 // ../../../../node_modules/@tauri-apps/api/window.js
 var exports_window = {};
 __export(exports_window, {
-  primaryMonitor: () => {
-    {
-      return primaryMonitor;
-    }
-  },
-  getCurrent: () => {
-    {
-      return getCurrent;
-    }
-  },
-  getAll: () => {
-    {
-      return getAll;
-    }
-  },
-  currentMonitor: () => {
-    {
-      return currentMonitor;
-    }
-  },
-  availableMonitors: () => {
-    {
-      return availableMonitors;
-    }
-  },
-  appWindow: () => {
-    {
-      return appWindow;
-    }
-  },
-  WindowManager: () => {
-    {
-      return WindowManager;
-    }
-  },
-  WebviewWindowHandle: () => {
-    {
-      return WebviewWindowHandle;
-    }
-  },
-  WebviewWindow: () => {
-    {
-      return WebviewWindow;
-    }
-  },
-  UserAttentionType: () => {
-    {
-      return UserAttentionType;
-    }
-  },
-  PhysicalSize: () => {
-    {
-      return PhysicalSize;
-    }
-  },
-  PhysicalPosition: () => {
-    {
-      return PhysicalPosition;
-    }
-  },
-  LogicalSize: () => {
-    {
-      return LogicalSize;
-    }
-  },
-  LogicalPosition: () => {
-    {
-      return LogicalPosition;
-    }
-  },
-  CloseRequestedEvent: () => {
-    {
-      return CloseRequestedEvent;
-    }
-  }
+  primaryMonitor: () => primaryMonitor,
+  getCurrent: () => getCurrent,
+  getAll: () => getAll,
+  currentMonitor: () => currentMonitor,
+  availableMonitors: () => availableMonitors,
+  appWindow: () => appWindow,
+  WindowManager: () => WindowManager,
+  WebviewWindowHandle: () => WebviewWindowHandle,
+  WebviewWindow: () => WebviewWindow,
+  UserAttentionType: () => UserAttentionType,
+  PhysicalSize: () => PhysicalSize,
+  PhysicalPosition: () => PhysicalPosition,
+  LogicalSize: () => LogicalSize,
+  LogicalPosition: () => LogicalPosition,
+  CloseRequestedEvent: () => CloseRequestedEvent
 });
-var getCurrent = function() {
+function getCurrent() {
   return new WebviewWindow(window.__TAURI_METADATA__.__currentWindow.label, {
     skip: true
   });
-};
-var getAll = function() {
+}
+function getAll() {
   return window.__TAURI_METADATA__.__windows.map((w) => new WebviewWindow(w.label, {
     skip: true
   }));
-};
-var mapMonitor = function(m) {
+}
+function mapMonitor(m) {
   return m === null ? null : {
     name: m.name,
     scaleFactor: m.scaleFactor,
     position: mapPhysicalPosition(m.position),
     size: mapPhysicalSize(m.size)
   };
-};
-var mapPhysicalPosition = function(m) {
+}
+function mapPhysicalPosition(m) {
   return new PhysicalPosition(m.x, m.y);
-};
-var mapPhysicalSize = function(m) {
+}
+function mapPhysicalSize(m) {
   return new PhysicalSize(m.width, m.height);
-};
+}
 async function currentMonitor() {
   return invokeTauriCommand({
     __tauriModule: "Window",
@@ -3086,3 +2614,6 @@ export {
   openShell,
   desktop
 };
+
+//# debugId=186A0F79356F64EE64756E2164756E21
+//# sourceMappingURL=index.js.map