lumen-plus 0.0.4 → 0.0.5

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

@@ -1,48 +0,0 @@
-/** @import { AST } from '#compiler' */
-/** @import { ComponentContext } from '../types' */
-import * as b from '#compiler/builders';
-import { build_template_chunk, Memoizer } from './shared/utils.js';
-
-/**
- * @param {AST.TitleElement} node
- * @param {ComponentContext} context
- */
-export function TitleElement(node, context) {
-	const memoizer = new Memoizer();
-	const { has_state, value } = build_template_chunk(
-		/** @type {any} */ (node.fragment.nodes),
-		context,
-		context.state,
-		(value, metadata) => memoizer.add(value, metadata)
-	);
-	const evaluated = context.state.scope.evaluate(value);
-
-	const statement = b.stmt(
-		b.assignment(
-			'=',
-			b.member(b.id('$.document'), b.id('title', node.name_loc)),
-			evaluated.is_known
-				? b.literal(evaluated.value)
-				: evaluated.is_defined
-					? value
-					: b.logical('??', value, b.literal(''))
-		)
-	);
-
-	// Make sure it only changes the title once async work is done
-	if (has_state) {
-		context.state.after_update.push(
-			b.stmt(
-				b.call(
-					'$.deferred_template_effect',
-					b.arrow(memoizer.apply(), b.block([statement])),
-					memoizer.sync_values(),
-					memoizer.async_values(),
-					memoizer.blockers()
-				)
-			)
-		);
-	} else {
-		context.state.after_update.push(b.stmt(b.call('$.effect', b.thunk(b.block([statement])))));
-	}
-}

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

@@ -1,41 +0,0 @@
-/** @import { Expression } from 'estree' */
-/** @import { AST } from '#compiler' */
-/** @import { ComponentContext } from '../types' */
-import { TRANSITION_GLOBAL, TRANSITION_IN, TRANSITION_OUT } from '../../../../../constants.js';
-import * as b from '#compiler/builders';
-import { parse_directive_name } from './shared/utils.js';
-
-/**
- * @param {AST.TransitionDirective} node
- * @param {ComponentContext} context
- */
-export function TransitionDirective(node, context) {
-	let flags = node.modifiers.includes('global') ? TRANSITION_GLOBAL : 0;
-	if (node.intro) flags |= TRANSITION_IN;
-	if (node.outro) flags |= TRANSITION_OUT;
-
-	const args = [
-		b.literal(flags),
-		context.state.node,
-		b.thunk(/** @type {Expression} */ (context.visit(parse_directive_name(node.name))))
-	];
-
-	if (node.expression) {
-		args.push(b.thunk(/** @type {Expression} */ (context.visit(node.expression))));
-	}
-
-	// in after_update to ensure it always happens after bind:this
-	let statement = b.stmt(b.call('$.transition', ...args));
-
-	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.after_update.push(statement);
-}

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

@@ -1,55 +0,0 @@
-/** @import { AssignmentExpression, Expression, UpdateExpression } from 'estree' */
-/** @import { Context } from '../types' */
-import { object } from '../../../../utils/ast.js';
-import * as b from '#compiler/builders';
-import { validate_mutation } from './shared/utils.js';
-
-/**
- * @param {UpdateExpression} node
- * @param {Context} context
- */
-export function UpdateExpression(node, context) {
-	const argument = node.argument;
-
-	if (
-		argument.type === 'MemberExpression' &&
-		argument.object.type === 'ThisExpression' &&
-		argument.property.type === 'PrivateIdentifier' &&
-		context.state.state_fields.has('#' + argument.property.name)
-	) {
-		let fn = '$.update';
-		if (node.prefix) fn += '_pre';
-
-		/** @type {Expression[]} */
-		const args = [argument];
-		if (node.operator === '--') {
-			args.push(b.literal(-1));
-		}
-
-		return b.call(fn, ...args);
-	}
-
-	if (argument.type !== 'Identifier' && argument.type !== 'MemberExpression') {
-		throw new Error('An impossible state was reached');
-	}
-
-	const left = object(argument);
-	const transformers = left && context.state.transform[left.name];
-
-	if (left === argument && transformers?.update) {
-		// we don't need to worry about ownership_invalid_mutation here, because
-		// we're not mutating but reassigning
-		return transformers.update(node);
-	}
-
-	let update = /** @type {Expression} */ (context.next());
-
-	if (left && transformers?.mutate) {
-		update = transformers.mutate(
-			left,
-			/** @type {AssignmentExpression | UpdateExpression} */ (update)
-		);
-	}
-
-	return validate_mutation(node, context, update);
-}

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

