vigla 0.0.0 → 0.1.0

package/src/runtime/reactivity/async.ts

@@ -0,0 +1,272 @@
+import { alias, collect, current, holds, onMerge, request, within, type Batch } from './batch.ts';
+import { stage, write } from './scheduler.ts';
+import { inside } from './views.ts';
+import { staleReaction } from '../../shared/abort.ts';
+import { block, fail } from './effects.ts';
+import { sequence } from './history.ts';
+import { changed, get } from './reads.ts';
+import { waitFor } from './held.ts';
+import { asyncOrphan, pendingOutside } from './errors.ts';
+import { type Boundary, type Effect, type Source } from './graph.ts';
+import { source } from './sources.ts';
+import { showing, tallied, tally } from './tallies.ts';
+import { begin, exempt, recheck, released } from './units.ts';
+import { awaiting, owner, running, settleReads, type Resumption } from './tracking.ts';
+
+export interface AsyncRun {
+	stale(): boolean;
+	supersede(): void;
+	adopt(batch: Batch): void;
+}
+
+interface Result {
+	readonly order: number;
+	readonly revision: number;
+	readonly reading: Resumption;
+	readonly speculative: boolean;
+}
+
+export function reveal(boundary: Boundary): void {
+	const found = tallied(boundary);
+	if (found === undefined) return;
+	for (const effect of found.effects.splice(0)) if (!effect.destroyed) collect(effect);
+}
+
+function count(boundary: Boundary | null, delta: 1 | -1): void {
+	if (boundary === null) return;
+	const found = tally(boundary);
+	found.units += delta;
+	boundary.settle(delta);
+	if (found.source === null || found.queued) return;
+	found.queued = true;
+	queueMicrotask(() => {
+		found.queued = false;
+		if (found.source !== null) write(found.source, found.units);
+	});
+}
+
+export async function hold<T>(fn: () => T): Promise<Awaited<T>> {
+	const finish = work();
+	try {
+		return await fn();
+	} finally {
+		finish();
+	}
+}
+
+export function work(): () => void {
+	const batch = current();
+	const holder = owner;
+	const boundary = holder === null ? null : holder.boundary;
+	const blocking = !showing(boundary);
+	const counted = !batch.fork;
+	if (counted) begin();
+	count(boundary, 1);
+	if (blocking) {
+		batch.work += 1;
+		if (holder !== null) {
+			const owners = (batch.owners ??= new Map());
+			owners.set(holder, (owners.get(holder) ?? 0) + 1);
+		}
+	}
+	let unsettled = true;
+	const settle = (): void => {
+		if (!unsettled) return;
+		unsettled = false;
+		holder?.units?.delete(settle);
+		count(boundary, -1);
+		if (blocking) {
+			const target = alias(batch);
+			target.work -= 1;
+			const owners = target.owners;
+			if (holder !== null && owners !== null) {
+				const left = (owners.get(holder) ?? 1) - 1;
+				if (left > 0) owners.set(holder, left);
+				else owners.delete(holder);
+			}
+			if (!target.done && !holds(target)) request();
+		}
+		if (counted) released();
+		else recheck();
+	};
+	if (!counted) exempt(settle);
+	if (holder !== null && !holder.destroyed) (holder.units ??= new Set()).add(settle);
+	return settle;
+}
+
+export function asyncDerived<T>(fn: () => T | PromiseLike<T>): Promise<Source<T>> {
+	if (owner === null) asyncOrphan();
+	const signal = source<T>(undefined as T);
+	const latest = new Map<Batch, AsyncRun>();
+	const results = new Map<Batch, Result>();
+	const ranks = new WeakMap<Batch, number>();
+	let resolved = false;
+	let committed = 0;
+	let committedRevision = 0;
+	let revision = 0;
+	let retained: Resumption | null = null;
+	const prune = (): void => {
+		if (latest.size === 0 && results.size === 0 && retained !== null) settleReads(retained);
+	};
+	const realOrder = (finished = false): number => {
+		let order = committed;
+		for (const [holder, result] of results) {
+			const batch = alias(holder);
+			if (batch.fork || batch.discarded || (finished && !batch.done)) continue;
+			order = Math.max(order, result.order);
+		}
+		return order;
+	};
+	const rank = (given: Batch): number => {
+		const batch = alias(given);
+		const result = results.get(batch);
+		let order = Math.max(batch.order, ranks.get(batch) ?? 0, result?.order ?? 0);
+		if (result?.speculative && !batch.fork) order = Math.max(order, realOrder(true));
+		return order;
+	};
+	const move = (from: Batch, into: Batch): void => {
+		ranks.set(into, Math.max(from.order, ranks.get(from) ?? 0, rank(into)));
+		const incoming = results.get(from);
+		if (incoming === undefined) return;
+		results.delete(from);
+		const current = results.get(into);
+		const newer =
+			current === undefined ||
+			incoming.order > current.order ||
+			(incoming.order === current.order && incoming.revision > current.revision);
+		const selected = newer ? incoming : current;
+		results.set(into, {
+			...selected,
+			speculative: incoming.speculative || current?.speculative === true
+		});
+	};
+	const finish = (holder: Batch): void => {
+		const batch = alias(holder);
+		const result = results.get(batch);
+		if (result === undefined) return;
+		results.delete(batch);
+		if (!batch.discarded) {
+			const order = result.speculative ? Math.max(committed, result.order) : result.order;
+			if (
+				result.speculative ||
+				order > committed ||
+				(order === committed && result.revision > committedRevision)
+			) {
+				committed = order;
+				ranks.set(batch, Math.max(rank(batch), order));
+				committedRevision = result.revision;
+				retained = result.reading;
+			}
+		}
+		prune();
+	};
+	const retain = (batch: Batch, reading: Resumption, order: number): void => {
+		ranks.set(batch, Math.max(rank(batch), order));
+		const current = results.get(batch);
+		results.set(batch, {
+			order,
+			revision: ++revision,
+			reading,
+			speculative: batch.fork || current?.speculative === true
+		});
+		if (current !== undefined) return;
+		onMerge(batch, move);
+		void waitFor(batch).then(() => finish(batch));
+	};
+	let initial = true;
+	let first!: (source: Source<T>) => void;
+	let refuse!: (error: unknown) => void;
+	const ready = new Promise<Source<T>>((resolve, reject) => {
+		first = resolve;
+		refuse = reject;
+	});
+	const effect: Effect = block(() => {
+		const batch = current();
+		const origin = sequence();
+		let order = Math.max(rank(batch), realOrder(true));
+		latest.get(batch)?.supersede();
+		const done = initial ? null : work();
+		initial = false;
+		let target = batch;
+		let owned = true;
+		const token: AsyncRun = {
+			stale() {
+				if (owned && !alias(target).fork && order < realOrder(true)) return true;
+				return changed(run.values, run.reaction);
+			},
+			supersede() {
+				if (!owned) return;
+				owned = false;
+				if (latest.get(target) === token) latest.delete(target);
+				done?.();
+			},
+			adopt(into) {
+				move(target, into);
+				order = Math.max(order, rank(into));
+				if (owned) {
+					latest.delete(target);
+					latest.set(into, token);
+				}
+				target = into;
+			}
+		};
+		latest.set(batch, token);
+		(batch.runs ??= new Map()).set(owner as Effect, token);
+		const run: Resumption = {
+			reaction: running() as Effect,
+			reads: new Set(),
+			values: new Map(),
+			ended: false
+		};
+		let promise: Promise<T>;
+		try {
+			promise = Promise.resolve(awaiting(run, fn));
+		} catch (error) {
+			promise = Promise.reject(error);
+		}
+		const own = (): boolean => {
+			if (!owned || latest.get(target) !== token) return false;
+			owned = false;
+			latest.delete(target);
+			const current = alias(target);
+			if (effect.destroyed || current.discarded) return false;
+			return current.fork || order >= realOrder(true);
+		};
+		promise.then(
+			(value) => {
+				if (own()) {
+					within(batch, () => {
+						const holder = alias(target);
+						if (holder.fork || order >= realOrder()) write(signal, value, origin);
+						else inside(holder, () => stage(holder, signal, value, origin));
+						retain(current(), run, order);
+					});
+					resolved = true;
+					first(signal);
+				}
+				prune();
+				done?.();
+			},
+			(error: unknown) => {
+				if (error === staleReaction && !alias(target).discarded) return;
+				const owned = own();
+				prune();
+				done?.();
+				if (!owned) return;
+				if (resolved) within(target, () => fail(effect, error));
+				else refuse(error);
+			}
+		);
+	});
+	effect.async = true;
+	return ready;
+}
+
+export function pending(): number {
+	if (owner === null) return pendingOutside();
+	const boundary = owner.boundary;
+	if (boundary === null) return 0;
+	const found = tally(boundary);
+	found.source ??= source(found.units);
+	return get(found.source);
+}

