@vigla/svelte 0.0.0-stage → 5.57.3

package/src/front/stores.ts

@@ -0,0 +1,98 @@
+import type * as ES from 'estree';
+import type { ExternalBinding, Rune } from 'vigla/compiler';
+import type { Resolution } from './runes.ts';
+
+function names(pattern: ES.Pattern): ES.Identifier[] {
+	switch (pattern.type) {
+		case 'Identifier':
+			return [pattern];
+		case 'ObjectPattern':
+			return pattern.properties.flatMap((property) =>
+				names(property.type === 'RestElement' ? property.argument : property.value)
+			);
+		case 'ArrayPattern':
+			return pattern.elements.flatMap((element) => (element === null ? [] : names(element)));
+		case 'AssignmentPattern':
+			return names(pattern.left);
+		case 'RestElement':
+			return names(pattern.argument);
+		default:
+			return [];
+	}
+}
+
+function declarations(program: ES.Program | null, into: Map<string, ES.Node | null>): void {
+	for (const item of program?.body ?? []) {
+		const statement = item.type === 'ExportNamedDeclaration' ? item.declaration : item;
+		if (statement?.type === 'ImportDeclaration') {
+			for (const specifier of statement.specifiers) into.set(specifier.local.name, statement);
+		} else if (statement?.type === 'VariableDeclaration') {
+			for (const declarator of statement.declarations) {
+				for (const name of names(declarator.id)) into.set(name.name, declarator.init ?? null);
+			}
+		} else if (
+			(statement?.type === 'FunctionDeclaration' || statement?.type === 'ClassDeclaration') &&
+			statement.id !== null
+		) {
+			into.set(statement.id.name, statement);
+		}
+	}
+}
+
+interface StoreBinding extends ExternalBinding {
+	readonly source: ES.Identifier;
+	readonly references: Set<ES.Identifier>;
+}
+
+const runeNames = new Set([
+	'$state',
+	'$derived',
+	'$effect',
+	'$props',
+	'$bindable',
+	'$inspect',
+	'$host'
+]);
+
+export function stores(
+	resolution: Resolution,
+	module: ES.Program | null,
+	instance: ES.Program | null
+): ExternalBinding[] {
+	const moduleDeclarations = new Map<string, ES.Node | null>();
+	declarations(module, moduleDeclarations);
+	const declared = new Map(moduleDeclarations);
+	declarations(instance, declared);
+	const bindings = new Map<string, StoreBinding>();
+	for (const [reference, name] of resolution.references) {
+		if (name === '$' || name.startsWith('$$')) continue;
+		const source = name.slice(1);
+		const at = (reference as ES.Identifier & { start?: number }).start ?? -1;
+		const span = module as (ES.Program & { start?: number; end?: number }) | null;
+		if (span !== null && at >= (span.start ?? 0) && at < (span.end ?? 0)) continue;
+		const initial = declared.get(source);
+		if (runeNames.has(name)) {
+			if (initial === undefined) continue;
+			const rune: Rune | undefined =
+				initial?.type === 'CallExpression' ? resolution.runes.get(initial.callee) : undefined;
+			if (rune !== undefined && (rune !== '$props' || source === 'props')) continue;
+			if (
+				name === '$derived' &&
+				initial?.type === 'ImportDeclaration' &&
+				initial.source.value === 'svelte/store'
+			)
+				continue;
+		}
+		let binding = bindings.get(name);
+		if (binding === undefined) {
+			binding = {
+				source: { type: 'Identifier', name: source },
+				name: source,
+				references: new Set()
+			};
+			bindings.set(name, binding);
+		}
+		binding.references.add(reference);
+	}
+	return [...bindings.values()];
+}

package/src/front/typescript.ts

