atom.io 0.14.1 → 0.14.3

package/internal/dist/index.js

@@ -1,3 +1,3 @@
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember } from '../../dist/chunk-TE3ZSTQ6.js';
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember } from '../../dist/chunk-PURABO5G.js';
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map

package/internal/src/atom/create-atom.ts

@@ -6,10 +6,11 @@ import type {
 	UpdateHandler,
 } from "atom.io"
 import { setState } from "atom.io"
+import { Json } from "atom.io/json"
 
 import { cacheValue } from "../caching"
 import { newest } from "../lineage"
-import { createMutableAtom } from "../mutable"
+import { Transceiver, createMutableAtom } from "../mutable"
 import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
@@ -19,6 +20,7 @@ import { markAtomAsDefault } from "./is-default"
 export type Atom<T> = {
 	key: string
 	type: `atom`
+	mutable?: boolean
 	family?: FamilyMetadata
 	install: (store: Store) => void
 	subject: Subject<{ newValue: T; oldValue: T }>

package/internal/src/families/create-atom-family.ts

@@ -39,10 +39,6 @@ export function createAtomFamily<T, K extends Json.Serializable>(
 				if (options.effects) {
 					individualOptions.effects = options.effects(key)
 				}
-				// if (`toJson` in options && `fromJson` in options) {
-				// 	individualOptions.toJson = options.toJson
-				// 	individualOptions.fromJson
-				// }
 				token = createAtom<T>(individualOptions, family, store)
 				subject.next(token)
 			}
@@ -54,6 +50,9 @@ export function createAtomFamily<T, K extends Json.Serializable>(
 			subject,
 		} as const,
 	)
+	if (`mutable` in options && typeof options.mutable === `boolean`) {
+		Object.assign(atomFamily, { mutable: options.mutable })
+	}
 	const target = newest(store)
 	target.families.set(options.key, atomFamily)
 	return atomFamily

package/internal/src/mutable/get-update-family.ts

@@ -0,0 +1,23 @@
+import type { AtomFamily, MutableAtomFamily, SelectorFamily } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import type { Signal, Transceiver } from "./transceiver"
+
+export const getUpdateFamily = <
+	Core extends Transceiver<Json.Serializable>,
+	SerializableCore extends Json.Serializable,
+	Key extends string,
+>(
+	mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>,
+	store: Store,
+): AtomFamily<Signal<Core> | null, Key> => {
+	const target = newest(store)
+	const key = `*${mutableAtomFamily.key}`
+	const updateFamily = target.families.get(key) as AtomFamily<
+		Signal<Core> | null,
+		Key
+	>
+	return updateFamily
+}

package/internal/src/mutable/index.ts

@@ -5,7 +5,7 @@ export * from "./create-mutable-atom-family"
 export * from "./get-json-family"
 export * from "./get-json-token"
 export * from "./get-update-token"
-export * from "./is-atom-token-mutable"
+export * from "./get-update-family"
 export * from "./tracker"
 export * from "./tracker-family"
 export * from "./transceiver"
@@ -13,6 +13,3 @@ export * from "./transceiver"
 export interface MutableAtom<T> extends Atom<T> {
 	mutable: true
 }
-
-export const isAtomMutable = <T>(atom: Atom<T>): atom is MutableAtom<T> =>
-	`isMutable` in atom

package/internal/src/mutable/is-mutable.ts

@@ -0,0 +1,44 @@
+import type {
+	AtomFamily,
+	AtomToken,
+	MutableAtomFamily,
+	MutableAtomToken,
+} from "~/packages/atom.io/src"
+import type { MutableAtom } from "."
+import type { Atom } from "../atom"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+
+export function isMutable(
+	token: AtomToken<any>,
+	store: Store,
+): token is MutableAtomToken<any, any>
+export function isMutable(atom: Atom<any>): atom is MutableAtom<any>
+export function isMutable(
+	family: AtomFamily<any, any>,
+): family is MutableAtomFamily<any, any, any>
+export function isMutable(
+	atomOrTokenOrFamily: Atom<any> | AtomFamily<any, any> | AtomToken<any>,
+	store?: Store,
+): boolean {
+	if (`mutable` in atomOrTokenOrFamily) {
+		return atomOrTokenOrFamily.mutable
+	}
+	if (atomOrTokenOrFamily.type === `atom_family`) {
+		return false
+	}
+	if (`default` in atomOrTokenOrFamily) {
+		return false
+	}
+	if (!store) {
+		throw new Error(`Cannot check mutability without a store`)
+	}
+	const atom = withdraw(atomOrTokenOrFamily, store)
+	if (!atom) {
+		throw new Error(`Cannot check mutability without an atom`)
+	}
+	if (`mutable` in atom) {
+		return atom.mutable
+	}
+	return false
+}

package/internal/src/mutable/tracker.ts

