atom.io 0.46.9 → 0.46.11

package/dist/{chunk-CKcAJnC7.js → chunk-Dms8e946.js}

@@ -1,6 +1,6 @@
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
-var __export = (all, symbols) => {
+var __exportAll = (all, symbols) => {
 	let target = {};
 	for (var name in all) {
 		__defProp(target, name, {
@@ -15,4 +15,4 @@ var __export = (all, symbols) => {
 };
 
 //#endregion
-export { __export as t };
+export { __exportAll as t };

package/dist/eslint-plugin/index.js

@@ -1,4 +1,4 @@
-import { t as __export } from "../chunk-CKcAJnC7.js";
+import { t as __exportAll } from "../chunk-Dms8e946.js";
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
 //#region src/eslint-plugin/rules/exact-catch-types.ts
@@ -199,7 +199,7 @@ const explicitStateTypes = createRule({
 
 //#endregion
 //#region src/eslint-plugin/rules/index.ts
-var rules_exports = /* @__PURE__ */ __export({
+var rules_exports = /* @__PURE__ */ __exportAll({
 	exactCatchTypes: () => exactCatchTypes,
 	explicitStateTypes: () => explicitStateTypes
 });

package/dist/internal/index.js

@@ -1165,20 +1165,20 @@ var Store = class {
 				family.install(this);
 			}
 			const mutableHelpers = /* @__PURE__ */ new Set();
-			for (const [, atom] of store.atoms) {
-				if (mutableHelpers.has(atom.key)) continue;
-				atom.install(this);
-				if (atom.type === `mutable_atom`) {
-					const originalJsonToken = getJsonToken(store, atom);
-					const originalUpdateToken = getUpdateToken(atom);
+			for (const [, atom$1] of store.atoms) {
+				if (mutableHelpers.has(atom$1.key)) continue;
+				atom$1.install(this);
+				if (atom$1.type === `mutable_atom`) {
+					const originalJsonToken = getJsonToken(store, atom$1);
+					const originalUpdateToken = getUpdateToken(atom$1);
 					mutableHelpers.add(originalJsonToken.key);
 					mutableHelpers.add(originalUpdateToken.key);
 				}
 			}
-			for (const [, selector] of store.readonlySelectors) selector.install(this);
-			for (const [, selector] of store.writableSelectors) {
-				if (mutableHelpers.has(selector.key)) continue;
-				selector.install(this);
+			for (const [, selector$1] of store.readonlySelectors) selector$1.install(this);
+			for (const [, selector$1] of store.writableSelectors) {
+				if (mutableHelpers.has(selector$1.key)) continue;
+				selector$1.install(this);
 			}
 			for (const [, tx] of store.transactions) tx.install(this);
 			for (const [, timeline] of store.timelines) timeline.install(this);
@@ -1903,23 +1903,23 @@ function dispatchOrDeferStateUpdate(target, state, proto, stateIsNewlyCreated, f
 //#endregion
 //#region src/internal/set-state/set-atom.ts
 const UNSET = Symbol(`UNSET`);
-const setAtom = (target, atom, next) => {
+const setAtom = (target, atom$1, next) => {
 	let oldValue;
 	let newValue;
 	if (isFn(next)) {
-		const prev = readOrComputeValue(target, atom, `mut`);
+		const prev = readOrComputeValue(target, atom$1, `mut`);
 		oldValue = prev;
 		newValue = next(prev);
 	} else {
-		if (target.valueMap.has(atom.key)) oldValue = readFromCache(target, atom, `mut`);
-		else if (atom.type === `atom` && !isFn(atom.default)) oldValue = atom.default;
+		if (target.valueMap.has(atom$1.key)) oldValue = readFromCache(target, atom$1, `mut`);
+		else if (atom$1.type === `atom` && !isFn(atom$1.default)) oldValue = atom$1.default;
 		else oldValue = UNSET;
 		newValue = next;
 	}
-	target.logger.info(`⭐`, `atom`, atom.key, `setting value`, newValue);
-	newValue = writeToCache(target, atom, newValue);
-	markDone(target, atom.key);
-	evictDownstreamFromAtom(target, atom);
+	target.logger.info(`⭐`, `atom`, atom$1.key, `setting value`, newValue);
+	newValue = writeToCache(target, atom$1, newValue);
+	markDone(target, atom$1.key);
+	evictDownstreamFromAtom(target, atom$1);
 	if (oldValue === UNSET) return { newValue };
 	return {
 		oldValue,
@@ -1929,14 +1929,14 @@ const setAtom = (target, atom, next) => {
 
 //#endregion
 //#region src/internal/set-state/reset-atom-or-selector.ts
-function resetAtom(target, atom) {
-	switch (atom.type) {
-		case `mutable_atom`: return setAtom(target, atom, new atom.class());
+function resetAtom(target, atom$1) {
+	switch (atom$1.type) {
+		case `mutable_atom`: return setAtom(target, atom$1, new atom$1.class());
 		case `atom`: {
 			let def;
-			if (isFn(atom.default)) def = safeCompute(target, atom);
-			else def = atom.default;
-			return setAtom(target, atom, def);
+			if (isFn(atom$1.default)) def = safeCompute(target, atom$1);
+			else def = atom$1.default;
+			return setAtom(target, atom$1, def);
 		}
 	}
 }
@@ -1950,7 +1950,7 @@ function resetAtomOrSelector(target, state) {
 		case `writable_held_selector`:
 			{
 				const atoms = traceRootSelectorAtoms(target, state.key);
-				for (const atom of atoms.values()) dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom), false);
+				for (const atom$1 of atoms.values()) dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom$1), false);
 				const value = state.getFrom(target);
 				protoUpdate = {
 					oldValue: value,
@@ -1962,7 +1962,7 @@ function resetAtomOrSelector(target, state) {
 			{
 				const oldValue = safeCompute(target, state);
 				const atoms = traceRootSelectorAtoms(target, state.key);
-				for (const atom of atoms.values()) dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom), false);
+				for (const atom$1 of atoms.values()) dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom$1), false);
 				protoUpdate = {
 					oldValue,
 					newValue: safeCompute(target, state)
@@ -1988,26 +1988,26 @@ function resetInStore(store, ...params) {
 
 //#endregion
 //#region src/internal/set-state/set-selector.ts
-function setSelector(target, selector, next) {
+function setSelector(target, selector$1, next) {
 	let oldValue;
 	let newValue;
 	let constant;
-	const { type, key } = selector;
-	switch (selector.type) {
+	const { type, key } = selector$1;
+	switch (selector$1.type) {
 		case `writable_pure_selector`:
-			oldValue = readOrComputeValue(target, selector, `mut`);
+			oldValue = readOrComputeValue(target, selector$1, `mut`);
 			newValue = become(next, oldValue);
-			newValue = writeToCache(target, selector, newValue);
+			newValue = writeToCache(target, selector$1, newValue);
 			break;
 		case `writable_held_selector`:
-			constant = selector.const;
+			constant = selector$1.const;
 			become(next, constant);
 			oldValue = constant;
 			newValue = constant;
 	}
 	target.logger.info(`⭐`, type, key, `setting to`, newValue);
 	markDone(target, key);
-	selector.setSelf(newValue);
+	selector$1.setSelf(newValue);
 	return {
 		oldValue,
 		newValue
@@ -2112,8 +2112,8 @@ function traceRootSelectorAtoms(store, selectorKey, covered = /* @__PURE__ */ ne
 		if (covered.has(dependencyKey)) continue;
 		covered.add(dependencyKey);
 		if (isAtomKey(store, dependencyKey)) {
-			const atom = store.atoms.get(dependencyKey);
-			roots.set(atom.key, atom);
+			const atom$1 = store.atoms.get(dependencyKey);
+			roots.set(atom$1.key, atom$1);
 		} else dependencies.push(...getSelectorDependencyKeys(store, dependencyKey));
 	}
 	return roots;
@@ -2455,13 +2455,13 @@ const recallState = (store, state) => {
 
 //#endregion
 //#region src/internal/subscribe/subscribe-to-root-atoms.ts
-const subscribeToRootDependency = (target, selector, atom) => {
-	return atom.subject.subscribe(`${selector.type}:${selector.key}`, (atomChange) => {
-		target.logger.info(`📢`, selector.type, selector.key, `root`, atom.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
-		const oldValue = recallState(target, selector);
-		const newValue = readOrComputeValue(target, selector);
-		target.logger.info(`✨`, selector.type, selector.key, `went`, oldValue, `->`, newValue);
-		selector.subject.next({
+const subscribeToRootDependency = (target, selector$1, atom$1) => {
+	return atom$1.subject.subscribe(`${selector$1.type}:${selector$1.key}`, (atomChange) => {
+		target.logger.info(`📢`, selector$1.type, selector$1.key, `root`, atom$1.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
+		const oldValue = recallState(target, selector$1);
+		const newValue = readOrComputeValue(target, selector$1);
+		target.logger.info(`✨`, selector$1.type, selector$1.key, `went`, oldValue, `->`, newValue);
+		selector$1.subject.next({
 			newValue,
 			oldValue
 		});
@@ -2483,7 +2483,7 @@ function subscribeToState(store, token, key, handleUpdate) {
 	let updateHandler = safelyHandleUpdate;
 	if (isSelector) {
 		readOrComputeValue(store, state);
-		for (const [atomKey, atom] of traceRootSelectorAtoms(store, state.key)) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom));
+		for (const [atomKey, atom$1] of traceRootSelectorAtoms(store, state.key)) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom$1));
 		updateHandler = function updateRootsBeforeHandlingUpdate(update) {
 			const dependencies = traceRootSelectorAtoms(store, state.key);
 			for (const [previousRootKey, unsub] of rootSubs) if (dependencies.get(previousRootKey)) dependencies.delete(previousRootKey);
@@ -2491,7 +2491,7 @@ function subscribeToState(store, token, key, handleUpdate) {
 				unsub();
 				rootSubs.delete(previousRootKey);
 			}
-			for (const [atomKey, atom] of dependencies) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom));
+			for (const [atomKey, atom$1] of dependencies) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom$1));
 			safelyHandleUpdate(update);
 		};
 	}
@@ -2891,9 +2891,9 @@ function evictCachedValue(target, key) {
 
 //#endregion
 //#region src/internal/set-state/evict-downstream.ts
-function evictDownstreamFromAtom(store, atom) {
+function evictDownstreamFromAtom(store, atom$1) {
 	const target = newest(store);
-	const { key, type } = atom;
+	const { key, type } = atom$1;
 	const downstreamKeys = target.selectorAtoms.getRelatedKeys(key);
 	target.logger.info(`🧹`, type, key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
 	if (downstreamKeys) {
@@ -2971,9 +2971,9 @@ function createRegularAtom(store, options, family, internalRoles) {
 //#endregion
 //#region src/internal/atom/has-role.ts
 const INTERNAL_ROLES = [`tracker:signal`];
-function hasRole(atom, role) {
-	if (`internalRoles` in atom === false) return false;
-	return atom.internalRoles.includes(role);
+function hasRole(atom$1, role) {
+	if (`internalRoles` in atom$1 === false) return false;
+	return atom$1.internalRoles.includes(role);
 }
 
 //#endregion
@@ -2981,11 +2981,11 @@ function hasRole(atom, role) {
 function disposeAtom(store, atomToken) {
 	const target = newest(store);
 	const { key, family } = atomToken;
-	const atom = withdraw(target, atomToken);
+	const atom$1 = withdraw(target, atomToken);
 	if (!family) store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`);
 	else {
-		atom.cleanup?.();
-		const lastValue = store.valueMap.get(atom.key);
+		atom$1.cleanup?.();
+		const lastValue = store.valueMap.get(atom$1.key);
 		const subject = withdraw(store, getFamilyOfToken(store, atomToken)).subject;
 		const disposalEvent = {
 			type: `state_disposal`,
@@ -3009,8 +3009,8 @@ function disposeAtom(store, atomToken) {
 		store.logger.info(`🔥`, `atom`, key, `deleted`);
 		if (isChild && target.transactionMeta.phase === `building`) {
 			const mostRecentUpdate = target.transactionMeta.update.subEvents.at(-1);
-			const updateAlreadyCaptured = mostRecentUpdate?.type === `molecule_disposal` && mostRecentUpdate.values.some(([k]) => k === atom.family?.key);
-			const isTracker = hasRole(atom, `tracker:signal`);
+			const updateAlreadyCaptured = mostRecentUpdate?.type === `molecule_disposal` && mostRecentUpdate.values.some(([k]) => k === atom$1.family?.key);
+			const isTracker = hasRole(atom$1, `tracker:signal`);
 			if (!updateAlreadyCaptured && !isTracker) target.transactionMeta.update.subEvents.push(disposalEvent);
 		} else store.on.atomDisposal.next(atomToken);
 	}
@@ -3395,12 +3395,12 @@ function addAtomToTimeline(store, atomToken, tl) {
 	reduceReference(store, atomToken);
 	let maybeAtom = withdraw(store, atomToken);
 	if (maybeAtom.type === `mutable_atom`) maybeAtom = withdraw(store, getUpdateToken(maybeAtom));
-	const atom = maybeAtom;
+	const atom$1 = maybeAtom;
 	store.timelineTopics.set({
-		topicKey: atom.key,
+		topicKey: atom$1.key,
 		timelineKey: tl.key
 	}, { topicType: `atom` });
-	tl.subscriptions.set(atom.key, atom.subject.subscribe(`timeline`, function timelineCapturesAtomUpdate(update) {
+	tl.subscriptions.set(atom$1.key, atom$1.subject.subscribe(`timeline`, function timelineCapturesAtomUpdate(update) {
 		const target = newest(store);
 		const currentSelectorToken = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.token : null;
 		const currentSelectorTime = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.timestamp : null;
@@ -3414,11 +3414,11 @@ function addAtomToTimeline(store, atomToken, tl) {
 			const atomUpdate = {
 				checkpoint: true,
 				type: `atom_update`,
-				token: deposit(atom),
+				token: deposit(atom$1),
 				update,
 				timestamp
 			};
-			store.logger.info(`⌛`, `timeline`, tl.key, `got an atom_update to "${atom.key}"`);
+			store.logger.info(`⌛`, `timeline`, tl.key, `got an atom_update to "${atom$1.key}"`);
 			addToHistory(tl, atomUpdate);
 		}
 	}));
@@ -3432,7 +3432,7 @@ function addAtomFamilyToTimeline(store, atomFamilyToken, tl) {
 	tl.subscriptions.set(family.key, family.subject.subscribe(`timeline`, function timelineCapturesStateLifecycleEvent(creationOrDisposal) {
 		handleStateLifecycleEvent(store, creationOrDisposal, tl);
 	}));
-	for (const atom of store.atoms.values()) if (atom.family?.key === family.key) addAtomToTimeline(store, atom, tl);
+	for (const atom$1 of store.atoms.values()) if (atom$1.family?.key === family.key) addAtomToTimeline(store, atom$1, tl);
 }
 function joinTransaction(store, tl, txUpdateInProgress) {
 	const currentTxKey = txUpdateInProgress.token.key;