@@ -0,0 +1,178 @@
+import { fail } from './diagnostics.ts';
+
+type Node = { type: string; [key: string]: unknown };
+
+const erasedStatements = new WeakSet<Node>();
+
+const empty = (): Node => {
+	const statement: Node = { type: 'EmptyStatement' };
+	erasedStatements.add(statement);
+	return statement;
+};
+
+const unwrapped = new Set([
+	'TSAsExpression',
+	'TSSatisfiesExpression',
+	'TSNonNullExpression',
+	'TSTypeAssertion',
+	'TSInstantiationExpression'
+]);
+
+const erased = new Set(['TSInterfaceDeclaration', 'TSTypeAliasDeclaration', 'TSDeclareFunction']);
+
+const typeFields = [
+	'typeAnnotation',
+	'typeParameters',
+	'typeArguments',
+	'returnType',
+	'accessibility',
+	'readonly',
+	'definite',
+	'override'
+];
+
+function isNode(value: unknown): value is Node {
+	return value !== null && typeof value === 'object' && typeof (value as Node).type === 'string';
+}
+
+class Stripper {
+	readonly path: Node[] = [];
+
+	children(node: Node): void {
+		this.path.push(node);
+		for (const key in node) {
+			if (key === 'type') continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (let index = 0; index < value.length; index++) {
+					if (isNode(value[index])) value[index] = this.visit(value[index] as Node);
+				}
+			} else if (isNode(value)) {
+				node[key] = this.visit(value);
+			}
+		}
+		this.path.pop();
+	}
+
+	clean(node: Node): Node {
+		for (const field of typeFields) delete node[field];
+		if (node.type !== 'MemberExpression' && node.type !== 'CallExpression') delete node.optional;
+		return node;
+	}
+
+	visit(node: Node): Node {
+		return this.clean(this.special(node));
+	}
+
+	special(node: Node): Node {
+		if (unwrapped.has(node.type)) return this.visit(node.expression as Node);
+		if (erased.has(node.type)) return empty();
+		switch (node.type) {
+			case 'Decorator':
+				fail('typescript_invalid_feature', node as never, {
+					feature: 'decorators (related TSC proposal is not stage 4 yet)'
+				});
+			case 'TSEnumDeclaration':
+				fail('typescript_invalid_feature', node as never, { feature: 'enums' });
+			case 'ImportDeclaration': {
+				if (node.importKind === 'type') return empty();
+				const specifiers = node.specifiers as Node[] | undefined;
+				if (specifiers !== undefined && specifiers.length > 0) {
+					const kept = specifiers.filter((specifier) => specifier.importKind !== 'type');
+					if (kept.length === 0) return empty();
+					node.specifiers = kept;
+				}
+				return node;
+			}
+			case 'ExportNamedDeclaration': {
+				if (node.exportKind === 'type') return empty();
+				if (node.declaration) {
+					this.children(node);
+					return (node.declaration as Node).type === 'EmptyStatement' ? empty() : node;
+				}
+				const specifiers = node.specifiers as Node[] | undefined;
+				if (specifiers) {
+					const kept = specifiers.filter((specifier) => specifier.exportKind !== 'type');
+					if (kept.length === 0) return empty();
+					node.specifiers = kept;
+				}
+				return node;
+			}
+			case 'ExportDefaultDeclaration':
+			case 'ExportAllDeclaration':
+				return node.exportKind === 'type' ? empty() : node;
+			case 'PropertyDefinition':
+				if (node.accessor) {
+					fail('typescript_invalid_feature', node as never, {
+						feature: 'accessor fields (related TSC proposal is not stage 4 yet)'
+					});
+				}
+				break;
+			case 'TSParameterProperty': {
+				if ((node.readonly || node.accessibility) && this.path.at(-2)?.kind === 'constructor') {
+					fail('typescript_invalid_feature', node as never, {
+						feature: 'accessibility modifiers on constructor parameters'
+					});
+				}
+				return this.visit(node.parameter as Node);
+			}
+			case 'FunctionExpression':
+			case 'FunctionDeclaration': {
+				const params = node.params as Node[];
+				const first = params[0];
+				if (first?.type === 'Identifier' && first.name === 'this') params.shift();
+				break;
+			}
+			case 'ClassBody': {
+				const body: Node[] = [];
+				this.path.push(node);
+				for (const member of node.body as Node[]) {
+					const child = this.visit(member);
+					if (child.type !== 'PropertyDefinition' || !child.declare) body.push(child);
+				}
+				this.path.pop();
+				node.body = body;
+				return node;
+			}
+			case 'ClassDeclaration':
+				if (node.declare) return empty();
+				delete node.abstract;
+				delete node.implements;
+				delete node.superTypeArguments;
+				delete node.superTypeParameters;
+				break;
+			case 'ClassExpression':
+				delete node.implements;
+				delete node.superTypeArguments;
+				delete node.superTypeParameters;
+				break;
+			case 'MethodDefinition':
+				if (node.abstract) return empty();
+				break;
+			case 'VariableDeclaration':
+				if (node.declare) return empty();
+				break;
+			case 'TSModuleDeclaration': {
+				const body = node.body as Node | undefined;
+				if (!body) return empty();
+				this.path.push(node);
+				const cleaned = (body.body as Node[]).map((entry) => this.visit(entry));
+				this.path.pop();
+				if (cleaned.some((entry) => !erasedStatements.has(entry))) {
+					fail('typescript_invalid_feature', node as never, {
+						feature: 'namespaces with non-type nodes'
+					});
+				}
+				return empty();
+			}
+			default:
+				break;
+		}
+		this.children(node);
+		return node;
+	}
+}
+
+export function stripTypes<T>(node: T): T {
+	return new Stripper().visit(node as unknown as Node) as unknown as T;
+}

