lumen-plus 0.0.4 → 0.0.5

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

@@ -1,225 +0,0 @@
-/** @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

@@ -1,26 +0,0 @@
-/** @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

@@ -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);
-	}
-}

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

@@ -1,124 +0,0 @@
-/** @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

@@ -1,25 +0,0 @@
-/** @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

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