@@ -20,7 +20,8 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		store: Store,
 	): AtomToken<typeof this.Update | null> {
 		const latestUpdateStateKey = `*${mutableState.key}`
-		deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store)
+		store.atoms.delete(latestUpdateStateKey)
+		store.valueMap.delete(latestUpdateStateKey)
 		const familyMetaData: FamilyMetadata | undefined = mutableState.family
 			? {
 					key: `*${mutableState.family.key}`,
@@ -37,6 +38,10 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			familyMetaData,
 			store,
 		)
+		if (store.parent) {
+			const parentValue = store.parent.valueMap.get(latestUpdateStateKey)
+			store.valueMap.set(latestUpdateStateKey, parentValue)
+		}
 
 		return latestUpdateState
 	}
@@ -137,7 +142,9 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					() => {
 						unsubscribe()
 						const mutable = getState(mutableState, store)
-						const updateNumber = mutable.getUpdateNumber(newValue)
+						// debugger
+						const updateNumber =
+							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
 						const eventOffset = updateNumber - mutable.cacheUpdateNumber
 						if (newValue && eventOffset === 1) {
 							// ❗ new:"0=add:\"myHand\"",old:"0=add:\"deckId\""

package/internal/src/subject.ts

@@ -14,7 +14,8 @@ export class Subject<T> {
 	}
 
 	public next(value: T): void {
-		for (const subscriber of this.subscribers.values()) {
+		const subscribers = this.subscribers.values()
+		for (const subscriber of subscribers) {
 			subscriber(value)
 		}
 	}

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -2,6 +2,7 @@ import type { TransactionUpdate, ƒn } from "atom.io"
 import type { AtomToken, TimelineUpdate } from "atom.io"
 
 import { newest } from "../lineage"
+import { getUpdateToken } from "../mutable"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import type {
@@ -15,13 +16,21 @@ export const addAtomToTimeline = (
 	tl: Timeline,
 	store: Store,
 ): void => {
-	const atom = withdraw(atomToken, store)
+	let maybeAtom = withdraw(atomToken, store)
+	if (maybeAtom?.mutable) {
+		console.log(`adding transceiver to timeline`, atomToken.key)
+		const updateToken = getUpdateToken(atomToken)
+		maybeAtom = withdraw(updateToken, store)
+	}
+	const atom = maybeAtom
 	if (atom === undefined) {
 		throw new Error(
 			`Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`,
 		)
 	}
+
 	atom.subject.subscribe(`timeline`, (update) => {
+		// debugger
 		const target = newest(store)
 		const currentSelectorKey =
 			store.operation.open && store.operation.token.type === `selector`

package/internal/src/timeline/create-timeline.ts

@@ -9,7 +9,10 @@ import type {
 } from "atom.io"
 
 import { newest } from "../lineage"
-import type { Store } from "../store"
+import { getUpdateToken } from "../mutable"
+import { getUpdateFamily } from "../mutable/get-update-family"
+import { isMutable } from "../mutable/is-mutable"
+import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
 import { addAtomToTimeline } from "./add-atom-to-timeline"
 
@@ -70,21 +73,26 @@ export function createTimeline(
 	if (options.shouldCapture) {
 		tl.shouldCapture = options.shouldCapture
 	}
-
+	const timelineKey = options.key
 	const target = newest(store)
 	for (const tokenOrFamily of options.atoms) {
-		const timelineKey = target.timelineAtoms.getRelatedKey(tokenOrFamily.key)
-		if (timelineKey) {
+		let atomKey = tokenOrFamily.key
+		const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey)
+		if (existingTimelineKey) {
 			store.logger.error(
 				`❌`,
 				`timeline`,
 				options.key,
-				`Failed to add atom "${tokenOrFamily.key}" because it already belongs to timeline "${timelineKey}"`,
+				`Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`,
 			)
 			continue
 		}
 		if (tokenOrFamily.type === `atom_family`) {
-			const family = tokenOrFamily
+			let family = tokenOrFamily
+			if (isMutable(family)) {
+				family = getUpdateFamily(family, store)
+				atomKey = family.key
+			}
 			family.subject.subscribe(`timeline:${options.key}`, (token) => {
 				addAtomToTimeline(token, tl, store)
 			})
@@ -94,32 +102,52 @@ export function createTimeline(
 				}
 			}
 		} else {
-			const token = tokenOrFamily
-			if (`family` in token && token.family) {
+			let atom = withdraw(tokenOrFamily, store)
+			if (atom === undefined) {
+				store.logger.error(
+					`❌`,
+					`timeline`,
+					options.key,
+					`Failed to add atom "${atomKey}" because it does not exist in the store`,
+				)
+				continue
+			}
+			if (isMutable(atom)) {
+				const updateAtom = withdraw(getUpdateToken(atom), store)
+				if (updateAtom === undefined) {
+					store.logger.error(
+						`❌`,
+						`timeline`,
+						options.key,
+						`Failed to add update atom "${atomKey}" because it does not exist in the store`,
+					)
+					continue
+				}
+				atom = updateAtom
+				atomKey = atom.key
+			}
+			if (`family` in atom) {
 				const familyTimelineKey = target.timelineAtoms.getRelatedKey(
-					token.family.key,
+					atom.family.key,
 				)
 				if (familyTimelineKey) {
 					store.logger.error(
 						`❌`,
 						`timeline`,
 						options.key,
-						`Failed to add atom "${token.key}" because its family "${token.family.key}" already belongs to timeline "${familyTimelineKey}"`,
+						`Failed to add atom "${atom.key}" because its family "${atom.family.key}" already belongs to timeline "${familyTimelineKey}"`,
 					)
 					continue
 				}
 			}
-			addAtomToTimeline(token, tl, store)
+			addAtomToTimeline(atom, tl, store)
 		}
-		target.timelineAtoms = target.timelineAtoms.set({
-			atomKey: tokenOrFamily.key,
-			timelineKey: options.key,
-		})
+		target.timelineAtoms.set({ atomKey, timelineKey })
 	}
 
 	store.timelines.set(options.key, tl)
 	const token: TimelineToken = {
-		key: options.key,
+		key: timelineKey,
 		type: `timeline`,
 	}
 	store.subject.timelineCreation.next(token)

package/introspection/dist/index.cjs

@@ -274,7 +274,8 @@ var Subject = class {
     this.subscribers.delete(key);
   }
   next(value) {
-    for (const subscriber of this.subscribers.values()) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers) {
       subscriber(value);
     }
   }
@@ -1081,35 +1082,6 @@ function createSelector(options, family, store) {
   return createReadonlySelector(options, family, store);
 }
 
-// internal/src/selector/delete-selector.ts
-function deleteSelector(selectorToken, store) {
-  const target = newest(store);
-  const { key } = selectorToken;
-  switch (selectorToken.type) {
-    case `selector`:
-      target.selectors.delete(key);
-      break;
-    case `readonly_selector`:
-      target.readonlySelectors.delete(key);
-      break;
-  }
-  target.valueMap.delete(key);
-  target.selectorAtoms.delete(key);
-  const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
-    ([downstreamSelectorKey]) => {
-      var _a;
-      return (_a = target.selectors.get(downstreamSelectorKey)) != null ? _a : target.readonlySelectors.get(downstreamSelectorKey);
-    }
-  );
-  for (const downstreamToken of downstreamTokens) {
-    if (downstreamToken) {
-      deleteSelector(downstreamToken, store);
-    }
-  }
-  target.selectorGraph.delete(key);
-  store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
-}
-
 // internal/src/subscribe/recall-state.ts
 var recallState = (state, store) => {
   const target = newest(store);
@@ -1228,7 +1200,8 @@ var Tracker = class {
   }
   initializeState(mutableState, store) {
     const latestUpdateStateKey = `*${mutableState.key}`;
-    deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store);
+    store.atoms.delete(latestUpdateStateKey);
+    store.valueMap.delete(latestUpdateStateKey);
     const familyMetaData = mutableState.family ? {
       key: `*${mutableState.family.key}`,
       subKey: mutableState.family.subKey
@@ -1241,6 +1214,10 @@ var Tracker = class {
       familyMetaData,
       store
     );
+    if (store.parent) {
+      const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
+      store.valueMap.set(latestUpdateStateKey, parentValue);
+    }
     return latestUpdateState;
   }
   observeCore(mutableState, latestUpdateState, store) {
@@ -1321,7 +1298,7 @@ var Tracker = class {
           () => {
             unsubscribe();
             const mutable = getState(mutableState, store);
-            const updateNumber = mutable.getUpdateNumber(newValue);
+            const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
             const eventOffset = updateNumber - mutable.cacheUpdateNumber;
             if (newValue && eventOffset === 1) {
               setState(
@@ -1396,6 +1373,9 @@ function createAtomFamily(options, store) {
       subject
     }
   );
+  if (`mutable` in options && typeof options.mutable === `boolean`) {
+    Object.assign(atomFamily, { mutable: options.mutable });
+  }
   const target = newest(store);
   target.families.set(options.key, atomFamily);
   return atomFamily;
@@ -1554,38 +1534,6 @@ function createAtom(options, family, store) {
   return token;
 }
 
-// internal/src/atom/delete-atom.ts
-function deleteAtom(atomToken, store) {
-  var _a, _b;
-  const target = newest(store);
-  const { key } = atomToken;
-  const atom = target.atoms.get(key);
-  if (!atom) {
-    store.logger.error(
-      `\u274C`,
-      `atom`,
-      `${key}`,
-      `Tried to delete atom, but it does not exist in the store.`
-    );
-  }
-  (_a = atom == null ? void 0 : atom.cleanup) == null ? void 0 : _a.call(atom);
-  target.atoms.delete(key);
-  target.valueMap.delete(key);
-  const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
-  if (selectorKeys) {
-    for (const selectorKey of selectorKeys) {
-      const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
-      if (token) {
-        deleteSelector(token, store);
-      }
-    }
-  }
-  target.selectorAtoms.delete(key);
-  target.atomsThatAreDefault.delete(key);
-  target.timelineAtoms.delete(key);
-  store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
-}
-
 // internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {