gesso-framework 0.6.29 → 0.7.0

package/dist/{persisted-fUzIU8FZ.js → persisted-8meJmsOh.js}

@@ -1,577 +1,5 @@
-import { O as structurallyEqual } from "./serveChannels-BlEag7WU.js";
-import { BehaviorSubject, Observable, Subject, Subscription, combineLatest, debounceTime, distinctUntilChanged, map, of, skip, tap, throttleTime } from "rxjs";
-//#region src/Input.ts
-/**
-* Reactive cell holding a component input.
-*
-* Inputs must be cells because render() runs exactly once. A component
-* that read a plain input value during render would capture it for the
-* life of the instance, so a parent supplying new props under a
-* dynamic subtree would update the field while the rendered tree kept
-* showing the original value.
-*
-* The cell is written by the component host only: it accepts whatever
-* the parent passed, subscribing it first when the parent passed an
-* Observable. `value` is deliberately read-only, so `this.label.value =
-* x` inside a component is a compile error rather than a silent
-* violation of the one-way data flow.
-*/
-var InputCell = class extends BehaviorSubject {
-	/**
-	* What to call this cell in a warning: `Component.prop`, or
-	* `channel.key`. Set by whoever creates it; a cell without one is
-	* reported as "a cell".
-	*/
-	label;
-	/** The component whose body read `.value`, for the stale-read warning below. */
-	snapshotBy = null;
-	warnedStale = false;
-	/** Everything emitted through `emit`, created on the first `events` read. */
-	emitted = null;
-	constructor(initialValue) {
-		super(initialValue);
-	}
-	/**
-	* Fires the output this cell stands for.
-	*
-	* An output is a cell whose value is what the parent gave to be
-	* called: a function, or a target made by `into(subject)`. `emit`
-	* calls it with the arguments, and also pushes the first argument
-	* through `events`, so the component can fire from three places
-	* without passing the cell around and a parent that wants a stream
-	* can have one. A parent that passed nothing is fine: the call
-	* simply reaches nobody.
-	*/
-	emit(...args) {
-		const handler = super.getValue();
-		if (typeof handler === "function") handler(...args);
-		this.emitted?.next(args[0]);
-	}
-	/** What `emit` has fired, as a stream: the first argument of each call. */
-	get events() {
-		if (this.emitted === null) this.emitted = new Subject();
-		return this.emitted.asObservable();
-	}
-	get value() {
-		trackRead(this);
-		if (bodyOf !== null && tracking === null && this.snapshotBy === null) this.snapshotBy = bodyOf;
-		return super.getValue();
-	}
-	/**
-	* The one place the run-once model goes quietly wrong is a body that
-	* reads `props.x.value`, uses the value to build the tree, and never
-	* hears that it changed. Nothing crashes; the screen is simply stale.
-	* So a cell remembers being read while a body ran, and if it later
-	* changes with nobody subscribed to it, it says so once. A cell that
-	* something is following is fine: the follower carries the change.
-	*
-	* The value it already holds is not a change, and tells nobody: values
-	* that cross into a component are treated as immutable, so the same
-	* reference is the same value.
-	*/
-	next(value) {
-		if (!this.hasError && Object.is(value, super.getValue())) return;
-		if (this.snapshotBy !== null && !this.warnedStale && !this.observed) {
-			this.warnedStale = true;
-			warnStaleRead(this.snapshotBy, this.label, super.getValue(), value);
-		}
-		super.next(value);
-	}
-};
-/** The component whose function body is running, while one is. */
-let bodyOf = null;
-/** The component whose body is running, for a cell that wants to remember being read there. */
-function currentBody() {
-	return bodyOf;
-}
-/** The set a running `computed` is collecting its reads into, while one is. */
-let tracking = null;
-/** Records a `.value` read for whatever `computed` is running, if one is. */
-function trackRead(cell) {
-	tracking?.add(cell);
-}
-/** Runs `run` with every `.value` read on the way recorded into `into`. */
-function withTracking(into, run) {
-	const previous = tracking;
-	tracking = into;
-	try {
-		return run();
-	} finally {
-		tracking = previous;
-	}
-}
-/**
-* Runs a component's body with its name on record, so a `.value` read
-* inside it can be told apart from one in an event handler later, which
-* is the ordinary way to read the current value and warns about nothing.
-*/
-function withBodyOf(tag, run) {
-	const previous = bodyOf;
-	bodyOf = tag;
-	try {
-		return run();
-	} finally {
-		bodyOf = previous;
-	}
-}
-function warnStaleRead(tag, label, from, to) {
-	const what = label === void 0 ? "a cell" : `\`${label}\``;
-	const change = describeChange(from, to);
-	console.warn(`Component '${tag}' read ${what} with .value while its body ran, and nothing is following that cell. It has since changed ${change}, and whatever was built from the first value still shows it. A component body runs once: bind the cell instead (pass it, or pipe it, into the prop it feeds), or give the component a key so a new value builds a new one.`);
-}
-/**
-* "from X to Y", or for two plain objects the first field that differs,
-* because two objects that print alike for sixty characters say nothing
-* about what actually moved.
-*/
-function describeChange(from, to) {
-	if (isPlainObject(from) && isPlainObject(to)) {
-		for (const key of /* @__PURE__ */ new Set([...Object.keys(from), ...Object.keys(to)])) {
-			const before = from[key];
-			const after = to[key];
-			if (!Object.is(before, after) && safeJson(before) !== safeJson(after)) return `at .${key}, from ${describe(before)} to ${describe(after)}`;
-		}
-		return "to an equal-looking object";
-	}
-	return `from ${describe(from)} to ${describe(to)}`;
-}
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function safeJson(value) {
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-function describe(value) {
-	let text;
-	try {
-		text = typeof value === "function" ? "a function" : JSON.stringify(value) ?? String(value);
-	} catch {
-		text = String(value);
-	}
-	return text.length > 60 ? `${text.slice(0, 57)}...` : text;
-}
-function input(first, fallback) {
-	if (arguments.length < 2 || !(first instanceof InputCell)) return new InputCell(first);
-	const source = first;
-	const withFallback = (value) => value === void 0 ? fallback : value;
-	const derived = new InputCell(withFallback(source.value));
-	derived.label = source.label;
-	source.subscribe({
-		next: (value) => derived.next(withFallback(value)),
-		complete: () => derived.complete()
-	});
-	return derived;
-}
-/**
-* An output a class component declares as a field:
-*
-*   @Output() changed = output<[value: number]>();
-*
-* The host wires the parent's handler into it exactly as it wires an
-* input, and `this.changed.emit(next)` fires it.
-*/
-function output() {
-	return new InputCell(void 0);
-}
-const OUTPUT_TARGET = Symbol("gesso:output-target");
-function into(target) {
-	return { [OUTPUT_TARGET]: target };
-}
-function isOutputTarget(value) {
-	return typeof value === "object" && value !== null && OUTPUT_TARGET in value;
-}
-/** The receiver an `into()` target wraps. */
-function outputTargetOf(target) {
-	return target[OUTPUT_TARGET];
-}
-//#endregion
-//#region src/InternalState.ts
-/**
-* A component's own state: originated here, and never crossing the
-* barrier.
-*
-* The writable counterpart to `InputCell`. The two are the same
-* `BehaviorSubject` and differ by one accessor — this one has a
-* `.value` setter — and that difference is the whole semantics:
-*
-*     internalState()   never crosses    I write it
-*     input()           crosses inward   someone else writes it
-*
-* Named on that axis deliberately. It used to be `state()`, which
-* described *what* a thing was while `input()` described *where it
-* came from*; two names on two axes made neither of them tell you
-* anything about the other. `internalState(products)` reads as a
-* mistake at the call site in a way `state(products)` never did.
-*
-* For values that originate on this thread and die with the component:
-* a tooltip's open flag, a caret, a scroll offset, the active tab.
-* Anything that survives a reload, or that another screen cares about,
-* is application state and belongs on a channel. Anything derived from
-* other cells is a `computed`.
-*
-* It is not only for components. The thread that owns a channel's data
-* writes cells too, and wrote them as a `BehaviorSubject` mirrored
-* into an `asObservable()` because this was reachable only through the
-* framework's main entry. `gesso-framework/worker` is the same cell
-* with none of the renderer behind it, so an application worker holds
-* one cell rather than a subject and a copy of it, and reads it with
-* `.value` in a `computed` rather than listing it in a
-* `combineLatest`. "Internal" still means what it says there: written
-* here, and crossing the barrier only as the plain data a view key
-* publishes.
-*/
-var InternalState = class extends BehaviorSubject {
-	/** What to call this cell in a warning or the inspector; optional. */
-	label;
-	constructor(initialValue) {
-		super(initialValue);
-	}
-	get value() {
-		trackRead(this);
-		return super.getValue();
-	}
-	set value(next) {
-		this.next(next);
-	}
-};
-/**
-* Creates a reactive state cell.
-*
-* Usage inside a component:
-*
-*   private readonly count = state(0);
-*
-*   increment() {
-*     this.count.value++;
-*   }
-*/
-function internalState(initialValue, label) {
-	const state = new InternalState(initialValue);
-	if (label !== void 0) state.label = label;
-	return state;
-}
-//#endregion
-//#region src/derive.ts
-/**
-* One value from several, kept equal to `project` of the latest of each
-* source, and emitted only when it changes.
-*
-* This is `combineLatest(...).pipe(map(...), distinctUntilChanged())`,
-* which is what nearly every derived binding in a component body wants
-* and what nearly every one had to write out. Sources are cells or any
-* Observables; the result is what a prop takes.
-*
-*   const playing = derive([queue.view.playlistId, audio.state], (id, state) =>
-*     id === card.id && state.status === 'playing'
-*   );
-*
-* @deprecated Write it as a `computed`, which is the one derivation the
-* documentation teaches. A cell is read with
-* `.value` and anything else through the `read` the function is handed,
-* so the sources are the reads themselves and there is no list beside
-* the expression to keep in step with it:
-*
-*   const playing = computed(read =>
-*     queue.view.playlistId.value === card.id && read(audio.state).status === 'playing'
-*   );
-*
-* It still works and nothing that uses it needs changing today.
-*/
-function derive(sources, project, options = {}) {
-	const equal = equalityOf(options.equal ?? "reference");
-	return combineLatest(sources).pipe(map((values) => project(...values)), distinctUntilChanged(equal));
-}
-/** The comparison an `Equality` names. Shared with `computed`. */
-function equalityOf(equal) {
-	if (equal === "reference") return Object.is;
-	if (equal === "structural") return (a, b) => structurallyEqual(a, b);
-	return equal;
-}
-//#endregion
-//#region src/computed.ts
-/**
-* A cell whose value is a function of other cells.
-*
-* `computed(() => quantity.value * price.value)` reads like the value it
-* is. The cells its function reads through `.value` are its sources,
-* found by running the function and watching what it touches, so there
-* is no list to keep in step with the expression; a read the function
-* did not make this time is a source it no longer has.
-*
-* A stream that is not a cell is read through the `read` the function
-* is handed: `computed(read => read(stream).status)` follows the stream
-* as it follows a cell. That is what makes this the only derivation an
-* application needs, whether or not the thing it derives from happens
-* to have a current value of its own.
-*
-* It is a cell and nothing else. Bound to a prop it is an Observable
-* like every other cell, so a component written with it and one written
-* with `pipe` compose without translation. Read in a handler with
-* `.value` it is the current result, computed on the spot if nothing is
-* following it. RxJS is underneath and nothing here replaces it.
-*
-* Nothing runs until someone asks. With no subscriber the function runs
-* only when `.value` is read; with one, the cell follows its sources and
-* emits a result when it differs from the last by `equal`. When the last
-* subscriber leaves it lets go of its sources, so a computed made in a
-* component body dies with the component's bindings and needs no
-* disposal of its own.
-*
-* Reading it with `.value` while a component body runs is the same
-* snapshot an input read there is, and it warns the same way: once, if
-* it later changes with nobody following.
-*/
-var ComputedCell = class extends Observable {
-	compute;
-	label;
-	equal;
-	changes = new Subject();
-	sources = /* @__PURE__ */ new Set();
-	/**
-	* The set the next run collects its reads into. It trades places with
-	* `sources` after the run, so following a cell allocates nothing per
-	* change; the two sets are simply reused.
-	*/
-	collecting = /* @__PURE__ */ new Set();
-	/** Whether the last run read different cells from the run before it. */
-	sourcesChanged = false;
-	recomputing = false;
-	cached;
-	hasValue = false;
-	upstream = null;
-	subscribers = 0;
-	attaching = false;
-	snapshotBy = null;
-	warnedStale = false;
-	/** Follows the sources after a body read, only to notice the change the body will not. */
-	staleWatch = null;
-	constructor(compute, options = {}) {
-		super((subscriber) => {
-			this.subscribers++;
-			this.staleWatch?.unsubscribe();
-			this.staleWatch = null;
-			if (this.upstream === null) this.attach();
-			subscriber.next(this.cached);
-			const following = this.changes.subscribe(subscriber);
-			return () => {
-				following.unsubscribe();
-				this.subscribers--;
-				if (this.subscribers === 0) this.detach();
-			};
-		});
-		this.compute = compute;
-		this.equal = equalityOf(options.equal ?? "reference");
-		this.label = options.label;
-	}
-	/** The current result: kept by the sources while followed, computed now when not. */
-	get value() {
-		trackRead(this);
-		if (this.upstream === null) this.recompute();
-		const body = currentBody();
-		if (body !== null && this.snapshotBy === null) {
-			this.snapshotBy = body;
-			this.watchForStaleRead();
-		}
-		return this.cached;
-	}
-	/**
-	* A body read the value once; if a source now changes with nothing
-	* following this cell, the screen built from that read is stale and
-	* nobody would know. So the sources are watched for exactly that, and
-	* the watch ends with the warning or with a real subscriber arriving.
-	*/
-	watchForStaleRead() {
-		this.staleWatch = new Subscription();
-		let settling = true;
-		for (const source of this.sources) this.staleWatch.add(source.subscribe(() => {
-			if (settling || this.observed) return;
-			if (this.recompute()) {
-				this.warnStale();
-				this.staleWatch?.unsubscribe();
-				this.staleWatch = null;
-			}
-		}));
-		settling = false;
-	}
-	warnStale() {
-		if (this.snapshotBy === null || this.warnedStale) return;
-		this.warnedStale = true;
-		console.warn(`Component '${this.snapshotBy}' read ${this.label === void 0 ? "a computed cell" : `\`${this.label}\``} with .value while its body ran, and nothing is following that cell. It has since changed, and whatever was built from the first value still shows it. A component body runs once: bind the cell instead.`);
-	}
-	/** Whether anything is following this cell; the stale-read warning's question. */
-	get observed() {
-		return this.subscribers > 0;
-	}
-	/** Runs the function, watching what it reads; true when the result changed. */
-	recompute() {
-		const nested = this.recomputing;
-		const touched = nested ? /* @__PURE__ */ new Set() : this.collecting;
-		touched.clear();
-		this.recomputing = true;
-		let next;
-		try {
-			next = withTracking(touched, () => this.compute(readSource));
-		} finally {
-			this.recomputing = nested;
-		}
-		this.sourcesChanged = !sameSet(touched, this.sources);
-		if (!nested) this.collecting = this.sources;
-		this.sources = touched;
-		const changed = !this.hasValue || !this.equal(this.cached, next);
-		this.hasValue = true;
-		this.cached = next;
-		return changed;
-	}
-	/** Follows the current sources, re-running on any change to them. */
-	attach() {
-		this.attaching = true;
-		this.recompute();
-		this.upstream = new Subscription();
-		for (const source of this.sources) this.upstream.add(source.subscribe(() => this.onSourceChanged()));
-		this.attaching = false;
-	}
-	detach() {
-		this.upstream?.unsubscribe();
-		this.upstream = null;
-	}
-	onSourceChanged() {
-		if (this.attaching) return;
-		const changed = this.recompute();
-		if (this.sourcesChanged) {
-			this.detach();
-			this.attaching = true;
-			this.upstream = new Subscription();
-			for (const source of this.sources) this.upstream.add(source.subscribe(() => this.onSourceChanged()));
-			this.attaching = false;
-		}
-		if (changed) this.changes.next(this.cached);
-	}
-};
-/**
-* A cell computed from what its function reads. See `ComputedCell`.
-*
-*   const total = computed(() => quantity.value * PRICE * RATES[currency.value]);
-*   <text text={computed(() => String(count.value))} />
-*
-* Cells are read with `.value`; anything else is read through the
-* `read` the function is given, which follows it the same way:
-*
-*   const late = computed(read => read(clock) > deadline);
-*/
-function computed(compute, options = {}) {
-	return new ComputedCell(compute, options);
-}
-/**
-* The cell standing for a stream, one per stream.
-*
-* Anything that already has a current value is its own cell, so a
-* `read` of an input, an internal state or another computed costs a
-* property access and nothing more. Everything else gets a `StreamCell`
-* held against it here, so several computeds reading one stream share a
-* single subscription to it rather than opening one each.
-*
-* Weak on purpose: the entry is reachable only while the stream is, so
-* a stream made in a component body is collected with the component.
-*/
-const streamCells = /* @__PURE__ */ new WeakMap();
-/**
-* Whether a source's `.value` announces itself to the running computed,
-* decided once per source and remembered.
-*
-* Having a `value` is not enough. A framework cell records its reads
-* through `trackRead`, which is what lets a computed learn what it
-* depends on; a plain `BehaviorSubject` has a `value` too and records
-* nothing, so a computed that trusted the property would read it once
-* and never hear it change. That is exactly what happened to three
-* data-layer specs that fed a raw subject where the application feeds
-* a channel view. The probe reads `.value` once under a tracking set
-* of its own and asks whether the source turned up in it.
-*/
-const tracksReads = /* @__PURE__ */ new WeakMap();
-function announcesItsReads(source) {
-	let known = tracksReads.get(source);
-	if (known === void 0) {
-		const seen = /* @__PURE__ */ new Set();
-		withTracking(seen, () => void source.value);
-		known = seen.has(source);
-		tracksReads.set(source, known);
-	}
-	return known;
-}
-function cellFor(source) {
-	if ("value" in source && announcesItsReads(source)) return source;
-	let cell = streamCells.get(source);
-	if (cell === void 0) {
-		cell = new StreamCell(source);
-		streamCells.set(source, cell);
-	}
-	return cell;
-}
-/** The `read` every computed's function is handed. */
-const readSource = (source) => cellFor(source).value;
-/**
-* A plain stream, seen as a cell.
-*
-* It holds the last value it saw and hands it to whoever asks, which is
-* the one thing a cell has and an Observable does not. While something
-* follows it, it follows the stream; when the last follower leaves it
-* lets go, so it costs nothing between uses and needs no disposal, on
-* the same terms as `ComputedCell`.
-*
-* A `.value` read with nothing following takes one synchronous
-* subscription and drops it again, which is how a `BehaviorSubject`
-* behind an `asObservable()`, or a `combineLatest` over such subjects,
-* answers with what it already holds. A stream that has nothing to say
-* synchronously answers `undefined` until its first emission arrives,
-* which is the honest answer: there is no value yet.
-*/
-var StreamCell = class extends Observable {
-	stream;
-	last;
-	followers = 0;
-	upstream = null;
-	changes = new Subject();
-	constructor(stream) {
-		super((subscriber) => {
-			this.followers++;
-			if (this.upstream === null) this.attach();
-			subscriber.next(this.last);
-			const following = this.changes.subscribe(subscriber);
-			return () => {
-				following.unsubscribe();
-				this.followers--;
-				if (this.followers === 0) {
-					this.upstream?.unsubscribe();
-					this.upstream = null;
-				}
-			};
-		});
-		this.stream = stream;
-	}
-	get value() {
-		trackRead(this);
-		if (this.upstream === null) this.stream.subscribe((value) => {
-			this.last = value;
-		}).unsubscribe();
-		return this.last;
-	}
-	attach() {
-		this.upstream = this.stream.subscribe((value) => {
-			this.last = value;
-			this.changes.next(value);
-		});
-	}
-};
-function sameSet(a, b) {
-	if (a.size !== b.size) return false;
-	for (const item of a) if (!b.has(item)) return false;
-	return true;
-}
-//#endregion
+import { i as equalityOf, n as computed, o as internalState, p as trackRead } from "./computed-_cYcdczA.js";
+import { Observable, Subject, debounceTime, distinctUntilChanged, map, of, skip, tap, throttleTime } from "rxjs";
 //#region src/select.ts
 function select(source, keyOrProject, options = {}) {
 	const project = typeof keyOrProject === "function" ? keyOrProject : (value) => value === null || value === void 0 ? void 0 : value[keyOrProject];
@@ -1751,6 +1179,6 @@ function persisted(adapter, key, options) {
 	return new PersistedState(adapter, key, options);
 }
 //#endregion
-export { output as A, equalityOf as C, input as D, InputCell as E, trackRead as M, withBodyOf as N, into as O, derive as S, internalState as T, Resource as _, undoable as a, ComputedCell as b, classifyStorageError as c, storageReadValue as d, pick as f, mutate as g, throttled as h, OpfsStorage as i, outputTargetOf as j, isOutputTarget as k, storageErrorMessage as l, debounced as m, persisted as n, UndoStack as o, pickKeys as p, IndexedDbStorage as r, MemoryStorage as s, PersistedState as t, storageReadFailure as u, resource as v, InternalState as w, computed as x, select as y };
+export { Resource as _, undoable as a, classifyStorageError as c, storageReadValue as d, pick as f, mutate as g, throttled as h, OpfsStorage as i, storageErrorMessage as l, debounced as m, persisted as n, UndoStack as o, pickKeys as p, IndexedDbStorage as r, MemoryStorage as s, PersistedState as t, storageReadFailure as u, resource as v, select as y };
 
-//# sourceMappingURL=persisted-fUzIU8FZ.js.map
+//# sourceMappingURL=persisted-8meJmsOh.js.map