pulse-framework 0.1.53__py3-none-any.whl → 0.1.54__py3-none-any.whl

pulse/renderer.py

@@ -65,48 +65,43 @@ class RenderPropTask(NamedTuple):
 
 
 class RenderTree:
-	root: Node
+	element: Node
 	callbacks: Callbacks
-	operations: list[VDOMOperation]
-	_normalized: Node | None
+	rendered: bool
 
-	def __init__(self, root: Node) -> None:
-		self.root = root
+	def __init__(self, element: Node) -> None:
+		self.element = element
 		self.callbacks = {}
-		self.operations = []
-		self._normalized = None
+		self.rendered = False
 
 	def render(self) -> VDOM:
+		"""First render. Returns VDOM."""
 		renderer = Renderer()
-		vdom, normalized = renderer.render_tree(self.root)
-		self.root = normalized
+		vdom, self.element = renderer.render_tree(self.element)
 		self.callbacks = renderer.callbacks
-		self._normalized = normalized
+		self.rendered = True
 		return vdom
 
-	def diff(self, new_tree: Node) -> list[VDOMOperation]:
-		if self._normalized is None:
-			raise RuntimeError("RenderTree.render must be called before diff")
+	def rerender(self, new_element: Node | None = None) -> list[VDOMOperation]:
+		"""Re-render and return update operations.
 
+		If new_element is provided, reconciles against it (for testing).
+		Otherwise, reconciles against the current element (production use).
+		"""
+		if not self.rendered:
+			raise RuntimeError("render() must be called before rerender()")
+		target = new_element if new_element is not None else self.element
 		renderer = Renderer()
-		normalized = renderer.reconcile_tree(self._normalized, new_tree, path="")
-
+		self.element = renderer.reconcile_tree(self.element, target, path="")
 		self.callbacks = renderer.callbacks
-		self._normalized = normalized
-		self.root = normalized
-
 		return renderer.operations
 
 	def unmount(self) -> None:
-		if self._normalized is not None:
-			unmount_element(self._normalized)
-			self._normalized = None
+		if self.rendered:
+			unmount_element(self.element)
+			self.rendered = False
 		self.callbacks.clear()
 
-	@property
-	def normalized(self) -> Node | None:
-		return self._normalized
-
 
 class Renderer:
 	def __init__(self) -> None:
@@ -123,13 +118,11 @@ class Renderer:
 		if isinstance(node, Element):
 			return self.render_node(node, path)
 		if isinstance(node, Value):
-			json_value = coerce_json(node.value, path)
-			return json_value, json_value
+			return node.value, node.value
 		if isinstance(node, Expr):
 			return node.render(), node
-		if is_json_primitive(node):
-			return node, node
-		raise TypeError(f"Unsupported node type: {type(node).__name__}")
+		# Pass through any other value - serializer will validate
+		return node, node
 
 	def render_component(
 		self, component: PulseNode, path: str
@@ -148,7 +141,7 @@ class Renderer:
 		if (key_val := key_value(element)) is not None:
 			vdom_node["key"] = key_val
 
-		props = element.props or {}
+		props = element.props_dict()
 		props_result = self.diff_props({}, props, path, prev_eval=set())
 		if props_result.delta_set:
 			vdom_node["props"] = props_result.delta_set
@@ -188,9 +181,9 @@ class Renderer:
 		path: str = "",
 	) -> Node:
 		if isinstance(current, Value):
-			current = coerce_json(current.value, path)
+			current = current.value
 		if isinstance(previous, Value):
-			previous = coerce_json(previous.value, path)
+			previous = previous.value
 		if not same_node(previous, current):
 			unmount_element(previous)
 			new_vdom, normalized = self.render_tree(current, path)
@@ -239,8 +232,8 @@ class Renderer:
 		current: Element,
 		path: str,
 	) -> Element:
-		prev_props = previous.props or {}
-		new_props = current.props or {}
+		prev_props = previous.props_dict()
+		new_props = current.props_dict()
 		prev_eval = eval_keys_for_props(prev_props)
 		props_result = self.diff_props(prev_props, new_props, path, prev_eval)
 
@@ -389,14 +382,14 @@ class Renderer:
 				continue
 
 			if isinstance(value, Value):
-				json_value = coerce_json(value.value, prop_path)
+				unwrapped = value.value
 				if normalized is None:
 					normalized = current.copy()
-				normalized[key] = json_value
+				normalized[key] = unwrapped
 				if isinstance(old_value, (Element, PulseNode)):
 					unmount_element(old_value)
-				if key not in previous or not values_equal(json_value, old_value):
-					updated[key] = cast(VDOMPropValue, json_value)
+				if key not in previous or not values_equal(unwrapped, old_value):
+					updated[key] = cast(VDOMPropValue, unwrapped)
 				continue
 
 			if isinstance(value, Expr):
@@ -422,16 +415,11 @@ class Renderer:
 					updated[key] = CALLBACK_PLACEHOLDER
 				continue
 
-			json_value = coerce_json(value, prop_path)
 			if isinstance(old_value, (Element, PulseNode)):
 				unmount_element(old_value)
-			if normalized is not None:
-				normalized[key] = json_value
-			elif json_value is not value:
-				normalized = current.copy()
-				normalized[key] = json_value
-			if key not in previous or not values_equal(json_value, old_value):
-				updated[key] = cast(VDOMPropValue, json_value)
+			# No normalization needed - value passes through unchanged
+			if key not in previous or not values_equal(value, old_value):
+				updated[key] = cast(VDOMPropValue, value)
 
 		for key in removed_keys:
 			old_value = previous.get(key)
@@ -488,31 +476,6 @@ def registry_ref(expr: Expr) -> RegistryRef | None:
 	return None
 
 
-def is_json_primitive(value: Any) -> bool:
-	return value is None or isinstance(value, (str, int, float, bool))
-
-
-def coerce_json(value: Any, path: str) -> Any:
-	"""Convert Python value to JSON-compatible structure.
-
-	Performs runtime conversions:
-	- tuple → list
-	- validates dict keys are strings
-	"""
-	if is_json_primitive(value):
-		return value
-	if isinstance(value, (list, tuple)):
-		return [coerce_json(v, path) for v in value]
-	if isinstance(value, dict):
-		out: dict[str, Any] = {}
-		for k, v in value.items():
-			if not isinstance(k, str):
-				raise TypeError(f"Non-string prop key at {path}: {k!r}")
-			out[k] = coerce_json(v, path)
-		return out
-	raise TypeError(f"Unsupported JSON value at {path}: {type(value).__name__}")
-
-
 def prop_requires_eval(value: PropValue) -> bool:
 	if isinstance(value, Value):
 		return False
@@ -611,7 +574,7 @@ def unmount_element(element: Node) -> None:
 		return
 
 	if isinstance(element, Element):
-		props = element.props or {}
+		props = element.props_dict()
 		for value in props.values():
 			if isinstance(value, (Element, PulseNode)):
 				unmount_element(value)

pulse/serializer.py

@@ -86,8 +86,11 @@ def serialize(data: Any) -> Serialized:
 		if isinstance(value, dict):
 			result_dict: dict[str, PlainJSON] = {}
 			for key, entry in value.items():
-				key_str = str(key)  # pyright: ignore[reportUnknownArgumentType]
-				result_dict[key_str] = process(entry)
+				if not isinstance(key, str):
+					raise TypeError(
+						f"Dict keys must be strings, got {type(key).__name__}: {key!r}"  # pyright: ignore[reportUnknownArgumentType]
+					)
+				result_dict[key] = process(entry)
 			return result_dict
 
 		if isinstance(value, (list, tuple)):

pulse/transpiler/builtins.py

