lumen-plus 0.0.3 → 0.0.4

package/dist/utils/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AssignmentExpression.js

@@ -0,0 +1,225 @@
+/** @import { AssignmentExpression, AssignmentOperator, Expression, Identifier, Pattern } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types.js' */
+import * as b from '#compiler/builders';
+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';
+import { get_rune } from '../../../scope.js';
+import { get_name } from '../../../nodes.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) {
+	if (context.state.analysis.runes && left.type === 'MemberExpression') {
+		const name = get_name(left.property);
+		const field = name && context.state.state_fields.get(name);
+
+		if (field) {
+			// special case — state declaration in class constructor
+			if (field.node.type === 'AssignmentExpression' && left === field.node.left) {
+				const rune = get_rune(right, context.state.scope);
+
+				if (rune) {
+					const child_state = {
+						...context.state,
+						in_constructor: rune !== '$derived' && rune !== '$derived.by'
+					};
+
+					let value = /** @type {Expression} */ (context.visit(right, child_state));
+
+					if (dev) {
+						const declaration = context.path.findLast(
+							(parent) => parent.type === 'ClassDeclaration' || parent.type === 'ClassExpression'
+						);
+						value = b.call(
+							'$.tag',
+							value,
+							b.literal(`${declaration?.id?.name ?? '[class]'}.${name}`)
+						);
+					}
+
+					return b.assignment(operator, b.member(b.this, field.key), value);
+				}
+			}
+
+			// special case — assignment to private state field
+			if (left.property.type === 'PrivateIdentifier') {
+				let value = /** @type {Expression} */ (
+					context.visit(build_assignment_value(operator, left, right))
+				);
+
+				const needs_proxy =
+					field.type === '$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 !== 'derived' &&
+				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) === 'BindDirective' ||
+				(path.at(-2) === 'Component' && path.at(-3) === 'Fragment') ||
+				(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;
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AttachTag.js

@@ -0,0 +1,26 @@
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+import * as b from '../../../../utils/builders.js';
+import { build_expression } from './shared/utils.js';
+
+/**
+ * @param {AST.AttachTag} node
+ * @param {ComponentContext} context
+ */
+export function AttachTag(node, context) {
+	const expression = build_expression(context, node.expression, node.metadata.expression);
+	let statement = b.stmt(b.call('$.attach', context.state.node, b.thunk(expression)));
+
+	if (node.metadata.expression.is_async()) {
+		statement = b.stmt(
+			b.call(
+				'$.run_after_blockers',
+				node.metadata.expression.blockers(),
+				b.thunk(b.block([statement]))
+			)
+		);
+	}
+
+	context.state.init.push(statement);
+	context.next();
+}

package/dist/utils/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);
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AwaitBlock.js

@@ -0,0 +1,124 @@
+/** @import { BlockStatement, Pattern, Statement } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentClientTransformState, ComponentContext } from '../types' */
+import { extract_identifiers, is_expression_async } from '../../../../utils/ast.js';
+import * as b from '#compiler/builders';
+import { create_derived } from '../utils.js';
+import { get_value } from './shared/declarations.js';
+import { build_expression, add_svelte_meta } from './shared/utils.js';
+
+/**
+ * @param {AST.AwaitBlock} node
+ * @param {ComponentContext} context
+ */
+export function AwaitBlock(node, context) {
+	context.state.template.push_comment();
+
+	// Visit {#await <expression>} first to ensure that scopes are in the correct order
+	const expression = b.thunk(
+		build_expression(context, node.expression, node.metadata.expression),
+		node.metadata.expression.has_await
+	);
+
+	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]));
+	}
+
+	const stmt = add_svelte_meta(
+		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
+		),
+		node,
+		'await'
+	);
+
+	if (node.metadata.expression.has_blockers()) {
+		context.state.init.push(
+			b.stmt(
+				b.call(
+					'$.async',
+					context.state.node,
+					node.metadata.expression.blockers(),
+					b.array([]),
+					b.arrow([context.state.node], b.block([stmt]))
+				)
+			)
+		);
+	} else {
+		context.state.init.push(stmt);
+	}
+}
+
+/**
+ * @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, block))];
+
+	for (const id of identifiers) {
+		context.state.transform[id.name] = { read: get_value };
+
+		declarations.push(
+			b.var(id, create_derived(context.state, b.member(b.call('$.get', value), id)))
+		);
+	}
+
+	return { id, declarations };
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/3-transform/client/visitors/AwaitExpression.js

@@ -0,0 +1,25 @@
+/** @import { AwaitExpression, Expression } from 'estree' */
+/** @import { Context } from '../types' */
+import { dev, is_ignored } from '../../../../state.js';
+import { save } from '../../../../utils/ast.js';
+import * as b from '../../../../utils/builders.js';
+
+/**
+ * @param {AwaitExpression} node
+ * @param {Context} context
+ */
+export function AwaitExpression(node, context) {
+	const argument = /** @type {Expression} */ (context.visit(node.argument));
+
+	if (context.state.analysis.pickled_awaits.has(node)) {
+		return save(argument);
+	}
+
+	// in dev, note which values are read inside a reactive expression,
+	// but don't track them
+	else if (dev && !is_ignored(node, 'await_reactivity_loss')) {
+		return b.call(b.await(b.call('$.track_reactivity_loss', argument)));
+	}
+
+	return argument === node.argument ? node : { ...node, argument };
+}

package/dist/utils/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 '#compiler/builders';
+
+/**
+ * @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();
+}