pulse-framework 0.1.46__py3-none-any.whl → 0.1.48__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/proxy.py

@@ -21,19 +21,32 @@ logger = logging.getLogger(__name__)
 class ReactProxy:
 	"""
 	Handles proxying HTTP requests and WebSocket connections to React Router server.
+
+	In single-server mode, the Python server proxies unmatched routes to the React
+	dev server. This proxy rewrites URLs in responses to use the external server
+	address instead of the internal React server address.
 	"""
 
 	react_server_address: str
+	server_address: str
 	_client: httpx.AsyncClient | None
 
-	def __init__(self, react_server_address: str):
+	def __init__(self, react_server_address: str, server_address: str):
 		"""
 		Args:
-		    react_server_address: React Router server full URL (required in single-server mode)
+		    react_server_address: Internal React Router server URL (e.g., http://localhost:5173)
+		    server_address: External server URL exposed to clients (e.g., http://localhost:8000)
 		"""
 		self.react_server_address = react_server_address
+		self.server_address = server_address
 		self._client = None
 
+	def _rewrite_url(self, url: str) -> str:
+		"""Rewrite internal React server URLs to external server address."""
+		if self.react_server_address in url:
+			return url.replace(self.react_server_address, self.server_address)
+		return url
+
 	@property
 	def client(self) -> httpx.AsyncClient:
 		"""Lazy initialization of HTTP client."""
@@ -190,12 +203,12 @@ class ReactProxy:
 			# Send request with streaming
 			r = await self.client.send(req, stream=True)
 
