lumen-plus 0.0.2 → 0.0.4

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

@@ -0,0 +1,125 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../../types' */
+import * as e from '../../../../errors.js';
+import { is_text_attribute } from '../../../../utils/ast.js';
+import * as w from '../../../../warnings.js';
+import { is_custom_element_node } from '../../../nodes.js';
+import { regex_only_whitespaces } from '../../../patterns.js';
+
+/**
+ * @param {AST.Attribute} attribute
+ */
+export function validate_attribute_name(attribute) {
+	if (
+		attribute.name.includes(':') &&
+		!attribute.name.startsWith('xmlns:') &&
+		!attribute.name.startsWith('xlink:') &&
+		!attribute.name.startsWith('xml:')
+	) {
+		w.attribute_illegal_colon(attribute);
+	}
+}
+
+/**
+ * @param {AST.Attribute} attribute
+ * @param {AST.ElementLike} parent
+ */
+export function validate_attribute(attribute, parent) {
+	if (
+		Array.isArray(attribute.value) &&
+		attribute.value.length === 1 &&
+		attribute.value[0].type === 'ExpressionTag' &&
+		(parent.type === 'Component' ||
+			parent.type === 'SvelteComponent' ||
+			parent.type === 'SvelteSelf' ||
+			(parent.type === 'RegularElement' && is_custom_element_node(parent)))
+	) {
+		w.attribute_quoted(attribute);
+	}
+
+	if (attribute.value === true || !Array.isArray(attribute.value) || attribute.value.length === 1) {
+		return;
+	}
+
+	const is_quoted = attribute.value.at(-1)?.end !== attribute.end;
+
+	if (!is_quoted) {
+		e.attribute_unquoted_sequence(attribute);
+	}
+}
+
+/**
+ * @param {Context} context
+ * @param {AST.Attribute} attribute
+ * @param {boolean} is_component
+ */
+export function validate_slot_attribute(context, attribute, is_component = false) {
+	const parent = context.path.at(-2);
+	let owner = undefined;
+
+	if (parent?.type === 'SnippetBlock') {
+		if (!is_text_attribute(attribute)) {
+			e.slot_attribute_invalid(attribute);
+		}
+		return;
+	}
+
+	let i = context.path.length;
+	while (i--) {
+		const ancestor = context.path[i];
+		if (
+			!owner &&
+			(ancestor.type === 'Component' ||
+				ancestor.type === 'SvelteComponent' ||
+				ancestor.type === 'SvelteSelf' ||
+				ancestor.type === 'SvelteElement' ||
+				(ancestor.type === 'RegularElement' && is_custom_element_node(ancestor)))
+		) {
+			owner = ancestor;
+		}
+	}
+
+	if (owner) {
+		if (
+			owner.type === 'Component' ||
+			owner.type === 'SvelteComponent' ||
+			owner.type === 'SvelteSelf'
+		) {
+			if (owner !== parent) {
+				if (!is_component) {
+					e.slot_attribute_invalid_placement(attribute);
+				}
+			} else {
+				if (!is_text_attribute(attribute)) {
+					e.slot_attribute_invalid(attribute);
+				}
+
+				const name = attribute.value[0].data;
+
+				if (context.state.component_slots.has(name)) {
+					e.slot_attribute_duplicate(attribute, name, owner.name);
+				}
+
+				context.state.component_slots.add(name);
+
+				if (name === 'default') {
+					for (const node of owner.fragment.nodes) {
+						if (node.type === 'Text' && regex_only_whitespaces.test(node.data)) {
+							continue;
+						}
+
+						if (node.type === 'RegularElement' || node.type === 'SvelteFragment') {
+							if (node.attributes.some((a) => a.type === 'Attribute' && a.name === 'slot')) {
+								continue;
+							}
+						}
+
+						e.slot_default_duplicate(node);
+					}
+				}
+			}
+		}
+	} else if (!is_component) {
+		e.slot_attribute_invalid_placement(attribute);
+	}
+}

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

