vigla 0.0.0-stage → 0.1.0

package/src/runtime/reactivity/leaving.ts

@@ -0,0 +1,303 @@
+import { active, alias, excluded, open, processing, type Batch } from './batch.ts';
+import { destroy, detach, detachment, fail } from './effects.ts';
+import { viewOf } from './views.ts';
+import {
+	CLEAN,
+	isDerived,
+	retainsFailures,
+	type Derived,
+	type Effect,
+	type Failure,
+	type Reaction,
+	type Source
+} from './graph.ts';
+import { beforeOf } from './history.ts';
+import { countLeaving, outgoing, selecting, setOutgoing } from './outgoing.ts';
+import { running, setOwner, track, view } from './tracking.ts';
+
+interface Entry {
+	readonly epoch: Epoch;
+	readonly value: unknown;
+	next: Entry | null;
+}
+
+interface Chain {
+	first: Entry;
+	last: Entry;
+}
+
+interface Epoch {
+	readonly order: number;
+	readonly sources: WeakRef<Source>[];
+	users: number;
+	next: Epoch | null;
+}
+
+export interface Cached {
+	value: unknown;
+	failure: Failure | null;
+	ready: boolean;
+	readonly locals: Map<Source, number>;
+	effects: Effect[] | null;
+}
+
+export interface LeavingView {
+	readonly epoch: Epoch;
+	values: WeakMap<Derived, Cached>;
+	locals: WeakMap<Source, Reaction>;
+	effects: Set<Effect> | null;
+	computing: Derived | null;
+	cache: Cached | null;
+	users: number;
+}
+
+let clock = 0;
+let first: Epoch | null = null;
+let latest: Epoch | null = null;
+let chains: WeakMap<Source, Chain> | null = null;
+let commits = new WeakMap<Batch, Epoch>();
+const branches = new WeakMap<Effect, LeavingView>();
+const inheriting = new WeakMap<Effect, () => void>();
+
+function append(epoch: Epoch, source: Source, value: unknown): void {
+	const map = chains as WeakMap<Source, Chain>;
+	const chain = map.get(source);
+	if (chain !== undefined && chain.last.epoch === epoch) return;
+	const entry: Entry = { epoch, value, next: null };
+	if (chain === undefined) map.set(source, { first: entry, last: entry });
+	else chain.last = chain.last.next = entry;
+	epoch.sources.push(new WeakRef(source));
+}
+
+export function remember(source: Source, value: unknown): void {
+	if (latest !== null) append(latest, source, value);
+}
+
+function start(): Epoch {
+	const given = processing ?? active ?? open;
+	const batch = given === null ? null : alias(given);
+	const known = batch === null ? undefined : commits.get(batch);
+	if (known !== undefined && known.users > 0) return known;
+	const epoch: Epoch = { order: ++clock, sources: [], users: 0, next: null };
+	if (latest === null) {
+		chains = new WeakMap();
+		first = epoch;
+	} else latest.next = epoch;
+	latest = epoch;
+	if (batch !== null) {
+		commits.set(batch, epoch);
+		const before = beforeOf(batch);
+		for (const [source, value] of before) append(epoch, source, value);
+		const givenView = view !== null && alias(view.batch) === batch ? view : viewOf(batch);
+		for (const source of givenView.hidden.keys())
+			if (!before.has(source)) append(epoch, source, givenView.values.get(source));
+	}
+	return epoch;
+}
+
+function prune(): void {
+	while (first !== null && first.users === 0) {
+		const expired = first;
+		first = expired.next;
+		expired.next = null;
+		if (first === null) {
+			expired.sources.length = 0;
+			latest = null;
+			chains = null;
+			commits = new WeakMap();
+			return;
+		}
+		for (const ref of expired.sources) {
+			const source = ref.deref();
+			if (source === undefined) continue;
+			const chain = chains?.get(source);
+			if (chain === undefined || chain.first.epoch !== expired) continue;
+			const next = chain.first.next;
+			if (next === null) chains?.delete(source);
+			else chain.first = next;
+		}
+		expired.sources.length = 0;
+	}
+}
+
+function release(given: LeavingView): void {
+	if (--given.users > 0) return;
+	given.values = new WeakMap();
+	given.locals = new WeakMap();
+	const effects = given.effects;
+	given.effects = null;
+	given.epoch.users--;
+	prune();
+	for (const effect of effects ?? []) destroy(effect);
+}
+
+export function leaving(branch: Effect): () => boolean {
+	stayed(branch);
+	const epoch = start();
+	epoch.users++;
+	const given: LeavingView = {
+		epoch,
+		values: new WeakMap(),
+		locals: new WeakMap(),
+		effects: null,
+		computing: null,
+		cache: null,
+		users: 1
+	};
+	branches.set(branch, given);
+	countLeaving(1);
+	const inherited = detachment(branch);
+	if (inherited !== null) inheriting.set(branch, inherited);
+	detach(branch, () => {
+		stayed(branch);
+		inherited?.();
+	});
+	return () => {
+		if (branches.get(branch) !== given) return false;
+		stayed(branch);
+		return true;
+	};
+}
+
+export function stayed(branch: Effect): void {
+	const given = branches.get(branch);
+	if (given === undefined) return;
+	branches.delete(branch);
+	countLeaving(-1);
+	detach(branch, branch.destroyed ? null : (inheriting.get(branch) ?? null));
+	inheriting.delete(branch);
+	release(given);
+}
+
+function admitted(branch: Effect): boolean {
+	const reaction = running();
+	if (reaction === null) return false;
+	const current = processing ?? active;
+	if (current === null) return false;
+	const batch = alias(current);
+	if (batch.shown?.has(branch) !== true || excluded(branch, batch)) return false;
+	for (
+		let at = isDerived(reaction) ? reaction.owner : (reaction as Effect);
+		at !== null;
+		at = at.parent
+	)
+		if (at === branch) return true;
+	return false;
+}
+
+export function leavingView(derived: Derived): LeavingView | null {
+	if (!selecting) return null;
+	for (let at = derived.owner; at !== null; at = at.parent) {
+		if (at.destroyed) return null;
+		const given = branches.get(at);
+		if (given !== undefined) return admitted(at) ? null : given;
+	}
+	return null;
+}
+
+function entryOf(source: Source, epoch: Epoch): Entry | null {
+	let entry = chains?.get(source)?.first ?? null;
+	while (entry !== null && entry.epoch.order < epoch.order) entry = entry.next;
+	return entry;
+}
+
+function unchanged(source: Derived, epoch: Epoch, seen: Set<Derived>): boolean {
+	if (seen.has(source)) return true;
+	seen.add(source);
+	for (const dep of source.deps ?? []) {
+		if (entryOf(dep, epoch) !== null) return false;
+		if (isDerived(dep) && !unchanged(dep, epoch, seen)) return false;
+	}
+	return true;
+}
+
+function inherit(given: LeavingView, locals: ReadonlyMap<Source, number>): void {
+	if (given.cache === null) return;
+	for (const [source, version] of locals)
+		if (given.locals.get(source) !== given.computing) given.cache.locals.set(source, version);
+}
+
+function cached(source: Derived, given: LeavingView): unknown {
+	let found = given.values.get(source);
+	if (found !== undefined && found.ready) {
+		for (const [local, version] of found.locals)
+			if (local.wv !== version) {
+				found.ready = false;
+				break;
+			}
+		if (found.ready) {
+			inherit(given, found.locals);
+			if (found.failure !== null) throw found.failure.error;
+			return found.value;
+		}
+	}
+	if (found === undefined) {
+		found = { value: undefined, failure: null, ready: false, locals: new Map(), effects: null };
+		given.values.set(source, found);
+		if (
+			(source.computed || source.failure !== null) &&
+			source.status === CLEAN &&
+			unchanged(source, given.epoch, new Set())
+		) {
+			found.value = source.v;
+			found.failure = source.failure;
+			found.ready = true;
+			if (found.failure !== null) throw found.failure.error;
+			return found.value;
+		}
+	}
+	for (const effect of found.effects ?? []) {
+		given.effects?.delete(effect);
+		destroy(effect);
+	}
+	found.effects = null;
+	found.failure = null;
+	found.locals.clear();
+	const previousCache = given.cache;
+	const previousDerived = given.computing;
+	const previousOwner = setOwner(source.owner);
+	given.cache = found;
+	given.computing = source;
+	try {
+		found.value = track(source, source.fn, true);
+		found.ready = true;
+		return found.value;
+	} catch (error) {
+		if (source.owner === null) throw error;
+		if (!source.owner.destroyed) fail(source.owner, error);
+		found.value = undefined;
+		found.ready = true;
+		if (!retainsFailures(source)) return undefined;
+		found.failure = { error };
+		throw error;
+	} finally {
+		given.cache = previousCache;
+		given.computing = previousDerived;
+		setOwner(previousOwner);
+		inherit(given, found.locals);
+	}
+}
+
+function read(source: Source, given: LeavingView): unknown {
+	const local = given.locals.get(source);
+	if (local !== undefined) {
+		if (given.cache !== null && local !== given.computing)
+			given.cache.locals.set(source, source.wv);
+		return source.v;
+	}
+	const entry = entryOf(source, given.epoch);
+	if (entry !== null) return entry.value;
+	return isDerived(source) ? cached(source, given) : source.v;
+}
+
+export function readLeaving(source: Source, given: LeavingView): unknown {
+	if (outgoing === given) return read(source, given);
+	const previous = setOutgoing(given);
+	given.users++;
+	try {
+		return read(source, given);
+	} finally {
+		setOutgoing(previous);
+		release(given);
+	}
+}

