svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/2-analyze/utils/check_graph_for_cycles.js

@@ -0,0 +1,46 @@
+/**
+ * @template T
+ * @param {Array<[T, T]>} edges
+ * @returns {Array<T>|undefined}
+ */
+export default function check_graph_for_cycles(edges) {
+	/** @type {Map<T, T[]>} */
+	const graph = edges.reduce((g, edge) => {
+		const [u, v] = edge;
+		if (!g.has(u)) g.set(u, []);
+		if (!g.has(v)) g.set(v, []);
+		g.get(u).push(v);
+		return g;
+	}, new Map());
+
+	const visited = new Set();
+	const on_stack = new Set();
+	/** @type {Array<Array<T>>} */
+	const cycles = [];
+
+	/**
+	 * @param {T} v
+	 */
+	function visit(v) {
+		visited.add(v);
+		on_stack.add(v);
+
+		graph.get(v)?.forEach((w) => {
+			if (!visited.has(w)) {
+				visit(w);
+			} else if (on_stack.has(w)) {
+				cycles.push([...on_stack, w]);
+			}
+		});
+
+		on_stack.delete(v);
+	}
+
+	graph.forEach((_, v) => {
+		if (!visited.has(v)) {
+			visit(v);
+		}
+	});
+
+	return cycles[0];
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/2-analyze/visitors/ArrowFunctionExpression.js

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

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js

@@ -0,0 +1,27 @@
+/** @import { AssignmentExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import { extract_identifiers, object } from '../../../utils/ast.js';
+import { validate_assignment } from './shared/utils.js';
+
+/**
+ * @param {AssignmentExpression} node
+ * @param {Context} context
+ */
+export function AssignmentExpression(node, context) {
+	validate_assignment(node, node.left, context.state);
+
+	if (context.state.reactive_statement) {
+		const id = node.left.type === 'MemberExpression' ? object(node.left) : node.left;
+		if (id !== null) {
+			for (const id of extract_identifiers(node.left)) {
+				const binding = context.state.scope.get(id.name);
+
+				if (binding) {
+					context.state.reactive_statement.assignments.add(binding);
+				}
+			}
+		}
+	}
+
+	context.next();
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/2-analyze/visitors/Attribute.js

@@ -0,0 +1,239 @@
+/** @import { ArrowFunctionExpression, Expression, FunctionDeclaration, FunctionExpression } from 'estree' */
+/** @import { AST, DelegatedEvent } from '#compiler' */
+/** @import { Context } from '../types' */
+import { cannot_be_set_statically, is_capture_event, is_delegated } from '../../../../utils.js';
+import {
+	get_attribute_chunks,
+	get_attribute_expression,
+	is_event_attribute
+} from '../../../utils/ast.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.Attribute} node
+ * @param {Context} context
+ */
+export function Attribute(node, context) {
+	context.next();
+
+	const parent = /** @type {AST.SvelteNode} */ (context.path.at(-1));
+
+	if (parent.type === 'RegularElement') {
+		// special case <option value="" />
+		if (node.name === 'value' && parent.name === 'option') {
+			mark_subtree_dynamic(context.path);
+		}
+	}
+
+	if (is_event_attribute(node)) {
+		mark_subtree_dynamic(context.path);
+	}
+
+	if (cannot_be_set_statically(node.name)) {
+		mark_subtree_dynamic(context.path);
+	}
+
+	// class={[...]} or class={{...}} or `class={x}` need clsx to resolve the classes
+	if (
+		node.name === 'class' &&
+		!Array.isArray(node.value) &&
+		node.value !== true &&
+		node.value.expression.type !== 'Literal' &&
+		node.value.expression.type !== 'TemplateLiteral' &&
+		node.value.expression.type !== 'BinaryExpression'
+	) {
+		mark_subtree_dynamic(context.path);
+		node.metadata.needs_clsx = true;
+	}
+
+	if (node.value !== true) {
+		for (const chunk of get_attribute_chunks(node.value)) {
+			if (chunk.type !== 'ExpressionTag') continue;
+
+			if (
+				chunk.expression.type === 'FunctionExpression' ||
+				chunk.expression.type === 'ArrowFunctionExpression'
+			) {
+				continue;
+			}
+		}
+
+		if (is_event_attribute(node)) {
+			const parent = context.path.at(-1);
+			if (parent?.type === 'RegularElement' || parent?.type === 'SvelteElement') {
+				context.state.analysis.uses_event_attributes = true;
+			}
+
+			const expression = get_attribute_expression(node);
+			const delegated_event = get_delegated_event(node.name.slice(2), expression, context);
+
+			if (delegated_event !== null) {
+				if (delegated_event.hoisted) {
+					delegated_event.function.metadata.hoisted = true;
+				}
+
+				node.metadata.delegated = delegated_event;
+			}
+		}
+	}
+}
+
+/** @type {DelegatedEvent} */
+const unhoisted = { hoisted: false };
+
+/**
+ * Checks if given event attribute can be delegated/hoisted and returns the corresponding info if so
+ * @param {string} event_name
+ * @param {Expression | null} handler
+ * @param {Context} context
+ * @returns {null | DelegatedEvent}
+ */
+function get_delegated_event(event_name, handler, context) {
+	// Handle delegated event handlers. Bail out if not a delegated event.
+	if (!handler || !is_delegated(event_name)) {
+		return null;
+	}
+
+	// If we are not working with a RegularElement, then bail out.
+	const element = context.path.at(-1);
+	if (element?.type !== 'RegularElement') {
+		return null;
+	}
+
+	/** @type {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression | null} */
+	let target_function = null;
+	let binding = null;
+
+	if (element.metadata.has_spread) {
+		// event attribute becomes part of the dynamic spread array
+		return unhoisted;
+	}
+
+	if (handler.type === 'ArrowFunctionExpression' || handler.type === 'FunctionExpression') {
+		target_function = handler;
+	} else if (handler.type === 'Identifier') {
+		binding = context.state.scope.get(handler.name);
+
+		if (context.state.analysis.module.scope.references.has(handler.name)) {
+			// If a binding with the same name is referenced in the module scope (even if not declared there), bail out
+			return unhoisted;
+		}
+
+		if (binding != null) {
+			for (const { path } of binding.references) {
+				const parent = path.at(-1);
+				if (parent === undefined) return unhoisted;
+
+				const grandparent = path.at(-2);
+
+				/** @type {AST.RegularElement | null} */
+				let element = null;
+				/** @type {string | null} */
+				let event_name = null;
+				if (parent.type === 'OnDirective') {
+					element = /** @type {AST.RegularElement} */ (grandparent);
+					event_name = parent.name;
+				} else if (
+					parent.type === 'ExpressionTag' &&
+					grandparent?.type === 'Attribute' &&
+					is_event_attribute(grandparent)
+				) {
+					element = /** @type {AST.RegularElement} */ (path.at(-3));
+					const attribute = /** @type {AST.Attribute} */ (grandparent);
+					event_name = get_attribute_event_name(attribute.name);
+				}
+
+				if (element && event_name) {
+					if (
+						element.type !== 'RegularElement' ||
+						element.metadata.has_spread ||
+						!is_delegated(event_name)
+					) {
+						return unhoisted;
+					}
+				} else if (parent.type !== 'FunctionDeclaration' && parent.type !== 'VariableDeclarator') {
+					return unhoisted;
+				}
+			}
+		}
+
+		// If the binding is exported, bail out
+		if (context.state.analysis.exports.find((node) => node.name === handler.name)) {
+			return unhoisted;
+		}
+
+		if (binding?.is_function()) {
+			target_function = binding.initial;
+		}
+	}
+
+	// If we can't find a function, or the function has multiple parameters, bail out
+	if (target_function == null || target_function.params.length > 1) {
+		return unhoisted;
+	}
+
+	const visited_references = new Set();
+	const scope = target_function.metadata.scope;
+	for (const [reference] of scope.references) {
+		// Bail out if the arguments keyword is used or $host is referenced
+		if (reference === 'arguments' || reference === '$host') return unhoisted;
+		// Bail out if references a store subscription
+		if (scope.get(`$${reference}`)?.kind === 'store_sub') return unhoisted;
+
+		const binding = scope.get(reference);
+		const local_binding = context.state.scope.get(reference);
+
+		// if the function access a snippet that can't be hoisted we bail out
+		if (
+			local_binding !== null &&
+			local_binding.initial?.type === 'SnippetBlock' &&
+			!local_binding.initial.metadata.can_hoist
+		) {
+			return unhoisted;
+		}
+
+		// If we are referencing a binding that is shadowed in another scope then bail out.
+		if (local_binding !== null && binding !== null && local_binding.node !== binding.node) {
+			return unhoisted;
+		}
+
+		// If we have multiple references to the same store using $ prefix, bail out.
+		if (
+			binding !== null &&
+			binding.kind === 'store_sub' &&
+			visited_references.has(reference.slice(1))
+		) {
+			return unhoisted;
+		}
+
+		// If we reference the index within an each block, then bail out.
+		if (binding !== null && binding.initial?.type === 'EachBlock') return unhoisted;
+
+		if (
+			binding !== null &&
+			// Bail out if the the binding is a rest param
+			(binding.declaration_kind === 'rest_param' ||
+				// Bail out if we reference anything from the EachBlock (for now) that mutates in non-runes mode,
+				(((!context.state.analysis.runes && binding.kind === 'each') ||
+					// or any normal not reactive bindings that are mutated.
+					binding.kind === 'normal') &&
+					binding.updated))
+		) {
+			return unhoisted;
+		}
+		visited_references.add(reference);
+	}
+
+	return { hoisted: true, function: target_function };
+}
+
+/**
+ * @param {string} event_name
+ */
+function get_attribute_event_name(event_name) {
+	event_name = event_name.slice(2);
+	if (is_capture_event(event_name)) {
+		event_name = event_name.slice(0, -7);
+	}
+	return event_name;
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/2-analyze/visitors/AwaitBlock.js

@@ -0,0 +1,45 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+import * as e from '../../../errors.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.AwaitBlock} node
+ * @param {Context} context
+ */
+export function AwaitBlock(node, context) {
+	validate_block_not_empty(node.pending, context);
+	validate_block_not_empty(node.then, context);
+	validate_block_not_empty(node.catch, context);
+
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '#');
+
+		if (node.value) {
+			const start = /** @type {number} */ (node.value.start);
+			const match = context.state.analysis.source
+				.substring(start - 10, start)
+				.match(/{(\s*):then\s+$/);
+
+			if (match && match[1] !== '') {
+				e.block_unexpected_character({ start: start - 10, end: start }, ':');
+			}
+		}
+
+		if (node.error) {
+			const start = /** @type {number} */ (node.error.start);
+			const match = context.state.analysis.source
+				.substring(start - 10, start)
+				.match(/{(\s*):catch\s+$/);
+
+			if (match && match[1] !== '') {
+				e.block_unexpected_character({ start: start - 10, end: start }, ':');
+			}
+		}
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	context.next();
+}

data/lib/mount_svelte/node_modules/svelte/src/compiler/phases/2-analyze/visitors/BindDirective.js

@@ -0,0 +1,254 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import {
+	extract_all_identifiers_from_expression,
+	is_text_attribute,
+	object
+} from '../../../utils/ast.js';
+import { validate_assignment } from './shared/utils.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import { binding_properties } from '../../bindings.js';
+import fuzzymatch from '../../1-parse/utils/fuzzymatch.js';
+import { is_content_editable_binding, is_svg } from '../../../../utils.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.BindDirective} node
+ * @param {Context} context
+ */
+export function BindDirective(node, context) {
+	const parent = context.path.at(-1);
+
+	if (
+		parent?.type === 'RegularElement' ||
+		parent?.type === 'SvelteElement' ||
+		parent?.type === 'SvelteWindow' ||
+		parent?.type === 'SvelteDocument' ||
+		parent?.type === 'SvelteBody'
+	) {
+		if (node.name in binding_properties) {
+			const property = binding_properties[node.name];
+			if (property.valid_elements && !property.valid_elements.includes(parent.name)) {
+				e.bind_invalid_target(
+					node,
+					node.name,
+					property.valid_elements.map((valid_element) => `<${valid_element}>`).join(', ')
+				);
+			}
+
+			if (property.invalid_elements && property.invalid_elements.includes(parent.name)) {
+				const valid_bindings = Object.entries(binding_properties)
+					.filter(([_, binding_property]) => {
+						return (
+							binding_property.valid_elements?.includes(parent.name) ||
+							(!binding_property.valid_elements &&
+								!binding_property.invalid_elements?.includes(parent.name))
+						);
+					})
+					.map(([property_name]) => property_name)
+					.sort();
+
+				e.bind_invalid_name(
+					node,
+					node.name,
+					`Possible bindings for <${parent.name}> are ${valid_bindings.join(', ')}`
+				);
+			}
+
+			if (parent.name === 'input' && node.name !== 'this') {
+				const type = /** @type {AST.Attribute | undefined} */ (
+					parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'type')
+				);
+
+				if (type && !is_text_attribute(type)) {
+					if (node.name !== 'value' || type.value === true) {
+						e.attribute_invalid_type(type);
+					}
+				} else {
+					if (node.name === 'checked' && type?.value[0].data !== 'checkbox') {
+						e.bind_invalid_target(node, node.name, '<input type="checkbox">');
+					}
+
+					if (node.name === 'files' && type?.value[0].data !== 'file') {
+						e.bind_invalid_target(node, node.name, '<input type="file">');
+					}
+				}
+			}
+
+			if (parent.name === 'select' && node.name !== 'this') {
+				const multiple = parent.attributes.find(
+					(a) =>
+						a.type === 'Attribute' &&
+						a.name === 'multiple' &&
+						!is_text_attribute(a) &&
+						a.value !== true
+				);
+
+				if (multiple) {
+					e.attribute_invalid_multiple(multiple);
+				}
+			}
+
+			if (node.name === 'offsetWidth' && is_svg(parent.name)) {
+				e.bind_invalid_target(
+					node,
+					node.name,
+					`non-<svg> elements. Use 'clientWidth' for <svg> instead`
+				);
+			}
+
+			if (is_content_editable_binding(node.name)) {
+				const contenteditable = /** @type {AST.Attribute} */ (
+					parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'contenteditable')
+				);
+
+				if (!contenteditable) {
+					e.attribute_contenteditable_missing(node);
+				} else if (!is_text_attribute(contenteditable) && contenteditable.value !== true) {
+					e.attribute_contenteditable_dynamic(contenteditable);
+				}
+			}
+		} else {
+			const match = fuzzymatch(node.name, Object.keys(binding_properties));
+
+			if (match) {
+				const property = binding_properties[match];
+				if (!property.valid_elements || property.valid_elements.includes(parent.name)) {
+					e.bind_invalid_name(node, node.name, `Did you mean '${match}'?`);
+				}
+			}
+
+			e.bind_invalid_name(node, node.name);
+		}
+	}
+
+	// When dealing with bind getters/setters skip the specific binding validation
+	// Group bindings aren't supported for getter/setters so we don't need to handle
+	// the metadata
+	if (node.expression.type === 'SequenceExpression') {
+		if (node.name === 'group') {
+			e.bind_group_invalid_expression(node);
+		}
+
+		let i = /** @type {number} */ (node.expression.start);
+		let leading_comments_start = /**@type {any}*/ (node.expression.leadingComments?.at(0))?.start;
+		let leading_comments_end = /**@type {any}*/ (node.expression.leadingComments?.at(-1))?.end;
+		while (context.state.analysis.source[--i] !== '{') {
+			if (
+				context.state.analysis.source[i] === '(' &&
+				// if the parenthesis is in a leading comment we don't need to throw the error
+				!(
+					leading_comments_start &&
+					leading_comments_end &&
+					i <= leading_comments_end &&
+					i >= leading_comments_start
+				)
+			) {
+				e.bind_invalid_parens(node, node.name);
+			}
+		}
+
+		if (node.expression.expressions.length !== 2) {
+			e.bind_invalid_expression(node);
+		}
+
+		mark_subtree_dynamic(context.path);
+
+		return;
+	}
+
+	validate_assignment(node, node.expression, context.state);
+
+	const assignee = node.expression;
+	const left = object(assignee);
+
+	if (left === null) {
+		e.bind_invalid_expression(node);
+	}
+
+	const binding = context.state.scope.get(left.name);
+
+	if (assignee.type === 'Identifier') {
+		// reassignment
+		if (
+			node.name !== 'this' && // bind:this also works for regular variables
+			(!binding ||
+				(binding.kind !== 'state' &&
+					binding.kind !== 'raw_state' &&
+					binding.kind !== 'prop' &&
+					binding.kind !== 'bindable_prop' &&
+					binding.kind !== 'each' &&
+					binding.kind !== 'store_sub' &&
+					!binding.updated)) // TODO wut?
+		) {
+			e.bind_invalid_value(node.expression);
+		}
+	}
+
+	if (node.name === 'group') {
+		if (!binding) {
+			throw new Error('Cannot find declaration for bind:group');
+		}
+
+		if (binding.kind === 'snippet') {
+			e.bind_group_invalid_snippet_parameter(node);
+		}
+
+		// Traverse the path upwards and find all EachBlocks who are (indirectly) contributing to bind:group,
+		// i.e. one of their declarations is referenced in the binding. This allows group bindings to work
+		// correctly when referencing a variable declared in an EachBlock by using the index of the each block
+		// entries as keys.
+		const each_blocks = [];
+		const [keypath, expression_ids] = extract_all_identifiers_from_expression(node.expression);
+		let ids = expression_ids;
+
+		let i = context.path.length;
+		while (i--) {
+			const parent = context.path[i];
+
+			if (parent.type === 'EachBlock') {
+				const references = ids.filter((id) => parent.metadata.declarations.has(id.name));
+
+				if (references.length > 0) {
+					parent.metadata.contains_group_binding = true;
+
+					each_blocks.push(parent);
+					ids = ids.filter((id) => !references.includes(id));
+					ids.push(...extract_all_identifiers_from_expression(parent.expression)[1]);
+				}
+			}
+		}
+
+		// The identifiers that make up the binding expression form they key for the binding group.
+		// If the same identifiers in the same order are used in another bind:group, they will be in the same group.
+		// (there's an edge case where `bind:group={a[i]}` will be in a different group than `bind:group={a[j]}` even when i == j,
+		//  but this is a limitation of the current static analysis we do; it also never worked in Svelte 4)
+		const bindings = expression_ids.map((id) => context.state.scope.get(id.name));
+		let group_name;
+
+		outer: for (const [[key, b], group] of context.state.analysis.binding_groups) {
+			if (b.length !== bindings.length || key !== keypath) continue;
+			for (let i = 0; i < bindings.length; i++) {
+				if (bindings[i] !== b[i]) continue outer;
+			}
+			group_name = group;
+		}
+
+		if (!group_name) {
+			group_name = context.state.scope.root.unique('binding_group');
+			context.state.analysis.binding_groups.set([keypath, bindings], group_name);
+		}
+
+		node.metadata = {
+			binding_group_name: group_name,
+			parent_each_blocks: each_blocks
+		};
+	}
+
+	if (binding?.kind === 'each' && binding.metadata?.inside_rest) {
+		w.bind_invalid_each_rest(binding.node, binding.node.name);
+	}
+
+	context.next();
+}