package/src/front/validate/anchors.ts

@@ -0,0 +1,54 @@
+import type { Diagnostic } from 'vigla/compiler';
+
+export const stopped: unique symbol = Symbol('stopped');
+
+export interface Anchor {
+	warnings: Diagnostic[];
+	error?: Diagnostic;
+}
+
+export class Anchors {
+	readonly map = new Map<object, Anchor>();
+	failed = false;
+
+	#entry(node: object): Anchor {
+		let entry = this.map.get(node);
+		if (entry === undefined) {
+			entry = { warnings: [] };
+			this.map.set(node, entry);
+		}
+		return entry;
+	}
+
+	warn(node: object, warnings: readonly Diagnostic[]): void {
+		if (warnings.length > 0) this.#entry(node).warnings.push(...warnings);
+	}
+
+	fail(node: object, error: Diagnostic): void {
+		const entry = this.#entry(node);
+		entry.error ??= error;
+		this.failed = true;
+	}
+
+	translated(
+		lowered: ReadonlyMap<object, object>,
+		first: ReadonlyMap<object, readonly Diagnostic[]>
+	): Map<object, Anchor> {
+		const out = new Map<object, Anchor>();
+		const entry = (key: object): Anchor => {
+			let found = out.get(key);
+			if (found === undefined) {
+				found = { warnings: [] };
+				out.set(key, found);
+			}
+			return found;
+		};
+		for (const [node, warnings] of first) entry(node).warnings.push(...warnings);
+		for (const [node, anchor] of this.map) {
+			const target = entry(lowered.get(node) ?? node);
+			target.warnings.push(...anchor.warnings);
+			if (anchor.error !== undefined) target.error ??= anchor.error;
+		}
+		return out;
+	}
+}

package/src/front/validate/index.ts

@@ -0,0 +1,174 @@
+import type { Diagnostic } from 'vigla/compiler';
+import type * as AST from '../ast.ts';
+import { bidirectionalChar } from '../parse/characters.ts';
+import type { Parsed } from '../parse/index.ts';
+import type * as ES from 'estree';
+import { diagnostic, fail } from '../diagnostics.ts';
+import { Anchors } from './anchors.ts';
+import { rejectLegacy } from './legacy.ts';
+import { Report } from './report.ts';
+import { Template } from './template.ts';
+
+export interface ValidateOptions {
+	readonly customElement: boolean;
+	readonly filename: string | undefined;
+}
+
+const bidirectional = bidirectionalChar;
+
+type Node = { type: string; [key: string]: unknown };
+
+function literals(node: unknown, report: Report, anchors: Anchors): void {
+	if (node === null || typeof node !== 'object') return;
+	if (Array.isArray(node)) {
+		for (const item of node) literals(item, report, anchors);
+		return;
+	}
+	const record = node as Node;
+	if (typeof record.type !== 'string') return;
+	const text =
+		record.type === 'Literal' && typeof record.value === 'string'
+			? record.value
+			: record.type === 'TemplateElement'
+				? ((record.value as { cooked?: string | null }).cooked ?? '')
+				: null;
+	if (text !== null && bidirectional.test(text)) {
+		const before = report.warnings.length;
+		report.warn('bidirectional_control_characters', record as never);
+		anchors.warn(record, report.warnings.slice(before));
+	}
+	for (const key in record) {
+		if (
+			key !== 'type' &&
+			key !== 'loc' &&
+			key !== 'leadingComments' &&
+			key !== 'trailingComments'
+		) {
+			literals(record[key], report, anchors);
+		}
+	}
+}
+
+const forbiddenUpdates = new Set(['beforeUpdate', 'afterUpdate']);
+
+function imports(
+	program: AST.Script['content'] | ES.Program | null | undefined,
+	anchors: Anchors
+): void {
+	for (const statement of program?.body ?? []) {
+		if (statement.type !== 'ImportDeclaration') continue;
+		const source = String(statement.source.value);
+		const at = statement as unknown as AST.Located;
+		if (source.startsWith('svelte/internal')) {
+			anchors.fail(statement, diagnostic('import_svelte_internal_forbidden', at));
+			continue;
+		}
+		if (source !== 'svelte') continue;
+		for (const specifier of statement.specifiers) {
+			if (specifier.type !== 'ImportSpecifier' || specifier.imported.type !== 'Identifier')
+				continue;
+			const name = specifier.imported.name;
+			if (forbiddenUpdates.has(name)) {
+				anchors.fail(
+					statement,
+					diagnostic('runes_mode_invalid_import', specifier as unknown as AST.Located, { name })
+				);
+				break;
+			}
+		}
+	}
+}
+
+export function validateModuleSyntax(program: ES.Program): Anchors {
+	const anchors = new Anchors();
+	imports(program, anchors);
+	return anchors;
+}
+
+function firstReference(node: unknown, name: string, parent: Node | null): Node | null {
+	if (node === null || typeof node !== 'object') return null;
+	if (Array.isArray(node)) {
+		for (const item of node) {
+			const found = firstReference(item, name, parent);
+			if (found !== null) return found;
+		}
+		return null;
+	}
+	const record = node as Node;
+	if (typeof record.type !== 'string') return null;
+	if (record.type === 'Identifier' && record.name === name) {
+		const property =
+			(parent?.type === 'MemberExpression' && parent.property === record && !parent.computed) ||
+			(parent?.type === 'Property' && parent.key === record && !parent.computed);
+		if (!property) return record;
+	}
+	for (const key in record) {
+		if (
+			key === 'type' ||
+			key === 'loc' ||
+			key === 'leadingComments' ||
+			key === 'trailingComments'
+		) {
+			continue;
+		}
+		const found = firstReference(record[key], name, record);
+		if (found !== null) return found;
+	}
+	return null;
+}
+
+function rejectLegacyProps(root: AST.Root): void {
+	for (const [name, code] of [
+		['$$props', 'legacy_props_invalid'],
+		['$$restProps', 'legacy_rest_props_invalid']
+	] as const) {
+		const found =
+			firstReference(root.module, name, null) ??
+			firstReference(root.instance, name, null) ??
+			firstReference(root.fragment, name, null);
+		if (found !== null) fail(code, found as unknown as AST.Located);
+	}
+}
+
+export interface Validated {
+	readonly parse: readonly Diagnostic[];
+	readonly before: readonly Diagnostic[];
+	readonly anchors: Anchors;
+}
+
+export function validateComponent(
+	parsed: Parsed,
+	source: string,
+	options: ValidateOptions
+): Validated {
+	const root = parsed.root;
+	const anchors = new Anchors();
+	rejectLegacy(root, { ...options, anchors });
+	const early = new Report();
+	for (const attribute of root.options?.attributes ?? []) {
+		if (
+			attribute.type === 'Attribute' &&
+			attribute.name === 'customElement' &&
+			!options.customElement
+		) {
+			early.warn('options_missing_custom_element', attribute);
+		}
+	}
+	rejectLegacyProps(root);
+	imports(root.module?.content, anchors);
+	imports(root.instance?.content, anchors);
+	for (const statement of root.instance?.content.body ?? []) {
+		if (statement.type === 'LabeledStatement' && statement.label.name === '$') {
+			anchors.fail(
+				statement,
+				diagnostic('legacy_reactive_statement_invalid', statement as unknown as AST.Located)
+			);
+		}
+	}
+	const scripts = new Report();
+	literals(root.module, scripts, anchors);
+	literals(root.instance, scripts, anchors);
+	new Template(source, new Report(), anchors).walk(root);
+	literals(root.fragment, new Report(), anchors);
+	return { parse: parsed.warnings, before: early.warnings, anchors };
+}

package/src/front/validate/legacy.ts

@@ -0,0 +1,119 @@
+import type * as AST from '../ast.ts';
+import { CompileError } from 'vigla/compiler';
+import { fail, legacy } from '../diagnostics.ts';
+import { stopped, type Anchors } from './anchors.ts';
+
+export interface LegacyContext {
+	readonly customElement: boolean;
+	readonly filename: string | undefined;
+	readonly anchors: Anchors;
+}
+
+const components = new Set(['Component', 'SvelteComponent', 'SvelteSelf']);
+
+function selfName(filename: string | undefined): { name: string; basename: string } {
+	const basename =
+		filename === undefined ? 'Self.svelte' : (filename.split(/[/\\]/).pop() as string);
+	const stem = basename.replace(/\.svelte$/, '');
+	return { name: stem.charAt(0).toUpperCase() + stem.slice(1), basename };
+}
+
+function children(node: AST.TemplateNode): (AST.Fragment | null | undefined)[] {
+	switch (node.type) {
+		case 'IfBlock':
+			return [node.consequent, node.alternate];
+		case 'EachBlock':
+			return [node.body, node.fallback];
+		case 'AwaitBlock':
+			return [node.pending, node.then, node.catch];
+		case 'KeyBlock':
+			return [node.fragment];
+		case 'SnippetBlock':
+			return [node.body];
+		default:
+			return 'fragment' in node ? [node.fragment] : [];
+	}
+}
+
+function element(
+	node: AST.ElementLike,
+	parent: AST.ElementLike | null,
+	inSnippet: boolean,
+	context: LegacyContext
+): void {
+	if (node.type === 'SvelteComponent') legacy('svelte_component_deprecated', node);
+	if (node.type === 'SvelteSelf')
+		legacy('svelte_self_deprecated', node, selfName(context.filename));
+	if (node.type === 'SvelteFragment') legacy('svelte_fragment_invalid', node);
+	if (node.type === 'SlotElement' && !context.customElement)
+		legacy('slot_element_deprecated', node);
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'LetDirective') legacy('let_directive_invalid', attribute);
+		if (attribute.type === 'OnDirective') {
+			legacy(
+				components.has(node.type)
+					? 'component_event_directive_invalid'
+					: 'event_directive_deprecated',
+				attribute,
+				{ name: attribute.name }
+			);
+		}
+		if (attribute.type !== 'Attribute' || attribute.name !== 'slot') continue;
+		if (inSnippet) {
+			const value = attribute.value;
+			if (!Array.isArray(value) || value.length !== 1 || value[0]?.type !== 'Text')
+				fail('slot_attribute_invalid', attribute);
+		} else if (parent !== null && components.has(parent.type)) {
+			legacy('slot_attribute_unsupported', attribute);
+		}
+	}
+}
+
+function fragment(
+	nodes: AST.Fragment | null | undefined,
+	parent: AST.ElementLike | null,
+	context: LegacyContext,
+	container: AST.TemplateNode | null = null
+): void {
+	for (const node of nodes?.nodes ?? []) {
+		const isElement = 'attributes' in node && 'name_loc' in node;
+		if (isElement) {
+			try {
+				element(node, parent, container?.type === 'SnippetBlock', context);
+			} catch (error) {
+				if (!(error instanceof CompileError)) throw error;
+				context.anchors.fail(node, error.diagnostic);
+				throw stopped;
+			}
+		}
+		const owner = isElement ? node : parent;
+		for (const child of children(node)) fragment(child, owner, context, node);
+	}
+}
+
+export function rejectLegacy(root: AST.Root, context: LegacyContext): void {
+	const options = root.options;
+	if (options?.runes === false) {
+		const at = options.attributes.find(
+			(attribute) => attribute.type === 'Attribute' && attribute.name === 'runes'
+		);
+		legacy('runes_mode_required', at ?? options);
+	}
+	for (const attribute of options?.attributes ?? []) {
+		if (attribute.type !== 'Attribute') continue;
+		if (attribute.name === 'accessors') legacy('options_deprecated_accessors', attribute);
+		if (attribute.name === 'immutable') legacy('options_deprecated_immutable', attribute);
+	}
+	const contextAttribute = root.module?.attributes.find(
+		(attribute) => attribute.type === 'Attribute' && attribute.name === 'context'
+	);
+	if (contextAttribute !== undefined) legacy('script_context_deprecated', contextAttribute);
+	try {
+		fragment(root.fragment, null, {
+			...context,
+			customElement: context.customElement || options?.customElement !== undefined
+		});
+	} catch (error) {
+		if (error !== stopped) throw error;
+	}
+}

