lumen-plus 0.0.3 → 0.0.4

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

@@ -0,0 +1,290 @@
+/** @import { CallExpression, Expression, Pattern } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+import { dev, is_ignored } from '../../../../state.js';
+import { is_text_attribute } from '../../../../utils/ast.js';
+import * as b from '#compiler/builders';
+import { binding_properties } from '../../../bindings.js';
+import { build_attribute_value } from './shared/element.js';
+import { build_bind_this, validate_binding } from './shared/utils.js';
+
+/**
+ * @param {AST.BindDirective} node
+ * @param {ComponentContext} context
+ */
+export function BindDirective(node, context) {
+	const expression = /** @type {Expression} */ (context.visit(node.expression));
+	const property = binding_properties[node.name];
+
+	const parent = /** @type {AST.SvelteNode} */ (context.path.at(-1));
+
+	let get, set;
+
+	if (expression.type === 'SequenceExpression') {
+		[get, set] = expression.expressions;
+	} else {
+		if (
+			dev &&
+			context.state.analysis.runes &&
+			expression.type === 'MemberExpression' &&
+			(node.name !== 'this' ||
+				context.path.some(
+					({ type }) =>
+						type === 'IfBlock' ||
+						type === 'EachBlock' ||
+						type === 'AwaitBlock' ||
+						type === 'KeyBlock'
+				)) &&
+			!is_ignored(node, 'binding_property_non_reactive')
+		) {
+			validate_binding(context.state, node, expression);
+		}
+
+		const assignment = /** @type {Expression} */ (
+			context.visit(b.assignment('=', /** @type {Pattern} */ (node.expression), b.id('$$value')))
+		);
+
+		if (dev) {
+			// in dev, create named functions, so that `$inspect(...)` delivers
+			// useful stack traces
+			get = b.function(b.id('get', node.name_loc), [], b.block([b.return(expression)]));
+			set = b.function(
+				b.id('set', node.name_loc),
+				[b.id('$$value')],
+				b.block([b.stmt(assignment)])
+			);
+		} else {
+			// in prod, optimise for brevity
+			get = b.thunk(expression);
+
+			/** @type {Expression | undefined} */
+			set = b.unthunk(
+				b.arrow(
+					[b.id('$$value')],
+					/** @type {Expression} */ (
+						context.visit(
+							b.assignment('=', /** @type {Pattern} */ (node.expression), b.id('$$value'))
+						)
+					)
+				)
+			);
+
+			if (get === set) {
+				set = undefined;
+			}
+		}
+	}
+
+	/** @type {CallExpression} */
+	let call;
+
+	if (property?.event) {
+		call = b.call(
+			'$.bind_property',
+			b.literal(node.name),
+			b.literal(property.event),
+			context.state.node,
+			set ?? get,
+			property.bidirectional && get
+		);
+	} else {
+		// special cases
+		switch (node.name) {
+			// window
+			case 'online':
+				call = b.call(`$.bind_online`, set ?? get);
+				break;
+
+			case 'scrollX':
+			case 'scrollY':
+				call = b.call(
+					'$.bind_window_scroll',
+					b.literal(node.name === 'scrollX' ? 'x' : 'y'),
+					get,
+					set
+				);
+				break;
+
+			case 'innerWidth':
+			case 'innerHeight':
+			case 'outerWidth':
+			case 'outerHeight':
+				call = b.call('$.bind_window_size', b.literal(node.name), set ?? get);
+				break;
+
+			// document
+			case 'activeElement':
+				call = b.call('$.bind_active_element', set ?? get);
+				break;
+
+			// media
+			case 'muted':
+				call = b.call(`$.bind_muted`, context.state.node, get, set);
+				break;
+			case 'paused':
+				call = b.call(`$.bind_paused`, context.state.node, get, set);
+				break;
+			case 'volume':
+				call = b.call(`$.bind_volume`, context.state.node, get, set);
+				break;
+			case 'playbackRate':
+				call = b.call(`$.bind_playback_rate`, context.state.node, get, set);
+				break;
+			case 'currentTime':
+				call = b.call(`$.bind_current_time`, context.state.node, get, set);
+				break;
+			case 'buffered':
+				call = b.call(`$.bind_buffered`, context.state.node, set ?? get);
+				break;
+			case 'played':
+				call = b.call(`$.bind_played`, context.state.node, set ?? get);
+				break;
+			case 'seekable':
+				call = b.call(`$.bind_seekable`, context.state.node, set ?? get);
+				break;
+			case 'seeking':
+				call = b.call(`$.bind_seeking`, context.state.node, set ?? get);
+				break;
+			case 'ended':
+				call = b.call(`$.bind_ended`, context.state.node, set ?? get);
+				break;
+			case 'readyState':
+				call = b.call(`$.bind_ready_state`, context.state.node, set ?? get);
+				break;
+
+			// dimensions
+			case 'contentRect':
+			case 'contentBoxSize':
+			case 'borderBoxSize':
+			case 'devicePixelContentBoxSize':
+				call = b.call(
+					'$.bind_resize_observer',
+					context.state.node,
+					b.literal(node.name),
+					set ?? get
+				);
+				break;
+
+			case 'clientWidth':
+			case 'clientHeight':
+			case 'offsetWidth':
+			case 'offsetHeight':
+				call = b.call('$.bind_element_size', context.state.node, b.literal(node.name), set ?? get);
+				break;
+
+			// various
+			case 'value': {
+				if (parent?.type === 'RegularElement' && parent.name === 'select') {
+					call = b.call(`$.bind_select_value`, context.state.node, get, set);
+				} else {
+					call = b.call(`$.bind_value`, context.state.node, get, set);
+				}
+				break;
+			}
+
+			case 'files':
+				call = b.call(`$.bind_files`, context.state.node, get, set);
+				break;
+
+			case 'this':
+				call = build_bind_this(node.expression, context.state.node, context);
+				break;
+
+			case 'textContent':
+			case 'innerHTML':
+			case 'innerText':
+				call = b.call(
+					'$.bind_content_editable',
+					b.literal(node.name),
+					context.state.node,
+					get,
+					set
+				);
+				break;
+
+			// checkbox/radio
+			case 'checked':
+				call = b.call(`$.bind_checked`, context.state.node, get, set);
+				break;
+
+			case 'focused':
+				call = b.call(`$.bind_focused`, context.state.node, set ?? get);
+				break;
+
+			case 'group': {
+				const indexes = node.metadata.parent_each_blocks.map((each) => {
+					// if we have a keyed block with an index, the index is wrapped in a source
+					return each.metadata.keyed && each.index
+						? b.call('$.get', each.metadata.index)
+						: each.metadata.index;
+				});
+
+				// We need to additionally invoke the value attribute signal to register it as a dependency,
+				// so that when the value is updated, the group binding is updated
+				let group_getter = get;
+
+				if (parent?.type === 'RegularElement') {
+					const value = /** @type {any[]} */ (
+						/** @type {AST.Attribute} */ (
+							parent.attributes.find(
+								(a) =>
+									a.type === 'Attribute' &&
+									a.name === 'value' &&
+									!is_text_attribute(a) &&
+									a.value !== true
+							)
+						)?.value
+					);
+
+					if (value !== undefined) {
+						group_getter = b.thunk(
+							b.block([b.stmt(build_attribute_value(value, context).value), b.return(expression)])
+						);
+					}
+				}
+
+				call = b.call(
+					'$.bind_group',
+					node.metadata.binding_group_name,
+					b.array(indexes),
+					context.state.node,
+					group_getter,
+					set ?? get
+				);
+				break;
+			}
+
+			default:
+				throw new Error('unknown binding ' + node.name);
+		}
+	}
+
+	const defer =
+		node.name !== 'this' &&
+		parent.type === 'RegularElement' &&
+		parent.attributes.find((a) => a.type === 'UseDirective');
+
+	let statement = defer ? b.stmt(b.call('$.effect', b.thunk(call))) : b.stmt(call);
+
+	if (node.metadata.expression.is_async()) {
+		statement = b.stmt(
+			b.call(
+				'$.run_after_blockers',
+				node.metadata.expression.blockers(),
+				b.thunk(b.block([statement]))
+			)
+		);
+	}
+
+	// Bindings need to happen after attribute updates, therefore after the render effect, and in order with events/actions.
+	// bind:this is a special case as it's one-way and could influence the render effect.
+	if (node.name === 'this') {
+		context.state.init.push(statement);
+	} else {
+		if (defer) {
+			context.state.init.push(statement);
+		} else {
+			context.state.after_update.push(statement);
+		}
+	}
+}

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

@@ -0,0 +1,32 @@
+/** @import { ArrowFunctionExpression, BlockStatement, Expression, FunctionDeclaration, FunctionExpression, Statement } from 'estree' */
+/** @import { ComponentContext } from '../types' */
+import { add_state_transformers } from './shared/declarations.js';
+import * as b from '#compiler/builders';
+
+/**
+ * @param {BlockStatement} node
+ * @param {ComponentContext} context
+ */
+export function BlockStatement(node, context) {
+	add_state_transformers(context);
+	const tracing = context.state.scope.tracing;
+
+	if (tracing !== null) {
+		const parent =
+			/** @type {ArrowFunctionExpression | FunctionDeclaration | FunctionExpression} */ (
+				context.path.at(-1)
+			);
+
+		const is_async = parent.async;
+
+		const call = b.call(
+			'$.trace',
+			/** @type {Expression} */ (tracing),
+			b.thunk(b.block(node.body.map((n) => /** @type {Statement} */ (context.visit(n)))), is_async)
+		);
+
+		return b.block([b.return(is_async ? b.await(call) : call)]);
+	}
+
+	context.next();
+}

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

@@ -0,0 +1,20 @@
+/** @import { BreakStatement } from 'estree' */
+/** @import { ComponentContext } from '../types' */
+import * as b from '#compiler/builders';
+
+/**
+ * @param {BreakStatement} node
+ * @param {ComponentContext} context
+ */
+export function BreakStatement(node, context) {
+	if (context.state.analysis.runes || !node.label || node.label.name !== '$') {
+		return;
+	}
+
+	const in_reactive_statement =
+		context.path[1].type === 'LabeledStatement' && context.path[1].label.name === '$';
+
+	if (in_reactive_statement) {
+		return b.return();
+	}
+}

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

