pulse-framework 0.1.51__py3-none-any.whl → 0.1.52__py3-none-any.whl

pulse/codegen/templates/route.py

@@ -1,19 +1,34 @@
-"""Route code generation using the javascript_v2 import system."""
+"""Route code generation using transpiler."""
 
 from __future__ import annotations
 
-import os
 from collections.abc import Sequence
-from pathlib import Path
-
-from pulse.react_component import ReactComponent
-from pulse.transpiler.constants import JsConstant
-from pulse.transpiler.function import AnyJsFunction, JsFunction, registered_functions
-from pulse.transpiler.imports import Import, registered_imports
 
+from pulse.transpiler import (
+	Constant,
+	Import,
+	collect_function_graph,
+	emit,
+	get_registered_imports,
+	registered_functions,
+)
+from pulse.transpiler.function import AnyJsFunction
+
+
+def _generate_import_statement(
+	src: str,
+	imports: list[Import],
+	asset_filenames: dict[str, str] | None = None,
+	asset_prefix: str = "../assets/",
+) -> str:
+	"""Generate import statement(s) for a source module.
 
-def _generate_import_statement(src: str, imports: list[Import]) -> str:
-	"""Generate import statement(s) for a source module."""
+	Args:
+		src: The original source path (may be remapped for local imports)
+		imports: List of Import objects for this source
+		asset_filenames: Mapping of original source paths to asset filenames
+		asset_prefix: Relative path prefix from route file to assets folder
+	"""
 	default_imports: list[Import] = []
 	namespace_imports: list[Import] = []
 	named_imports: list[Import] = []
@@ -26,32 +41,37 @@ def _generate_import_statement(src: str, imports: list[Import]) -> str:
 		elif imp.is_namespace:
 			namespace_imports.append(imp)
 		elif imp.is_default:
-			if imp.is_type_only:
+			if imp.is_type:
 				type_imports.append(imp)
 			else:
 				default_imports.append(imp)
 		else:
-			if imp.is_type_only:
+			if imp.is_type:
 				type_imports.append(imp)
 			else:
 				named_imports.append(imp)
 
+	# Remap source path if this is a local import
+	import_src = src
+	if asset_filenames and src in asset_filenames:
+		import_src = asset_prefix + asset_filenames[src]
+
 	lines: list[str] = []
 
 	# Namespace import (only one allowed per source)
 	if namespace_imports:
 		imp = namespace_imports[0]
-		lines.append(f'import * as {imp.js_name} from "{src}";')
+		lines.append(f'import * as {imp.js_name} from "{import_src}";')
 
 	# Default import (only one allowed per source)
 	if default_imports:
 		imp = default_imports[0]
-		lines.append(f'import {imp.js_name} from "{src}";')
+		lines.append(f'import {imp.js_name} from "{import_src}";')
 
 	# Named imports
 	if named_imports:
 		members = [f"{imp.name} as {imp.js_name}" for imp in named_imports]
-		lines.append(f'import {{ {", ".join(members)} }} from "{src}";')
+		lines.append(f'import {{ {", ".join(members)} }} from "{import_src}";')
 
 	# Type imports
 	if type_imports:
@@ -61,7 +81,9 @@ def _generate_import_statement(src: str, imports: list[Import]) -> str:
 				type_members.append(f"default as {imp.js_name}")
 			else:
 				type_members.append(f"{imp.name} as {imp.js_name}")
-		lines.append(f'import type {{ {", ".join(type_members)} }} from "{src}";')
+		lines.append(
+			f'import type {{ {", ".join(type_members)} }} from "{import_src}";'
+		)
 
 	# Side-effect only import (only if no other imports)
 	if (
@@ -71,13 +93,23 @@ def _generate_import_statement(src: str, imports: list[Import]) -> str:
 		and not named_imports
 		and not type_imports
 	):
-		lines.append(f'import "{src}";')
+		lines.append(f'import "{import_src}";')
 
 	return "\n".join(lines)
 
 
-def _generate_imports_section(imports: Sequence[Import]) -> str:
-	"""Generate the full imports section with deduplication and topological ordering."""
+def _generate_imports_section(
+	imports: Sequence[Import],
+	asset_filenames: dict[str, str] | None = None,
+	asset_prefix: str = "../assets/",
+) -> str:
+	"""Generate the full imports section with deduplication and topological ordering.
+
+	Args:
+		imports: List of Import objects to generate
+		asset_filenames: Mapping of original source paths to asset filenames
+		asset_prefix: Relative path prefix from route file to assets folder
+	"""
 	if not imports:
 		return ""
 
@@ -131,51 +163,23 @@ def _generate_imports_section(imports: Sequence[Import]) -> str:
 
 	lines: list[str] = []
 	for src in ordered:
-		stmt = _generate_import_statement(src, grouped[src])
+		stmt = _generate_import_statement(
+			src, grouped[src], asset_filenames, asset_prefix
+		)
 		if stmt:
 			lines.append(stmt)
 
 	return "\n".join(lines)
 
 
-def _collect_function_graph(
-	functions: Sequence[AnyJsFunction],
-) -> tuple[list[JsConstant], list[AnyJsFunction]]:
-	"""Collect all constants and functions in dependency order (depth-first)."""
-	seen_funcs: set[str] = set()
-	seen_consts: set[str] = set()
-	all_funcs: list[AnyJsFunction] = []
-	all_consts: list[JsConstant] = []
-
-	def walk(fn: AnyJsFunction) -> None:
-		if fn.id in seen_funcs:
-			return
-		seen_funcs.add(fn.id)
-
-		for dep in fn.deps.values():
-			if isinstance(dep, JsFunction):
-				walk(dep)  # pyright: ignore[reportUnknownArgumentType]
-			elif isinstance(dep, JsConstant):
-				if dep.id not in seen_consts:
-					seen_consts.add(dep.id)
-					all_consts.append(dep)
-
-		all_funcs.append(fn)
-
-	for fn in functions:
-		walk(fn)
-
-	return all_consts, all_funcs
-
-
-def _generate_constants_section(constants: Sequence[JsConstant]) -> str:
+def _generate_constants_section(constants: Sequence[Constant]) -> str:
 	"""Generate the constants section."""
 	if not constants:
 		return ""
 
 	lines: list[str] = ["// Constants"]
 	for const in constants:
-		js_value = const.expr.emit()
+		js_value = emit(const.expr)
 		lines.append(f"const {const.js_name} = {js_value};")
 
 	return "\n".join(lines)
@@ -188,59 +192,38 @@ def _generate_functions_section(functions: Sequence[AnyJsFunction]) -> str:
 
 	lines: list[str] = ["// Functions"]
 	for fn in functions:
-		js_code = fn.transpile()
+		js_code = emit(fn.transpile())
 		lines.append(js_code)
 
 	return "\n".join(lines)
 
 
 def _generate_registry_section(
-	all_imports: Sequence[Import],
-	lazy_components: Sequence[tuple[ReactComponent[...], Import]] | None = None,
-	prop_components: Sequence[ReactComponent[...]] | None = None,
-	functions: Sequence[AnyJsFunction] | None = None,
+	imports: Sequence[Import],
+	constants: Sequence[Constant],
+	functions: Sequence[AnyJsFunction],
 ) -> str:
-	"""Generate the unified registry containing all imports for runtime lookup."""
-	lines: list[str] = []
+	"""Generate the unified registry from all registered entities.
 
-	# Unified Registry - contains all imports that need to be looked up at runtime
+	The registry contains all values that need to be looked up at runtime,
+	keyed by their unique ID.
+	"""
+	lines: list[str] = []
 	lines.append("// Unified Registry")
 	lines.append("const __registry = {")
 
-	# Add non-type, non-side-effect imports to the registry
-	seen_js_names: set[str] = set()
-	for imp in all_imports:
-		if imp.is_side_effect or imp.is_type_only:
-			continue
-		if imp.js_name in seen_js_names:
-			continue
-		seen_js_names.add(imp.js_name)
-		lines.append(f'  "{imp.js_name}": {imp.js_name},')
-
-	# Add components with prop access (e.g., AppShell.Header)
-	# These need separate registry entries because the lookup key includes the prop
-	for comp in prop_components or []:
-		if comp.prop:
-			# Key is "ImportName_123.PropName", value is ImportName_123.PropName
-			key = f"{comp.import_.js_name}.{comp.prop}"
-			lines.append(f'  "{key}": {key},')
-
-	# Add lazy components with RenderLazy wrapper
-	for comp, render_lazy_imp in lazy_components or []:
-		attr = "default" if comp.is_default else comp.name
-		prop_accessor = f".{comp.prop}" if comp.prop else ""
-		dynamic = f"({{ default: m.{attr}{prop_accessor} }})"
-		# Key includes prop if present (e.g., "AppShell_123.Header")
-		key = comp.import_.js_name
-		if comp.prop:
-			key = f"{key}.{comp.prop}"
-		lines.append(
-			f'  "{key}": {render_lazy_imp.js_name}(() => import("{comp.src}").then((m) => {dynamic})),'
-		)
+	# Add imports
+	for imp in imports:
+		if not imp.is_side_effect:
+			lines.append(f'  "{imp.id}": {imp.js_name},')
 
-	# Add transpiled functions to the registry
-	for fn in functions or []:
-		lines.append(f'  "{fn.js_name}": {fn.js_name},')
+	# Add constants
+	for const in constants:
+		lines.append(f'  "{const.id}": {const.js_name},')
+
+	# Add functions
+	for fn in functions:
+		lines.append(f'  "{fn.id}": {fn.js_name},')
 
 	lines.append("};")
 