@@ -0,0 +1,177 @@
+/** @import { Expression } from 'estree' */
+/** @import { AST } from '#compiler' */
+/** @import { AnalysisState, Context } from '../../types' */
+import * as e from '../../../../errors.js';
+import { get_attribute_expression, is_expression_attribute } from '../../../../utils/ast.js';
+import { determine_slot } from '../../../../utils/slot.js';
+import {
+	validate_attribute,
+	validate_attribute_name,
+	validate_slot_attribute
+} from './attribute.js';
+import { mark_subtree_dynamic } from './fragment.js';
+import { is_resolved_snippet } from './snippets.js';
+
+/**
+ * @param {AST.Component | AST.SvelteComponent | AST.SvelteSelf} node
+ * @param {Context} context
+ */
+export function visit_component(node, context) {
+	node.metadata.path = [...context.path];
+
+	// link this node to all the snippets that it could render, so that we can prune CSS correctly
+	node.metadata.snippets = new Set();
+
+	// 'resolved' means we know which snippets this component might render. if it is `false`,
+	// then `node.metadata.snippets` is populated with every locally defined snippet
+	// once analysis is complete
+	let resolved = true;
+
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'SpreadAttribute' || attribute.type === 'BindDirective') {
+			resolved = false;
+			continue;
+		}
+
+		if (attribute.type !== 'Attribute' || !is_expression_attribute(attribute)) {
+			continue;
+		}
+
+		const expression = get_attribute_expression(attribute);
+
+		// given an attribute like `foo={bar}`, if `bar` resolves to an import or a prop
+		// then we know it doesn't reference a locally defined snippet. if it resolves
+		// to a `{#snippet bar()}` then we know _which_ snippet it resolves to. in all
+		// other cases, we can't know (without much more complex static analysis) which
+		// snippets the component might render, so we treat the component as unresolved
+		if (expression.type === 'Identifier') {
+			const binding = context.state.scope.get(expression.name);
+
+			resolved &&= is_resolved_snippet(binding);
+
+			if (binding?.initial?.type === 'SnippetBlock') {
+				node.metadata.snippets.add(binding.initial);
+			}
+		} else if (expression.type !== 'Literal') {
+			resolved = false;
+		}
+	}
+
+	if (resolved) {
+		for (const child of node.fragment.nodes) {
+			if (child.type === 'SnippetBlock') {
+				node.metadata.snippets.add(child);
+			}
+		}
+	}
+
+	context.state.analysis.snippet_renderers.set(node, resolved);
+
+	mark_subtree_dynamic(context.path);
+
+	for (const attribute of node.attributes) {
+		if (
+			attribute.type !== 'Attribute' &&
+			attribute.type !== 'SpreadAttribute' &&
+			attribute.type !== 'LetDirective' &&
+			attribute.type !== 'OnDirective' &&
+			attribute.type !== 'BindDirective' &&
+			attribute.type !== 'AttachTag'
+		) {
+			e.component_invalid_directive(attribute);
+		}
+
+		if (
+			attribute.type === 'OnDirective' &&
+			(attribute.modifiers.length > 1 || attribute.modifiers.some((m) => m !== 'once'))
+		) {
+			e.event_handler_invalid_component_modifier(attribute);
+		}
+
+		if (attribute.type === 'Attribute') {
+			if (context.state.analysis.runes) {
+				validate_attribute(attribute, node);
+
+				if (is_expression_attribute(attribute)) {
+					disallow_unparenthesized_sequences(
+						get_attribute_expression(attribute),
+						context.state.analysis.source
+					);
+				}
+			}
+
+			validate_attribute_name(attribute);
+
+			if (attribute.name === 'slot') {
+				validate_slot_attribute(context, attribute, true);
+			}
+		}
+
+		if (attribute.type === 'BindDirective' && attribute.name !== 'this') {
+			context.state.analysis.uses_component_bindings = true;
+		}
+
+		if (attribute.type === 'AttachTag') {
+			disallow_unparenthesized_sequences(attribute.expression, context.state.analysis.source);
+		}
+	}
+
+	// If the component has a slot attribute — `<Foo slot="whatever" .../>` —
+	// then `let:` directives apply to other attributes, instead of just the
+	// top-level contents of the component. Yes, this is very weird.
+	const default_state = determine_slot(node)
+		? context.state
+		: { ...context.state, scope: node.metadata.scopes.default };
+
+	for (const attribute of node.attributes) {
+		context.visit(attribute, attribute.type === 'LetDirective' ? default_state : context.state);
+	}
+
+	/** @type {AST.Comment[]} */
+	let comments = [];
+
+	/** @type {Record<string, AST.Fragment['nodes']>} */
+	const nodes = { default: [] };
+
+	for (const child of node.fragment.nodes) {
+		if (child.type === 'Comment') {
+			comments.push(child);
+			continue;
+		}
+
+		const slot_name = determine_slot(child) ?? 'default';
+		(nodes[slot_name] ??= []).push(...comments, child);
+
+		if (slot_name !== 'default') comments = [];
+	}
+
+	/** @type {Set<string>} */
+	const component_slots = new Set();
+
+	for (const slot_name in nodes) {
+		/** @type {AnalysisState} */
+		const state = {
+			...context.state,
+			scope: node.metadata.scopes[slot_name],
+			parent_element: null,
+			component_slots
+		};
+
+		context.visit({ ...node.fragment, nodes: nodes[slot_name] }, state);
+	}
+}
+
+/**
+ * @param {Expression} expression
+ * @param {string} source
+ */
+function disallow_unparenthesized_sequences(expression, source) {
+	if (expression.type === 'SequenceExpression') {
+		let i = /** @type {number} */ (expression.start);
+		while (--i > 0) {
+			const char = source[i];
+			if (char === '(') break; // parenthesized sequence expressions are ok
+			if (char === '{') e.attribute_invalid_sequence_expression(expression);
+		}
+	}
+}

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

