svelte-on-rails 0.0.30 → 0.0.31

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

@@ -1,296 +0,0 @@
-/** @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/svelte_on_rails/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AnimateDirective.js

@@ -1,28 +0,0 @@
-/** @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/svelte_on_rails/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/ArrowFunctionExpression.js

@@ -1,11 +0,0 @@
-/** @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/svelte_on_rails/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js

@@ -1,195 +0,0 @@
-/** @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/svelte_on_rails/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/Attribute.js

@@ -1,14 +0,0 @@
-/** @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/svelte_on_rails/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AwaitBlock.js

@@ -1,104 +0,0 @@
-/** @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/svelte_on_rails/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/BinaryExpression.js

@@ -1,34 +0,0 @@
-/** @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();
-}