@@ -21,7 +21,6 @@ from pulse.transpiler.nodes import (
 	Literal,
 	Member,
 	New,
-	Object,
 	Spread,
 	Subscript,
 	Template,
@@ -173,25 +172,6 @@ def emit_dict(*args: Any, ctx: Transpiler) -> Expr:
 	raise TranspileError("dict() expects at most one argument")
 
 
-@transformer("obj")
-def obj(*args: Any, ctx: Transpiler, **kwargs: Any) -> Expr:
-	"""obj(key=value, ...) -> { key: value, ... }
-
-	Creates a plain JavaScript object literal.
-	Use this instead of dict() when you need a plain object (e.g., for React props).
-
-	Example:
-		style=obj(display="block", color="red")
-		-> style={{ display: "block", color: "red" }}
-	"""
-	if args:
-		raise TranspileError("obj() only accepts keyword arguments")
-	props: list[tuple[str, Expr]] = []
-	for key, value in kwargs.items():
-		props.append((key, ctx.emit_expr(value)))
-	return Object(props)
-
-
 @transformer("filter")
 def emit_filter(*args: Any, ctx: Transpiler) -> Expr:
 	"""filter(func, iterable) -> iterable.filter(func)"""

pulse/transpiler/errors.py

@@ -13,6 +13,7 @@ class TranspileError(Exception):
 	source: str | None
 	filename: str | None
 	func_name: str | None
+	source_start_line: int | None
 
 	def __init__(
 		self,
@@ -22,12 +23,14 @@ class TranspileError(Exception):
 		source: str | None = None,
 		filename: str | None = None,
 		func_name: str | None = None,
+		source_start_line: int | None = None,
 	) -> None:
 		self.message = message
 		self.node = node
 		self.source = source
 		self.filename = filename
 		self.func_name = func_name
+		self.source_start_line = source_start_line
 		super().__init__(self._format_message())
 
 	def _format_message(self) -> str:
@@ -38,25 +41,38 @@ class TranspileError(Exception):
 			loc_parts: list[str] = []
 			if self.func_name:
 				loc_parts.append(f"in {self.func_name}")
+			display_lineno = self.node.lineno
+			if self.source_start_line is not None:
+				display_lineno = self.source_start_line + self.node.lineno - 1
 			if self.filename:
-				loc_parts.append(f"at {self.filename}:{self.node.lineno}")
+				loc_parts.append(f"at {self.filename}:{display_lineno}")
 			else:
-				loc_parts.append(f"at line {self.node.lineno}")
-			if hasattr(self.node, "col_offset"):
-				loc_parts[-1] += f":{self.node.col_offset}"
-
-			if loc_parts:
-				parts.append(" ".join(loc_parts))
+				loc_parts.append(f"at line {display_lineno}")
 
-			# Show the source line if available
+			display_line = None
+			display_col = None
 			if self.source:
 				lines = self.source.splitlines()
 				if 0 < self.node.lineno <= len(lines):
 					source_line = lines[self.node.lineno - 1]
-					parts.append(f"\n  {source_line}")
-					# Add caret pointing to column
+					display_line = source_line.expandtabs(4)
 					if hasattr(self.node, "col_offset"):
-						parts.append("  " + " " * self.node.col_offset + "^")
+						prefix = source_line[: self.node.col_offset]
+						display_col = len(prefix.expandtabs(4))
+
+			if hasattr(self.node, "col_offset"):
+				col = display_col if display_col is not None else self.node.col_offset
+				loc_parts[-1] += f":{col}"
+
+			if loc_parts:
+				parts.append(" ".join(loc_parts))
+
+			# Show the source line if available
+			if display_line is not None:
+				parts.append(f"\n  {display_line}")
+				# Add caret pointing to column
+				if display_col is not None:
+					parts.append("  " + " " * display_col + "^")
 
 		return "\n".join(parts) if len(parts) > 1 else parts[0]
 
@@ -67,6 +83,7 @@ class TranspileError(Exception):
 		source: str | None = None,
 		filename: str | None = None,
 		func_name: str | None = None,
+		source_start_line: int | None = None,
 	) -> TranspileError:
 		"""Return a new TranspileError with additional context."""
 		return TranspileError(
@@ -75,4 +92,5 @@ class TranspileError(Exception):
 			source=source or self.source,
 			filename=filename or self.filename,
 			func_name=func_name or self.func_name,
+			source_start_line=source_start_line or self.source_start_line,
 		)

