vigla 0.0.0 → 0.2.0

package/src/compiler/client/ownership.ts

@@ -0,0 +1,54 @@
+import type * as ES from 'estree';
+import { spanOf, type ComponentAnalysis } from '../analysis/index.ts';
+import * as b from '../ir/estree.ts';
+import type { Span } from '../ir/nodes.ts';
+import { rewrite, type Context } from './script.ts';
+
+export interface Ownership {
+	readonly validator: ES.Identifier;
+	readonly ignored: readonly Span[];
+}
+
+export function ownership(analysis: ComponentAnalysis, names: b.Names): Ownership {
+	const ignored: Span[] = [];
+	for (const [node, codes] of [...analysis.unit.ignores, ...analysis.ignored]) {
+		if (codes.has('ownership_invalid_mutation')) ignored.push(spanOf(node as ES.Node));
+	}
+	return { validator: b.id(names.unique('$$ownership')), ignored };
+}
+
+export function validateMutation(
+	context: Context,
+	node: ES.AssignmentExpression | ES.UpdateExpression,
+	value: ES.Expression
+): ES.Expression {
+	const ownership = context.ownership;
+	if (!context.dev || ownership === undefined || context.props === null) return value;
+	let base: ES.Node = node.type === 'AssignmentExpression' ? node.left : node.argument;
+	if (base.type !== 'MemberExpression') return value;
+	const span = spanOf(base);
+	if (ownership.ignored.some((ignored) => ignored.start <= span.start && ignored.end >= span.end))
+		return value;
+	const path: ES.Expression[] = [];
+	while (base.type === 'MemberExpression') {
+		const property = base.property;
+		if (property.type !== 'Literal' && property.type !== 'Identifier') return value;
+		path.unshift(
+			base.computed ? rewrite(context, property) : b.literal((property as ES.Identifier).name)
+		);
+		base = base.object;
+	}
+	if (base.type !== 'Identifier') return value;
+	const binding = context.analysis.references.get(base);
+	if (binding?.kind !== 'prop' || binding.prop === null) return value;
+	path.unshift(b.literal(base.name));
+	const position = base.loc?.start;
+	return b.call(
+		b.member(ownership.validator, 'mutation'),
+		b.literal(binding.prop.key),
+		{ type: 'ArrayExpression', elements: path },
+		value,
+		b.literal(position?.line ?? 0),
+		b.literal(position?.column ?? 0)
+	);
+}

package/src/compiler/client/parameters.ts

@@ -0,0 +1,38 @@
+import type * as ES from 'estree';
+import * as b from '../ir/estree.ts';
+import { extract, type Extraction } from './patterns.ts';
+import { runtime } from './script.ts';
+import type { TemplateContext } from './template.ts';
+
+export function snippetParameters(
+	context: TemplateContext,
+	parameters: readonly ES.Pattern[]
+): { params: ES.Pattern[]; declarations: ES.Statement[] } {
+	const params: ES.Pattern[] = [];
+	const declarations: ES.Statement[] = [];
+	parameters.forEach((parameter, index) => {
+		if (parameter.type === 'Identifier') {
+			params.push({
+				type: 'AssignmentPattern',
+				left: parameter,
+				right: b.member(context.runtime, 'noop')
+			});
+			return;
+		}
+		const argument = b.id(context.names.unique(`$$arg${index}`));
+		params.push(argument);
+		const base: ES.Expression = {
+			type: 'ChainExpression',
+			expression: { type: 'CallExpression', callee: argument, arguments: [], optional: true }
+		};
+		const extraction: Extraction = { context, optional: true, paths: [], inserts: declarations };
+		extract(extraction, parameter, base);
+		for (const path of extraction.paths) {
+			const thunk = b.arrow([], path.value);
+			declarations.push(
+				b.constant(path.name.name, path.defaulted ? runtime(context, 'derived', thunk) : thunk)
+			);
+		}
+	});
+	return { params, declarations };
+}

package/src/compiler/client/patterns.ts

@@ -0,0 +1,154 @@
+import type * as ES from 'estree';
+import { hasAwait, isSignal, spanOf, unsupported } from '../analysis/index.ts';
+import * as b from '../ir/estree.ts';
+import type { Rune } from '../ir/port.ts';
+import { declare, primitive, rewrite, runtime, type Context } from './script.ts';
+import { tagged } from './inspect.ts';
+
+export interface Path {
+	readonly name: ES.Identifier;
+	readonly value: ES.Expression;
+	readonly defaulted: boolean;
+}
+
+export interface Extraction {
+	readonly context: Context;
+	readonly optional: boolean;
+	readonly paths: Path[];
+	readonly inserts: ES.Statement[];
+}
+
+function step(
+	extraction: Extraction,
+	base: ES.Expression,
+	key: ES.Expression,
+	computed: boolean
+): ES.Expression {
+	if (!extraction.optional) {
+		return { type: 'MemberExpression', object: base, property: key, computed, optional: false };
+	}
+	const inner = base.type === 'ChainExpression' ? base.expression : base;
+	const member: ES.MemberExpression = {
+		type: 'MemberExpression',
+		object: inner as ES.Expression,
+		property: key,
+		computed,
+		optional: true
+	};
+	return { type: 'ChainExpression', expression: member };
+}
+
+function keyOf(property: ES.Property): { key: ES.Expression; computed: boolean } {
+	if (property.computed) return { key: property.key as ES.Expression, computed: true };
+	if (property.key.type === 'Identifier') return { key: b.id(property.key.name), computed: false };
+	return { key: property.key as ES.Expression, computed: true };
+}
+
+export function extract(
+	extraction: Extraction,
+	pattern: ES.Pattern,
+	base: ES.Expression,
+	defaulted = false
+): void {
+	const { context, paths, inserts } = extraction;
+	switch (pattern.type) {
+		case 'Identifier':
+			paths.push({ name: pattern, value: base, defaulted });
+			return;
+		case 'AssignmentPattern': {
+			const fallback = runtime(
+				context,
+				'fallback',
+				base,
+				b.arrow([], rewrite(context, pattern.right))
+			);
+			extract(extraction, pattern.left, fallback, true);
+			return;
+		}
+		case 'ObjectPattern': {
+			const keys: ES.Expression[] = [];
+			for (const property of pattern.properties) {
+				if (property.type === 'RestElement') {
+					const rest = runtime(context, 'exclude', base, {
+						type: 'ArrayExpression',
+						elements: keys
+					});
+					extract(extraction, property.argument, rest, defaulted);
+					continue;
+				}
+				const { key, computed } = keyOf(property);
+				keys.push(computed ? rewrite(context, key) : b.literal((key as ES.Identifier).name));
+				const member = computed ? rewrite(context, key) : key;
+				extract(extraction, property.value, step(extraction, base, member, computed), defaulted);
+			}
+			return;
+		}
+		case 'ArrayPattern': {
+			const array = b.id(context.names.unique('$$array'));
+			const rested = pattern.elements.at(-1)?.type === 'RestElement';
+			const args = rested ? [base] : [base, b.literal(pattern.elements.length)];
+			inserts.push(
+				b.constant(
+					array.name,
+					runtime(context, 'derived', b.arrow([], runtime(context, 'toArray', ...args)))
+				)
+			);
+			const current = runtime(context, 'get', array);
+			pattern.elements.forEach((element, index) => {
+				if (element === null) return;
+				if (element.type === 'RestElement') {
+					const rest = b.call(b.member(current, 'slice'), b.literal(index));
+					extract(extraction, element.argument, rest, defaulted);
+					return;
+				}
+				extract(extraction, element, step(extraction, current, b.literal(index), true), defaulted);
+			});
+			return;
+		}
+		default:
+			throw unsupported(spanOf(pattern), 'This destructuring pattern');
+	}
+}
+
+export function destructured(
+	context: Context,
+	rune: Rune,
+	pattern: ES.Pattern,
+	init: ES.CallExpression,
+	next: <T extends ES.Node>(node: T) => T
+): ES.VariableDeclarator[] {
+	const result: ES.VariableDeclarator[] = [];
+	const hold = (name: string, value: ES.Expression): ES.Identifier => {
+		const id = b.id(context.names.unique(name));
+		result.push({ type: 'VariableDeclarator', id, init: value });
+		return id;
+	};
+	const given = init.arguments[0] as ES.Expression | undefined;
+	const state = rune === '$state' || rune === '$state.raw';
+	let base: ES.Expression;
+	if (state) base = hold('tmp', given === undefined ? b.id('undefined') : next(given));
+	else if (rune === '$derived' && given?.type === 'Identifier' && !hasAwait(given))
+		base = next(given);
+	else base = runtime(context, 'get', hold('$$d', declare(context, rune, undefined, init, next)));
+	const extraction: Extraction = { context, optional: false, paths: [], inserts: [] };
+	extract(extraction, pattern, base);
+	for (const insert of extraction.inserts)
+		result.push(...(insert as ES.VariableDeclaration).declarations);
+	for (const path of extraction.paths) {
+		let value = path.value;
+		if (state) {
+			const binding = context.analysis.declarations.get(path.name);
+			if (rune === '$state' && !primitive(value)) value = runtime(context, 'proxy', value);
+			if (binding !== undefined && isSignal(binding)) value = runtime(context, 'state', value);
+		} else {
+			value = runtime(context, 'derived', b.arrow([], value));
+		}
+		const binding = context.analysis.declarations.get(path.name);
+		result.push({
+			type: 'VariableDeclarator',
+			id: path.name,
+			init: tagged(context, value, path.name.name, binding !== undefined && isSignal(binding))
+		});
+	}
+	return result;
+}