lumen-plus 0.0.4 → 0.0.5

package/dist/utils/node_modules/svelte/src/compiler/phases/3-transform/server/visitors/shared/utils.js

@@ -1,407 +0,0 @@
-/** @import { Expression, Identifier, Node, Statement, BlockStatement, ArrayExpression } from 'estree' */
-/** @import { AST } from '#compiler' */
-/** @import { ComponentContext, ServerTransformState } from '../../types.js' */
-
-import { escape_html } from '../../../../../../escaping.js';
-import {
-	BLOCK_CLOSE,
-	BLOCK_OPEN,
-	BLOCK_OPEN_ELSE,
-	EMPTY_COMMENT
-} from '../../../../../../internal/server/hydration.js';
-import * as b from '#compiler/builders';
-import { sanitize_template_string } from '../../../../../utils/sanitize_template_string.js';
-import { regex_whitespaces_strict } from '../../../../patterns.js';
-import { has_await_expression } from '../../../../../utils/ast.js';
-import { ExpressionMetadata } from '../../../../nodes.js';
-
-/** Opens an if/each block, so that we can remove nodes in the case of a mismatch */
-export const block_open = b.literal(BLOCK_OPEN);
-
-/** Opens an if/each block, so that we can remove nodes in the case of a mismatch */
-export const block_open_else = b.literal(BLOCK_OPEN_ELSE);
-
-/** Closes an if/each block, so that we can remove nodes in the case of a mismatch. Also serves as an anchor for these blocks */
-export const block_close = b.literal(BLOCK_CLOSE);
-
-/** Empty comment to keep text nodes separate, or provide an anchor node for blocks */
-export const empty_comment = b.literal(EMPTY_COMMENT);
-
-/**
- * Processes an array of template nodes, joining sibling text/expression nodes and
- * recursing into child nodes.
- * @param {Array<AST.SvelteNode>} nodes
- * @param {ComponentContext} context
- */
-export function process_children(nodes, { visit, state }) {
-	/** @type {Array<AST.Text | AST.Comment | AST.ExpressionTag>} */
-	let sequence = [];
-
-	function flush() {
-		if (sequence.length === 0) {
-			return;
-		}
-
-		let quasi = b.quasi('', false);
-		const quasis = [quasi];
-
-		/** @type {Expression[]} */
-		const expressions = [];
-
-		for (let i = 0; i < sequence.length; i++) {
-			const node = sequence[i];
-
-			if (node.type === 'Text' || node.type === 'Comment') {
-				quasi.value.cooked +=
-					node.type === 'Comment' ? `<!--${node.data}-->` : escape_html(node.data);
-			} else {
-				const evaluated = state.scope.evaluate(node.expression);
-
-				if (evaluated.is_known) {
-					quasi.value.cooked += escape_html((evaluated.value ?? '') + '');
-				} else {
-					expressions.push(b.call('$.escape', /** @type {Expression} */ (visit(node.expression))));
-
-					quasi = b.quasi('', i + 1 === sequence.length);
-					quasis.push(quasi);
-				}
-			}
-		}
-
-		for (const quasi of quasis) {
-			quasi.value.raw = sanitize_template_string(/** @type {string} */ (quasi.value.cooked));
-		}
-
-		state.template.push(b.template(quasis, expressions));
-		sequence = [];
-	}
-
-	for (const node of nodes) {
-		if (node.type === 'ExpressionTag' && node.metadata.expression.is_async()) {
-			flush();
-
-			const expression = /** @type {Expression} */ (visit(node.expression));
-			state.template.push(create_push(b.call('$.escape', expression), node.metadata.expression));
-		} else if (node.type === 'Text' || node.type === 'Comment' || node.type === 'ExpressionTag') {
-			sequence.push(node);
-		} else {
-			flush();
-			visit(node, { ...state });
-		}
-	}
-
-	flush();
-}
-
-/**
- * @param {Node} node
- * @returns {node is Statement}
- */
-function is_statement(node) {
-	return node.type.endsWith('Statement') || node.type.endsWith('Declaration');
-}
-
-/**
- * @param {Array<Statement | Expression>} template
- * @returns {Statement[]}
- */
-export function build_template(template) {
-	/** @type {string[]} */
-	let strings = [];
-
-	/** @type {Expression[]} */
-	let expressions = [];
-
-	/** @type {Statement[]} */
-	const statements = [];
-
-	const flush = () => {
-		statements.push(
-			b.stmt(
-				b.call(
-					b.id('$$renderer.push'),
-					b.template(
-						strings.map((cooked, i) => b.quasi(cooked, i === strings.length - 1)),
-						expressions
-					)
-				)
-			)
-		);
-
-		strings = [];
-		expressions = [];
-	};
-
-	for (let i = 0; i < template.length; i++) {
-		const node = template[i];
-
-		if (is_statement(node)) {
-			if (strings.length !== 0) {
-				flush();
-			}
-
-			statements.push(node);
-		} else {
-			if (strings.length === 0) {
-				strings.push('');
-			}
-
-			if (node.type === 'Literal') {
-				strings[strings.length - 1] += node.value;
-			} else if (node.type === 'TemplateLiteral') {
-				strings[strings.length - 1] += node.quasis[0].value.cooked;
-				strings.push(...node.quasis.slice(1).map((q) => /** @type {string} */ (q.value.cooked)));
-				expressions.push(...node.expressions);
-			} else {
-				expressions.push(node);
-				strings.push('');
-			}
-		}
-	}
-
-	if (strings.length !== 0) {
-		flush();
-	}
-
-	return statements;
-}
-
-/**
- *
- * @param {AST.Attribute['value']} value
- * @param {ComponentContext} context
- * @param {(expression: Expression, metadata: ExpressionMetadata) => Expression} transform
- * @param {boolean} trim_whitespace
- * @param {boolean} is_component
- * @returns {Expression}
- */
-export function build_attribute_value(
-	value,
-	context,
-	transform,
-	trim_whitespace = false,
-	is_component = false
-) {
-	if (value === true) {
-		return b.true;
-	}
-
-	if (!Array.isArray(value) || value.length === 1) {
-		const chunk = Array.isArray(value) ? value[0] : value;
-
-		if (chunk.type === 'Text') {
-			const data = trim_whitespace
-				? chunk.data.replace(regex_whitespaces_strict, ' ').trim()
-				: chunk.data;
-
-			return b.literal(is_component ? data : escape_html(data, true));
-		}
-
-		return transform(
-			/** @type {Expression} */ (context.visit(chunk.expression)),
-			chunk.metadata.expression
-		);
-	}
-
-	let quasi = b.quasi('', false);
-	const quasis = [quasi];
-
-	/** @type {Expression[]} */
-	const expressions = [];
-
-	for (let i = 0; i < value.length; i++) {
-		const node = value[i];
-
-		if (node.type === 'Text') {
-			quasi.value.raw += trim_whitespace
-				? node.data.replace(regex_whitespaces_strict, ' ')
-				: node.data;
-		} else {
-			expressions.push(
-				b.call(
-					'$.stringify',
-					transform(
-						/** @type {Expression} */ (context.visit(node.expression)),
-						node.metadata.expression
-					)
-				)
-			);
-
-			quasi = b.quasi('', i + 1 === value.length);
-			quasis.push(quasi);
-		}
-	}
-
-	return b.template(quasis, expressions);
-}
-
-/**
- * @param {Identifier} node
- * @param {ServerTransformState} state
- * @returns {Expression}
- */
-export function build_getter(node, state) {
-	const binding = state.scope.get(node.name);
-
-	if (binding === null || node === binding.node) {
-		// No associated binding or the declaration itself which shouldn't be transformed
-		return node;
-	}
-
-	if (binding.kind === 'store_sub') {
-		const store_id = b.id(node.name.slice(1));
-		return b.call(
-			'$.store_get',
-			b.assignment('??=', b.id('$$store_subs'), b.object([])),
-			b.literal(node.name),
-			build_getter(store_id, state)
-		);
-	}
-
-	return node;
-}
-
-/**
- * Creates a `$$renderer.child(...)` expression statement
- * @param {BlockStatement | Expression} body
- * @param {boolean} async
- * @returns {Statement}
- */
-export function create_child_block(body, async) {
-	return b.stmt(b.call('$$renderer.child', b.arrow([b.id('$$renderer')], body, async)));
-}
-
-/**
- * Creates a `$$renderer.async(...)` expression statement
- * @param {BlockStatement | Expression} body
- * @param {ArrayExpression} blockers
- * @param {boolean} has_await
- * @param {boolean} needs_hydration_markers
- */
-export function create_async_block(
-	body,
-	blockers = b.array([]),
-	has_await = true,
-	needs_hydration_markers = true
-) {
-	return b.stmt(
-		b.call(
-			needs_hydration_markers ? '$$renderer.async_block' : '$$renderer.async',
-			blockers,
-			b.arrow([b.id('$$renderer')], body, has_await)
-		)
-	);
-}
-
-/**
- * @param {Expression} expression
- * @param {ExpressionMetadata} metadata
- * @param {boolean} needs_hydration_markers
- * @returns {Expression | Statement}
- */
-export function create_push(expression, metadata, needs_hydration_markers = false) {
-	if (metadata.is_async()) {
-		let statement = b.stmt(b.call('$$renderer.push', b.thunk(expression, metadata.has_await)));
-
-		const blockers = metadata.blockers();
-
-		if (blockers.elements.length > 0) {
-			statement = create_async_block(
-				b.block([statement]),
-				blockers,
-				false,
-				needs_hydration_markers
-			);
-		}
-
-		return statement;
-	}
-
-	return expression;
-}
-
-/**
- * @param {BlockStatement | Expression} body
- * @param {Identifier | false} component_fn_id
- * @returns {Statement}
- */
-export function call_component_renderer(body, component_fn_id) {
-	return b.stmt(
-		b.call('$$renderer.component', b.arrow([b.id('$$renderer')], body, false), component_fn_id)
-	);
-}
-
-/**
- * A utility for optimising promises in templates. Without it code like
- * `<Component foo={await fetch()} bar={await other()} />` would be transformed
- * into two blocking promises, with it it's using `Promise.all` to await them.
- * It also keeps track of blocking promises, i.e. those that need to be resolved before continuing.
- */
-export class PromiseOptimiser {
-	/** @type {Expression[]} */
-	expressions = [];
-
-	has_await = false;
-
-	/** @type {Set<Expression>} */
-	#blockers = new Set();
-
-	/**
-	 * @param {Expression} expression
-	 * @param {ExpressionMetadata} metadata
-	 */
-	transform = (expression, metadata) => {
-		this.check_blockers(metadata);
-
-		if (metadata.has_await) {
-			this.has_await = true;
-
-			const length = this.expressions.push(expression);
-			return b.id(`$$${length - 1}`);
-		}
-
-		return expression;
-	};
-
-	/**
-	 * @param {ExpressionMetadata} metadata
-	 */
-	check_blockers(metadata) {
-		for (const binding of metadata.dependencies) {
-			if (binding.blocker) {
-				this.#blockers.add(binding.blocker);
-			}
-		}
-	}
-
-	apply() {
-		if (this.expressions.length === 0) {
-			return b.empty;
-		}
-
-		if (this.expressions.length === 1) {
-			return b.const('$$0', this.expressions[0]);
-		}
-
-		const promises = b.array(
-			this.expressions.map((expression) => {
-				return expression.type === 'AwaitExpression' && !has_await_expression(expression.argument)
-					? expression.argument
-					: b.call(b.thunk(expression, true));
-			})
-		);
-
-		return b.const(
-			b.array_pattern(this.expressions.map((_, i) => b.id(`$$${i}`))),
-			b.await(b.call('Promise.all', promises))
-		);
-	}
-
-	blockers() {
-		return b.array([...this.#blockers]);
-	}
-
-	is_async() {
-		return this.expressions.length > 0 || this.#blockers.size > 0;
-	}
-}

package/dist/utils/node_modules/svelte/src/compiler/phases/3-transform/shared/assignments.js

@@ -1,93 +0,0 @@
-/** @import { AssignmentExpression, AssignmentOperator, Expression, Node, Pattern, Statement } from 'estree' */
-/** @import { Context as ClientContext } from '../client/types.js' */
-/** @import { Context as ServerContext } from '../server/types.js' */
-import { extract_paths, is_expression_async } from '../../../utils/ast.js';
-import * as b from '#compiler/builders';
-import { get_value } from '../client/visitors/shared/declarations.js';
-
-/**
- * @template {ClientContext | ServerContext} Context
- * @param {AssignmentExpression} node
- * @param {Context} context
- * @param {(operator: AssignmentOperator, left: Pattern, right: Expression, context: Context) => Expression | null} build_assignment
- * @returns
- */
-export function visit_assignment_expression(node, context, build_assignment) {
-	if (
-		node.left.type === 'ArrayPattern' ||
-		node.left.type === 'ObjectPattern' ||
-		node.left.type === 'RestElement'
-	) {
-		const value = /** @type {Expression} */ (context.visit(node.right));
-		const should_cache = value.type !== 'Identifier';
-		const rhs = should_cache ? b.id('$$value') : value;
-
-		let changed = false;
-
-		const { inserts, paths } = extract_paths(node.left, rhs);
-
-		for (const { id } of inserts) {
-			id.name = context.state.scope.generate('$$array');
-		}
-
-		const assignments = paths.map((path) => {
-			const value = path.expression;
-
-			let assignment = build_assignment('=', path.node, value, context);
-			if (assignment !== null) changed = true;
-
-			return (
-				assignment ??
-				b.assignment(
-					'=',
-					/** @type {Pattern} */ (context.visit(path.node)),
-					/** @type {Expression} */ (context.visit(value))
-				)
-			);
-		});
-
-		if (!changed) {
-			// No change to output -> nothing to transform -> we can keep the original assignment
-			return null;
-		}
-
-		const is_standalone = /** @type {Node} */ (context.path.at(-1)).type.endsWith('Statement');
-
-		if (inserts.length > 0 || should_cache) {
-			/** @type {Statement[]} */
-			const statements = [
-				...inserts.map(({ id, value }) => b.var(id, value)),
-				...assignments.map(b.stmt)
-			];
-
-			if (!is_standalone) {
-				// this is part of an expression, we need the sequence to end with the value
-				statements.push(b.return(rhs));
-			}
-
-			const async =
-				is_expression_async(value) ||
-				assignments.some((assignment) => is_expression_async(assignment));
-
-			const iife = b.arrow([rhs], b.block(statements), async);
-			const call = b.call(iife, value);
-
-			return async ? b.await(call) : call;
-		}
-
-		const sequence = b.sequence(assignments);
-
-		if (!is_standalone) {
-			// this is part of an expression, we need the sequence to end with the value
-			sequence.expressions.push(rhs);
-		}
-
-		return sequence;
-	}
-
-	if (node.left.type !== 'Identifier' && node.left.type !== 'MemberExpression') {
-		throw new Error(`Unexpected assignment type ${node.left.type}`);
-	}
-
-	return build_assignment(node.operator, node.left, node.right, context);
-}

package/dist/utils/node_modules/svelte/src/compiler/phases/3-transform/shared/transform-async.js

@@ -1,114 +0,0 @@
-/** @import * as ESTree from 'estree' */
-/** @import { ComponentAnalysis } from '../../types' */
-import * as b from '#compiler/builders';
-
-/**
- * Transforms the body of the instance script in such a way that await expressions are made non-blocking as much as possible.
- *
- * Example Transformation:
- * ```js
- * let x = 1;
- * let data = await fetch('/api');
- * let y = data.value;
- * ```
- * becomes:
- * ```js
- * let x = 1;
- * var data, y;
- * var $$promises = $.run([
- *   () => data = await fetch('/api'),
- *   () => y = data.value
- * ]);
- * ```
- * where `$$promises` is an array of promises that are resolved in the order they are declared,
- * and which expressions in the template can await on like `await $$promises[0]` which means they
- * wouldn't have to wait for e.g. `$$promises[1]` to resolve.
- *
- * @param {ComponentAnalysis['instance_body']} instance_body
- * @param {ESTree.Expression} runner
- * @param {(node: ESTree.Node) => ESTree.Node} transform
- * @returns {Array<ESTree.Statement | ESTree.VariableDeclaration>}
- */
-export function transform_body(instance_body, runner, transform) {
-	// Any sync statements before the first await expression
-	const statements = instance_body.sync.map(
-		(node) => /** @type {ESTree.Statement | ESTree.VariableDeclaration} */ (transform(node))
-	);
-
-	// Declarations for the await expressions (they will assign to them; need to be hoisted to be available in whole instance scope)
-	if (instance_body.declarations.length > 0) {
-		statements.push(
-			b.declaration(
-				'var',
-				instance_body.declarations.map((id) => b.declarator(id))
-			)
-		);
-	}
-
-	// Thunks for the await expressions
-	if (instance_body.async.length > 0) {
-		const thunks = instance_body.async.map((s) => {
-			if (s.node.type === 'VariableDeclarator') {
-				const visited = /** @type {ESTree.VariableDeclaration | ESTree.EmptyStatement} */ (
-					transform(b.var(s.node.id, s.node.init))
-				);
-
-				const statements =
-					visited.type === 'VariableDeclaration'
-						? visited.declarations.map((node) => {
-								if (
-									node.id.type === 'Identifier' &&
-									(node.id.name.startsWith('$$d') || node.id.name.startsWith('$$array'))
-								) {
-									// this is an intermediate declaration created in VariableDeclaration.js;
-									// subsequent statements depend on it
-									return b.var(node.id, node.init);
-								}
-
-								return b.stmt(b.assignment('=', node.id, node.init ?? b.void0));
-							})
-						: [];
-
-				if (statements.length === 1) {
-					const statement = /** @type {ESTree.ExpressionStatement} */ (statements[0]);
-					return b.thunk(statement.expression, s.has_await);
-				}
-
-				return b.thunk(b.block(statements), s.has_await);
-			}
-
-			if (s.node.type === 'ClassDeclaration') {
-				return b.thunk(
-					b.assignment(
-						'=',
-						s.node.id,
-						/** @type {ESTree.ClassExpression} */ ({ ...s.node, type: 'ClassExpression' })
-					),
-					s.has_await
-				);
-			}
-
-			if (s.node.type === 'ExpressionStatement') {
-				// the expression may be a $inspect call, which will be transformed into an empty statement
-				const expression = /** @type {ESTree.Expression | ESTree.EmptyStatement} */ (
-					transform(s.node.expression)
-				);
-
-				if (expression.type === 'EmptyStatement') {
-					return null;
-				}
-
-				return expression.type === 'AwaitExpression'
-					? b.thunk(expression, true)
-					: b.thunk(b.unary('void', expression), s.has_await);
-			}
-
-			return b.thunk(b.block([/** @type {ESTree.Statement} */ (transform(s.node))]), s.has_await);
-		});
-
-		// TODO get the `$$promises` ID from scope
-		statements.push(b.var('$$promises', b.call(runner, b.array(thunks))));
-	}
-
-	return statements;
-}