@@ -0,0 +1,160 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../../types' */
+import { get_attribute_expression, is_expression_attribute } from '../../../../utils/ast.js';
+import { regex_illegal_attribute_character } from '../../../patterns.js';
+import * as e from '../../../../errors.js';
+import * as w from '../../../../warnings.js';
+import {
+	validate_attribute,
+	validate_attribute_name,
+	validate_slot_attribute
+} from './attribute.js';
+
+const EVENT_MODIFIERS = [
+	'preventDefault',
+	'stopPropagation',
+	'stopImmediatePropagation',
+	'capture',
+	'once',
+	'passive',
+	'nonpassive',
+	'self',
+	'trusted'
+];
+
+/**
+ * @param {AST.RegularElement | AST.SvelteElement} node
+ * @param {Context} context
+ */
+export function validate_element(node, context) {
+	let has_animate_directive = false;
+
+	/** @type {AST.TransitionDirective | null} */
+	let in_transition = null;
+
+	/** @type {AST.TransitionDirective | null} */
+	let out_transition = null;
+
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'Attribute') {
+			const is_expression = is_expression_attribute(attribute);
+
+			if (context.state.analysis.runes) {
+				validate_attribute(attribute, node);
+
+				if (is_expression) {
+					const expression = get_attribute_expression(attribute);
+					if (expression.type === 'SequenceExpression') {
+						let i = /** @type {number} */ (expression.start);
+						while (--i > 0) {
+							const char = context.state.analysis.source[i];
+							if (char === '(') break; // parenthesized sequence expressions are ok
+							if (char === '{') e.attribute_invalid_sequence_expression(expression);
+						}
+					}
+				}
+			}
+
+			if (regex_illegal_attribute_character.test(attribute.name)) {
+				e.attribute_invalid_name(attribute, attribute.name);
+			}
+
+			if (attribute.name.startsWith('on') && attribute.name.length > 2) {
+				if (!is_expression) {
+					e.attribute_invalid_event_handler(attribute);
+				}
+
+				const value = get_attribute_expression(attribute);
+				if (
+					value.type === 'Identifier' &&
+					value.name === attribute.name &&
+					!context.state.scope.get(value.name)
+				) {
+					w.attribute_global_event_reference(attribute, attribute.name);
+				}
+			}
+
+			if (attribute.name === 'slot') {
+				/** @type {AST.RegularElement | AST.SvelteElement | AST.Component | AST.SvelteComponent | AST.SvelteSelf | undefined} */
+				validate_slot_attribute(context, attribute);
+			}
+
+			if (attribute.name === 'is') {
+				w.attribute_avoid_is(attribute);
+			}
+
+			const correct_name = react_attributes.get(attribute.name);
+			if (correct_name) {
+				w.attribute_invalid_property_name(attribute, attribute.name, correct_name);
+			}
+
+			validate_attribute_name(attribute);
+		} else if (attribute.type === 'AnimateDirective') {
+			const parent = context.path.at(-2);
+			if (parent?.type !== 'EachBlock') {
+				e.animation_invalid_placement(attribute);
+			} else if (!parent.key) {
+				e.animation_missing_key(attribute);
+			} else if (
+				parent.body.nodes.filter(
+					(n) =>
+						n.type !== 'Comment' &&
+						n.type !== 'ConstTag' &&
+						(n.type !== 'Text' || n.data.trim() !== '')
+				).length > 1
+			) {
+				e.animation_invalid_placement(attribute);
+			}
+
+			if (has_animate_directive) {
+				e.animation_duplicate(attribute);
+			} else {
+				has_animate_directive = true;
+			}
+		} else if (attribute.type === 'TransitionDirective') {
+			const existing = /** @type {AST.TransitionDirective | null} */ (
+				(attribute.intro && in_transition) || (attribute.outro && out_transition)
+			);
+
+			if (existing) {
+				const a = existing.intro ? (existing.outro ? 'transition' : 'in') : 'out';
+				const b = attribute.intro ? (attribute.outro ? 'transition' : 'in') : 'out';
+
+				if (a === b) {
+					e.transition_duplicate(attribute, a);
+				} else {
+					e.transition_conflict(attribute, a, b);
+				}
+			}
+
+			if (attribute.intro) in_transition = attribute;
+			if (attribute.outro) out_transition = attribute;
+		} else if (attribute.type === 'OnDirective') {
+			let has_passive_modifier = false;
+			let conflicting_passive_modifier = '';
+			for (const modifier of attribute.modifiers) {
+				if (!EVENT_MODIFIERS.includes(modifier)) {
+					const list = `${EVENT_MODIFIERS.slice(0, -1).join(', ')} or ${EVENT_MODIFIERS.at(-1)}`;
+					e.event_handler_invalid_modifier(attribute, list);
+				}
+				if (modifier === 'passive') {
+					has_passive_modifier = true;
+				} else if (modifier === 'nonpassive' || modifier === 'preventDefault') {
+					conflicting_passive_modifier = modifier;
+				}
+				if (has_passive_modifier && conflicting_passive_modifier) {
+					e.event_handler_invalid_modifier_combination(
+						attribute,
+						'passive',
+						conflicting_passive_modifier
+					);
+				}
+			}
+		}
+	}
+}
+
+const react_attributes = new Map([
+	['className', 'class'],
+	['htmlFor', 'for']
+]);

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