-			# Filter out headers that shouldn't be present in streaming responses
-			response_headers = {
-				k: v
-				for k, v in r.headers.items()
-				# if k.lower() not in ("content-length", "transfer-encoding")
-			}
+			# Rewrite headers that may contain internal React server URLs
+			response_headers: dict[str, str] = {}
+			for k, v in r.headers.items():
+				if k.lower() in ("location", "content-location"):
+					v = self._rewrite_url(v)
+				response_headers[k] = v
 
 			return StreamingResponse(
 				r.aiter_raw(),

pulse/react_component.py

@@ -13,6 +13,7 @@ from types import UnionType
 from typing import (
 	Annotated,
 	Any,
+	ClassVar,
 	Generic,
 	Literal,
 	ParamSpec,
@@ -24,9 +25,18 @@ from typing import (
 	override,
 )
 
-from pulse.codegen.imports import Imported, ImportStatement
 from pulse.helpers import Sentinel
 from pulse.reactive_extensions import unwrap
+from pulse.transpiler.errors import JSCompilationError
+from pulse.transpiler.imports import Import
+from pulse.transpiler.nodes import (
+	JSExpr,
+	JSMember,
+	JSSpread,
+	JSXElement,
+	JSXProp,
+	JSXSpreadProp,
+)
 from pulse.vdom import Child, Element, Node
 
 T = TypeVar("T")
@@ -295,25 +305,112 @@ def default_fn_signature_without_children(
 ) -> Element: ...
 
 
-class ReactComponent(Generic[P], Imported):
+# ----------------------------------------------------------------------------
+# JSX transpilation helpers
+# ----------------------------------------------------------------------------
+
+
+def _build_jsx_props(kwargs: dict[str, Any]) -> list[JSXProp | JSXSpreadProp]:
+	"""Build JSX props list from kwargs dict.
+
+	Kwargs maps:
+	- "propName" -> value for named props
+	- "__spread_N" -> JSSpread(expr) for spread props
+	"""
+	props: list[JSXProp | JSXSpreadProp] = []
+	for key, value in kwargs.items():
+		if isinstance(value, JSSpread):
+			props.append(JSXSpreadProp(value.expr))
+		else:
+			props.append(JSXProp(key, JSExpr.of(value)))
+	return props
+
+
+def _flatten_children(items: list[Any], out: list[JSExpr | JSXElement | str]) -> None:
+	"""Flatten arrays and handle spreads in children list."""
+	from pulse.transpiler.nodes import JSArray, JSString
+
+	for it in items:
+		# Convert raw values first
+		it = JSExpr.of(it) if not isinstance(it, JSExpr) else it
+		if isinstance(it, JSArray):
+			_flatten_children(list(it.elements), out)
+		elif isinstance(it, JSSpread):
+			out.append(it.expr)
+		elif isinstance(it, JSString):
+			out.append(it.value)
+		else:
+			out.append(it)
+
+
+class ReactComponentCallExpr(JSExpr):
+	"""JSX call expression for a ReactComponent.
+
+	Created when a ReactComponent is called with props. Supports subscripting
+	to add children, producing the final JSXElement.
+	"""
+
+	is_jsx: ClassVar[bool] = True
+	component: "ReactComponent[...]"
+	props: tuple[JSXProp | JSXSpreadProp, ...]
+	children: tuple[str | JSExpr | JSXElement, ...]
+
+	def __init__(
+		self,
+		component: "ReactComponent[...]",
+		props: tuple[JSXProp | JSXSpreadProp, ...],
+		children: tuple[str | JSExpr | JSXElement, ...],
+	) -> None:
+		self.component = component
+		self.props = props
+		self.children = children
+
+	@override
+	def emit(self) -> str:
+		return JSXElement(self.component, self.props, self.children).emit()
+
+	@override
+	def emit_subscript(self, indices: list[Any]) -> JSExpr:
+		"""Handle Component(props...)[children] -> JSXElement."""
+		extra_children: list[JSExpr | JSXElement | str] = []
+		_flatten_children(indices, extra_children)
+		all_children = list(self.children) + extra_children
+		return JSXElement(self.component, self.props, all_children)
+
+	@override
+	def emit_call(self, args: list[Any], kwargs: dict[str, Any]) -> JSExpr:
+		"""Calling an already-called component is an error."""
+		raise JSCompilationError(
+			f"Cannot call <{self.component.name}> - already called. "
+			+ "Use subscript for children: Component(props...)[children]"
+		)
+
+
+class ReactComponent(JSExpr, Generic[P]):
 	"""
 	A React component that can be used within the UI tree.
 	Returns a function that creates mount point UITreeNode instances.
 
 	Args:
-	    tag: Name of the component (or "default" for default export)
-	    import_path: Module path to import the component from
-	    alias: Optional alias for the component in the registry
+	    name: Name of the component (or "default" for default export)
+	    src: Module path to import the component from
 	    is_default: True if this is a default export, else named export
-	    import_name: If specified, import this name from import_path and access tag as a property of it
+	    prop: Optional property name to access the component from the imported object
+	    lazy: Whether to lazy load the component
+	    version: Optional npm semver constraint for this component's package
+	    prop_spec: Optional PropSpec for the component
+	    fn_signature: Function signature to parse for props
+	    extra_imports: Additional imports to include (CSS files, etc.)
 
 	Returns:
 	    A function that creates Node instances with mount point tags
 	"""
 
+	import_: Import
 	props_spec: PropSpec
 	fn_signature: Callable[P, Element]
 	lazy: bool
+	_prop: str | None  # Property access like AppShell.Header
 
 	def __init__(
 		self,
@@ -326,11 +423,14 @@ class ReactComponent(Generic[P], Imported):
 		version: str | None = None,
 		prop_spec: PropSpec | None = None,
 		fn_signature: Callable[P, Element] = default_signature,
-		extra_imports: tuple[ImportStatement, ...]
-		| list[ImportStatement]
-		| None = None,
+		extra_imports: tuple[Import, ...] | list[Import] | None = None,
 	):
-		super().__init__(name, src, is_default=is_default, prop=prop)
+		# Create the Import directly (prop is stored separately on ReactComponent)
+		if is_default:
+			self.import_ = Import.default(name, src)
+		else:
+			self.import_ = Import.named(name, src)
+		self._prop = prop
 
 		# Build props_spec from fn_signature if provided and props not provided
 		if prop_spec:
@@ -347,10 +447,62 @@ class ReactComponent(Generic[P], Imported):
 		self.lazy = lazy
 		# Optional npm semver constraint for this component's package
 		self.version: str | None = version
-		# Additional import statements to include in route where this component is used
-		self.extra_imports: list[ImportStatement] = list(extra_imports or [])
+		# Additional imports to include in route where this component is used
+		self.extra_imports: list[Import] = list(extra_imports or [])
 		COMPONENT_REGISTRY.get().add(self)
 
+	@override
+	def emit(self) -> str:
+		if self.prop:
+			return JSMember(self.import_, self.prop).emit()
+		return self.import_.emit()
+
+	@override
+	def emit_call(self, args: list[Any], kwargs: dict[str, Any]) -> JSExpr:
+		"""Handle Component(props...) -> ReactComponentCallExpr."""
+		props_list = _build_jsx_props(kwargs)
+		children_list: list[JSExpr | JSXElement | str] = []
+		_flatten_children(args, children_list)
+		return ReactComponentCallExpr(self, tuple(props_list), tuple(children_list))
+
+	@override
+	def emit_subscript(self, indices: list[Any]) -> JSExpr:
+		"""Direct subscript on ReactComponent is not allowed.
+
+		Use Component(props...)[children] instead of Component[children].
+		"""
+		raise JSCompilationError(
+			f"Cannot subscript ReactComponent '{self.name}' directly. "
+			+ "Use Component(props...)[children] or Component()[children] instead."
+		)
+
+	@property
+	def name(self) -> str:
+		return self.import_.name
+
+	@property
+	def src(self) -> str:
+		return self.import_.src
+
+	@property
+	def is_default(self) -> bool:
+		return self.import_.is_default
+
+	@property
+	def prop(self) -> str | None:
+		return self._prop
+
+	@property
+	def expr(self) -> str:
+		"""Expression for the component in the registry and VDOM tags.
+
+		Uses the import's js_name (with unique ID suffix) to match the
+		unified registry on the client side.
+		"""
+		if self.prop:
+			return f"{self.import_.js_name}.{self.prop}"
+		return self.import_.js_name
+
 	@override
 	def __repr__(self) -> str:
 		default_part = ", default=True" if self.is_default else ""
@@ -359,7 +511,8 @@ class ReactComponent(Generic[P], Imported):
 		props_part = f", props_spec={self.props_spec!r}"
 		return f"ReactComponent(name='{self.name}', src='{self.src}'{prop_part}{default_part}{lazy_part}{props_part})"
 
-	def __call__(self, *children: P.args, **props: P.kwargs) -> Node:
+	@override
+	def __call__(self, *children: P.args, **props: P.kwargs) -> Node:  # pyright: ignore[reportIncompatibleMethodOverride]
 		key = props.get("key")
 		if key is not None and not isinstance(key, str):
 			raise ValueError("key must be a string or None")
@@ -806,7 +959,7 @@ def react_component(
 	is_default: bool = False,
 	lazy: bool = False,
 	version: str | None = None,
-	extra_imports: list[ImportStatement] | None = None,
+	extra_imports: list[Import] | None = None,
 ) -> Callable[[Callable[P, None] | Callable[P, Element]], ReactComponent[P]]:
 	"""
 	Decorator to define a React component wrapper. The decorated function is

pulse/reactive_extensions.py

@@ -45,7 +45,7 @@ class SupportsKeysAndGetItem(Protocol[T1, T2_co]):
 
 # Return an iterable view that subscribes to per-key signals during iteration
 class ReactiveDictItems(Generic[T1, T2]):
-	__slots__: tuple[str, ...] = ("_host",)
+	__slots__ = ("_host",)  # pyright: ignore[reportUnannotatedClassAttribute]
 	_host: ReactiveDict[T1, T2]
 
 	def __init__(self, host: ReactiveDict[T1, T2]) -> None:
@@ -60,7 +60,7 @@ class ReactiveDictItems(Generic[T1, T2]):
 
 
 class ReactiveDictValues(Generic[T1, T2]):
-	__slots__: tuple[str, ...] = ("_host",)
+	__slots__ = ("_host",)  # pyright: ignore[reportUnannotatedClassAttribute]
 	_host: ReactiveDict[T1, T2]
 
 	def __init__(self, host: ReactiveDict[T1, T2]) -> None:
@@ -84,7 +84,7 @@ class ReactiveDict(dict[T1, T2]):
 	- Iteration, membership checks, and len are reactive to structural changes
 	"""
 
-	__slots__: tuple[str, ...] = ("_signals", "_structure")
+	__slots__ = ("_signals", "_structure")  # pyright: ignore[reportUnannotatedClassAttribute]
 
 	def __init__(self, initial: Mapping[T1, T2] | None = None) -> None:
 		super().__init__()
@@ -409,7 +409,7 @@ class ReactiveList(list[T1]):
 	- len() subscribes to structural changes
 	"""
 
-	__slots__: tuple[str, ...] = ("_signals", "_structure")
+	__slots__ = ("_signals", "_structure")  # pyright: ignore[reportUnannotatedClassAttribute]
 
 	def __init__(self, initial: Iterable[T1] | None = None) -> None:
 		super().__init__()
@@ -645,7 +645,7 @@ class ReactiveSet(set[T1]):
 	- Iteration subscribes to membership signals for all elements
 	"""
 
-	__slots__: tuple[str, ...] = ("_signals",)
+	__slots__ = ("_signals",)  # pyright: ignore[reportUnannotatedClassAttribute]
 
 	def __init__(self, initial: Iterable[T1] | None = None) -> None:
 		super().__init__()