lumen-plus 0.0.3 → 0.0.4

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/EachBlock.js

@@ -0,0 +1,97 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST, Binding } from '#compiler' */
+/** @import { Context } from '../types' */
+/** @import { Scope } from '../../scope' */
+import * as e from '../../../errors.js';
+import { extract_identifiers } from '../../../utils/ast.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {AST.EachBlock} node
+ * @param {Context} context
+ */
+export function EachBlock(node, context) {
+	validate_opening_tag(node, context.state, '#');
+
+	validate_block_not_empty(node.body, context);
+	validate_block_not_empty(node.fallback, context);
+
+	const id = node.context;
+	if (id?.type === 'Identifier' && (id.name === '$state' || id.name === '$derived')) {
+		// TODO weird that this is necessary
+		e.state_invalid_placement(node, id.name);
+	}
+
+	if (node.key) {
+		// treat `{#each items as item, i (i)}` as a normal indexed block, everything else as keyed
+		node.metadata.keyed =
+			node.key.type !== 'Identifier' || !node.index || node.key.name !== node.index;
+	}
+
+	if (node.metadata.keyed && !node.context) {
+		e.each_key_without_as(/** @type {Expression} */ (node.key));
+	}
+
+	// evaluate expression in parent scope
+	context.visit(node.expression, {
+		...context.state,
+		expression: node.metadata.expression,
+		scope: /** @type {Scope} */ (context.state.scope.parent)
+	});
+
+	context.visit(node.body);
+	if (node.key) context.visit(node.key);
+	if (node.fallback) context.visit(node.fallback);
+
+	if (!context.state.analysis.runes) {
+		let mutated =
+			!!node.context &&
+			extract_identifiers(node.context).some((id) => {
+				const binding = context.state.scope.get(id.name);
+				return !!binding?.mutated;
+			});
+
+		// collect transitive dependencies...
+		for (const binding of node.metadata.expression.dependencies) {
+			if (binding.declaration_kind !== 'function') {
+				collect_transitive_dependencies(binding, node.metadata.transitive_deps);
+			}
+		}
+
+		// ...and ensure they are marked as state, so they can be turned
+		// into mutable sources and invalidated
+		if (mutated) {
+			for (const binding of node.metadata.transitive_deps) {
+				if (
+					binding.kind === 'normal' &&
+					(binding.declaration_kind === 'const' ||
+						binding.declaration_kind === 'let' ||
+						binding.declaration_kind === 'var')
+				) {
+					binding.kind = 'state';
+				}
+			}
+		}
+	}
+
+	mark_subtree_dynamic(context.path);
+}
+
+/**
+ * @param {Binding} binding
+ * @param {Set<Binding>} bindings
+ * @returns {void}
+ */
+function collect_transitive_dependencies(binding, bindings) {
+	if (bindings.has(binding)) {
+		return;
+	}
+	bindings.add(binding);
+
+	if (binding.kind === 'legacy_reactive') {
+		for (const dep of binding.legacy_dependencies) {
+			collect_transitive_dependencies(dep, bindings);
+		}
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/ExportDefaultDeclaration.js

@@ -0,0 +1,20 @@
+/** @import { ExportDefaultDeclaration } from 'estree' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { validate_export } from './shared/utils.js';
+
+/**
+ * @param {ExportDefaultDeclaration} node
+ * @param {Context} context
+ */
+export function ExportDefaultDeclaration(node, context) {
+	if (!context.state.ast_type /* .svelte.js module */) {
+		if (node.declaration.type === 'Identifier') {
+			validate_export(node, context.state.scope, node.declaration.name);
+		}
+	} else {
+		e.module_illegal_default_export(node);
+	}
+
+	context.next();
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/ExportNamedDeclaration.js

@@ -0,0 +1,70 @@
+/** @import { ExportNamedDeclaration, Identifier } from 'estree' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { extract_identifiers } from '../../../utils/ast.js';
+
+/**
+ * @param {ExportNamedDeclaration} node
+ * @param {Context} context
+ */
+export function ExportNamedDeclaration(node, context) {
+	// visit children, so bindings are correctly initialised
+	context.next();
+
+	if (
+		context.state.ast_type &&
+		node.specifiers.some((specifier) =>
+			specifier.exported.type === 'Identifier'
+				? specifier.exported.name === 'default'
+				: specifier.exported.value === 'default'
+		)
+	) {
+		e.module_illegal_default_export(node);
+	}
+
+	if (node.declaration?.type === 'VariableDeclaration') {
+		// in runes mode, forbid `export let`
+		if (
+			context.state.analysis.runes &&
+			context.state.ast_type === 'instance' &&
+			node.declaration.kind === 'let'
+		) {
+			e.legacy_export_invalid(node);
+		}
+
+		for (const declarator of node.declaration.declarations) {
+			for (const id of extract_identifiers(declarator.id)) {
+				const binding = context.state.scope.get(id.name);
+				if (!binding) continue;
+
+				if (binding.kind === 'derived') {
+					e.derived_invalid_export(node);
+				}
+
+				if ((binding.kind === 'state' || binding.kind === 'raw_state') && binding.reassigned) {
+					e.state_invalid_export(node);
+				}
+			}
+		}
+	}
+
+	if (context.state.analysis.runes) {
+		if (node.declaration && context.state.ast_type === 'instance') {
+			if (
+				node.declaration.type === 'FunctionDeclaration' ||
+				node.declaration.type === 'ClassDeclaration'
+			) {
+				context.state.analysis.exports.push({
+					name: /** @type {Identifier} */ (node.declaration.id).name,
+					alias: null
+				});
+			} else if (node.declaration.kind === 'const') {
+				for (const declarator of node.declaration.declarations) {
+					for (const node of extract_identifiers(declarator.id)) {
+						context.state.analysis.exports.push({ name: node.name, alias: null });
+					}
+				}
+			}
+		}
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/ExportSpecifier.js

@@ -0,0 +1,30 @@
+/** @import { ExportSpecifier } from 'estree' */
+/** @import { Context } from '../types' */
+import { validate_export } from './shared/utils.js';
+
+/**
+ * @param {ExportSpecifier} node
+ * @param {Context} context
+ */
+export function ExportSpecifier(node, context) {
+	const local_name =
+		node.local.type === 'Identifier' ? node.local.name : /** @type {string} */ (node.local.value);
+	const exported_name =
+		node.exported.type === 'Identifier'
+			? node.exported.name
+			: /** @type {string} */ (node.exported.value);
+
+	if (context.state.ast_type === 'instance') {
+		if (context.state.analysis.runes) {
+			context.state.analysis.exports.push({
+				name: local_name,
+				alias: exported_name
+			});
+
+			const binding = context.state.scope.get(local_name);
+			if (binding) binding.reassigned = true;
+		}
+	} else {
+		validate_export(node, context.state.scope, local_name);
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/ExpressionStatement.js

@@ -0,0 +1,38 @@
+/** @import { ExpressionStatement, ImportDeclaration } from 'estree' */
+/** @import { Context } from '../types' */
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {ExpressionStatement} node
+ * @param {Context} context
+ */
+export function ExpressionStatement(node, context) {
+	// warn on `new Component({ target: ... })` if imported from a `.svelte` file
+	if (
+		node.expression.type === 'NewExpression' &&
+		node.expression.callee.type === 'Identifier' &&
+		node.expression.arguments.length === 1 &&
+		node.expression.arguments[0].type === 'ObjectExpression' &&
+		node.expression.arguments[0].properties.some(
+			(p) => p.type === 'Property' && p.key.type === 'Identifier' && p.key.name === 'target'
+		)
+	) {
+		const binding = context.state.scope.get(node.expression.callee.name);
+
+		if (binding?.kind === 'normal' && binding.declaration_kind === 'import') {
+			const declaration = /** @type {ImportDeclaration} */ (binding.initial);
+
+			// Theoretically someone could import a class from a `.svelte.js` module, but that's too rare to worry about
+			if (
+				/** @type {string} */ (declaration.source.value).endsWith('.svelte') &&
+				declaration.specifiers.find(
+					(s) => s.local.name === binding.node.name && s.type === 'ImportDefaultSpecifier'
+				)
+			) {
+				w.legacy_component_creation(node.expression);
+			}
+		}
+	}
+
+	context.next();
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js

@@ -0,0 +1,26 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { is_tag_valid_with_parent } from '../../../../html-tree-validation.js';
+import * as e from '../../../errors.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.ExpressionTag} node
+ * @param {Context} context
+ */
+export function ExpressionTag(node, context) {
+	const in_template = context.path.at(-1)?.type === 'Fragment';
+
+	if (in_template && context.state.parent_element) {
+		const message = is_tag_valid_with_parent('#text', context.state.parent_element);
+		if (message) {
+			e.node_invalid_placement(node, message);
+		}
+	}
+
+	// TODO ideally we wouldn't do this here, we'd just do it on encountering
+	// an `Identifier` within the tag. But we currently need to handle `{42}` etc
+	mark_subtree_dynamic(context.path);
+
+	context.next({ ...context.state, expression: node.metadata.expression });
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/Fragment.js

@@ -0,0 +1,10 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types.js' */
+
+/**
+ * @param {AST.Fragment} node
+ * @param {Context} context
+ */
+export function Fragment(node, context) {
+	context.next({ ...context.state, fragment: node });
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/FunctionDeclaration.js

@@ -0,0 +1,16 @@
+/** @import { FunctionDeclaration } from 'estree' */
+/** @import { Context } from '../types' */
+import { visit_function } from './shared/function.js';
+import { validate_identifier_name } from './shared/utils.js';
+
+/**
+ * @param {FunctionDeclaration} node
+ * @param {Context} context
+ */
+export function FunctionDeclaration(node, context) {
+	if (context.state.analysis.runes && node.id !== null) {
+		validate_identifier_name(context.state.scope.get(node.id.name));
+	}
+
+	visit_function(node, context);
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/FunctionExpression.js

@@ -0,0 +1,11 @@
+/** @import { FunctionExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import { visit_function } from './shared/function.js';
+
+/**
+ * @param {FunctionExpression} node
+ * @param {Context} context
+ */
+export function FunctionExpression(node, context) {
+	visit_function(node, context);
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/HtmlTag.js

@@ -0,0 +1,19 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { mark_subtree_dynamic } from './shared/fragment.js';
+import { validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {AST.HtmlTag} node
+ * @param {Context} context
+ */
+export function HtmlTag(node, context) {
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '@');
+	}
+
+	// unfortunately this is necessary in order to fix invalid HTML
+	mark_subtree_dynamic(context.path);
+
+	context.next({ ...context.state, expression: node.metadata.expression });
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js

@@ -0,0 +1,193 @@
+/** @import { Expression, Identifier } from 'estree' */
+/** @import { Context } from '../types' */
+import is_reference from 'is-reference';
+import { should_proxy } from '../../3-transform/client/utils.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import { is_rune } from '../../../../utils.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+import { get_rune } from '../../scope.js';
+import { is_component_node } from '../../nodes.js';
+
+/**
+ * @param {Identifier} node
+ * @param {Context} context
+ */
+export function Identifier(node, context) {
+	let i = context.path.length;
+	let parent = /** @type {Expression} */ (context.path[--i]);
+
+	if (!is_reference(node, parent)) {
+		return;
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	// If we are using arguments outside of a function, then throw an error
+	if (
+		node.name === 'arguments' &&
+		!context.path.some((n) => n.type === 'FunctionDeclaration' || n.type === 'FunctionExpression')
+	) {
+		e.invalid_arguments_usage(node);
+	}
+
+	// `$$slots` exists even in runes mode
+	if (node.name === '$$slots') {
+		context.state.analysis.uses_slots = true;
+	}
+
+	if (context.state.analysis.runes) {
+		if (
+			is_rune(node.name) &&
+			context.state.scope.get(node.name) === null &&
+			context.state.scope.get(node.name.slice(1))?.kind !== 'store_sub'
+		) {
+			/** @type {Expression} */
+			let current = node;
+			let name = node.name;
+
+			while (parent.type === 'MemberExpression') {
+				if (parent.computed) e.rune_invalid_computed_property(parent);
+				name += `.${/** @type {Identifier} */ (parent.property).name}`;
+
+				current = parent;
+				parent = /** @type {Expression} */ (context.path[--i]);
+
+				if (!is_rune(name)) {
+					if (name === '$effect.active') {
+						e.rune_renamed(parent, '$effect.active', '$effect.tracking');
+					}
+
+					if (name === '$state.frozen') {
+						e.rune_renamed(parent, '$state.frozen', '$state.raw');
+					}
+
+					if (name === '$state.is') {
+						e.rune_removed(parent, '$state.is');
+					}
+
+					e.rune_invalid_name(parent, name);
+				}
+			}
+
+			if (parent.type !== 'CallExpression') {
+				e.rune_missing_parentheses(current);
+			}
+		}
+	}
+
+	let binding = context.state.scope.get(node.name);
+
+	if (!context.state.analysis.runes) {
+		if (node.name === '$$props') {
+			context.state.analysis.uses_props = true;
+		}
+
+		if (node.name === '$$restProps') {
+			context.state.analysis.uses_rest_props = true;
+		}
+	}
+
+	if (binding) {
+		if (context.state.expression) {
+			context.state.expression.dependencies.add(binding);
+			context.state.expression.references.add(binding);
+			context.state.expression.has_state ||=
+				binding.kind !== 'static' &&
+				(binding.kind === 'prop' ||
+					binding.kind === 'bindable_prop' ||
+					binding.kind === 'rest_prop' ||
+					!binding.is_function()) &&
+				!context.state.scope.evaluate(node).is_known;
+		}
+
+		if (
+			context.state.analysis.runes &&
+			node !== binding.node &&
+			context.state.function_depth === binding.scope.function_depth &&
+			// If we have $state that can be proxied or frozen and isn't re-assigned, then that means
+			// it's likely not using a primitive value and thus this warning isn't that helpful.
+			((binding.kind === 'state' &&
+				(binding.reassigned ||
+					(binding.initial?.type === 'CallExpression' &&
+						binding.initial.arguments.length === 1 &&
+						binding.initial.arguments[0].type !== 'SpreadElement' &&
+						!should_proxy(binding.initial.arguments[0], context.state.scope)))) ||
+				binding.kind === 'raw_state' ||
+				binding.kind === 'derived' ||
+				binding.kind === 'prop') &&
+			// We're only concerned with reads here
+			(parent.type !== 'AssignmentExpression' || parent.left !== node) &&
+			parent.type !== 'UpdateExpression'
+		) {
+			let type = 'closure';
+
+			let i = context.path.length;
+			while (i--) {
+				const parent = context.path[i];
+
+				if (
+					parent.type === 'ArrowFunctionExpression' ||
+					parent.type === 'FunctionDeclaration' ||
+					parent.type === 'FunctionExpression'
+				) {
+					break;
+				}
+
+				if (
+					parent.type === 'CallExpression' &&
+					parent.arguments.includes(/** @type {any} */ (context.path[i + 1]))
+				) {
+					const rune = get_rune(parent, context.state.scope);
+
+					if (rune === '$state' || rune === '$state.raw') {
+						type = 'derived';
+						break;
+					}
+				}
+			}
+
+			w.state_referenced_locally(node, node.name, type);
+		}
+
+		if (
+			context.state.reactive_statement &&
+			binding.scope === context.state.analysis.module.scope &&
+			binding.reassigned
+		) {
+			w.reactive_declaration_module_script_dependency(node);
+		}
+
+		if (binding.metadata?.is_template_declaration && context.state.options.experimental.async) {
+			let snippet_name;
+
+			// Find out if this references a {@const ...} declaration of an implicit children snippet
+			// when it is itself inside a snippet block at the same level. If so, error.
+			for (let i = context.path.length - 1; i >= 0; i--) {
+				const parent = context.path[i];
+				const grand_parent = context.path[i - 1];
+
+				if (parent.type === 'SnippetBlock') {
+					snippet_name = parent.expression.name;
+				} else if (
+					snippet_name &&
+					grand_parent &&
+					parent.type === 'Fragment' &&
+					(is_component_node(grand_parent) ||
+						(grand_parent.type === 'SvelteBoundary' &&
+							(snippet_name === 'failed' || snippet_name === 'pending')))
+				) {
+					if (
+						is_component_node(grand_parent)
+							? grand_parent.metadata.scopes.default === binding.scope
+							: context.state.scopes.get(parent) === binding.scope
+					) {
+						e.const_tag_invalid_reference(node, node.name);
+					} else {
+						break;
+					}
+				}
+			}
+		}
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/IfBlock.js

@@ -0,0 +1,27 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { mark_subtree_dynamic } from './shared/fragment.js';
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {AST.IfBlock} node
+ * @param {Context} context
+ */
+export function IfBlock(node, context) {
+	validate_block_not_empty(node.consequent, context);
+	validate_block_not_empty(node.alternate, context);
+
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, node.elseif ? ':' : '#');
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	context.visit(node.test, {
+		...context.state,
+		expression: node.metadata.expression
+	});
+
+	context.visit(node.consequent);
+	if (node.alternate) context.visit(node.alternate);
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/ImportDeclaration.js

@@ -0,0 +1,31 @@
+/** @import { ImportDeclaration } from 'estree' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {ImportDeclaration} node
+ * @param {Context} context
+ */
+export function ImportDeclaration(node, context) {
+	if (context.state.analysis.runes) {
+		const source = /** @type {string} */ (node.source.value);
+
+		if (source.startsWith('svelte/internal')) {
+			e.import_svelte_internal_forbidden(node);
+		}
+
+		if (source === 'svelte') {
+			for (const specifier of node.specifiers) {
+				if (specifier.type === 'ImportSpecifier') {
+					if (
+						specifier.imported.type === 'Identifier' &&
+						(specifier.imported.name === 'beforeUpdate' ||
+							specifier.imported.name === 'afterUpdate')
+					) {
+						e.runes_mode_invalid_import(specifier, specifier.imported.name);
+					}
+				}
+			}
+		}
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/KeyBlock.js

@@ -0,0 +1,21 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { mark_subtree_dynamic } from './shared/fragment.js';
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+
+/**
+ * @param {AST.KeyBlock} node
+ * @param {Context} context
+ */
+export function KeyBlock(node, context) {
+	validate_block_not_empty(node.fragment, context);
+
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '#');
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	context.visit(node.expression, { ...context.state, expression: node.metadata.expression });
+	context.visit(node.fragment);
+}