@reely/signals 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,109 @@
-# Temporary Holding Version
+# @reely/signals
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Signals, computed values and effects: a push-pull graph with owners that release what a piece of work subscribed. Typed, tree-shakeable, no DOM. [`@reely/dommy`](https://www.npmjs.com/package/@reely/dommy) binds them to the DOM and re-exports them.
+
+```sh
+npm i @reely/signals
+```
+
+## Signals
+
+```ts
+import { batch, computed, effect, signal, untracked } from '@reely/signals';
+
+const tickets = signal(1);
+const total = computed(() => tickets.value * 12.5); // euros
+
+effect(() => console.log(`Pay €${total.value}`)); // runs now, then after every change
+batch(() => {
+  tickets.value += 1; // effects run once, when the batch ends
+  tickets.value += 1;
+});
+untracked(() => tickets.value); // reads without subscribing; same as `tickets.peek()`
+
+// the style of Angular works as well: a signal and a computed are functions
+tickets(); // reads, as `tickets.value` does
+tickets.set(4); // writes, as `tickets.value = 4` does
+tickets.update((n) => n + 1); // writes from the value, read without subscribing
+total(); // a computed reads the same way
+```
+
+Pick the style you like; the two mix freely. A `ReactiveValue<T>` is anything read that way: a signal, a computed or a getter of them.
+
+Effects run synchronously, and a computed recomputes only when it is read after a change. A write of an equal value (`Object.is`, or the `equals` you pass) changes nothing. A signal holds any value, a function included: `set` and `.value =` store it; `update` calls only the function you pass it.
+
+```ts
+import { signal } from '@reely/signals';
+
+const garage = { cars: ['Volvo'] };
+const state = signal(garage, { equals: false }); // changed in place: every write notifies
+garage.cars.push('Saab');
+state.value = garage;
+
+const standings = signal({ leader: 'Ada', lap: 3 }, { equals: (previous, next) => previous.leader === next.leader });
+standings.value = { leader: 'Ada', lap: 4 }; // the same leader: nothing is notified, the value stays
+```
+
+`equals` decides whether the signal notifies. What derives from it compares its own result by `Object.is`: a `computed` that returns the same object notifies nothing, so derive the part that changes (`() => state.value.cars.length`).
+
+## Owners
+
+An owner holds what a piece of work must release: the effects created under it, `onCleanup` callbacks and nested owners. `withOwner(fn)` runs `fn` under a new owner and passes it `dispose`.
+
+```ts
+import { effect, onCleanup, signal, withOwner } from '@reely/signals';
+
+const lap = signal(1);
+
+const stopRace = withOwner((dispose) => {
+  effect(() => console.log(`lap ${lap.value}`));
+  const timer = setInterval(() => lap.update((n) => n + 1), 60_000);
+  onCleanup(() => clearInterval(timer));
+  return dispose;
+});
+
+stopRace(); // the effect unsubscribes and the timer stops
+```
+
+Each run of an effect has its own owner: `onCleanup` inside it runs before the next run and when the effect is disposed, and the effects it created go with it. `getOwner()` captures the running owner, for code that runs later to pass to `withOwner(fn, owner)`.
+
+```ts
+import { effect, onCleanup, signal } from '@reely/signals';
+
+const draft = signal('');
+const typing = signal(false); // shows "typing…" to the other side of a chat
+
+effect(() => {
+  if (draft.value === '') return;
+  typing.value = true;
+  const timer = setTimeout(() => (typing.value = false), 2000);
+  onCleanup(() => clearTimeout(timer)); // the next keystroke, or dispose, cancels it
+});
+```
+
+## Testing
+
+`@reely/signals/testing` counts what still listens to a signal, so a test can check that `dispose` released everything:
+
+```ts
+import { effect, signal, withOwner } from '@reely/signals';
+import { subscriberCount } from '@reely/signals/testing';
+
+const lap = signal(1);
+const stopRace = withOwner((dispose) => {
+  effect(() => console.log(`lap ${lap.value}`));
+  return dispose;
+});
+
+stopRace();
+console.assert(subscriberCount(lap) === 0);
+```
+
+## License
+
+MIT
+
+## Credits
+
+- The signal core implements the push-pull graph known from [Reactively](https://github.com/milomg/reactively), [@preact/signals-core](https://github.com/preactjs/signals) and [alien-signals](https://github.com/stackblitz/alien-signals), written from the concept.
+- The signal tests are adapted from [@preact/signals-core](https://github.com/preactjs/signals), Copyright (c) 2022-present Preact Team, MIT licence.

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+/** Groups writes: effects run once, when the outermost `batch` ends, even if `fn` throws. */
+export declare const batch: <T>(fn: () => T) => T;
+
+export declare interface Computed<T> extends Subscribable<T> {
+    (): T;
+    get value(): T;
+    /** Reads the value without subscribing the running effect or computed to it. */
+    peek(): T;
+}
+
+/**
+ * A value derived from signals, recomputed only after one of them changes. What `fn` throws is
+ * rethrown on every read until then.
+ */
+export declare const computed: <T>(fn: () => T) => Computed<T>;
+
+/**
+ * Runs `fn` now and after every change of what it reads; what a run registers is released before
+ * the next one. Returns `dispose`, also reachable as `this.dispose()` inside `fn`.
+ */
+export declare const effect: (fn: () => void) => (() => void);
+
+declare type Equality<T> = {
+    bivarianceHack(previous: T, next: T): boolean;
+}['bivarianceHack'];
+
+/** For code that runs later, such as a callback creating effects, to pass to `withOwner`. */
+export declare const getOwner: () => Nullable<Owner>;
+
+declare type Nil = null | undefined;
+
+declare type Nullable<T> = T | Nil;
+
+/** Registers a release in the running owner; outside any owner nothing holds it. */
+export declare const onCleanup: (cleanup: () => void) => void;
+
+/** What a piece of work must release when it ends: its effects, cleanups and nested owners. */
+export declare interface Owner {
+    readonly cleanups: Set<() => void>;
+}
+
+/** A value read reactively: a signal, a computed or any getter of them; an effect or computed that reads it follows it. */
+export declare type ReactiveValue<T> = () => T;
+
+export declare interface Signal<T> extends Subscribable<T> {
+    (): T;
+    get value(): T;
+    set value(value: T);
+    /** Writes `value`, as `.value =` does. */
+    set(value: T): void;
+    /** Writes what `fn` makes of the value, read without subscribing the running effect or computed to it. */
+    update(fn: (value: T) => T): void;
+    /** Reads the value without subscribing the running effect or computed to it. */
+    peek(): T;
+}
+
+/** A value that effects and computeds re-read when it is written; a function is held as a value too. */
+export declare const signal: <T>(init: T, options?: SignalOptions<T>) => Signal<T>;
+
+/** How a signal tells a write that changes nothing from one that notifies. */
+export declare interface SignalOptions<T> {
+    /**
+     * Whether a write leaves the value unchanged, so nothing is notified; `Object.is` by default.
+     * `false` (or `() => false`) notifies every write, for an object changed in place.
+     */
+    equals?: Equality<T> | false;
+}
+
+declare interface Subscribable<T> {
+    subscribe(cb: (value: T, prevValue?: T) => void): () => void;
+}
+
+/** Runs `fn` without subscribing the running effect or computed to what it reads. */
+export declare const untracked: <T>(fn: () => T) => T;
+
+/**
+ * Runs `fn` under a new owner nested in `parent` and passes it `dispose`. Every cleanup runs even
+ * when one throws; the first error is rethrown after all have run.
+ */
+export declare const withOwner: <T>(fn: (dispose: () => void) => T, parent?: Nullable<Owner>) => T;
+
+export { }

package/dist/index.js

@@ -0,0 +1,151 @@
+import { a as subscribe, c as write, i as signal$1, l as noop, n as computed$1, r as effect$1, s as untracked, t as batch } from "./signals-CHdm5V62.js";
+import { hasSome } from "@reely/basics";
+//#region ../utils/dist/lib/objects/setPrototype.js
+function setPrototype(proto, object) {
+	if (!Reflect.setPrototypeOf(object, proto)) throw new Error("Failed to set prototype of provided object.");
+	return object;
+}
+//#endregion
+//#region src/lib/owner.ts
+var currentOwner = null;
+/** For code that runs later, such as a callback creating effects, to pass to `withOwner`. */
+var getOwner = () => currentOwner;
+/** Registers a release in the running owner; outside any owner nothing holds it. */
+var onCleanup = (cleanup) => {
+	currentOwner?.cleanups.add(cleanup);
+};
+/**
+* Runs `fn` under a new owner nested in `parent` and passes it `dispose`. Every cleanup runs even
+* when one throws; the first error is rethrown after all have run.
+*/
+var withOwner = (fn, parent = currentOwner) => {
+	const owner = { cleanups: /* @__PURE__ */ new Set() };
+	const dispose = () => {
+		parent?.cleanups.delete(dispose);
+		const cleanups = [...owner.cleanups].reverse();
+		owner.cleanups.clear();
+		let failure = null;
+		for (const cleanup of cleanups) try {
+			cleanup();
+		} catch (error) {
+			failure ??= { error };
+		}
+		if (hasSome(failure)) throw failure.error;
+	};
+	parent?.cleanups.add(dispose);
+	const previous = currentOwner;
+	currentOwner = owner;
+	try {
+		return fn(dispose);
+	} catch (error) {
+		currentOwner = previous;
+		dispose();
+		throw error;
+	} finally {
+		currentOwner = previous;
+	}
+};
+//#endregion
+//#region src/lib/signal.ts
+/** A value that effects and computeds re-read when it is written; a function is held as a value too. */
+var signal = (init, options) => setPrototype(signalProto, signal$1(init, options));
+/**
+* A value derived from signals, recomputed only after one of them changes. What `fn` throws is
+* rethrown on every read until then.
+*/
+var computed = (fn) => setPrototype(computedProto, computed$1(fn));
+/**
+* Runs `fn` now and after every change of what it reads; what a run registers is released before
+* the next one. Returns `dispose`, also reachable as `this.dispose()` inside `fn`.
+*/
+var effect = (fn) => {
+	const parent = getOwner();
+	let disposeRun = noop;
+	let running = false;
+	let disposed = false;
+	let unsubscribe = noop;
+	let body = noop;
+	const releaseRun = () => {
+		const release = disposeRun;
+		disposeRun = noop;
+		untracked(() => batch(release));
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		parent?.cleanups.delete(dispose);
+		body = noop;
+		unsubscribe();
+		unsubscribe = noop;
+		if (!running) releaseRun();
+	};
+	body = fn.bind({ dispose });
+	const run = () => {
+		try {
+			releaseRun();
+		} catch (error) {
+			dispose();
+			throw error;
+		}
+		if (disposed) return;
+		running = true;
+		try {
+			withOwner((disposeOwner) => {
+				disposeRun = disposeOwner;
+				body();
+			}, null);
+		} finally {
+			running = false;
+			if (disposed) releaseRun();
+		}
+	};
+	parent?.cleanups.add(dispose);
+	try {
+		const release = effect$1(run);
+		if (disposed) release();
+		else unsubscribe = release;
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+	return dispose;
+};
+var computedProto = {
+	get value() {
+		return this();
+	},
+	peek() {
+		return untracked(this);
+	},
+	subscribe(cb) {
+		return subscribe(this, cb);
+	},
+	toString() {
+		return String(untracked(this));
+	},
+	valueOf() {
+		return untracked(this);
+	},
+	toJSON() {
+		return untracked(this);
+	}
+};
+var signalProto = {
+	__proto__: computedProto,
+	get value() {
+		return this();
+	},
+	set value(value) {
+		write(this, value);
+	},
+	set(value) {
+		write(this, value);
+	},
+	update(fn) {
+		write(this, fn(untracked(this)));
+	}
+};
+//#endregion
+export { batch, computed, effect, getOwner, onCleanup, signal, untracked, withOwner };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["reelx.signal","reelx.computed","reelx.batch","reelx.effect","reelx.untracked","reelx.subscribe"],"sources":["../../utils/dist/lib/objects/setPrototype.js","../src/lib/owner.ts","../src/lib/signal.ts"],"sourcesContent":["export function setPrototype(proto, object) {\n    if (!Reflect.setPrototypeOf(object, proto)) {\n        throw new Error('Failed to set prototype of provided object.');\n    }\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    return object;\n}\n","import { hasSome } from '@reely/basics';\nimport type { Nullable } from '@reely/utils';\n\n/** What a piece of work must release when it ends: its effects, cleanups and nested owners. */\nexport interface Owner {\n  readonly cleanups: Set<() => void>;\n}\n\nlet currentOwner: Nullable<Owner> = null;\n\n/** For code that runs later, such as a callback creating effects, to pass to `withOwner`. */\nexport const getOwner = (): Nullable<Owner> => currentOwner;\n\n/** Registers a release in the running owner; outside any owner nothing holds it. */\nexport const onCleanup = (cleanup: () => void): void => {\n  currentOwner?.cleanups.add(cleanup);\n};\n\n/**\n * Runs `fn` under a new owner nested in `parent` and passes it `dispose`. Every cleanup runs even\n * when one throws; the first error is rethrown after all have run.\n */\nexport const withOwner = <T>(fn: (dispose: () => void) => T, parent: Nullable<Owner> = currentOwner): T => {\n  const owner: Owner = { cleanups: new Set() };\n  const dispose = (): void => {\n    parent?.cleanups.delete(dispose);\n    // reverse order of creation, like a stack of resources\n    const cleanups = [...owner.cleanups].reverse();\n    owner.cleanups.clear();\n    let failure: Nullable<{ readonly error: unknown }> = null;\n    for (const cleanup of cleanups) {\n      try {\n        cleanup();\n      } catch (error) {\n        failure ??= { error };\n      }\n    }\n    if (hasSome(failure)) {\n      throw failure.error;\n    }\n  };\n  parent?.cleanups.add(dispose);\n\n  const previous = currentOwner;\n  currentOwner = owner;\n  try {\n    return fn(dispose);\n  } catch (error) {\n    // work that failed leaves nothing subscribed\n    currentOwner = previous;\n    dispose();\n    throw error;\n  } finally {\n    currentOwner = previous;\n  }\n};\n","import { noop, setPrototype } from '@reely/utils';\n\nimport { getOwner, withOwner } from './owner';\nimport * as reelx from './reelx.core';\n\nimport type { ReactiveValue, SignalOptions } from './reelx.core';\n\nexport { batch, untracked, type ReactiveValue, type SignalOptions } from './reelx.core';\n\ninterface Subscribable<T> {\n  subscribe(cb: (value: T, prevValue?: T) => void): () => void;\n}\n\nexport interface Signal<T> extends Subscribable<T> {\n  (): T;\n  get value(): T;\n  set value(value: T);\n  /** Writes `value`, as `.value =` does. */\n  set(value: T): void;\n  /** Writes what `fn` makes of the value, read without subscribing the running effect or computed to it. */\n  update(fn: (value: T) => T): void;\n  /** Reads the value without subscribing the running effect or computed to it. */\n  peek(): T;\n}\n\nexport interface Computed<T> extends Subscribable<T> {\n  (): T;\n  get value(): T;\n  /** Reads the value without subscribing the running effect or computed to it. */\n  peek(): T;\n}\n\n/** A value that effects and computeds re-read when it is written; a function is held as a value too. */\nexport const signal = <T>(init: T, options?: SignalOptions<T>): Signal<T> =>\n  setPrototype<Signal<T>>(signalProto, reelx.signal(init, options));\n\n/**\n * A value derived from signals, recomputed only after one of them changes. What `fn` throws is\n * rethrown on every read until then.\n */\nexport const computed = <T>(fn: () => T): Computed<T> => setPrototype<Computed<T>>(computedProto, reelx.computed(fn));\n\n/**\n * Runs `fn` now and after every change of what it reads; what a run registers is released before\n * the next one. Returns `dispose`, also reachable as `this.dispose()` inside `fn`.\n */\nexport const effect = (fn: () => void): (() => void) => {\n  const parent = getOwner();\n  let disposeRun: () => void = noop;\n  let running = false;\n  let disposed = false;\n  let unsubscribe: () => void = noop;\n  let body: () => void = noop;\n\n  // cleanups read and write signals like any code outside the effect: untracked, in one batch\n  const releaseRun = (): void => {\n    const release = disposeRun;\n    disposeRun = noop;\n    reelx.untracked(() => reelx.batch(release));\n  };\n\n  const dispose = (): void => {\n    if (disposed) {\n      return;\n    }\n    disposed = true;\n    parent?.cleanups.delete(dispose);\n    // a kept `dispose` must not keep the body or the effect's last dependencies alive\n    body = noop;\n    unsubscribe();\n    unsubscribe = noop;\n    // a run that disposes its own effect releases its cleanups once it has finished\n    if (!running) {\n      releaseRun();\n    }\n  };\n\n  // `this` in the body: a run can dispose its own effect, the first run included\n  body = fn.bind({ dispose });\n\n  const run = (): void => {\n    try {\n      releaseRun();\n    } catch (error) {\n      dispose();\n      throw error;\n    }\n    if (disposed) {\n      return;\n    }\n    running = true;\n    try {\n      withOwner((disposeOwner) => {\n        disposeRun = disposeOwner;\n        body();\n      }, null);\n    } finally {\n      running = false;\n      if (disposed) {\n        releaseRun();\n      }\n    }\n  };\n\n  parent?.cleanups.add(dispose);\n  try {\n    const release = reelx.effect(run);\n    // the first run may have disposed the effect before its subscription existed\n    if (disposed) {\n      release();\n    } else {\n      unsubscribe = release;\n    }\n  } catch (error) {\n    dispose();\n    throw error;\n  }\n  return dispose;\n};\n\nconst computedProto: ThisType<ReactiveValue<unknown>> = {\n  get value(): unknown {\n    return this();\n  },\n  peek(): unknown {\n    return reelx.untracked(this);\n  },\n  subscribe(cb: (value: unknown, prevValue?: unknown) => void): () => void {\n    return reelx.subscribe(this, cb);\n  },\n  toString(): string {\n    return String(reelx.untracked(this));\n  },\n  valueOf(): unknown {\n    return reelx.untracked(this);\n  },\n  toJSON(): unknown {\n    return reelx.untracked(this);\n  },\n};\n\n// `__proto__` in a literal, not a call, so importing the module runs no code\nconst signalProto: ThisType<ReactiveValue<unknown>> = {\n  __proto__: computedProto,\n  get value(): unknown {\n    return this();\n  },\n  set value(value: unknown) {\n    reelx.write(this, value);\n  },\n  set(value: unknown): void {\n    reelx.write(this, value);\n  },\n  update(fn: (value: unknown) => unknown): void {\n    reelx.write(this, fn(reelx.untracked(this)));\n  },\n};\n"],"mappings":"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"}

package/dist/signals-CHdm5V62.js

@@ -0,0 +1,294 @@
+import { hasSome } from "@reely/basics";
+//#region ../utils/dist/lib/objects/isInstanceOf.js
+function isInstanceOf(instanceType, instance) {
+	return instance instanceof instanceType;
+}
+//#endregion
+//#region ../utils/dist/lib/fp/noop.js
+function noop() {}
+//#endregion
+//#region src/lib/reelx.core.ts
+var MAX_FLUSH_WAVES = 100;
+var epoch = 0;
+var tracker = null;
+var running = null;
+var batchDepth = 0;
+var queue = [];
+var flushing = false;
+var setTracker = (observer) => {
+	const outer = tracker;
+	tracker = observer;
+	return outer;
+};
+var setRunning = (computation) => {
+	const outer = running;
+	running = computation;
+	return outer;
+};
+var Signal = class {
+	value;
+	options;
+	version = 0;
+	observers = /* @__PURE__ */ new Set();
+	refresh = noop;
+	constructor(value, options) {
+		this.value = value;
+		this.options = options;
+	}
+	read = () => {
+		tracker?.onRead(this);
+		return this.value;
+	};
+	observe(observer) {
+		this.observers.add(observer);
+	}
+	unobserve(observer) {
+		this.observers.delete(observer);
+	}
+	write(value) {
+		const { equals = Object.is } = this.options;
+		if (equals !== false && equals(this.value, value)) return;
+		this.value = value;
+		this.version++;
+		epoch++;
+		running?.onOwnWrite(this);
+		const idle = queue.length === 0;
+		for (const observer of this.observers) observer.mark(this);
+		if (idle && queue.length > 0 && batchDepth === 0 && !flushing) flushSync();
+	}
+};
+var Computation = class {
+	fn;
+	version = 0;
+	needsCheck = false;
+	sources = /* @__PURE__ */ new Map();
+	outcome = null;
+	runCount = 0;
+	checkedAt = -1;
+	markedAt = -1;
+	deafTo = null;
+	constructor(fn) {
+		this.fn = fn;
+	}
+	mark(written) {
+		if (this.markedAt === epoch) return;
+		this.markedAt = epoch;
+		if (this === running) {
+			this.deafTo ??= /* @__PURE__ */ new Set();
+			this.deafTo.add(written);
+		} else if (!this.deafTo?.has(written)) this.onMarked(written);
+	}
+	onOwnWrite(source) {
+		const link = this.sources.get(source);
+		if (hasSome(link)) link.version = source.version;
+	}
+	onRead(source) {
+		this.deafTo?.delete(source);
+		const link = this.sources.get(source);
+		if (hasSome(link)) {
+			link.version = source.version;
+			link.readIn = this.runCount;
+			return;
+		}
+		this.sources.set(source, {
+			version: source.version,
+			readIn: this.runCount
+		});
+		if (this.linked) source.observe(this);
+	}
+	refresh() {
+		const current = this.outcome;
+		if (hasSome(current) && !this.needsCheck && (this.linked || this.checkedAt === epoch)) return current;
+		this.needsCheck = false;
+		this.checkedAt = epoch;
+		if (hasSome(current) && !this.sourceChanged()) return current;
+		const { fn } = this;
+		this.runCount++;
+		this.deafTo = null;
+		const outer = setTracker(this);
+		const outerRunning = setRunning(this);
+		let next;
+		try {
+			next = {
+				threw: false,
+				value: fn()
+			};
+		} catch (error) {
+			next = {
+				threw: true,
+				value: error
+			};
+		}
+		setTracker(outer);
+		setRunning(outerRunning);
+		this.dropUnread();
+		if (!hasSome(current) || current.threw !== next.threw || !Object.is(current.value, next.value)) this.version++;
+		this.outcome = next;
+		return next;
+	}
+	detach() {
+		for (const source of this.sources.keys()) source.unobserve(this);
+	}
+	unlink(source) {
+		this.sources.delete(source);
+		source.unobserve(this);
+	}
+	sourceChanged() {
+		for (const [source, { version }] of this.sources) {
+			source.refresh();
+			if (source.version !== version) return true;
+		}
+		return false;
+	}
+	dropUnread() {
+		for (const [source, link] of this.sources) if (link.readIn !== this.runCount) this.unlink(source);
+	}
+};
+var Computed = class extends Computation {
+	observers = /* @__PURE__ */ new Set();
+	get linked() {
+		return this.observers.size > 0;
+	}
+	read = () => {
+		const outcome = this.refresh();
+		tracker?.onRead(this);
+		if (outcome.threw) throw outcome.value;
+		return outcome.value;
+	};
+	observe(observer) {
+		if (this.observers.size === 0) for (const source of this.sources.keys()) source.observe(this);
+		this.observers.add(observer);
+	}
+	unobserve(observer) {
+		if (this.observers.delete(observer) && this.observers.size === 0) this.detach();
+	}
+	onMarked(written) {
+		this.needsCheck = true;
+		for (const observer of this.observers) observer.mark(written);
+	}
+};
+var Effect = class extends Computation {
+	disposed = false;
+	get linked() {
+		return !this.disposed;
+	}
+	dispose = () => {
+		this.disposed = true;
+		this.detach();
+		this.sources.clear();
+	};
+	run() {
+		if (this.disposed) return;
+		const before = this.outcome;
+		const after = this.refresh();
+		if (after !== before && after.threw) throw after.value;
+	}
+	dequeue() {
+		this.needsCheck = false;
+	}
+	onMarked() {
+		if (!this.needsCheck) {
+			this.needsCheck = true;
+			queue.push(this);
+		}
+	}
+};
+/** Runs the queued effects now; what they write joins as the next wave. Every effect runs, the first error is rethrown. */
+var flushSync = () => {
+	if (flushing) return;
+	flushing = true;
+	let failure = null;
+	try {
+		let wave = 0;
+		while (queue.length > 0) {
+			wave++;
+			if (wave > MAX_FLUSH_WAVES) {
+				const dropped = queue;
+				queue = [];
+				dropped.forEach((effect) => effect.dequeue());
+				throw new Error(`reelx: a cycle of effects, each writes a signal another one reads (${MAX_FLUSH_WAVES} waves)`, { cause: failure?.error });
+			}
+			const effects = queue;
+			queue = [];
+			for (const effect of effects) try {
+				effect.run();
+			} catch (error) {
+				failure ??= { error };
+			}
+		}
+	} finally {
+		flushing = false;
+	}
+	if (hasSome(failure)) throw failure.error;
+};
+var nodes = /* @__PURE__ */ new WeakMap();
+var toReactiveValue = (node) => {
+	nodes.set(node.read, node);
+	return node.read;
+};
+/** A value that effects and computeds re-read when it is written; a function is held as a value too. */
+var signal = (initial, options = {}) => toReactiveValue(new Signal(initial, options));
+/** A value derived from what `fn` reads, recomputed on read after one of them changes; what `fn` throws is rethrown until then. */
+var computed = (fn) => toReactiveValue(new Computed(fn));
+/** Writes `value` to the signal `read` reads (a computed's reader is ignored); a value its `equals` finds unchanged changes nothing. */
+var write = (read, value) => {
+	const node = nodes.get(read);
+	if (isInstanceOf(Signal, node)) node.write(value);
+};
+/** Runs `fn` now and again after every change of what it read. Returns `dispose`; creation that throws leaves nothing subscribed. */
+var effect = (fn) => {
+	const node = new Effect(fn);
+	try {
+		batch(() => {
+			try {
+				node.run();
+			} catch (error) {
+				node.dispose();
+				throw error;
+			}
+		});
+	} catch (error) {
+		node.dispose();
+		throw error;
+	}
+	return node.dispose;
+};
+/**
+* Calls `cb` with the value of `read` and the one before it: now, unless it is `undefined`, then
+* after every change `read` notifies. Returns `unsubscribe`.
+*/
+var subscribe = (read, cb) => {
+	let last;
+	let started = false;
+	return effect(() => {
+		const value = read();
+		const previous = last;
+		last = value;
+		if (started || !Object.is(value, void 0)) untracked(() => cb(value, previous));
+		started = true;
+	});
+};
+/** Groups writes: effects run once, when the outermost `batch` ends, even if `fn` throws. */
+var batch = (fn) => {
+	batchDepth++;
+	try {
+		return fn();
+	} finally {
+		if (--batchDepth === 0) flushSync();
+	}
+};
+/** Runs `fn` without subscribing the running effect or computed to what it reads. */
+var untracked = (fn) => {
+	const outer = setTracker(null);
+	try {
+		return fn();
+	} finally {
+		setTracker(outer);
+	}
+};
+/** How many effects and computeds read `read` now: tests count them to prove that `dispose` released them. */
+var subscriberCount = (read) => nodes.get(read)?.observers.size ?? 0;
+//#endregion
+export { subscribe as a, write as c, signal as i, noop as l, computed as n, subscriberCount as o, effect as r, untracked as s, batch as t };
+
+//# sourceMappingURL=signals-CHdm5V62.js.map

package/dist/signals-CHdm5V62.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals-CHdm5V62.js","names":[],"sources":["../../utils/dist/lib/objects/isInstanceOf.js","../../utils/dist/lib/fp/noop.js","../src/lib/reelx.core.ts"],"sourcesContent":["export default function isInstanceOf(instanceType, instance) {\n    return instance instanceof instanceType;\n}\n","export default function noop() {\n    return undefined;\n}\n","// A push-pull signal graph: a write marks what may have changed, a read brings a node up to date.\nimport { hasSome } from '@reely/basics';\nimport type { Nullable } from '@reely/utils';\nimport { isInstanceOf, noop } from '@reely/utils';\n\n/** A value read reactively: a signal, a computed or any getter of them; an effect or computed that reads it follows it. */\nexport type ReactiveValue<T> = () => T;\n\n// a method type: its parameters stay bivariant, so a `Signal<T>` is a `Signal<unknown>`\ntype Equality<T> = { bivarianceHack(previous: T, next: T): boolean }['bivarianceHack'];\n\n/** How a signal tells a write that changes nothing from one that notifies. */\nexport interface SignalOptions<T> {\n  /**\n   * Whether a write leaves the value unchanged, so nothing is notified; `Object.is` by default.\n   * `false` (or `() => false`) notifies every write, for an object changed in place.\n   */\n  equals?: Equality<T> | false;\n}\n\ninterface Source {\n  // grows with every change of the value, so an observer can tell whether what it read is still current\n  readonly version: number;\n  readonly observers: ReadonlySet<Computation<unknown>>;\n  refresh(): void;\n  observe(observer: Computation<unknown>): void;\n  unobserve(observer: Computation<unknown>): void;\n}\n\ninterface Link {\n  version: number;\n  readIn: number;\n}\n\n// the value, or what the computation threw\ntype Outcome<T> = { readonly threw: false; readonly value: T } | { readonly threw: true; readonly value: unknown };\n\nconst MAX_FLUSH_WAVES = 100;\n\n// grows with every write: an unlinked computed hears no writes, but one checked at this epoch is current\nlet epoch = 0;\nlet tracker: Nullable<Computation<unknown>> = null;\n// the computation whose `fn` runs now, tracked or not: its own writes never run it again\nlet running: Nullable<Computation<unknown>> = null;\nlet batchDepth = 0;\nlet queue: Effect[] = [];\nlet flushing = false;\n\nconst setTracker = (observer: Nullable<Computation<unknown>>): Nullable<Computation<unknown>> => {\n  const outer = tracker;\n  tracker = observer;\n  return outer;\n};\n\nconst setRunning = (computation: Nullable<Computation<unknown>>): Nullable<Computation<unknown>> => {\n  const outer = running;\n  running = computation;\n  return outer;\n};\n\nclass Signal<T> implements Source {\n  public version = 0;\n  public readonly observers = new Set<Computation<unknown>>();\n  public readonly refresh = noop;\n\n  constructor(private value: T, private readonly options: SignalOptions<T>) {}\n\n  public readonly read = (): T => {\n    tracker?.onRead(this);\n    return this.value;\n  };\n\n  public observe(observer: Computation<unknown>): void {\n    this.observers.add(observer);\n  }\n\n  public unobserve(observer: Computation<unknown>): void {\n    this.observers.delete(observer);\n  }\n\n  public write(value: T): void {\n    const { equals = Object.is } = this.options;\n    if (equals !== false && equals(this.value, value)) {\n      return;\n    }\n    this.value = value;\n    this.version++;\n    epoch++;\n    running?.onOwnWrite(this);\n    const idle = queue.length === 0;\n    for (const observer of this.observers) {\n      observer.mark(this);\n    }\n    if (idle && queue.length > 0 && batchDepth === 0 && !flushing) {\n      flushSync();\n    }\n  }\n}\n\n// runs `fn` recording what it reads, and reruns it on demand only when one of those sources changed\nabstract class Computation<T> {\n  public version = 0;\n  // a source may have changed; the versions of the sources tell whether one did\n  protected needsCheck = false;\n  // in the order first read\n  protected readonly sources = new Map<Source, Link>();\n  protected outcome: Nullable<Outcome<T>> = null;\n  private runCount = 0;\n  private checkedAt = -1;\n  private markedAt = -1;\n  private deafTo: Nullable<Set<Source>> = null;\n\n  constructor(private readonly fn: () => T) {}\n\n  // whether its sources hold it, so that their writes reach it\n  protected abstract get linked(): boolean;\n\n  // `written` is the signal whose write this mark carries\n  public mark(written: Source): void {\n    // once per write: a node already marked by an earlier write still passes a new one on\n    if (this.markedAt === epoch) {\n      return;\n    }\n    this.markedAt = epoch;\n    // A run does not depend on a signal it writes, read directly or through a computed: its own\n    // write coming back makes it deaf to that signal until it reads it again or runs again.\n    if (this === running) {\n      this.deafTo ??= new Set();\n      this.deafTo.add(written);\n    } else if (!this.deafTo?.has(written)) {\n      this.onMarked(written);\n    }\n  }\n\n  // what a run writes itself is not a change it missed\n  public onOwnWrite(source: Source): void {\n    const link = this.sources.get(source);\n    if (hasSome(link)) {\n      link.version = source.version;\n    }\n  }\n\n  public onRead(source: Source): void {\n    this.deafTo?.delete(source);\n    const link = this.sources.get(source);\n    if (hasSome(link)) {\n      link.version = source.version;\n      link.readIn = this.runCount;\n      return;\n    }\n    this.sources.set(source, { version: source.version, readIn: this.runCount });\n    if (this.linked) {\n      source.observe(this);\n    }\n  }\n\n  public refresh(): Outcome<T> {\n    const current = this.outcome;\n    if (hasSome(current) && !this.needsCheck && (this.linked || this.checkedAt === epoch)) {\n      return current;\n    }\n    this.needsCheck = false;\n    this.checkedAt = epoch;\n    if (hasSome(current) && !this.sourceChanged()) {\n      return current;\n    }\n\n    const { fn } = this;\n    this.runCount++;\n    this.deafTo = null;\n    const outer = setTracker(this);\n    const outerRunning = setRunning(this);\n    let next: Outcome<T>;\n    try {\n      next = { threw: false, value: fn() };\n    } catch (error) {\n      next = { threw: true, value: error };\n    }\n    setTracker(outer);\n    setRunning(outerRunning);\n    this.dropUnread();\n    if (!hasSome(current) || current.threw !== next.threw || !Object.is(current.value, next.value)) {\n      this.version++;\n    }\n    this.outcome = next;\n    return next;\n  }\n\n  protected detach(): void {\n    for (const source of this.sources.keys()) {\n      source.unobserve(this);\n    }\n  }\n\n  private unlink(source: Source): void {\n    this.sources.delete(source);\n    source.unobserve(this);\n  }\n\n  private sourceChanged(): boolean {\n    for (const [source, { version }] of this.sources) {\n      source.refresh();\n      if (source.version !== version) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  private dropUnread(): void {\n    for (const [source, link] of this.sources) {\n      if (link.readIn !== this.runCount) {\n        this.unlink(source);\n      }\n    }\n  }\n\n  protected abstract onMarked(written: Source): void;\n}\n\nclass Computed<T> extends Computation<T> implements Source {\n  public readonly observers = new Set<Computation<unknown>>();\n\n  protected get linked(): boolean {\n    return this.observers.size > 0;\n  }\n\n  public readonly read = (): T => {\n    const outcome = this.refresh();\n    tracker?.onRead(this);\n    if (outcome.threw) {\n      throw outcome.value;\n    }\n    return outcome.value;\n  };\n\n  public observe(observer: Computation<unknown>): void {\n    if (this.observers.size === 0) {\n      for (const source of this.sources.keys()) {\n        source.observe(this);\n      }\n    }\n    this.observers.add(observer);\n  }\n\n  public unobserve(observer: Computation<unknown>): void {\n    if (this.observers.delete(observer) && this.observers.size === 0) {\n      this.detach();\n    }\n  }\n\n  protected onMarked(written: Source): void {\n    this.needsCheck = true;\n    for (const observer of this.observers) {\n      observer.mark(written);\n    }\n  }\n}\n\n// stays linked until disposed; a mark queues it to run\nclass Effect extends Computation<void> {\n  private disposed = false;\n\n  protected get linked(): boolean {\n    return !this.disposed;\n  }\n\n  public readonly dispose = (): void => {\n    this.disposed = true;\n    this.detach();\n    this.sources.clear();\n  };\n\n  // runs it if what it read has changed, and throws what that run threw\n  public run(): void {\n    if (this.disposed) {\n      return;\n    }\n    const before = this.outcome;\n    const after = this.refresh();\n    if (after !== before && after.threw) {\n      throw after.value;\n    }\n  }\n\n  // taken out of the queue without running: the next write queues it again\n  public dequeue(): void {\n    this.needsCheck = false;\n  }\n\n  protected onMarked(): void {\n    if (!this.needsCheck) {\n      this.needsCheck = true;\n      queue.push(this);\n    }\n  }\n}\n\n/** Runs the queued effects now; what they write joins as the next wave. Every effect runs, the first error is rethrown. */\nconst flushSync = (): void => {\n  if (flushing) {\n    return;\n  }\n  flushing = true;\n  let failure: Nullable<{ readonly error: unknown }> = null;\n  try {\n    let wave = 0;\n    while (queue.length > 0) {\n      wave++;\n      if (wave > MAX_FLUSH_WAVES) {\n        const dropped = queue;\n        queue = [];\n        dropped.forEach((effect) => effect.dequeue());\n        throw new Error(\n          `reelx: a cycle of effects, each writes a signal another one reads (${MAX_FLUSH_WAVES} waves)`,\n          { cause: failure?.error }\n        );\n      }\n      const effects = queue;\n      queue = [];\n      for (const effect of effects) {\n        try {\n          effect.run();\n        } catch (error) {\n          failure ??= { error };\n        }\n      }\n    }\n  } finally {\n    flushing = false;\n  }\n  if (hasSome(failure)) {\n    throw failure.error;\n  }\n};\n\n// the node behind each reader, for writes and for `subscriberCount`\nconst nodes = new WeakMap<ReactiveValue<unknown>, Signal<unknown> | Computed<unknown>>();\n\nconst toReactiveValue = <T>(node: Signal<T> | Computed<T>): ReactiveValue<T> => {\n  nodes.set(node.read, node);\n  return node.read;\n};\n\n/** A value that effects and computeds re-read when it is written; a function is held as a value too. */\nexport const signal = <T>(initial: T, options: SignalOptions<T> = {}): ReactiveValue<T> =>\n  toReactiveValue(new Signal(initial, options));\n\n/** A value derived from what `fn` reads, recomputed on read after one of them changes; what `fn` throws is rethrown until then. */\nexport const computed = <T>(fn: () => T): ReactiveValue<T> => toReactiveValue(new Computed(fn));\n\n/** Writes `value` to the signal `read` reads (a computed's reader is ignored); a value its `equals` finds unchanged changes nothing. */\nexport const write = <T>(read: ReactiveValue<T>, value: T): void => {\n  const node = nodes.get(read);\n  if (isInstanceOf(Signal, node)) {\n    node.write(value);\n  }\n};\n\n/** Runs `fn` now and again after every change of what it read. Returns `dispose`; creation that throws leaves nothing subscribed. */\nexport const effect = (fn: () => void): (() => void) => {\n  const node = new Effect(fn);\n  try {\n    batch(() => {\n      try {\n        node.run();\n      } catch (error) {\n        // before the flush that ends the batch, so it never runs an effect whose creation threw\n        node.dispose();\n        throw error;\n      }\n    });\n  } catch (error) {\n    node.dispose();\n    throw error;\n  }\n  return node.dispose;\n};\n\n/**\n * Calls `cb` with the value of `read` and the one before it: now, unless it is `undefined`, then\n * after every change `read` notifies. Returns `unsubscribe`.\n */\nexport const subscribe = <T>(read: ReactiveValue<T>, cb: (value: T, prevValue?: T) => void): (() => void) => {\n  let last: T | undefined;\n  let started = false;\n  return effect(() => {\n    const value = read();\n    const previous = last;\n    last = value;\n    if (started || !Object.is(value, undefined)) {\n      untracked(() => cb(value, previous));\n    }\n    started = true;\n  });\n};\n\n/** Groups writes: effects run once, when the outermost `batch` ends, even if `fn` throws. */\nexport const batch = <T>(fn: () => T): T => {\n  batchDepth++;\n  try {\n    return fn();\n  } finally {\n    if (--batchDepth === 0) {\n      flushSync();\n    }\n  }\n};\n\n/** Runs `fn` without subscribing the running effect or computed to what it reads. */\nexport const untracked = <T>(fn: () => T): T => {\n  const outer = setTracker(null);\n  try {\n    return fn();\n  } finally {\n    setTracker(outer);\n  }\n};\n\n/** How many effects and computeds read `read` now: tests count them to prove that `dispose` released them. */\nexport const subscriberCount = (read: ReactiveValue<unknown>): number => nodes.get(read)?.observers.size ?? 0;\n"],"mappings":"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"}

package/dist/testing.d.ts

@@ -0,0 +1,7 @@
+/** A value read reactively: a signal, a computed or any getter of them; an effect or computed that reads it follows it. */
+declare type ReactiveValue<T> = () => T;
+
+/** How many effects and computeds read `read` now: tests count them to prove that `dispose` released them. */
+export declare const subscriberCount: (read: ReactiveValue<unknown>) => number;
+
+export { }

package/dist/testing.js

@@ -0,0 +1,2 @@
+import { o as subscriberCount } from "./signals-CHdm5V62.js";
+export { subscriberCount };

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "@reely/signals",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Signals, computed values and effects: a push-pull graph with owners that release what a piece of work subscribed. No DOM.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JsPowWow/reely.git"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js",
+      "default": "./dist/testing.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "nx": {
+    "tags": [
+      "scope:shared"
+    ],
+    "projectType": "library",
+    "sourceRoot": "packages/signals/src",
+    "targets": {
+      "build": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "vite build",
+          "cwd": "packages/signals"
+        },
+        "dependsOn": [
+          "^build"
+        ],
+        "outputs": [
+          "{projectRoot}/dist"
+        ]
+      },
+      "consumer": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "node ../../scripts/consumer-check.mjs",
+          "cwd": "packages/signals"
+        },
+        "dependsOn": [
+          "build",
+          "^build"
+        ]
+      }
+    }
+  },
+  "devDependencies": {
+    "@reely/utils": "*"
+  },
+  "dependencies": {
+    "@reely/basics": "^0.1.0"
+  }
+}