pake-cli 1.3.0 → 2.0.0-alpha6

package/src-tauri/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "app"
 version = "0.1.0"
-description = "Pake 打包工具"
+description = "🤱🏻 Turn any webpage into a desktop app with Rust."
 authors = ["Tw93"]
-license = ""
-repository = ""
+license = "MIT"
+repository = "https://github.com/tw93/Pake"
 default-run = "app"
 edition = "2021"
 rust-version = "1.63.0"
@@ -15,15 +15,11 @@ rust-version = "1.63.0"
 tauri-build = { version = "1.2.1", features = [] }
 
 [dependencies]
-serde_json = "1.0.91"
-serde = { version = "1.0.152", features = ["derive"] }
-tauri = { version = "1.2.4", features = [] }
-image = "0.24.5"
-home = "0.5.4"
-tauri-utils = "1.2.1"
-webbrowser = "0.8.7"
-wry = "0.23.4"
-dirs = "4.0"
+serde_json = "1.0.89"
+serde = { version = "1.0.150", features = ["derive"] }
+tauri = { version = "1.2.4", features = ["api-all", "system-tray"] }
+download_rs = { version = "0.2.0", features = ["sync_download"] }
+tauri-plugin-window-state = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "dev" }
 
 [features]
 # by default Tauri runs in production mode
@@ -32,5 +28,8 @@ default = ["custom-protocol"]
 # this feature is used used for production builds where `devPath` points to the filesystem
 # DO NOT remove this
 custom-protocol = ["tauri/custom-protocol"]
-# Enable DevTools for debugging.
-devtools = []
+
+# Pay attention to the code size during optimization in order to generate smaller binary files.
+# [profile.release]
+# opt-level = "s"
+# lto = true

package/src-tauri/pake.json

@@ -0,0 +1,28 @@
+{
+  "windows": [
+    {
+      "url": "https://weread.qq.com/",
+      "transparent": true,
+      "fullscreen": false,
+      "width": 1200,
+      "height": 780,
+      "resizable": true,
+      "url_type": "web"
+    }
+  ],
+  "user_agent": {
+    "macos": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15",
+    "linux": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
+    "windows": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36"
+  },
+  "menu": {
+    "macos": true,
+    "linux": false,
+    "windows": false
+  },
+  "system_tray": {
+    "macos": false,
+    "linux": true,
+    "windows": true
+  }
+}

package/src-tauri/src/app/config.rs

