vigla 0.0.0 → 0.1.0

package/src/runtime/classes/date.ts

@@ -0,0 +1,65 @@
+import type { Derived, Effect } from '../reactivity/graph.ts';
+import { derived, set, state } from '../reactivity/sources.ts';
+import { get } from '../reactivity/reads.ts';
+import { owner, setOwner } from '../reactivity/tracking.ts';
+
+type Method = (this: Date, ...args: unknown[]) => unknown;
+
+const native = Date.prototype as unknown as Record<string, Method>;
+
+export class ReactiveDate extends Date {
+	static #installed = false;
+
+	readonly #time = state(super.getTime());
+	readonly #reads = new Map<string, Derived>();
+	readonly #owner: Effect | null = owner;
+
+	constructor(...args: unknown[]) {
+		super(...(args as []));
+		if (!ReactiveDate.#installed) ReactiveDate.#install();
+	}
+
+	static #install(): void {
+		ReactiveDate.#installed = true;
+		const prototype = ReactiveDate.prototype as unknown as Record<
+			string,
+			(this: ReactiveDate, ...args: unknown[]) => unknown
+		>;
+		for (const name of Object.getOwnPropertyNames(Date.prototype)) {
+			const method = native[name];
+			if (name === 'constructor' || typeof method !== 'function') continue;
+			if (name.startsWith('get') || name.startsWith('to') || name === 'valueOf') {
+				prototype[name] = function (this: ReactiveDate, ...args: unknown[]) {
+					return this.#read(name, method, args);
+				};
+			} else if (name.startsWith('set')) {
+				prototype[name] = function (this: ReactiveDate, ...args: unknown[]) {
+					const result = method.apply(this, args);
+					set(this.#time, native.getTime!.call(this) as number);
+					return result;
+				};
+			}
+		}
+	}
+
+	#read(name: string, method: Method, args: unknown[]): unknown {
+		if (args.length > 0) {
+			get(this.#time);
+			return method.apply(this, args);
+		}
+		let read = this.#reads.get(name);
+		if (read === undefined) {
+			const previous = setOwner(this.#owner);
+			try {
+				read = derived(() => {
+					get(this.#time);
+					return method.call(this);
+				});
+			} finally {
+				setOwner(previous);
+			}
+			this.#reads.set(name, read);
+		}
+		return get(read);
+	}
+}

package/src/runtime/classes/frames.ts

@@ -0,0 +1,27 @@
+export interface Task {
+	readonly promise: Promise<void>;
+	abort(): void;
+}
+
+export function loop(step: (now: number) => boolean): Task {
+	let handle = 0;
+	let aborted = false;
+	let finish!: () => void;
+	const promise = new Promise<void>((done) => (finish = done));
+	const frame = (now: number): void => {
+		if (aborted) return;
+		if (step(now)) request();
+		else finish();
+	};
+	const request = (): void => {
+		if (typeof requestAnimationFrame === 'function') handle = requestAnimationFrame(frame);
+	};
+	request();
+	return {
+		promise,
+		abort() {
+			aborted = true;
+			if (typeof cancelAnimationFrame === 'function') cancelAnimationFrame(handle);
+		}
+	};
+}

package/src/runtime/classes/local.ts

@@ -0,0 +1,7 @@
+import type { Source } from '../reactivity/graph.ts';
+import { source, state } from '../reactivity/sources.ts';
+import { local } from '../reactivity/tracking.ts';
+
+export function keyed<T>(sibling: Source, value: T): Source<T> {
+	return local(sibling) ? state(value) : source(value);
+}

package/src/runtime/classes/map.ts

@@ -0,0 +1,135 @@
+import type { Source } from '../reactivity/graph.ts';
+import { set, state } from '../reactivity/sources.ts';
+import { get } from '../reactivity/reads.ts';
+import { bump } from './subscriber.ts';
+import { keyed } from './local.ts';
+
+export class ReactiveMap<K, V> extends Map<K, V> {
+	readonly #keys = new Map<K, Source<number>>();
+	readonly #version = state(0);
+	readonly #size = state(0);
+
+	constructor(entries?: Iterable<readonly [K, V]> | null) {
+		super();
+		if (entries !== null && entries !== undefined) {
+			for (const [key, value] of entries) super.set(key, value);
+			this.#size.v = super.size;
+		}
+	}
+
+	#key(key: K): Source<number> | undefined {
+		let source = this.#keys.get(key);
+		if (source === undefined && super.has(key)) {
+			source = keyed(this.#version, 0);
+			this.#keys.set(key, source);
+		}
+		return source;
+	}
+
+	override has(key: K): boolean {
+		const source = this.#key(key);
+		if (source === undefined) {
+			get(this.#version);
+			return false;
+		}
+		get(source);
+		return true;
+	}
+
+	override get(key: K): V | undefined {
+		const source = this.#key(key);
+		if (source === undefined) {
+			get(this.#version);
+			return undefined;
+		}
+		get(source);
+		return super.get(key);
+	}
+
+	getOrInsert(key: K, value: V): V {
+		if (!super.has(key)) this.set(key, value);
+		return this.get(key) as V;
+	}
+
+	getOrInsertComputed(key: K, compute: (key: K) => V): V {
+		if (!super.has(key)) this.set(key, compute(key));
+		return this.get(key) as V;
+	}
+
+	override set(key: K, value: V): this {
+		const source = this.#keys.get(key);
+		const previous = super.get(key);
+		super.set(key, value);
+		if (source === undefined) {
+			this.#keys.set(key, keyed(this.#version, 0));
+			set(this.#size, super.size);
+			bump(this.#version);
+		} else if (previous !== value) {
+			bump(source);
+		}
+		return this;
+	}
+
+	override delete(key: K): boolean {
+		const source = this.#keys.get(key);
+		const deleted = super.delete(key);
+		if (source !== undefined) {
+			this.#keys.delete(key);
+			set(source, -1);
+		}
+		if (deleted) {
+			set(this.#size, super.size);
+			bump(this.#version);
+		}
+		return deleted;
+	}
+
+	override clear(): void {
+		if (super.size === 0) return;
+		super.clear();
+		set(this.#size, 0);
+		for (const source of this.#keys.values()) set(source, -1);
+		this.#keys.clear();
+		bump(this.#version);
+	}
+
+	#all(): void {
+		get(this.#version);
+		const keys = this.#keys;
+		if (keys.size !== super.size) {
+			for (const key of super.keys()) {
+				if (!keys.has(key)) keys.set(key, keyed(this.#version, 0));
+			}
+		}
+		for (const source of keys.values()) get(source);
+	}
+
+	override forEach(callback: (value: V, key: K, map: Map<K, V>) => void, thisArg?: unknown): void {
+		this.#all();
+		super.forEach(callback, thisArg);
+	}
+
+	override keys(): MapIterator<K> {
+		get(this.#version);
+		return super.keys();
+	}
+
+	override values(): MapIterator<V> {
+		this.#all();
+		return super.values();
+	}
+
+	override entries(): MapIterator<[K, V]> {
+		this.#all();
+		return super.entries();
+	}
+
+	override [Symbol.iterator](): MapIterator<[K, V]> {
+		return this.entries();
+	}
+
+	override get size(): number {
+		get(this.#size);
+		return super.size;
+	}
+}

package/src/runtime/classes/media.ts

@@ -0,0 +1,25 @@
+import { Subscribed } from './subscriber.ts';
+
+const parenthesized = /\(.+\)/;
+
+const bare = new Set(['all', 'print', 'screen', 'and', 'or', 'not', 'only']);
+
+export function normalize(query: string): string {
+	if (parenthesized.test(query)) return query;
+	for (const word of query.split(/[\s,]+/)) if (bare.has(word.trim())) return query;
+	return `(${query})`;
+}
+
+export class MediaQuery extends Subscribed<boolean> {
+	constructor(query: string, fallback?: boolean) {
+		void fallback;
+		const list = window.matchMedia(normalize(query));
+		super(
+			() => list.matches,
+			(update) => {
+				list.addEventListener('change', update);
+				return () => list.removeEventListener('change', update);
+			}
+		);
+	}
+}

package/src/runtime/classes/motion.ts

@@ -0,0 +1,3 @@
+import { MediaQuery } from './media.ts';
+
+export const prefersReducedMotion = new MediaQuery('(prefers-reduced-motion: reduce)');

package/src/runtime/classes/search.ts

@@ -0,0 +1,136 @@
+import { state } from '../reactivity/sources.ts';
+import { get } from '../reactivity/reads.ts';
+import { bump } from './subscriber.ts';
+
+export interface Searched {
+	search: string;
+}
+
+let attach: (params: ReactiveURLSearchParams, url: Searched) => void;
+let refill: (params: ReactiveURLSearchParams, from: URLSearchParams) => void;
+
+export class ReactiveURLSearchParams extends URLSearchParams {
+	readonly #version = state(0);
+	#url: Searched | null = null;
+	#updating = false;
+
+	static {
+		attach = (params, url) => {
+			params.#url = url;
+		};
+		refill = (params, from) => params.#refill(from);
+	}
+
+	#write(): void {
+		const url = this.#url;
+		if (url === null || this.#updating) return;
+		this.#updating = true;
+		try {
+			const search = super.toString();
+			url.search = search === '' ? '' : `?${search}`;
+		} finally {
+			this.#updating = false;
+		}
+	}
+
+	#changed(): void {
+		this.#write();
+		bump(this.#version);
+	}
+
+	#refill(from: URLSearchParams): void {
+		if (this.#updating || from.toString() === super.toString()) return;
+		this.#updating = true;
+		try {
+			for (const key of [...super.keys()]) super.delete(key);
+			for (const [key, value] of from) super.append(key, value);
+		} finally {
+			this.#updating = false;
+		}
+		bump(this.#version);
+	}
+
+	override append(name: string, value: string): void {
+		super.append(name, value);
+		this.#changed();
+	}
+
+	override delete(name: string, value?: string): void {
+		const present = super.has(name, value);
+		super.delete(name, value);
+		if (present) this.#changed();
+	}
+
+	override set(name: string, value: string): void {
+		const before = super.getAll(name);
+		super.set(name, value);
+		const after = super.getAll(name);
+		if (before.length !== after.length || before.some((item, index) => item !== after[index]))
+			this.#changed();
+	}
+
+	override sort(): void {
+		super.sort();
+		this.#changed();
+	}
+
+	override get(name: string): string | null {
+		get(this.#version);
+		return super.get(name);
+	}
+
+	override getAll(name: string): string[] {
+		get(this.#version);
+		return super.getAll(name);
+	}
+
+	override has(name: string, value?: string): boolean {
+		get(this.#version);
+		return super.has(name, value);
+	}
+
+	override forEach(
+		callback: (value: string, key: string, parent: URLSearchParams) => void,
+		thisArg?: unknown
+	): void {
+		get(this.#version);
+		super.forEach(callback, thisArg);
+	}
+
+	override keys(): URLSearchParamsIterator<string> {
+		get(this.#version);
+		return super.keys();
+	}
+
+	override values(): URLSearchParamsIterator<string> {
+		get(this.#version);
+		return super.values();
+	}
+
+	override entries(): URLSearchParamsIterator<[string, string]> {
+		get(this.#version);
+		return super.entries();
+	}
+
+	override [Symbol.iterator](): URLSearchParamsIterator<[string, string]> {
+		return this.entries();
+	}
+
+	override toString(): string {
+		get(this.#version);
+		return super.toString();
+	}
+
+	override get size(): number {
+		get(this.#version);
+		return super.size;
+	}
+}
+
+export function bind(params: ReactiveURLSearchParams, url: Searched): void {
+	attach(params, url);
+}
+
+export function replace(params: ReactiveURLSearchParams, from: URLSearchParams): void {
+	refill(params, from);
+}

package/src/runtime/classes/server.ts

@@ -0,0 +1,17 @@
+import type { Start } from './subscriber.ts';
+
+export class MediaQuery {
+	readonly current: boolean;
+
+	constructor(query: string, fallback = false) {
+		void query;
+		this.current = fallback;
+	}
+}
+
+export const prefersReducedMotion = new MediaQuery('(prefers-reduced-motion: reduce)');
+
+export function createSubscriber(start: Start): () => void {
+	void start;
+	return () => {};
+}

package/src/runtime/classes/set.ts

@@ -0,0 +1,146 @@
+import type { Source } from '../reactivity/graph.ts';
+import { set, state } from '../reactivity/sources.ts';
+import { get } from '../reactivity/reads.ts';
+import { keyed } from './local.ts';
+import { bump } from './subscriber.ts';
+
+interface Like<T> {
+	readonly size: number;
+	has(value: T): boolean;
+	keys(): Iterator<T>;
+}
+
+interface Algebra {
+	union<T>(this: Set<T>, other: Like<unknown>): Set<unknown>;
+	intersection<T>(this: Set<T>, other: Like<unknown>): Set<unknown>;
+	difference<T>(this: Set<T>, other: Like<unknown>): Set<unknown>;
+	symmetricDifference<T>(this: Set<T>, other: Like<unknown>): Set<unknown>;
+	isSubsetOf<T>(this: Set<T>, other: Like<unknown>): boolean;
+	isSupersetOf<T>(this: Set<T>, other: Like<unknown>): boolean;
+	isDisjointFrom<T>(this: Set<T>, other: Like<unknown>): boolean;
+}
+
+const native = Set.prototype as unknown as Algebra;
+
+export class ReactiveSet<T> extends Set<T> {
+	readonly #values = new Map<T, Source<boolean>>();
+	readonly #version = state(0);
+	readonly #size = state(0);
+
+	constructor(values?: Iterable<T> | null) {
+		super();
+		if (values !== null && values !== undefined) {
+			for (const value of values) super.add(value);
+			this.#size.v = super.size;
+		}
+	}
+
+	override has(value: T): boolean {
+		const present = super.has(value);
+		let source = this.#values.get(value);
+		if (source === undefined) {
+			if (!present) {
+				get(this.#version);
+				return false;
+			}
+			source = keyed(this.#version, true);
+			this.#values.set(value, source);
+		}
+		get(source);
+		return present;
+	}
+
+	override add(value: T): this {
+		if (!super.has(value)) {
+			super.add(value);
+			set(this.#size, super.size);
+			bump(this.#version);
+		}
+		return this;
+	}
+
+	override delete(value: T): boolean {
+		const deleted = super.delete(value);
+		const source = this.#values.get(value);
+		if (source !== undefined) {
+			this.#values.delete(value);
+			set(source, false);
+		}
+		if (deleted) {
+			set(this.#size, super.size);
+			bump(this.#version);
+		}
+		return deleted;
+	}
+
+	override clear(): void {
+		if (super.size === 0) return;
+		super.clear();
+		for (const source of this.#values.values()) set(source, false);
+		this.#values.clear();
+		set(this.#size, 0);
+		bump(this.#version);
+	}
+
+	override forEach(callback: (value: T, key: T, set: Set<T>) => void, thisArg?: unknown): void {
+		get(this.#version);
+		super.forEach(callback, thisArg);
+	}
+
+	override keys(): SetIterator<T> {
+		return this.values();
+	}
+
+	override values(): SetIterator<T> {
+		get(this.#version);
+		return super.values();
+	}
+
+	override entries(): SetIterator<[T, T]> {
+		get(this.#version);
+		return super.entries();
+	}
+
+	override [Symbol.iterator](): SetIterator<T> {
+		return this.keys();
+	}
+
+	override get size(): number {
+		return get(this.#size);
+	}
+
+	union<U>(other: Like<U>): ReactiveSet<T | U> {
+		get(this.#version);
+		return new ReactiveSet(native.union.call(this, other) as Set<T | U>);
+	}
+
+	intersection<U>(other: Like<U>): ReactiveSet<T & U> {
+		get(this.#version);
+		return new ReactiveSet(native.intersection.call(this, other) as Set<T & U>);
+	}
+
+	difference<U>(other: Like<U>): ReactiveSet<T> {
+		get(this.#version);
+		return new ReactiveSet(native.difference.call(this, other) as Set<T>);
+	}
+
+	symmetricDifference<U>(other: Like<U>): ReactiveSet<T | U> {
+		get(this.#version);
+		return new ReactiveSet(native.symmetricDifference.call(this, other) as Set<T | U>);
+	}
+
+	isSubsetOf(other: Like<unknown>): boolean {
+		get(this.#version);
+		return native.isSubsetOf.call(this, other);
+	}
+
+	isSupersetOf(other: Like<unknown>): boolean {
+		get(this.#version);
+		return native.isSupersetOf.call(this, other);
+	}
+
+	isDisjointFrom(other: Like<unknown>): boolean {
+		get(this.#version);
+		return native.isDisjointFrom.call(this, other);
+	}
+}