package/src/runtime/reactivity/loss.ts

@@ -0,0 +1,71 @@
+import { warn } from '../../shared/diagnostics.ts';
+import { active, open, processing } from './batch.ts';
+import type { Source } from './graph.ts';
+import { labelOf } from './provenance.ts';
+import { asyncRun, lost, setLost, type Resumption } from './tracking.ts';
+
+const warned = new WeakSet<Resumption>();
+
+function expire(run: Resumption | null): void {
+	queueMicrotask(() => {
+		if (lost === run) setLost(null);
+	});
+}
+
+export async function trackLoss<T>(value: T | PromiseLike<T>): Promise<() => T> {
+	const run = lost ?? asyncRun();
+	if (lost !== null) expire(lost);
+	const resolved = await value;
+	return () => {
+		setLost(run);
+		expire(run);
+		return resolved;
+	};
+}
+
+export async function* trackLossEach<T>(
+	iterable: Iterable<T> | AsyncIterable<T>
+): AsyncGenerator<T, void> {
+	const iterator: Iterator<T> | AsyncIterator<T> | undefined =
+		(iterable as AsyncIterable<T>)[Symbol.asyncIterator]?.() ??
+		(iterable as Iterable<T>)[Symbol.iterator]?.();
+	if (iterator === undefined) throw new TypeError('value is not async iterable');
+	let close = true;
+	try {
+		while (true) {
+			const { done, value } = (await trackLoss(iterator.next()))();
+			if (done) {
+				close = false;
+				break;
+			}
+			const run = lost;
+			try {
+				yield value;
+			} catch (error) {
+				setLost(run);
+				if (iterator.return !== undefined) (await trackLoss(iterator.return()))();
+				throw error;
+			}
+			setLost(run);
+		}
+	} catch (error) {
+		close = false;
+		throw error;
+	} finally {
+		if (close && iterator.return !== undefined) (await trackLoss(iterator.return()))();
+	}
+}
+
+export function lose(source: Source): void {
+	const run = lost;
+	if (run === null || warned.has(run) || run.reads.has(source)) return;
+	if (active !== null || open !== null || processing !== null) return;
+	warned.add(run);
+	warn(
+		'await_reactivity_loss',
+		`Detected reactivity loss when reading \`${labelOf(source)}\`. This happens when state is read in an async function after an earlier \`await\``
+	);
+	const trace = new Error();
+	Object.defineProperty(trace, 'name', { value: 'traced at' });
+	console.warn(trace);
+}

