PromiseOptimiser Class — svelte Architecture

Source Code

packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/utils.js lines 299–400

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

	/**
	 * @param {Statement[]} statements
	 * @returns {Statement[]}
	 */
	render(statements) {
		if (!this.is_async()) {
			return statements;
		}

		const fn = b.arrow(
			[b.id('$$renderer')],
			b.block([this.#apply(), ...statements]),
			this.has_await