@@ -0,0 +1,136 @@
+/** @import { CallExpression, Expression } from 'estree' */
+/** @import { Context } from '../types' */
+import { dev, is_ignored } from '../../../../state.js';
+import * as b from '#compiler/builders';
+import { get_rune } from '../../../scope.js';
+import { should_proxy } from '../utils.js';
+import { get_inspect_args } from '../../utils.js';
+
+/**
+ * @param {CallExpression} node
+ * @param {Context} context
+ */
+export function CallExpression(node, context) {
+	const rune = get_rune(node, context.state.scope);
+
+	switch (rune) {
+		case '$host':
+			return b.id('$$props.$$host');
+
+		case '$effect.tracking':
+			return b.call('$.effect_tracking');
+
+		// transform state field assignments in constructors
+		case '$state':
+		case '$state.raw': {
+			let arg = node.arguments[0];
+
+			/** @type {Expression | undefined} */
+			let value = undefined;
+
+			if (arg) {
+				value = /** @type {Expression} */ (context.visit(node.arguments[0]));
+
+				if (
+					rune === '$state' &&
+					should_proxy(/** @type {Expression} */ (arg), context.state.scope)
+				) {
+					value = b.call('$.proxy', value);
+				}
+			}
+
+			const callee = b.id('$.state', node.callee.loc);
+			return b.call(callee, value);
+		}
+
+		case '$derived':
+		case '$derived.by': {
+			let fn = /** @type {Expression} */ (context.visit(node.arguments[0]));
+
+			return b.call('$.derived', rune === '$derived' ? b.thunk(fn) : fn);
+		}
+
+		case '$state.eager':
+			return b.call(
+				'$.eager',
+				b.thunk(/** @type {Expression} */ (context.visit(node.arguments[0])))
+			);
+
+		case '$state.snapshot':
+			return b.call(
+				'$.snapshot',
+				/** @type {Expression} */ (context.visit(node.arguments[0])),
+				is_ignored(node, 'state_snapshot_uncloneable') && b.true
+			);
+
+		case '$effect':
+		case '$effect.pre': {
+			const callee = rune === '$effect' ? '$.user_effect' : '$.user_pre_effect';
+			const func = /** @type {Expression} */ (context.visit(node.arguments[0]));
+
+			const expr = b.call(callee, /** @type {Expression} */ (func));
+			expr.callee.loc = node.callee.loc; // ensure correct mapping
+
+			return expr;
+		}
+
+		case '$effect.root':
+			return b.call(
+				'$.effect_root',
+				.../** @type {Expression[]} */ (node.arguments.map((arg) => context.visit(arg)))
+			);
+
+		case '$effect.pending':
+			return b.call('$.eager', b.thunk(b.call('$.pending')));
+
+		case '$inspect':
+		case '$inspect().with':
+			return transform_inspect_rune(rune, node, context);
+	}
+
+	if (
+		dev &&
+		node.callee.type === 'MemberExpression' &&
+		node.callee.object.type === 'Identifier' &&
+		node.callee.object.name === 'console' &&
+		context.state.scope.get('console') === null &&
+		node.callee.property.type === 'Identifier' &&
+		['debug', 'dir', 'error', 'group', 'groupCollapsed', 'info', 'log', 'trace', 'warn'].includes(
+			node.callee.property.name
+		) &&
+		node.arguments.some(
+			(arg) => arg.type === 'SpreadElement' || context.state.scope.evaluate(arg).has_unknown
+		)
+	) {
+		return b.call(
+			node.callee,
+			b.spread(
+				b.call(
+					'$.log_if_contains_state',
+					b.literal(node.callee.property.name),
+					.../** @type {Expression[]} */ (node.arguments.map((arg) => context.visit(arg)))
+				)
+			)
+		);
+	}
+
+	context.next();
+}
+
+/**
+ * @param {'$inspect' | '$inspect().with'} rune
+ * @param {CallExpression} node
+ * @param {Context} context
+ */
+function transform_inspect_rune(rune, node, context) {
+	if (!dev) return b.empty;
+
+	const { args, inspector } = get_inspect_args(rune, node, context.visit);
+
+	// by passing an arrow function, the log appears to come from the `$inspect` callsite
+	// rather than the `inspect.js` file containing the utility
+	const id = b.id('$$args');
+	const fn = b.arrow([b.rest(id)], b.call(inspector, b.spread(id)));
+
+	return b.call('$.inspect', b.thunk(b.array(args)), fn, rune === '$inspect' && b.true);
+}

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

