vigla 0.0.0 → 0.1.0

package/src/runtime/reactivity/provenance.ts

@@ -0,0 +1,189 @@
+import { DEV } from 'esm-env';
+import type { Batch } from './batch.ts';
+import { stamp, type Reaction, type Source } from './graph.ts';
+import { beforeOf } from './history.ts';
+import type { View } from './tracking.ts';
+
+export interface Tracing {
+	readonly reaction: Reaction | null;
+	traced(source: Source, reaction: Reaction | null): void;
+}
+
+export interface Update {
+	readonly value: unknown;
+	readonly version: number;
+	readonly stack: Error | null;
+}
+
+interface Updates {
+	readonly current: WeakMap<Source, Update>;
+	readonly before: WeakMap<Source, Update | null>;
+}
+
+const labels = new WeakMap<Source, string>();
+const relabels = new WeakMap<object, (label: string) => void>();
+const updates = new WeakMap<Source, Update>();
+const batches = new WeakMap<Batch, Updates>();
+const runs = new WeakMap<Reaction, number>();
+
+export let tracing: Tracing | null = null;
+let stacks = false;
+let repeats = new WeakMap<Source, number>();
+let culprits: Map<string, Error> | null = null;
+
+export function setTracing(next: Tracing | null): Tracing | null {
+	const previous = tracing;
+	tracing = next;
+	return previous;
+}
+
+export function untrace<T>(fn: () => T): T {
+	const previous = setTracing(null);
+	try {
+		return fn();
+	} finally {
+		tracing = previous;
+	}
+}
+
+export function loopWrite(source: Source): void {
+	const count = (repeats.get(source) ?? 0) + 1;
+	repeats.set(source, count);
+	if (count <= 5) return;
+	const error = new Error('updated at');
+	const stack = error.stack ?? '';
+	if (!(culprits ??= new Map()).has(stack)) culprits.set(stack, error);
+}
+
+export function resetLoop(): void {
+	repeats = new WeakMap();
+	culprits = null;
+}
+
+export function reportLoop(): void {
+	for (const error of culprits?.values() ?? []) console.error(error);
+	resetLoop();
+}
+
+export function traceStacks(): void {
+	if (DEV) stacks = true;
+}
+
+export function tag<T extends Source>(source: T, label: string): T {
+	if (DEV) {
+		labels.set(source, label);
+		tagProxy(source.v, label);
+	}
+	return source;
+}
+
+export function labelOf(source: Source): string | undefined {
+	return labels.get(source);
+}
+
+export function tagProxy<T>(value: T, label: string): T {
+	if (DEV && typeof value === 'object' && value !== null) relabels.get(value)?.(label);
+	return value;
+}
+
+export function labelled(proxy: object, relabel: (label: string) => void): void {
+	relabels.set(proxy, relabel);
+}
+
+export function relabelled(value: object): boolean {
+	return relabels.has(value);
+}
+
+export function labelFor(path: string, prop: string | symbol): string {
+	if (typeof prop === 'symbol') return `${path}[Symbol(${prop.description ?? ''})]`;
+	if (/^[$_\p{ID_Start}][$‌‍\p{ID_Continue}]*$/u.test(prop)) return `${path}.${prop}`;
+	return /^\d+$/.test(prop) ? `${path}[${prop}]` : `${path}['${prop}']`;
+}
+
+function history(batch: Batch): Updates {
+	let found = batches.get(batch);
+	if (found === undefined) {
+		found = { current: new WeakMap(), before: new WeakMap() };
+		batches.set(batch, found);
+	}
+	return found;
+}
+
+export function updated(
+	source: Source,
+	value: unknown = source.v,
+	batch: Batch | null = null
+): void {
+	const label = labels.get(source);
+	if (label !== undefined) tagProxy(value, label);
+	if (!stacks) return;
+	const entry: Update = {
+		value,
+		version: batch?.fork ? stamp() : source.wv,
+		stack: new Error('updated at')
+	};
+	if (batch !== null) {
+		const found = history(batch);
+		if (!found.before.has(source)) found.before.set(source, updates.get(source) ?? null);
+		found.current.set(source, entry);
+	}
+	if (batch === null || !batch.fork) updates.set(source, entry);
+}
+
+export function computed(source: Source, value: unknown, batch: Batch): void {
+	if (!stacks) return;
+	const found = history(batch);
+	const previous = found.current.get(source) ?? updates.get(source);
+	if (Object.is(previous === undefined ? source.v : previous.value, value)) return;
+	found.current.set(source, { value, version: stamp(), stack: null });
+}
+
+export function applied(source: Source, batch: Batch): void {
+	if (!stacks) return;
+	const found = history(batch);
+	found.before.set(source, updates.get(source) ?? null);
+	const entry: Update = {
+		value: source.v,
+		version: source.wv,
+		stack: found.current.get(source)?.stack ?? null
+	};
+	found.current.set(source, entry);
+	updates.set(source, entry);
+}
+
+export function merged(from: Batch, into: Batch): void {
+	const source = batches.get(from);
+	if (source === undefined) return;
+	const target = history(into);
+	const older = from.order < into.order;
+	for (const value of beforeOf(from).keys()) {
+		if (older || !target.before.has(value))
+			target.before.set(value, source.before.get(value) ?? null);
+		const current = source.current.get(value);
+		if (current !== undefined && (!older || !target.current.has(value)))
+			target.current.set(value, current);
+	}
+}
+
+export function forgotten(batch: Batch): void {
+	batches.delete(batch);
+}
+
+export function tracedRun(reaction: Reaction, version: number): void {
+	if (stacks) runs.set(reaction, version);
+}
+
+export function ranAt(reaction: Reaction): number | undefined {
+	return runs.get(reaction);
+}
+
+export function updateOf(source: Source, given: View | null): Update | null {
+	if (given !== null) {
+		const hidden = given.hidden.get(source);
+		if (hidden !== undefined && !hidden.fork)
+			return batches.get(hidden)?.before.get(source) ?? null;
+		const own = batches.get(given.batch)?.current.get(source);
+		if (own !== undefined) return own;
+	}
+	return updates.get(source) ?? null;
+}