@@ -1,49 +0,0 @@
-/** @import { Expression } from 'estree' */
-/** @import { AST } from '#compiler' */
-/** @import { ComponentContext } from '../types' */
-import * as b from '#compiler/builders';
-import { parse_directive_name } from './shared/utils.js';
-
-/**
- * @param {AST.UseDirective} node
- * @param {ComponentContext} context
- */
-export function UseDirective(node, context) {
-	const params = [b.id('$$node')];
-
-	if (node.expression) {
-		params.push(b.id('$$action_arg'));
-	}
-
-	/** @type {Expression[]} */
-	const args = [
-		context.state.node,
-		b.arrow(
-			params,
-			b.maybe_call(
-				/** @type {Expression} */ (context.visit(parse_directive_name(node.name))),
-				...params
-			)
-		)
-	];
-
-	if (node.expression) {
-		args.push(b.thunk(/** @type {Expression} */ (context.visit(node.expression))));
-	}
-
-	// actions need to run after attribute updates in order with bindings/events
-	let statement = b.stmt(b.call('$.action', ...args));
-
-	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/VariableDeclaration.js

@@ -1,422 +0,0 @@
-/** @import { CallExpression, Expression, Identifier, Literal, VariableDeclaration, VariableDeclarator } from 'estree' */
-/** @import { Binding } from '#compiler' */
-/** @import { ComponentContext } from '../types' */
-import { dev, is_ignored, locate_node } from '../../../../state.js';
-import { extract_paths, save } from '../../../../utils/ast.js';
-import * as b from '#compiler/builders';
-import * as assert from '../../../../utils/assert.js';
-import { get_rune } from '../../../scope.js';
-import { get_prop_source, is_prop_source, is_state_source, should_proxy } from '../utils.js';
-import { get_value } from './shared/declarations.js';
-
-/**
- * @param {VariableDeclaration} node
- * @param {ComponentContext} context
- */
-export function VariableDeclaration(node, context) {
-	/** @type {VariableDeclarator[]} */
-	const declarations = [];
-
-	if (context.state.analysis.runes) {
-		for (const declarator of node.declarations) {
-			const init = /** @type {Expression} */ (declarator.init);
-			const rune = get_rune(init, context.state.scope);
-
-			if (
-				!rune ||
-				rune === '$effect.tracking' ||
-				rune === '$effect.root' ||
-				rune === '$inspect' ||
-				rune === '$inspect.trace' ||
-				rune === '$state.snapshot' ||
-				rune === '$host'
-			) {
-				declarations.push(/** @type {VariableDeclarator} */ (context.visit(declarator)));
-				continue;
-			}
-
-			if (rune === '$props.id') {
-				// skip
-				continue;
-			}
-
-			if (rune === '$props') {
-				/** @type {string[]} */
-				const seen = ['$$slots', '$$events', '$$legacy'];
-
-				if (context.state.analysis.custom_element) {
-					seen.push('$$host');
-				}
-
-				if (declarator.id.type === 'Identifier') {
-					/** @type {Expression[]} */
-					const args = [b.id('$$props'), b.array(seen.map((name) => b.literal(name)))];
-
-					if (dev) {
-						// include rest name, so we can provide informative error messages
-						args.push(b.literal(declarator.id.name));
-					}
-
-					declarations.push(b.declarator(declarator.id, b.call('$.rest_props', ...args)));
-				} else {
-					assert.equal(declarator.id.type, 'ObjectPattern');
-
-					for (const property of declarator.id.properties) {
-						if (property.type === 'Property') {
-							const key = /** @type {Identifier | Literal} */ (property.key);
-							const name = key.type === 'Identifier' ? key.name : /** @type {string} */ (key.value);
-
-							seen.push(name);
-
-							let id =
-								property.value.type === 'AssignmentPattern' ? property.value.left : property.value;
-							assert.equal(id.type, 'Identifier');
-							const binding = /** @type {Binding} */ (context.state.scope.get(id.name));
-							let initial =
-								binding.initial && /** @type {Expression} */ (context.visit(binding.initial));
-							// We're adding proxy here on demand and not within the prop runtime function so that
-							// people not using proxied state anywhere in their code don't have to pay the additional bundle size cost
-							if (
-								initial &&
-								binding.kind === 'bindable_prop' &&
-								should_proxy(initial, context.state.scope)
-							) {
-								initial = b.call('$.proxy', initial);
-
-								if (dev) {
-									initial = b.call('$.tag_proxy', initial, b.literal(id.name));
-								}
-							}
-
-							if (is_prop_source(binding, context.state)) {
-								declarations.push(
-									b.declarator(id, get_prop_source(binding, context.state, name, initial))
-								);
-							}
-						} else {
-							// RestElement
-							/** @type {Expression[]} */
-							const args = [b.id('$$props'), b.array(seen.map((name) => b.literal(name)))];
-
-							if (dev) {
-								// include rest name, so we can provide informative error messages
-								args.push(b.literal(/** @type {Identifier} */ (property.argument).name));
-							}
-
-							declarations.push(b.declarator(property.argument, b.call('$.rest_props', ...args)));
-						}
-					}
-				}
-
-				// TODO
-				continue;
-			}
-
-			const args = /** @type {CallExpression} */ (init).arguments;
-			const value = /** @type {Expression} */ (args[0]) ?? b.void0; // TODO do we need the void 0? can we just omit it altogether?
-
-			if (rune === '$state' || rune === '$state.raw') {
-				/**
-				 * @param {Identifier} id
-				 * @param {Expression} value
-				 */
-				const create_state_declarator = (id, value) => {
-					const binding = /** @type {import('#compiler').Binding} */ (
-						context.state.scope.get(id.name)
-					);
-					const is_state = is_state_source(binding, context.state.analysis);
-					const is_proxy = should_proxy(value, context.state.scope);
-
-					if (rune === '$state' && is_proxy) {
-						value = b.call('$.proxy', value);
-
-						if (dev && !is_state) {
-							value = b.call('$.tag_proxy', value, b.literal(id.name));
-						}
-					}
-
-					if (is_state) {
-						const callee = b.id('$.state', /** @type {CallExpression} */ (init).callee.loc);
-						value = b.call(callee, value);
-
-						if (dev) {
-							value = b.call('$.tag', value, b.literal(id.name));
-						}
-					}
-
-					return value;
-				};
-
-				if (declarator.id.type === 'Identifier') {
-					const expression = /** @type {Expression} */ (context.visit(value));
-
-					declarations.push(
-						b.declarator(declarator.id, create_state_declarator(declarator.id, expression))
-					);
-				} else {
-					const tmp = b.id(context.state.scope.generate('tmp'));
-					const { inserts, paths } = extract_paths(declarator.id, tmp);
-
-					declarations.push(
-						b.declarator(tmp, /** @type {Expression} */ (context.visit(value))),
-						...inserts.map(({ id, value }) => {
-							id.name = context.state.scope.generate('$$array');
-							context.state.transform[id.name] = { read: get_value };
-
-							const expression = /** @type {Expression} */ (context.visit(b.thunk(value)));
-							let call = b.call('$.derived', expression);
-
-							if (dev) {
-								const label = `[$state ${declarator.id.type === 'ArrayPattern' ? 'iterable' : 'object'}]`;
-								call = b.call('$.tag', call, b.literal(label));
-							}
-
-							return b.declarator(id, call);
-						}),
-						...paths.map((path) => {
-							const value = /** @type {Expression} */ (context.visit(path.expression));
-							const binding = context.state.scope.get(/** @type {Identifier} */ (path.node).name);
-							return b.declarator(
-								path.node,
-								binding?.kind === 'state' || binding?.kind === 'raw_state'
-									? create_state_declarator(binding.node, value)
-									: value
-							);
-						})
-					);
-				}
-
-				continue;
-			}
-
-			if (rune === '$derived' || rune === '$derived.by') {
-				const is_async = context.state.analysis.async_deriveds.has(
-					/** @type {CallExpression} */ (init)
-				);
-
-				// for now, only wrap async derived in $.save if it's not
-				// a top-level instance derived. TODO in future maybe we
-				// can dewaterfall all of them?
-				const should_save = context.state.is_instance && context.state.scope.function_depth > 1;
-
-				if (declarator.id.type === 'Identifier') {
-					let expression = /** @type {Expression} */ (context.visit(value));
-
-					if (is_async) {
-						const location = dev && !is_ignored(init, 'await_waterfall') && locate_node(init);
-
-						/** @type {Expression} */
-						let call = b.call(
-							'$.async_derived',
-							b.thunk(expression, true),
-							dev && b.literal(declarator.id.name),
-							location ? b.literal(location) : undefined
-						);
-
-						call = should_save ? save(call) : b.await(call);
-
-						declarations.push(b.declarator(declarator.id, call));
-					} else {
-						if (rune === '$derived') expression = b.thunk(expression);
-
-						let call = b.call('$.derived', expression);
-						if (dev) call = b.call('$.tag', call, b.literal(declarator.id.name));
-
-						declarations.push(b.declarator(declarator.id, call));
-					}
-				} else {
-					const init = /** @type {CallExpression} */ (declarator.init);
-					let expression = /** @type {Expression} */ (context.visit(value));
-
-					let rhs = value;
-
-					if (rune !== '$derived' || init.arguments[0].type !== 'Identifier') {
-						const id = b.id(context.state.scope.generate('$$d'));
-
-						/** @type {Expression} */
-						let call = b.call('$.derived', rune === '$derived' ? b.thunk(expression) : expression);
-
-						rhs = b.call('$.get', id);
-
-						if (is_async) {
-							const location = dev && !is_ignored(init, 'await_waterfall') && locate_node(init);
-
-							call = b.call(
-								'$.async_derived',
-								b.thunk(expression, true),
-								dev &&
-									b.literal(
-										`[$derived ${declarator.id.type === 'ArrayPattern' ? 'iterable' : 'object'}]`
-									),
-								location ? b.literal(location) : undefined
-							);
-
-							call = should_save ? save(call) : b.await(call);
-						}
-
-						declarations.push(b.declarator(id, call));
-					}
-
-					const { inserts, paths } = extract_paths(declarator.id, rhs);
-
-					for (const { id, value } of inserts) {
-						id.name = context.state.scope.generate('$$array');
-						context.state.transform[id.name] = { read: get_value };
-
-						const expression = /** @type {Expression} */ (context.visit(b.thunk(value)));
-						let call = b.call('$.derived', expression);
-
-						if (dev) {
-							const label = `[$derived ${declarator.id.type === 'ArrayPattern' ? 'iterable' : 'object'}]`;
-							call = b.call('$.tag', call, b.literal(label));
-						}
-
-						declarations.push(b.declarator(id, call));
-					}
-
-					for (const path of paths) {
-						const expression = /** @type {Expression} */ (context.visit(path.expression));
-						const call = b.call('$.derived', b.thunk(expression));
-						declarations.push(
-							b.declarator(
-								path.node,
-								dev
-									? b.call('$.tag', call, b.literal(/** @type {Identifier} */ (path.node).name))
-									: call
-							)
-						);
-					}
-				}
-
-				continue;
-			}
-		}
-	} else {
-		for (const declarator of node.declarations) {
-			const bindings = /** @type {Binding[]} */ (context.state.scope.get_bindings(declarator));
-			const has_state = bindings.some((binding) => binding.kind === 'state');
-			const has_props = bindings.some((binding) => binding.kind === 'bindable_prop');
-
-			if (!has_state && !has_props) {
-				declarations.push(/** @type {VariableDeclarator} */ (context.visit(declarator)));
-				continue;
-			}
-
-			if (has_props) {
-				if (declarator.id.type !== 'Identifier') {
-					// Turn export let into props. It's really really weird because export let { x: foo, z: [bar]} = ..
-					// means that foo and bar are the props (i.e. the leaves are the prop names), not x and z.
-					const tmp = b.id(context.state.scope.generate('tmp'));
-					const { inserts, paths } = extract_paths(declarator.id, tmp);
-
-					declarations.push(
-						b.declarator(
-							tmp,
-							/** @type {Expression} */ (context.visit(/** @type {Expression} */ (declarator.init)))
-						)
-					);
-
-					for (const { id, value } of inserts) {
-						id.name = context.state.scope.generate('$$array');
-						context.state.transform[id.name] = { read: get_value };
-
-						const expression = /** @type {Expression} */ (context.visit(b.thunk(value)));
-						declarations.push(b.declarator(id, b.call('$.derived', expression)));
-					}
-
-					for (const path of paths) {
-						const name = /** @type {Identifier} */ (path.node).name;
-						const binding = /** @type {Binding} */ (context.state.scope.get(name));
-						const value = /** @type {Expression} */ (context.visit(path.expression));
-
-						declarations.push(
-							b.declarator(
-								path.node,
-								binding.kind === 'bindable_prop'
-									? get_prop_source(binding, context.state, binding.prop_alias ?? name, value)
-									: value
-							)
-						);
-					}
-
-					continue;
-				}
-
-				const binding = /** @type {Binding} */ (context.state.scope.get(declarator.id.name));
-
-				declarations.push(
-					b.declarator(
-						declarator.id,
-						get_prop_source(
-							binding,
-							context.state,
-							binding.prop_alias ?? declarator.id.name,
-							declarator.init && /** @type {Expression} */ (context.visit(declarator.init))
-						)
-					)
-				);
-
-				continue;
-			}
-
-			declarations.push(
-				...create_state_declarators(
-					declarator,
-					context,
-					/** @type {Expression} */ (declarator.init && context.visit(declarator.init))
-				)
-			);
-		}
-	}
-
-	if (declarations.length === 0) {
-		return b.empty;
-	}
-
-	return {
-		...node,
-		declarations
-	};
-}
-
-/**
- * Creates the output for a state declaration in legacy mode.
- * @param {VariableDeclarator} declarator
- * @param {ComponentContext} context
- * @param {Expression} value
- */
-function create_state_declarators(declarator, context, value) {
-	if (declarator.id.type === 'Identifier') {
-		return [
-			b.declarator(
-				declarator.id,
-				b.call('$.mutable_source', value, context.state.analysis.immutable ? b.true : undefined)
-			)
-		];
-	}
-
-	const tmp = b.id(context.state.scope.generate('tmp'));
-	const { inserts, paths } = extract_paths(declarator.id, tmp);
-
-	return [
-		b.declarator(tmp, value),
-		...inserts.map(({ id, value }) => {
-			id.name = context.state.scope.generate('$$array');
-			context.state.transform[id.name] = { read: get_value };
-
-			const expression = /** @type {Expression} */ (context.visit(b.thunk(value)));
-			return b.declarator(id, b.call('$.derived', expression));
-		}),
-		...paths.map((path) => {
-			const value = /** @type {Expression} */ (context.visit(path.expression));
-			const binding = context.state.scope.get(/** @type {Identifier} */ (path.node).name);
-
-			return b.declarator(
-				path.node,
-				binding?.kind === 'state'
-					? b.call('$.mutable_source', value, context.state.analysis.immutable ? b.true : undefined)
-					: value
-			);
-		})
-	];
-}