cross-state 0.53.3 → 0.54.0

package/dist/store-BWMWEUpu.cjs

@@ -0,0 +1,819 @@
+const require_propAccess = require('./propAccess-ByqBjC19.cjs');
+
+//#region src/lib/autobind.ts
+const marker = Symbol("autobind");
+const autobind = (_class) => {
+	for (const key of Reflect.ownKeys(_class.prototype)) {
+		if (key === "constructor") continue;
+		const descriptor = Reflect.getOwnPropertyDescriptor(_class.prototype, key);
+		let method = descriptor?.get?.() ?? descriptor?.value;
+		let isBinding = false;
+		if (typeof method !== "function" || method[marker]) continue;
+		Reflect.defineProperty(_class.prototype, key, {
+			configurable: true,
+			get() {
+				if (isBinding || this === _class.prototype || Object.prototype.hasOwnProperty.call(this, key) || typeof method !== "function") return method;
+				const boundMethod = (...args) => Reflect.apply(method, this, args);
+				boundMethod[marker] = true;
+				isBinding = true;
+				Object.defineProperty(this, key, {
+					configurable: true,
+					get() {
+						return boundMethod;
+					}
+				});
+				isBinding = false;
+				return boundMethod;
+			},
+			set(v) {
+				method = v;
+			}
+		});
+	}
+	return _class;
+};
+
+//#endregion
+//#region src/lib/calcDuration.ts
+function calcDuration(t) {
+	if (typeof t === "number") return t;
+	return (t.milliseconds ?? 0) + (t.seconds ?? 0) * 1e3 + (t.minutes ?? 0) * 60 * 1e3 + (t.hours ?? 0) * 60 * 60 * 1e3 + (t.days ?? 0) * 24 * 60 * 60 * 1e3;
+}
+
+//#endregion
+//#region src/lib/deferred.ts
+var Deferred = class Deferred extends Promise {
+	constructor() {
+		Object.defineProperty(Deferred, Symbol.species, { value: Promise });
+		const that = {};
+		super((resolve, reject) => {
+			Object.assign(that, {
+				resolve,
+				reject
+			});
+		});
+		this.resolve = () => void 0;
+		this.reject = () => void 0;
+		Object.assign(this, that);
+	}
+};
+
+//#endregion
+//#region src/lib/isPromise.ts
+function isPromise(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+
+//#endregion
+//#region src/lib/promiseWithState.ts
+var PromiseWithState = class PromiseWithState extends Promise {
+	static resolve(value) {
+		return new PromiseWithState(value);
+	}
+	static reject(error) {
+		return new PromiseWithState(Promise.reject(error), {
+			status: "error",
+			error
+		});
+	}
+	constructor(value, state = { status: "pending" }) {
+		super((resolve) => resolve(value));
+		this.state = state;
+		Object.defineProperty(PromiseWithState, Symbol.species, { value: Promise });
+		if (isPromise(value)) value.then((value$1) => {
+			this.state = {
+				status: "value",
+				value: value$1
+			};
+		}).catch((error) => {
+			this.state = {
+				status: "error",
+				error
+			};
+		});
+		else this.state = {
+			status: "value",
+			value
+		};
+	}
+};
+
+//#endregion
+//#region src/lib/queue.ts
+function queue() {
+	const q = [];
+	const completionListeners = /* @__PURE__ */ new Set();
+	let active = false;
+	const notify = () => {
+		for (const listener of completionListeners) listener();
+		completionListeners.clear();
+	};
+	const run = async () => {
+		if (!active) {
+			active = true;
+			let next;
+			while (next = q.shift()) try {
+				let result = next.action();
+				if (isPromise(result)) result = await result;
+				next.resolve(result);
+			} catch (error) {
+				next.reject(error);
+			}
+			active = false;
+			notify();
+		}
+	};
+	return Object.assign((action, ref) => {
+		return new Promise((resolve, reject) => {
+			q.push({
+				action,
+				resolve,
+				reject,
+				ref
+			});
+			run();
+		});
+	}, {
+		clear() {
+			q.length = 0;
+		},
+		whenDone() {
+			if (!active) return Promise.resolve();
+			return new Promise((resolve) => {
+				completionListeners.add(resolve);
+			});
+		},
+		get size() {
+			return q.length;
+		},
+		getRefs() {
+			return q.map((item) => item.ref).filter((x) => x !== void 0);
+		}
+	});
+}
+
+//#endregion
+//#region src/lib/calculatedValue.ts
+function calculatedValue(store, notify) {
+	if (!(store.getter instanceof Function)) return staticValue(store.getter);
+	let active = false;
+	const deps = new Array();
+	let value;
+	const whenConnected = new Deferred();
+	const whenExecuted = new Deferred();
+	const ac = new AbortController();
+	let connection;
+	const q = queue();
+	q(() => whenExecuted);
+	const cancelEffect = store.addEffect(() => {
+		if (connection) {
+			store.invalidate();
+			return;
+		}
+		active = true;
+		for (const dep of deps) dep.on();
+		return () => {
+			active = false;
+			for (const dep of deps) dep.off();
+			if (connection) {
+				connection.active = false;
+				connection.cancel?.();
+				q.clear();
+				if ("state" in store) store.state.set((state) => ({
+					...state,
+					isConnected: false,
+					isStale: true
+				}));
+			}
+		};
+	});
+	function use(dep) {
+		const value$1 = dep.get();
+		let cancel;
+		const on = () => {
+			cancel ||= dep.subscribe(() => store.invalidate(), { runNow: false });
+		};
+		const off = () => {
+			cancel?.();
+			cancel = void 0;
+		};
+		deps.push({
+			store: dep,
+			value: value$1,
+			on,
+			off
+		});
+		if (active) on();
+		return value$1;
+	}
+	async function connect(createConnection) {
+		if (!active) {
+			connection = { active: false };
+			return;
+		}
+		const actions = {
+			set(_value) {
+				q(() => {
+					if (!connection?.active) return;
+					value = _value;
+					notify();
+				});
+			},
+			updateValue(update) {
+				q(async () => {
+					if (!connection?.active) return;
+					if (update instanceof Function) {
+						const currentValue = await value;
+						if (!connection?.active) return;
+						try {
+							update = update(currentValue);
+						} catch (error) {
+							value = PromiseWithState.reject(error);
+							notify();
+							connection.active = false;
+							connection.cancel?.();
+							return;
+						}
+					}
+					value = PromiseWithState.resolve(update);
+					notify();
+				});
+			},
+			updateError(error) {
+				q(() => {
+					if (!connection?.active) return;
+					connection.active = false;
+					connection.cancel?.();
+					if ("state" in store) store.state.set({
+						status: "error",
+						error,
+						isConnected: false,
+						isUpdating: false,
+						isStale: false
+					});
+					value = PromiseWithState.reject(error);
+					notify();
+				});
+			},
+			updateIsConnected(isConnected) {
+				if (isConnected) whenConnected.resolve();
+				q(() => {
+					if (!connection?.active) return;
+					if ("state" in store) store.state.set("isConnected", isConnected);
+				});
+			},
+			close() {
+				if (connection?.active) store.invalidate();
+			}
+		};
+		connection = { active: true };
+		let _cancel = createConnection(actions);
+		connection.cancel = () => {
+			_cancel?.();
+			_cancel = void 0;
+		};
+		if (!connection.active) connection.cancel();
+		return whenConnected;
+	}
+	try {
+		value = store.getter({
+			signal: ac.signal,
+			use,
+			connect
+		});
+	} catch (error) {
+		value = PromiseWithState.reject(error);
+		if (connection) {
+			connection.active = false;
+			connection.cancel?.();
+			q.clear();
+		}
+	}
+	if (isPromise(value)) value.finally(() => whenExecuted.resolve()).catch(() => void 0);
+	else whenExecuted.resolve();
+	function check() {
+		for (const dep of deps) if (!require_propAccess.deepEqual(dep.store.get(), dep.value)) {
+			store.invalidate();
+			return;
+		}
+	}
+	function stop() {
+		cancelEffect();
+		whenExecuted.resolve();
+		whenConnected.resolve();
+		ac.abort();
+		if (connection) {
+			connection.active = false;
+			connection.cancel?.();
+			q.clear();
+		}
+	}
+	function invalidateDependencies(recursive) {
+		for (const dep of deps) dep.store.invalidate(recursive);
+	}
+	return {
+		get value() {
+			return value;
+		},
+		check,
+		stop,
+		invalidateDependencies
+	};
+}
+function staticValue(value) {
+	return {
+		value,
+		check: () => void 0,
+		stop: () => void 0,
+		invalidateDependencies: () => void 0
+	};
+}
+
+//#endregion
+//#region src/lib/makeSelector.ts
+function makeSelector(selector) {
+	if (!selector) return (x) => x;
+	if (selector instanceof Function) return selector;
+	return (x) => require_propAccess.get(x, selector);
+}
+
+//#endregion
+//#region src/lib/debounce.ts
+function debounce(action, options) {
+	const wait = typeof options === "object" && "wait" in options ? calcDuration(options.wait) : calcDuration(options);
+	const maxWait = typeof options === "object" && "maxWait" in options && options.maxWait !== void 0 ? calcDuration(options.maxWait) : void 0;
+	let run;
+	let timeout;
+	let timeoutStarted;
+	function flush() {
+		if (timeout !== void 0) clearTimeout(timeout);
+		run?.();
+	}
+	function cancel() {
+		if (timeout !== void 0) clearTimeout(timeout);
+		run = void 0;
+		timeout = void 0;
+		timeoutStarted = void 0;
+	}
+	function isScheduled() {
+		return timeout !== void 0;
+	}
+	function debounce$1(...args) {
+		const now = Date.now();
+		timeoutStarted ??= now;
+		const deadline = Math.min(now + wait, timeoutStarted + (maxWait ?? Number.POSITIVE_INFINITY));
+		if (timeout !== void 0) clearTimeout(timeout);
+		run = () => {
+			run = void 0;
+			timeout = void 0;
+			timeoutStarted = void 0;
+			action(...args);
+		};
+		timeout = setTimeout(run, deadline - now);
+	}
+	return Object.assign(debounce$1, {
+		flush,
+		cancel,
+		isScheduled
+	});
+}
+
+//#endregion
+//#region src/lib/disposable.ts
+function disposable(dispose) {
+	return Object.assign(dispose, Symbol.dispose ? { [Symbol.dispose]: dispose } : {});
+}
+
+//#endregion
+//#region src/lib/forwardError.ts
+function forwardError(error) {
+	setTimeout(() => {
+		throw error;
+	});
+}
+
+//#endregion
+//#region src/lib/promiseWithCancel.ts
+var PromiseCancelError = class extends Error {
+	constructor() {
+		super("cancelled");
+	}
+};
+var PromiseWithCancel = class PromiseWithCancel extends Promise {
+	constructor(executor) {
+		autobind(PromiseWithCancel);
+		const abortController = new AbortController();
+		super((resolve, reject) => {
+			executor(resolve, reject, abortController.signal);
+			abortController.signal.addEventListener("abort", () => {
+				reject(abortController.signal.reason);
+			});
+		});
+		this.abortController = abortController;
+	}
+	cancel(reason = new PromiseCancelError()) {
+		this.abortController.abort(reason);
+	}
+};
+
+//#endregion
+//#region src/lib/standardMethods.ts
+function createArrayAction(prop) {
+	return function arrayAction(...args) {
+		const newArray = this.get().slice();
+		const result = newArray[prop](...args);
+		this.set(newArray);
+		return result;
+	};
+}
+const arrayMethods = {
+	splice: /* @__PURE__ */ createArrayAction("splice"),
+	push: /* @__PURE__ */ createArrayAction("push"),
+	pop: /* @__PURE__ */ createArrayAction("pop"),
+	shift: /* @__PURE__ */ createArrayAction("shift"),
+	unshift: /* @__PURE__ */ createArrayAction("unshift"),
+	reverse: /* @__PURE__ */ createArrayAction("reverse"),
+	sort: /* @__PURE__ */ createArrayAction("sort")
+};
+const recordMethods = {
+	delete(key) {
+		const copy = { ...this.get() };
+		delete copy[key];
+		this.set(copy);
+	},
+	clear() {
+		this.set({});
+	}
+};
+const mapMethods = {
+	delete(key) {
+		const newMap = new Map(this.get());
+		const result = newMap.delete(key);
+		this.set(newMap);
+		return result;
+	},
+	clear() {
+		this.set(/* @__PURE__ */ new Map());
+	}
+};
+const setMethods = {
+	add(value) {
+		const newSet = new Set(this.get());
+		newSet.add(value);
+		this.set(newSet);
+	},
+	delete(value) {
+		const newSet = new Set(this.get());
+		newSet.delete(value);
+		this.set(newSet);
+	},
+	clear() {
+		this.set(/* @__PURE__ */ new Set());
+	}
+};
+
+//#endregion
+//#region src/lib/throttle.ts
+function throttle(action, duration) {
+	const ms = calcDuration(duration);
+	let t = 0;
+	let timeout;
+	return (...args) => {
+		if (timeout !== void 0) clearTimeout(timeout);
+		const dt = t + ms - Date.now();
+		if (dt <= 0) {
+			action(...args);
+			t = Date.now();
+			return;
+		}
+		timeout = setTimeout(() => {
+			action(...args);
+			t = Date.now();
+		}, dt);
+	};
+}
+
+//#endregion
+//#region src/core/store.ts
+function noop() {
+	return void 0;
+}
+var Store = class Store {
+	static addHook(hook) {
+		this.hooks ??= /* @__PURE__ */ new Set();
+		this.hooks.add(hook);
+		return disposable(() => this.hooks?.delete(hook));
+	}
+	constructor(getter, options = {}, derivedFrom) {
+		this.getter = getter;
+		this.options = options;
+		this.derivedFrom = derivedFrom;
+		this.listeners = /* @__PURE__ */ new Map();
+		this.effects = /* @__PURE__ */ new Map();
+		this.notifyId = {};
+		autobind(Store);
+		if (typeof getter !== "function") this.calculatedValue = this.defaultValue = staticValue(getter);
+		for (const hook of Store.hooks ?? []) hook.apply(this, [this]);
+		if (options.effect instanceof Function) this.addEffect(options.effect);
+		else if (options.effect) this.addEffect(options.effect.effect, options.effect.retain);
+	}
+	get() {
+		this.calculatedValue?.check();
+		if (!this.calculatedValue) this.calculatedValue = calculatedValue(this, this.notify);
+		return this.calculatedValue.value;
+	}
+	set(...args) {
+		const path = args.length > 1 ? args[0] : [];
+		let update = args.length > 1 ? args[1] : args[0];
+		if (update instanceof Function) {
+			const before = this.get();
+			const valueBefore = require_propAccess.get(before, path);
+			const valueAfter = update(valueBefore);
+			update = require_propAccess.set(before, path, valueAfter);
+		} else if (path.length > 0) update = require_propAccess.set(this.get(), path, update);
+		if (this.derivedFrom) {
+			this.derivedFrom.updater(update);
+			return;
+		}
+		this.calculatedValue?.stop();
+		this.calculatedValue = staticValue(update);
+		this.notify();
+	}
+	invalidate(recursive) {
+		if (recursive) this.calculatedValue?.invalidateDependencies(recursive);
+		this.calculatedValue?.stop();
+		this.calculatedValue = this.defaultValue;
+		this.notify();
+	}
+	subscribe(listener, options) {
+		const { passive, runNow = true, throttle: throttleOption, debounce: debounceOption, equals = this.options.equals ?? require_propAccess.deepEqual } = options ?? {};
+		let isSetup = false;
+		let previousValue;
+		let innerListener = () => {
+			if (!isSetup) return;
+			const value = passive ? this.calculatedValue : { value: this.get() };
+			if (!value) return;
+			if (previousValue && equals(value.value, previousValue.value)) return;
+			const _previousValue = previousValue?.value;
+			previousValue = this.calculatedValue && { value: this.calculatedValue?.value };
+			try {
+				listener.apply({ cancel }, [value.value, _previousValue]);
+			} catch (error) {
+				forwardError(error);
+			}
+		};
+		if (throttleOption) innerListener = throttle(innerListener, throttleOption);
+		else if (debounceOption) innerListener = debounce(innerListener, debounceOption);
+		this.listeners.set(innerListener, !passive);
+		const cancel = () => {
+			if (this.listeners.delete(innerListener) && !passive) this.onUnsubscribe();
+		};
+		if (!passive) this.onSubscribe();
+		isSetup = true;
+		if (runNow) {
+			innerListener();
+			if (!throttleOption && typeof debounceOption === "object" && "waitOnRunNow" in debounceOption && debounceOption.waitOnRunNow === false && "flush" in innerListener) innerListener.flush();
+		} else previousValue = passive ? this.calculatedValue && { value: this.calculatedValue.value } : { value: this.get() };
+		return disposable(cancel);
+	}
+	once(...args) {
+		const condition = args[0] instanceof Function ? args[0] : Boolean;
+		const options = args[0] instanceof Function ? args[1] : args[0];
+		return new PromiseWithCancel((resolve, reject, signal) => {
+			let stopped = false;
+			let timer;
+			const cancel = this.subscribe((value) => {
+				if (stopped || !condition(value)) return;
+				resolve(value);
+				stopped = true;
+				if (timer) clearTimeout(timer);
+				setTimeout(() => cancel());
+			}, { runNow: !!condition });
+			if (stopped) return;
+			signal.addEventListener("abort", cancel);
+			options?.signal?.addEventListener("abort", () => {
+				cancel();
+				reject(options.signal?.reason ?? /* @__PURE__ */ new Error("cancelled"));
+			});
+			if (options?.timeout !== void 0) timer = setTimeout(() => {
+				cancel();
+				reject(/* @__PURE__ */ new Error("timeout"));
+			}, calcDuration(options.timeout));
+		});
+	}
+	map(_selector, ...args) {
+		const updater = _selector instanceof Function ? args[0] : (value) => (state) => require_propAccess.set(state, _selector, value);
+		const selector = makeSelector(_selector);
+		const derivedFrom = {
+			store: this.derivedFrom ? this.derivedFrom.store : this,
+			selectors: this.derivedFrom ? [...this.derivedFrom.selectors, _selector] : [_selector],
+			updater: (value) => {
+				if (!updater) throw new TypeError("Can only update computed stores that either are derived from other stores using string selectors or have an updater function.");
+				let update = updater(value);
+				if (update instanceof Function) update = update(this.get());
+				if (this.derivedFrom) this.derivedFrom.updater(update);
+				else this.set(update);
+			}
+		};
+		return new Store(({ use }) => {
+			return selector(use(this));
+		}, void 0, derivedFrom);
+	}
+	/** Add an effect that will be executed when the store becomes active, which means when it has at least one subscriber.
+	* @param effect
+	* If there is already a subscriber, the effect will be executed immediately.
+	* Otherweise it will be executed as soon as the first subscription is created.
+	* Every time all subscriptions are removed and the first is created again, the effect will be executed again.
+	* @param retain
+	* If provided, delay tearing down effects when the last subscriber is removed. This is useful if a short gap in subscriber coverage is supposed to be ignored. E.g. when switching pages, the old page might unsubscribe, while the new page subscribes immediately after.
+	* @returns
+	* The effect can return a teardown callback, which will be executed when the last subscription is removed and potentially the ratain time has passed.
+	*/
+	addEffect(effect, retain = this.options.retain) {
+		this.effects.set(effect, {
+			handle: this.isActive() ? effect.apply(this, [this]) ?? noop : void 0,
+			retain: retain !== void 0 ? calcDuration(retain) : void 0
+		});
+		return disposable(() => {
+			const { handle, timeout } = this.effects.get(effect) ?? {};
+			handle?.();
+			if (timeout !== void 0) clearTimeout(timeout);
+			this.effects.delete(effect);
+		});
+	}
+	/** Return whether the store is currently active, which means whether it has at least one subscriber. */
+	isActive() {
+		return [...this.listeners.values()].some(Boolean);
+	}
+	onSubscribe() {
+		if ([...this.listeners.values()].filter(Boolean).length > 1) return;
+		for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
+			if (timeout !== void 0) clearTimeout(timeout);
+			this.effects.set(effect, {
+				handle: handle ?? effect.apply(this, [this]) ?? noop,
+				retain,
+				timeout: void 0
+			});
+		}
+	}
+	onUnsubscribe() {
+		if ([...this.listeners.values()].some(Boolean)) return;
+		for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
+			if (!retain) {
+				handle?.();
+				if (timeout !== void 0) clearTimeout(timeout);
+				this.effects.set(effect, {
+					handle: void 0,
+					retain,
+					timeout: void 0
+				});
+				continue;
+			}
+			const newTimeout = timeout ?? (handle ? setTimeout(() => {
+				handle();
+				this.effects.set(effect, {
+					handle: void 0,
+					retain,
+					timeout: void 0
+				});
+			}, retain) : void 0);
+			this.effects.set(effect, {
+				handle,
+				retain,
+				timeout: newTimeout
+			});
+		}
+	}
+	notify() {
+		const n = {};
+		this.notifyId = n;
+		const snapshot = [...this.listeners.entries()];
+		const active = snapshot.filter(([, active$1]) => active$1);
+		const passive = snapshot.filter(([, active$1]) => !active$1);
+		for (const [listener] of [...active, ...passive]) {
+			listener();
+			if (n !== this.notifyId) break;
+		}
+	}
+};
+function create(initialState, options) {
+	options = {
+		...createStore.defaultOptions,
+		...options
+	};
+	const store = new Store(initialState, options);
+	if (initialState instanceof Function) return store;
+	let methods = options?.methods;
+	if (initialState instanceof Map) methods = {
+		...mapMethods,
+		...methods
+	};
+	else if (initialState instanceof Set) methods = {
+		...setMethods,
+		...methods
+	};
+	else if (Array.isArray(initialState)) methods = {
+		...arrayMethods,
+		...methods
+	};
+	else if (require_propAccess.isObject(initialState)) methods = {
+		...recordMethods,
+		...methods
+	};
+	const boundMethods = Object.fromEntries(Object.entries(methods ?? {}).filter(([name]) => !(name in store)).map(([name, action]) => [name, action.bind(store)]));
+	return Object.assign(store, boundMethods);
+}
+const createStore = /* @__PURE__ */ Object.assign(create, { defaultOptions: { equals: require_propAccess.deepEqual } });
+
+//#endregion
+Object.defineProperty(exports, 'PromiseWithState', {
+  enumerable: true,
+  get: function () {
+    return PromiseWithState;
+  }
+});
+Object.defineProperty(exports, 'Store', {
+  enumerable: true,
+  get: function () {
+    return Store;
+  }
+});
+Object.defineProperty(exports, 'arrayMethods', {
+  enumerable: true,
+  get: function () {
+    return arrayMethods;
+  }
+});
+Object.defineProperty(exports, 'autobind', {
+  enumerable: true,
+  get: function () {
+    return autobind;
+  }
+});
+Object.defineProperty(exports, 'calcDuration', {
+  enumerable: true,
+  get: function () {
+    return calcDuration;
+  }
+});
+Object.defineProperty(exports, 'calculatedValue', {
+  enumerable: true,
+  get: function () {
+    return calculatedValue;
+  }
+});
+Object.defineProperty(exports, 'createStore', {
+  enumerable: true,
+  get: function () {
+    return createStore;
+  }
+});
+Object.defineProperty(exports, 'debounce', {
+  enumerable: true,
+  get: function () {
+    return debounce;
+  }
+});
+Object.defineProperty(exports, 'isPromise', {
+  enumerable: true,
+  get: function () {
+    return isPromise;
+  }
+});
+Object.defineProperty(exports, 'makeSelector', {
+  enumerable: true,
+  get: function () {
+    return makeSelector;
+  }
+});
+Object.defineProperty(exports, 'mapMethods', {
+  enumerable: true,
+  get: function () {
+    return mapMethods;
+  }
+});
+Object.defineProperty(exports, 'queue', {
+  enumerable: true,
+  get: function () {
+    return queue;
+  }
+});
+Object.defineProperty(exports, 'recordMethods', {
+  enumerable: true,
+  get: function () {
+    return recordMethods;
+  }
+});
+Object.defineProperty(exports, 'setMethods', {
+  enumerable: true,
+  get: function () {
+    return setMethods;
+  }
+});
+Object.defineProperty(exports, 'throttle', {
+  enumerable: true,
+  get: function () {
+    return throttle;
+  }
+});
+//# sourceMappingURL=store-BWMWEUpu.cjs.map