@@ -0,0 +1,111 @@
+/** @import { CallExpression, ClassBody, ClassDeclaration, ClassExpression, MethodDefinition, PropertyDefinition, StaticBlock } from 'estree' */
+/** @import { StateField } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as b from '#compiler/builders';
+import { dev } from '../../../../state.js';
+import { get_parent } from '../../../../utils/ast.js';
+import { get_name } from '../../../nodes.js';
+
+/**
+ * @param {ClassBody} node
+ * @param {Context} context
+ */
+export function ClassBody(node, context) {
+	const state_fields = context.state.analysis.classes.get(node);
+
+	if (!state_fields) {
+		// in legacy mode, do nothing
+		context.next();
+		return;
+	}
+
+	/** @type {Array<MethodDefinition | PropertyDefinition | StaticBlock>} */
+	const body = [];
+
+	const child_state = { ...context.state, state_fields };
+
+	for (const [name, field] of state_fields) {
+		if (name[0] === '#') {
+			continue;
+		}
+
+		// insert backing fields for stuff declared in the constructor
+		if (field.node.type === 'AssignmentExpression') {
+			const member = b.member(b.this, field.key);
+
+			const should_proxy = field.type === '$state' && true; // TODO
+
+			const key = b.key(name);
+
+			body.push(
+				b.prop_def(field.key, null),
+
+				b.method('get', key, [], [b.return(b.call('$.get', member))]),
+
+				b.method(
+					'set',
+					key,
+					[b.id('value')],
+					[b.stmt(b.call('$.set', member, b.id('value'), should_proxy && b.true))]
+				)
+			);
+		}
+	}
+
+	const declaration = /** @type {ClassDeclaration | ClassExpression} */ (
+		get_parent(context.path, -1)
+	);
+
+	// Replace parts of the class body
+	for (const definition of node.body) {
+		if (definition.type !== 'PropertyDefinition') {
+			body.push(
+				/** @type {MethodDefinition | StaticBlock} */ (context.visit(definition, child_state))
+			);
+			continue;
+		}
+
+		const name = get_name(definition.key);
+		const field = name && /** @type {StateField} */ (state_fields.get(name));
+
+		if (!field) {
+			body.push(/** @type {PropertyDefinition} */ (context.visit(definition, child_state)));
+			continue;
+		}
+
+		if (name[0] === '#') {
+			let value = definition.value
+				? /** @type {CallExpression} */ (context.visit(definition.value, child_state))
+				: undefined;
+
+			if (dev && field.node === definition) {
+				value = b.call('$.tag', value, b.literal(`${declaration.id?.name ?? '[class]'}.${name}`));
+			}
+
+			body.push(b.prop_def(definition.key, value));
+		} else if (field.node === definition) {
+			let call = /** @type {CallExpression} */ (context.visit(field.value, child_state));
+
+			if (dev) {
+				call = b.call('$.tag', call, b.literal(`${declaration.id?.name ?? '[class]'}.${name}`));
+			}
+			const member = b.member(b.this, field.key);
+			const should_proxy = field.type === '$state' && true; // TODO
+
+			body.push(
+				b.prop_def(field.key, call),
+
+				b.method('get', definition.key, [], [b.return(b.call('$.get', member))]),
+
+				b.method(
+					'set',
+					definition.key,
+					[b.id('value')],
+					[b.stmt(b.call('$.set', member, b.id('value'), should_proxy && b.true))]
+				)
+			);
+		}
+	}
+
+	return { ...node, body };
+}

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

@@ -0,0 +1,11 @@
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+
+/**
+ * @param {AST.Comment} node
+ * @param {ComponentContext} context
+ */
+export function Comment(node, context) {
+	// We'll only get here if comments are not filtered out, which they are unless preserveComments is true
+	context.state.template.push_comment(node.data);
+}

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

@@ -0,0 +1,12 @@
+/** @import { AST } from '#compiler' */
+/** @import { ComponentContext } from '../types' */
+import { build_component } from './shared/component.js';
+
+/**
+ * @param {AST.Component} node
+ * @param {ComponentContext} context
+ */
+export function Component(node, context) {
+	const component = build_component(node, node.name, node.name_loc, context);
+	context.state.init.push(component);
+}