@systemfsoftware/xstate-store 0.0.0-bootstrap.0 → 5.0.0-beta.6

package/dist/store-BMZdYhoE.mjs

@@ -0,0 +1,755 @@
+import { t as isStoreValidationError } from "./validationError-Ndy-qk0W.mjs";
+// src/alien.ts
+function createReactiveSystem({ update, notify, unwatched }) {
+	return {
+		link,
+		unlink,
+		propagate,
+		checkDirty,
+		shallowPropagate
+	};
+	function link(dep, sub, version) {
+		const prevDep = sub.depsTail;
+		if (prevDep !== void 0 && prevDep.dep === dep) return;
+		const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+		if (nextDep !== void 0 && nextDep.dep === dep) {
+			nextDep.version = version;
+			sub.depsTail = nextDep;
+			return;
+		}
+		const prevSub = dep.subsTail;
+		if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
+		const newLink = sub.depsTail = dep.subsTail = {
+			version,
+			dep,
+			sub,
+			prevDep,
+			nextDep,
+			prevSub,
+			nextSub: void 0
+		};
+		if (nextDep !== void 0) nextDep.prevDep = newLink;
+		if (prevDep !== void 0) prevDep.nextDep = newLink;
+		else sub.deps = newLink;
+		if (prevSub !== void 0) prevSub.nextSub = newLink;
+		else dep.subs = newLink;
+	}
+	function unlink(link, sub = link.sub) {
+		const dep = link.dep;
+		const prevDep = link.prevDep;
+		const nextDep = link.nextDep;
+		const nextSub = link.nextSub;
+		const prevSub = link.prevSub;
+		if (nextDep !== void 0) nextDep.prevDep = prevDep;
+		else sub.depsTail = prevDep;
+		if (prevDep !== void 0) prevDep.nextDep = nextDep;
+		else sub.deps = nextDep;
+		if (nextSub !== void 0) nextSub.prevSub = prevSub;
+		else dep.subsTail = prevSub;
+		if (prevSub !== void 0) prevSub.nextSub = nextSub;
+		else if ((dep.subs = nextSub) === void 0) unwatched(dep);
+		return nextDep;
+	}
+	function propagate(link) {
+		let next = link.nextSub;
+		let stack;
+		top: do {
+			const sub = link.sub;
+			let flags = sub.flags;
+			if (!(flags & 60)) sub.flags = flags | 32;
+			else if (!(flags & 12)) flags = 0;
+			else if (!(flags & 4)) sub.flags = flags & -9 | 32;
+			else if (!(flags & 48) && isValidLink(link, sub)) {
+				sub.flags = flags | 40;
+				flags &= 1;
+			} else flags = 0;
+			if (flags & 2) notify(sub);
+			if (flags & 1) {
+				const subSubs = sub.subs;
+				if (subSubs !== void 0) {
+					const nextSub = (link = subSubs).nextSub;
+					if (nextSub !== void 0) {
+						stack = {
+							value: next,
+							prev: stack
+						};
+						next = nextSub;
+					}
+					continue;
+				}
+			}
+			if ((link = next) !== void 0) {
+				next = link.nextSub;
+				continue;
+			}
+			while (stack !== void 0) {
+				link = stack.value;
+				stack = stack.prev;
+				if (link !== void 0) {
+					next = link.nextSub;
+					continue top;
+				}
+			}
+			break;
+		} while (true);
+	}
+	function checkDirty(link, sub) {
+		let stack;
+		let checkDepth = 0;
+		let dirty = false;
+		top: do {
+			const dep = link.dep;
+			const flags = dep.flags;
+			if (sub.flags & 16) dirty = true;
+			else if ((flags & 17) === 17) {
+				if (update(dep)) {
+					const subs = dep.subs;
+					if (subs.nextSub !== void 0) shallowPropagate(subs);
+					dirty = true;
+				}
+			} else if ((flags & 33) === 33) {
+				if (link.nextSub !== void 0 || link.prevSub !== void 0) stack = {
+					value: link,
+					prev: stack
+				};
+				link = dep.deps;
+				sub = dep;
+				++checkDepth;
+				continue;
+			}
+			if (!dirty) {
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue;
+				}
+			}
+			while (checkDepth--) {
+				const firstSub = sub.subs;
+				const hasMultipleSubs = firstSub.nextSub !== void 0;
+				if (hasMultipleSubs) {
+					link = stack.value;
+					stack = stack.prev;
+				} else link = firstSub;
+				if (dirty) {
+					if (update(sub)) {
+						if (hasMultipleSubs) shallowPropagate(firstSub);
+						sub = link.sub;
+						continue;
+					}
+					dirty = false;
+				} else sub.flags &= -33;
+				sub = link.sub;
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue top;
+				}
+			}
+			return dirty;
+		} while (true);
+	}
+	function shallowPropagate(link) {
+		do {
+			const sub = link.sub;
+			const flags = sub.flags;
+			if ((flags & 48) === 32) {
+				sub.flags = flags | 16;
+				if ((flags & 6) === 2) notify(sub);
+			}
+		} while ((link = link.nextSub) !== void 0);
+	}
+	function isValidLink(checkLink, sub) {
+		let link = sub.depsTail;
+		while (link !== void 0) {
+			if (link === checkLink) return true;
+			link = link.prevDep;
+		}
+		return false;
+	}
+}
+let cycle$1 = 0;
+let queuedLength = 0;
+let activeSub$1;
+const queued = [];
+const { link: link$1, unlink: unlink$1, propagate: propagate$1, checkDirty: checkDirty$1, shallowPropagate: shallowPropagate$1 } = createReactiveSystem({
+	update(node) {
+		if (node.depsTail !== void 0) return updateComputed(node);
+		else return updateSignal(node);
+	},
+	notify(effect) {
+		let insertIndex = queuedLength;
+		let firstInsertedIndex = insertIndex;
+		do {
+			queued[insertIndex++] = effect;
+			effect.flags &= -3;
+			effect = effect.subs?.sub;
+			if (effect === void 0 || !(effect.flags & 2)) break;
+		} while (true);
+		queuedLength = insertIndex;
+		while (firstInsertedIndex < --insertIndex) {
+			const left = queued[firstInsertedIndex];
+			queued[firstInsertedIndex++] = queued[insertIndex];
+			queued[insertIndex] = left;
+		}
+	},
+	unwatched(node) {
+		if (!(node.flags & 1)) effectScopeOper.call(node);
+		else if (node.depsTail !== void 0) {
+			node.depsTail = void 0;
+			node.flags = 17;
+			purgeDeps$1(node);
+		}
+	}
+});
+function setActiveSub(sub) {
+	const prevSub = activeSub$1;
+	activeSub$1 = sub;
+	return prevSub;
+}
+function updateComputed(c) {
+	++cycle$1;
+	c.depsTail = void 0;
+	c.flags = 5;
+	const prevSub = setActiveSub(c);
+	try {
+		const oldValue = c.value;
+		return oldValue !== (c.value = c.getter(oldValue));
+	} finally {
+		activeSub$1 = prevSub;
+		c.flags &= -5;
+		purgeDeps$1(c);
+	}
+}
+function updateSignal(s) {
+	s.flags = 1;
+	return s.currentValue !== (s.currentValue = s.pendingValue);
+}
+function effectScopeOper() {
+	this.depsTail = void 0;
+	this.flags = 0;
+	purgeDeps$1(this);
+	const sub = this.subs;
+	if (sub !== void 0) unlink$1(sub);
+}
+function purgeDeps$1(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink$1(dep, sub);
+}
+// src/atom.ts
+/** Returns `true` if `value` is an atom (has `get` and `subscribe` methods). */
+function isAtom(value) {
+	return typeof value === "object" && value !== null && typeof value.get === "function" && typeof value.subscribe === "function";
+}
+const queuedEffects = [];
+let cycle = 0;
+const { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
+	update(atom) {
+		return atom._update();
+	},
+	notify(effect) {
+		queuedEffects[queuedEffectsLength++] = effect;
+		effect.flags &= -3;
+	},
+	unwatched(atom) {
+		if (atom.depsTail !== void 0) {
+			atom.depsTail = void 0;
+			atom.flags = 17;
+			purgeDeps(atom);
+		}
+	}
+});
+let notifyIndex = 0;
+let queuedEffectsLength = 0;
+let activeSub;
+function purgeDeps(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink(dep, sub);
+}
+function flush() {
+	let didThrow = false;
+	let firstError;
+	try {
+		while (notifyIndex < queuedEffectsLength) {
+			const effect = queuedEffects[notifyIndex];
+			queuedEffects[notifyIndex++] = void 0;
+			try {
+				effect.notify();
+			} catch (error) {
+				effect.flags |= 10;
+				if (!didThrow) {
+					didThrow = true;
+					firstError = error;
+				}
+			}
+		}
+	} finally {
+		notifyIndex = 0;
+		queuedEffectsLength = 0;
+	}
+	if (didThrow) throw firstError;
+}
+function updateAsyncAtom(atom, nextValue, compare = Object.is) {
+	if (!compare(atom._snapshot, nextValue)) {
+		atom._snapshot = nextValue;
+		const subs = atom.subs;
+		if (subs !== void 0) {
+			propagate(subs);
+			shallowPropagate(subs);
+			flush();
+		}
+	}
+}
+/**
+* Creates a read-only atom whose value is loaded from an async getter.
+*
+* The getter receives an `AbortSignal`; when the async atom recomputes, the
+* previous signal is aborted and stale resolutions are ignored.
+*/
+function createAsyncAtom(getValue, options) {
+	const ref = {};
+	let currentController;
+	let currentRunId = 0;
+	const atom = createAtom(() => {
+		currentController?.abort();
+		const controller = new AbortController();
+		const runId = ++currentRunId;
+		currentController = controller;
+		getValue({ signal: controller.signal }).then((data) => {
+			if (runId !== currentRunId || controller.signal.aborted) return;
+			updateAsyncAtom(ref.current, {
+				status: "done",
+				data
+			}, options?.compare);
+		}, (error) => {
+			if (runId !== currentRunId || controller.signal.aborted) return;
+			updateAsyncAtom(ref.current, {
+				status: "error",
+				error
+			}, options?.compare);
+		});
+		return { status: "pending" };
+	}, options);
+	ref.current = atom;
+	return atom;
+}
+function createAtom(valueOrFn, optionsOrInput) {
+	const isComputed = typeof valueOrFn === "function";
+	const getter = valueOrFn;
+	const atom = {
+		_snapshot: isComputed ? void 0 : valueOrFn,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: isComputed ? 0 : 1,
+		get() {
+			if (activeSub !== void 0) link(atom, activeSub, cycle);
+			return atom._snapshot;
+		},
+		subscribe(observerOrFn) {
+			const observer = typeof observerOrFn === "function" ? { next: observerOrFn } : observerOrFn;
+			const observed = { current: false };
+			const e = effect(() => {
+				atom.get();
+				if (!observed.current) observed.current = true;
+				else {
+					const prevSub = activeSub;
+					activeSub = void 0;
+					try {
+						observer.next?.(atom._snapshot);
+					} finally {
+						activeSub = prevSub;
+					}
+					atom.get();
+				}
+			});
+			return { unsubscribe: () => {
+				e.stop();
+			} };
+		},
+		_update(getValue) {
+			const prevSub = activeSub;
+			const compare = optionsOrInput?.compare ?? Object.is;
+			activeSub = isComputed ? atom : void 0;
+			++cycle;
+			atom.depsTail = void 0;
+			if (isComputed) atom.flags = 5;
+			try {
+				const oldValue = atom._snapshot;
+				const newValue = typeof getValue === "function" ? getValue(oldValue) : getValue === void 0 && isComputed ? getter(oldValue) : getValue;
+				if (oldValue === void 0 || !compare(oldValue, newValue)) {
+					atom._snapshot = newValue;
+					return true;
+				}
+				return false;
+			} finally {
+				activeSub = prevSub;
+				if (isComputed) atom.flags &= -5;
+				purgeDeps(atom);
+			}
+		}
+	};
+	if (isComputed) {
+		atom.flags = 17;
+		atom.get = function() {
+			const flags = atom.flags;
+			if (flags & 16 || flags & 32 && checkDirty(atom.deps, atom)) {
+				if (atom._update()) {
+					const subs = atom.subs;
+					if (subs !== void 0) shallowPropagate(subs);
+				}
+			} else if (flags & 32) atom.flags = flags & -33;
+			if (activeSub !== void 0) link(atom, activeSub, cycle);
+			return atom._snapshot;
+		};
+	} else atom.set = function(valueOrFn) {
+		if (atom._update(valueOrFn)) {
+			const subs = atom.subs;
+			if (subs !== void 0) {
+				propagate(subs);
+				shallowPropagate(subs);
+				flush();
+			}
+		}
+	};
+	return atom;
+}
+function createAtomConfig(initialValueOrFn, options) {
+	return { createAtom(input) {
+		return createAtom(typeof initialValueOrFn === "function" ? initialValueOrFn(input) : initialValueOrFn, options);
+	} };
+}
+/** Creates an atom whose updates are handled by a reducer function. */
+function createReducerAtom(initialValue, reducer, options) {
+	const atom = createAtom(initialValue, options);
+	return {
+		get: atom.get.bind(atom),
+		subscribe: atom.subscribe.bind(atom),
+		send(event) {
+			const prevSub = activeSub;
+			activeSub = void 0;
+			let nextState;
+			try {
+				nextState = reducer(atom.get(), event);
+			} finally {
+				activeSub = prevSub;
+			}
+			atom.set(nextState);
+		}
+	};
+}
+function effect(fn) {
+	const run = () => {
+		const prevSub = activeSub;
+		activeSub = effectObj;
+		++cycle;
+		effectObj.depsTail = void 0;
+		effectObj.flags = 6;
+		try {
+			return fn();
+		} finally {
+			activeSub = prevSub;
+			effectObj.flags &= -5;
+			purgeDeps(effectObj);
+		}
+	};
+	const effectObj = {
+		deps: void 0,
+		depsTail: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		flags: 6,
+		notify() {
+			const flags = this.flags;
+			if (flags & 16 || flags & 32 && checkDirty(this.deps, this)) run();
+			else this.flags = 2;
+		},
+		stop() {
+			this.flags = 0;
+			this.depsTail = void 0;
+			purgeDeps(this);
+		}
+	};
+	run();
+	return effectObj;
+}
+// src/store.ts
+const symbolObservable = (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
+const isDevelopment = globalThis.process?.env?.NODE_ENV !== "production";
+const UNSUPPORTED_ASYNC_TRANSITION_ERROR = "Async transition unsupported here";
+function isPromiseLike(value) {
+	return !!value && typeof value.then === "function";
+}
+function ignorePromiseRejection(value) {
+	Promise.resolve(value).catch(() => {});
+}
+function createTransitionResult(snapshot, effects, allowed) {
+	const result = [snapshot, effects];
+	if (allowed !== void 0) result._allowed = allowed;
+	return result;
+}
+function toEvent(eventType, payload) {
+	return payload === void 0 ? { type: eventType } : {
+		...payload,
+		type: eventType
+	};
+}
+function createEnqueueObject(effects, trigger) {
+	return {
+		emit: new Proxy({}, { get: (_, eventType) => {
+			return (payload) => {
+				effects.push(toEvent(eventType, payload));
+			};
+		} }),
+		trigger: new Proxy({}, { get: (_, eventType) => {
+			return (payload) => {
+				trigger?.(toEvent(eventType, payload));
+			};
+		} }),
+		effect: (fn) => {
+			effects.push(fn);
+		}
+	};
+}
+function getDistinctEventTypes(eventTypes) {
+	return [...new Set(eventTypes)];
+}
+function assertNoInternalEventTypeCollisions(existingEventTypes, internalEventTypes, extensionName) {
+	if (!isDevelopment || !existingEventTypes?.length) return;
+	const existingEventTypeSet = new Set(existingEventTypes);
+	const collisions = getDistinctEventTypes(internalEventTypes.filter((eventType) => existingEventTypeSet.has(eventType)));
+	if (collisions.length === 0) return;
+	throw new Error(`The "${extensionName}" store extension uses reserved event type(s): ${collisions.map((eventType) => `"${eventType}"`).join(", ")}. Rename the conflicting store event(s) before applying the extension.`);
+}
+function appendInternalEventTypes(existingEventTypes, internalEventTypes, extensionName) {
+	assertNoInternalEventTypeCollisions(existingEventTypes, internalEventTypes, extensionName);
+	return getDistinctEventTypes([...existingEventTypes ?? [], ...internalEventTypes]);
+}
+function createConcreteTrigger(eventTypes, send) {
+	const trigger = {};
+	for (const eventType of eventTypes) trigger[eventType] = ((payload) => {
+		send(toEvent(eventType, payload));
+	});
+	return trigger;
+}
+function createConcreteCan(eventTypes, can) {
+	const canObject = {};
+	for (const eventType of eventTypes) canObject[eventType] = ((payload) => {
+		return can(toEvent(eventType, payload));
+	});
+	return canObject;
+}
+function attachSelectors(store, selectorsConfig) {
+	const selectors = {};
+	for (const [key, selector] of Object.entries(selectorsConfig)) selectors[key] = store.select(selector);
+	const originalWith = store.with;
+	const storeWithSelectors = store;
+	storeWithSelectors.selectors = selectors;
+	storeWithSelectors.with = ((extension) => attachSelectors(originalWith(extension), selectorsConfig));
+	return storeWithSelectors;
+}
+function createStoreCore(logic) {
+	let listeners;
+	let inspectionObservers;
+	const initialSnapshot = logic.getInitialSnapshot();
+	let currentSnapshot = initialSnapshot;
+	const atom = createAtom(currentSnapshot);
+	const eventTypes = logic.eventTypes;
+	const schemas = logic.schemas;
+	const emit = (ev) => {
+		listeners?.get(ev.type)?.forEach((listener) => listener(ev));
+		listeners?.get("*")?.forEach((listener) => listener(ev));
+	};
+	const transition = logic.transition;
+	const notifyInspection = (event, snapshot) => {
+		inspectionObservers?.forEach((observer) => {
+			observer.next?.({
+				type: "@xstate.transition",
+				event,
+				snapshot,
+				actorRef: store,
+				rootId: store.sessionId
+			});
+		});
+	};
+	const send = (event) => {
+		receive(event);
+	};
+	function receive(event) {
+		const [nextSnapshot, effects] = transition(currentSnapshot, event);
+		currentSnapshot = nextSnapshot;
+		atom.set(nextSnapshot);
+		notifyInspection(event, nextSnapshot);
+		let committed = false;
+		const effectEnqueue = {
+			trigger,
+			send,
+			getSnapshot: () => committed ? currentSnapshot : nextSnapshot
+		};
+		for (const effect of effects) if (typeof effect === "function") effect(effectEnqueue);
+		else emit(effect);
+		committed = true;
+	}
+	const trigger = eventTypes && eventTypes.length > 0 ? createConcreteTrigger(eventTypes, (event) => store.send(event)) : new Proxy({}, { get: (_, eventType) => {
+		return (payload) => {
+			send(toEvent(eventType, payload));
+		};
+	} });
+	const can = eventTypes && eventTypes.length > 0 ? createConcreteCan(eventTypes, (event) => canTransition(event)) : new Proxy({}, { get: (_, eventType) => {
+		return (payload) => {
+			return canTransition(toEvent(eventType, payload));
+		};
+	} });
+	function canTransition(event) {
+		const snapshot = currentSnapshot;
+		try {
+			const result = transition(snapshot, event);
+			return result._allowed ?? (result[0] !== snapshot || result[1].length > 0);
+		} catch (error) {
+			if (isStoreValidationError(error)) return false;
+			throw error;
+		}
+	}
+	const store = {
+		on(emittedEventType, handler) {
+			if (!listeners) listeners = /* @__PURE__ */ new Map();
+			let eventListeners = listeners.get(emittedEventType);
+			if (!eventListeners) {
+				eventListeners = /* @__PURE__ */ new Set();
+				listeners.set(emittedEventType, eventListeners);
+			}
+			eventListeners.add(handler);
+			return { unsubscribe() {
+				eventListeners.delete(handler);
+			} };
+		},
+		transition(state, event) {
+			return transition(state, event);
+		},
+		schemas,
+		sessionId: uniqueId(),
+		send,
+		getSnapshot() {
+			return currentSnapshot;
+		},
+		get() {
+			return atom.get();
+		},
+		getInitialSnapshot() {
+			return initialSnapshot;
+		},
+		subscribe: atom.subscribe.bind(atom),
+		[symbolObservable]() {
+			return this;
+		},
+		inspect: (observerOrFn) => {
+			const observer = typeof observerOrFn === "function" ? { next: observerOrFn } : observerOrFn;
+			(inspectionObservers ??= /* @__PURE__ */ new Set()).add(observer);
+			observer.next?.({
+				type: "@xstate.transition",
+				event: { type: "@xstate.init" },
+				snapshot: currentSnapshot,
+				actorRef: store,
+				rootId: store.sessionId
+			});
+			return { unsubscribe() {
+				return inspectionObservers?.delete(observer);
+			} };
+		},
+		trigger,
+		can,
+		select(selector, equalityFn = Object.is) {
+			return createAtom(() => selector(store.get().context), { compare: equalityFn });
+		},
+		with(extension) {
+			return createStoreCore(extension(logic));
+		}
+	};
+	return store;
+}
+function createStore(definitionOrLogic) {
+	if ("transition" in definitionOrLogic) return createStoreCore(definitionOrLogic);
+	const transition = createStoreTransition(definitionOrLogic.on);
+	return createStoreCore({
+		eventTypes: definitionOrLogic.schemas?.events ? Object.keys(definitionOrLogic.schemas.events) : Object.keys(definitionOrLogic.on),
+		schemas: definitionOrLogic.schemas,
+		warn: definitionOrLogic.warn,
+		getInitialSnapshot: () => ({
+			status: "active",
+			context: definitionOrLogic.context,
+			output: void 0,
+			error: void 0
+		}),
+		transition
+	});
+}
+function _createStoreConfig(definition) {
+	return definition;
+}
+const createStoreConfig = _createStoreConfig;
+function createStoreLogic(config) {
+	return { createStore(input) {
+		const context = typeof config.context === "function" ? config.context(input) : config.context;
+		const store = createStore({
+			...config,
+			context
+		});
+		return config.selectors ? attachSelectors(store, config.selectors) : store;
+	} };
+}
+/**
+* Creates a store transition function that handles state updates based on
+* events.
+*
+* @param transitions - An object mapping event types to transition functions
+* @param producer - Optional producer function (e.g., Immer's produce) for
+*   immutable updates
+* @returns A transition function that takes a snapshot and event and returns a
+*   new snapshot with effects
+*/
+function createStoreTransition(transitions, producer) {
+	const storeTransition = (snapshot, event) => {
+		let currentSnapshot = snapshot;
+		const effects = [];
+		const pendingEvents = [event];
+		let allowed = false;
+		for (let index = 0; index < pendingEvents.length; index++) {
+			const currentEvent = pendingEvents[index];
+			if (currentEvent === void 0) continue;
+			const currentContext = currentSnapshot.context;
+			const assigner = transitions?.[currentEvent.type];
+			let producerAssignerResult;
+			let assignerResult = void 0;
+			const effectsLength = effects.length;
+			if (!assigner) continue;
+			const enqueue = createEnqueueObject(effects, (triggeredEvent) => {
+				allowed = true;
+				pendingEvents.push(triggeredEvent);
+			});
+			const nextContext = producer ? producer(currentContext, (draftContext) => producerAssignerResult = assigner(draftContext, currentEvent, enqueue)) : (assignerResult = assigner(currentContext, currentEvent, enqueue)) === void 0 ? currentContext : assignerResult;
+			if (isPromiseLike(producer ? producerAssignerResult : nextContext)) {
+				ignorePromiseRejection(producer ? producerAssignerResult : nextContext);
+				throw new Error(UNSUPPORTED_ASYNC_TRANSITION_ERROR);
+			}
+			allowed ||= producer ? nextContext !== currentContext || effects.length > effectsLength : assignerResult !== void 0 || effects.length > effectsLength;
+			if (nextContext !== currentContext) currentSnapshot = {
+				...currentSnapshot,
+				context: nextContext
+			};
+		}
+		return createTransitionResult(currentSnapshot, effects, allowed);
+	};
+	return storeTransition;
+}
+/**
+* Generates a unique 6-character identifier.
+*
+* @returns A random string identifier
+*/
+function uniqueId() {
+	return Math.random().toString(36).slice(6);
+}
+export { createStoreConfig as a, createAsyncAtom as c, createReducerAtom as d, isAtom as f, createStore as i, createAtom as l, assertNoInternalEventTypeCollisions as n, createStoreLogic as o, createEnqueueObject as r, createStoreTransition as s, appendInternalEventTypes as t, createAtomConfig as u };