@depup/svelte 5.53.3-depup.0

package/src/compiler/phases/3-transform/server/visitors/ClassBody.js

@@ -0,0 +1,81 @@
+/** @import { CallExpression, ClassBody, MethodDefinition, PropertyDefinition, StaticBlock } from 'estree' */
+/** @import { Context } from '../types.js' */
+import * as b from '#compiler/builders';
+import { get_name } from '../../../nodes.js';
+
+/**
+ * @param {ClassBody} node
+ * @param {Context} context
+ */
+export function ClassBody(node, context) {
+	const state_fields = context.state.analysis.classes.get(node);
+
+	if (!state_fields) {
+		// in legacy mode, do nothing
+		context.next();
+		return;
+	}
+
+	/** @type {Array<MethodDefinition | PropertyDefinition | StaticBlock>} */
+	const body = [];
+
+	const child_state = { ...context.state, state_fields };
+
+	for (const [name, field] of state_fields) {
+		if (name[0] === '#') {
+			continue;
+		}
+
+		// insert backing fields for stuff declared in the constructor
+		if (
+			field &&
+			field.node.type === 'AssignmentExpression' &&
+			(field.type === '$derived' || field.type === '$derived.by')
+		) {
+			const member = b.member(b.this, field.key);
+
+			body.push(
+				b.prop_def(field.key, null),
+				b.method('get', b.key(name), [], [b.return(b.call(member))]),
+				b.method('set', b.key(name), [b.id('$$value')], [b.return(b.call(member, b.id('$$value')))])
+			);
+		}
+	}
+
+	// Replace parts of the class body
+	for (const definition of node.body) {
+		if (definition.type !== 'PropertyDefinition') {
+			body.push(
+				/** @type {MethodDefinition | StaticBlock} */ (context.visit(definition, child_state))
+			);
+			continue;
+		}
+
+		const name = get_name(definition.key);
+		const field = name && state_fields.get(name);
+
+		if (!field) {
+			body.push(/** @type {PropertyDefinition} */ (context.visit(definition, child_state)));
+			continue;
+		}
+
+		if (name[0] === '#' || field.type === '$state' || field.type === '$state.raw') {
+			body.push(/** @type {PropertyDefinition} */ (context.visit(definition, child_state)));
+		} else if (field.node === definition) {
+			// $derived / $derived.by
+			const member = b.member(b.this, field.key);
+
+			body.push(
+				b.prop_def(
+					field.key,
+					/** @type {CallExpression} */ (context.visit(field.value, child_state))
+				),
+
+				b.method('get', definition.key, [], [b.return(b.call(member))]),
+				b.method('set', b.key(name), [b.id('$$value')], [b.return(b.call(member, b.id('$$value')))])
+			);
+		}
+	}
+
+	return { ...node, body };
+}

package/src/compiler/phases/3-transform/server/visitors/Component.js

@@ -0,0 +1,13 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import * as b from '#compiler/builders';
+import { build_inline_component } from './shared/component.js';
+
+/**
+ * @param {AST.Component} node
+ * @param {ComponentContext} context
+ */
+export function Component(node, context) {
+	build_inline_component(node, /** @type {Expression} */ (context.visit(b.id(node.name))), context);
+}

package/src/compiler/phases/3-transform/server/visitors/ConstTag.js

@@ -0,0 +1,49 @@
+/** @import { Expression, Pattern } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import * as b from '#compiler/builders';
+import { extract_identifiers } from '../../../../utils/ast.js';
+
+/**
+ * @param {AST.ConstTag} node
+ * @param {ComponentContext} context
+ */
+export function ConstTag(node, context) {
+	const declaration = node.declaration.declarations[0];
+	const id = /** @type {Pattern} */ (context.visit(declaration.id));
+	const init = /** @type {Expression} */ (context.visit(declaration.init));
+	const has_await = node.metadata.expression.has_await;
+	const blockers = [...node.metadata.expression.dependencies]
+		.map((dep) => dep.blocker)
+		.filter((b) => b !== null && b.object !== context.state.async_consts?.id);
+
+	if (has_await || context.state.async_consts || blockers.length > 0) {
+		const run = (context.state.async_consts ??= {
+			id: b.id(context.state.scope.generate('promises')),
+			thunks: []
+		});
+
+		const identifiers = extract_identifiers(declaration.id);
+		const bindings = context.state.scope.get_bindings(declaration);
+
+		for (const identifier of identifiers) {
+			context.state.init.push(b.let(identifier.name));
+		}
+
+		if (blockers.length === 1) {
+			run.thunks.push(b.thunk(/** @type {Expression} */ (blockers[0])));
+		} else if (blockers.length > 0) {
+			run.thunks.push(b.thunk(b.call('Promise.all', b.array(blockers))));
+		}
+
+		const assignment = b.assignment('=', id, init);
+		run.thunks.push(b.thunk(b.block([b.stmt(assignment)]), has_await));
+
+		const blocker = b.member(run.id, b.literal(run.thunks.length - 1), true);
+		for (const binding of bindings) {
+			binding.blocker = blocker;
+		}
+	} else {
+		context.state.init.push(b.const(id, init));
+	}
+}

