svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/svelte/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 '../../../../utils/builders.js';
+
+/**
+ * @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
+	);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/EachBlock.js

@@ -0,0 +1,66 @@
+/** @import { BlockStatement, Expression, Pattern, Statement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import { BLOCK_OPEN_ELSE } from '../../../../../internal/server/hydration.js';
+import * as b from '../../../../utils/builders.js';
+import { block_close, block_open } 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');
+	state.init.push(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));
+	}
+
+	each.push(.../** @type {BlockStatement} */ (context.visit(node.body)).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.assignment('+=', b.id('$$payload.out'), block_open));
+
+		const fallback = /** @type {BlockStatement} */ (context.visit(node.fallback));
+
+		fallback.body.unshift(
+			b.stmt(b.assignment('+=', b.id('$$payload.out'), b.literal(BLOCK_OPEN_ELSE)))
+		);
+
+		state.template.push(
+			b.if(
+				b.binary('!==', b.member(array_id, 'length'), b.literal(0)),
+				b.block([open, for_loop]),
+				fallback
+			),
+			block_close
+		);
+	} else {
+		state.template.push(block_open, for_loop, block_close);
+	}
+}

data/lib/mount_svelte/node_modules/svelte/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 '../../../../utils/builders.js';
+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();
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/Fragment.js

@@ -0,0 +1,46 @@
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext, ComponentServerTransformState } from '../types.js' */
+import { clean_nodes, infer_namespace } from '../../utils.js';
+import * as b from '../../../../utils/builders.js';
+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,
+		skip_hydration_boundaries: is_standalone
+	};
+
+	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 });
+
+	return b.block([...state.init, ...build_template(state.template)]);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/HtmlTag.js

@@ -0,0 +1,13 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import * as b from '../../../../utils/builders.js';
+
+/**
+ * @param {AST.HtmlTag} node
+ * @param {ComponentContext} context
+ */
+export function HtmlTag(node, context) {
+	const expression = /** @type {Expression} */ (context.visit(node.expression));
+	context.state.template.push(b.call('$.html', expression));
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/Identifier.js

@@ -0,0 +1,19 @@
+/** @import { Identifier, Node } from 'estree' */
+/** @import { Context } from '../types.js' */
+import is_reference from 'is-reference';
+import * as b from '../../../../utils/builders.js';
+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');
+		}
+
+		return build_getter(node, context.state);
+	}
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/IfBlock.js

@@ -0,0 +1,38 @@
+/** @import { BlockStatement, Expression, IfStatement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import { BLOCK_OPEN_ELSE } from '../../../../../internal/server/hydration.js';
+import * as b from '../../../../utils/builders.js';
+import { block_close, block_open } 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.assignment('+=', b.id('$$payload.out'), block_open)));
+	let if_statement = b.if(/** @type {Expression} */ (context.visit(node.test)), consequent);
+
+	context.state.template.push(if_statement, block_close);
+
+	let index = 1;
+	let alt = node.alternate;
+	while (alt && alt.nodes.length === 1 && alt.nodes[0].type === 'IfBlock' && alt.nodes[0].elseif) {
+		const elseif = alt.nodes[0];
+		const alternate = /** @type {BlockStatement} */ (context.visit(elseif.consequent));
+		alternate.body.unshift(
+			b.stmt(b.assignment('+=', b.id('$$payload.out'), b.literal(`<!--[${index++}-->`)))
+		);
+		if_statement = if_statement.alternate = b.if(
+			/** @type {Expression} */ (context.visit(elseif.test)),
+			alternate
+		);
+		alt = elseif.alternate;
+	}
+
+	if_statement.alternate = alt ? /** @type {BlockStatement} */ (context.visit(alt)) : b.block([]);
+	if_statement.alternate.body.unshift(
+		b.stmt(b.assignment('+=', b.id('$$payload.out'), b.literal(BLOCK_OPEN_ELSE)))
+	);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/KeyBlock.js

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

