pulse-framework 0.1.44__py3-none-any.whl → 0.1.47__py3-none-any.whl

pulse/js/window.py

@@ -0,0 +1,199 @@
+"""Browser window global Any.
+
+Usage:
+    from pulse.js import window
+    window.alert("Hello!")      # -> window.alert("Hello!")
+    window.innerWidth           # -> window.innerWidth
+"""
+
+from collections.abc import Callable as _Callable
+from typing import Any as _Any
+
+from pulse.js._types import Element as _Element
+from pulse.js._types import Selection as _Selection
+from pulse.transpiler.js_module import register_js_module as _register_js_module
+
+# Dimensions
+innerWidth: int
+innerHeight: int
+outerWidth: int
+outerHeight: int
+
+# Scroll position
+scrollX: float
+scrollY: float
+pageXOffset: float  # Alias for scrollX
+pageYOffset: float  # Alias for scrollY
+
+# Screen information
+devicePixelRatio: float
+
+# Location and history (typed as Any since they're complex interfaces)
+location: _Any
+history: _Any
+navigator: _Any
+document: _Any
+
+# Storage
+localStorage: _Any
+sessionStorage: _Any
+
+# Performance
+performance: _Any
+
+
+# Dialog methods
+def alert(message: str = "") -> None:
+	"""Display an alert dialog with the given message."""
+	...
+
+
+def confirm(message: str = "") -> bool:
+	"""Display a confirmation dialog. Returns True if user clicks OK."""
+	...
+
+
+def prompt(message: str = "", default: str = "") -> str | None:
+	"""Display a prompt dialog. Returns input or None if cancelled."""
+	...
+
+
+# Scroll methods
+def scrollTo(x: float | dict[str, float], y: float | None = None) -> None:
+	"""Scroll to the given position."""
+	...
+
+
+def scrollBy(x: float | dict[str, float], y: float | None = None) -> None:
+	"""Scroll by the given amount."""
+	...
+
+
+def scroll(x: float | dict[str, float], y: float | None = None) -> None:
+	"""Alias for scrollTo."""
+	...
+
+
+# Selection
+def getSelection() -> _Selection | None:
+	"""Return the current text selection."""
+	...
+
+
+def getComputedStyle(element: _Element, pseudoElt: str | None = None) -> _Any:
+	"""Return the computed style of an element."""
+	...
+
+
+# Focus
+def focus() -> None:
+	"""Give focus to the window."""
+	...
+
+
+def blur() -> None:
+	"""Remove focus from the window."""
+	...
+
+
+# Open/close
+def open(
+	url: str = "",
+	target: str = "_blank",
+	features: str = "",
+) -> _Any | None:
+	"""Open a new window. Returns the new window Any or None."""
+	...
+
+
+def close() -> None:
+	"""Close the window (only works for windows opened by script)."""
+	...
+
+
+# Timers (these return timer IDs)
+def setTimeout(handler: _Callable[..., None], timeout: int = 0, *args: _Any) -> int:
+	"""Schedule a function to run after a delay. Returns timer ID."""
+	...
+
+
+def clearTimeout(timeoutId: int) -> None:
+	"""Cancel a timeout scheduled with setTimeout."""
+	...
+
+
+def setInterval(handler: _Callable[..., None], timeout: int = 0, *args: _Any) -> int:
+	"""Schedule a function to run repeatedly. Returns timer ID."""
+	...
+
+
+def clearInterval(intervalId: int) -> None:
+	"""Cancel an interval scheduled with setInterval."""
+	...
+
+
+# Animation
+def requestAnimationFrame(callback: _Callable[[float], None]) -> int:
+	"""Request a callback before the next repaint. Returns request ID."""
+	...
+
+
+def cancelAnimationFrame(requestId: int) -> None:
+	"""Cancel an animation frame request."""
+	...
+
+
+# Event listeners
+def addEventListener(
+	type: str,
+	listener: _Callable[..., None],
+	options: bool | dict[str, bool] | None = None,
+) -> None:
+	"""Add an event listener to the window."""
+	...
+
+
+def removeEventListener(
+	type: str,
+	listener: _Callable[..., None],
+	options: bool | dict[str, bool] | None = None,
+) -> None:
+	"""Remove an event listener from the window."""
+	...
+
+
+def dispatchEvent(event: _Any) -> bool:
+	"""Dispatch an event to the window."""
+	...
+
+
+# Encoding
+def atob(encoded: str) -> str:
+	"""Decode a base64 encoded string."""
+	...
+
+
+def btoa(data: str) -> str:
+	"""Encode a string as base64."""
+	...
+
+
+# Misc
+def matchMedia(query: str) -> _Any:
+	"""Return a MediaQueryList for the given media query."""
+	...
+
+
+def print_() -> None:
+	"""Open the print dialog."""
+	...
+
+
+def postMessage(
+	message: _Any, targetOrigin: str, transfer: list[_Any] | None = None
+) -> None:
+	"""Post a message to another window."""
+	...
+
+
+_register_js_module(name="window")

pulse/messages.py

@@ -1,8 +1,7 @@
 from typing import Any, Literal, NotRequired, TypedDict
 
-from pulse.renderer import VDOMOperation
 from pulse.routing import RouteInfo
-from pulse.vdom import VDOM
+from pulse.vdom import VDOM, VDOMOperation
 
 
 # ====================
@@ -14,7 +13,7 @@ class ServerInitMessage(TypedDict):
 	vdom: VDOM
 	callbacks: list[str]
 	render_props: list[str]
-	css_refs: list[str]
+	jsexpr_paths: list[str]  # paths containing JS expressions
 
 
 class ServerUpdateMessage(TypedDict):
