@vigla/svelte 0.0.0-stage → 5.57.3

package/src/front/parse/options.ts

@@ -0,0 +1,194 @@
+import type * as ES from 'estree';
+import type * as AST from '../ast.ts';
+import { fail, type At } from '../diagnostics.ts';
+
+const svgNamespace = 'http://www.w3.org/2000/svg';
+const mathmlNamespace = 'http://www.w3.org/1998/Math/MathML';
+
+const tagChar =
+	'[a-z0-9_.\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}-]';
+const customTag = new RegExp(`^[a-z]${tagChar}*-${tagChar}*$`, 'u');
+const reservedTags = new Set([
+	'annotation-xml',
+	'color-profile',
+	'font-face',
+	'font-face-src',
+	'font-face-uri',
+	'font-face-format',
+	'font-face-name',
+	'missing-glyph'
+]);
+
+const propTypes = new Set(['String', 'Number', 'Boolean', 'Array', 'Object']);
+
+type Static = string | number | boolean | RegExp | bigint | null | undefined;
+
+function staticValue(attribute: AST.Attribute): Static {
+	const { value } = attribute;
+	if (value === true) return true;
+	const chunk = Array.isArray(value) ? value[0] : value;
+	if (chunk === undefined) return true;
+	if (Array.isArray(value) && value.length > 1) return null;
+	if (chunk.type === 'Text') return chunk.data;
+	if (chunk.expression.type !== 'Literal') return null;
+	return chunk.expression.value;
+}
+
+function booleanValue(attribute: AST.Attribute): boolean {
+	const value = staticValue(attribute);
+	if (typeof value !== 'boolean') {
+		fail('svelte_options_invalid_attribute_value', attribute, { list: 'true or false' });
+	}
+	return value;
+}
+
+function validateTag(at: At, tag: unknown): asserts tag is string {
+	if (typeof tag !== 'string') fail('svelte_options_invalid_tagname', at);
+	if (tag) {
+		if (!customTag.test(tag)) fail('svelte_options_invalid_tagname', at);
+		if (reservedTags.has(tag)) fail('svelte_options_reserved_tagname', at);
+	}
+}
+
+function plainKey(property: ES.Property | ES.SpreadElement): property is ES.Property & {
+	key: ES.Identifier;
+} {
+	return property.type === 'Property' && !property.computed && property.key.type === 'Identifier';
+}
+
+function customElement(attribute: AST.Attribute): AST.CustomElementOptions | undefined {
+	const options: AST.CustomElementOptions = {};
+	const raw = attribute.value;
+	if (raw === true) fail('svelte_options_invalid_customelement', attribute);
+	const value = Array.isArray(raw) ? raw : [raw];
+	const first = value[0] as AST.Text | AST.ExpressionTag;
+	if (first.type === 'Text') {
+		const tag = staticValue(attribute);
+		validateTag(attribute, tag);
+		options.tag = tag;
+		return options;
+	}
+	const expression = first.expression;
+	if (expression.type !== 'ObjectExpression') {
+		if (expression.type === 'Literal' && expression.value === null) return undefined;
+		fail('svelte_options_invalid_customelement', attribute);
+	}
+	const properties: [string, ES.Node][] = [];
+	for (const property of expression.properties) {
+		if (!plainKey(property)) fail('svelte_options_invalid_customelement', attribute);
+		properties.push([property.key.name, property.value]);
+	}
+	const find = (name: string): ES.Node | undefined => properties.find(([key]) => key === name)?.[1];
+
+	const tag = properties.find(([name]) => name === 'tag');
+	if (tag !== undefined) {
+		const tagValue = (tag[1] as ES.Literal | undefined)?.value;
+		validateTag(tag as unknown as At, tagValue);
+		options.tag = tagValue;
+	}
+
+	const props = find('props');
+	if (props !== undefined) {
+		if (props.type !== 'ObjectExpression')
+			fail('svelte_options_invalid_customelement_props', attribute);
+		options.props = {};
+		for (const property of props.properties) {
+			if (!plainKey(property) || property.value.type !== 'ObjectExpression') {
+				fail('svelte_options_invalid_customelement_props', attribute);
+			}
+			const prop: AST.CustomElementProp = {};
+			options.props[property.key.name] = prop;
+			for (const entry of property.value.properties) {
+				if (!plainKey(entry) || entry.value.type !== 'Literal') {
+					fail('svelte_options_invalid_customelement_props', attribute);
+				}
+				const literal = entry.value.value;
+				if (entry.key.name === 'type') {
+					if (!propTypes.has(literal as string)) {
+						fail('svelte_options_invalid_customelement_props', attribute);
+					}
+					prop.type = literal as AST.CustomElementProp['type'];
+				} else if (entry.key.name === 'reflect') {
+					if (typeof literal !== 'boolean')
+						fail('svelte_options_invalid_customelement_props', attribute);
+					prop.reflect = literal;
+				} else if (entry.key.name === 'attribute') {
+					if (typeof literal !== 'string')
+						fail('svelte_options_invalid_customelement_props', attribute);
+					prop.attribute = literal;
+				} else {
+					fail('svelte_options_invalid_customelement_props', attribute);
+				}
+			}
+		}
+	}
+
+	const shadow = find('shadow');
+	if (shadow) {
+		if (shadow.type === 'Literal' && (shadow.value === 'open' || shadow.value === 'none')) {
+			options.shadow = shadow.value;
+		} else if (shadow.type === 'ObjectExpression') {
+			options.shadow = shadow;
+		} else {
+			fail('svelte_options_invalid_customelement_shadow', attribute);
+		}
+	}
+
+	const extend = find('extend');
+	if (extend) options.extend = extend as AST.Expression;
+	return options;
+}
+
+export function readOptions(node: AST.ElementLike): AST.SvelteOptions {
+	const options: AST.SvelteOptions = {
+		start: node.start,
+		end: node.end,
+		attributes: node.attributes
+	};
+	for (const attribute of node.attributes) {
+		if (attribute.type !== 'Attribute') fail('svelte_options_invalid_attribute', attribute);
+		const { name } = attribute;
+		switch (name) {
+			case 'runes':
+				options.runes = booleanValue(attribute);
+				break;
+			case 'tag':
+				fail('svelte_options_deprecated_tag', attribute);
+			case 'customElement': {
+				const element = customElement(attribute);
+				if (element !== undefined) options.customElement = element;
+				break;
+			}
+			case 'namespace': {
+				const value = staticValue(attribute);
+				if (value === svgNamespace) options.namespace = 'svg';
+				else if (value === mathmlNamespace) options.namespace = 'mathml';
+				else if (value === 'html' || value === 'mathml' || value === 'svg')
+					options.namespace = value;
+				else {
+					fail('svelte_options_invalid_attribute_value', attribute, {
+						list: '"html", "mathml" or "svg"'
+					});
+				}
+				break;
+			}
+			case 'css': {
+				if (staticValue(attribute) === 'injected') options.css = 'injected';
+				else fail('svelte_options_invalid_attribute_value', attribute, { list: '"injected"' });
+				break;
+			}
+			case 'immutable':
+				options.immutable = booleanValue(attribute);
+				break;
+			case 'preserveWhitespace':
+				options.preserveWhitespace = booleanValue(attribute);
+				break;
+			case 'accessors':
+				options.accessors = booleanValue(attribute);
+				break;
+			default:
+				fail('svelte_options_unknown_attribute', attribute, { name });
+		}
+	}
+	return options;
+}