package/src/runtime/reactivity/outgoing.ts

@@ -0,0 +1,41 @@
+import { ROOT, type Effect, type Reaction, type Source } from './graph.ts';
+import type { LeavingView } from './leaving.ts';
+
+export let outgoing: LeavingView | null = null;
+export let leavingCount = 0;
+export let selecting = true;
+
+export function withoutLeaving<T>(fn: () => T): T {
+	const previous = outgoing;
+	const allowed = selecting;
+	outgoing = null;
+	selecting = false;
+	try {
+		return fn();
+	} finally {
+		outgoing = previous;
+		selecting = allowed;
+	}
+}
+
+export function setOutgoing(next: LeavingView | null): LeavingView | null {
+	const previous = outgoing;
+	outgoing = next;
+	return previous;
+}
+
+export function countLeaving(delta: 1 | -1): void {
+	leavingCount += delta;
+}
+
+export function localLeaving(source: Source, reaction: Reaction): void {
+	outgoing?.locals.set(source, reaction);
+}
+
+export function ownLeaving(effect: Effect): boolean {
+	const given = outgoing;
+	if (given === null || given.cache === null || effect.kind === ROOT) return false;
+	(given.cache.effects ??= []).push(effect);
+	(given.effects ??= new Set()).add(effect);
+	return true;
+}