@@ -82,6 +81,15 @@ class ServerChannelResponseMessage(TypedDict):
 	error: NotRequired[Any]
 
 
+class ServerJsExecMessage(TypedDict):
+	"""Execute JavaScript code on the client."""
+
+	type: Literal["js_exec"]
+	path: str
+	id: str
+	code: str
+
+
 # ====================
 # Client messages
 # ====================
@@ -136,6 +144,15 @@ class ClientChannelResponseMessage(TypedDict):
 	error: NotRequired[Any]
 
 
+class ClientJsResultMessage(TypedDict):
+	"""Result of client-side JS execution."""
+
+	type: Literal["js_result"]
+	id: str
+	result: Any
+	error: str | None
+
+
 ServerChannelMessage = ServerChannelRequestMessage | ServerChannelResponseMessage
 ServerMessage = (
 	ServerInitMessage
@@ -144,6 +161,7 @@ ServerMessage = (
 	| ServerApiCallMessage
 	| ServerNavigateToMessage
 	| ServerChannelMessage
+	| ServerJsExecMessage
 )
 
 
@@ -153,6 +171,7 @@ ClientPulseMessage = (
 	| ClientNavigateMessage
 	| ClientUnmountMessage
 	| ClientApiResultMessage
+	| ClientJsResultMessage
 )
 ClientChannelMessage = ClientChannelRequestMessage | ClientChannelResponseMessage
 ClientMessage = ClientPulseMessage | ClientChannelMessage

pulse/queries/client.py

@@ -5,7 +5,7 @@ from typing import Any, TypeVar, overload
 from pulse.context import PulseContext
 from pulse.queries.common import ActionResult, QueryKey
 from pulse.queries.infinite_query import InfiniteQuery, Page
-from pulse.queries.query import Query
+from pulse.queries.query import KeyedQuery
 
 T = TypeVar("T")
 
@@ -62,11 +62,11 @@ class QueryClient:
 	# Query accessors
 	# ─────────────────────────────────────────────────────────────────────────
 
-	def get(self, key: QueryKey) -> Query[Any] | None:
+	def get(self, key: QueryKey):
 		"""Get an existing regular query by key, or None if not found."""
 		return self._get_store().get(key)
 
-	def get_infinite(self, key: QueryKey) -> InfiniteQuery[Any, Any] | None:
+	def get_infinite(self, key: QueryKey):
 		"""Get an existing infinite query by key, or None if not found."""
 		return self._get_store().get_infinite(key)
 
@@ -75,7 +75,7 @@ class QueryClient:
 		filter: QueryFilter | None = None,
 		*,
 		include_infinite: bool = True,
-	) -> list[Query[Any] | InfiniteQuery[Any, Any]]:
+	) -> list[KeyedQuery[Any] | InfiniteQuery[Any, Any]]:
 		"""
 		Get all queries matching the filter.
 
@@ -89,7 +89,7 @@ class QueryClient:
 		"""
 		store = self._get_store()
 		predicate = _normalize_filter(filter)
-		results: list[Query[Any] | InfiniteQuery[Any, Any]] = []
+		results: list[KeyedQuery[Any] | InfiniteQuery[Any, Any]] = []
 
 		for key, entry in store.items():
 			if predicate is not None and not predicate(key):
@@ -100,11 +100,11 @@ class QueryClient:
 
 		return results
 
-	def get_queries(self, filter: QueryFilter | None = None) -> list[Query[Any]]:
+	def get_queries(self, filter: QueryFilter | None = None) -> list[KeyedQuery[Any]]:
 		"""Get all regular queries matching the filter."""
 		store = self._get_store()
 		predicate = _normalize_filter(filter)
-		results: list[Query[Any]] = []
+		results: list[KeyedQuery[Any]] = []
 
 		for key, entry in store.items():
 			if isinstance(entry, InfiniteQuery):

pulse/queries/effect.py

@@ -2,6 +2,7 @@ import asyncio
 from collections.abc import Awaitable, Callable
 from typing import (
 	Any,
+	Literal,
 	Protocol,
 	override,
 )
@@ -11,15 +12,21 @@ from pulse.reactive import AsyncEffect, Computed, Signal
 
 class Fetcher(Protocol):
 	is_fetching: Signal[bool]
+	data: Signal[Any]
+	status: Signal[Literal["loading", "success", "error"]]
 
 
 class AsyncQueryEffect(AsyncEffect):
 	"""
 	Specialized AsyncEffect for queries that synchronously sets loading state
 	when rescheduled/run.
+
+	For unkeyed queries (deps=None), also resets data/status when re-running
+	due to dependency changes, to behave like keyed queries on key change.
 	"""
 
 	fetcher: Fetcher
+	_is_unkeyed: bool
 
 	def __init__(
 		self,
@@ -30,10 +37,19 @@ class AsyncQueryEffect(AsyncEffect):
 		deps: list[Signal[Any] | Computed[Any]] | None = None,
 	):
 		self.fetcher = fetcher
+		# Unkeyed queries have deps=None (auto-track), keyed have deps=[] (no auto-track)
+		self._is_unkeyed = deps is None
 		super().__init__(fn, name=name, lazy=lazy, deps=deps)
 
 	@override
 	def run(self) -> asyncio.Task[Any]:
 		# Immediately set loading state before running the effect
 		self.fetcher.is_fetching.write(True)
+
+		# For unkeyed queries on re-run (dependency changed), reset data/status
+		# to behave like keyed queries when key changes (new Query with data=None)
+		if self._is_unkeyed and self.runs > 0:
+			self.fetcher.data.write(None)
+			self.fetcher.status.write("loading")
+
 		return super().run()