vigla 0.0.0 → 0.1.0

package/src/compiler/css/template.ts

@@ -0,0 +1,297 @@
+import type * as ES from 'estree';
+import type * as IR from '../ir/nodes.ts';
+import type { ComponentUnit } from '../ir/port.ts';
+
+export type Host = IR.Element | IR.DynamicElement;
+
+export type Renderer = IR.Render | IR.Component;
+
+interface Place {
+	readonly fragment: IR.Fragment;
+	readonly owner: IR.Node | null;
+}
+
+type Resolution = 'resolved' | 'unresolved';
+
+function fragmentsOf(node: IR.Node): (IR.Fragment | null)[] {
+	switch (node.kind) {
+		case 'element':
+		case 'component':
+		case 'dynamic-element':
+		case 'keyed-block':
+		case 'boundary':
+		case 'snippet':
+		case 'special':
+			return [node.body];
+		case 'slot':
+			return [node.fallback];
+		case 'branch':
+			return [...node.arms.map((arm) => arm.body), node.fallback];
+		case 'keyed-list':
+		case 'unkeyed-list':
+			return [node.body, node.fallback];
+		case 'async-block':
+			return [node.pending, node.resolved?.body ?? null, node.rejected?.body ?? null];
+		default:
+			return [];
+	}
+}
+
+export function isBlock(node: IR.Node): boolean {
+	switch (node.kind) {
+		case 'branch':
+		case 'keyed-list':
+		case 'unkeyed-list':
+		case 'async-block':
+		case 'keyed-block':
+		case 'slot':
+			return true;
+		default:
+			return false;
+	}
+}
+
+function patternNames(pattern: ES.Node | null, into: Set<string>): void {
+	if (pattern === null) return;
+	switch (pattern.type) {
+		case 'Identifier':
+			into.add(pattern.name);
+			return;
+		case 'ObjectPattern':
+			for (const property of pattern.properties) {
+				patternNames(property.type === 'RestElement' ? property.argument : property.value, into);
+			}
+			return;
+		case 'ArrayPattern':
+			for (const element of pattern.elements) patternNames(element, into);
+			return;
+		case 'RestElement':
+			patternNames(pattern.argument, into);
+			return;
+		case 'AssignmentPattern':
+			patternNames(pattern.left, into);
+			return;
+		default:
+			return;
+	}
+}
+
+function scriptNames(
+	program: ES.Program | null,
+	unit: ComponentUnit,
+	resolved: Set<string>,
+	unresolved: Set<string>
+): void {
+	if (program === null) return;
+	for (const statement of program.body) {
+		const declaration =
+			statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+		if (declaration === null || declaration === undefined) continue;
+		switch (declaration.type) {
+			case 'ImportDeclaration':
+				for (const specifier of declaration.specifiers) resolved.add(specifier.local.name);
+				break;
+			case 'FunctionDeclaration':
+			case 'ClassDeclaration':
+				if (declaration.id) unresolved.add(declaration.id.name);
+				break;
+			case 'VariableDeclaration':
+				for (const declarator of declaration.declarations) {
+					const init = declarator.init;
+					const props = init?.type === 'CallExpression' && unit.runes.get(init.callee) === '$props';
+					patternNames(declarator.id, props ? resolved : unresolved);
+				}
+				break;
+			default:
+				break;
+		}
+	}
+}
+
+export class TemplateIndex {
+	readonly hosts: Host[] = [];
+	readonly snippets: IR.Snippet[] = [];
+	readonly #places = new Map<IR.Node, Place>();
+	readonly #renders = new Map<Renderer, Set<IR.Snippet>>();
+	readonly #sites = new Map<IR.Snippet, Set<Renderer>>();
+	readonly #resolved = new Set<string>();
+	readonly #script = new Set<string>();
+
+	constructor(unit: ComponentUnit) {
+		scriptNames(unit.module, unit, this.#resolved, this.#script);
+		scriptNames(unit.instance, unit, this.#resolved, this.#script);
+		const unresolved: Renderer[] = [];
+		this.#fragment(unit.template, null, [], unresolved);
+		for (const renderer of unresolved) {
+			const set = this.#renders.get(renderer) ?? new Set();
+			for (const snippet of this.snippets) set.add(snippet);
+			this.#renders.set(renderer, set);
+		}
+		for (const [renderer, snippets] of this.#renders) {
+			for (const snippet of snippets) {
+				const sites = this.#sites.get(snippet) ?? new Set();
+				sites.add(renderer);
+				this.#sites.set(snippet, sites);
+			}
+		}
+	}
+
+	#fragment(
+		fragment: IR.Fragment,
+		owner: IR.Node | null,
+		scopes: readonly ReadonlyMap<string, IR.Snippet | null>[],
+		unresolved: Renderer[]
+	): void {
+		const scope = new Map<string, IR.Snippet | null>();
+		for (const node of fragment.nodes) {
+			if (node.kind === 'snippet') scope.set(node.name.name, node);
+			else if (node.kind === 'constant') {
+				const names = new Set<string>();
+				patternNames(node.declarator.id, names);
+				for (const name of names) scope.set(name, null);
+			}
+		}
+		const inner = scope.size > 0 ? [...scopes, scope] : scopes;
+		for (const node of fragment.nodes) {
+			this.#places.set(node, { fragment, owner });
+			if (node.kind === 'element' || node.kind === 'dynamic-element') this.hosts.push(node);
+			if (node.kind === 'snippet') this.snippets.push(node);
+			if (node.kind === 'render') this.#render(node, inner, unresolved);
+			if (node.kind === 'component') this.#component(node, inner, unresolved);
+			const own = this.#declared(node);
+			const nested = own.size > 0 ? [...inner, own] : inner;
+			for (const child of fragmentsOf(node)) {
+				if (child !== null) this.#fragment(child, node, nested, unresolved);
+			}
+		}
+	}
+
+	#declared(node: IR.Node): Map<string, IR.Snippet | null> {
+		const names = new Set<string>();
+		switch (node.kind) {
+			case 'keyed-list':
+			case 'unkeyed-list':
+				patternNames(node.item, names);
+				if (node.index !== null) names.add(node.index.name);
+				break;
+			case 'snippet':
+				for (const parameter of node.parameters) patternNames(parameter, names);
+				break;
+			case 'async-block':
+				patternNames(node.resolved?.binding ?? null, names);
+				patternNames(node.rejected?.binding ?? null, names);
+				break;
+			default:
+				break;
+		}
+		const declared = new Map<string, IR.Snippet | null>();
+		for (const name of names) declared.set(name, null);
+		return declared;
+	}
+
+	#lookup(
+		name: string,
+		scopes: readonly ReadonlyMap<string, IR.Snippet | null>[]
+	): IR.Snippet | Resolution {
+		for (let i = scopes.length - 1; i >= 0; i--) {
+			const scope = scopes[i];
+			if (scope?.has(name)) return scope.get(name) ?? 'unresolved';
+		}
+		if (this.#script.has(name)) return 'unresolved';
+		return 'resolved';
+	}
+
+	#add(renderer: Renderer, snippet: IR.Snippet): void {
+		const set = this.#renders.get(renderer) ?? new Set();
+		set.add(snippet);
+		this.#renders.set(renderer, set);
+	}
+
+	#render(
+		node: IR.Render,
+		scopes: readonly ReadonlyMap<string, IR.Snippet | null>[],
+		unresolved: Renderer[]
+	): void {
+		const call = node.call.type === 'ChainExpression' ? node.call.expression : node.call;
+		const callee = call.type === 'CallExpression' ? call.callee : null;
+		this.#renders.set(node, new Set());
+		if (callee?.type !== 'Identifier') {
+			unresolved.push(node);
+			return;
+		}
+		const found = this.#lookup(callee.name, scopes);
+		if (found === 'unresolved') unresolved.push(node);
+		else if (found !== 'resolved') this.#add(node, found);
+	}
+
+	#component(
+		node: IR.Component,
+		scopes: readonly ReadonlyMap<string, IR.Snippet | null>[],
+		unresolved: Renderer[]
+	): void {
+		this.#renders.set(node, new Set());
+		let resolved = true;
+		for (const attribute of node.attributes) {
+			if (attribute.kind === 'spread' || attribute.kind === 'binding') {
+				resolved = false;
+				continue;
+			}
+			if (attribute.kind !== 'attribute') continue;
+			const expression = attributeExpression(attribute.value);
+			if (expression === null) continue;
+			if (expression.type === 'Identifier') {
+				const found = this.#lookup(expression.name, scopes);
+				if (found === 'unresolved') resolved = false;
+				else if (found !== 'resolved') this.#add(node, found);
+			} else if (expression.type !== 'Literal') {
+				resolved = false;
+			}
+		}
+		if (!resolved) {
+			unresolved.push(node);
+			return;
+		}
+		for (const child of node.body.nodes) {
+			if (child.kind === 'snippet') this.#add(node, child);
+		}
+	}
+
+	place(node: IR.Node): Place | null {
+		return this.#places.get(node) ?? null;
+	}
+
+	owner(node: IR.Node): IR.Node | null {
+		return this.#places.get(node)?.owner ?? null;
+	}
+
+	snippetsOf(renderer: Renderer): ReadonlySet<IR.Snippet> {
+		return this.#renders.get(renderer) ?? new Set();
+	}
+
+	sitesOf(snippet: IR.Snippet): ReadonlySet<Renderer> {
+		return this.#sites.get(snippet) ?? new Set();
+	}
+
+	insideHead(node: IR.Node): boolean {
+		for (let owner = this.owner(node); owner !== null; owner = this.owner(owner)) {
+			if (owner.kind === 'special' && owner.target === 'head') return true;
+		}
+		return false;
+	}
+
+	fragments(node: IR.Node): (IR.Fragment | null)[] {
+		return fragmentsOf(node);
+	}
+}
+
+export function attributeExpression(value: IR.Value): ES.Expression | null {
+	if (value.kind === 'expression') return value.expression;
+	if (value.kind === 'text' && value.parts.length === 1 && value.parts[0]?.kind === 'expression') {
+		return value.parts[0].expression;
+	}
+	return null;
+}
+
+export function hostName(host: Host): string | null {
+	return host.kind === 'element' ? host.name : null;
+}

