PyWebWinUI3 1.1.0__tar.gz → 1.2.1__tar.gz

{pywebwinui3-1.1.0/PyWebWinUI3.egg-info → pywebwinui3-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyWebWinUI3
-Version: 1.1.0
+Version: 1.2.1
 Summary: Create modern WinUI3-style desktop UIs in Python using pywebview and a Svelte frontend.
 Home-page: https://github.com/Haruna5718/PyWebWinUI3
 Author: Haruna5718

{pywebwinui3-1.1.0 → pywebwinui3-1.2.1/PyWebWinUI3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyWebWinUI3
-Version: 1.1.0
+Version: 1.2.1
 Summary: Create modern WinUI3-style desktop UIs in Python using pywebview and a Svelte frontend.
 Home-page: https://github.com/Haruna5718/PyWebWinUI3
 Author: Haruna5718

{pywebwinui3-1.1.0 → pywebwinui3-1.2.1}/PyWebWinUI3.egg-info/SOURCES.txt

@@ -112,17 +112,17 @@ pywebwinui3/web/Pretendard/PretendardVariable.subset.91.woff2
 pywebwinui3/web/Pretendard/Variable-dynamic-subset.min.css
 pywebwinui3/web/_app/env.js
 pywebwinui3/web/_app/version.json
-pywebwinui3/web/_app/immutable/assets/2.DFa7Tulp.css
+pywebwinui3/web/_app/immutable/assets/2.B-R7-woU.css
 pywebwinui3/web/_app/immutable/chunks/6pQH9Hkv.js
 pywebwinui3/web/_app/immutable/chunks/B-XLOWlt.js
-pywebwinui3/web/_app/immutable/chunks/BrxDGwA4.js
+pywebwinui3/web/_app/immutable/chunks/CDNCM73h.js
 pywebwinui3/web/_app/immutable/chunks/CGGCsFu4.js
 pywebwinui3/web/_app/immutable/chunks/CW0wlPPy.js
 pywebwinui3/web/_app/immutable/chunks/CZPLFskb.js
 pywebwinui3/web/_app/immutable/chunks/CZuXpvpo.js
 pywebwinui3/web/_app/immutable/chunks/DF1x2LYX.js
-pywebwinui3/web/_app/immutable/entry/app.COvDX_WQ.js
-pywebwinui3/web/_app/immutable/entry/start.D-PUi8dH.js
+pywebwinui3/web/_app/immutable/entry/app.DZs-LPnH.js
+pywebwinui3/web/_app/immutable/entry/start.BIkwzMz6.js
 pywebwinui3/web/_app/immutable/nodes/0.C49PHrK2.js
-pywebwinui3/web/_app/immutable/nodes/1.Qo_2yB_V.js
-pywebwinui3/web/_app/immutable/nodes/2.DAAD9EkZ.js
+pywebwinui3/web/_app/immutable/nodes/1.CrcwixmX.js
+pywebwinui3/web/_app/immutable/nodes/2.BX-aQgy_.js

{pywebwinui3-1.1.0 → pywebwinui3-1.2.1}/pywebwinui3/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["core", "event", "util", "type"]
 
-__version__ = '1.1.0'
+__version__ = '1.2.1'

{pywebwinui3-1.1.0 → pywebwinui3-1.2.1}/pywebwinui3/core.py

@@ -3,9 +3,15 @@ from __future__ import annotations
 import importlib
 import json
 import logging
+import mimetypes
+import os
+import re
 import sys
 import threading
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
+from urllib.parse import unquote, urlparse, urlunparse
 
 import webview
 from hPyT import title_bar
@@ -23,6 +29,63 @@ DEFAULT_WINDOW_MIN_WIDTH = 100
 DEFAULT_WINDOW_MIN_HEIGHT = 100
 
 
+def _default_ui_origin_host(title: str) -> str:
+	slug = re.sub(r"[^a-z0-9]+", "-", str(title).casefold()).strip("-")
+	if not slug:
+		slug = "app"
+	slug = re.sub(r"-{2,}", "-", slug)[:48].strip("-")
+	if not slug:
+		slug = "app"
+	return f"{slug}.local"
+
+
+class _UiHttpServer(ThreadingHTTPServer):
+	daemon_threads = True
+	allow_reuse_address = True
+
+	def __init__(self, server_address, request_handler_class, main: "MainWindow"):
+		super().__init__(server_address, request_handler_class)
+		self.main = main
+
+
+class _UiRequestHandler(BaseHTTPRequestHandler):
+	server: _UiHttpServer
+
+	def do_GET(self):
+		try:
+			path = self.server.main._resolve_server_path(urlparse(self.path).path)
+			if path is None or not path.is_file():
+				self._send_error("Not found.", HTTPStatus.NOT_FOUND)
+				return
+
+			body = path.read_bytes()
+			content_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+			self.send_response(HTTPStatus.OK)
+			self._send_common_headers(content_type)
+			self.send_header("Content-Length", str(len(body)))
+			self.end_headers()
+			self.wfile.write(body)
+		except Exception:
+			core_logger.debug("Failed to serve UI asset", exc_info=True)
+			self._send_error("Failed to serve UI asset.", HTTPStatus.INTERNAL_SERVER_ERROR)
+
+	def log_message(self, format, *args):
+		return
+
+	def _send_error(self, message: str, status: HTTPStatus):
+		body = message.encode("utf-8")
+		self.send_response(status)
+		self._send_common_headers("text/plain; charset=utf-8")
+		self.send_header("Content-Length", str(len(body)))
+		self.end_headers()
+		self.wfile.write(body)
+
+	def _send_common_headers(self, content_type: str):
+		self.send_header("Content-Type", content_type)
+		self.send_header("Cache-Control", "no-store")
+		self.send_header("Permissions-Policy", "display-capture=*")
+
+
 class _JsApi:
 	def _init(self, main:MainWindow):
 		self.init = main._init_payload
@@ -58,6 +121,15 @@ class MainWindow:
 		self._minimum_height = DEFAULT_WINDOW_MIN_HEIGHT
 		self._sync_lock = threading.Lock()
 		self._pending_sync: dict[str, object] = {}
+		self._ui_server: _UiHttpServer | None = None
+		self._ui_server_thread: threading.Thread | None = None
+		self._ui_origin = ""
+		self._ui_bind_host = "127.0.0.1"
+		self._ui_origin_host = getattr(self, "ui_origin_host", _default_ui_origin_host(title))
+		self._resource_roots: list[tuple[str, Path]] = [
+			("root", self.rootPath),
+			("package", self.packagePath),
+		]
 
 		self.values = SyncDict(
 			{
@@ -72,10 +144,12 @@ class MainWindow:
 			}
 		)
 		self.values.sync = self.queue_sync_value
+		self._start_ui_server()
+		self._configure_webview2_origin_identity()
 
 		self._window = webview.create_window(
 			self._current_title(),
-			self._entry_path().as_uri(),
+			f"{self._ui_origin}/index.html",
 			js_api=self.api,
 			background_color="#202020",
 			text_select=True,
@@ -178,6 +252,80 @@ class MainWindow:
 			raise FileNotFoundError(f"Frontend entry not found: {entry}")
 		return entry
 
+	def _start_ui_server(self):
+		self._ui_server = _UiHttpServer((self._ui_bind_host, 0), _UiRequestHandler, self)
+		self._ui_origin = f"http://{self._ui_origin_host}:{self._ui_server.server_port}"
+		self._ui_server_thread = threading.Thread(target=self._ui_server.serve_forever, daemon=True)
+		self._ui_server_thread.start()
+
+	def _configure_webview2_origin_identity(self):
+		if self._ui_origin_host == self._ui_bind_host:
+			return
+
+		parsed = urlparse(self._ui_origin)
+		if not parsed.scheme or parsed.port is None:
+			return
+
+		required_args = [
+			f'--host-resolver-rules="MAP {self._ui_origin_host} {self._ui_bind_host}"',
+			f"--unsafely-treat-insecure-origin-as-secure={parsed.scheme}://{self._ui_origin_host}:{parsed.port}",
+		]
+		existing = os.environ.get("WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS", "").strip()
+		missing = [arg for arg in required_args if arg not in existing]
+		if missing:
+			os.environ["WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS"] = " ".join(
+				[value for value in [existing, *missing] if value]
+			).strip()
+
+	def _stop_ui_server(self):
+		if self._ui_server is None:
+			return
+		try:
+			self._ui_server.shutdown()
+			self._ui_server.server_close()
+		except Exception:
+			core_logger.debug("Failed to stop UI server", exc_info=True)
+		finally:
+			self._ui_server = None
+			self._ui_server_thread = None
+
+	def _resolve_path_under(self, base_path: Path, relative_path: str) -> Path | None:
+		candidate = (base_path / relative_path).resolve()
+		try:
+			candidate.relative_to(base_path)
+		except ValueError:
+			return None
+		return candidate
+
+	def _resolve_server_path(self, raw_path: str) -> Path | None:
+		path = unquote(raw_path or "/")
+		if path in {"", "/"}:
+			return self._entry_path()
+
+		for name, base_path in self._resource_roots:
+			if name == "package":
+				continue
+
+			prefix = f"/__{name}__/"
+			if path.startswith(prefix):
+				return self._resolve_path_under(base_path, path[len(prefix) :])
+
+		return self._resolve_path_under(self.packagePath, path.lstrip("/"))
+
+	def _resource_url(self, path: Path) -> str:
+		path = path.resolve()
+		for name, base_path in self._resource_roots:
+			try:
+				relative = path.relative_to(base_path)
+			except ValueError:
+				continue
+
+			if name == "package":
+				return f"{self._ui_origin}/{relative.as_posix()}"
+			return f"{self._ui_origin}/__{name}__/{relative.as_posix()}"
+
+		raise ValueError(f"Path is outside of registered resource roots: {path}")
+
 	def _before_show(self):
 		try:
 			hwnd = self._window.native.Handle.ToInt64()
@@ -186,6 +334,8 @@ class MainWindow:
 			core_logger.debug("Failed to hide title bar", exc_info=True)
 
 	def _on_closed(self):
+		self.accent.stop()
+		self._stop_ui_server()
 		self.events.closed.set()
 
 	def _dispatch_or_defer_sync(self, key: str, value):
@@ -286,11 +436,27 @@ class MainWindow:
 		if lowered.startswith(("http://", "https://", "file://", "data:", "about:")):
 			return raw_value
 
-		resolved = self.resolve_path(raw_value)
+		parsed = urlparse(raw_value)
+		path_value = parsed.path or raw_value
+		resolved = self.resolve_path(path_value)
 		if resolved is None or not resolved.exists() or not resolved.is_file():
 			return raw_value
 
-		return resolved.resolve().as_uri()
+		resource_url = self._resource_url(resolved)
+		if not parsed.scheme and (parsed.query or parsed.fragment):
+			resource_parts = urlparse(resource_url)
+			resource_url = urlunparse(
+				(
+					resource_parts.scheme,
+					resource_parts.netloc,
+					resource_parts.path,
+					resource_parts.params,
+					parsed.query,
+					parsed.fragment,
+				)
+			)
+
+		return resource_url
 
 	def start(
 		self,

{pywebwinui3-1.1.0 → pywebwinui3-1.2.1}/pywebwinui3/util.py

@@ -1,14 +1,57 @@
+import ctypes
+import logging
+import threading
+import winreg
 import xml.etree.ElementTree
 from functools import lru_cache
 from typing import Any, Callable
-import winreg
-import logging
 import re
+from ctypes import wintypes
 
 from .event import PathEvent, Event
 
 logger = logging.getLogger('pywebwinui3.util')
 
+ACCENT_REGISTRY_PATH = r"Software\Microsoft\Windows\CurrentVersion\Explorer\Accent"
+REG_NOTIFY_CHANGE_LAST_SET = 0x00000004
+WAIT_OBJECT_0 = 0x00000000
+WAIT_FAILED = 0xFFFFFFFF
+INFINITE = 0xFFFFFFFF
+
+_advapi32 = ctypes.WinDLL("Advapi32", use_last_error=True)
+_kernel32 = ctypes.WinDLL("Kernel32", use_last_error=True)
+
+_advapi32.RegNotifyChangeKeyValue.argtypes = [
+	wintypes.HKEY,
+	wintypes.BOOL,
+	wintypes.DWORD,
+	wintypes.HANDLE,
+	wintypes.BOOL,
+]
+_advapi32.RegNotifyChangeKeyValue.restype = wintypes.LONG
+
+_kernel32.CreateEventW.argtypes = [
+	wintypes.LPVOID,
+	wintypes.BOOL,
+	wintypes.BOOL,
+	wintypes.LPCWSTR,
+]
+_kernel32.CreateEventW.restype = wintypes.HANDLE
+
+_kernel32.SetEvent.argtypes = [wintypes.HANDLE]
+_kernel32.SetEvent.restype = wintypes.BOOL
+
+_kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
+_kernel32.CloseHandle.restype = wintypes.BOOL
+
+_kernel32.WaitForMultipleObjects.argtypes = [
+	wintypes.DWORD,
+	ctypes.POINTER(wintypes.HANDLE),
+	wintypes.BOOL,
+	wintypes.DWORD,
+]
+_kernel32.WaitForMultipleObjects.restype = wintypes.DWORD
+
 DEFAULT_ACCENT_PALETTE = [
 	"#99ebff",
 	"#00ccff",
@@ -162,16 +205,72 @@ class AccentColorWatcher:
 	def __init__(self, event:Event=None):
 		self.event = event or Event()
 		self.palette = self.getSystemAccentColor()
+		self._watch_thread: threading.Thread | None = None
+		self._stop_event_handle: int | None = None
 
 	@staticmethod
 	def getSystemAccentColor():
 		try:
-			with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\Accent") as key:
+			with winreg.OpenKey(winreg.HKEY_CURRENT_USER, ACCENT_REGISTRY_PATH) as key:
 				p, _ = winreg.QueryValueEx(key, "AccentPalette")
 		except OSError:
 			return DEFAULT_ACCENT_PALETTE.copy()
 		return [f"#{p[i]:02x}{p[i+1]:02x}{p[i+2]:02x}" for i in range(0,len(p),4)]
 
+	@staticmethod
+	def _create_event_handle():
+		handle = _kernel32.CreateEventW(None, False, False, None)
+		if not handle:
+			raise ctypes.WinError(ctypes.get_last_error())
+		return int(handle)
+
+	@staticmethod
+	def _close_handle(handle: int | None):
+		if handle:
+			_kernel32.CloseHandle(handle)
+
+	def _watch_loop(self, stop_event_handle: int):
+		change_event_handle = None
+		try:
+			with winreg.OpenKey(
+				winreg.HKEY_CURRENT_USER,
+				ACCENT_REGISTRY_PATH,
+				0,
+				winreg.KEY_READ | winreg.KEY_NOTIFY,
+			) as key:
+				change_event_handle = self._create_event_handle()
+				wait_handles = (wintypes.HANDLE * 2)(change_event_handle, stop_event_handle)
+				key_handle = wintypes.HKEY(int(key.handle))
+				while True:
+					result = _advapi32.RegNotifyChangeKeyValue(
+						key_handle,
+						False,
+						REG_NOTIFY_CHANGE_LAST_SET,
+						wintypes.HANDLE(change_event_handle),
+						True,
+					)
+					if result != 0:
+						logger.debug("Accent watcher registry notification failed: %s", result)
+						break
+
+					wait_result = _kernel32.WaitForMultipleObjects(2, wait_handles, False, INFINITE)
+					if wait_result == WAIT_OBJECT_0:
+						self.refresh()
+						continue
+					if wait_result == WAIT_OBJECT_0 + 1:
+						break
+
+					logger.debug("Accent watcher wait failed: %s", wait_result)
+					break
+		except Exception:
+			logger.debug("Accent watcher stopped unexpectedly", exc_info=True)
+		finally:
+			self._close_handle(change_event_handle)
+			self._close_handle(stop_event_handle)
+			if self._stop_event_handle == stop_event_handle:
+				self._stop_event_handle = None
+			self._watch_thread = None
+
 	def refresh(self):
 		if self.palette != (color := self.getSystemAccentColor()):
 			self.palette = color
@@ -179,4 +278,24 @@ class AccentColorWatcher:
 
 	def start(self):
 		self.refresh()
+		if self._watch_thread and self._watch_thread.is_alive():
+			return
+
+		try:
+			self._stop_event_handle = self._create_event_handle()
+		except Exception:
+			logger.debug("Failed to start accent watcher", exc_info=True)
+			return
+
+		self._watch_thread = threading.Thread(
+			target=self._watch_loop,
+			args=(self._stop_event_handle,),
+			daemon=True,
+			name="AccentColorWatcher",
+		)
+		self._watch_thread.start()
 		logger.debug("Accent watcher initialized")
+
+	def stop(self):
+		if self._stop_event_handle:
+			_kernel32.SetEvent(wintypes.HANDLE(self._stop_event_handle))