package/src/runtime/reactivity/owners.ts

@@ -0,0 +1,234 @@
+import { keyed, type Context, type Layer } from '../../shared/context.ts';
+import { failure } from '../../shared/diagnostics.ts';
+import { format } from '../../shared/format.ts';
+import { destroy, destroyed, detached, start } from './effects.ts';
+import { setFront } from './front.ts';
+import { lifetime } from './abort.ts';
+import { settledUnder, unit } from './units.ts';
+import { presently } from './past.ts';
+import type { Effect } from './graph.ts';
+import { ambient, carry, port } from './carried.ts';
+import { handle } from './handlers.ts';
+import { setOwner, withoutReaction } from './tracking.ts';
+
+const effects = new WeakMap<Owner, Effect>();
+const owners = new WeakMap<Effect, Owner>();
+
+export interface Components {
+	layer(): Layer<Effect> | null;
+	teardown?(fn: () => void): boolean;
+}
+
+const installed: Components[] = [];
+
+export function installComponents(components: Components): void {
+	installed.push(components);
+}
+
+export function layerOf(effect: Effect | null): Layer<Effect> | null {
+	return (effect?.context as Layer<Effect> | null | undefined) ?? null;
+}
+
+function standing(): Layer<Effect> | null {
+	for (const components of installed) {
+		const layer = components.layer();
+		if (layer !== null) return layer;
+	}
+	return null;
+}
+
+function current(): Layer<Effect> | null {
+	return standing() ?? layerOf(ambient());
+}
+
+function writable(): Layer<Effect> {
+	const layer = standing();
+	if (layer !== null) return layer;
+	const effect = ambient();
+	if (effect === null) {
+		throw failure('context_without_owner', 'Context can only be set where an owner exists');
+	}
+	return ownContext(effect);
+}
+
+export function getContext<T>(key: unknown): T {
+	for (let layer = current(); layer !== null; layer = layer.parent) {
+		if (layer.map?.has(key)) return layer.map.get(key) as T;
+	}
+	return undefined as T;
+}
+
+export function setContext<T>(key: unknown, value: T): T {
+	const layer = writable();
+	(layer.map ??= new Map()).set(key, value);
+	return value;
+}
+
+export function hasContext(key: unknown): boolean {
+	for (let layer = current(); layer !== null; layer = layer.parent) {
+		if (layer.map?.has(key)) return true;
+	}
+	return false;
+}
+
+export function createContext<T>(): Context<T> {
+	return keyed<T>({ getContext, setContext, hasContext });
+}
+
+export function getAllContexts<T extends Map<unknown, unknown> = Map<unknown, unknown>>(): T {
+	const chain: Layer<Effect>[] = [];
+	for (let layer = current(); layer !== null; layer = layer.parent) chain.push(layer);
+	const all = new Map<unknown, unknown>();
+	for (let index = chain.length - 1; index >= 0; index--) {
+		for (const [key, value] of chain[index]?.map ?? []) all.set(key, value);
+	}
+	return all as T;
+}
+
+function register(effect: Effect | null, fn: () => void): Effect {
+	const previous = setOwner(effect);
+	try {
+		return destroyed(fn);
+	} finally {
+		setOwner(previous);
+	}
+}
+
+export function onDestroy(fn: () => void): void {
+	const effect = ambient();
+	if (effect !== null && effect.destroyed) {
+		withoutReaction(() => presently(fn));
+		return;
+	}
+	for (const components of installed) if (components.teardown?.(fn) === true) return;
+	register(effect, fn);
+}
+
+export function ownContext(effect: Effect): Layer<Effect> {
+	const inherited = effect.context as Layer<Effect> | null;
+	if (inherited !== null && inherited.owner === effect) return inherited;
+	const layer: Layer<Effect> = { parent: inherited, owner: effect, component: false, map: null };
+	effect.context = layer;
+	repoint(effect, inherited, layer);
+	return layer;
+}
+
+function repoint(effect: Effect, inherited: Layer<Effect> | null, layer: Layer<Effect>): void {
+	for (let child = effect.first; child !== null; child = child.next) {
+		const context = child.context as Layer<Effect> | null;
+		if (context === inherited) {
+			child.context = layer;
+			repoint(child, inherited, layer);
+		} else if (context?.owner === child && context.parent === inherited && !context.isolated) {
+			context.parent = layer;
+		}
+	}
+}
+
+export class Owner {
+	constructor(effect: Effect) {
+		effects.set(this, effect);
+		owners.set(effect, this);
+		ownContext(effect);
+	}
+
+	get parent(): Owner | null {
+		const parent = effectOf(this).parent;
+		return parent === null ? null : ownerOf(parent);
+	}
+
+	get disposed(): boolean {
+		return effectOf(this).destroyed;
+	}
+
+	get signal(): AbortSignal {
+		return lifetime(effectOf(this));
+	}
+
+	onError(handler: (error: unknown) => void): () => void {
+		const effect = effectOf(this);
+		if (effect.destroyed) throw new Error('Cannot handle failures under a disposed owner');
+		return handle(effect, handler);
+	}
+
+	run<T>(fn: () => T): T {
+		const effect = effectOf(this);
+		if (effect.destroyed) throw new Error('Cannot run code under a disposed owner');
+		return port === null ? enter(effect, fn) : carry(effect, () => enter(effect, fn));
+	}
+
+	async start<T>(fn: () => T): Promise<Awaited<T>> {
+		const effect = effectOf(this);
+		if (effect.destroyed) throw new Error('Cannot run code under a disposed owner');
+		const finish = unit(effect);
+		try {
+			return await this.run(fn);
+		} finally {
+			finish();
+		}
+	}
+
+	settled(): Promise<void> {
+		return settledUnder(effectOf(this));
+	}
+
+	root(fn?: () => void | (() => void)): Owner {
+		return root(fn, this);
+	}
+
+	onDispose(fn: () => void): () => void {
+		const effect = effectOf(this);
+		if (effect.destroyed) {
+			withoutReaction(() => presently(fn));
+			return () => {};
+		}
+		let live = true;
+		const registered = register(effect, () => {
+			if (live) fn();
+		});
+		return () => {
+			live = false;
+			destroy(registered);
+		};
+	}
+
+	dispose(): void {
+		destroy(effectOf(this));
+	}
+}
+
+function enter<T>(effect: Effect, fn: () => T): T {
+	const previous = setOwner(effect);
+	try {
+		return withoutReaction(fn);
+	} finally {
+		setOwner(previous);
+	}
+}
+
+export function effectOf(owner: Owner): Effect {
+	return effects.get(owner) as Effect;
+}
+
+export function ownerOf(effect: Effect): Owner {
+	return owners.get(effect) ?? new Owner(effect);
+}
+
+export function getOwner(): Owner | null {
+	const effect = ambient();
+	return effect === null ? null : ownerOf(effect);
+}
+
+export function root(fn?: () => void | (() => void), parent: Owner | null = null): Owner {
+	if (parent !== null && parent.disposed)
+		throw new Error('Cannot create a root under a disposed owner');
+	const effect = detached(null, parent === null ? null : effectOf(parent));
+	effect.scope = true;
+	if (parent === null) setFront(effect, format);
+	const owner = ownerOf(effect);
+	if (fn !== undefined) {
+		effect.fn = fn;
+		start(effect);
+	}
+	return owner;
+}

