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

pulse/transpiler/function.py

@@ -12,6 +12,7 @@ import textwrap
 import types as pytypes
 from collections.abc import Callable
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import (
 	Any,
 	Generic,
@@ -57,11 +58,13 @@ CONSTANT_REGISTRY: dict[int, "Constant"] = {}
 
 def clear_function_cache() -> None:
 	"""Clear function/constant/ref caches and reset the shared ID counters."""
+	from pulse.transpiler.assets import clear_asset_registry
 	from pulse.transpiler.imports import clear_import_registry
 
 	FUNCTION_CACHE.clear()
 	CONSTANT_REGISTRY.clear()
 	clear_import_registry()
+	clear_asset_registry()
 	reset_id_counter()
 
 
@@ -142,6 +145,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
@@ -152,7 +159,7 @@ def _transpile_function_body(
 		raise TranspileError("No function definition found in source")
 	fndef = fndefs[-1]
 
-	# Get filename for error messages
+	# Get filename for error messages and source file resolution
 	try:
 		filename = inspect.getfile(fn)
 	except (TypeError, OSError):
@@ -160,7 +167,8 @@ def _transpile_function_body(
 
 	# Transpile with source context for errors
 	try:
-		transpiler = Transpiler(fndef, deps, jsx=jsx)
+		source_file = Path(filename) if filename else None
+		transpiler = Transpiler(fndef, deps, jsx=jsx, source_file=source_file)
 		result = transpiler.transpile()
 	except TranspileError as e:
 		# Re-raise with source context if not already present
@@ -169,6 +177,7 @@ def _transpile_function_body(
 				source=src,
 				filename=filename,
 				func_name=fn.__name__,
+				source_start_line=source_start_line,
 			) from None
 		raise
 
@@ -347,10 +356,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 +376,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/imports.py

@@ -15,6 +15,8 @@ from typing import (
 from typing import Literal as Lit
 
 from pulse.cli.packages import pick_more_specific
+from pulse.transpiler.assets import LocalAsset, register_local_asset
+from pulse.transpiler.errors import TranspileError
 from pulse.transpiler.id import next_id
 from pulse.transpiler.nodes import Call, Expr, to_js_identifier
 from pulse.transpiler.vdom import VDOMNode
@@ -122,10 +124,10 @@ def resolve_local_path(path: str, caller: Path | None = None) -> Path | None:
 	return base_path
 
 
-# Registry key depends on kind:
-# - named: (name, src, "named")
-# - default/namespace/side_effect: ("", src, kind) - only one per src
-_ImportKey: TypeAlias = tuple[str, str, str]
+# Registry key depends on kind and lazy:
+# - named: (name, src, "named", lazy)
+# - default/namespace/side_effect: ("", src, kind, lazy) - only one per src
+_ImportKey: TypeAlias = tuple[str, str, str, bool]
 _IMPORT_REGISTRY: dict[_ImportKey, "Import"] = {}
 
 
@@ -171,17 +173,22 @@ class Import(Expr):
 		Import("", "./styles.css", kind="side_effect")  # Local CSS
 		utils = Import("utils", "./utils", kind="namespace")  # Local JS (resolves extension)
 		config = Import("config", "/absolute/path/config", kind="default")  # Absolute path
+
+		# Lazy import (generates factory for code-splitting)
+		Chart = Import("Chart", "./Chart", kind="default", lazy=True)
+		# Generates: const Chart_1 = () => import("./Chart")
 	"""
 
 	name: str
 	src: str
 	kind: ImportKind
 	is_type: bool
+	lazy: bool
 	before: tuple[str, ...]
 	id: str
 	version: str | None = None
-	source_path: Path | None = (
-		None  # Resolved local file path (for copying during codegen)
+	asset: LocalAsset | None = (
+		None  # Registered local asset (for copying during codegen)
 	)
 
 	def __init__(
@@ -191,12 +198,17 @@ class Import(Expr):
 		*,
 		kind: ImportKind | None = None,
 		is_type: bool = False,
+		lazy: bool = False,
 		version: str | None = None,
 		before: tuple[str, ...] | list[str] = (),
 		_caller_depth: int = 2,
 	) -> None:
+		# Validate: lazy imports cannot be type-only
+		if lazy and is_type:
+			raise TranspileError("Import cannot be both lazy and type-only")
+
 		# Auto-resolve local paths (relative or absolute) to actual files
-		source_path: Path | None = None
+		asset: LocalAsset | None = None
 		import_src = src
 
 		if is_local_path(src):
@@ -204,7 +216,8 @@ class Import(Expr):
 			caller = caller_file(depth=_caller_depth) if is_relative_path(src) else None
 			resolved = resolve_local_path(src, caller)
 			if resolved is not None:
-				source_path = resolved
+				# Register with unified asset registry
+				asset = register_local_asset(resolved)
 				import_src = str(resolved)
 
 		# Default kind to "named" if not specified
@@ -215,16 +228,16 @@ class Import(Expr):
 		self.src = import_src
 		self.kind = kind
 		self.version = version
-		self.source_path = source_path
+		self.lazy = lazy
+		self.asset = asset
 
 		before_tuple = tuple(before) if isinstance(before, list) else before
 
-		# Dedupe key: for named imports use (name, src, "named")
-		# For default/namespace/side_effect, only one per src: ("", src, kind)
+		# Dedupe key: includes lazy flag to keep lazy and eager imports separate
 		if kind == "named":
-			key: _ImportKey = (name, import_src, "named")
+			key: _ImportKey = (name, import_src, "named", lazy)
 		else:
-			key = ("", import_src, kind)
+			key = ("", import_src, kind, lazy)
 
 		if key in _IMPORT_REGISTRY:
 			existing = _IMPORT_REGISTRY[key]
@@ -260,8 +273,13 @@ class Import(Expr):
 
 	@property
 	def is_local(self) -> bool:
-		"""Check if this is a local file import (has resolved source_path)."""
-		return self.source_path is not None
+		"""Check if this is a local file import (has registered asset)."""
+		return self.asset is not None
+
+	@property
+	def is_lazy(self) -> bool:
+		"""Check if this is a lazy import."""
+		return self.lazy
 
 	# Convenience properties for kind checks
 	@property
@@ -276,18 +294,6 @@ class Import(Expr):
 	def is_side_effect(self) -> bool:
 		return self.kind == "side_effect"
 
-	def asset_filename(self) -> str:
-		"""Get the filename for this import when copied to assets folder.
-
-		Uses the import ID for uniqueness and preserves the original extension.
-		For JS-like files, uses the resolved extension.
-		"""
-		if self.source_path is None:
-			raise ValueError("Cannot get asset filename for non-local import")
-		stem = self.source_path.stem
-		suffix = self.source_path.suffix
-		return f"{stem}_{self.id}{suffix}"
-
 	# -------------------------------------------------------------------------
 	# Expr.emit: outputs the unique identifier
 	# -------------------------------------------------------------------------

pulse/transpiler/js_module.py

@@ -10,13 +10,15 @@ import ast
 import inspect
 import sys
 from dataclasses import dataclass, field
-from typing import Literal, override
+from typing import Any, Literal, override
 
+from pulse.code_analysis import is_stub_function
 from pulse.transpiler.errors import TranspileError
 from pulse.transpiler.imports import Import
 from pulse.transpiler.nodes import (
 	Expr,
 	Identifier,
+	Jsx,
 	Member,
 	New,
 )
@@ -63,10 +65,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])
 
@@ -91,6 +93,7 @@ class JsModule(Expr):
 			- "member": Access as property (e.g., React.useState)
 			- "named_import": Each attribute is a named import (e.g., import { useState } from "react")
 		constructors: Set of names that are constructors (emit with 'new')
+		components: Set of names that are components (wrapped with Jsx)
 	"""
 
 	name: str | None
@@ -99,6 +102,7 @@ class JsModule(Expr):
 	kind: Literal["default", "namespace"] = "namespace"
 	values: Literal["member", "named_import"] = "named_import"
 	constructors: frozenset[str] = field(default_factory=frozenset)
+	components: frozenset[str] = field(default_factory=frozenset)
 
 	@override
 	def emit(self, out: list[str]) -> None:
@@ -114,7 +118,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"
@@ -159,16 +163,17 @@ class JsModule(Expr):
 		import_kind = "default" if self.kind == "default" else "named"
 		return Import(self.name, self.src, kind=import_kind)
 
-	def get_value(self, name: str) -> Member | Class | Identifier | Import:
+	def get_value(self, name: str) -> Member | Class | Jsx | 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
 
 		If name is in constructors, returns a Class that emits `new ...(...)`.
+		If name is in components, returns a Jsx-wrapped expression.
 		"""
 		# Convention: trailing underscore escapes Python keywords (e.g. from_ -> from, is_ -> is).
 		# We keep the original `name` for constructor detection, but emit the JS name.
@@ -176,14 +181,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:
@@ -191,6 +193,8 @@ class JsModule(Expr):
 
 		if name in self.constructors:
 			return Class(expr, name=name)
+		if name in self.components:
+			return Jsx(expr)
 		return expr
 
 	@override
@@ -229,28 +233,74 @@ class JsModule(Expr):
 		Example (inside pulse/js/set.py):
 			JsModule.register(name=None)  # global identifier builtin (no module binding)
 		"""
+		from pulse.component import Component  # Import here to avoid cycles
+
 		# Get the calling module from the stack frame
 		frame = inspect.currentframe()
 		assert frame is not None and frame.f_back is not None
 		module_name = frame.f_back.f_globals["__name__"]
 		module = sys.modules[module_name]
 
-		# Collect locally defined names and clean up module namespace
+		# Collect locally defined names and clean up module namespace.
+		# Priority order for categorization:
+		#   1. Overrides: real functions (with body), Exprs, real @components → returned directly
+		#   2. Components: stub @component functions → wrapped as Jsx(Import(...))
+		#   3. Constructors: classes → emitted with 'new' keyword
+		#   4. Regular imports: stub functions → standard named imports
 		constructors: set[str] = set()
+		components: set[str] = set()
 		local_names: set[str] = set()
+		overrides: dict[str, Any] = {}
 
 		for attr_name in list(vars(module)):
-			if attr_name in _MODULE_DUNDERS:
+			if attr_name in _MODULE_DUNDERS or attr_name.startswith("_"):
 				continue
 
 			obj = getattr(module, attr_name)
+
+			# Component-wrapped function - check the raw function's module
+			if isinstance(obj, Component):
+				raw_fn = obj._raw_fn  # pyright: ignore[reportPrivateUsage]
+				fn_module = getattr(raw_fn, "__module__", None)
+				if fn_module != module_name:
+					delattr(module, attr_name)
+					continue
+				if is_stub_function(raw_fn):
+					# Stub component → becomes Jsx(Import(...))
+					components.add(attr_name)
+					local_names.add(attr_name)
+				else:
+					# Real component → preserve as override
+					overrides[attr_name] = obj
+				delattr(module, attr_name)
+				continue
+
 			is_local = not hasattr(obj, "__module__") or obj.__module__ == module_name
+			if not is_local:
+				delattr(module, attr_name)
+				continue
 
-			if is_local and not attr_name.startswith("_"):
+			# Existing Expr (e.g., manually created Jsx)
+			if isinstance(obj, Expr):
+				overrides[attr_name] = obj
+				delattr(module, attr_name)
+				continue
+
+			# Real function with body → preserve as override
+			if inspect.isfunction(obj) and not is_stub_function(obj):
+				overrides[attr_name] = obj
+				delattr(module, attr_name)
+				continue
+
+			# Class → constructor (existing behavior)
+			if inspect.isclass(obj):
+				constructors.add(attr_name)
 				local_names.add(attr_name)
-				if inspect.isclass(obj):
-					constructors.add(attr_name)
+				delattr(module, attr_name)
+				continue
 
+			# Stub function → regular import (existing behavior)
+			local_names.add(attr_name)
 			delattr(module, attr_name)
 
 		# Add annotated constants to local_names
@@ -271,11 +321,14 @@ class JsModule(Expr):
 			kind=kind,
 			values=values,
 			constructors=frozenset(constructors),
+			components=frozenset(components),
 		)
 		# Register the module object itself so `import pulse.js.math as Math` resolves via EXPR_REGISTRY.
 		Expr.register(module, js_module)
 
-		def __getattr__(name: str) -> Member | Class | Identifier | Import:
+		def __getattr__(name: str) -> Member | Class | Jsx | Identifier | Import | Any:
+			if name in overrides:
+				return overrides[name]
 			if name.startswith("_") or name not in local_names:
 				raise AttributeError(name)
 			return js_module.get_value(name)

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