svelte-effect-runtime 2.0.1 → 2.1.0

package/.dist/chunks/{transform-BtlxgJrg.js → transform-B4g76Ur4.js}

@@ -196,7 +196,7 @@ function classify_declaration_tag(node, candidates, matched, classified) {
 }
 function visit_element_attributes(node, candidates, matched, classified) {
 	for (const attr of node.attributes) {
-		if (attr.type === "Attribute" && attr.name && (attr.name.startsWith("on:") || /^on[a-z]/.test(attr.name))) {
+		if (attr.type === "Attribute" && attr.name && is_event_attribute_name(attr.name)) {
 			visit_attribute_value(attr.value, "event", candidates, matched, classified);
 			continue;
 		}
@@ -206,6 +206,9 @@ function visit_element_attributes(node, candidates, matched, classified) {
 		}
 	}
 }
+function is_event_attribute_name(name) {
+	return name.startsWith("on:") || /^on[a-z]/.test(name);
+}
 function visit_attribute_value(value, kind, candidates, matched, classified) {
 	if (value === true) return;
 	if (Array.isArray(value)) {
@@ -216,19 +219,219 @@ function visit_attribute_value(value, kind, candidates, matched, classified) {
 }
 function classify_expression(expression, kind, candidates, matched, classified) {
 	if (!expression) return;
-	const candidate = find_candidate(expression, candidates);
-	if (!candidate || matched.has(candidate.placeholder)) return;
-	matched.add(candidate.placeholder);
-	classified.push({
-		candidate,
-		kind
-	});
+	const found_candidates = find_candidates(expression, candidates);
+	for (const candidate of found_candidates) {
+		if (matched.has(candidate.placeholder)) continue;
+		matched.add(candidate.placeholder);
+		classified.push({
+			candidate,
+			kind
+		});
+	}
 }
-function find_candidate(expression, candidates) {
-	if (expression.type === "Identifier" && expression.name) return candidates.get(expression.name);
-	if (expression.type === "CallExpression" && expression.callee?.type === "Identifier" && expression.callee.name) return candidates.get(expression.callee.name);
+function find_candidates(expression, candidates) {
+	const found = [];
+	visit_expression_value(expression, candidates, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), found);
+	return found;
+}
+function visit_expression_value(value, candidates, seen_nodes, seen_placeholders, found) {
+	if (Array.isArray(value)) {
+		for (const item of value) visit_expression_value(item, candidates, seen_nodes, seen_placeholders, found);
+		return;
+	}
+	if (!is_record(value) || seen_nodes.has(value)) return;
+	seen_nodes.add(value);
+	if (value.type === "Identifier" && typeof value.name === "string") {
+		const candidate = candidates.get(value.name);
+		if (candidate && !seen_placeholders.has(candidate.placeholder)) {
+			seen_placeholders.add(candidate.placeholder);
+			found.push(candidate);
+		}
+	}
+	for (const child of Object.values(value)) visit_expression_value(child, candidates, seen_nodes, seen_placeholders, found);
+}
+function is_record(value) {
+	return typeof value === "object" && value !== null;
 }
 //#endregion
+//#region src/error.ts
+/**
+* Formats a runtime-owned error message with a stable screaming-case code.
+*
+* @example
+* ```ts
+* throw new Error(make_error_message("DISPATCHER_DISPOSED", "Dispatcher has been disposed"));
+* ```
+*
+* @since 2.0.0
+* @param code - Stable screaming-case identifier for the error category.
+* @param message - Human-readable error message without the leading code.
+* @returns The complete error message prefixed with the stable code.
+*/
+function make_error_message(code, message) {
+	return `[${code}]: ${message}`;
+}
+/**
+* Base error class for all preprocessor errors emitted during script and
+* markup transformation. Carries the source filename so error messages can
+* reference the affected file.
+*
+* @since 2.0.0
+*/
+var PreprocessError = class extends Error {
+	/**
+	* The source filename that triggered this error.
+	*
+	* @since 2.0.0
+	*/
+	filename;
+	constructor(message, filename) {
+		super(message);
+		this.name = "PreprocessError";
+		this.filename = filename;
+	}
+};
+/**
+* Thrown when a statement mixes JavaScript `await` with Effect `yield*` work
+* that must be lowered into an `Effect.gen` program.
+*
+* @since 2.0.0
+*/
+var AwaitInEffectWorkError = class extends PreprocessError {
+	/**
+	* The full text of the problematic statement containing mixed async work.
+	*
+	* @since 2.0.0
+	*/
+	statement_text;
+	constructor(filename, statement_text) {
+		super([
+			make_error_message("AWAIT_IN_EFFECT_WORK", `${filename}: await cannot be mixed with yield* in Effect work.`),
+			`Top-level await is supported as ordinary Svelte async rendering, but statements lowered into Effect.gen must use yield* for async Effect work.`,
+			"",
+			`Problematic statement:`,
+			statement_text
+		].join("\n"), filename);
+		this.name = "AwaitInEffectWorkError";
+		this.statement_text = statement_text;
+	}
+};
+/**
+* Thrown when async Effect work appears inside a Svelte rune position that
+* must stay synchronous.
+*
+* @since 2.0.0
+*/
+var AsyncEffectInSyncRuneError = class extends PreprocessError {
+	/**
+	* The name of the rune that contained async Effect work.
+	*
+	* @since 2.0.0
+	*/
+	rune_name;
+	/**
+	* The full text of the expression that triggered the error.
+	*
+	* @since 2.0.0
+	*/
+	expression_text;
+	constructor(rune_name, expression_text, filename) {
+		super([
+			make_error_message("ASYNC_EFFECT_IN_SYNC_RUNE", `${filename}: yield* cannot be used inside ${rune_name}().`),
+			`${rune_name}() must stay synchronous. Do not put async Effect work inside this rune.`,
+			"",
+			`Problematic expression:`,
+			expression_text
+		].join("\n"), filename);
+		this.name = "AsyncEffectInSyncRuneError";
+		this.rune_name = rune_name;
+		this.expression_text = expression_text;
+	}
+};
+/**
+* Thrown when async Effect work appears inside a non-generator callback nested
+* in a markup event handler.
+*
+* @example
+* ```ts
+* throw new AsyncEffectInEventCallbackError(
+*   "Component.svelte",
+*   "Effect.try(() => yield* save())",
+* );
+* ```
+*
+* @since 2.0.0
+*/
+var AsyncEffectInEventCallbackError = class extends PreprocessError {
+	/**
+	* The full text of the problematic event handler body.
+	*
+	* @since 2.0.0
+	*/
+	expression_text;
+	constructor(filename, expression_text) {
+		super([
+			make_error_message("ASYNC_EFFECT_IN_EVENT_CALLBACK", `${filename}: yield* cannot be used inside a nested non-generator callback in a markup event handler.`),
+			`Move the yield* to the event handler body. Effect.try and Effect.sync callbacks are plain synchronous JavaScript; do not call Effect-returning functions inside them.`,
+			"",
+			`Run the remote Effect directly:`,
+			`  onclick={yield* UpvotePost(id)}`,
+			"",
+			`Recover from remote failures by composing the Effect value:`,
+			`  onclick={yield* UpvotePost(id).pipe(Effect.catch(() => Effect.void))}`,
+			"",
+			`Problematic expression:`,
+			expression_text
+		].join("\n"), filename);
+		this.name = "AsyncEffectInEventCallbackError";
+		this.expression_text = expression_text;
+	}
+};
+/**
+* Thrown when an event handler callback contains the old raw `yield*`
+* shorthand. Effectful event handlers must put `yield*` directly in the event
+* attribute so the callback boundary is generated by the markup runtime.
+*
+* @example
+* ```ts
+* throw new YieldStarInEventCallbackError(
+*   "Component.svelte",
+*   "() => yield* save()",
+* );
+* ```
+*
+* @since 2.0.0
+* @param filename - Svelte component filename used to identify where the
+*   invalid event handler callback was found.
+* @param expression_text - Original event handler callback text that contained
+*   `yield*` and should be rewritten as a direct event Effect expression.
+*/
+var YieldStarInEventCallbackError = class extends PreprocessError {
+	/**
+	* The full text of the problematic event handler callback.
+	*
+	* @since 2.0.0
+	*/
+	expression_text;
+	constructor(filename, expression_text) {
+		super([
+			make_error_message("ASYNC_EFFECT_IN_EVENT_HANDLER_CALLBACK", `${filename}: yield* in markup event handlers must be written directly as the event attribute value.`),
+			`SER generates the event callback for effectful event handlers; do not put yield* inside a JavaScript callback.`,
+			"",
+			`Use this form:`,
+			`  onclick={yield* UpvotePost(id)}`,
+			"",
+			`Instead of this form:`,
+			`  onclick={() => yield* UpvotePost(id)}`,
+			"",
+			`Problematic expression:`,
+			expression_text
+		].join("\n"), filename);
+		this.name = "YieldStarInEventCallbackError";
+		this.expression_text = expression_text;
+	}
+};
+//#endregion
 //#region src/markup/transform/expressions.ts
 /**
 * Strips an event handler arrow function down to its executable body.
@@ -273,6 +476,20 @@ function strip_arrow_function(expr) {
 	};
 }
 /**
+* Returns whether an expression is a callback function.
+*
+* @since 2.0.0
+* @param expr - Expression text from a markup attribute or expression tag.
+* @returns Whether the expression parses as an arrow or function expression.
+*/
+function is_callback_function_expression(expr) {
+	const wrapped = `const __ser_callback = ${expr};`;
+	const stmt = ts.createSourceFile("callback.ts", wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
+	if (!ts.isVariableStatement(stmt)) return false;
+	const initializer = stmt.declarationList.declarations[0]?.initializer;
+	return initializer !== void 0 && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer));
+}
+/**
 * Classifies `yield*` placement inside an event handler body.
 *
 * @example
@@ -336,7 +553,7 @@ function visit_ids(node, seen, ids) {
 	node.forEachChild((child) => visit_ids(child, seen, ids));
 }
 function visit_event_body(node, context, result) {
-	if (is_yield_star_expression(node)) {
+	if (is_yield_star_expression$1(node)) {
 		if (context === "top_level") result.has_top_level_yield_star = true;
 		else if (context === "nested_invalid") result.has_nested_invalid_yield_star = true;
 		node.forEachChild((child) => visit_event_body(child, context, result));
@@ -355,7 +572,7 @@ function is_nested_function_boundary(node) {
 function is_generator_function_boundary(node) {
 	return (ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0;
 }
-function is_yield_star_expression(node) {
+function is_yield_star_expression$1(node) {
 	if (ts.isYieldExpression(node)) return node.asteriskToken !== void 0;
 	return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AsteriskToken && ts.isIdentifier(node.left) && node.left.text === "yield";
 }
@@ -395,13 +612,12 @@ function emit_replacement(candidate, kind) {
 		replacement_text = emit_each_expression(id_text, effect);
 		helpers = [effect.helper];
 	} else if (kind === "event") {
-		const event = strip_arrow_function(candidate.expr_text);
-		replacement_text = `${event.params} => { void ${HELPERS.run}(function* () { ${event.body}; }); }`;
+		replacement_text = make_event_handler(candidate).text;
 		helpers = [];
 		relocation = make_relocation(candidate, replacement_text, {
-			originalStart: event.body_start,
-			originalEnd: event.body_end,
-			generatedText: event.body
+			originalStart: 0,
+			originalEnd: candidate.expr_text.length,
+			generatedText: candidate.expr_text
 		});
 	} else {
 		const effect = make_effect_helper(candidate, helper_name);
@@ -416,6 +632,11 @@ function emit_replacement(candidate, kind) {
 		relocation
 	};
 }
+function make_event_handler(candidate) {
+	if (is_callback_function_expression(candidate.expr_text)) throw new YieldStarInEventCallbackError(candidate.filename, candidate.expr_text);
+	if (analyze_event_body_yield_star(candidate.expr_text).has_nested_invalid_yield_star) throw new AsyncEffectInEventCallbackError(candidate.filename, candidate.expr_text);
+	return { text: `(event) => { void ${HELPERS.run}(function* () { ${candidate.expr_text}; }); }` };
+}
 function emit_promise_expression(id_text, effect) {
 	return `${HELPERS.promise}(${id_text}, ${effect.deps_text}, () => ${effect.call})`;
 }
@@ -464,92 +685,90 @@ function make_relocation(candidate, replacement_text, inner) {
 	};
 }
 //#endregion
-//#region src/error.ts
+//#region src/preprocess/ast.ts
 /**
-* Base error class for all preprocessor errors emitted during script and
-* markup transformation. Carries the source filename so error messages can
-* reference the affected file.
+* Checks whether a node is a `yield*` binary expression.
 *
 * @since 2.0.0
+* @param node - TypeScript AST node to check.
+* @returns Whether the node represents `yield * operand`.
 */
-var PreprocessError = class extends Error {
-	/**
-	* The source filename that triggered this error.
-	*
-	* @since 2.0.0
-	*/
-	filename;
-	constructor(message, filename) {
-		super(message);
-		this.name = "PreprocessError";
-		this.filename = filename;
-	}
-};
+function is_yield_star_expression(node) {
+	return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AsteriskToken && ts.isIdentifier(node.left) && node.left.text === "yield";
+}
 /**
-* Thrown when `await` is used at the top level of a `<script effect>` block.
-* Top-level `await` is not supported — users should use
-* `yield* Effect.promise(...)` or `yield* Effect.tryPromise(...)` instead.
+* Checks whether a node owns its own yield semantics.
 *
 * @since 2.0.0
+* @param node - TypeScript AST node to check.
+* @returns Whether traversal should stop at this function boundary.
 */
-var TopLevelAwaitError = class extends PreprocessError {
-	/**
-	* The full text of the problematic statement containing the `await`.
-	*
-	* @since 2.0.0
-	*/
-	statement_text;
-	constructor(filename, statement_text) {
-		super([
-			`${filename}: top-level await is not supported in <script effect>.`,
-			`Use yield* Effect.promise(...) or yield* Effect.tryPromise(...) instead.`,
-			"",
-			`Problematic statement:`,
-			statement_text
-		].join("\n"), filename);
-		this.name = "TopLevelAwaitError";
-		this.statement_text = statement_text;
+function is_function_boundary_node(node) {
+	return ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node);
+}
+/**
+* Returns `true` if the node tree contains a top-level `await`.
+*
+* @since 2.0.0
+* @param node - Root node to search.
+* @returns Whether a top-level await expression was found.
+*/
+function contains_top_level_await(node) {
+	if (ts.isAwaitExpression(node)) return true;
+	return node.getChildren().some((child) => !is_function_boundary_node(child) && contains_top_level_await(child));
+}
+/**
+* Collects top-level `yield*` nodes under an expression.
+*
+* @since 2.0.0
+* @param node - Root node to search.
+* @param on_found - Callback invoked for each matching yield node.
+* @returns Nothing.
+*/
+function collect_yield_star_nodes(node, on_found) {
+	if (is_function_boundary_node(node)) return;
+	if (is_yield_star_expression(node)) {
+		on_found(node);
+		return;
 	}
-};
+	node.forEachChild((child) => {
+		collect_yield_star_nodes(child, on_found);
+	});
+}
 /**
-* Thrown when an event handler contains `yield*` inside a nested callback that
-* is not itself a generator function.
+* Finds the first top-level `yield*` expression below a node.
 *
-* @example
-* ```ts
-* throw new NestedYieldStarInEventHandlerError(
-*   "Component.svelte",
-*   "Effect.try(() => yield* save())",
-* );
-* ```
+* @since 2.0.0
+* @param node - Root node to search.
+* @param on_found - Callback invoked with the first matching node.
+* @returns Nothing.
+*/
+function find_yield_star_node(node, on_found) {
+	if (is_function_boundary_node(node)) return;
+	if (is_yield_star_expression(node)) {
+		on_found(node);
+		return;
+	}
+	node.forEachChild((child) => {
+		find_yield_star_node(child, on_found);
+	});
+}
+/**
+* Extracts identifier names from a TypeScript binding name.
 *
 * @since 2.0.0
+* @param name - Binding name node to flatten.
+* @returns Identifier names from identifiers and destructuring patterns.
 */
-var NestedYieldStarInEventHandlerError = class extends PreprocessError {
-	/**
-	* The full text of the problematic event handler body.
-	*
-	* @since 2.0.0
-	*/
-	expression_text;
-	constructor(filename, expression_text) {
-		super([
-			`${filename}: yield* cannot be used inside a nested non-generator callback in a markup event handler.`,
-			`Move the yield* to the event handler body. Effect.try and Effect.sync callbacks are plain synchronous JavaScript; do not call Effect-returning functions inside them.`,
-			"",
-			`Run the remote Effect directly:`,
-			`  onclick={() => yield* UpvotePost(id)}`,
-			"",
-			`Recover from remote failures by composing the Effect value:`,
-			`  onclick={() => yield* UpvotePost(id).pipe(Effect.catch(() => Effect.void))}`,
-			"",
-			`Problematic expression:`,
-			expression_text
-		].join("\n"), filename);
-		this.name = "NestedYieldStarInEventHandlerError";
-		this.expression_text = expression_text;
+function extract_binding_names(name) {
+	if (ts.isIdentifier(name)) return [name.text];
+	const result = [];
+	for (const element of name.elements) {
+		if (ts.isOmittedExpression(element)) continue;
+		result.push(...extract_binding_names(element.name));
 	}
-};
+	return result;
+}
 //#endregion
 //#region src/markup/transform/scan.ts
 function sanitize_markup(content, filename) {
@@ -575,20 +794,20 @@ function sanitize_markup(content, filename) {
 		const trimmed = inner.trimStart();
 		const leading_ws = inner.length - trimmed.length;
 		const tag_info = get_tag_info(trimmed);
-		const declaration_initializers = collect_declaration_initializers(content, open, leading_ws, trimmed);
-		if (declaration_initializers.length > 0) {
-			for (const initializer of declaration_initializers) {
+		const declaration_yields = collect_declaration_yield_expressions(content, open, leading_ws, trimmed);
+		if (declaration_yields.length > 0) {
+			for (const declaration_yield of declaration_yields) {
 				const placeholder = `__ser_markup_placeholder_${helper_index}`;
 				helper_index += 1;
 				candidates.push({
 					placeholder,
-					start: initializer.start,
-					end: initializer.end,
-					expr_text: initializer.expr_text,
+					start: declaration_yield.start,
+					end: declaration_yield.end,
+					expr_text: declaration_yield.expr_text,
 					filename,
 					key: "plain"
 				});
-				magic.overwrite(initializer.start, initializer.end, placeholder);
+				magic.overwrite(declaration_yield.start, declaration_yield.end, placeholder);
 			}
 			cursor = close + 1;
 			continue;
@@ -596,7 +815,7 @@ function sanitize_markup(content, filename) {
 		let expr_body = trimmed.slice(tag_info.prefix_length);
 		/** For @const, only use the RHS after `=` as the expression body. */
 		const equal_idx = tag_info.kind === "plain" && trimmed.startsWith("@const ") ? expr_body.indexOf("=") : -1;
-		if (!((is_event_expression(inner) ? analyze_event_yield(inner, filename) : void 0)?.has_top_level_yield_star ?? contains_yield_star_in_text(expr_body))) {
+		if (!((is_event_callback_expression(inner) ? analyze_event_yield(inner) : void 0)?.has_top_level_yield_star ?? contains_yield_star_in_text(expr_body))) {
 			cursor = close + 1;
 			continue;
 		}
@@ -742,35 +961,40 @@ function get_tag_info(trimmed) {
 		prefix_length: 0
 	};
 }
-function collect_declaration_initializers(content, open, leading_ws, trimmed) {
+function collect_declaration_yield_expressions(content, open, leading_ws, trimmed) {
 	if (!is_declaration_tag_text(trimmed)) return [];
 	const source_file = ts.createSourceFile("declaration-tag.ts", `${trimmed};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
 	const stmt = source_file.statements[0];
 	if (!stmt || !ts.isVariableStatement(stmt)) return [];
 	const tag_start = open + 1 + leading_ws;
-	return stmt.declarationList.declarations.filter((decl) => decl.initializer && contains_top_level_yield_star(decl.initializer)).map((decl) => {
+	return stmt.declarationList.declarations.flatMap((decl) => {
 		const initializer = decl.initializer;
-		const start = tag_start + initializer.getStart(source_file);
-		const end = tag_start + initializer.end;
-		return {
-			start,
-			end,
-			expr_text: content.slice(start, end).trim()
-		};
+		if (!initializer || !contains_top_level_yield_star(initializer)) return [];
+		const expressions = [];
+		collect_yield_star_nodes(initializer, (yield_node) => {
+			const start = tag_start + yield_node.getStart(source_file);
+			const end = tag_start + yield_node.end;
+			const expr_text = content.slice(start, end).trim();
+			expressions.push({
+				start,
+				end,
+				expr_text
+			});
+		});
+		return expressions;
 	});
 }
 function is_declaration_tag_text(trimmed) {
 	return /^(?:const|let)\s/.test(trimmed);
 }
-function is_event_expression(inner) {
+function is_event_callback_expression(inner) {
 	const trimmed = inner.trimStart();
-	return /^(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(trimmed);
+	return /^(?:async\s+)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(trimmed) || /^(?:async\s+)?function\b/.test(trimmed);
 }
-function analyze_event_yield(inner, filename) {
+function analyze_event_yield(inner) {
 	const event = strip_arrow_function(inner);
 	const analysis = analyze_event_body_yield_star(event.body);
-	if (analysis.has_nested_invalid_yield_star) throw new NestedYieldStarInEventHandlerError(filename, event.body);
-	return { has_top_level_yield_star: analysis.has_top_level_yield_star };
+	return { has_top_level_yield_star: analysis.has_top_level_yield_star || analysis.has_nested_invalid_yield_star || /\byield\s*\*/.test(event.body) };
 }
 function contains_yield_star_in_text(text) {
 	if (!/\byield\s*\*/.test(text)) return false;
@@ -831,6 +1055,6 @@ function transform_markup_effect(content, filename) {
 	};
 }
 //#endregion
-export { TopLevelAwaitError as n, transform_markup_effect as t };
+export { find_yield_star_node as a, AsyncEffectInSyncRuneError as c, extract_binding_names as i, AwaitInEffectWorkError as l, collect_yield_star_nodes as n, is_yield_star_expression as o, contains_top_level_await as r, collect_free_identifiers as s, transform_markup_effect as t };
 
-//# sourceMappingURL=transform-BtlxgJrg.js.map
+//# sourceMappingURL=transform-B4g76Ur4.js.map