package/src/compiler/phases/3-transform/server/visitors/DebugTag.js

@@ -0,0 +1,24 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import * as b from '#compiler/builders';
+
+/**
+ * @param {AST.DebugTag} node
+ * @param {ComponentContext} context
+ */
+export function DebugTag(node, context) {
+	context.state.template.push(
+		b.stmt(
+			b.call(
+				'console.log',
+				b.object(
+					node.identifiers.map((identifier) =>
+						b.prop('init', identifier, /** @type {Expression} */ (context.visit(identifier)))
+					)
+				)
+			)
+		),
+		b.debugger
+	);
+}

package/src/compiler/phases/3-transform/server/visitors/EachBlock.js

@@ -0,0 +1,76 @@
+/** @import { BlockStatement, Expression, Statement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import * as b from '#compiler/builders';
+import { block_close, block_open, block_open_else, create_child_block } from './shared/utils.js';
+
+/**
+ * @param {AST.EachBlock} node
+ * @param {ComponentContext} context
+ */
+export function EachBlock(node, context) {
+	const state = context.state;
+
+	const each_node_meta = node.metadata;
+	const collection = /** @type {Expression} */ (context.visit(node.expression));
+	const index =
+		each_node_meta.contains_group_binding || !node.index ? each_node_meta.index : b.id(node.index);
+
+	const array_id = state.scope.root.unique('each_array');
+
+	/** @type {Statement[]} */
+	let statements = [b.const(array_id, b.call('$.ensure_array_like', collection))];
+
+	/** @type {Statement[]} */
+	const each = [];
+
+	if (node.context) {
+		each.push(b.let(node.context, b.member(array_id, index, true)));
+	}
+
+	if (index.name !== node.index && node.index != null) {
+		each.push(b.let(node.index, index));
+	}
+
+	const new_body = /** @type {BlockStatement} */ (context.visit(node.body)).body;
+
+	if (node.body) each.push(...new_body);
+
+	const for_loop = b.for(
+		b.declaration('let', [
+			b.declarator(index, b.literal(0)),
+			b.declarator('$$length', b.member(array_id, 'length'))
+		]),
+		b.binary('<', index, b.id('$$length')),
+		b.update('++', index, false),
+		b.block(each)
+	);
+
+	if (node.fallback) {
+		const open = b.stmt(b.call(b.id('$$renderer.push'), block_open));
+
+		const fallback = /** @type {BlockStatement} */ (context.visit(node.fallback));
+
+		fallback.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), block_open_else)));
+
+		statements.push(
+			b.if(
+				b.binary('!==', b.member(array_id, 'length'), b.literal(0)),
+				b.block([open, for_loop]),
+				fallback
+			)
+		);
+	} else {
+		state.template.push(block_open);
+		statements.push(for_loop);
+	}
+
+	state.template.push(
+		...create_child_block(
+			statements,
+			node.metadata.expression.blockers(),
+			node.metadata.expression.has_await
+		),
+		block_close
+	);
+}

package/src/compiler/phases/3-transform/server/visitors/ExpressionStatement.js

@@ -0,0 +1,23 @@
+/** @import { ExpressionStatement } from 'estree' */
+/** @import { Context } from '../types.js' */
+import * as b from '#compiler/builders';
+import { get_rune } from '../../../scope.js';
+
+/**
+ * @param {ExpressionStatement} node
+ * @param {Context} context
+ */
+export function ExpressionStatement(node, context) {
+	const rune = get_rune(node.expression, context.state.scope);
+
+	if (
+		rune === '$effect' ||
+		rune === '$effect.pre' ||
+		rune === '$effect.root' ||
+		rune === '$inspect.trace'
+	) {
+		return b.empty;
+	}
+
+	context.next();
+}

package/src/compiler/phases/3-transform/server/visitors/Fragment.js