@@ -0,0 +1,15 @@
+/** @import { AST } from '#compiler' */
+
+/**
+ * @param {AST.SvelteNode[]} path
+ */
+export function mark_subtree_dynamic(path) {
+	let i = path.length;
+	while (i--) {
+		const node = path[i];
+		if (node.type === 'Fragment') {
+			if (node.metadata.dynamic) return;
+			node.metadata.dynamic = true;
+		}
+	}
+}

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

@@ -0,0 +1,24 @@
+/** @import { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from 'estree' */
+/** @import { Context } from '../../types' */
+
+/**
+ * @param {ArrowFunctionExpression | FunctionExpression | FunctionDeclaration} node
+ * @param {Context} context
+ */
+export function visit_function(node, context) {
+	if (context.state.expression) {
+		for (const [name] of context.state.scope.references) {
+			const binding = context.state.scope.get(name);
+
+			if (binding && binding.scope.function_depth < context.state.scope.function_depth) {
+				context.state.expression.references.add(binding);
+			}
+		}
+	}
+
+	context.next({
+		...context.state,
+		function_depth: context.state.function_depth + 1,
+		expression: null
+	});
+}

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

@@ -0,0 +1,17 @@
+/** @import { Binding } from '#compiler' */
+
+/**
+ * Returns `true` if a binding unambiguously resolves to a specific
+ * snippet declaration, or is external to the current component
+ * @param {Binding | null} binding
+ */
+export function is_resolved_snippet(binding) {
+	return (
+		!binding ||
+		binding.declaration_kind === 'import' ||
+		binding.kind === 'prop' ||
+		binding.kind === 'rest_prop' ||
+		binding.kind === 'bindable_prop' ||
+		binding?.initial?.type === 'SnippetBlock'
+	);
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/shared/special-element.js

@@ -0,0 +1,16 @@
+/** @import { AST } from '#compiler' */
+import * as e from '../../../../errors.js';
+
+/**
+ * @param {AST.SvelteBody | AST.SvelteDocument | AST.SvelteOptionsRaw | AST.SvelteWindow} node
+ */
+export function disallow_children(node) {
+	const { nodes } = node.fragment;
+
+	if (nodes.length > 0) {
+		const first = nodes[0];
+		const last = nodes[nodes.length - 1];
+
+		e.svelte_meta_invalid_content({ start: first.start, end: last.end }, node.name);
+	}
+}