data/lib/mount_svelte/node_modules/svelte/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 '../../../../utils/builders.js';
+
+/**
+ * @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;
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/MemberExpression.js

@@ -0,0 +1,23 @@
+/** @import { MemberExpression } from 'estree' */
+/** @import { Context } from '../types.js' */
+import * as b from '../../../../utils/builders.js';
+
+/**
+ * @param {MemberExpression} node
+ * @param {Context} context
+ */
+export function MemberExpression(node, context) {
+	if (
+		context.state.analysis.runes &&
+		node.object.type === 'ThisExpression' &&
+		node.property.type === 'PrivateIdentifier'
+	) {
+		const field = context.state.private_derived.get(node.property.name);
+
+		if (field) {
+			return b.call(node);
+		}
+	}
+
+	context.next();
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/PropertyDefinition.js

@@ -0,0 +1,36 @@
+/** @import { Expression, PropertyDefinition } from 'estree' */
+/** @import { Context } from '../types.js' */
+import * as b from '../../../../utils/builders.js';
+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' || rune === '$derived') {
+			return {
+				...node,
+				value:
+					node.value.arguments.length === 0
+						? null
+						: /** @type {Expression} */ (context.visit(node.value.arguments[0]))
+			};
+		}
+
+		if (rune === '$derived.by') {
+			return {
+				...node,
+				value:
+					node.value.arguments.length === 0
+						? null
+						: b.call(/** @type {Expression} */ (context.visit(node.value.arguments[0])))
+			};
+		}
+	}
+
+	context.next();
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/RegularElement.js