package/src/compiler/ir/estree.ts

@@ -0,0 +1,256 @@
+import type * as ES from 'estree';
+
+const ignored = new Set([
+	'type',
+	'loc',
+	'range',
+	'start',
+	'end',
+	'leadingComments',
+	'trailingComments'
+]);
+
+function isNode(value: unknown): value is ES.Node {
+	return typeof value === 'object' && value !== null && typeof (value as ES.Node).type === 'string';
+}
+
+export class Names {
+	readonly #used: Set<string>;
+	readonly #next = new Map<string, number>();
+	readonly #bindings = new WeakMap<ES.Identifier, string>();
+
+	constructor(used: ReadonlySet<string>) {
+		this.#used = new Set(used);
+	}
+
+	unique(base: string): string {
+		let suffix = this.#next.get(base) ?? 0;
+		let name = suffix === 0 ? base : `${base}_${suffix}`;
+		while (this.#used.has(name)) name = `${base}_${++suffix}`;
+		this.#next.set(base, suffix + 1);
+		this.#used.add(name);
+		return name;
+	}
+
+	bound(declaration: ES.Identifier): string {
+		let name = this.#bindings.get(declaration);
+		if (name === undefined) {
+			name = this.unique(declaration.name);
+			this.#bindings.set(declaration, name);
+		}
+		return name;
+	}
+}
+
+export function children(node: ES.Node, each: (child: ES.Node) => void): void {
+	for (const key of Object.keys(node)) {
+		if (ignored.has(key)) continue;
+		const value = (node as unknown as Record<string, unknown>)[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) each(item);
+		} else if (isNode(value)) {
+			each(value);
+		}
+	}
+}
+
+export type Enter = (node: ES.Node, parent: ES.Node | null) => boolean | void;
+
+export function walk(node: ES.Node, enter: Enter, parent: ES.Node | null = null): void {
+	if (enter(node, parent) === false) return;
+	children(node, (child) => walk(child, enter, node));
+}
+
+export type Rewrite = (
+	node: ES.Node,
+	next: <T extends ES.Node>(node: T) => T
+) => ES.Node | undefined;
+
+export function rewrite<T extends ES.Node>(node: T, visit: Rewrite): T {
+	const next = <N extends ES.Node>(child: N): N => rewrite(child, visit);
+	const replaced = visit(node, next);
+	if (replaced !== undefined) {
+		return (
+			replaced !== node && replaced.loc == null && node.loc != null
+				? { ...replaced, loc: node.loc }
+				: replaced
+		) as T;
+	}
+	let copy: Record<string, unknown> | null = null;
+	const source = node as unknown as Record<string, unknown>;
+	for (const key of Object.keys(node)) {
+		if (ignored.has(key)) continue;
+		const value = source[key];
+		let mapped: unknown = value;
+		if (Array.isArray(value)) {
+			let changed = false;
+			const items = value.map((item: unknown) => {
+				if (!isNode(item)) return item;
+				const result = next(item);
+				if (result !== item) changed = true;
+				return result;
+			});
+			if (changed) mapped = items;
+		} else if (isNode(value)) {
+			mapped = next(value);
+		}
+		if (mapped !== value) {
+			copy ??= { ...source };
+			copy[key] = mapped;
+		}
+	}
+	return (copy ?? node) as T;
+}
+
+export function id(name: string): ES.Identifier {
+	return { type: 'Identifier', name };
+}
+
+export function literal(value: string | number | boolean | null): ES.Literal {
+	return { type: 'Literal', value };
+}
+
+export function object(entries: Readonly<Record<string, ES.Expression>>): ES.ObjectExpression {
+	return {
+		type: 'ObjectExpression',
+		properties: Object.entries(entries).map(([key, value]) => ({
+			type: 'Property',
+			key: /^[A-Za-z_$][\w$]*$/.test(key) ? id(key) : literal(key),
+			value,
+			kind: 'init',
+			method: false,
+			shorthand: false,
+			computed: false
+		}))
+	};
+}
+
+export function member(object: ES.Expression, property: string): ES.MemberExpression {
+	return {
+		type: 'MemberExpression',
+		object,
+		property: id(property),
+		computed: false,
+		optional: false
+	};
+}
+
+export function call(
+	callee: ES.Expression,
+	...args: readonly (ES.Expression | ES.SpreadElement)[]
+): ES.SimpleCallExpression {
+	return { type: 'CallExpression', callee, arguments: [...args], optional: false };
+}
+
+export function arrow(
+	params: readonly ES.Pattern[],
+	body: ES.Expression | readonly ES.Statement[]
+): ES.ArrowFunctionExpression {
+	const block = Array.isArray(body);
+	return {
+		type: 'ArrowFunctionExpression',
+		params: [...params],
+		body: block
+			? { type: 'BlockStatement', body: [...(body as readonly ES.Statement[])] }
+			: (body as ES.Expression),
+		expression: !block,
+		async: false,
+		generator: false
+	};
+}
+
+export function functionExpression(
+	params: readonly ES.Pattern[],
+	body: readonly ES.Statement[]
+): ES.FunctionExpression {
+	return {
+		type: 'FunctionExpression',
+		id: null,
+		params: [...params],
+		body: { type: 'BlockStatement', body: [...body] },
+		async: false,
+		generator: false
+	};
+}
+
+export function conditional(
+	test: ES.Expression,
+	consequent: ES.Expression,
+	alternate: ES.Expression
+): ES.ConditionalExpression {
+	return { type: 'ConditionalExpression', test, consequent, alternate };
+}
+
+export function logical(
+	operator: ES.LogicalOperator,
+	left: ES.Expression,
+	right: ES.Expression
+): ES.LogicalExpression {
+	return { type: 'LogicalExpression', operator, left, right };
+}
+
+export function binary(
+	operator: ES.BinaryOperator,
+	left: ES.Expression,
+	right: ES.Expression
+): ES.BinaryExpression {
+	return { type: 'BinaryExpression', operator, left, right };
+}
+
+export function template(
+	quasis: readonly string[],
+	expressions: readonly ES.Expression[]
+): ES.TemplateLiteral {
+	return {
+		type: 'TemplateLiteral',
+		quasis: quasis.map((raw, index) => ({
+			type: 'TemplateElement',
+			value: { raw: raw.replace(/[\\`]|\$\{/g, (match) => `\\${match}`), cooked: raw },
+			tail: index === quasis.length - 1
+		})),
+		expressions: [...expressions]
+	};
+}
+
+export function statement(expression: ES.Expression): ES.ExpressionStatement {
+	return { type: 'ExpressionStatement', expression };
+}
+
+export function constant(name: string, init: ES.Expression): ES.VariableDeclaration {
+	return {
+		type: 'VariableDeclaration',
+		kind: 'const',
+		declarations: [{ type: 'VariableDeclarator', id: id(name), init }]
+	};
+}
+
+export function namespaceImport(local: string, source: string): ES.ImportDeclaration {
+	return {
+		type: 'ImportDeclaration',
+		specifiers: [{ type: 'ImportNamespaceSpecifier', local: id(local) }],
+		source: literal(source) as ES.Literal & { value: string },
+		attributes: []
+	};
+}
+
+export function exportDefaultFunction(
+	name: string,
+	params: readonly ES.Pattern[],
+	body: readonly ES.Statement[]
+): ES.ExportDefaultDeclaration {
+	return {
+		type: 'ExportDefaultDeclaration',
+		declaration: {
+			type: 'FunctionDeclaration',
+			id: id(name),
+			params: [...params],
+			body: { type: 'BlockStatement', body: [...body] },
+			async: false,
+			generator: false
+		}
+	};
+}
+
+export function program(body: readonly (ES.Statement | ES.ModuleDeclaration)[]): ES.Program {
+	return { type: 'Program', sourceType: 'module', body: [...body] };
+}

package/src/compiler/ir/maps.ts

@@ -0,0 +1,64 @@
+import remapping, {
+	type DecodedSourceMap,
+	type EncodedSourceMap,
+	type SourceMap,
+	type SourceMapInput
+} from '@jridgewell/remapping';
+
+export type InputMap = string | EncodedSourceMap | DecodedSourceMap;
+
+export interface OutputMap {
+	sources: (string | null)[];
+}
+
+export function basename(path: string): string {
+	return path.split(/[/\\]/).pop() as string;
+}
+
+export function relative(from: string, to: string): string {
+	const base = from.split(/[/\\]/);
+	const target = to.split(/[/\\]/);
+	base.pop();
+	while (base.length > 0 && target.length > 0 && base[0] === target[0]) {
+		base.shift();
+		target.shift();
+	}
+	return [...base.map(() => '..'), ...target].join('/');
+}
+
+export function sourceName(
+	filename: string | null,
+	outputFilename: string | null | undefined
+): string | undefined {
+	if (filename === null) return undefined;
+	return outputFilename ? relative(outputFilename, filename) : basename(filename);
+}
+
+export function combine(file: string | null, maps: readonly SourceMapInput[]): SourceMap | null {
+	if (maps.length === 0) return null;
+	let next = 1;
+	const sourced = (map: SourceMapInput) => (map as { sources: unknown[] }).sources.length === 1;
+	const map = maps.slice(0, -1).every(sourced)
+		? remapping(maps as SourceMapInput[], () => null, true)
+		: remapping(
+				maps[0] as SourceMapInput,
+				(source) => (source === file && maps[next] ? maps[next++] : null),
+				true
+			);
+	if (!map.file) delete map.file;
+	if (map.sources.length === 0) map.sources = [file];
+	return map;
+}
+
+export function chain(map: OutputMap, filename: string | null, input: InputMap): void {
+	const own = map.sources[0] ?? null;
+	const file = filename === null ? null : basename(filename);
+	const parsed = (typeof input === 'string' ? JSON.parse(input) : input) as EncodedSourceMap;
+	const preceding =
+		parsed.sources.length === 1 && !parsed.sources[0] ? { ...parsed, sources: [file] } : parsed;
+	map.sources = [file];
+	Object.assign(map, combine(file, [map as SourceMapInput, preceding]));
+	if (own !== null && file !== own) {
+		map.sources = map.sources.map((source) => (source === null ? null : relative(own, source)));
+	}
+}