atom.io 0.39.0 → 0.40.0

package/dist/internal/index.js

@@ -663,7 +663,8 @@ function openOperation(store, token) {
 		done: /* @__PURE__ */ new Set(),
 		prev: /* @__PURE__ */ new Map(),
 		timestamp: Date.now(),
-		token
+		token,
+		subEvents: []
 	};
 	store.logger.info(`⭕`, token.type, token.key, `operation start in store "${store.config.name}"${isChildStore(store) ? ` ${store.transactionMeta.phase} "${store.transactionMeta.update.token.key}"` : ``}`);
 	return store;
@@ -798,6 +799,14 @@ function evictCachedValue(target, key) {
 	target.logger.info(`🗑`, `state`, key, `evicted`);
 }
 
+//#endregion
+//#region src/internal/is-fn.ts
+const NON_CTOR_FN_REGEX = /^\[object (?:Async|Generator|AsyncGenerator)?Function\]$/;
+function isFn(input) {
+	const protoString = Object.prototype.toString.call(input);
+	return NON_CTOR_FN_REGEX.test(protoString);
+}
+
 //#endregion
 //#region src/internal/get-state/read-or-compute-value.ts
 function readOrComputeValue(target, state, mut) {
@@ -813,7 +822,7 @@ function readOrComputeValue(target, state, mut) {
 			return state.getFrom(target);
 		case `atom`: {
 			let def;
-			if (state.default instanceof Function) {
+			if (isFn(state.default)) {
 				def = state.default();
 				target.logger.info(`✨`, state.type, key, `computed default`, def);
 			} else {
@@ -893,18 +902,24 @@ function actUponStore(store, token, id) {
 
 //#endregion
 //#region src/internal/set-state/become.ts
-const become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
+function become(nextVersionOfThing, originalThing) {
+	if (isFn(nextVersionOfThing)) return nextVersionOfThing(originalThing);
+	return nextVersionOfThing;
+}
 
 //#endregion
 //#region src/internal/set-state/set-atom.ts
 const setAtom = (target, atom, next) => {
 	const oldValue = readOrComputeValue(target, atom, `mut`);
-	let newValue = become(next)(oldValue);
+	let newValue = become(next, oldValue);
 	target.logger.info(`⭐`, `atom`, atom.key, `setting value`, newValue);
 	newValue = writeToCache(target, atom, newValue);
 	markDone(target, atom.key);
 	evictDownstreamFromAtom(target, atom);
-	return [oldValue, newValue];
+	return {
+		oldValue,
+		newValue
+	};
 };
 
 //#endregion
@@ -914,7 +929,7 @@ function resetAtom(target, atom) {
 		case `mutable_atom`: return setAtom(target, atom, new atom.class());
 		case `atom`: {
 			let def = atom.default;
-			if (def instanceof Function) def = def();
+			if (isFn(def)) def = def();
 			return setAtom(target, atom, def);
 		}
 	}
@@ -936,7 +951,10 @@ function resetAtomOrSelector(target, state) {
 					dispatchOrDeferStateUpdate(target, state, rootProtoUpdate, false);
 				}
 				const newValue = state.getFrom(target);
-				protoUpdate = [oldValue, newValue];
+				protoUpdate = {
+					oldValue,
+					newValue
+				};
 			}
 			break;
 	}
@@ -975,20 +993,23 @@ function setSelector(target, selector, next) {
 	const { type, key } = selector;
 	switch (selector.type) {
 		case `writable_pure_selector`:
-			oldValue = selector.getFrom(target);
-			newValue = become(next)(oldValue);
-			writeToCache(target, selector, newValue);
+			oldValue = readOrComputeValue(target, selector, `mut`);
+			newValue = become(next, oldValue);
+			newValue = writeToCache(target, selector, newValue);
 			break;
 		case `writable_held_selector`:
 			constant = selector.const;
-			become(next)(constant);
+			become(next, constant);
 			oldValue = constant;
 			newValue = constant;
 	}
 	target.logger.info(`⭐`, type, key, `setting to`, newValue);
 	markDone(target, key);
 	selector.setSelf(newValue);
-	return [oldValue, newValue];
+	return {
+		oldValue,
+		newValue
+	};
 }
 
 //#endregion
@@ -1247,9 +1268,10 @@ function ingestMoleculeTransferEvent(store, event, applying) {
 //#region src/internal/events/ingest-selector-update.ts
 function ingestSelectorUpdateEvent(store, selectorUpdate, applying) {
 	let updates;
-	if (applying === `newValue`) updates = selectorUpdate.atomUpdates;
-	else updates = selectorUpdate.atomUpdates.toReversed();
-	for (const atomUpdate of updates) ingestAtomUpdateEvent(store, atomUpdate, applying);
+	if (applying === `newValue`) updates = selectorUpdate.subEvents;
+	else updates = selectorUpdate.subEvents.toReversed();
+	for (const atomUpdate of updates) if (atomUpdate.type === `state_creation`) ingestCreationEvent(store, atomUpdate, applying);
+	else ingestAtomUpdateEvent(store, atomUpdate, applying);
 }
 
 //#endregion
@@ -1326,7 +1348,7 @@ function applyTransaction(store, output) {
 	parent.child = null;
 	parent.on.transactionApplying.next(child.transactionMeta);
 	const { subEvents: updates } = child.transactionMeta.update;
-	store.logger.info(`🛄`, `transaction`, child.transactionMeta.update.token.key, `Applying transaction with ${updates.length} updates:`, updates);
+	store.logger.info(`🛄`, `transaction`, child.transactionMeta.update.token.key, `applying ${updates.length} subEvents:`, updates);
 	ingestTransactionOutcomeEvent(parent, child.transactionMeta.update, `newValue`);
 	if (isRootStore(parent)) {
 		setEpochNumberOfAction(parent, child.transactionMeta.update.token.key, child.transactionMeta.update.epoch);
@@ -1335,7 +1357,7 @@ function applyTransaction(store, output) {
 			type: `transaction`
 		});
 		myTransaction?.subject.next(child.transactionMeta.update);
-		store.logger.info(`🛬`, `transaction`, child.transactionMeta.update.token.key, `Finished applying transaction.`);
+		store.logger.info(`🛬`, `transaction`, child.transactionMeta.update.token.key, `applied`);
 	} else if (isChildStore(parent)) parent.transactionMeta.update.subEvents.push(child.transactionMeta.update);
 	parent.on.transactionApplying.next(null);
 }
@@ -1421,7 +1443,7 @@ const buildTransaction = (store, token, params, id) => {
 	};
 	const child = Object.assign(childBase, { transactionMeta });
 	parent.child = child;
-	store.logger.info(`🛫`, `transaction`, token.key, `Building transaction with params:`, params);
+	store.logger.info(`🛫`, `transaction`, token.key, `building with params:`, params);
 	return child;
 };
 
@@ -1468,17 +1490,19 @@ const TRANSACTION_PHASES = [
 
 //#endregion
 //#region src/internal/set-state/dispatch-state-update.ts
-function dispatchOrDeferStateUpdate(target, state, [oldValue, newValue], stateIsNewlyCreated, family) {
+function dispatchOrDeferStateUpdate(target, state, { oldValue, newValue }, stateIsNewlyCreated, family) {
 	const token = deposit(state);
 	if (stateIsNewlyCreated && family) {
 		state.subject.next({ newValue });
 		const stateCreationEvent = {
+			write: true,
 			type: `state_creation`,
 			subType: `writable`,
 			token,
 			timestamp: Date.now(),
 			value: newValue
 		};
+		target.operation.subEvents.push(stateCreationEvent);
 		const familySubject = family.subject;
 		familySubject.next(stateCreationEvent);
 		const innerTarget = newest(target);
@@ -1505,11 +1529,11 @@ function dispatchOrDeferStateUpdate(target, state, [oldValue, newValue], stateIs
 	if (isRootStore(target)) {
 		switch (type) {
 			case `mutable_atom`:
-				target.logger.info(`📢`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers);
+				target.logger.info(`📢`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers.keys());
 				break;
 			case `atom`:
 			case `writable_pure_selector`:
-			case `writable_held_selector`: target.logger.info(`📢`, type, key, `went (`, oldValue, `->`, newValue, `) subscribers:`, subject.subscribers);
+			case `writable_held_selector`: target.logger.info(`📢`, type, key, `went (`, oldValue, `->`, newValue, `) subscribers:`, subject.subscribers.keys());
 		}
 		subject.next(update);
 	}
@@ -2037,7 +2061,7 @@ function createRegularAtomFamily(store, options, internalRoles) {
 		const def = options.default;
 		const individualOptions = {
 			key: fullKey,
-			default: def instanceof Function ? () => def(key) : def
+			default: isFn(def) ? () => def(key) : def
 		};
 		if (options.effects) individualOptions.effects = options.effects(key);
 		const token = createRegularAtom(target, individualOptions, family);
@@ -2050,7 +2074,7 @@ function createRegularAtomFamily(store, options, internalRoles) {
 		internalRoles
 	});
 	store.families.set(options.key, atomFamily$1);
-	if (options.default instanceof Function === false) store.defaults.set(options.key, options.default);
+	if (isFn(options.default) === false) store.defaults.set(options.key, options.default);
 	return familyToken;
 }
 
@@ -2288,9 +2312,22 @@ function reduceReference(store, ...params) {
 	const isCounterfeit = `counterfeit` in token;
 	const isNewlyCreated = Boolean(brandNewToken) && isCounterfeit === false;
 	if (isNewlyCreated && family) {
+		let subType;
+		switch (token.type) {
+			case `readonly_pure_selector`:
+			case `readonly_held_selector`:
+				subType = `readable`;
+				break;
+			case `atom`:
+			case `mutable_atom`:
+			case `writable_pure_selector`:
+			case `writable_held_selector`:
+				subType = `writable`;
+				break;
+		}
 		const stateCreationEvent = {
 			type: `state_creation`,
-			subType: `readable`,
+			subType,
 			token,
 			timestamp: Date.now()
 		};
@@ -3501,7 +3538,6 @@ function createTimeline(store, options, data) {
 		subject: new Subject(),
 		subscriptions: /* @__PURE__ */ new Map()
 	};
-	if (options.shouldCapture) tl.shouldCapture = options.shouldCapture;
 	const timelineKey = options.key;
 	const target = newest(store);
 	for (const initialTopic of options.scope) switch (initialTopic.type) {
@@ -3567,60 +3603,19 @@ function addAtomToTimeline(store, atomToken, tl) {
 		const txUpdateInProgress = target.on.transactionApplying.state?.update;
 		store.logger.info(`⏳`, `timeline`, tl.key, `atom`, atomToken.key, `went`, update.oldValue, `->`, update.newValue, txUpdateInProgress ? `in transaction "${txUpdateInProgress.token.key}"` : currentSelectorToken ? `in selector "${currentSelectorToken.key}"` : ``);
 		if (tl.timeTraveling === null) if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress);
-		else if (currentSelectorToken && currentSelectorTime) {
-			let latestUpdate = tl.history.at(-1);
-			if (currentSelectorTime !== tl.selectorTime) {
-				latestUpdate = {
-					type: `selector_update`,
-					timestamp: currentSelectorTime,
-					token: currentSelectorToken,
-					atomUpdates: []
-				};
-				latestUpdate.atomUpdates.push({
-					type: `atom_update`,
-					token: atomToken,
-					update,
-					timestamp: Date.now()
-				});
-				if (tl.at !== tl.history.length) tl.history.splice(tl.at);
-				tl.history.push(latestUpdate);
-				store.logger.info(`⌛`, `timeline`, tl.key, `got a selector_update "${currentSelectorToken.key}" with`, latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.token.key));
-				tl.at = tl.history.length;
-				tl.selectorTime = currentSelectorTime;
-			} else if (latestUpdate?.type === `selector_update`) {
-				latestUpdate.atomUpdates.push({
-					type: `atom_update`,
-					token: atomToken,
-					update,
-					timestamp: Date.now()
-				});
-				store.logger.info(`⌛`, `timeline`, tl.key, `set selector_update "${currentSelectorToken.key}" to`, latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.token.key));
-			}
-			if (latestUpdate) {
-				const willCaptureSelectorUpdate = tl.shouldCapture?.(latestUpdate, tl) ?? true;
-				if (willCaptureSelectorUpdate) tl.subject.next(latestUpdate);
-				else {
-					tl.history.pop();
-					tl.at = tl.history.length;
-				}
-			}
-		} else {
+		else if (currentSelectorToken && currentSelectorTime) buildSelectorUpdate(store, tl, atomToken, update, currentSelectorToken, currentSelectorTime);
+		else {
 			const timestamp = Date.now();
 			tl.selectorTime = null;
-			if (tl.at !== tl.history.length) tl.history.splice(tl.at);
 			const atomUpdate = {
+				write: true,
 				type: `atom_update`,
 				token: deposit(atom),
 				update,
 				timestamp
 			};
-			const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true;
 			store.logger.info(`⌛`, `timeline`, tl.key, `got an atom_update to "${atom.key}"`);
-			if (willCapture) {
-				tl.history.push(atomUpdate);
-				tl.at = tl.history.length;
-				tl.subject.next(atomUpdate);
-			}
+			addToHistory(tl, atomUpdate);
 		}
 	}));
 }
@@ -3649,23 +3644,55 @@ function joinTransaction(store, tl, txUpdateInProgress) {
 			unsubscribe();
 			tl.transactionKey = null;
 			if (tl.timeTraveling === null && currentTxInstanceId) {
-				if (tl.at !== tl.history.length) tl.history.splice(tl.at);
 				const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key);
 				const subEventsFiltered = filterTransactionSubEvents(transactionUpdate.subEvents, timelineTopics);
 				const timelineTransactionUpdate = {
+					write: true,
 					...transactionUpdate,
 					subEvents: subEventsFiltered
 				};
-				const willCapture = tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true;
-				if (willCapture) {
-					tl.history.push(timelineTransactionUpdate);
-					tl.at = tl.history.length;
-					tl.subject.next(timelineTransactionUpdate);
-				}
+				addToHistory(tl, timelineTransactionUpdate);
 			}
 		});
 	}
 }
+function buildSelectorUpdate(store, tl, atomToken, eventOrUpdate, currentSelectorToken, currentSelectorTime) {
+	let latestUpdate = tl.history.at(-1);
+	if (currentSelectorTime !== tl.selectorTime) {
+		const selectorUpdate = latestUpdate = {
+			write: true,
+			type: `selector_update`,
+			timestamp: currentSelectorTime,
+			token: currentSelectorToken,
+			subEvents: []
+		};
+		if (`type` in eventOrUpdate) latestUpdate.subEvents.push(eventOrUpdate);
+		else latestUpdate.subEvents.push({
+			type: `atom_update`,
+			token: atomToken,
+			update: eventOrUpdate,
+			timestamp: Date.now()
+		});
+		addToHistory(tl, latestUpdate);
+		tl.selectorTime = currentSelectorTime;
+		store.logger.info(`⌛`, `timeline`, tl.key, `got a selector_update "${currentSelectorToken.key}" with`, latestUpdate.subEvents.map((event) => event.token.key));
+		const operation = store.operation;
+		const unsub = store.on.operationClose.subscribe(`timeline:${tl.key} (needs to gather nested selector creations)`, () => {
+			unsub();
+			if (operation.open) selectorUpdate.subEvents = [...operation.subEvents, ...selectorUpdate.subEvents];
+		});
+	} else if (latestUpdate?.type === `selector_update`) {
+		if (`type` in eventOrUpdate) latestUpdate.subEvents.push(eventOrUpdate);
+		else latestUpdate.subEvents.push({
+			type: `atom_update`,
+			token: atomToken,
+			update: eventOrUpdate,
+			timestamp: Date.now()
+		});
+		store.logger.info(`⌛`, `timeline`, tl.key, `set selector_update "${currentSelectorToken.key}" to`, latestUpdate?.subEvents.map((event) => event.token.key));
+	}
+	if (latestUpdate) tl.subject.next(latestUpdate);
+}
 function filterTransactionSubEvents(updates, timelineTopics) {
 	return updates.filter((updateFromTx) => {
 		if (updateFromTx.type === `transaction_outcome`) return true;
@@ -3694,16 +3721,15 @@ function filterTransactionSubEvents(updates, timelineTopics) {
 	});
 }
 function handleStateLifecycleEvent(store, event, tl) {
+	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;
 	if (!tl.timeTraveling) {
 		const target = newest(store);
 		if (isChildStore(target)) {} else {
 			const txUpdateInProgress = target.on.transactionApplying.state;
 			if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress.update);
-			else {
-				tl.history.push(event);
-				tl.at = tl.history.length;
-				tl.subject.next(event);
-			}
+			else if (currentSelectorToken && currentSelectorTime && event.type === `state_creation`) buildSelectorUpdate(store, tl, event.token, event, currentSelectorToken, currentSelectorTime);
+			else addToHistory(tl, event);
 		}
 	}
 	switch (event.type) {
@@ -3716,6 +3742,12 @@ function handleStateLifecycleEvent(store, event, tl) {
 			break;
 	}
 }
+function addToHistory(tl, event) {
+	if (tl.at !== tl.history.length) tl.history.splice(tl.at);
+	tl.history.push(event);
+	tl.at = tl.history.length;
+	tl.subject.next(event);
+}
 
 //#endregion
 //#region src/internal/timeline/time-travel.ts
@@ -3731,10 +3763,21 @@ const timeTravel = (store, action, token) => {
 		return;
 	}
 	timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`;
-	if (action === `undo`) --timelineData.at;
-	const event = timelineData.history[timelineData.at];
+	let nextIndex = timelineData.at;
+	let events;
+	switch (action) {
+		case `undo`:
+			--nextIndex;
+			while (nextIndex !== 0 && timelineData.history[nextIndex].write !== true) --nextIndex;
+			events = timelineData.history.slice(nextIndex, timelineData.at).reverse();
+			break;
+		case `redo`:
+			++nextIndex;
+			events = timelineData.history.slice(timelineData.at, nextIndex);
+	}
+	timelineData.at = nextIndex;
 	const applying = action === `redo` ? `newValue` : `oldValue`;
-	switch (event.type) {
+	for (const event of events) switch (event.type) {
 		case `atom_update`:
 			ingestAtomUpdateEvent(store, event, applying);
 			break;
@@ -3753,10 +3796,9 @@ const timeTravel = (store, action, token) => {
 		case `molecule_creation`:
 		case `molecule_disposal`:
 	}
-	if (action === `redo`) ++timelineData.at;
 	timelineData.subject.next(action);
 	timelineData.timeTraveling = null;
-	store.logger.info(`⏹️`, `timeline`, token.key, `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`);
+	store.logger.info(`⏸️`, `timeline`, token.key, `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`);
 };
 
 //#endregion