@@ -0,0 +1,104 @@
+/** @import { Location } from 'locate-character' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext, ComponentServerTransformState } from '../types.js' */
+/** @import { Scope } from '../../../scope.js' */
+import { is_void } from '../../../../../utils.js';
+import { dev, locator } from '../../../../state.js';
+import * as b from '../../../../utils/builders.js';
+import { clean_nodes, determine_namespace_for_children } from '../../utils.js';
+import { build_element_attributes } from './shared/element.js';
+import { process_children, build_template } from './shared/utils.js';
+
+/**
+ * @param {AST.RegularElement} node
+ * @param {ComponentContext} context
+ */
+export function RegularElement(node, context) {
+	const namespace = determine_namespace_for_children(node, context.state.namespace);
+
+	/** @type {ComponentServerTransformState} */
+	const state = {
+		...context.state,
+		namespace,
+		preserve_whitespace:
+			context.state.preserve_whitespace || node.name === 'pre' || node.name === 'textarea'
+	};
+
+	context.state.template.push(b.literal(`<${node.name}`));
+	const body = build_element_attributes(node, { ...context, state });
+	context.state.template.push(b.literal('>'));
+
+	if ((node.name === 'script' || node.name === 'style') && node.fragment.nodes.length === 1) {
+		context.state.template.push(
+			b.literal(/** @type {AST.Text} */ (node.fragment.nodes[0]).data),
+			b.literal(`</${node.name}>`)
+		);
+
+		return;
+	}
+
+	const { hoisted, trimmed } = clean_nodes(
+		node,
+		node.fragment.nodes,
+		context.path,
+		namespace,
+		{
+			...state,
+			scope: /** @type {Scope} */ (state.scopes.get(node.fragment))
+		},
+		state.preserve_whitespace,
+		state.options.preserveComments
+	);
+
+	for (const node of hoisted) {
+		context.visit(node, state);
+	}
+
+	if (dev) {
+		const location = /** @type {Location} */ (locator(node.start));
+		state.template.push(
+			b.stmt(
+				b.call(
+					'$.push_element',
+					b.id('$$payload'),
+					b.literal(node.name),
+					b.literal(location.line),
+					b.literal(location.column)
+				)
+			)
+		);
+	}
+
+	if (body === null) {
+		process_children(trimmed, { ...context, state });
+	} else {
+		let id = body;
+
+		if (body.type !== 'Identifier') {
+			id = b.id(state.scope.generate('$$body'));
+			state.template.push(b.const(id, body));
+		}
+
+		// if this is a `<textarea>` value or a contenteditable binding, we only add
+		// the body if the attribute/binding is falsy
+		const inner_state = { ...state, template: [], init: [] };
+		process_children(trimmed, { ...context, state: inner_state });
+
+		// Use the body expression as the body if it's truthy, otherwise use the inner template
+		state.template.push(
+			b.if(
+				id,
+				b.block(build_template([id])),
+				b.block([...inner_state.init, ...build_template(inner_state.template)])
+			)
+		);
+	}
+
+	if (!is_void(node.name)) {
+		state.template.push(b.literal(`</${node.name}>`));
+	}
+
+	if (dev) {
+		state.template.push(b.stmt(b.call('$.pop_element')));
+	}
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/RenderTag.js

@@ -0,0 +1,35 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import { unwrap_optional } from '../../../../utils/ast.js';
+import * as b from '../../../../utils/builders.js';
+import { empty_comment } from './shared/utils.js';
+
+/**
+ * @param {AST.RenderTag} node
+ * @param {ComponentContext} context
+ */
+export function RenderTag(node, context) {
+	const callee = unwrap_optional(node.expression).callee;
+	const raw_args = unwrap_optional(node.expression).arguments;
+
+	const snippet_function = /** @type {Expression} */ (context.visit(callee));
+
+	const snippet_args = raw_args.map((arg) => {
+		return /** @type {Expression} */ (context.visit(arg));
+	});
+
+	context.state.template.push(
+		b.stmt(
+			(node.expression.type === 'CallExpression' ? b.call : b.maybe_call)(
+				snippet_function,
+				b.id('$$payload'),
+				...snippet_args
+			)
+		)
+	);
+
+	if (!context.state.skip_hydration_boundaries) {
+		context.state.template.push(empty_comment);
+	}
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/SlotElement.js

@@ -0,0 +1,54 @@
+/** @import { BlockStatement, Expression, Literal, Property } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import * as b from '../../../../utils/builders.js';
+import { empty_comment, build_attribute_value } from './shared/utils.js';
+
+/**
+ * @param {AST.SlotElement} node
+ * @param {ComponentContext} context
+ */
+export function SlotElement(node, context) {
+	/** @type {Property[]} */
+	const props = [];
+
+	/** @type {Expression[]} */
+	const spreads = [];
+
+	let name = b.literal('default');
+
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'SpreadAttribute') {
+			spreads.push(/** @type {Expression} */ (context.visit(attribute)));
+		} else if (attribute.type === 'Attribute') {
+			const value = build_attribute_value(attribute.value, context, false, true);
+
+			if (attribute.name === 'name') {
+				name = /** @type {Literal} */ (value);
+			} else if (attribute.name !== 'slot') {
+				props.push(b.init(attribute.name, value));
+			}
+		}
+	}
+
+	const props_expression =
+		spreads.length === 0
+			? b.object(props)
+			: b.call('$.spread_props', b.array([b.object(props), ...spreads]));
+
+	const fallback =
+		node.fragment.nodes.length === 0
+			? b.null
+			: b.thunk(/** @type {BlockStatement} */ (context.visit(node.fragment)));
+
+	const slot = b.call(
+		'$.slot',
+		b.id('$$payload'),
+		b.id('$$props'),
+		name,
+		props_expression,
+		fallback
+	);
+
+	context.state.template.push(empty_comment, b.stmt(slot), empty_comment);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/SnippetBlock.js

@@ -0,0 +1,28 @@
+/** @import { BlockStatement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import { dev } from '../../../../state.js';
+import * as b from '../../../../utils/builders.js';
+
+/**
+ * @param {AST.SnippetBlock} node
+ * @param {ComponentContext} context
+ */
+export function SnippetBlock(node, context) {
+	const fn = b.function_declaration(
+		node.expression,
+		[b.id('$$payload'), ...node.parameters],
+		/** @type {BlockStatement} */ (context.visit(node.body))
+	);
+	if (dev) {
+		fn.body.body.unshift(b.stmt(b.call('$.validate_snippet_args', b.id('$$payload'))));
+	}
+	// @ts-expect-error - TODO remove this hack once $$render_inner for legacy bindings is gone
+	fn.___snippet = true;
+
+	if (node.metadata.can_hoist) {
+		context.state.hoisted.push(fn);
+	} else {
+		context.state.init.push(fn);
+	}
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/SpreadAttribute.js

@@ -0,0 +1,10 @@
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+
+/**
+ * @param {AST.SpreadAttribute} node
+ * @param {ComponentContext} context
+ */
+export function SpreadAttribute(node, context) {
+	return context.visit(node.expression);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/SvelteBoundary.js

@@ -0,0 +1,17 @@
+/** @import { BlockStatement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+import { BLOCK_CLOSE, BLOCK_OPEN } from '../../../../../internal/server/hydration.js';
+import * as b from '../../../../utils/builders.js';
+
+/**
+ * @param {AST.SvelteBoundary} node
+ * @param {ComponentContext} context
+ */
+export function SvelteBoundary(node, context) {
+	context.state.template.push(
+		b.literal(BLOCK_OPEN),
+		/** @type {BlockStatement} */ (context.visit(node.fragment)),
+		b.literal(BLOCK_CLOSE)
+	);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/SvelteComponent.js

@@ -0,0 +1,12 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types.js' */
+import { build_inline_component } from './shared/component.js';
+
+/**
+ * @param {AST.SvelteComponent} node
+ * @param {ComponentContext} context
+ */
+export function SvelteComponent(node, context) {
+	build_inline_component(node, /** @type {Expression} */ (context.visit(node.expression)), context);
+}