atom.io 0.27.3 → 0.27.5

package/internal/src/store/deposit.ts

@@ -1,30 +1,47 @@
 import type {
+	AtomFamilyToken,
 	AtomToken,
+	MoleculeConstructor,
 	MoleculeFamily,
 	MoleculeFamilyToken,
 	MoleculeToken,
+	MutableAtomFamilyToken,
 	MutableAtomToken,
+	ReadableFamilyToken,
 	ReadableToken,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
 	RegularAtomToken,
+	SelectorFamilyToken,
 	SelectorToken,
 	TransactionToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type {
 	Atom,
+	AtomFamily,
 	Func,
 	Molecule,
 	MutableAtom,
+	MutableAtomFamily,
+	ReadableFamily,
 	ReadableState,
 	ReadonlySelector,
+	ReadonlySelectorFamily,
 	RegularAtom,
+	RegularAtomFamily,
 	Selector,
+	SelectorFamily,
 	Transceiver,
+	WritableFamily,
 	WritableSelector,
+	WritableSelectorFamily,
 	WritableState,
 } from ".."
 import type { Transaction } from "../transaction"
@@ -38,37 +55,61 @@ export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
 export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
+export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
+
+export function deposit<T, K extends Canonical>(
+	state: RegularAtomFamily<T, K>,
+): RegularAtomFamilyToken<T, K>
 export function deposit<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
 	K extends Canonical,
-	S extends { [key: string]: any },
-	P extends any[],
->(state: Molecule<any>): MoleculeToken<any>
-export function deposit<
-	K extends Canonical,
-	S extends { [key: string]: any },
-	P extends any[],
->(state: MoleculeFamily<any>): MoleculeFamilyToken<any>
+>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>
+export function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>
+export function deposit<T>(
+	state: WritableSelectorFamily<T, any>,
+): WritableSelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: ReadonlySelectorFamily<T, any>,
+): ReadonlySelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: SelectorFamily<T, any>,
+): SelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: WritableFamily<T, any>,
+): WritableFamilyToken<T, any>
+export function deposit<T>(
+	state: ReadableFamily<T, any>,
+): ReadableFamilyToken<T, any>
+
+export function deposit<M extends MoleculeConstructor>(
+	state: MoleculeFamily<M>,
+): MoleculeFamilyToken<M>
+export function deposit<M extends MoleculeConstructor>(
+	state: Molecule<M>,
+): MoleculeToken<M>
+
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
-export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
-export function deposit<T>(
+
+export function deposit(
+	state: Molecule<any> | ReadableState<any>,
+): MoleculeToken<any> | ReadableToken<any>
+
+export function deposit(
 	state:
 		| Molecule<any>
 		| MoleculeFamily<any>
-		| ReadableState<T>
-		| ReadonlySelector<T>
-		| RegularAtom<T>
-		| Transaction<T extends Func ? T : never>
-		| WritableSelector<T>
-		| (T extends Transceiver<any> ? MutableAtom<T, any> : never),
+		| ReadableFamily<any, any>
+		| ReadableState<any>
+		| Transaction<Func>,
 ):
 	| MoleculeFamilyToken<any>
 	| MoleculeToken<any>
-	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
-	| RegularAtomToken<T>
-	| SelectorToken<T>
-	| TransactionToken<T extends Func ? T : never> {
+	| ReadableFamilyToken<any, any>
+	| ReadableToken<any>
+	| TransactionToken<Func> {
 	const token = {
 		key: state.key,
 		type: state.type,

package/internal/src/store/store.ts

@@ -42,6 +42,7 @@ export class Store implements Lineage {
 	public child: Store | null = null
 
 	public valueMap = new Map<string, any>()
+	public defaults = new Map<string, any>()
 
 	public atoms = new Map<string, Atom<any>>()
 	public selectors = new Map<string, WritableSelector<any>>()
@@ -175,7 +176,7 @@ export class Store implements Lineage {
 				}
 				atom.install(this)
 				if (atom.type === `mutable_atom`) {
-					const originalJsonToken = getJsonToken(atom, store)
+					const originalJsonToken = getJsonToken(store, atom)
 					const originalUpdateToken = getUpdateToken(atom)
 					mutableHelpers.add(originalJsonToken.key)
 					mutableHelpers.add(originalUpdateToken.key)

package/internal/src/subscribe/index.ts

@@ -1,3 +1,5 @@
+export * from "./recall-state"
+export * from "./subscribe-in-store"
 export * from "./subscribe-to-root-atoms"
 export * from "./subscribe-to-state"
 export * from "./subscribe-to-timeline"

package/internal/src/subscribe/subscribe-in-store.ts

@@ -0,0 +1,62 @@
+import type {
+	ReadableToken,
+	TimelineManageable,
+	TimelineToken,
+	TimelineUpdate,
+	TransactionToken,
+	TransactionUpdateHandler,
+	UpdateHandler,
+} from "atom.io"
+import type { Func, Store } from "atom.io/internal"
+import {
+	arbitrary,
+	subscribeToState,
+	subscribeToTimeline,
+	subscribeToTransaction,
+} from "atom.io/internal"
+
+export function subscribeInStore<T>(
+	store: Store,
+	token: ReadableToken<T>,
+	handleUpdate: UpdateHandler<T>,
+	key?: string,
+): () => void
+export function subscribeInStore<F extends Func>(
+	store: Store,
+	token: TransactionToken<F>,
+	handleUpdate: TransactionUpdateHandler<F>,
+	key?: string,
+): () => void
+export function subscribeInStore<M extends TimelineManageable>(
+	store: Store,
+	token: TimelineToken<M>,
+	handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void,
+	key?: string,
+): () => void
+export function subscribeInStore<M extends TimelineManageable>(
+	store: Store,
+	token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>,
+	handleUpdate:
+		| TransactionUpdateHandler<any>
+		| UpdateHandler<any>
+		| ((update: TimelineUpdate<M> | `redo` | `undo`) => void),
+	key?: string,
+): () => void
+export function subscribeInStore(
+	store: Store,
+	token: ReadableToken<any> | TimelineToken<any> | TransactionToken<any>,
+	handleUpdate: (update: any) => void,
+	key: string = arbitrary(),
+): () => void {
+	switch (token.type) {
+		case `atom`:
+		case `mutable_atom`:
+		case `readonly_selector`:
+		case `selector`:
+			return subscribeToState(token, handleUpdate, key, store)
+		case `transaction`:
+			return subscribeToTransaction(token, handleUpdate, key, store)
+		case `timeline`:
+			return subscribeToTimeline(token, handleUpdate, key, store)
+	}
+}

package/internal/src/timeline/time-travel.ts

@@ -12,9 +12,9 @@ import {
 import type { Store } from "../store"
 
 export const timeTravel = (
+	store: Store,
 	action: `redo` | `undo`,
 	token: TimelineToken<any>,
-	store: Store,
 ): void => {
 	store.logger.info(
 		action === `redo` ? `⏩` : `⏪`,

package/internal/src/transaction/build-transaction.ts

@@ -48,6 +48,7 @@ export const buildTransaction = (
 		}),
 		selectors: new LazyMap(parent.selectors),
 		valueMap: new LazyMap(parent.valueMap),
+		defaults: parent.defaults,
 		molecules: new LazyMap(parent.molecules),
 		moleculeFamilies: new LazyMap(parent.moleculeFamilies),
 		moleculeInProgress: parent.moleculeInProgress,
@@ -67,19 +68,19 @@ export const buildTransaction = (
 		},
 		toolkit: {
 			get: ((...ps: Parameters<typeof getState>) =>
-				getFromStore(...ps, child)) as typeof getState,
+				getFromStore(child, ...ps)) as typeof getState,
 			set: ((...ps: Parameters<typeof setState>) => {
-				setIntoStore(...ps, child)
+				setIntoStore(child, ...ps)
 			}) as typeof setState,
 			run: (token, identifier = arbitrary()) =>
 				actUponStore(token, identifier, child),
-			find: ((token, k) => findInStore(token, k, child)) as typeof findState,
-			seek: ((token, k) => seekInStore(token, k, child)) as typeof seekState,
-			json: (token) => getJsonToken(token, child),
+			find: ((token, k) => findInStore(child, token, k)) as typeof findState,
+			seek: ((token, k) => seekInStore(child, token, k)) as typeof seekState,
+			json: (token) => getJsonToken(child, token),
 			make: (context, family, k, ...args) =>
 				makeMoleculeInStore(child, context, family, k, ...args),
 			dispose: ((...ps: Parameters<typeof disposeState>) => {
-				disposeFromStore(...ps, child)
+				disposeFromStore(child, ...ps)
 			}) as typeof disposeState,
 			env: () => getEnvironmentData(child),
 		},

package/introspection/dist/index.js

@@ -5,6 +5,7 @@ import { getState } from 'atom.io';
 
 var attachAtomIndex = (store = IMPLICIT.STORE) => {
   const atomTokenIndexState__INTERNAL = createRegularAtom(
+    store,
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
       default: () => {
@@ -73,19 +74,16 @@ var attachAtomIndex = (store = IMPLICIT.STORE) => {
         }
       ]
     },
-    void 0,
-    store
-  );
-  return createStandaloneSelector(
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index`,
-      get: ({ get }) => get(atomTokenIndexState__INTERNAL)
-    },
-    store
+    void 0
   );
+  return createStandaloneSelector(store, {
+    key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index`,
+    get: ({ get }) => get(atomTokenIndexState__INTERNAL)
+  });
 };
 var attachSelectorIndex = (store = IMPLICIT.STORE) => {
   const readonlySelectorTokenIndexState__INTERNAL = createRegularAtom(
+    store,
     {
       key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index (Internal)`,
       default: () => {
@@ -162,56 +160,50 @@ var attachSelectorIndex = (store = IMPLICIT.STORE) => {
         }
       ]
     },
-    void 0,
-    store
-  );
-  return createStandaloneSelector(
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index`,
-      get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
-    },
-    IMPLICIT.STORE
+    void 0
   );
+  return createStandaloneSelector(IMPLICIT.STORE, {
+    key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index`,
+    get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
+  });
 };
 var attachTimelineFamily = (store = IMPLICIT.STORE) => {
-  const findTimelineLogState__INTERNAL = createRegularAtomFamily(
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log (Internal)`,
-      default: (key) => store.timelines.get(key) ?? {
-        type: `timeline`,
-        key: ``,
-        at: 0,
-        timeTraveling: null,
-        history: [],
-        selectorTime: null,
-        transactionKey: null,
-        install: () => {
-        },
-        subject: new Subject(),
-        subscriptions: /* @__PURE__ */ new Map()
+  const findTimelineLogState__INTERNAL = createRegularAtomFamily(store, {
+    key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log (Internal)`,
+    default: (key) => store.timelines.get(key) ?? {
+      type: `timeline`,
+      key: ``,
+      at: 0,
+      timeTraveling: null,
+      history: [],
+      selectorTime: null,
+      transactionKey: null,
+      install: () => {
       },
-      effects: (key) => [
-        ({ setSelf }) => {
-          const tl = store.timelines.get(key);
-          tl?.subject.subscribe(`introspection`, (_) => {
-            setSelf({ ...tl });
-          });
-        }
-      ]
+      subject: new Subject(),
+      subscriptions: /* @__PURE__ */ new Map()
     },
-    store
-  );
+    effects: (key) => [
+      ({ setSelf }) => {
+        const tl = store.timelines.get(key);
+        tl?.subject.subscribe(`introspection`, (_) => {
+          setSelf({ ...tl });
+        });
+      }
+    ]
+  });
   const findTimelineLogState = createSelectorFamily(
+    store,
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log`,
       get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL, key)
-    },
-    store
+    }
   );
   return findTimelineLogState;
 };
 var attachTimelineIndex = (store = IMPLICIT.STORE) => {
   const timelineTokenIndexState__INTERNAL = createRegularAtom(
+    store,
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index (Internal)`,
       default: () => [...store.timelines].map(([key]) => {
@@ -228,20 +220,17 @@ var attachTimelineIndex = (store = IMPLICIT.STORE) => {
         }
       ]
     },
-    void 0,
-    store
-  );
-  const timelineTokenIndex = createStandaloneSelector(
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index`,
-      get: ({ get }) => get(timelineTokenIndexState__INTERNAL)
-    },
-    store
+    void 0
   );
+  const timelineTokenIndex = createStandaloneSelector(store, {
+    key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index`,
+    get: ({ get }) => get(timelineTokenIndexState__INTERNAL)
+  });
   return timelineTokenIndex;
 };
 var attachTransactionIndex = (store = IMPLICIT.STORE) => {
   const transactionTokenIndexState__INTERNAL = createRegularAtom(
+    store,
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index (Internal)`,
       default: () => [...store.transactions].map(([key]) => {
@@ -258,43 +247,33 @@ var attachTransactionIndex = (store = IMPLICIT.STORE) => {
         }
       ]
     },
-    void 0,
-    store
-  );
-  const transactionTokenIndex = createStandaloneSelector(
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index`,
-      get: ({ get }) => get(transactionTokenIndexState__INTERNAL)
-    },
-    store
+    void 0
   );
+  const transactionTokenIndex = createStandaloneSelector(store, {
+    key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index`,
+    get: ({ get }) => get(transactionTokenIndexState__INTERNAL)
+  });
   return transactionTokenIndex;
 };
 var attachTransactionLogs = (store = IMPLICIT.STORE) => {
-  const transactionUpdateLogAtoms = createRegularAtomFamily(
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log (Internal)`,
-      default: () => [],
-      effects: (key) => [
-        ({ setSelf }) => {
-          const tx = store.transactions.get(key);
-          tx?.subject.subscribe(`introspection`, (transactionUpdate) => {
-            if (transactionUpdate.key === key) {
-              setSelf((state) => [...state, transactionUpdate]);
-            }
-          });
-        }
-      ]
-    },
-    store
-  );
-  const findTransactionUpdateLogState = createSelectorFamily(
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log`,
-      get: (key) => ({ get }) => get(transactionUpdateLogAtoms, key)
-    },
-    store
-  );
+  const transactionUpdateLogAtoms = createRegularAtomFamily(store, {
+    key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log (Internal)`,
+    default: () => [],
+    effects: (key) => [
+      ({ setSelf }) => {
+        const tx = store.transactions.get(key);
+        tx?.subject.subscribe(`introspection`, (transactionUpdate) => {
+          if (transactionUpdate.key === key) {
+            setSelf((state) => [...state, transactionUpdate]);
+          }
+        });
+      }
+    ]
+  });
+  const findTransactionUpdateLogState = createSelectorFamily(store, {
+    key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log`,
+    get: (key) => ({ get }) => get(transactionUpdateLogAtoms, key)
+  });
   return findTransactionUpdateLogState;
 };
 

package/introspection/src/attach-atom-index.ts

@@ -15,6 +15,7 @@ export const attachAtomIndex = (
 	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorToken<AtomTokenIndex> => {
 	const atomTokenIndexState__INTERNAL = createRegularAtom<AtomTokenIndex>(
+		store,
 		{
 			key: `👁‍🗨 Atom Token Index (Internal)`,
 			default: () => {
@@ -88,13 +89,9 @@ export const attachAtomIndex = (
 			],
 		},
 		undefined,
-		store,
-	)
-	return createStandaloneSelector(
-		{
-			key: `👁‍🗨 Atom Token Index`,
-			get: ({ get }) => get(atomTokenIndexState__INTERNAL),
-		},
-		store,
 	)
+	return createStandaloneSelector(store, {
+		key: `👁‍🗨 Atom Token Index`,
+		get: ({ get }) => get(atomTokenIndexState__INTERNAL),
+	})
 }

package/introspection/src/attach-selector-index.ts

@@ -16,6 +16,8 @@ export const attachSelectorIndex = (
 ): ReadonlySelectorToken<SelectorTokenIndex> => {
 	const readonlySelectorTokenIndexState__INTERNAL =
 		createRegularAtom<SelectorTokenIndex>(
+			store,
+
 			{
 				key: `👁‍🗨 Selector Token Index (Internal)`,
 				default: () => {
@@ -98,13 +100,9 @@ export const attachSelectorIndex = (
 				],
 			},
 			undefined,
-			store,
 		)
-	return createStandaloneSelector(
-		{
-			key: `👁‍🗨 Selector Token Index`,
-			get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
-		},
-		IMPLICIT.STORE,
-	)
+	return createStandaloneSelector(IMPLICIT.STORE, {
+		key: `👁‍🗨 Selector Token Index`,
+		get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
+	})
 }

package/introspection/src/attach-timeline-family.ts

@@ -13,34 +13,32 @@ export const attachTimelineFamily = (
 	const findTimelineLogState__INTERNAL = createRegularAtomFamily<
 		Timeline<any>,
 		string
-	>(
-		{
-			key: `👁‍🗨 Timeline Update Log (Internal)`,
-			default: (key) =>
-				store.timelines.get(key) ?? {
-					type: `timeline`,
-					key: ``,
-					at: 0,
-					timeTraveling: null,
-					history: [],
-					selectorTime: null,
-					transactionKey: null,
-					install: () => {},
-					subject: new Subject(),
-					subscriptions: new Map(),
-				},
-			effects: (key) => [
-				({ setSelf }) => {
-					const tl = store.timelines.get(key)
-					tl?.subject.subscribe(`introspection`, (_) => {
-						setSelf({ ...tl })
-					})
-				},
-			],
-		},
-		store,
-	)
+	>(store, {
+		key: `👁‍🗨 Timeline Update Log (Internal)`,
+		default: (key) =>
+			store.timelines.get(key) ?? {
+				type: `timeline`,
+				key: ``,
+				at: 0,
+				timeTraveling: null,
+				history: [],
+				selectorTime: null,
+				transactionKey: null,
+				install: () => {},
+				subject: new Subject(),
+				subscriptions: new Map(),
+			},
+		effects: (key) => [
+			({ setSelf }) => {
+				const tl = store.timelines.get(key)
+				tl?.subject.subscribe(`introspection`, (_) => {
+					setSelf({ ...tl })
+				})
+			},
+		],
+	})
 	const findTimelineLogState = createSelectorFamily<Timeline<any>, string>(
+		store,
 		{
 			key: `👁‍🗨 Timeline Update Log`,
 			get:
@@ -48,7 +46,6 @@ export const attachTimelineFamily = (
 				({ get }) =>
 					get(findTimelineLogState__INTERNAL, key),
 		},
-		store,
 	)
 	return findTimelineLogState
 }

package/introspection/src/attach-timeline-index.ts

@@ -12,6 +12,7 @@ export const attachTimelineIndex = (
 	const timelineTokenIndexState__INTERNAL = createRegularAtom<
 		TimelineToken<any>[]
 	>(
+		store,
 		{
 			key: `👁‍🗨 Timeline Token Index (Internal)`,
 			default: () =>
@@ -30,14 +31,10 @@ export const attachTimelineIndex = (
 			],
 		},
 		undefined,
-		store,
-	)
-	const timelineTokenIndex = createStandaloneSelector(
-		{
-			key: `👁‍🗨 Timeline Token Index`,
-			get: ({ get }) => get(timelineTokenIndexState__INTERNAL),
-		},
-		store,
 	)
+	const timelineTokenIndex = createStandaloneSelector(store, {
+		key: `👁‍🗨 Timeline Token Index`,
+		get: ({ get }) => get(timelineTokenIndexState__INTERNAL),
+	})
 	return timelineTokenIndex
 }

package/introspection/src/attach-transaction-index.ts

@@ -12,6 +12,7 @@ export const attachTransactionIndex = (
 	const transactionTokenIndexState__INTERNAL = createRegularAtom<
 		TransactionToken<Func>[]
 	>(
+		store,
 		{
 			key: `👁‍🗨 Transaction Token Index (Internal)`,
 			default: () =>
@@ -30,14 +31,10 @@ export const attachTransactionIndex = (
 			],
 		},
 		undefined,
-		store,
-	)
-	const transactionTokenIndex = createStandaloneSelector(
-		{
-			key: `👁‍🗨 Transaction Token Index`,
-			get: ({ get }) => get(transactionTokenIndexState__INTERNAL),
-		},
-		store,
 	)
+	const transactionTokenIndex = createStandaloneSelector(store, {
+		key: `👁‍🗨 Transaction Token Index`,
+		get: ({ get }) => get(transactionTokenIndexState__INTERNAL),
+	})
 	return transactionTokenIndex
 }