package/src/runtime/reactivity/proxy.ts

@@ -0,0 +1,212 @@
+import { DEV } from 'esm-env';
+import { write } from './scheduler.ts';
+import { sequence } from './history.ts';
+import { holdEager } from './eager.ts';
+import type { Source } from './graph.ts';
+import { set, source as plain, state, type Cell } from './sources.ts';
+import { get } from './reads.ts';
+import { guard, local, untrack } from './tracking.ts';
+import { labelFor, labelled, tag } from './provenance.ts';
+import { descriptorsFixed } from './errors.ts';
+
+const RAW = Symbol('raw');
+
+const mutating = new Set([
+	'copyWithin',
+	'fill',
+	'pop',
+	'push',
+	'reverse',
+	'shift',
+	'sort',
+	'splice',
+	'unshift'
+]);
+
+export const ABSENT = Symbol('absent');
+
+type Indexed = Record<PropertyKey, unknown>;
+
+function proxiable(value: unknown): value is Indexed {
+	if (typeof value !== 'object' || value === null || RAW in value) return false;
+	const prototype = Object.getPrototypeOf(value) as unknown;
+	return prototype === Object.prototype || prototype === Array.prototype || prototype === null;
+}
+
+function index(prop: string | symbol): number {
+	return typeof prop === 'string' && /^(0|[1-9]\d*)$/.test(prop) ? Number(prop) : -1;
+}
+
+export function proxy<T>(value: T): T {
+	return wrap(value, true);
+}
+
+export function deep<T>(value: T): Cell<T> {
+	const held = state(proxy(value));
+	return {
+		get current() {
+			return get(held);
+		},
+		set current(next) {
+			set(held, proxy(next));
+		}
+	};
+}
+
+export function original<T>(value: T): T {
+	if (typeof value !== 'object' || value === null) return value;
+	return ((value as Indexed)[RAW] as T | undefined) ?? value;
+}
+
+function wrap<T>(value: T, aware: boolean): T {
+	if (!proxiable(value)) return value;
+	const target = value;
+	const array = Array.isArray(target);
+	const sources = new Map<string | symbol, Source<unknown>>();
+	const keys = aware ? state(0) : plain(0);
+	if (array) {
+		const length = (target as unknown as unknown[]).length;
+		sources.set('length', aware ? state(length) : plain(length));
+	}
+
+	let path = '';
+	let relabelling = false;
+	const make = (initial: unknown): Source<unknown> =>
+		local(keys) ? state(initial) : plain(initial);
+	const nested = <V>(child: V): V => wrap(child, local(keys));
+
+	const source = (prop: string | symbol): Source<unknown> => {
+		let found = sources.get(prop);
+		if (found === undefined) {
+			found = make(Object.hasOwn(target, prop) ? nested(target[prop]) : ABSENT);
+			sources.set(prop, found);
+			if (DEV) tag(found, labelFor(path, prop));
+		}
+		return found;
+	};
+
+	const tracked = (prop: string | symbol): boolean => {
+		if (typeof prop === 'symbol') return false;
+		if (sources.has(prop) || !(prop in target)) return true;
+		const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+		return descriptor !== undefined && 'value' in descriptor && descriptor.writable === true;
+	};
+
+	const assign = (prop: string | symbol, next: unknown): void => {
+		const existing = sources.get(prop);
+		const added = existing === undefined ? !Object.hasOwn(target, prop) : existing.v === ABSENT;
+		const found = source(prop);
+		guard(found);
+		const value = nested(next);
+		const origin = sequence();
+		write(found, value, origin);
+		if (array) {
+			const position = index(prop);
+			const length = sources.get('length') as Source<unknown>;
+			if (position >= (length.v as number)) write(length, position + 1, origin);
+		}
+		if (added) write(keys, (keys.v as number) + 1, origin);
+	};
+
+	const wrapped = new Proxy(target, {
+		get(object, prop, receiver) {
+			if (prop === RAW) return object;
+			if (!tracked(prop)) {
+				const value = Reflect.get(object, prop, receiver);
+				if (!DEV || !array || typeof prop !== 'string' || !mutating.has(prop)) return value;
+				const method = value as (...args: unknown[]) => unknown;
+				return function (this: unknown, ...args: unknown[]): unknown {
+					return holdEager(() => method.apply(this, args));
+				};
+			}
+			const found = get(source(prop));
+			if (found !== ABSENT) return found;
+			return Object.hasOwn(object, prop) ? undefined : Reflect.get(object, prop, receiver);
+		},
+		has(object, prop) {
+			if (prop === RAW) return true;
+			if (!tracked(prop)) return Reflect.has(object, prop);
+			const found = get(source(prop));
+			return found === ABSENT ? Reflect.has(object, prop) && !Object.hasOwn(object, prop) : true;
+		},
+		set(object, prop, next, receiver) {
+			if (!tracked(prop)) return Reflect.set(object, prop, next, receiver);
+			if (array && prop === 'length') {
+				const length = sources.get('length') as Source<unknown>;
+				guard(length);
+				const origin = sequence();
+				for (let position = next as number; position < (length.v as number); position++) {
+					const key = String(position);
+					const item = sources.get(key);
+					if (item === undefined) {
+						const missing = make(ABSENT);
+						sources.set(key, missing);
+						if (DEV) tag(missing, labelFor(path, key));
+					} else write(item, ABSENT, origin);
+				}
+				write(length, next, origin);
+				write(keys, (keys.v as number) + 1, origin);
+				return true;
+			}
+			assign(prop, next);
+			return true;
+		},
+		deleteProperty(object, prop) {
+			if (!tracked(prop)) return Reflect.deleteProperty(object, prop);
+			const found = source(prop);
+			if (found.v !== ABSENT) {
+				guard(found);
+				const origin = sequence();
+				write(found, ABSENT, origin);
+				write(keys, (keys.v as number) + 1, origin);
+			}
+			return true;
+		},
+		ownKeys(object) {
+			get(keys);
+			return untrack(() => {
+				const own = Reflect.ownKeys(object).filter((key) => {
+					const found = sources.get(key);
+					return found === undefined || get(found) !== ABSENT;
+				});
+				for (const [key, found] of sources) {
+					if (get(found) !== ABSENT && !own.includes(key)) own.push(key);
+				}
+				return own;
+			});
+		},
+		getOwnPropertyDescriptor(object, prop) {
+			const descriptor = Reflect.getOwnPropertyDescriptor(object, prop);
+			if (!tracked(prop)) return descriptor;
+			const found = get(source(prop));
+			if (found === ABSENT) return undefined;
+			if (descriptor !== undefined) return { ...descriptor, value: found };
+			return { value: found, writable: true, enumerable: true, configurable: true };
+		},
+		defineProperty(object, prop, descriptor) {
+			if (!tracked(prop)) return Reflect.defineProperty(object, prop, descriptor);
+			if (
+				!('value' in descriptor) ||
+				descriptor.configurable === false ||
+				descriptor.enumerable === false ||
+				descriptor.writable === false
+			)
+				descriptorsFixed();
+			assign(prop, descriptor.value);
+			return true;
+		}
+	});
+	if (DEV)
+		labelled(wrapped, (label) => {
+			if (relabelling) return;
+			relabelling = true;
+			try {
+				path = label;
+				tag(keys, `${path} version`);
+				for (const [prop, found] of sources) tag(found, labelFor(path, prop));
+			} finally {
+				relabelling = false;
+			}
+		});
+	return wrapped;
+}

package/src/runtime/reactivity/public.ts

@@ -0,0 +1,51 @@
+import {
+	expose,
+	type External,
+	type Subscribable,
+	type WritableExternal,
+	type WritableSource
+} from '../../shared/external.ts';
+import { asyncDerived } from './async.ts';
+import { destroy, effect as user, effectRoot, pre } from './effects.ts';
+import { external as connect } from './external.ts';
+import { get } from './reads.ts';
+
+type Body = () => void | (() => void);
+
+export interface Effects {
+	(fn: Body): () => void;
+	pre(fn: Body): () => void;
+	root(fn: Body): () => void;
+}
+
+export interface Resource<T> {
+	readonly current: T;
+}
+
+function watch(fn: Body): () => void {
+	const created = user(fn);
+	return () => destroy(created);
+}
+
+export const effect: Effects = Object.assign(watch, {
+	pre(fn: Body): () => void {
+		const created = pre(fn);
+		return () => destroy(created);
+	},
+	root: effectRoot
+});
+
+export async function resource<T>(fn: () => T | PromiseLike<T>): Promise<Resource<T>> {
+	const value = await asyncDerived(fn);
+	return {
+		get current() {
+			return get(value);
+		}
+	};
+}
+
+export function external<T>(read: () => WritableSource<T> | null | undefined): WritableExternal<T>;
+export function external<T>(read: () => Subscribable<T> | null | undefined): External<T>;
+export function external<T>(read: () => Subscribable<T> | null | undefined): WritableExternal<T> {
+	return expose(connect(read));
+}