package/src/front/validate/report.ts

@@ -0,0 +1,38 @@
+import type { Diagnostic } from 'vigla/compiler';
+import { warning, type Args, type At } from '../diagnostics.ts';
+
+export class Report {
+	readonly warnings: Diagnostic[] = [];
+	readonly #stack: ReadonlySet<string>[] = [];
+	readonly #snapshots = new Map<object, ReadonlySet<string> | undefined>();
+
+	push(codes: readonly string[]): void {
+		const inherited = this.#stack.at(-1);
+		this.#stack.push(new Set([...(inherited ?? []), ...codes]));
+	}
+
+	pop(): void {
+		this.#stack.pop();
+	}
+
+	mark(node: object): void {
+		this.#snapshots.set(node, this.#stack.at(-1));
+	}
+
+	ignored(code: string, at?: object): boolean {
+		const codes =
+			at !== undefined && this.#snapshots.has(at) ? this.#snapshots.get(at) : this.#stack.at(-1);
+		return codes?.has(code) ?? false;
+	}
+
+	warn(code: string, at: At & object, args?: Args): void;
+	warn(code: string, at: At, args?: Args): void;
+	warn(code: string, at: At, args: Args = {}): void {
+		if (this.ignored(code, typeof at === 'object' ? at : undefined)) return;
+		this.warnings.push(warning(code, at, args));
+	}
+
+	add(diagnostics: readonly Diagnostic[]): void {
+		this.warnings.push(...diagnostics);
+	}
+}