package/src/runtime/reactivity/batch.ts

@@ -0,0 +1,382 @@
+import { DEV } from 'esm-env';
+import type { AsyncRun } from './async.ts';
+import { BRANCH, CLEAN, ROOT, type Effect, type Source } from './graph.ts';
+import { clear, detach, enter, sequence, type History, type Origin } from './history.ts';
+import { forgotten } from './provenance.ts';
+import { parked, showing } from './tallies.ts';
+
+type Phase = 'structure' | 'commit' | 'content' | 'effects';
+export type Transfer = (from: Batch, into: Batch) => void;
+
+export interface Change {
+	prepare?(): void;
+	apply(): void;
+}
+
+export interface Batch extends History {
+	after: Map<Source, unknown> | null;
+	origins: Map<Source, Origin> | null;
+	runs: Map<Effect, AsyncRun> | null;
+	reads: Map<Effect, ReadonlyMap<Source, unknown>> | null;
+	readonly queued: Effect[];
+	readonly commits: Change[];
+	merges: Transfer[] | null;
+	readonly effects: Effect[];
+	discards: (() => void)[] | null;
+	content: Effect[] | null;
+	deferred: Effect[] | null;
+	members: Set<Effect> | null;
+	forced: Set<Effect> | null;
+	skipped: Set<Effect> | null;
+	shown: Set<Effect> | null;
+	owners: Map<Effect, number> | null;
+	roots: Set<Effect> | null;
+	waits: Map<Batch, Set<Effect>> | null;
+	settles: (() => void)[] | null;
+	into: Batch | null;
+	work: number;
+	phase: Phase | null;
+	started: boolean;
+	fork: boolean;
+	held: boolean;
+	done: boolean;
+	discarded: boolean;
+}
+
+export function createBatch(): Batch {
+	const created: Batch = {
+		order: sequence(),
+		log: [],
+		map: null,
+		prior: null,
+		passed: null,
+		crowded: false,
+		after: null,
+		origins: null,
+		runs: null,
+		reads: null,
+		queued: [],
+		commits: [],
+		merges: null,
+		effects: [],
+		discards: null,
+		content: null,
+		deferred: null,
+		members: null,
+		forced: null,
+		skipped: null,
+		shown: null,
+		owners: null,
+		roots: null,
+		waits: null,
+		settles: null,
+		into: null,
+		work: 0,
+		phase: null,
+		started: false,
+		fork: false,
+		held: false,
+		done: false,
+		discarded: false
+	};
+	enter(created);
+	return created;
+}
+
+export function release(batch: Batch): void {
+	if (DEV) forgotten(batch);
+	batch.runs = null;
+	batch.merges = null;
+	batch.origins = null;
+	batch.reads = null;
+	clear(batch);
+}
+
+export let open: Batch | null = null;
+export let processing: Batch | null = null;
+export let active: Batch | null = null;
+export const pending: Batch[] = [];
+export const offscreen = new Set<Effect>();
+export const overlooked = new WeakSet<Effect>();
+let requested = false;
+let flusher: () => void = () => {};
+
+export function setOpen(next: Batch | null): void {
+	open = next;
+}
+
+export function setProcessing(next: Batch | null): Batch | null {
+	const previous = processing;
+	processing = next;
+	return previous;
+}
+
+export function setActive(next: Batch | null): Batch | null {
+	const previous = active;
+	active = next;
+	return previous;
+}
+
+export function onFlush(flush: () => void): void {
+	flusher = flush;
+}
+
+export function alias(batch: Batch): Batch {
+	let found = batch;
+	while (found.into !== null) found = found.into;
+	return found;
+}
+
+export function joins(batch: Batch | null): batch is Batch {
+	return batch !== null && (batch.phase === 'structure' || batch.phase === 'commit');
+}
+
+export function receiver(): Batch | null {
+	return active ?? (joins(processing) ? processing : null);
+}
+
+export function request(): void {
+	if (requested) return;
+	requested = true;
+	queueMicrotask(() => {
+		requested = false;
+		if (processing === null) flusher();
+	});
+}
+
+export function opening(): Batch {
+	if (open === null) {
+		open = createBatch();
+		request();
+	}
+	return open;
+}
+
+export function receiving(): Batch {
+	return receiver() ?? opening();
+}
+
+export function current(): Batch {
+	return receiving();
+}
+
+export function holds(batch: Batch): boolean {
+	if (batch.fork) return true;
+	if (batch.work === 0) return false;
+	const owners = batch.owners;
+	if (owners === null || (batch.skipped === null && offscreen.size === 0)) return true;
+	let free = batch.work;
+	for (const [effect, count] of owners) if (excluded(effect, batch)) free -= count;
+	return free > 0;
+}
+
+export function excluded(effect: Effect, batch: Batch): boolean {
+	const skipped = batch.skipped;
+	const shown = batch.shown;
+	for (let at: Effect | null = effect; at !== null; at = at.parent) {
+		if (skipped !== null && skipped.has(at)) return true;
+		if (at.inert && (shown === null || !shown.has(at))) return true;
+	}
+	return false;
+}
+
+export function live(batch: Batch | null): Batch | null {
+	if (batch === null) return null;
+	const found = alias(batch);
+	return found.done ? null : found;
+}
+
+export function within<T>(batch: Batch, fn: () => T): T {
+	const previous = active;
+	active = live(batch);
+	try {
+		return fn();
+	} finally {
+		active = previous;
+	}
+}
+
+export function members(batch: Batch): Set<Effect> {
+	return (batch.members ??= new Set(batch.queued));
+}
+
+export function enqueue(batch: Batch, effect: Effect): void {
+	const known = batch.members;
+	if (known !== null) {
+		if (known.has(effect)) return;
+		known.add(effect);
+	}
+	const queued = batch.queued;
+	queued[queued.length] = effect;
+}
+
+export function schedule(effect: Effect): void {
+	const batch = receiving();
+	enqueue(batch, effect);
+	if (batch !== processing && batch.started) request();
+}
+
+export function collect(effect: Effect): void {
+	if (effect.boundary !== null && showing(effect.boundary)) {
+		parked(effect.boundary).push(effect);
+		return;
+	}
+	const batch = receiver();
+	if (batch !== null) batch.effects.push(effect);
+	else schedule(effect);
+}
+
+export function atCommit(change: Change): void {
+	if (joins(processing)) processing.commits.push(change);
+	else {
+		change.prepare?.();
+		change.apply();
+	}
+}
+
+export function atDiscard(fn: () => void): void {
+	if (joins(processing)) (processing.discards ??= []).push(fn);
+}
+
+export function atMerge(fn: Transfer): void {
+	if (joins(processing)) (processing.merges ??= []).push(fn);
+}
+
+export function onMerge(batch: Batch, fn: Transfer): void {
+	const found = alias(batch);
+	if (!found.done) (found.merges ??= []).push(fn);
+}
+
+export function onCommit(batch: Batch, change: Change): void {
+	const found = alias(batch);
+	if (found.done) return;
+	found.commits.push(change);
+	if (found.started && found !== processing && !holds(found)) request();
+}
+
+export function skip(effect: Effect, batch: Batch | null = processing): void {
+	if (batch !== null) (alias(batch).skipped ??= new Set()).add(effect);
+}
+
+export function unskip(effect: Effect): void {
+	const batch = processing;
+	if (batch === null) return;
+	const skipped = batch.skipped !== null && batch.skipped.delete(effect);
+	(batch.shown ??= new Set()).add(effect);
+	const foreign = effect.batch !== 0 && effect.batch !== batch.order;
+	if (skipped || foreign || overlooked.has(effect)) requeue(batch, effect);
+}
+
+export function processed(): Batch | null {
+	return processing;
+}
+
+export function force(batch: Batch, effect: Effect): void {
+	if (effect.destroyed) return;
+	(batch.forced ??= new Set()).add(effect);
+	enqueue(batch, effect);
+}
+
+function gather(effect: Effect, out: Effect[], marked: boolean, adopter = 0): void {
+	if (marked) effect.pending = false;
+	for (let child = effect.first; child !== null; child = child.next) {
+		if (child.destroyed) continue;
+		const foreign = adopter !== 0 && child.batch !== 0 && child.batch !== adopter;
+		if ((child.status !== CLEAN || foreign) && child.kind !== BRANCH && child.kind !== ROOT)
+			out.push(child);
+		if (!marked || child.pending) gather(child, out, marked, adopter);
+	}
+}
+
+export function overlook(branch: Effect, from: Batch): void {
+	const found: Effect[] = [];
+	gather(branch, found, true);
+	overlooked.add(branch);
+	if (found.length === 0 || from.fork) return;
+	const pass = (other: Batch | null): void => {
+		if (other === null || other === from || other.done) return;
+		if (other.shown === null || !other.shown.has(branch)) return;
+		for (const effect of found) force(other, effect);
+		request();
+	};
+	for (const other of pending) pass(other);
+	pass(open);
+}
+
+export function handOver(effect: Effect, holder: Batch): void {
+	const found: Effect[] = [];
+	if (effect.status !== CLEAN && effect.kind !== BRANCH && effect.kind !== ROOT) found.push(effect);
+	gather(effect, found, true);
+	if (found.length === 0) return;
+	if (!pending.includes(holder)) pending.push(holder);
+	for (const each of found) force(holder, each);
+	request();
+}
+
+export function requeue(batch: Batch, branch: Effect): void {
+	overlooked.delete(branch);
+	const found: Effect[] = [];
+	gather(branch, found, false, batch.order);
+	for (const effect of found) force(batch, effect);
+}
+
+function park(batch: Batch): void {
+	const index = pending.indexOf(batch);
+	if (index !== -1) pending.splice(index, 1);
+	batch.queued.length = 0;
+	batch.commits.length = 0;
+	batch.effects.length = 0;
+	batch.members = batch.forced = batch.skipped = batch.shown = batch.waits = null;
+	batch.content = batch.deferred = batch.discards = null;
+	batch.runs = null;
+	batch.merges = null;
+	for (const other of pending) other.waits?.delete(batch);
+	open?.waits?.delete(batch);
+	detach(batch);
+}
+
+export function orphaned(root: Effect): void {
+	if (pending.length === 0) return;
+	for (const batch of [...pending]) {
+		const roots = batch.roots;
+		if (!batch.fork || roots === null || !roots.delete(root)) continue;
+		if (roots.size === 0) park(batch);
+	}
+}
+
+export function untouched(batch: Batch): void {
+	if (batch.fork && batch.roots === null && !batch.done) park(batch);
+}
+
+export function rerunAfter(reader: Batch, writer: Batch, effects: Iterable<Effect>): void {
+	if (writer.done) return;
+	if (writer === reader) {
+		for (const effect of effects) force(reader, effect);
+		return;
+	}
+	const waits = (reader.waits ??= new Map());
+	let found = waits.get(writer);
+	if (found === undefined) waits.set(writer, (found = new Set()));
+	for (const effect of effects) found.add(effect);
+}
+
+export function revisit(effect: Effect, hidden: Set<Batch> | null): void {
+	const reader = active ?? processing;
+	for (const found of hidden ?? []) {
+		const writer = alias(found);
+		if (writer.done) continue;
+		if (members(writer).has(effect)) (writer.forced ??= new Set()).add(effect);
+		if (reader !== null && reader !== writer) rerunAfter(reader, writer, [effect]);
+	}
+	for (const other of pending) {
+		if (other === reader || other.done || other.fork || other.queued.length === 0) continue;
+		if (members(other).has(effect)) (other.forced ??= new Set()).add(effect);
+	}
+}
+
+export function tick(): Promise<void> {
+	return new Promise((done) => {
+		if (typeof requestAnimationFrame === 'function') requestAnimationFrame(() => done());
+		setTimeout(done, 0);
+	});
+}

