lumen-plus 0.0.3 → 0.0.4

package/dist/utils/node_modules/svelte/src/compiler/utils/builders.js

@@ -0,0 +1,698 @@
+/** @import * as ESTree from 'estree' */
+import { walk } from 'zimmerframe';
+import { regex_is_valid_identifier } from '../phases/patterns.js';
+import { sanitize_template_string } from './sanitize_template_string.js';
+import { has_await_expression } from './ast.js';
+
+/**
+ * @param {Array<ESTree.Expression | ESTree.SpreadElement | null>} elements
+ * @returns {ESTree.ArrayExpression}
+ */
+export function array(elements = []) {
+	return { type: 'ArrayExpression', elements };
+}
+
+/**
+ * @param {Array<ESTree.Pattern | null>} elements
+ * @returns {ESTree.ArrayPattern}
+ */
+export function array_pattern(elements) {
+	return { type: 'ArrayPattern', elements };
+}
+
+/**
+ * @param {ESTree.Pattern} left
+ * @param {ESTree.Expression} right
+ * @returns {ESTree.AssignmentPattern}
+ */
+export function assignment_pattern(left, right) {
+	return { type: 'AssignmentPattern', left, right };
+}
+
+/**
+ * @param {Array<ESTree.Pattern>} params
+ * @param {ESTree.BlockStatement | ESTree.Expression} body
+ * @param {boolean} async
+ * @returns {ESTree.ArrowFunctionExpression}
+ */
+export function arrow(params, body, async = false) {
+	return {
+		type: 'ArrowFunctionExpression',
+		params,
+		body,
+		expression: body.type !== 'BlockStatement',
+		generator: false,
+		async
+	};
+}
+
+/**
+ * @param {ESTree.AssignmentOperator} operator
+ * @param {ESTree.Pattern} left
+ * @param {ESTree.Expression} right
+ * @returns {ESTree.AssignmentExpression}
+ */
+export function assignment(operator, left, right) {
+	return { type: 'AssignmentExpression', operator, left, right };
+}
+
+/**
+ * @param {ESTree.Expression} argument
+ * @returns {ESTree.AwaitExpression}
+ */
+function await_builder(argument) {
+	return { type: 'AwaitExpression', argument };
+}
+
+/**
+ * @param {ESTree.BinaryOperator} operator
+ * @param {ESTree.Expression} left
+ * @param {ESTree.Expression} right
+ * @returns {ESTree.BinaryExpression}
+ */
+export function binary(operator, left, right) {
+	return { type: 'BinaryExpression', operator, left, right };
+}
+
+/**
+ * @param {ESTree.Statement[]} body
+ * @returns {ESTree.BlockStatement}
+ */
+export function block(body) {
+	return { type: 'BlockStatement', body };
+}
+
+/**
+ * @param {ESTree.Identifier | null} id
+ * @param {ESTree.ClassBody} body
+ * @param {ESTree.Expression | null} [superClass]
+ * @param {ESTree.Decorator[]} [decorators]
+ * @returns {ESTree.ClassExpression}
+ */
+export function class_expression(id, body, superClass, decorators = []) {
+	return { type: 'ClassExpression', body, superClass, decorators };
+}
+
+/**
+ * @param {string} name
+ * @param {ESTree.Statement} body
+ * @returns {ESTree.LabeledStatement}
+ */
+export function labeled(name, body) {
+	return { type: 'LabeledStatement', label: id(name), body };
+}
+
+/**
+ * @param {string | ESTree.Expression} callee
+ * @param {...(ESTree.Expression | ESTree.SpreadElement | false | undefined | null)} args
+ * @returns {ESTree.CallExpression}
+ */
+export function call(callee, ...args) {
+	if (typeof callee === 'string') callee = id(callee);
+	args = args.slice();
+
+	// replacing missing arguments with `void(0)`, unless they're at the end in which case remove them
+	let i = args.length;
+	let popping = true;
+	while (i--) {
+		if (!args[i]) {
+			if (popping) {
+				args.pop();
+			} else {
+				args[i] = void0;
+			}
+		} else {
+			popping = false;
+		}
+	}
+
+	return {
+		type: 'CallExpression',
+		callee,
+		arguments: /** @type {Array<ESTree.Expression | ESTree.SpreadElement>} */ (args),
+		optional: false
+	};
+}
+
+/**
+ * @param {string | ESTree.Expression} callee
+ * @param {...ESTree.Expression} args
+ * @returns {ESTree.ChainExpression}
+ */
+export function maybe_call(callee, ...args) {
+	const expression = /** @type {ESTree.SimpleCallExpression} */ (call(callee, ...args));
+	expression.optional = true;
+
+	return {
+		type: 'ChainExpression',
+		expression
+	};
+}
+
+/**
+ * @param {ESTree.UnaryOperator} operator
+ * @param {ESTree.Expression} argument
+ * @returns {ESTree.UnaryExpression}
+ */
+export function unary(operator, argument) {
+	return { type: 'UnaryExpression', argument, operator, prefix: true };
+}
+
+export const void0 = unary('void', literal(0));
+
+/**
+ * @param {ESTree.Expression} test
+ * @param {ESTree.Expression} consequent
+ * @param {ESTree.Expression} alternate
+ * @returns {ESTree.ConditionalExpression}
+ */
+export function conditional(test, consequent, alternate) {
+	return { type: 'ConditionalExpression', test, consequent, alternate };
+}
+
+/**
+ * @param {ESTree.LogicalOperator} operator
+ * @param {ESTree.Expression} left
+ * @param {ESTree.Expression} right
+ * @returns {ESTree.LogicalExpression}
+ */
+export function logical(operator, left, right) {
+	return { type: 'LogicalExpression', operator, left, right };
+}
+
+/**
+ * @param {ESTree.VariableDeclaration['kind']} kind
+ * @param {ESTree.VariableDeclarator[]} declarations
+ * @returns {ESTree.VariableDeclaration}
+ */
+export function declaration(kind, declarations) {
+	return {
+		type: 'VariableDeclaration',
+		kind,
+		declarations
+	};
+}
+
+/**
+ * @param {ESTree.Pattern | string} pattern
+ * @param {ESTree.Expression | null} [init]
+ * @returns {ESTree.VariableDeclarator}
+ */
+export function declarator(pattern, init) {
+	if (typeof pattern === 'string') pattern = id(pattern);
+	return { type: 'VariableDeclarator', id: pattern, init };
+}
+
+/** @type {ESTree.EmptyStatement} */
+export const empty = {
+	type: 'EmptyStatement'
+};
+
+/**
+ * @param {ESTree.Expression | ESTree.MaybeNamedClassDeclaration | ESTree.MaybeNamedFunctionDeclaration} declaration
+ * @returns {ESTree.ExportDefaultDeclaration}
+ */
+export function export_default(declaration) {
+	return { type: 'ExportDefaultDeclaration', declaration };
+}
+
+/**
+ * @param {ESTree.VariableDeclaration | ESTree.Pattern} left
+ * @param {ESTree.Expression} right
+ * @param {ESTree.Statement} body
+ * @param {boolean} [_await]
+ * @returns {ESTree.ForOfStatement}
+ */
+export function for_of(left, right, body, _await = false) {
+	return {
+		type: 'ForOfStatement',
+		left,
+		right,
+		body,
+		await: _await
+	};
+}
+
+/**
+ * @param {ESTree.Identifier} id
+ * @param {ESTree.Pattern[]} params
+ * @param {ESTree.BlockStatement} body
+ * @param {boolean} async
+ * @returns {ESTree.FunctionDeclaration}
+ */
+export function function_declaration(id, params, body, async = false) {
+	return {
+		type: 'FunctionDeclaration',
+		id,
+		params,
+		body,
+		generator: false,
+		async
+	};
+}
+
+/**
+ * @param {string} name
+ * @param {ESTree.Statement[]} body
+ * @returns {ESTree.Property & { value: ESTree.FunctionExpression}}}
+ */
+export function get(name, body) {
+	return prop('get', key(name), function_builder(null, [], block(body)));
+}
+
+/**
+ * @param {string} name
+ * @param {ESTree.SourceLocation | null} [loc]
+ * @returns {ESTree.Identifier}
+ */
+export function id(name, loc) {
+	const node = /** @type {ESTree.Identifier} */ ({ type: 'Identifier', name });
+	if (loc) node.loc = loc;
+
+	return node;
+}
+
+/**
+ * @param {string} name
+ * @returns {ESTree.PrivateIdentifier}
+ */
+export function private_id(name) {
+	return { type: 'PrivateIdentifier', name };
+}
+
+/**
+ * @param {string} local
+ * @returns {ESTree.ImportNamespaceSpecifier}
+ */
+function import_namespace(local) {
+	return {
+		type: 'ImportNamespaceSpecifier',
+		local: id(local)
+	};
+}
+
+/**
+ * @param {string} name
+ * @param {ESTree.Expression} value
+ * @returns {ESTree.Property}
+ */
+export function init(name, value) {
+	return prop('init', key(name), value);
+}
+
+/**
+ * @param {string | boolean | null | number | RegExp} value
+ * @returns {ESTree.Literal}
+ */
+export function literal(value) {
+	// @ts-expect-error we don't want to muck around with bigint here
+	return { type: 'Literal', value };
+}
+
+/**
+ * @param {ESTree.Expression | ESTree.Super} object
+ * @param {string | ESTree.Expression | ESTree.PrivateIdentifier} property
+ * @param {boolean} computed
+ * @param {boolean} optional
+ * @returns {ESTree.MemberExpression}
+ */
+export function member(object, property, computed = false, optional = false) {
+	if (typeof property === 'string') {
+		property = id(property);
+	}
+
+	return { type: 'MemberExpression', object, property, computed, optional };
+}
+
+/**
+ * @param {string} path
+ * @returns {ESTree.Identifier | ESTree.MemberExpression}
+ */
+export function member_id(path) {
+	const parts = path.split('.');
+
+	/** @type {ESTree.Identifier | ESTree.MemberExpression} */
+	let expression = id(parts[0]);
+
+	for (let i = 1; i < parts.length; i += 1) {
+		expression = member(expression, id(parts[i]));
+	}
+	return expression;
+}
+
+/**
+ * @param {Array<ESTree.Property | ESTree.SpreadElement>} properties
+ * @returns {ESTree.ObjectExpression}
+ */
+export function object(properties) {
+	return { type: 'ObjectExpression', properties };
+}
+
+/**
+ * @param {Array<ESTree.RestElement | ESTree.AssignmentProperty | ESTree.Property>} properties
+ * @returns {ESTree.ObjectPattern}
+ */
+export function object_pattern(properties) {
+	// @ts-expect-error the types appear to be wrong
+	return { type: 'ObjectPattern', properties };
+}
+
+/**
+ * @template {ESTree.Expression} Value
+ * @param {'init' | 'get' | 'set'} kind
+ * @param {ESTree.Expression} key
+ * @param {Value} value
+ * @param {boolean} computed
+ * @returns {ESTree.Property & { value: Value }}
+ */
+export function prop(kind, key, value, computed = false) {
+	return { type: 'Property', kind, key, value, method: false, shorthand: false, computed };
+}
+
+/**
+ * @param {ESTree.Expression | ESTree.PrivateIdentifier} key
+ * @param {ESTree.Expression | null | undefined} value
+ * @param {boolean} computed
+ * @param {boolean} is_static
+ * @returns {ESTree.PropertyDefinition}
+ */
+export function prop_def(key, value, computed = false, is_static = false) {
+	return {
+		type: 'PropertyDefinition',
+		decorators: [],
+		key,
+		value,
+		computed,
+		static: is_static
+	};
+}
+
+/**
+ * @param {string} cooked
+ * @param {boolean} tail
+ * @returns {ESTree.TemplateElement}
+ */
+export function quasi(cooked, tail = false) {
+	const raw = sanitize_template_string(cooked);
+	return { type: 'TemplateElement', value: { raw, cooked }, tail };
+}
+
+/**
+ * @param {ESTree.Pattern} argument
+ * @returns {ESTree.RestElement}
+ */
+export function rest(argument) {
+	return { type: 'RestElement', argument };
+}
+
+/**
+ * @param {ESTree.Expression[]} expressions
+ * @returns {ESTree.SequenceExpression}
+ */
+export function sequence(expressions) {
+	return { type: 'SequenceExpression', expressions };
+}
+
+/**
+ * @param {string} name
+ * @param {ESTree.Statement[]} body
+ * @returns {ESTree.Property & { value: ESTree.FunctionExpression}}
+ */
+export function set(name, body) {
+	return prop('set', key(name), function_builder(null, [id('$$value')], block(body)));
+}
+
+/**
+ * @param {ESTree.Expression} argument
+ * @returns {ESTree.SpreadElement}
+ */
+export function spread(argument) {
+	return { type: 'SpreadElement', argument };
+}
+
+/**
+ * @param {ESTree.Expression} expression
+ * @returns {ESTree.ExpressionStatement}
+ */
+export function stmt(expression) {
+	return { type: 'ExpressionStatement', expression };
+}
+
+/**
+ * @param {ESTree.TemplateElement[]} elements
+ * @param {ESTree.Expression[]} expressions
+ * @returns {ESTree.TemplateLiteral}
+ */
+export function template(elements, expressions) {
+	return { type: 'TemplateLiteral', quasis: elements, expressions };
+}
+
+/**
+ * @param {ESTree.Expression | ESTree.BlockStatement} expression
+ * @param {boolean} [async]
+ * @returns {ESTree.Expression}
+ */
+export function thunk(expression, async = false) {
+	return unthunk(arrow([], expression, async));
+}
+
+/**
+ * Replace "(arg) => func(arg)" to "func"
+ * @param {ESTree.ArrowFunctionExpression} expression
+ * @returns {ESTree.Expression}
+ */
+export function unthunk(expression) {
+	// optimize `async () => await x()`, but not `async () => await x(await y)`
+	if (expression.async && expression.body.type === 'AwaitExpression') {
+		if (!has_await_expression(expression.body.argument)) {
+			return unthunk(arrow(expression.params, expression.body.argument));
+		}
+	}
+
+	if (
+		expression.async === false &&
+		expression.body.type === 'CallExpression' &&
+		expression.body.callee.type === 'Identifier' &&
+		expression.params.length === expression.body.arguments.length &&
+		expression.params.every((param, index) => {
+			const arg = /** @type {ESTree.SimpleCallExpression} */ (expression.body).arguments[index];
+			return param.type === 'Identifier' && arg.type === 'Identifier' && param.name === arg.name;
+		})
+	) {
+		return expression.body.callee;
+	}
+	return expression;
+}
+
+/**
+ *
+ * @param {string | ESTree.Expression} expression
+ * @param  {...ESTree.Expression} args
+ * @returns {ESTree.NewExpression}
+ */
+function new_builder(expression, ...args) {
+	if (typeof expression === 'string') expression = id(expression);
+
+	return {
+		callee: expression,
+		arguments: args,
+		type: 'NewExpression'
+	};
+}
+
+/**
+ * @param {ESTree.UpdateOperator} operator
+ * @param {ESTree.Expression} argument
+ * @param {boolean} prefix
+ * @returns {ESTree.UpdateExpression}
+ */
+export function update(operator, argument, prefix = false) {
+	return { type: 'UpdateExpression', operator, argument, prefix };
+}
+
+/**
+ * @param {ESTree.Expression} test
+ * @param {ESTree.Statement} body
+ * @returns {ESTree.DoWhileStatement}
+ */
+export function do_while(test, body) {
+	return { type: 'DoWhileStatement', test, body };
+}
+
+const true_instance = literal(true);
+const false_instance = literal(false);
+const null_instance = literal(null);
+
+/** @type {ESTree.DebuggerStatement} */
+const debugger_builder = {
+	type: 'DebuggerStatement'
+};
+
+/** @type {ESTree.ThisExpression} */
+const this_instance = {
+	type: 'ThisExpression'
+};
+
+/**
+ * @param {string | ESTree.Pattern} pattern
+ * @param {ESTree.Expression | null} [init]
+ * @returns {ESTree.VariableDeclaration}
+ */
+function let_builder(pattern, init) {
+	return declaration('let', [declarator(pattern, init)]);
+}
+
+/**
+ * @param {string | ESTree.Pattern} pattern
+ * @param {ESTree.Expression | null} init
+ * @returns {ESTree.VariableDeclaration}
+ */
+function const_builder(pattern, init) {
+	return declaration('const', [declarator(pattern, init)]);
+}
+
+/**
+ * @param {string | ESTree.Pattern} pattern
+ * @param {ESTree.Expression | null} [init]
+ * @returns {ESTree.VariableDeclaration}
+ */
+function var_builder(pattern, init) {
+	return declaration('var', [declarator(pattern, init)]);
+}
+
+/**
+ *
+ * @param {ESTree.VariableDeclaration | ESTree.Expression | null} init
+ * @param {ESTree.Expression} test
+ * @param {ESTree.Expression} update
+ * @param {ESTree.Statement} body
+ * @returns {ESTree.ForStatement}
+ */
+function for_builder(init, test, update, body) {
+	return { type: 'ForStatement', init, test, update, body };
+}
+
+/**
+ *
+ * @param {'constructor' | 'method' | 'get' | 'set'} kind
+ * @param {ESTree.Expression | ESTree.PrivateIdentifier} key
+ * @param {ESTree.Pattern[]} params
+ * @param {ESTree.Statement[]} body
+ * @param {boolean} computed
+ * @param {boolean} is_static
+ * @returns {ESTree.MethodDefinition}
+ */
+export function method(kind, key, params, body, computed = false, is_static = false) {
+	return {
+		type: 'MethodDefinition',
+		decorators: [],
+		key,
+		kind,
+		value: function_builder(null, params, block(body)),
+		computed,
+		static: is_static
+	};
+}
+
+/**
+ *
+ * @param {ESTree.Identifier | null} id
+ * @param {ESTree.Pattern[]} params
+ * @param {ESTree.BlockStatement} body
+ * @returns {ESTree.FunctionExpression}
+ */
+function function_builder(id, params, body, async = false) {
+	return {
+		type: 'FunctionExpression',
+		id,
+		params,
+		body,
+		generator: false,
+		async
+	};
+}
+
+/**
+ * @param {ESTree.Expression} test
+ * @param {ESTree.Statement} consequent
+ * @param {ESTree.Statement} [alternate]
+ * @returns {ESTree.IfStatement}
+ */
+function if_builder(test, consequent, alternate) {
+	return { type: 'IfStatement', test, consequent, alternate };
+}
+
+/**
+ * @param {string} as
+ * @param {string} source
+ * @returns {ESTree.ImportDeclaration}
+ */
+export function import_all(as, source) {
+	return {
+		type: 'ImportDeclaration',
+		attributes: [],
+		source: literal(source),
+		specifiers: [import_namespace(as)]
+	};
+}
+
+/**
+ * @param {Array<[string, string]>} parts
+ * @param {string} source
+ * @returns {ESTree.ImportDeclaration}
+ */
+export function imports(parts, source) {
+	return {
+		type: 'ImportDeclaration',
+		attributes: [],
+		source: literal(source),
+		specifiers: parts.map((p) => ({
+			type: 'ImportSpecifier',
+			imported: id(p[0]),
+			local: id(p[1])
+		}))
+	};
+}
+
+/**
+ * @param {ESTree.Expression | null} argument
+ * @returns {ESTree.ReturnStatement}
+ */
+function return_builder(argument = null) {
+	return { type: 'ReturnStatement', argument };
+}
+
+/**
+ * @param {string} str
+ * @returns {ESTree.ThrowStatement}
+ */
+export function throw_error(str) {
+	return {
+		type: 'ThrowStatement',
+		argument: new_builder('Error', literal(str))
+	};
+}
+
+export {
+	await_builder as await,
+	let_builder as let,
+	const_builder as const,
+	var_builder as var,
+	true_instance as true,
+	false_instance as false,
+	for_builder as for,
+	function_builder as function,
+	return_builder as return,
+	if_builder as if,
+	this_instance as this,
+	null_instance as null,
+	debugger_builder as debugger
+};
+
+/**
+ * @param {string} name
+ * @returns {ESTree.Expression}
+ */
+export function key(name) {
+	return regex_is_valid_identifier.test(name) ? id(name) : literal(name);
+}