atom.io 0.35.0 → 0.36.0

package/dist/internal/index.js

@@ -1,5 +1,5 @@
 import { Join as Join$1, arbitrary as arbitrary$1, subscribeToState as subscribeToState$1, subscribeToTimeline as subscribeToTimeline$1, subscribeToTransaction as subscribeToTransaction$1 } from "atom.io/internal";
-import { parseJson, selectJson, selectJsonFamily, stringifyJson } from "atom.io/json";
+import { parseJson, stringifyJson } from "atom.io/json";
 import { Anarchy, AtomIOLogger } from "atom.io";
 import { SetRTX } from "atom.io/transceivers/set-rtx";
 
@@ -460,10 +460,10 @@ 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 atom.default();
+	if (originValue === void 0) return new atom.class();
 	origin.logger.info(`📃`, `atom`, atom.key, `copying`);
-	const jsonValue = atom.toJson(originValue);
-	const copiedValue = atom.fromJson(jsonValue);
+	const jsonValue = originValue.toJSON();
+	const copiedValue = atom.class.fromJSON(jsonValue);
 	target.valueMap.set(atom.key, copiedValue);
 	new Tracker(atom, origin);
 	return copiedValue;
@@ -619,8 +619,7 @@ const readOrComputeValue = (target, state) => {
 		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, state.key, `computing value`);
 			return state.get();
-		case `atom`:
-		case `mutable_atom`: {
+		case `atom`: {
 			const def = state.default;
 			let defaultValue;
 			if (def instanceof Function) defaultValue = def();
@@ -629,6 +628,13 @@ const readOrComputeValue = (target, state) => {
 			target.logger.info(`💁`, `atom`, state.key, `could not find cached value; using default`, defaultValue);
 			return cachedValue;
 		}
+		case `mutable_atom`: {
+			const Ctor = state.class;
+			const instance = new Ctor();
+			const cachedValue = cacheValue(target, state.key, instance, state.subject);
+			target.logger.info(`💁`, `mutable_atom`, state.key, `could not find cached value; using default`, instance);
+			return cachedValue;
+		}
 	}
 };
 
@@ -718,9 +724,16 @@ const setAtom = (target, atom, next) => {
 //#endregion
 //#region src/internal/set-state/reset-atom-or-selector.ts
 function resetAtom(store, state) {
-	let def = state.default;
-	if (def instanceof Function) def = def();
-	setAtom(store, state, def);
+	switch (state.type) {
+		case `mutable_atom`:
+			setAtom(store, state, new state.class());
+			return;
+		case `atom`: {
+			let def = state.default;
+			if (def instanceof Function) def = def();
+			setAtom(store, state, def);
+		}
+	}
 }
 function resetAtomOrSelector(store, state) {
 	switch (state.type) {
@@ -1210,6 +1223,7 @@ function claimWithinStore(store, newProvenance, claim, exclusive) {
 	const transferEvent = {
 		type: `molecule_transfer`,
 		key: molecule.key,
+		exclusive: Boolean(exclusive),
 		from: priorProvenance,
 		to: [newProvenanceMolecule.key]
 	};
@@ -1282,15 +1296,15 @@ function ingestMoleculeDisposalEvent(update, applying, store) {
 function ingestMoleculeTransferEvent(update, applying, store) {
 	switch (applying) {
 		case `newValue`:
-			{
-				const provenance = update.to.length === 1 ? update.to[0] : update.to;
-				claimWithinStore(store, provenance, update.key, `exclusive`);
-			}
+			for (const newOwner of update.to) claimWithinStore(store, newOwner, update.key, update.exclusive ? `exclusive` : void 0);
 			break;
 		case `oldValue`:
 			{
-				const provenance = update.from.length === 1 ? update.from[0] : update.from;
-				claimWithinStore(store, provenance, update.key, `exclusive`);
+				let exclusivity = `exclusive`;
+				for (const previousOwner of update.from) {
+					claimWithinStore(store, previousOwner, update.key, exclusivity);
+					exclusivity = void 0;
+				}
 			}
 			break;
 	}
@@ -1299,7 +1313,9 @@ function ingestMoleculeTransferEvent(update, applying, store) {
 //#endregion
 //#region src/internal/ingest-updates/ingest-selector-update.ts
 function ingestSelectorUpdate(applying, selectorUpdate, store) {
-	const updates = applying === `newValue` ? selectorUpdate.atomUpdates : selectorUpdate.atomUpdates.toReversed();
+	let updates;
+	if (applying === `newValue`) updates = selectorUpdate.atomUpdates;
+	else updates = selectorUpdate.atomUpdates.toReversed();
 	for (const atomUpdate of updates) ingestAtomUpdate(applying, atomUpdate, store);
 }
 
@@ -1693,19 +1709,18 @@ function createStandaloneSelector(store, options) {
 //#region src/internal/selector/dispose-selector.ts
 function disposeSelector(store, selectorToken) {
 	const target = newest(store);
-	const { key, type } = selectorToken;
-	const selector = withdraw(target, selectorToken);
-	if (!selector.family) store.logger.error(`❌`, type, key, `Standalone selectors cannot be disposed.`);
+	const { key, type, family: familyMeta } = selectorToken;
+	if (!familyMeta) store.logger.error(`❌`, type, key, `Standalone selectors cannot be disposed.`);
 	else {
-		const molecule = target.molecules.get(selector.family.subKey);
-		if (molecule) target.moleculeData.delete(selector.family.subKey, selector.family.key);
+		const molecule = target.molecules.get(familyMeta.subKey);
+		if (molecule) target.moleculeData.delete(familyMeta.subKey, familyMeta.key);
 		let familyToken;
 		switch (selectorToken.type) {
 			case `writable_held_selector`:
 				{
 					target.writableSelectors.delete(key);
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `writable_held_selector_family`
 					};
 					const family = withdraw(store, familyToken);
@@ -1720,7 +1735,7 @@ function disposeSelector(store, selectorToken) {
 				{
 					target.writableSelectors.delete(key);
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `writable_pure_selector_family`
 					};
 					const family = withdraw(store, familyToken);
@@ -1735,7 +1750,7 @@ function disposeSelector(store, selectorToken) {
 				{
 					target.readonlySelectors.delete(key);
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `readonly_held_selector_family`
 					};
 					const family = withdraw(store, familyToken);
@@ -1750,7 +1765,7 @@ function disposeSelector(store, selectorToken) {
 				{
 					target.readonlySelectors.delete(key);
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `readonly_pure_selector_family`
 					};
 					const family = withdraw(store, familyToken);
@@ -1765,6 +1780,7 @@ function disposeSelector(store, selectorToken) {
 		target.valueMap.delete(key);
 		target.selectorAtoms.delete(key);
 		target.selectorGraph.delete(key);
+		target.moleculeData.delete(familyMeta.key, familyMeta.subKey);
 		store.logger.info(`🔥`, selectorToken.type, key, `deleted`);
 		if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.updates.push({
 			type: `state_disposal`,
@@ -2237,66 +2253,60 @@ var Tracker = class {
 	}
 	unsubscribeFromInnerValue;
 	unsubscribeFromState;
-	observeCore(mutableState, latestUpdateState, target) {
+	captureSignalsFromCore(mutableState, latestUpdateState, target) {
 		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-		const originalInnerValue = getFromStore(target, mutableState);
-		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(subscriptionKey, (update) => {
+		const trackerCapturesOutboundSignal = (update) => {
 			setIntoStore(target, latestUpdateState, update);
-		});
-		this.unsubscribeFromState = subscribeToState(target, mutableState, subscriptionKey, (update) => {
+		};
+		const originalInnerValue = getFromStore(target, mutableState);
+		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(subscriptionKey, trackerCapturesOutboundSignal);
+		this.unsubscribeFromState = subscribeToState(target, mutableState, subscriptionKey, function trackerLooksForNewReference(update) {
 			if (update.newValue !== update.oldValue) {
 				this.unsubscribeFromInnerValue();
-				this.unsubscribeFromInnerValue = update.newValue.subscribe(subscriptionKey, (transceiverUpdate) => {
-					setIntoStore(target, latestUpdateState, transceiverUpdate);
-				});
+				this.unsubscribeFromInnerValue = update.newValue.subscribe(subscriptionKey, trackerCapturesOutboundSignal);
 			}
-		});
+		}.bind(this));
 	}
-	updateCore(mutableState, latestUpdateState, target) {
+	supplySignalsToCore(mutableState, latestUpdateState, target) {
 		const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-		subscribeToState(target, latestUpdateState, subscriptionKey, ({ newValue, oldValue }) => {
+		subscribeToState(target, latestUpdateState, subscriptionKey, function trackerCapturesInboundSignal({ newValue, oldValue }) {
 			const timelineId = target.timelineTopics.getRelatedKey(latestUpdateState.key);
-			if (timelineId) {
-				const timelineData = target.timelines.get(timelineId);
-				if (timelineData?.timeTraveling) {
-					const unsubscribe$1 = subscribeToTimeline(target, {
-						key: timelineId,
-						type: `timeline`
-					}, subscriptionKey, (update) => {
-						unsubscribe$1();
-						setIntoStore(target, mutableState, (transceiver) => {
-							if (update === `redo` && newValue) transceiver.do(newValue);
-							else if (update === `undo` && oldValue) transceiver.undo(oldValue);
-							return transceiver;
-						});
+			if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
+				const unsubscribe = subscribeToTimeline(target, {
+					key: timelineId,
+					type: `timeline`
+				}, subscriptionKey, function trackerWaitsForTimeTravelToFinish(update) {
+					unsubscribe();
+					setIntoStore(target, mutableState, (transceiver) => {
+						if (update === `redo` && newValue) transceiver.do(newValue);
+						else if (update === `undo` && oldValue) transceiver.undo(oldValue);
+						return transceiver;
 					});
-					return;
-				}
+				});
+				return;
 			}
-			const unsubscribe = target.on.operationClose.subscribe(subscriptionKey, () => {
-				unsubscribe();
-				const mutable = getFromStore(target, mutableState);
-				const updateNumber = newValue === null ? -1 : 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}`);
-			});
+			const mutable = getFromStore(target, mutableState);
+			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}`);
 		});
 	}
-	mutableState;
-	latestUpdateState;
+	mutableAtomToken;
+	latestSignalToken;
 	[Symbol.dispose];
-	constructor(mutableState, store) {
-		this.mutableState = mutableState;
+	constructor(mutableAtomToken, store) {
 		const target = newest(store);
-		this.latestUpdateState = this.initializeState(mutableState, target);
-		this.observeCore(mutableState, this.latestUpdateState, target);
-		this.updateCore(mutableState, this.latestUpdateState, target);
-		target.trackers.set(mutableState.key, this);
+		const latestSignalToken = this.initializeState(mutableAtomToken, target);
+		this.mutableAtomToken = mutableAtomToken;
+		this.latestSignalToken = latestSignalToken;
+		this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target);
+		this.supplySignalsToCore(mutableAtomToken, latestSignalToken, target);
+		target.trackers.set(mutableAtomToken.key, this);
 		this[Symbol.dispose] = () => {
 			this.unsubscribeFromInnerValue();
 			this.unsubscribeFromState();
-			target.trackers.delete(mutableState.key);
+			target.trackers.delete(mutableAtomToken.key);
 		};
 	}
 };
@@ -2347,7 +2357,13 @@ function createMutableAtom(store, options, family) {
 		};
 	}
 	new Tracker(token, store);
-	if (!family) selectJson(token, options, store);
+	if (!family) createStandaloneSelector(store, {
+		key: `${key}:JSON`,
+		get: ({ get }) => get(token).toJSON(),
+		set: ({ set }, newValue) => {
+			set(token, options.class.fromJSON(newValue));
+		}
+	});
 	store.on.atomCreation.next(token);
 	return token;
 }
@@ -2408,9 +2424,7 @@ function createMutableAtomFamily(store, options, internalRoles) {
 		const target = newest(store);
 		const individualOptions = {
 			key: fullKey,
-			default: () => options.default(key),
-			toJson: options.toJson,
-			fromJson: options.fromJson
+			class: options.class
 		};
 		if (options.effects) individualOptions.effects = options.effects(key);
 		const token = createMutableAtom(target, individualOptions, family);
@@ -2423,12 +2437,16 @@ function createMutableAtomFamily(store, options, internalRoles) {
 	const atomFamily$1 = Object.assign(familyFunction, familyToken, {
 		subject,
 		install: (s) => createMutableAtomFamily(s, options),
-		toJson: options.toJson,
-		fromJson: options.fromJson,
 		internalRoles
 	});
 	store.families.set(options.key, atomFamily$1);
-	selectJsonFamily(store, atomFamily$1, options);
+	createWritablePureSelectorFamily(store, {
+		key: `${options.key}:JSON`,
+		get: (key) => ({ get }) => get(familyToken, key).toJSON(),
+		set: (key) => ({ set }, newValue) => {
+			set(familyToken, key, options.class.fromJSON(newValue));
+		}
+	}, [`mutable`, `json`]);
 	new FamilyTracker(atomFamily$1, store);
 	return familyToken;
 }
@@ -2738,6 +2756,7 @@ function disposeAtom(store, atomToken) {
 		target.valueMap.delete(key);
 		target.selectorAtoms.delete(key);
 		target.atomsThatAreDefault.delete(key);
+		target.moleculeData.delete(family.key, family.subKey);
 		store.timelineTopics.delete(key);
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken);
@@ -2833,9 +2852,7 @@ var Join = class {
 		const bSide = options.between[1];
 		const relatedKeysAtoms = createMutableAtomFamily(store, {
 			key: `${options.key}/relatedKeys`,
-			default: () => new SetRTX(),
-			fromJson: (json) => SetRTX.fromJSON(json),
-			toJson: (set) => set.toJSON()
+			class: SetRTX
 		}, [`join`, `relations`]);
 		this.core = { relatedKeysAtoms };
 		const getRelatedKeys = ({ get }, key) => get(relatedKeysAtoms, key);