atom.io 0.36.0 → 0.36.1

package/dist/internal/index.js

@@ -454,21 +454,6 @@ var Future = class extends Promise {
 	}
 };
 
-//#endregion
-//#region src/internal/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(target, atom, origin) {
-	const originValue = origin.valueMap.get(atom.key);
-	const targetValue = target.valueMap.get(atom.key);
-	if (originValue !== targetValue) return targetValue;
-	if (originValue === void 0) return new atom.class();
-	origin.logger.info(`📃`, `atom`, atom.key, `copying`);
-	const jsonValue = originValue.toJSON();
-	const copiedValue = atom.class.fromJSON(jsonValue);
-	target.valueMap.set(atom.key, copiedValue);
-	new Tracker(atom, origin);
-	return copiedValue;
-}
-
 //#endregion
 //#region src/internal/transaction/is-root-store.ts
 function isRootStore(store) {
@@ -542,7 +527,7 @@ function evictDownStreamFromSelector(store, selector) {
 
 //#endregion
 //#region src/internal/caching.ts
-function cacheValue(target, key, value, subject) {
+function writeToCache(target, key, value, subject) {
 	const currentValue = target.valueMap.get(key);
 	if (currentValue instanceof Future && !currentValue.done) {
 		const future = currentValue;
@@ -559,7 +544,7 @@ function cacheValue(target, key, value, subject) {
 		future.then(function handleResolvedFuture(resolved) {
 			const current = target.valueMap.get(key);
 			if (current === future) {
-				cacheValue(target, key, resolved, subject);
+				writeToCache(target, key, resolved, subject);
 				const atom = target.atoms.get(key);
 				if (atom) {
 					openOperation(target, atom);
@@ -586,17 +571,31 @@ function cacheValue(target, key, value, subject) {
 	target.valueMap.set(key, value);
 	return value;
 }
-const readCachedValue = (state, target) => {
+/**
+* @param target - the newest layer of the store
+* @param state - the state to read from cache
+* @param mut - whether the value is intended to be mutable
+* @returns the state's current value
+*/
+function readFromCache(target, state, mut) {
 	target.logger.info(`📖`, state.type, state.key, `reading cached value`);
 	let value = target.valueMap.get(state.key);
-	if (state.type === `mutable_atom` && isChildStore(target)) {
+	const mayNeedToBeCopied = mut === `mut` && state.type === `mutable_atom` && isChildStore(target);
+	if (mayNeedToBeCopied) {
+		const mutableAtom$1 = state;
 		const { parent } = target;
-		const copiedValue = copyMutableIfNeeded(target, state, parent);
+		if (target.valueMap.hasOwn(mutableAtom$1.key)) return value;
+		const parentValue = parent.valueMap.get(mutableAtom$1.key);
+		target.logger.info(`📃`, `atom`, mutableAtom$1.key, `copying`);
+		const jsonValue = parentValue.toJSON();
+		const copiedValue = mutableAtom$1.class.fromJSON(jsonValue);
+		target.valueMap.set(mutableAtom$1.key, copiedValue);
+		new Tracker(mutableAtom$1, parent);
 		value = copiedValue;
 	}
 	return value;
-};
-const evictCachedValue = (target, key) => {
+}
+function evictCachedValue(target, key) {
 	const currentValue = target.valueMap.get(key);
 	if (currentValue instanceof Future) {
 		const selector = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
@@ -606,12 +605,12 @@ const evictCachedValue = (target, key) => {
 	if (target.operation.open) target.operation.prev.set(key, currentValue);
 	target.valueMap.delete(key);
 	target.logger.info(`🗑`, `state`, key, `evicted`);
-};
+}
 
 //#endregion
 //#region src/internal/get-state/read-or-compute-value.ts
-const readOrComputeValue = (target, state) => {
-	if (target.valueMap.has(state.key)) return readCachedValue(state, target);
+function readOrComputeValue(target, state, mut) {
+	if (target.valueMap.has(state.key)) return readFromCache(target, state, mut);
 	switch (state.type) {
 		case `readonly_held_selector`:
 		case `readonly_pure_selector`:
@@ -620,23 +619,21 @@ const readOrComputeValue = (target, state) => {
 			target.logger.info(`🧮`, state.type, state.key, `computing value`);
 			return state.get();
 		case `atom`: {
-			const def = state.default;
-			let defaultValue;
-			if (def instanceof Function) defaultValue = def();
-			else defaultValue = def;
-			const cachedValue = cacheValue(target, state.key, defaultValue, state.subject);
-			target.logger.info(`💁`, `atom`, state.key, `could not find cached value; using default`, defaultValue);
+			let def;
+			if (state.default instanceof Function) def = state.default();
+			else def = state.default;
+			const cachedValue = writeToCache(target, state.key, def, state.subject);
+			target.logger.info(`💁`, `atom`, state.key, `could not find cached value; using default`, def);
 			return cachedValue;
 		}
 		case `mutable_atom`: {
-			const Ctor = state.class;
-			const instance = new Ctor();
-			const cachedValue = cacheValue(target, state.key, instance, state.subject);
+			const instance = new state.class();
+			const cachedValue = writeToCache(target, state.key, instance, state.subject);
 			target.logger.info(`💁`, `mutable_atom`, state.key, `could not find cached value; using default`, instance);
 			return cachedValue;
 		}
 	}
-};
+}
 
 //#endregion
 //#region src/internal/subscribe/subscribe-to-root-atoms.ts
@@ -657,6 +654,14 @@ const subscribeToRootDependency = (target, selector, atom) => {
 //#region src/internal/set-state/become.ts
 const become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
 
+//#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);
+}
+
 //#endregion
 //#region src/internal/set-state/emit-update.ts
 const emitUpdate = (store, state, update) => {
@@ -676,16 +681,10 @@ const emitUpdate = (store, state, update) => {
 //#endregion
 //#region src/internal/set-state/set-atom.ts
 const setAtom = (target, atom, next) => {
-	const oldValue = readOrComputeValue(target, atom);
-	let newValue = oldValue;
-	if (atom.type === `mutable_atom` && isChildStore(target)) {
-		const { parent } = target;
-		const copiedValue = copyMutableIfNeeded(target, atom, parent);
-		newValue = copiedValue;
-	}
-	newValue = become(next)(newValue);
+	const oldValue = readOrComputeValue(target, atom, `mut`);
+	let newValue = become(next)(oldValue);
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue);
-	newValue = cacheValue(target, atom.key, newValue, atom.subject);
+	newValue = writeToCache(target, atom.key, newValue, atom.subject);
 	markDone(target, atom.key);
 	evictDownStream(target, atom);
 	const update = {
@@ -707,17 +706,12 @@ const setAtom = (target, atom, next) => {
 		if (atom.family) atomUpdate.family = atom.family;
 		target.transactionMeta.update.updates.push(atomUpdate);
 		target.logger.info(`📁`, `atom`, key, `stowed (`, update.oldValue, `->`, update.newValue, `)`);
-	} else if (atom.key.startsWith(`*`)) {
-		const mutableKey = atom.key.slice(1);
-		const mutableAtom$1 = target.atoms.get(mutableKey);
-		let transceiver = target.valueMap.get(mutableKey);
-		if (mutableAtom$1.type === `mutable_atom` && isChildStore(target)) {
-			const { parent } = target;
-			const copiedValue = copyMutableIfNeeded(target, mutableAtom$1, parent);
-			transceiver = copiedValue;
-		}
+	} else if (hasRole(atom, `tracker:signal`)) {
+		const key = atom.key.slice(1);
+		const mutable = target.atoms.get(key);
+		const transceiver = readOrComputeValue(target, mutable, `mut`);
 		const accepted = transceiver.do(update.newValue) === null;
-		if (accepted) evictDownStream(target, mutableAtom$1);
+		if (accepted === true) evictDownStream(target, mutable);
 	}
 };
 
@@ -823,9 +817,9 @@ function setIntoStore(store, ...params) {
 	if (params.length === 2) {
 		token = params[0];
 		value = params[1];
-		family = getFamilyOfToken(store, token) ?? null;
-		if (family) {
-			key = token.family ? parseJson(token.family.subKey) : null;
+		if (token.family) {
+			family = getFamilyOfToken(store, token);
+			key = parseJson(token.family.subKey);
 			token = findInStore(store, family, key);
 		}
 	} else {
@@ -842,7 +836,7 @@ function setIntoStore(store, ...params) {
 	}
 	const rejectionTime = openOperation(store, token);
 	if (rejectionTime) {
-		const unsubscribe = store.on.operationClose.subscribe(`waiting to set "${token.key}" at T-${rejectionTime}`, () => {
+		const unsubscribe = store.on.operationClose.subscribe(`waiting to set "${token.key}" at T-${rejectionTime}`, function waitUntilOperationCloseToSetState() {
 			unsubscribe();
 			store.logger.info(`🟢`, token.type, token.key, `resuming deferred setState from T-${rejectionTime}`);
 			setIntoStore(store, token, value);
@@ -967,7 +961,7 @@ const createReadonlyHeldSelector = (store, options, family) => {
 			find,
 			json
 		}, constant);
-		cacheValue(newest(store), key, constant, subject);
+		writeToCache(newest(store), key, constant, subject);
 		covered.clear();
 		return constant;
 	};
@@ -1008,7 +1002,7 @@ const createReadonlyPureSelector = (store, options, family) => {
 			find,
 			json
 		});
-		const cached = cacheValue(innerTarget, key, value, subject);
+		const cached = writeToCache(innerTarget, key, value, subject);
 		store.logger.info(`✨`, type, key, `=`, cached);
 		covered.clear();
 		return cached;
@@ -1586,7 +1580,7 @@ const createWritableHeldSelector = (store, options, family) => {
 		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
 		innerTarget.selectorAtoms.delete(key);
 		getFn(getterToolkit, constant);
-		cacheValue(innerTarget, key, constant, subject);
+		writeToCache(innerTarget, key, constant, subject);
 		store.logger.info(`✨`, type, key, `=`, constant);
 		covered.clear();
 		return constant;
@@ -1596,7 +1590,7 @@ const createWritableHeldSelector = (store, options, family) => {
 		const oldValue = getSelf(options.get, innerTarget);
 		const newValue = become(next)(oldValue);
 		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`);
-		cacheValue(innerTarget, key, newValue, subject);
+		writeToCache(innerTarget, key, newValue, subject);
 		markDone(innerTarget, key);
 		if (isRootStore(innerTarget)) subject.next({
 			newValue,
@@ -1642,7 +1636,7 @@ const createWritablePureSelector = (store, options, family) => {
 		for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
 		innerTarget.selectorAtoms.delete(key);
 		const value = getFn(getterToolkit);
-		const cached = cacheValue(innerTarget, key, value, subject);
+		const cached = writeToCache(innerTarget, key, value, subject);
 		store.logger.info(`✨`, type, key, `=`, cached);
 		covered.clear();
 		return value;
@@ -1652,7 +1646,7 @@ const createWritablePureSelector = (store, options, family) => {
 		const oldValue = getSelf(options.get, innerTarget);
 		const newValue = become(next)(oldValue);
 		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`);
-		cacheValue(innerTarget, options.key, newValue, subject);
+		writeToCache(innerTarget, options.key, newValue, subject);
 		markDone(innerTarget, options.key);
 		if (isRootStore(innerTarget)) subject.next({
 			newValue,
@@ -2233,30 +2227,33 @@ const subscribeToTransaction = (store, token, key, handleUpdate) => {
 * the tracker will update its own state to reflect the change.
 */
 var Tracker = class {
-	initializeState(mutableState, store) {
-		const latestUpdateStateKey = `*${mutableState.key}`;
-		store.atoms.delete(latestUpdateStateKey);
-		store.valueMap.delete(latestUpdateStateKey);
+	initializeSignalAtom(mutableState, store) {
+		const latestSignalStateKey = `*${mutableState.key}`;
+		store.atoms.delete(latestSignalStateKey);
+		store.valueMap.delete(latestSignalStateKey);
 		const familyMetaData = mutableState.family ? {
 			key: `*${mutableState.family.key}`,
 			subKey: mutableState.family.subKey
 		} : void 0;
-		const latestUpdateState = createRegularAtom(store, {
-			key: latestUpdateStateKey,
+		const latestSignalState = createRegularAtom(store, {
+			key: latestSignalStateKey,
 			default: null
-		}, familyMetaData);
-		if (store.parent?.valueMap.has(latestUpdateStateKey)) {
-			const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
-			store.valueMap.set(latestUpdateStateKey, parentValue);
+		}, familyMetaData, [`tracker:signal`]);
+		if (store.parent?.valueMap.has(latestSignalStateKey)) {
+			const parentValue = store.parent.valueMap.get(latestSignalStateKey);
+			store.valueMap.set(latestSignalStateKey, parentValue);
 		}
-		return latestUpdateState;
+		return latestSignalState;
 	}
 	unsubscribeFromInnerValue;
 	unsubscribeFromState;
-	captureSignalsFromCore(mutableState, latestUpdateState, target) {
-		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
+	captureSignalsFromCore(mutableState, latestSignalState, target) {
+		const stateKey = mutableState.key;
+		const storeName = target.config.name;
+		const storeStatus = isChildStore(target) ? target.transactionMeta.update.key : `main`;
+		const subscriptionKey = `tracker:${storeName}:${storeStatus}:${stateKey}`;
 		const trackerCapturesOutboundSignal = (update) => {
-			setIntoStore(target, latestUpdateState, update);
+			setIntoStore(target, latestSignalState, update);
 		};
 		const originalInnerValue = getFromStore(target, mutableState);
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(subscriptionKey, trackerCapturesOutboundSignal);
@@ -2267,10 +2264,10 @@ var Tracker = class {
 			}
 		}.bind(this));
 	}
-	supplySignalsToCore(mutableState, latestUpdateState, target) {
+	supplySignalsToCore(mutableState, latestSignalState, target) {
 		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-		subscribeToState(target, latestUpdateState, subscriptionKey, function trackerCapturesInboundSignal({ newValue, oldValue }) {
-			const timelineId = target.timelineTopics.getRelatedKey(latestUpdateState.key);
+		subscribeToState(target, latestSignalState, subscriptionKey, function trackerCapturesInboundSignal({ newValue, oldValue }) {
+			const timelineId = target.timelineTopics.getRelatedKey(latestSignalState.key);
 			if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
 				const unsubscribe = subscribeToTimeline(target, {
 					key: timelineId,
@@ -2289,7 +2286,10 @@ var Tracker = class {
 			const updateNumber = mutable.getUpdateNumber(newValue);
 			const eventOffset = updateNumber - mutable.cacheUpdateNumber;
 			if (newValue && eventOffset === 1) setIntoStore(target, mutableState, (transceiver) => (transceiver.do(newValue), transceiver));
-			else target.logger.info(`❌`, `mutable_atom`, mutableState.key, `could not be updated. Expected update number ${mutable.cacheUpdateNumber + 1}, but got ${updateNumber}`);
+			else {
+				const expected = mutable.cacheUpdateNumber + 1;
+				target.logger.info(`❌`, `mutable_atom`, mutableState.key, `could not be updated. Expected update number`, expected, `but got`, updateNumber);
+			}
 		});
 	}
 	mutableAtomToken;
@@ -2297,7 +2297,7 @@ var Tracker = class {
 	[Symbol.dispose];
 	constructor(mutableAtomToken, store) {
 		const target = newest(store);
-		const latestSignalToken = this.initializeState(mutableAtomToken, target);
+		const latestSignalToken = this.initializeSignalAtom(mutableAtomToken, target);
 		this.mutableAtomToken = mutableAtomToken;
 		this.latestSignalToken = latestSignalToken;
 		this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target);
@@ -2372,16 +2372,16 @@ function createMutableAtom(store, options, family) {
 //#region src/internal/mutable/tracker-family.ts
 var FamilyTracker = class {
 	trackers = /* @__PURE__ */ new Map();
-	latestUpdateAtoms;
+	latestSignalAtoms;
 	mutableAtoms;
 	constructor(mutableAtoms, store) {
-		const updateAtoms = createRegularAtomFamily(store, {
+		const latestSignalAtoms = createRegularAtomFamily(store, {
 			key: `*${mutableAtoms.key}`,
 			default: null
 		}, [`mutable`, `updates`]);
-		this.latestUpdateAtoms = withdraw(store, updateAtoms);
+		this.latestSignalAtoms = withdraw(store, latestSignalAtoms);
 		this.mutableAtoms = mutableAtoms;
-		this.mutableAtoms.subject.subscribe(`store=${store.config.name}::tracker-atom-family`, (event) => {
+		const trackerFamilyWatchesForCreationAndDisposalEvents = (event) => {
 			const { type, token } = event;
 			if (token.family) {
 				const key = parseJson(token.family.subKey);
@@ -2389,18 +2389,17 @@ var FamilyTracker = class {
 					case `state_creation`:
 						this.trackers.set(key, new Tracker(token, store));
 						break;
-					case `state_disposal`:
-						{
-							const tracker = this.trackers.get(key);
-							if (tracker) {
-								tracker[Symbol.dispose]();
-								this.trackers.delete(key);
-							}
+					case `state_disposal`: {
+						const tracker = this.trackers.get(key);
+						if (tracker) {
+							tracker[Symbol.dispose]();
+							this.trackers.delete(key);
 						}
-						break;
+					}
 				}
 			}
-		});
+		};
+		this.mutableAtoms.subject.subscribe(`store=${store.config.name}::tracker-atom-family`, trackerFamilyWatchesForCreationAndDisposalEvents);
 	}
 };
 
@@ -2683,7 +2682,7 @@ function withdraw(store, token) {
 
 //#endregion
 //#region src/internal/atom/create-regular-atom.ts
-function createRegularAtom(store, options, family) {
+function createRegularAtom(store, options, family, internalRoles) {
 	const type = `atom`;
 	const { key } = options;
 	store.logger.info(`🔨`, `atom`, key, `creating in store "${store.config.name}"`);
@@ -2704,6 +2703,7 @@ function createRegularAtom(store, options, family) {
 		subject
 	};
 	if (family) newAtom.family = family;
+	if (internalRoles) newAtom.internalRoles = internalRoles;
 	target.atoms.set(key, newAtom);
 	const token = deposit(newAtom);
 	if (options.effects) {
@@ -3547,5 +3547,5 @@ const timeTravel = (store, action, token) => {
 };
 
 //#endregion
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw };
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, INTERNAL_ROLES, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createJoin, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, hasRole, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markDone, newest, openOperation, prettyPrintTokenType, readFromCache, readOrComputeValue, recallState, registerSelector, resetAtomOrSelector, resetInStore, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootDependency, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceRootSelectorAtoms, updateSelectorAtoms, withdraw, writeToCache };
 //# sourceMappingURL=index.js.map