@@ -0,0 +1,53 @@
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext, ComponentServerTransformState } from '../types.js' */
+import { clean_nodes, infer_namespace } from '../../utils.js';
+import * as b from '#compiler/builders';
+import { empty_comment, process_children, build_template } from './shared/utils.js';
+
+/**
+ * @param {AST.Fragment} node
+ * @param {ComponentContext} context
+ */
+export function Fragment(node, context) {
+	const parent = context.path.at(-1) ?? node;
+	const namespace = infer_namespace(context.state.namespace, parent, node.nodes);
+
+	const { hoisted, trimmed, is_standalone, is_text_first } = clean_nodes(
+		parent,
+		node.nodes,
+		context.path,
+		namespace,
+		context.state,
+		context.state.preserve_whitespace,
+		context.state.options.preserveComments
+	);
+
+	/** @type {ComponentServerTransformState} */
+	const state = {
+		...context.state,
+		init: [],
+		template: [],
+		namespace,
+		is_standalone,
+		async_consts: undefined
+	};
+
+	for (const node of hoisted) {
+		context.visit(node, state);
+	}
+
+	if (is_text_first) {
+		// insert `<!---->` to prevent this from being glued to the previous fragment
+		state.template.push(empty_comment);
+	}
+
+	process_children(trimmed, { ...context, state });
+
+	if (state.async_consts && state.async_consts.thunks.length > 0) {
+		state.init.push(
+			b.var(state.async_consts.id, b.call('$$renderer.run', b.array(state.async_consts.thunks)))
+		);
+	}
+
+	return b.block([...state.init, ...build_template(state.template)]);
+}

package/src/compiler/phases/3-transform/server/visitors/HtmlTag.js

@@ -0,0 +1,25 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import * as b from '#compiler/builders';
+import { create_child_block } from './shared/utils.js';
+
+/**
+ * @param {AST.HtmlTag} node
+ * @param {ComponentContext} context
+ */
+export function HtmlTag(node, context) {
+	const expression = b.call('$.html', /** @type {Expression} */ (context.visit(node.expression)));
+
+	if (node.metadata.expression.is_async()) {
+		context.state.template.push(
+			...create_child_block(
+				[b.stmt(b.call('$$renderer.push', expression))],
+				node.metadata.expression.blockers(),
+				node.metadata.expression.has_await
+			)
+		);
+	} else {
+		context.state.template.push(expression);
+	}
+}

package/src/compiler/phases/3-transform/server/visitors/Identifier.js

@@ -0,0 +1,24 @@
+/** @import { Identifier, Node } from 'estree' */
+/** @import { Context } from '../types.js' */
+import is_reference from 'is-reference';
+import * as b from '#compiler/builders';
+import { build_getter } from './shared/utils.js';
+
+/**
+ * @param {Identifier} node
+ * @param {Context} context
+ */
+export function Identifier(node, context) {
+	if (is_reference(node, /** @type {Node} */ (context.path.at(-1)))) {
+		if (node.name === '$$props') {
+			return b.id('$$sanitized_props');
+		}
+
+		if (node.name.startsWith('$$derived_array')) {
+			// terrible hack, but easier than adding new stuff to `context.state` for now
+			return b.call(node);
+		}
+
+		return build_getter(node, context.state);
+	}
+}

package/src/compiler/phases/3-transform/server/visitors/IfBlock.js

@@ -0,0 +1,48 @@
+/** @import { BlockStatement, Expression, IfStatement, Statement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import * as b from '#compiler/builders';
+import { block_close, block_open, block_open_else, create_child_block } from './shared/utils.js';
+
+/**
+ * @param {AST.IfBlock} node
+ * @param {ComponentContext} context
+ */
+export function IfBlock(node, context) {
+	const consequent = /** @type {BlockStatement} */ (context.visit(node.consequent));
+	consequent.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), block_open)));
+
+	/** @type {IfStatement} */
+	let if_statement = b.if(/** @type {Expression} */ (context.visit(node.test)), consequent);
+
+	let index = 1;
+	let current_if = if_statement;
+	let alt = node.alternate;
+
+	// Walk the else-if chain, flattening branches
+	for (const elseif of node.metadata.flattened ?? []) {
+		const branch = /** @type {BlockStatement} */ (context.visit(elseif.consequent));
+		branch.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), b.literal(`<!--[${index++}-->`))));
+
+		current_if = current_if.alternate = b.if(
+			/** @type {Expression} */ (context.visit(elseif.test)),
+			branch
+		);
+		alt = elseif.alternate;
+	}
+
+	// Handle final else (or remaining async chain)
+	const final_alternate = alt ? /** @type {BlockStatement} */ (context.visit(alt)) : b.block([]);
+
+	final_alternate.body.unshift(b.stmt(b.call(b.id('$$renderer.push'), block_open_else)));
+	current_if.alternate = final_alternate;
+
+	context.state.template.push(
+		...create_child_block(
+			[if_statement],
+			node.metadata.expression.blockers(),
+			node.metadata.expression.has_await
+		),
+		block_close
+	);
+}