@@ -249,68 +232,34 @@ def _generate_registry_section(
 
 def generate_route(
 	path: str,
-	components: Sequence[ReactComponent[...]] | None = None,
-	route_file_path: Path | None = None,
-	css_dir: Path | None = None,
+	asset_filenames: dict[str, str] | None = None,
+	asset_prefix: str = "../assets/",
 ) -> str:
-	"""Generate a route file with all imports and components.
+	"""Generate a route file with all registered imports, functions, and components.
 
 	Args:
 		path: The route path (e.g., "/users/:id")
-		components: React components used in the route
-		route_file_path: Path where the route file will be written (for computing relative imports)
-		css_dir: Path to the CSS output directory (for computing relative CSS imports)
+		asset_filenames: Mapping of original source paths to asset filenames
+		asset_prefix: Relative path prefix from route file to assets folder
 	"""
-	# Collect lazy component import IDs to exclude from registered_imports
-	lazy_import_ids: set[str] = set()
-	for comp in components or []:
-		if comp.lazy:
-			lazy_import_ids.add(comp.import_.id)
-
-	# Add core Pulse imports - store references to use their js_name later
-	pulse_view_import = Import.named("PulseView", "pulse-ui-client")
-
-	# Check if we need RenderLazy
-	render_lazy_import: Import | None = None
-	if any(c.lazy for c in (components or [])):
-		render_lazy_import = Import.named("RenderLazy", "pulse-ui-client")
-
-	# Process components: add non-lazy imports and collect metadata
-	prop_components: list[ReactComponent[...]] = []
-	lazy_components: list[tuple[ReactComponent[...], Import]] = []
-	for comp in components or []:
-		if comp.lazy:
-			if render_lazy_import is not None:
-				lazy_components.append((comp, render_lazy_import))
-		else:
-			# Force registration by accessing the import
-			_ = comp.import_
-			if comp.prop:
-				prop_components.append(comp)
-
-	# Collect function graph (constants + functions in dependency order)
-	constants, funcs = _collect_function_graph(registered_functions())
+	# Note: Lazy component support is not yet implemented.
+	# Components now register via the unified registry.
 
-	# Get all registered imports, excluding lazy ones
-	all_imports = [imp for imp in registered_imports() if imp.id not in lazy_import_ids]
+	# Add core Pulse imports
+	pulse_view_import = Import("PulseView", "pulse-ui-client")
 
-	# Update src for local CSS imports to use relative paths from the route file
-	if route_file_path is not None and css_dir is not None:
-		from pulse.transpiler.imports import CssImport
+	# Collect function graph (constants + functions in dependency order)
+	constants, funcs = collect_function_graph(registered_functions())
 
-		route_dir = route_file_path.parent
-		for imp in all_imports:
-			if isinstance(imp, CssImport) and imp.is_local:
-				generated_filename = imp.generated_filename
-				assert generated_filename is not None
-				css_file_path = css_dir / generated_filename
-				rel_path = Path(os.path.relpath(css_file_path, route_dir))
-				imp.src = rel_path.as_posix()
+	# Get all registered imports
+	all_imports = list(get_registered_imports())
 
 	# Generate output sections
 	output_parts: list[str] = []
 
-	imports_section = _generate_imports_section(all_imports)
+	imports_section = _generate_imports_section(
+		all_imports, asset_filenames, asset_prefix
+	)
 	if imports_section:
 		output_parts.append(imports_section)
 
@@ -324,9 +273,8 @@ def generate_route(
 		output_parts.append(_generate_functions_section(funcs))
 		output_parts.append("")
 
-	output_parts.append(
-		_generate_registry_section(all_imports, lazy_components, prop_components, funcs)
-	)
+	# Generate the unified registry including all imports, constants and functions
+	output_parts.append(_generate_registry_section(all_imports, constants, funcs))
 	output_parts.append("")
 
 	# Route component

pulse/component.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from inspect import Parameter, signature
+from typing import Any, Generic, ParamSpec, TypeVar, overload, override
+
+from pulse.hooks.init import rewrite_init_blocks
+from pulse.transpiler.nodes import (
+	Children,
+	Node,
+	Primitive,
+	PulseNode,
+	flatten_children,
+)
+from pulse.transpiler.nodes import Element as Element
+from pulse.transpiler.vdom import VDOMNode
+
+P = ParamSpec("P")
+_T = TypeVar("_T")
+
+
+class Component(Generic[P]):
+	fn: Callable[P, Any]
+	name: str
+	_takes_children: bool
+
+	def __init__(self, fn: Callable[P, Any], name: str | None = None) -> None:
+		self.fn = rewrite_init_blocks(fn)
+		self.name = name or _infer_component_name(fn)
+		self._takes_children = _takes_children(fn)
+
+	def __call__(self, *args: P.args, **kwargs: P.kwargs) -> PulseNode:
+		key = kwargs.get("key")
+		if key is not None and not isinstance(key, str):
+			raise ValueError("key must be a string or None")
+
+		if self._takes_children and args:
+			flattened = flatten_children(
+				args,  # pyright: ignore[reportArgumentType]
+				parent_name=f"<{self.name}>",
+				warn_stacklevel=4,
+			)
+			args = tuple(flattened)  # pyright: ignore[reportAssignmentType]
+
+		return PulseNode(fn=self.fn, args=args, kwargs=kwargs, key=key, name=self.name)
+
+	@override
+	def __repr__(self) -> str:
+		return f"Component(name={self.name!r}, fn={_callable_qualname(self.fn)!r})"
+
+	@override
+	def __str__(self) -> str:
+		return self.name
+
+
+@overload
+def component(fn: Callable[P, Any]) -> Component[P]: ...
+
+
+@overload
+def component(
+	fn: None = None, *, name: str | None = None
+) -> Callable[[Callable[P, Any]], Component[P]]: ...
+
+
+# The explicit return type is necessary for the type checker to be happy
+def component(
+	fn: Callable[P, Any] | None = None, *, name: str | None = None
+) -> Component[P] | Callable[[Callable[P, Any]], Component[P]]:
+	def decorator(fn: Callable[P, Any]) -> Component[P]:
+		return Component(fn, name)
+
+	if fn is not None:
+		return decorator(fn)
+	return decorator
+
+
+def _takes_children(fn: Callable[..., Any]) -> bool:
+	try:
+		sig = signature(fn)
+	except (ValueError, TypeError):
+		return False
+	for p in sig.parameters.values():
+		if p.kind == Parameter.VAR_POSITIONAL and p.name == "children":
+			return True
+	return False
+
+
+# ----------------------------------------------------------------------------
+# Formatting helpers
+# ----------------------------------------------------------------------------
+
+
+def _infer_component_name(fn: Callable[..., Any]) -> str:
+	name = getattr(fn, "__name__", None)
+	if name:
+		return name
+	return "Component"
+
+
+def _callable_qualname(fn: Callable[..., Any]) -> str:
+	mod = getattr(fn, "__module__", "<unknown>")
+	qname = getattr(fn, "__qualname__", getattr(fn, "__name__", "<callable>"))
+	return f"{mod}.{qname}"
+
+
+__all__ = [
+	"Node",
+	"Children",
+	"Component",
+	"Element",
+	"Primitive",
+	"VDOMNode",
+	"component",
+]

pulse/components/for_.py

@@ -2,7 +2,7 @@ from collections.abc import Callable, Iterable
 from inspect import Parameter, signature
 from typing import TypeVar, overload
 
-from pulse.vdom import Element
+from pulse.transpiler.nodes import Element
 
 T = TypeVar("T")
 

pulse/components/if_.py

@@ -2,7 +2,7 @@ from collections.abc import Iterable
 from typing import Any, TypeVar
 
 from pulse.reactive import Computed, Signal
-from pulse.vdom import Element
+from pulse.transpiler.nodes import Element
 
 T1 = TypeVar("T1", bound=Element | Iterable[Element])
 T2 = TypeVar("T2", bound=Element | Iterable[Element] | None)

pulse/components/react_router.py

@@ -1,8 +1,9 @@
 from typing import Literal, TypedDict, Unpack
 
-from pulse.html.props import HTMLAnchorProps
-from pulse.react_component import DEFAULT, react_component
-from pulse.vdom import Child
+from pulse.dom.props import HTMLAnchorProps
+from pulse.transpiler import Import
+from pulse.transpiler.nodes import Node
+from pulse.transpiler.react_component import react_component
 
 
 class LinkPath(TypedDict):
@@ -11,33 +12,26 @@ class LinkPath(TypedDict):
 	hash: str
 
 
-@react_component("Link", "react-router", version="^7")
+# @react_component(Import("Link", "react-router", version="^7"))
+@react_component(Import("Link", "react-router"))
 def Link(
-	*children: Child,
+	*children: Node,
 	key: str | None = None,
 	to: str,
-	# Default: render
-	discover: Literal["render", "none"] = DEFAULT,
-	# The React Router default is 'none' to match the behavior of regular links,
-	# but 'intent' is more desirable in general
+	discover: Literal["render", "none"] | None = None,
 	prefetch: Literal["none", "intent", "render", "viewport"] = "intent",
-	# Default: False
-	preventScrollReset: bool = DEFAULT,
-	# Default: 'route'
-	relative: Literal["route", "path"] = DEFAULT,
-	# Default: False
-	reloadDocument: bool = DEFAULT,
-	# Default: False
-	replace: bool = DEFAULT,
-	# Default: undefined
-	state: dict[str, object] = DEFAULT,
-	# Default: False
-	viewTransition: bool = DEFAULT,
+	preventScrollReset: bool | None = None,
+	relative: Literal["route", "path"] | None = None,
+	reloadDocument: bool | None = None,
+	replace: bool | None = None,
+	state: dict[str, object] | None = None,
+	viewTransition: bool | None = None,
 	**props: Unpack[HTMLAnchorProps],
 ): ...
 
 
-@react_component("Outlet", "react-router", version="^7")
+# @react_component(Import("Outlet", "react-router", version="^7"))
+@react_component(Import("Outlet", "react-router"))
 def Outlet(key: str | None = None): ...
 
 

pulse/{html → dom}/events.py

@@ -13,7 +13,7 @@ from typing import (
 	TypeVar,
 )
 
-from pulse.html.elements import (
+from pulse.dom.elements import (
 	HTMLDialogElement,
 	HTMLElement,
 	HTMLInputElement,

pulse/{html → dom}/props.py

@@ -2,8 +2,7 @@
 # NOT the same thing as the properties in `elements.py` (but very similar)
 from typing import Any, Literal, TypedDict
 
-from pulse.helpers import CSSProperties
-from pulse.html.elements import (
+from pulse.dom.elements import (
 	GenericHTMLElement,
 	HTMLAnchorElement,
 	HTMLAreaElement,
@@ -60,7 +59,7 @@ from pulse.html.elements import (
 	HTMLTrackElement,
 	HTMLUListElement,
 )
-from pulse.html.events import (
+from pulse.dom.events import (
 	DialogDOMEvents,
 	DOMEvents,
 	InputDOMEvents,
@@ -68,12 +67,13 @@ from pulse.html.events import (
 	TElement,
 	TextAreaDOMEvents,
 )
-from pulse.transpiler.nodes import JSExpr
+from pulse.helpers import CSSProperties
+from pulse.transpiler.nodes import Expr
 
 Booleanish = Literal[True, False, "true", "false"]
 CrossOrigin = Literal["anonymous", "use-credentials", ""] | None
-# ClassName can be a string or any JSExpr (e.g., JSMember from CssModule.classname)
-ClassName = str | JSExpr
+# ClassName can be a string or any Expr (e.g., Member from CssModule.classname)
+ClassName = str | Expr
 
 
 class BaseHTMLProps(TypedDict, total=False):

pulse/{html → dom}/tags.py

@@ -1,6 +1,6 @@
 from typing import Any, ParamSpec
 
-from pulse.vdom import Element, Node
+from pulse.transpiler.nodes import Element, Node
 
 P = ParamSpec("P")
 
@@ -17,12 +17,13 @@ def define_tag(name: str, default_props: dict[str, Any] | None = None):
 	    A function that creates UITreeNode instances
 	"""
 
-	def create_element(*children: Element, **props: Any) -> Node:
-		"""Create a UITreeNode for this tag."""
+	def create_element(*children: Node, **props: Any) -> Element:
+		"""Create a UI element for this tag."""
 		if default_props:
 			props = default_props | props
 		key = props.pop("key", None)
-		return Node(tag=name, key=key, props=props, children=children)
+		child_list = list(children) if children else None
+		return Element(tag=name, key=key, props=props or None, children=child_list)
 
 	return create_element
 
@@ -40,17 +41,16 @@ def define_self_closing_tag(name: str, default_props: dict[str, Any] | None = No
 	"""
 	default_props = default_props
 
-	def create_element(**props: Any) -> Node:
-		"""Create a self-closing UITreeNode for this tag."""
+	def create_element(**props: Any) -> Element:
+		"""Create a self-closing UI element for this tag."""
 		if default_props:
 			props = default_props | props
 		key = props.pop("key", None)
-		return Node(
+		return Element(
 			tag=name,
 			key=key,
-			props=props,
-			children=(),  # Self-closing tags never have children
-			allow_children=False,
+			props=props or None,
+			children=None,
 		)
 
 	return create_element
@@ -171,7 +171,7 @@ track = define_self_closing_tag("track")
 wbr = define_self_closing_tag("wbr")
 
 # React fragment
-fragment = define_tag("$$fragment")
+fragment = define_tag("")
 
 
 # SVG tags