@@ -0,0 +1,63 @@
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct WindowConfig {
+    pub url: String,
+    pub transparent: bool,
+    pub fullscreen: bool,
+    pub width: f64,
+    pub height: f64,
+    pub resizable: bool,
+    pub url_type: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct PlatformSpecific<T> {
+    pub macos: T,
+    pub linux: T,
+    pub windows: T,
+}
+
+impl<T> PlatformSpecific<T> {
+    pub const fn get(&self) -> &T {
+        #[cfg(target_os = "macos")]
+        let platform = &self.macos;
+        #[cfg(target_os = "linux")]
+        let platform = &self.linux;
+        #[cfg(target_os = "windows")]
+        let platform = &self.windows;
+
+        platform
+    }
+}
+
+impl<T> PlatformSpecific<T>
+where
+    T: Copy,
+{
+    pub const fn copied(&self) -> T {
+        *self.get()
+    }
+}
+
+pub type UserAgent = PlatformSpecific<String>;
+pub type FunctionON = PlatformSpecific<bool>;
+
+#[derive(Debug, Deserialize)]
+pub struct PakeConfig {
+    pub windows: Vec<WindowConfig>,
+    pub user_agent: UserAgent,
+    pub menu: FunctionON,
+    pub system_tray: FunctionON,
+}
+
+impl PakeConfig {
+    pub fn show_menu(&self) -> bool {
+        self.menu.copied()
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    pub fn show_system_tray(&self) -> bool {
+        self.system_tray.copied()
+    }
+}

package/src-tauri/src/app/invoke.rs

@@ -0,0 +1,47 @@
+use crate::util::{check_file_or_append, get_download_message, show_toast};
+use download_rs::sync_download::Download;
+use tauri::{api, command, AppHandle, Manager, Window};
+
+#[derive(serde::Deserialize)]
+pub struct DownloadFileParams {
+    url: String,
+    filename: String,
+}
+
+#[command]
+pub fn drag_window(app: AppHandle) {
+    app.get_window("pake").unwrap().start_dragging().unwrap();
+}
+
+#[command]
+pub fn fullscreen(app: AppHandle) {
+    let win = app.get_window("pake").unwrap();
+    if win.is_fullscreen().unwrap() {
+        win.set_fullscreen(false).unwrap();
+    } else {
+        win.set_fullscreen(true).unwrap();
+    }
+}
+
+#[tauri::command]
+pub fn open_browser(app: AppHandle, url: String) {
+    api::shell::open(&app.shell_scope(), url, None).unwrap();
+}
+
+#[command]
+pub async fn download_file(app: AppHandle, params: DownloadFileParams) -> Result<(), String> {
+    let window: Window = app.get_window("pake").unwrap();
+    let output_path = api::path::download_dir().unwrap().join(params.filename);
+    let file_path = check_file_or_append(output_path.to_str().unwrap());
+    let download = Download::new(&params.url, Some(&file_path), None);
+    match download.download() {
+        Ok(_) => {
+            show_toast(&window, &get_download_message());
+            Ok(())
+        }
+        Err(e) => {
+            show_toast(&window, &e.to_string());
+            Err(e.to_string())
+        }
+    }
+}

package/src-tauri/src/app/menu.rs

@@ -0,0 +1,114 @@
+use tauri::MenuItem;
+
+use tauri::{CustomMenuItem, Menu, Submenu, WindowMenuEvent};
+
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+use tauri::{Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, WindowBuilder, WindowUrl};
+
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+use tauri_plugin_window_state::{AppHandleExt, StateFlags};
+
+pub fn get_menu() -> Menu {
+    let close = CustomMenuItem::new("close".to_string(), "Close Window").accelerator("CmdOrCtrl+W");
+    let goto_url_item = CustomMenuItem::new("goto_url".to_string(), "Go to URL...")
+        .accelerator("CmdOrCtrl+Shift+L");
+    let first_menu = Menu::new()
+        .add_native_item(MenuItem::Copy)
+        .add_native_item(MenuItem::Cut)
+        .add_native_item(MenuItem::Paste)
+        .add_native_item(MenuItem::Undo)
+        .add_native_item(MenuItem::Redo)
+        .add_native_item(MenuItem::SelectAll)
+        .add_native_item(MenuItem::Separator)
+        .add_item(goto_url_item)
+        .add_native_item(MenuItem::Separator)
+        .add_native_item(MenuItem::EnterFullScreen)
+        .add_native_item(MenuItem::Minimize)
+        .add_native_item(MenuItem::Hide)
+        .add_native_item(MenuItem::HideOthers)
+        .add_native_item(MenuItem::ShowAll)
+        .add_native_item(MenuItem::Separator)
+        .add_item(close)
+        .add_native_item(MenuItem::Quit);
+
+    let app_menu = Submenu::new("File", first_menu);
+    Menu::new().add_submenu(app_menu)
+}
+
+pub fn menu_event_handle(event: WindowMenuEvent) {
+    if event.menu_item_id() == "close" {
+        event.window().minimize().expect("can't minimize window");
+    }
+
+    if event.menu_item_id() == "goto_url" {
+        let js_code = "showUrlModal();";
+        event.window().eval(js_code).unwrap();
+    }
+}
+
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+pub fn get_system_tray(show_menu: bool) -> SystemTray {
+    let hide_app = CustomMenuItem::new("hide_app".to_string(), "Hide App");
+    let show_app = CustomMenuItem::new("show_app".to_string(), "Show App");
+    let quit = CustomMenuItem::new("quit".to_string(), "Quit");
+    let about = CustomMenuItem::new("about".to_string(), "About");
+    let tray_menu = SystemTrayMenu::new().add_item(hide_app).add_item(show_app);
+    if show_menu {
+        let hide_menu = CustomMenuItem::new("hide_menu".to_string(), "Hide Menu");
+        let show_menu = CustomMenuItem::new("show_menu".to_string(), "Show Menu");
+        let tray_menu = tray_menu
+            .add_item(hide_menu)
+            .add_item(show_menu)
+            .add_item(quit)
+            .add_item(about);
+        SystemTray::new().with_menu(tray_menu)
+    } else {
+        let tray_menu = tray_menu.add_item(quit).add_item(about);
+        SystemTray::new().with_menu(tray_menu)
+    }
+}
+
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+pub fn system_tray_handle(app: &tauri::AppHandle, event: SystemTrayEvent) {
+    if let SystemTrayEvent::MenuItemClick { tray_id: _, id, .. } = event {
+        match id.as_str() {
+            "hide_app" => {
+                app.get_window("pake").unwrap().hide().unwrap();
+            }
+            "show_app" => {
+                app.get_window("pake").unwrap().show().unwrap();
+            }
+            "hide_menu" => {
+                app.get_window("pake")
+                    .unwrap()
+                    .menu_handle()
+                    .hide()
+                    .unwrap();
+            }
+            "show_menu" => {
+                app.get_window("pake")
+                    .unwrap()
+                    .menu_handle()
+                    .show()
+                    .unwrap();
+            }
+            "quit" => {
+                let _res = app.save_window_state(StateFlags::all());
+                std::process::exit(0);
+            }
+            "about" => {
+                let _about_window = WindowBuilder::new(
+                    app,
+                    "about",
+                    WindowUrl::App(std::path::PathBuf::from("about_pake.html")),
+                )
+                .resizable(true)
+                .title("About")
+                .inner_size(600.0, 400.0)
+                .build()
+                .expect("can't open about!");
+            }
+            _ => {}
+        }
+    };
+}

package/src-tauri/src/app/mod.rs

@@ -0,0 +1,4 @@
+pub mod config;
+pub mod invoke;
+pub mod menu;
+pub mod window;

package/src-tauri/src/app/window.rs

@@ -0,0 +1,49 @@
+use crate::app::config::PakeConfig;
+use std::path::PathBuf;
+use tauri::{App, Window, WindowBuilder, WindowUrl};
+
+#[cfg(target_os = "macos")]
+use tauri::TitleBarStyle;
+
+pub fn get_window(app: &mut App, config: PakeConfig, _data_dir: PathBuf) -> Window {
+    let window_config = config
+        .windows
+        .first()
+        .expect("At least one window configuration is required");
+
+    let user_agent = config.user_agent.get();
+
+    let url = match window_config.url_type.as_str() {
+        "web" => WindowUrl::App(window_config.url.parse().unwrap()),
+        "local" => WindowUrl::App(PathBuf::from(&window_config.url)),
+        _ => panic!("url type can only be web or local"),
+    };
+
+    let mut window_builder = WindowBuilder::new(app, "pake", url)
+        .title("")
+        .user_agent(user_agent)
+        .visible(false) // Prevent initial shaking
+        .resizable(window_config.resizable)
+        .fullscreen(window_config.fullscreen)
+        .inner_size(window_config.width, window_config.height)
+        .initialization_script(include_str!("../inject/style.js"))
+        .initialization_script(include_str!("../inject/event.js"))
+        .initialization_script(include_str!("../inject/component.js"));
+
+    #[cfg(target_os = "macos")]
+    {
+        let title_bar_style = if window_config.transparent {
+            TitleBarStyle::Overlay
+        } else {
+            TitleBarStyle::Visible
+        };
+        window_builder = window_builder.title_bar_style(title_bar_style)
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    {
+        window_builder = window_builder.data_directory(_data_dir);
+    }
+
+    window_builder.build().unwrap()
+}

package/src-tauri/src/inject/component.js

@@ -0,0 +1,143 @@
+document.addEventListener('DOMContentLoaded', () => {
+  // Create a modal
+  const modalHtml = `
+  <div id="pakeUrlModal" class="pake-modal">
+    <div class="pake-modal-container">
+      <div class="pake-modal-content">
+        <label for="pakeUrlInput">Enter URL to navigate anywhere</label>
+        <input type="text" id="pakeUrlInput" />
+        <button id="pakeUrlSubmit">Submit</button>
+        <button id="pakeUrlClose">Close</button>
+      </div>
+    </div>
+  </div>
+  `;
+
+  const modalStyle = `
+  .pake-modal {
+    display: none;
+    position: fixed;
+    z-index: 1000;
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.4);
+  }
+
+  .pake-modal-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    height: 100%;
+  }
+
+  .pake-modal-content {
+    background-color: #fff;
+    padding: 20px;
+    border-radius: 10px;
+    width: 80%;
+    max-width: 400px;
+    font-size:14px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1), 0 1px 3px rgba(0, 0, 0, 0.08);
+  }
+
+  .pake-modal-content label {
+    display: block;
+    color: #11182B;
+    margin-bottom: 12px;
+    font-weight: bold;
+  }
+
+  .pake-modal-content input[type="text"] {
+    width: 90%;
+    padding: 8px;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    font-size: 14px;
+    margin-bottom: 12px;
+    outline: none;
+  }
+
+  .pake-modal-content button {
+    background: #11182B;
+    color: #FFF;
+    padding: 6px 14px;
+    border-radius: 4px;
+    cursor: pointer;
+    margin-right: 4px;
+    font-size:14px;
+    border: 1px solid #11182B;
+  }
+
+  #pakeUrlClose{
+    background: #fff;
+    color: #11182B;
+  }
+  `;
+
+  const modalDiv = document.createElement('div');
+  modalDiv.innerHTML = modalHtml;
+  document.body.appendChild(modalDiv);
+
+  const modalStyleElement = document.createElement('style');
+  modalStyleElement.innerText = modalStyle;
+  document.head.appendChild(modalStyleElement);
+
+  const urlModal = document.getElementById('pakeUrlModal');
+  const urlInput = document.getElementById('pakeUrlInput');
+  const urlSubmit = document.getElementById('pakeUrlSubmit');
+  const urlClose = document.getElementById('pakeUrlClose');
+
+  urlSubmit.onclick = function () {
+    const url = urlInput.value;
+    if (url) {
+      window.location.href = url;
+    }
+  };
+
+  urlClose.onclick = function () {
+    urlModal.style.display = 'none';
+  };
+
+  urlInput.addEventListener('keydown', function (event) {
+    if (event.key === 'Enter') {
+      const url = urlInput.value;
+      if (url) {
+        window.location.href = url;
+      }
+    }
+  });
+
+  document.addEventListener('keydown', function (event) {
+    if (event.key === 'Escape' && urlModal.style.display === 'block') {
+      urlModal.style.display = 'none';
+    }
+  });
+
+  window.showUrlModal = function () {
+    urlModal.style.display = 'block';
+    urlInput.focus();
+  };
+
+  // Toast
+  function pakeToast(msg) {
+    const m = document.createElement('div');
+    m.innerHTML = msg;
+    m.style.cssText =
+      'max-width:60%;min-width: 80px;padding:0 12px;height: 32px;color: rgb(255, 255, 255);line-height: 32px;text-align: center;border-radius: 8px;position: fixed; bottom:24px;right: 28px;z-index: 999999;background: rgba(0, 0, 0,.8);font-size: 13px;';
+    document.body.appendChild(m);
+    setTimeout(function () {
+      const d = 0.5;
+      m.style.transition =
+        'transform ' + d + 's ease-in, opacity ' + d + 's ease-in';
+      m.style.opacity = '0';
+      setTimeout(function () {
+        document.body.removeChild(m);
+      }, d * 1000);
+    }, 3000);
+  }
+
+  window.pakeToast = pakeToast;
+});

package/src-tauri/src/inject/event.js

@@ -0,0 +1,175 @@
+const shortcuts = {
+  ArrowUp: () => scrollTo(0, 0),
+  ArrowDown: () => scrollTo(0, document.body.scrollHeight),
+  ArrowLeft: () => window.history.back(),
+  ArrowRight: () => window.history.forward(),
+  '[': () => window.history.back(),
+  ']': () => window.history.forward(),
+  r: () => window.location.reload(),
+  '-': () => zoomOut(),
+  '=': () => zoomIn(),
+  '+': () => zoomIn(),
+  0: () => setZoom('100%'),
+};
+
+function setZoom(zoom) {
+  const html = document.getElementsByTagName('html')[0];
+  html.style.zoom = zoom;
+  window.localStorage.setItem('htmlZoom', zoom);
+}
+
+function zoomCommon(zoomChange) {
+  const currentZoom = window.localStorage.getItem('htmlZoom') || '100%';
+  setZoom(zoomChange(currentZoom));
+}
+
+function zoomIn() {
+  zoomCommon((currentZoom) => `${Math.min(parseInt(currentZoom) + 10, 200)}%`);
+}
+
+function zoomOut() {
+  zoomCommon((currentZoom) => `${Math.max(parseInt(currentZoom) - 10, 30)}%`);
+}
+
+function handleShortcut(event) {
+  if (shortcuts[event.key]) {
+    event.preventDefault();
+    shortcuts[event.key]();
+  }
+}
+
+//这里参考 ChatGPT 的代码
+const uid = () => window.crypto.getRandomValues(new Uint32Array(1))[0];
+function transformCallback(callback = () => {}, once = false) {
+  const identifier = uid();
+  const prop = `_${identifier}`;
+  Object.defineProperty(window, prop, {
+    value: (result) => {
+      if (once) {
+        Reflect.deleteProperty(window, prop);
+      }
+      return callback(result);
+    },
+    writable: false,
+    configurable: true,
+  });
+  return identifier;
+}
+async function invoke(cmd, args) {
+  return new Promise((resolve, reject) => {
+    if (!window.__TAURI_POST_MESSAGE__)
+      reject('__TAURI_POST_MESSAGE__ does not exist~');
+    const callback = transformCallback((e) => {
+      resolve(e);
+      Reflect.deleteProperty(window, `_${error}`);
+    }, true);
+    const error = transformCallback((e) => {
+      reject(e);
+      Reflect.deleteProperty(window, `_${callback}`);
+    }, true);
+    window.__TAURI_POST_MESSAGE__({
+      cmd,
+      callback,
+      error,
+      ...args,
+    });
+  });
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+  const topDom = document.createElement('div');
+  topDom.id = 'pack-top-dom';
+  document.body.appendChild(topDom);
+  const domEl = document.getElementById('pack-top-dom');
+
+  domEl.addEventListener('mousedown', (e) => {
+    e.preventDefault();
+    if (e.buttons === 1 && e.detail !== 2) {
+      invoke('drag_window');
+    }
+  });
+
+  domEl.addEventListener('touchstart', () => {
+    invoke('drag_window');
+  });
+
+  domEl.addEventListener('dblclick', () => {
+    invoke('fullscreen');
+  });
+
+  document.addEventListener('keyup', (event) => {
+    if (/windows|linux/i.test(navigator.userAgent) && event.ctrlKey) {
+      handleShortcut(event);
+    }
+    if (/macintosh|mac os x/i.test(navigator.userAgent) && event.metaKey) {
+      handleShortcut(event);
+    }
+  });
+
+  document.addEventListener('click', (e) => {
+    const anchorElement = e.target.closest('a');
+
+    if (anchorElement && anchorElement.href) {
+      const target = anchorElement.target;
+      anchorElement.target = '_self';
+      const hrefUrl = new URL(anchorElement.href);
+      const absoluteUrl = hrefUrl.href;
+
+      // Handling external link redirection.
+      if (window.location.host !== hrefUrl.host && (target === '_blank'|| target === '_new')) {
+        e.preventDefault();
+        invoke('open_browser', { url: absoluteUrl });
+        return;
+      }
+
+      // Process download links for Rust to handle.
+      if (/\.[a-zA-Z0-9]+$/i.test(removeUrlParameters(absoluteUrl))) {
+        e.preventDefault();
+        invoke('download_file', {
+          params: {
+            url: absoluteUrl,
+            filename: getFilenameFromUrl(absoluteUrl),
+          },
+        });
+      }
+    }
+  });
+
+  setDefaultZoom();
+
+  // Rewrite the window.open function.
+  const originalWindowOpen = window.open;
+  window.open = function (url, name, specs) {
+    // Apple login and google login
+    if (name === 'AppleAuthentication') {
+      //do nothing
+    } else if (specs.includes('height=') || specs.includes('width=')) {
+      location.href = url;
+    } else {
+      const baseUrl = window.location.origin + window.location.pathname;
+      const hrefUrl = new URL(url, baseUrl);
+      invoke('open_browser', { url: hrefUrl.href });
+    }
+    // Call the original window.open function to maintain its normal functionality.
+    return originalWindowOpen.call(window, url, name, specs);
+  };
+});
+
+function setDefaultZoom() {
+  const htmlZoom = window.localStorage.getItem('htmlZoom');
+  if (htmlZoom) {
+    setZoom(htmlZoom);
+  }
+}
+
+function getFilenameFromUrl(url) {
+  const urlPath = new URL(url).pathname;
+  const filename = urlPath.substring(urlPath.lastIndexOf('/') + 1);
+  return filename;
+}
+
+function removeUrlParameters(url) {
+  const parsedUrl = new URL(url);
+  parsedUrl.search = '';
+  return parsedUrl.toString();
+}