package/src/runtime/reactivity/past.ts

@@ -0,0 +1,57 @@
+import { active, open, processing } from './batch.ts';
+import type { Source } from './graph.ts';
+import { earlier, prior, type Prior } from './history.ts';
+import { withoutLeaving } from './outgoing.ts';
+import { past, setPast, withoutReaction } from './tracking.ts';
+
+let instant = false;
+let retiring = 0;
+
+export function tearingDown(): boolean {
+	return retiring !== 0;
+}
+
+export function instantly(fn: () => void): void {
+	const outer = instant;
+	instant = true;
+	try {
+		fn();
+	} finally {
+		instant = outer;
+	}
+}
+
+export function retire(teardown: () => void): void {
+	const batch = active ?? processing ?? open;
+	retiring++;
+	try {
+		if (batch === null || instant) withoutReaction(() => teardown.call(null));
+		else recalling(earlier(batch), open !== null && open !== batch ? prior(open) : null, teardown);
+	} finally {
+		retiring--;
+	}
+}
+
+export function recalling(before: Prior, later: Prior | null, fn: () => void): void {
+	const previous = setPast({ before, later, written: null, derived: null });
+	try {
+		withoutReaction(() => fn.call(null));
+	} finally {
+		setPast(previous);
+	}
+}
+
+export function presently(fn: () => void): void {
+	const previous = setPast(null);
+	try {
+		withoutLeaving(fn);
+	} finally {
+		setPast(previous);
+	}
+}
+
+export function written(source: Source): void {
+	if (past === null) return;
+	(past.written ??= new Set()).add(source);
+	past.derived = null;
+}