svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/client/utils.js

@@ -0,0 +1,296 @@
+/** @import { ArrowFunctionExpression, AssignmentExpression, Expression, FunctionDeclaration, FunctionExpression, Identifier, Node, Pattern, UpdateExpression } from 'estree' */
+/** @import { Binding } from '#compiler' */
+/** @import { ClientTransformState, ComponentClientTransformState, ComponentContext } from './types.js' */
+/** @import { Analysis } from '../../types.js' */
+/** @import { Scope } from '../../scope.js' */
+import * as b from '../../../utils/builders.js';
+import { is_simple_expression } from '../../../utils/ast.js';
+import {
+	PROPS_IS_LAZY_INITIAL,
+	PROPS_IS_IMMUTABLE,
+	PROPS_IS_RUNES,
+	PROPS_IS_UPDATED,
+	PROPS_IS_BINDABLE
+} from '../../../../constants.js';
+import { dev } from '../../../state.js';
+import { walk } from 'zimmerframe';
+import { validate_mutation } from './visitors/shared/utils.js';
+
+/**
+ * @param {Binding} binding
+ * @param {Analysis} analysis
+ * @returns {boolean}
+ */
+export function is_state_source(binding, analysis) {
+	return (
+		(binding.kind === 'state' || binding.kind === 'raw_state') &&
+		(!analysis.immutable || binding.reassigned || analysis.accessors)
+	);
+}
+
+/**
+ * @param {Identifier} node
+ * @param {ClientTransformState} state
+ * @returns {Expression}
+ */
+export function build_getter(node, state) {
+	if (Object.hasOwn(state.transform, node.name)) {
+		const binding = state.scope.get(node.name);
+
+		// don't transform the declaration itself
+		if (node !== binding?.node) {
+			return state.transform[node.name].read(node);
+		}
+	}
+
+	return node;
+}
+
+/**
+ * @param {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression} node
+ * @param {ComponentContext} context
+ * @returns {Pattern[]}
+ */
+function get_hoisted_params(node, context) {
+	const scope = context.state.scope;
+
+	/** @type {Identifier[]} */
+	const params = [];
+
+	/**
+	 * We only want to push if it's not already present to avoid name clashing
+	 * @param {Identifier} id
+	 */
+	function push_unique(id) {
+		if (!params.find((param) => param.name === id.name)) {
+			params.push(id);
+		}
+	}
+
+	for (const [reference] of scope.references) {
+		let binding = scope.get(reference);
+
+		if (binding !== null && !scope.declarations.has(reference) && binding.initial !== node) {
+			if (binding.kind === 'store_sub') {
+				// We need both the subscription for getting the value and the store for updating
+				push_unique(b.id(binding.node.name));
+				binding = /** @type {Binding} */ (scope.get(binding.node.name.slice(1)));
+			}
+
+			let expression = context.state.transform[reference]?.read(b.id(binding.node.name));
+
+			if (
+				// If it's a destructured derived binding, then we can extract the derived signal reference and use that.
+				// TODO this code is bad, we need to kill it
+				expression != null &&
+				typeof expression !== 'function' &&
+				expression.type === 'MemberExpression' &&
+				expression.object.type === 'CallExpression' &&
+				expression.object.callee.type === 'Identifier' &&
+				expression.object.callee.name === '$.get' &&
+				expression.object.arguments[0].type === 'Identifier'
+			) {
+				push_unique(b.id(expression.object.arguments[0].name));
+			} else if (
+				// If we are referencing a simple $$props value, then we need to reference the object property instead
+				(binding.kind === 'prop' || binding.kind === 'bindable_prop') &&
+				!is_prop_source(binding, context.state)
+			) {
+				push_unique(b.id('$$props'));
+			} else if (
+				// imports don't need to be hoisted
+				binding.declaration_kind !== 'import'
+			) {
+				// create a copy to remove start/end tags which would mess up source maps
+				push_unique(b.id(binding.node.name));
+				// rest props are often accessed through the $$props object for optimization reasons,
+				// but we can't know if the delegated event handler will use it, so we need to add both as params
+				if (binding.kind === 'rest_prop' && context.state.analysis.runes) {
+					push_unique(b.id('$$props'));
+				}
+			}
+		}
+	}
+
+	if (dev) {
+		// this is a little hacky, but necessary for ownership validation
+		// to work inside hoisted event handlers
+
+		/**
+		 * @param {AssignmentExpression | UpdateExpression} node
+		 * @param {{ next: () => void, stop: () => void }} context
+		 */
+		function visit(node, { next, stop }) {
+			if (validate_mutation(node, /** @type {any} */ (context), node) !== node) {
+				params.push(b.id('$$ownership_validator'));
+				stop();
+			} else {
+				next();
+			}
+		}
+
+		walk(/** @type {Node} */ (node), null, {
+			AssignmentExpression: visit,
+			UpdateExpression: visit
+		});
+	}
+
+	return params;
+}
+
+/**
+ * @param {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression} node
+ * @param {ComponentContext} context
+ * @returns {Pattern[]}
+ */
+export function build_hoisted_params(node, context) {
+	const hoisted_params = get_hoisted_params(node, context);
+	node.metadata.hoisted_params = hoisted_params;
+
+	/** @type {Pattern[]} */
+	const params = [];
+
+	if (node.params.length === 0) {
+		if (hoisted_params.length > 0) {
+			// For the event object
+			params.push(b.id(context.state.scope.generate('_')));
+		}
+	} else {
+		for (const param of node.params) {
+			params.push(/** @type {Pattern} */ (context.visit(param)));
+		}
+	}
+
+	params.push(...hoisted_params);
+	return params;
+}
+
+/**
+ * @param {Binding} binding
+ * @param {ComponentClientTransformState} state
+ * @param {string} name
+ * @param {Expression | null} [initial]
+ * @returns
+ */
+export function get_prop_source(binding, state, name, initial) {
+	/** @type {Expression[]} */
+	const args = [b.id('$$props'), b.literal(name)];
+
+	let flags = 0;
+
+	if (binding.kind === 'bindable_prop') {
+		flags |= PROPS_IS_BINDABLE;
+	}
+
+	if (state.analysis.immutable) {
+		flags |= PROPS_IS_IMMUTABLE;
+	}
+
+	if (state.analysis.runes) {
+		flags |= PROPS_IS_RUNES;
+	}
+
+	if (
+		state.analysis.accessors ||
+		(state.analysis.immutable
+			? binding.reassigned || (state.analysis.runes && binding.mutated)
+			: binding.updated)
+	) {
+		flags |= PROPS_IS_UPDATED;
+	}
+
+	/** @type {Expression | undefined} */
+	let arg;
+
+	if (initial) {
+		// To avoid eagerly evaluating the right-hand-side, we wrap it in a thunk if necessary
+		if (is_simple_expression(initial)) {
+			arg = initial;
+		} else {
+			if (
+				initial.type === 'CallExpression' &&
+				initial.callee.type === 'Identifier' &&
+				initial.arguments.length === 0
+			) {
+				arg = initial.callee;
+			} else {
+				arg = b.thunk(initial);
+			}
+
+			flags |= PROPS_IS_LAZY_INITIAL;
+		}
+	}
+
+	if (flags || arg) {
+		args.push(b.literal(flags));
+		if (arg) args.push(arg);
+	}
+
+	return b.call('$.prop', ...args);
+}
+
+/**
+ *
+ * @param {Binding} binding
+ * @param {ClientTransformState} state
+ * @returns
+ */
+export function is_prop_source(binding, state) {
+	return (
+		(binding.kind === 'prop' || binding.kind === 'bindable_prop') &&
+		(!state.analysis.runes ||
+			state.analysis.accessors ||
+			binding.reassigned ||
+			binding.initial ||
+			// Until legacy mode is gone, we also need to use the prop source when only mutated is true,
+			// because the parent could be a legacy component which needs coarse-grained reactivity
+			binding.updated)
+	);
+}
+
+/**
+ * @param {Expression} node
+ * @param {Scope | null} scope
+ */
+export function should_proxy(node, scope) {
+	if (
+		!node ||
+		node.type === 'Literal' ||
+		node.type === 'TemplateLiteral' ||
+		node.type === 'ArrowFunctionExpression' ||
+		node.type === 'FunctionExpression' ||
+		node.type === 'UnaryExpression' ||
+		node.type === 'BinaryExpression' ||
+		(node.type === 'Identifier' && node.name === 'undefined')
+	) {
+		return false;
+	}
+
+	if (node.type === 'Identifier' && scope !== null) {
+		const binding = scope.get(node.name);
+		// Let's see if the reference is something that can be proxied
+		if (
+			binding !== null &&
+			!binding.reassigned &&
+			binding.initial !== null &&
+			binding.initial.type !== 'FunctionDeclaration' &&
+			binding.initial.type !== 'ClassDeclaration' &&
+			binding.initial.type !== 'ImportDeclaration' &&
+			binding.initial.type !== 'EachBlock' &&
+			binding.initial.type !== 'SnippetBlock'
+		) {
+			return should_proxy(binding.initial, null);
+		}
+	}
+
+	return true;
+}
+
+/**
+ * Svelte legacy mode should use safe equals in most places, runes mode shouldn't
+ * @param {ComponentClientTransformState} state
+ * @param {Expression} arg
+ */
+export function create_derived(state, arg) {
+	return b.call(state.analysis.runes ? '$.derived' : '$.derived_safe_equal', arg);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AnimateDirective.js

@@ -0,0 +1,28 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+import * as b from '../../../../utils/builders.js';
+import { parse_directive_name } from './shared/utils.js';
+
+/**
+ * @param {AST.AnimateDirective} node
+ * @param {ComponentContext} context
+ */
+export function AnimateDirective(node, context) {
+	const expression =
+		node.expression === null
+			? b.null
+			: b.thunk(/** @type {Expression} */ (context.visit(node.expression)));
+
+	// in after_update to ensure it always happens after bind:this
+	context.state.after_update.push(
+		b.stmt(
+			b.call(
+				'$.animation',
+				context.state.node,
+				b.thunk(/** @type {Expression} */ (context.visit(parse_directive_name(node.name)))),
+				expression
+			)
+		)
+	);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/ArrowFunctionExpression.js

@@ -0,0 +1,11 @@
+/** @import { ArrowFunctionExpression } from 'estree' */
+/** @import { ComponentContext } from '../types' */
+import { visit_function } from './shared/function.js';
+
+/**
+ * @param {ArrowFunctionExpression} node
+ * @param {ComponentContext} context
+ */
+export function ArrowFunctionExpression(node, context) {
+	return visit_function(node, context);
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js

@@ -0,0 +1,195 @@
+/** @import { AssignmentExpression, AssignmentOperator, Expression, Identifier, Pattern } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types.js' */
+import * as b from '../../../../utils/builders.js';
+import {
+	build_assignment_value,
+	get_attribute_expression,
+	is_event_attribute
+} from '../../../../utils/ast.js';
+import { dev, locate_node } from '../../../../state.js';
+import { should_proxy } from '../utils.js';
+import { visit_assignment_expression } from '../../shared/assignments.js';
+import { validate_mutation } from './shared/utils.js';
+
+/**
+ * @param {AssignmentExpression} node
+ * @param {Context} context
+ */
+export function AssignmentExpression(node, context) {
+	const expression = /** @type {Expression} */ (
+		visit_assignment_expression(node, context, build_assignment) ?? context.next()
+	);
+
+	return validate_mutation(node, context, expression);
+}
+
+/**
+ * Determines whether the value will be coerced on assignment (as with e.g. `+=`).
+ * If not, we may need to proxify the value, or warn that the value will not be
+ * proxified in time
+ * @param {AssignmentOperator} operator
+ */
+function is_non_coercive_operator(operator) {
+	return ['=', '||=', '&&=', '??='].includes(operator);
+}
+
+/** @type {Record<string, string>} */
+const callees = {
+	'=': '$.assign',
+	'&&=': '$.assign_and',
+	'||=': '$.assign_or',
+	'??=': '$.assign_nullish'
+};
+
+/**
+ * @param {AssignmentOperator} operator
+ * @param {Pattern} left
+ * @param {Expression} right
+ * @param {Context} context
+ * @returns {Expression | null}
+ */
+function build_assignment(operator, left, right, context) {
+	// Handle class private/public state assignment cases
+	if (
+		context.state.analysis.runes &&
+		left.type === 'MemberExpression' &&
+		left.property.type === 'PrivateIdentifier'
+	) {
+		const private_state = context.state.private_state.get(left.property.name);
+
+		if (private_state !== undefined) {
+			let value = /** @type {Expression} */ (
+				context.visit(build_assignment_value(operator, left, right))
+			);
+
+			const needs_proxy =
+				private_state.kind === 'state' &&
+				is_non_coercive_operator(operator) &&
+				should_proxy(value, context.state.scope);
+
+			return b.call('$.set', left, value, needs_proxy && b.true);
+		}
+	}
+
+	let object = left;
+
+	while (object.type === 'MemberExpression') {
+		// @ts-expect-error
+		object = object.object;
+	}
+
+	if (object.type !== 'Identifier') {
+		return null;
+	}
+
+	const binding = context.state.scope.get(object.name);
+	if (!binding) return null;
+
+	const transform = Object.hasOwn(context.state.transform, object.name)
+		? context.state.transform[object.name]
+		: null;
+
+	const path = context.path.map((node) => node.type);
+
+	// reassignment
+	if (object === left && transform?.assign) {
+		// special case — if an element binding, we know it's a primitive
+
+		const is_primitive = path.at(-1) === 'BindDirective' && path.at(-2) === 'RegularElement';
+
+		let value = /** @type {Expression} */ (
+			context.visit(build_assignment_value(operator, left, right))
+		);
+
+		return transform.assign(
+			object,
+			value,
+			!is_primitive &&
+				binding.kind !== 'prop' &&
+				binding.kind !== 'bindable_prop' &&
+				binding.kind !== 'raw_state' &&
+				binding.kind !== 'store_sub' &&
+				context.state.analysis.runes &&
+				should_proxy(right, context.state.scope) &&
+				is_non_coercive_operator(operator)
+		);
+	}
+
+	// mutation
+	if (transform?.mutate) {
+		return transform.mutate(
+			object,
+			b.assignment(
+				operator,
+				/** @type {Pattern} */ (context.visit(left)),
+				/** @type {Expression} */ (context.visit(right))
+			)
+		);
+	}
+
+	// in cases like `(object.items ??= []).push(value)`, we may need to warn
+	// if the value gets proxified, since the proxy _isn't_ the thing that
+	// will be pushed to. we do this by transforming it to something like
+	// `$.assign_nullish(object, 'items', [])`
+	let should_transform =
+		dev && path.at(-1) !== 'ExpressionStatement' && is_non_coercive_operator(operator);
+
+	// special case — ignore `onclick={() => (...)}`
+	if (
+		path.at(-1) === 'ArrowFunctionExpression' &&
+		(path.at(-2) === 'RegularElement' || path.at(-2) === 'SvelteElement')
+	) {
+		const element = /** @type {AST.RegularElement} */ (context.path.at(-2));
+
+		const attribute = element.attributes.find((attribute) => {
+			if (attribute.type !== 'Attribute' || !is_event_attribute(attribute)) {
+				return false;
+			}
+
+			const expression = get_attribute_expression(attribute);
+
+			return expression === context.path.at(-1);
+		});
+
+		if (attribute) {
+			should_transform = false;
+		}
+	}
+
+	// special case — ignore `bind:prop={getter, (v) => (...)}` / `bind:value={x.y}`
+	if (
+		path.at(-1) === 'BindDirective' ||
+		path.at(-1) === 'Component' ||
+		path.at(-1) === 'SvelteComponent' ||
+		(path.at(-1) === 'ArrowFunctionExpression' &&
+			path.at(-2) === 'SequenceExpression' &&
+			(path.at(-3) === 'Component' ||
+				path.at(-3) === 'SvelteComponent' ||
+				path.at(-3) === 'BindDirective'))
+	) {
+		should_transform = false;
+	}
+
+	if (left.type === 'MemberExpression' && should_transform) {
+		const callee = callees[operator];
+
+		return /** @type {Expression} */ (
+			context.visit(
+				b.call(
+					callee,
+					/** @type {Expression} */ (left.object),
+					/** @type {Expression} */ (
+						left.computed
+							? left.property
+							: b.literal(/** @type {Identifier} */ (left.property).name)
+					),
+					right,
+					b.literal(locate_node(left))
+				)
+			)
+		);
+	}
+
+	return null;
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/Attribute.js

@@ -0,0 +1,14 @@
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+import { is_event_attribute } from '../../../../utils/ast.js';
+import { visit_event_attribute } from './shared/events.js';
+
+/**
+ * @param {AST.Attribute} node
+ * @param {ComponentContext} context
+ */
+export function Attribute(node, context) {
+	if (is_event_attribute(node)) {
+		visit_event_attribute(node, context);
+	}
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AwaitBlock.js

@@ -0,0 +1,104 @@
+/** @import { BlockStatement, Expression, Pattern, Statement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentClientTransformState, ComponentContext } from '../types' */
+import { extract_identifiers } from '../../../../utils/ast.js';
+import * as b from '../../../../utils/builders.js';
+import { create_derived } from '../utils.js';
+import { get_value } from './shared/declarations.js';
+
+/**
+ * @param {AST.AwaitBlock} node
+ * @param {ComponentContext} context
+ */
+export function AwaitBlock(node, context) {
+	context.state.template.push('<!>');
+
+	// Visit {#await <expression>} first to ensure that scopes are in the correct order
+	const expression = b.thunk(/** @type {Expression} */ (context.visit(node.expression)));
+
+	let then_block;
+	let catch_block;
+
+	if (node.then) {
+		const then_context = {
+			...context,
+			state: { ...context.state, transform: { ...context.state.transform } }
+		};
+		const argument = node.value && create_derived_block_argument(node.value, then_context);
+
+		/** @type {Pattern[]} */
+		const args = [b.id('$$anchor')];
+		if (argument) args.push(argument.id);
+
+		const declarations = argument?.declarations ?? [];
+		const block = /** @type {BlockStatement} */ (then_context.visit(node.then, then_context.state));
+
+		then_block = b.arrow(args, b.block([...declarations, ...block.body]));
+	}
+
+	if (node.catch) {
+		const catch_context = { ...context, state: { ...context.state } };
+		const argument = node.error && create_derived_block_argument(node.error, catch_context);
+
+		/** @type {Pattern[]} */
+		const args = [b.id('$$anchor')];
+		if (argument) args.push(argument.id);
+
+		const declarations = argument?.declarations ?? [];
+		const block = /** @type {BlockStatement} */ (
+			catch_context.visit(node.catch, catch_context.state)
+		);
+
+		catch_block = b.arrow(args, b.block([...declarations, ...block.body]));
+	}
+
+	context.state.init.push(
+		b.stmt(
+			b.call(
+				'$.await',
+				context.state.node,
+				expression,
+				node.pending
+					? b.arrow([b.id('$$anchor')], /** @type {BlockStatement} */ (context.visit(node.pending)))
+					: b.null,
+				then_block,
+				catch_block
+			)
+		)
+	);
+}
+
+/**
+ * @param {Pattern} node
+ * @param {import('zimmerframe').Context<AST.SvelteNode, ComponentClientTransformState>} context
+ * @returns {{ id: Pattern, declarations: null | Statement[] }}
+ */
+function create_derived_block_argument(node, context) {
+	if (node.type === 'Identifier') {
+		context.state.transform[node.name] = { read: get_value };
+		return { id: node, declarations: null };
+	}
+
+	const pattern = /** @type {Pattern} */ (context.visit(node));
+	const identifiers = extract_identifiers(node);
+
+	const id = b.id('$$source');
+	const value = b.id('$$value');
+
+	const block = b.block([
+		b.var(pattern, b.call('$.get', id)),
+		b.return(b.object(identifiers.map((identifier) => b.prop('init', identifier, identifier))))
+	]);
+
+	const declarations = [b.var(value, create_derived(context.state, b.thunk(block)))];
+
+	for (const id of identifiers) {
+		context.state.transform[id.name] = { read: get_value };
+
+		declarations.push(
+			b.var(id, create_derived(context.state, b.thunk(b.member(b.call('$.get', value), id))))
+		);
+	}
+
+	return { id, declarations };
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/BinaryExpression.js

@@ -0,0 +1,34 @@
+/** @import { Expression, BinaryExpression } from 'estree' */
+/** @import { ComponentContext } from '../types' */
+import { dev } from '../../../../state.js';
+import * as b from '../../../../utils/builders.js';
+
+/**
+ * @param {BinaryExpression} node
+ * @param {ComponentContext} context
+ */
+export function BinaryExpression(node, context) {
+	if (dev) {
+		const operator = node.operator;
+
+		if (operator === '===' || operator === '!==') {
+			return b.call(
+				'$.strict_equals',
+				/** @type {Expression} */ (context.visit(node.left)),
+				/** @type {Expression} */ (context.visit(node.right)),
+				operator === '!==' && b.false
+			);
+		}
+
+		if (operator === '==' || operator === '!=') {
+			return b.call(
+				'$.equals',
+				/** @type {Expression} */ (context.visit(node.left)),
+				/** @type {Expression} */ (context.visit(node.right)),
+				operator === '!=' && b.false
+			);
+		}
+	}
+
+	context.next();
+}