package/src/front/parse/parser.ts

@@ -0,0 +1,189 @@
+import type * as ES from 'estree';
+import type { Diagnostic } from 'vigla/compiler';
+import type * as AST from '../ast.ts';
+import { fail, warning, type Args, type At } from '../diagnostics.ts';
+import type { Locator } from '../locate.ts';
+import { isReserved, isWhitespace } from './html.ts';
+import { identifierEnd } from './identifier.ts';
+import type { Context } from './js.ts';
+
+export type Open = AST.Root | AST.ElementLike | AST.Block;
+
+export interface AutoClosed {
+	readonly tag: string;
+	readonly reason: string;
+	readonly depth: number;
+}
+
+export type Identifier = ES.Identifier & AST.Located & { loc: AST.NameLocation };
+
+const scriptLang =
+	/<!--[^]*?-->|<script\s+(?:[^>]*|(?:[^=>'"/]+=(?:"[^"]*"|'[^']*'|[^>\s]+)\s+)*)lang=(["'])?([^"' >]+)\1[^>]*>/g;
+
+function typescript(source: string): boolean {
+	scriptLang.lastIndex = 0;
+	let match: RegExpExecArray | null;
+	do match = scriptLang.exec(source);
+	while (match !== null && match[0][1] !== 's');
+	scriptLang.lastIndex = 0;
+	return match?.[2] === 'ts';
+}
+
+export class Scanner {
+	template: string;
+	readonly loose: boolean;
+	cssComments: AST.Css.Comment[] = [];
+	index = 0;
+
+	constructor(template: string, loose: boolean) {
+		this.template = template;
+		this.loose = loose;
+	}
+
+	match(text: string): boolean {
+		return text.length === 1
+			? this.template[this.index] === text
+			: this.template.startsWith(text, this.index);
+	}
+
+	eat(text: string, required = false, requiredInLoose = true): boolean {
+		if (this.match(text)) {
+			this.index += text.length;
+			return true;
+		}
+		if (required && (!this.loose || requiredInLoose))
+			fail('expected_token', this.index, { token: text });
+		return false;
+	}
+
+	matchRegex(pattern: RegExp): string | null {
+		pattern.lastIndex = this.index;
+		const match = pattern.exec(this.template);
+		if (match === null || match.index !== this.index) return null;
+		return match[0];
+	}
+
+	read(pattern: RegExp): string | null {
+		const result = this.matchRegex(pattern);
+		if (result) this.index += result.length;
+		return result;
+	}
+
+	allowWhitespace(): void {
+		while (
+			this.index < this.template.length &&
+			isWhitespace(this.template.charCodeAt(this.index))
+		) {
+			this.index++;
+		}
+	}
+
+	readUntil(delimiter: string): string {
+		if (this.index >= this.template.length) {
+			if (this.loose) return '';
+			fail('unexpected_eof', this.template.length);
+		}
+		const start = this.index;
+		const found = this.template.indexOf(delimiter, start);
+		this.index = found === -1 ? this.template.length : found;
+		return this.template.slice(start, this.index);
+	}
+
+	readUntilRegex(pattern: RegExp): string {
+		if (this.index >= this.template.length) {
+			if (this.loose) return '';
+			fail('unexpected_eof', this.template.length);
+		}
+		const start = this.index;
+		const match = pattern.exec(this.template.slice(start));
+		this.index = match === null ? this.template.length : start + match.index;
+		return this.template.slice(start, this.index);
+	}
+}
+
+export class Parser extends Scanner implements Context {
+	readonly ts: boolean;
+	readonly locate: Locator;
+	readonly root: AST.Root;
+	readonly stack: Open[] = [];
+	readonly fragments: AST.Fragment[] = [];
+	readonly meta = new Set<string>();
+	readonly warnings: Diagnostic[] = [];
+	lastAutoClosed: AutoClosed | undefined;
+
+	constructor(source: string, loose: boolean, locate: Locator) {
+		super(source.trimEnd(), loose);
+		this.locate = locate;
+		this.ts = typescript(source);
+		this.root = {
+			css: null,
+			js: [],
+			start: 0,
+			end: source.length,
+			type: 'Root',
+			fragment: { type: 'Fragment', nodes: [] },
+			options: null,
+			comments: []
+		};
+		this.stack.push(this.root);
+		this.fragments.push(this.root.fragment);
+	}
+
+	get comments(): AST.JSComment[] {
+		return this.root.comments;
+	}
+
+	current(): Open {
+		return this.stack[this.stack.length - 1] as Open;
+	}
+
+	warn(code: string, at: At, args?: Args): void {
+		this.warnings.push(warning(code, at, args));
+	}
+
+	requireWhitespace(): void {
+		if (!isWhitespace(this.template.charCodeAt(this.index)))
+			fail('expected_whitespace', this.index);
+		this.index++;
+		this.allowWhitespace();
+	}
+
+	readIdentifier(): Identifier {
+		const start = this.index;
+		let end = identifierEnd(this.template, start);
+		let name = '';
+		if (end === -1) {
+			end = start;
+		} else {
+			name = this.template.slice(start, end);
+			this.index = end;
+			if (isReserved(name)) fail('unexpected_reserved_word', start, { word: name });
+		}
+		return {
+			type: 'Identifier',
+			name,
+			start,
+			end,
+			loc: { start: this.locate(start), end: this.locate(end) }
+		};
+	}
+
+	push(node: Open, fragment: AST.Fragment): void {
+		this.stack.push(node);
+		this.fragments.push(fragment);
+	}
+
+	pop(): Open | undefined {
+		this.fragments.pop();
+		return this.stack.pop();
+	}
+
+	append<T extends AST.TemplateNode>(node: T): T {
+		this.fragments.at(-1)?.nodes.push(node);
+		return node;
+	}
+}
+
+export function fragment(): AST.Fragment {
+	return { type: 'Fragment', nodes: [] };
+}

package/src/front/parse/pattern.ts

@@ -0,0 +1,57 @@
+import type * as AST from '../ast.ts';
+import { fail } from '../diagnostics.ts';
+import { matchBracket } from './bracket.ts';
+import { parseExpressionAt, removeParens, type Node } from './js.ts';
+import type { Parser } from './parser.ts';
+
+export function readPattern(parser: Parser): AST.Pattern {
+	const start = parser.index;
+	const id = parser.readIdentifier();
+	if (id.name !== '') {
+		return { ...id, typeAnnotation: readTypeAnnotation(parser) } as AST.Pattern;
+	}
+	const char = parser.template[start];
+	if (char !== '{' && char !== '[') fail('expected_pattern', start);
+	const end = matchBracket(parser.template, start);
+	parser.index = end;
+	const assignment = removeParens(
+		parseExpressionAt(parser, `${parser.template.slice(0, end)} = 1`, start)
+	);
+	const pattern = assignment.left as Node;
+	pattern.typeAnnotation = readTypeAnnotation(parser);
+	if (pattern.typeAnnotation) pattern.end = (pattern.typeAnnotation as Node).end;
+	return pattern as unknown as AST.Pattern;
+}
+
+const optionalColon = /\?\s*:/g;
+
+function readTypeAnnotation(parser: Parser): Node | undefined {
+	const start = parser.index;
+	parser.allowWhitespace();
+	if (!parser.eat(':')) {
+		parser.index = start;
+		return undefined;
+	}
+	const insert = '_ as ';
+	const from = parser.index - insert.length;
+	const template =
+		parser.template.slice(0, from) +
+		insert +
+		parser.template.slice(parser.index).replace(optionalColon, ':');
+	let expression = removeParens(parseExpressionAt(parser, template, from));
+	if (expression.type === 'AssignmentExpression') {
+		let equals = (expression.right as Node).start;
+		while (template[equals] !== '=') equals -= 1;
+		expression = removeParens(parseExpressionAt(parser, template.slice(0, equals), from));
+	}
+	if (expression.type === 'SequenceExpression') {
+		expression = (expression.expressions as Node[])[0] as Node;
+	}
+	parser.index = expression.end;
+	return {
+		type: 'TSTypeAnnotation',
+		start,
+		end: parser.index,
+		typeAnnotation: expression.typeAnnotation
+	} as unknown as Node;
+}

package/src/front/parse/script.ts

@@ -0,0 +1,74 @@
+import type * as AST from '../ast.ts';
+import { fail } from '../diagnostics.ts';
+import { parseScript } from './js.ts';
+import type { Parser } from './parser.ts';
+
+const closing = /<\/script\s*>/;
+const closingHere = /<\/script\s*>/y;
+const notNewline = /[^\n]/g;
+
+const reserved = new Set(['server', 'client', 'worker', 'test', 'default']);
+const allowed = new Set(['context', 'generics', 'lang', 'module']);
+
+export function readScript(
+	parser: Parser,
+	start: number,
+	attributes: AST.AttributeLike[]
+): AST.Script {
+	const contentStart = parser.index;
+	const data = parser.readUntilRegex(closing);
+	if (parser.index >= parser.template.length) {
+		fail('element_unclosed', parser.template.length, { name: 'script' });
+	}
+	const source = parser.template.slice(0, contentStart).replace(notNewline, ' ') + data;
+	parser.read(closingHere);
+
+	const ast = parseScript(source, parser.comments, parser.ts);
+	ast.start = contentStart;
+	const loc = ast.loc as {
+		start: { line: number; column: number };
+		end: { line: number; column: number };
+	};
+	const from = parser.locate(start);
+	const to = parser.locate(parser.index);
+	loc.start.line = from.line;
+	loc.start.column = from.column;
+	loc.end.line = to.line;
+	loc.end.column = to.column;
+
+	let context: 'default' | 'module' = 'default';
+	for (const attribute of attributes as AST.Attribute[]) {
+		if (reserved.has(attribute.name)) {
+			fail('script_reserved_attribute', attribute, { name: attribute.name });
+		}
+		if (!allowed.has(attribute.name)) parser.warn('script_unknown_attribute', attribute);
+		if (attribute.name === 'module') {
+			if (attribute.value !== true) {
+				fail('script_invalid_attribute_value', attribute, { name: attribute.name });
+			}
+			context = 'module';
+		}
+		if (attribute.name === 'context') {
+			const value = attribute.value;
+			if (
+				value === true ||
+				!Array.isArray(value) ||
+				value.length !== 1 ||
+				value[0]?.type !== 'Text'
+			) {
+				fail('script_invalid_context', attribute);
+			}
+			if (value[0].data !== 'module') fail('script_invalid_context', attribute);
+			context = 'module';
+		}
+	}
+
+	return {
+		type: 'Script',
+		start,
+		end: parser.index,
+		context,
+		content: ast as unknown as AST.Script['content'],
+		attributes
+	};
+}