pulse/transpiler/function.py

@@ -142,6 +142,10 @@ def _transpile_function_body(
 	# Get and parse source
 	src = getsourcecode(fn)
 	src = textwrap.dedent(src)
+	try:
+		source_start_line = inspect.getsourcelines(fn)[1]
+	except (OSError, TypeError):
+		source_start_line = None
 	module = ast.parse(src)
 
 	# Find the function definition
@@ -169,6 +173,7 @@ def _transpile_function_body(
 				source=src,
 				filename=filename,
 				func_name=fn.__name__,
+				source_start_line=source_start_line,
 			) from None
 		raise
 
@@ -347,10 +352,10 @@ class JsxFunction(Expr, Generic[P, R]):
 
 	@override
 	def transpile_call(
-		self, args: list[ast.expr], kwargs: dict[str, ast.expr], ctx: Transpiler
+		self, args: list[ast.expr], keywords: list[ast.keyword], ctx: Transpiler
 	) -> Expr:
 		# delegate JSX element building to the generic Jsx wrapper
-		return Jsx(self).transpile_call(args, kwargs, ctx)
+		return Jsx(self).transpile_call(args, keywords, ctx)
 
 	@override
 	def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:  # pyright: ignore[reportIncompatibleMethodOverride]
@@ -367,18 +372,40 @@ def analyze_code_object(
 	    - effective_globals: dict mapping names to their values (includes closure vars)
 	    - all_names: set of all names referenced in the code (including nested functions)
 	"""
+	import dis
+
 	code = fn.__code__
 
 	# Collect all names from code object and nested functions in one pass
 	seen_codes: set[int] = set()
 	all_names: set[str] = set()
 
+	# Opcodes that load names from globals/locals (not attributes)
+	GLOBAL_LOAD_OPS = frozenset(
+		{
+			"LOAD_GLOBAL",
+			"LOAD_NAME",
+			"STORE_GLOBAL",
+			"STORE_NAME",
+			"DELETE_GLOBAL",
+			"DELETE_NAME",
+		}
+	)
+
 	def walk_code(c: pytypes.CodeType) -> None:
 		if id(c) in seen_codes:
 			return
 		seen_codes.add(id(c))
-		all_names.update(c.co_names)
+
+		# Only collect names that are actually loaded as globals, not attributes
+		# co_names contains both global names and attribute names, so we need
+		# to check the bytecode to distinguish them
+		for instr in dis.get_instructions(c):
+			if instr.opname in GLOBAL_LOAD_OPS and instr.argval is not None:
+				all_names.add(instr.argval)
+
 		all_names.update(c.co_freevars)  # Include closure variables
+
 		for const in c.co_consts:
 			if isinstance(const, pytypes.CodeType):
 				walk_code(const)

pulse/transpiler/js_module.py

@@ -63,10 +63,10 @@ class Class(Expr):
 	def transpile_call(
 		self,
 		args: list[ast.expr],
-		kwargs: dict[str, ast.expr],
+		keywords: list[ast.keyword],
 		ctx: Transpiler,
 	) -> Expr:
-		if kwargs:
+		if keywords:
 			raise TranspileError("Keyword arguments not supported in constructor call")
 		return New(self.ctor, [ctx.emit_expr(a) for a in args])
 
@@ -114,7 +114,7 @@ class JsModule(Expr):
 	def transpile_call(
 		self,
 		args: list[ast.expr],
-		kwargs: dict[str, ast.expr],
+		keywords: list[ast.keyword],
 		ctx: Transpiler,
 	) -> Expr:
 		label = self.py_name or self.name or "JsModule"
@@ -162,9 +162,9 @@ class JsModule(Expr):
 	def get_value(self, name: str) -> Member | Class | Identifier | Import:
 		"""Get a member of this module as an expression.
 
-		For global-identifier modules (name=None): returns Identifier(name) directly (e.g., Set -> Set)
-		For builtins: returns Member (e.g., Math.sin), or Identifier if name
-			matches the module name (e.g., Set -> Set, not Set.Set)
+		For global-identifier modules (name=None): returns Identifier directly (e.g., Set -> Set)
+			These are "virtual" Python modules exposing JS globals - no actual JS module exists.
+		For builtin namespaces (src=None): returns Member (e.g., Math.floor)
 		For external modules with "member" style: returns Member (e.g., React.useState)
 		For external modules with "named_import" style: returns a named Import
 
@@ -176,14 +176,11 @@ class JsModule(Expr):
 
 		expr: Member | Identifier | Import
 		if self.name is None:
-			# No module expression: members are just identifiers, not members of a module
+			# Virtual module exposing JS globals - members are just identifiers
 			expr = Identifier(js_name)
 		elif self.src is None:
-			# Builtins: use identifier when name matches module name (Set.Set -> Set)
-			if name == self.name:
-				expr = Identifier(js_name)
-			else:
-				expr = Member(Identifier(self.name), js_name)
+			# Builtin namespace (Math, console, etc.) - members accessed as properties
+			expr = Member(Identifier(self.name), js_name)
 		elif self.values == "named_import":
 			expr = Import(js_name, self.src)
 		else:

pulse/transpiler/modules/pulse/tags.py

@@ -16,7 +16,16 @@ import ast
 from dataclasses import dataclass
 from typing import Any, final, override
 
-from pulse.transpiler.nodes import Element, Expr, Literal, Node, Prop
+from pulse.components.for_ import emit_for
+from pulse.transpiler.nodes import (
+	Element,
+	Expr,
+	Literal,
+	Node,
+	Prop,
+	Spread,
+	spread_dict,
+)
 from pulse.transpiler.py_module import PyModule
 from pulse.transpiler.transpiler import Transpiler
 from pulse.transpiler.vdom import VDOMNode
@@ -44,30 +53,38 @@ class TagExpr(Expr):
 	def transpile_call(
 		self,
 		args: list[ast.expr],
-		kwargs: dict[str, ast.expr],
+		keywords: list[ast.keyword],
 		ctx: Transpiler,
 	) -> Expr:
-		"""Handle tag calls: positional args are children, kwargs are props."""
+		"""Handle tag calls: positional args are children, kwargs are props.
+
+		Spread (**expr) is supported for prop spreading.
+		"""
 		# Build children from positional args
 		children: list[Node] = []
 		for a in args:
 			children.append(ctx.emit_expr(a))
 
 		# Build props from kwargs
-		props: dict[str, Prop] = {}
+		props: list[tuple[str, Prop] | Spread] = []
 		key: str | Expr | None = None
-		for k, v in kwargs.items():
-			prop_value = ctx.emit_expr(v)
-			if k == "key":
-				# Accept any expression as key for transpilation
-				if isinstance(prop_value, Literal) and isinstance(
-					prop_value.value, str
-				):
-					key = prop_value.value  # Optimize string literals
-				else:
-					key = prop_value  # Keep as expression
+		for kw in keywords:
+			if kw.arg is None:
+				# **spread syntax
+				props.append(spread_dict(ctx.emit_expr(kw.value)))
 			else:
-				props[k] = prop_value
+				k = kw.arg
+				prop_value = ctx.emit_expr(kw.value)
+				if k == "key":
+					# Accept any expression as key for transpilation
+					if isinstance(prop_value, Literal) and isinstance(
+						prop_value.value, str
+					):
+						key = prop_value.value  # Optimize string literals
+					else:
+						key = prop_value  # Keep as expression
+				else:
+					props.append((k, prop_value))
 
 		return Element(
 			tag=self.tag,
@@ -229,3 +246,6 @@ class PulseTags(PyModule):
 
 	# React fragment
 	fragment = TagExpr("")
+
+	# For component - maps to array.map()
+	For = emit_for