package/src/compiler/phases/3-transform/server/visitors/KeyBlock.js

@@ -0,0 +1,22 @@
+/** @import { BlockStatement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import { block_close, block_open, empty_comment } from './shared/utils.js';
+
+/**
+ * @param {AST.KeyBlock} node
+ * @param {ComponentContext} context
+ */
+export function KeyBlock(node, context) {
+	const is_async = node.metadata.expression.is_async();
+
+	if (is_async) context.state.template.push(block_open);
+
+	context.state.template.push(
+		empty_comment,
+		/** @type {BlockStatement} */ (context.visit(node.fragment)),
+		empty_comment
+	);
+
+	if (is_async) context.state.template.push(block_close);
+}

package/src/compiler/phases/3-transform/server/visitors/LabeledStatement.js

@@ -0,0 +1,24 @@
+/** @import { ExpressionStatement, LabeledStatement } from 'estree' */
+/** @import { Context } from '../types.js' */
+import * as b from '#compiler/builders';
+
+/**
+ * @param {LabeledStatement} node
+ * @param {Context} context
+ */
+export function LabeledStatement(node, context) {
+	if (context.state.analysis.runes || context.path.length > 1 || node.label.name !== '$') {
+		return;
+	}
+
+	// TODO bail out if we're in module context
+
+	// these statements will be topologically ordered later
+	context.state.legacy_reactive_statements.set(
+		node,
+		// people could do "break $" inside, so we need to keep the label
+		b.labeled('$', /** @type {ExpressionStatement} */ (context.visit(node.body)))
+	);
+
+	return b.empty;
+}

package/src/compiler/phases/3-transform/server/visitors/MemberExpression.js

@@ -0,0 +1,19 @@
+/** @import { ClassBody, MemberExpression } from 'estree' */
+/** @import { Context } from '../types.js' */
+import * as b from '#compiler/builders';
+
+/**
+ * @param {MemberExpression} node
+ * @param {Context} context
+ */
+export function MemberExpression(node, context) {
+	if (context.state.analysis.runes && node.property.type === 'PrivateIdentifier') {
+		const field = context.state.state_fields?.get(`#${node.property.name}`);
+
+		if (field?.type === '$derived' || field?.type === '$derived.by') {
+			return b.call(node);
+		}
+	}
+
+	context.next();
+}

package/src/compiler/phases/3-transform/server/visitors/Program.js

@@ -0,0 +1,25 @@
+/** @import { Node, Program } from 'estree' */
+/** @import { Context, ComponentServerTransformState } from '../types' */
+import * as b from '#compiler/builders';
+import { transform_body } from '../../shared/transform-async.js';
+
+/**
+ * @param {Program} node
+ * @param {Context} context
+ */
+export function Program(node, context) {
+	if (context.state.is_instance) {
+		const state = /** @type {ComponentServerTransformState} */ (context.state);
+
+		return {
+			...node,
+			body: transform_body(
+				state.analysis.instance_body,
+				b.id('$$renderer.run'),
+				(node) => /** @type {Node} */ (context.visit(node))
+			)
+		};
+	}
+
+	context.next();
+}

package/src/compiler/phases/3-transform/server/visitors/PropertyDefinition.js

@@ -0,0 +1,37 @@
+/** @import { Expression, PropertyDefinition } from 'estree' */
+/** @import { Context } from '../types.js' */
+import * as b from '#compiler/builders';
+import { get_rune } from '../../../scope.js';
+
+/**
+ * @param {PropertyDefinition} node
+ * @param {Context} context
+ */
+export function PropertyDefinition(node, context) {
+	if (context.state.analysis.runes && node.value != null && node.value.type === 'CallExpression') {
+		const rune = get_rune(node.value, context.state.scope);
+
+		if (rune === '$state' || rune === '$state.raw') {
+			return {
+				...node,
+				value:
+					node.value.arguments.length === 0
+						? null
+						: /** @type {Expression} */ (context.visit(node.value.arguments[0]))
+			};
+		}
+
+		if (rune === '$derived.by' || rune === '$derived') {
+			const fn = /** @type {Expression} */ (context.visit(node.value.arguments[0]));
+			return {
+				...node,
+				value:
+					node.value.arguments.length === 0
+						? null
+						: b.call('$.derived', rune === '$derived' ? b.thunk(fn) : fn)
+			};
+		}
+	}
+
+	context.next();
+}