pake-cli 3.7.5 → 3.7.7

package/dist/cli.js

@@ -22,7 +22,7 @@ import * as psl from 'psl';
 import { InvalidArgumentError, program as program$1, Option } from 'commander';
 
 var name = "pake-cli";
-var version = "3.7.5";
+var version = "3.7.7";
 var description = "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。";
 var engines = {
 	node: ">=18.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pake-cli",
-  "version": "3.7.5",
+  "version": "3.7.7",
   "description": "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。",
   "engines": {
     "node": ">=18.0.0"

package/src-tauri/Cargo.lock

@@ -2539,7 +2539,7 @@ dependencies = [
 
 [[package]]
 name = "pake"
-version = "3.7.5"
+version = "3.7.6"
 dependencies = [
  "serde",
  "serde_json",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pake"
-version = "3.7.5"
+version = "3.7.6"
 description = "🤱🏻 Turn any webpage into a desktop app with Rust."
 authors = ["Tw93"]
 license = "MIT"

package/src-tauri/capabilities/default.json

@@ -13,6 +13,10 @@
     "core:window:allow-toggle-maximize",
     "core:window:allow-is-fullscreen",
     "core:window:allow-set-fullscreen",
+    "core:window:allow-set-resizable",
+    "core:window:allow-maximize",
+    "core:window:allow-minimize",
+    "core:window:allow-close",
     "core:webview:allow-internal-toggle-devtools",
     "notification:allow-is-permission-granted",
     "notification:allow-notify",

package/src-tauri/gen/schemas/capabilities.json

@@ -1 +1 @@
-{"pake-capability":{"identifier":"pake-capability","description":"Capability for the pake app.","remote":{"urls":["https://*.*"]},"local":true,"webviews":["pake"],"permissions":["shell:allow-open","core:window:allow-theme","core:window:allow-start-dragging","core:window:allow-toggle-maximize","core:window:allow-is-fullscreen","core:window:allow-set-fullscreen","core:webview:allow-internal-toggle-devtools","notification:allow-is-permission-granted","notification:allow-notify","notification:allow-get-active","notification:allow-register-listener","notification:allow-register-action-types","notification:default","core:path:default"]}}
+{"pake-capability":{"identifier":"pake-capability","description":"Capability for the pake app.","remote":{"urls":["https://*.*"]},"local":true,"webviews":["pake"],"permissions":["shell:allow-open","core:window:allow-theme","core:window:allow-start-dragging","core:window:allow-toggle-maximize","core:window:allow-is-fullscreen","core:window:allow-set-fullscreen","core:window:allow-set-resizable","core:window:allow-maximize","core:window:allow-minimize","core:window:allow-close","core:webview:allow-internal-toggle-devtools","notification:allow-is-permission-granted","notification:allow-notify","notification:allow-get-active","notification:allow-register-listener","notification:allow-register-action-types","notification:default","core:path:default"]}}

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

@@ -19,3 +19,240 @@ document.addEventListener("DOMContentLoaded", () => {
 
   window.pakeToast = pakeToast;
 });
+
+// Polyfill for HTML5 Fullscreen API in Tauri webview
+// This bridges the HTML5 Fullscreen API to Tauri's native window fullscreen
+// Works for all video sites (YouTube, Vimeo, Bilibili, etc.)
+(function () {
+  function initFullscreenPolyfill() {
+    if (!window.__TAURI__ || !document.head) {
+      setTimeout(initFullscreenPolyfill, 100);
+      return;
+    }
+
+    const appWindow = window.__TAURI__.window.getCurrentWindow();
+    let fullscreenElement = null;
+    let actualFullscreenElement = null;
+    let originalStyles = null;
+    let originalParent = null;
+    let originalNextSibling = null;
+    let wasInBody = false;
+
+    // Inject fullscreen styles
+    const styleEl = document.createElement('style');
+    styleEl.id = 'pake-fullscreen-style';
+    styleEl.textContent = `
+      body.pake-fullscreen-active {
+        overflow: hidden !important;
+      }
+      .pake-fullscreen-element {
+        position: fixed !important;
+        top: 0 !important;
+        left: 0 !important;
+        width: 100vw !important;
+        height: 100vh !important;
+        max-width: 100vw !important;
+        max-height: 100vh !important;
+        margin: 0 !important;
+        padding: 0 !important;
+        z-index: 2147483647 !important;
+        background: #000 !important;
+        object-fit: contain !important;
+      }
+      .pake-fullscreen-element video {
+        width: 100% !important;
+        height: 100% !important;
+        object-fit: contain !important;
+      }
+    `;
+    document.head.appendChild(styleEl);
+
+    // Find the actual video element
+    function findMediaElement() {
+      const videos = document.querySelectorAll('video');
+      if (videos.length > 0) {
+        let largestVideo = videos[0];
+        let maxArea = 0;
+        videos.forEach(video => {
+          const rect = video.getBoundingClientRect();
+          const area = rect.width * rect.height;
+          if (area > maxArea || !video.paused) {
+            maxArea = area;
+            largestVideo = video;
+          }
+        });
+        return largestVideo;
+      }
+      return null;
+    }
+
+    // Enter fullscreen
+    function enterFullscreen(element) {
+      fullscreenElement = element;
+
+      // If html/body element, find the video instead
+      let targetElement = element;
+      if (element === document.documentElement || element === document.body) {
+        const mediaElement = findMediaElement();
+        if (mediaElement) {
+          targetElement = mediaElement;
+          actualFullscreenElement = mediaElement;
+        } else {
+          actualFullscreenElement = element;
+        }
+      } else {
+        actualFullscreenElement = element;
+      }
+
+      // Save original state
+      originalStyles = {
+        position: targetElement.style.position,
+        top: targetElement.style.top,
+        left: targetElement.style.left,
+        width: targetElement.style.width,
+        height: targetElement.style.height,
+        maxWidth: targetElement.style.maxWidth,
+        maxHeight: targetElement.style.maxHeight,
+        margin: targetElement.style.margin,
+        padding: targetElement.style.padding,
+        zIndex: targetElement.style.zIndex,
+        background: targetElement.style.background,
+        objectFit: targetElement.style.objectFit,
+      };
+
+      wasInBody = targetElement.parentNode === document.body;
+      if (!wasInBody) {
+        originalParent = targetElement.parentNode;
+        originalNextSibling = targetElement.nextSibling;
+      }
+
+      // Apply fullscreen
+      targetElement.classList.add('pake-fullscreen-element');
+      document.body.classList.add('pake-fullscreen-active');
+
+      if (!wasInBody) {
+        document.body.appendChild(targetElement);
+      }
+
+      // Fullscreen window
+      appWindow.setFullscreen(true).then(() => {
+        const event = new Event('fullscreenchange', { bubbles: true });
+        document.dispatchEvent(event);
+        element.dispatchEvent(event);
+
+        const webkitEvent = new Event('webkitfullscreenchange', { bubbles: true });
+        document.dispatchEvent(webkitEvent);
+        element.dispatchEvent(webkitEvent);
+      });
+
+      return Promise.resolve();
+    }
+
+    // Exit fullscreen
+    function exitFullscreen() {
+      if (!fullscreenElement) {
+        return Promise.resolve();
+      }
+
+      const exitingElement = fullscreenElement;
+      const targetElement = actualFullscreenElement;
+
+      // Restore styles and position
+      targetElement.classList.remove('pake-fullscreen-element');
+      document.body.classList.remove('pake-fullscreen-active');
+
+      if (originalStyles) {
+        Object.keys(originalStyles).forEach(key => {
+          targetElement.style[key] = originalStyles[key];
+        });
+      }
+
+      if (!wasInBody && originalParent) {
+        if (originalNextSibling && originalNextSibling.parentNode === originalParent) {
+          originalParent.insertBefore(targetElement, originalNextSibling);
+        } else if (originalParent.isConnected) {
+          originalParent.appendChild(targetElement);
+        }
+      }
+
+      // Reset state
+      fullscreenElement = null;
+      actualFullscreenElement = null;
+      originalStyles = null;
+      originalParent = null;
+      originalNextSibling = null;
+      wasInBody = false;
+
+      // Exit window fullscreen
+      return appWindow.setFullscreen(false).then(() => {
+        const event = new Event('fullscreenchange', { bubbles: true });
+        document.dispatchEvent(event);
+        exitingElement.dispatchEvent(event);
+
+        const webkitEvent = new Event('webkitfullscreenchange', { bubbles: true });
+        document.dispatchEvent(webkitEvent);
+        exitingElement.dispatchEvent(webkitEvent);
+      });
+    }
+
+    // Override fullscreenEnabled
+    Object.defineProperty(document, 'fullscreenEnabled', {
+      get: () => true,
+      configurable: true
+    });
+    Object.defineProperty(document, 'webkitFullscreenEnabled', {
+      get: () => true,
+      configurable: true
+    });
+
+    // Override fullscreenElement
+    Object.defineProperty(document, 'fullscreenElement', {
+      get: () => fullscreenElement,
+      configurable: true
+    });
+    Object.defineProperty(document, 'webkitFullscreenElement', {
+      get: () => fullscreenElement,
+      configurable: true
+    });
+    Object.defineProperty(document, 'webkitCurrentFullScreenElement', {
+      get: () => fullscreenElement,
+      configurable: true
+    });
+
+    // Override requestFullscreen
+    Element.prototype.requestFullscreen = function () {
+      return enterFullscreen(this);
+    };
+    Element.prototype.webkitRequestFullscreen = function () {
+      return enterFullscreen(this);
+    };
+    Element.prototype.webkitRequestFullScreen = function () {
+      return enterFullscreen(this);
+    };
+
+    // Override exitFullscreen
+    document.exitFullscreen = exitFullscreen;
+    document.webkitExitFullscreen = exitFullscreen;
+    document.webkitCancelFullScreen = exitFullscreen;
+
+    // Handle Escape key
+    document.addEventListener('keydown', (e) => {
+      if (e.key === 'Escape' && fullscreenElement) {
+        exitFullscreen();
+      }
+    }, true);
+
+    // Monitor window fullscreen changes
+    let lastFullscreenState = false;
+    setInterval(() => {
+      appWindow.isFullscreen().then(isFullscreen => {
+        if (lastFullscreenState && !isFullscreen && fullscreenElement) {
+          exitFullscreen();
+        }
+        lastFullscreenState = isFullscreen;
+      }).catch(() => {});
+    }, 500);
+  }
+
+  initFullscreenPolyfill();
+})();

package/src-tauri/src/lib.rs

@@ -105,6 +105,8 @@ pub fn run_app() {
                     {
                         if init_fullscreen {
                             window_clone.set_fullscreen(true).unwrap();
+                            // Ensure webview maintains focus for input after fullscreen
+                            let _ = window_clone.set_focus();
                         }
                     }
                 });
@@ -125,6 +127,14 @@ pub fn run_app() {
                                 tokio::time::sleep(Duration::from_millis(900)).await;
                             }
                         }
+                        #[cfg(all(not(target_os = "windows"), not(target_os = "macos")))]
+                        {
+                            if window.is_fullscreen().unwrap_or(false) {
+                                window.set_fullscreen(false).unwrap();
+                                // Restore focus after exiting fullscreen to fix input issues
+                                let _ = window.set_focus();
+                            }
+                        }
                         window.minimize().unwrap();
                         window.hide().unwrap();
                     });