@sigil-dev/runtime 0.7.5 → 0.7.7

package/package.json

@@ -2,7 +2,7 @@
   "name": "@sigil-dev/runtime",
   "module": "index.ts",
   "type": "module",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "description": "Runtime for the Sigil framework",
   "private": false,
   "devDependencies": {

package/reactivity/map.ts

@@ -0,0 +1,98 @@
+import { createSignal, type Signal } from "../index.ts";
+
+export class ReactiveMap<K, V> extends Map<K, V> {
+	#keyVersions: Map<K, Signal<number>> = new Map();
+	#structVersion: Signal<number>;
+	#structVal: number = 0;
+	#getKeyVersion(key: K): Signal<number> {
+		let sig = this.#keyVersions.get(key);
+		if (!sig) {
+			const inner = createSignal(0);
+			this.#keyVersions.set(key, inner);
+			sig = inner;
+		}
+		return sig;
+	}
+	#bumpKey(key: K) {
+		const sig = this.#keyVersions.get(key);
+		if (sig) {
+			const v = sig.peek() + 1;
+			(sig as Signal<number>).set(v);
+		}
+	}
+	#bumpStruct() {
+		this.#structVal++;
+		this.#structVersion.set(this.#structVal);
+	}
+
+	constructor(entries?: readonly (readonly [K, V])[] | null) {
+		super(entries);
+		this.#structVersion = createSignal(0);
+		if (entries) {
+			for (const [k] of entries) this.#getKeyVersion(k);
+		}
+	}
+
+	get(key: K): V | undefined {
+		this.#getKeyVersion(key)();
+		return super.get(key);
+	}
+
+	set(key: K, value: V): this {
+		const existed = super.has(key);
+		super.set(key, value);
+		this.#bumpKey(key);
+		if (!existed) this.#bumpStruct();
+		return this;
+	}
+
+	delete(key: K): boolean {
+		const result = super.delete(key);
+		if (result) {
+			this.#bumpKey(key);
+			this.#bumpStruct();
+		}
+		return result;
+	}
+
+	clear(): void {
+		if (this.size > 0) {
+			for (const key of this.keys()) this.#bumpKey(key);
+			super.clear();
+			this.#bumpStruct();
+		}
+	}
+
+	forEach(
+		callbackfn: (value: V, key: K, map: Map<K, V>) => void,
+		thisArg?: unknown,
+	): void {
+		this.#structVersion();
+		super.forEach(callbackfn, thisArg);
+	}
+
+	get size(): number {
+		this.#structVersion();
+		return super.size;
+	}
+
+	entries(): IterableIterator<[K, V]> {
+		this.#structVersion();
+		return super.entries();
+	}
+
+	keys(): IterableIterator<K> {
+		this.#structVersion();
+		return super.keys();
+	}
+
+	values(): IterableIterator<V> {
+		this.#structVersion();
+		return super.values();
+	}
+
+	[Symbol.iterator](): IterableIterator<[K, V]> {
+		this.#structVersion();
+		return super[Symbol.iterator]();
+	}
+}

package/reactivity/set.ts

@@ -0,0 +1,74 @@
+import { createSignal, type Signal } from "../index.ts";
+
+export class ReactiveSet<T> extends Set<T> {
+	#version: Signal<number>;
+	#versionVal: number = 0;
+
+	constructor(values?: readonly T[] | null) {
+		super(values);
+		this.#version = createSignal(0);
+	}
+
+	#bump() {
+		this.#versionVal++;
+		this.#version.set(this.#versionVal);
+	}
+
+	has(value: T): boolean {
+		this.#version();
+		return super.has(value);
+	}
+
+	add(value: T): this {
+		const sizeBefore = super.size;
+		super.add(value);
+		if (super.size !== sizeBefore) this.#bump();
+		return this;
+	}
+
+	delete(value: T): boolean {
+		const result = super.delete(value);
+		if (result) this.#bump();
+		return result;
+	}
+
+	clear(): void {
+		if (this.size > 0) {
+			super.clear();
+			this.#bump();
+		}
+	}
+
+	forEach(
+		callbackfn: (value: T, value2: T, set: Set<T>) => void,
+		thisArg?: unknown,
+	): void {
+		this.#version();
+		super.forEach(callbackfn, thisArg);
+	}
+
+	get size(): number {
+		this.#version();
+		return super.size;
+	}
+
+	entries(): IterableIterator<[T, T]> {
+		this.#version();
+		return super.entries();
+	}
+
+	keys(): IterableIterator<T> {
+		this.#version();
+		return super.keys();
+	}
+
+	values(): IterableIterator<T> {
+		this.#version();
+		return super.values();
+	}
+
+	[Symbol.iterator](): IterableIterator<T> {
+		this.#version();
+		return super[Symbol.iterator]();
+	}
+}