package/src/runtime/reactivity/carried.ts

@@ -0,0 +1,64 @@
+import { failure } from '../../shared/diagnostics.ts';
+import type { Effect } from './graph.ts';
+import { owner } from './tracking.ts';
+
+export interface AsyncStore {
+	run<R>(value: unknown, fn: () => R): R;
+	getStore(): unknown;
+}
+
+type Frame = readonly unknown[];
+
+const empty: Frame = [];
+export let port: AsyncStore | null = null;
+let slots = 1;
+
+export function carryAcrossAwait(store: AsyncStore): void {
+	if (port === store) return;
+	if (port !== null) {
+		throw failure(
+			'async_store_conflict',
+			'A different async store already carries values across `await` in this realm'
+		);
+	}
+	port = store;
+}
+
+function frame(store: AsyncStore): Frame {
+	return (store.getStore() as Frame | undefined) ?? empty;
+}
+
+function within<R>(store: AsyncStore, slot: number, value: unknown, fn: () => R): R {
+	const next = frame(store).slice();
+	next[slot] = value;
+	return store.run(next, fn);
+}
+
+export function carry<R>(effect: Effect, fn: () => R): R {
+	return port === null ? fn() : within(port, 0, effect, fn);
+}
+
+export function ambient(): Effect | null {
+	if (owner !== null || port === null) return owner;
+	return (frame(port)[0] as Effect | undefined) ?? null;
+}
+
+export class AsyncVariable<T> {
+	readonly #slot = slots++;
+	#value: T | undefined;
+
+	run<R>(value: T, fn: () => R): R {
+		if (port !== null) return within(port, this.#slot, value, fn);
+		const previous = this.#value;
+		this.#value = value;
+		try {
+			return fn();
+		} finally {
+			this.#value = previous;
+		}
+	}
+
+	get(): T | undefined {
+		return port === null ? this.#value : (frame(port)[this.#slot] as T | undefined);
+	}
+}