atom.io 0.18.3 → 0.19.1

package/dist/chunk-7ZR244C2.js

@@ -0,0 +1,489 @@
+import { Junction } from './chunk-WX2NCOZR.js';
+import { dispose } from 'atom.io';
+import { getFromStore, setIntoStore, findInStore, createMutableAtomFamily, createRegularAtomFamily, IMPLICIT, newest, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { SetRTX } from 'atom.io/transceivers/set-rtx';
+
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+var Join = class _Join {
+  transact(transactors, run) {
+    const originalTransactors = this.transactors;
+    this.transactors = transactors;
+    run(this);
+    this.transactors = originalTransactors;
+  }
+  in(store) {
+    const key = store.config.name;
+    const alternate = this.alternates.get(key);
+    if (alternate) {
+      return alternate;
+    }
+    const join2 = new _Join(this.options, this.defaultContent, store);
+    this.alternates.set(key, join2);
+    join2.alternates = this.alternates;
+    return join2;
+  }
+  constructor(options, defaultContent, store = IMPLICIT.STORE) {
+    this.options = options;
+    this.defaultContent = defaultContent;
+    this.alternates = /* @__PURE__ */ new Map();
+    this.alternates.set(store.config.name, this);
+    this.transactors = {
+      get: (token) => getFromStore(token, store),
+      set: (token, value) => setIntoStore(token, value, store),
+      find: (token, key) => findInStore(token, key, store)
+    };
+    const a = options.between[0];
+    const b = options.between[1];
+    const relatedKeysAtoms = createMutableAtomFamily(
+      {
+        key: `${options.key}/relatedKeys`,
+        default: () => new SetRTX(),
+        mutable: true,
+        fromJson: (json) => SetRTX.fromJSON(json),
+        toJson: (set) => set.toJSON()
+      },
+      store
+    );
+    this.core = { findRelatedKeysState: relatedKeysAtoms };
+    const getRelatedKeys = ({ find, get }, key) => get(find(relatedKeysAtoms, key));
+    const addRelation = (transactors, a2, b2) => {
+      const { set, find } = transactors;
+      const aKeysState = find(relatedKeysAtoms, a2);
+      const bKeysState = find(relatedKeysAtoms, b2);
+      set(aKeysState, (aKeys) => aKeys.add(b2));
+      set(bKeysState, (bKeys) => bKeys.add(a2));
+    };
+    const deleteRelation = (transactors, a2, b2) => {
+      const { find, set } = transactors;
+      const aKeysState = find(relatedKeysAtoms, a2);
+      const bKeysState = find(relatedKeysAtoms, b2);
+      set(aKeysState, (aKeys) => (aKeys.delete(b2), aKeys));
+      set(bKeysState, (bKeys) => (bKeys.delete(a2), bKeys));
+    };
+    const replaceRelationsSafely = (transactors, a2, newRelationsOfA) => {
+      const { find, get, set } = transactors;
+      const relationsOfAState = find(relatedKeysAtoms, a2);
+      const currentRelationsOfA = get(relationsOfAState);
+      for (const currentRelationB of currentRelationsOfA) {
+        const remainsRelated = newRelationsOfA.includes(currentRelationB);
+        if (remainsRelated) {
+          continue;
+        }
+        const relationsOfBState = find(relatedKeysAtoms, currentRelationB);
+        set(relationsOfBState, (relationsOfB) => {
+          relationsOfB.delete(a2);
+          return relationsOfB;
+        });
+      }
+      set(relationsOfAState, (relationsOfA) => {
+        relationsOfA.transaction((nextRelationsOfA) => {
+          nextRelationsOfA.clear();
+          for (const newRelationB of newRelationsOfA) {
+            const relationsOfB = getRelatedKeys(transactors, newRelationB);
+            const newRelationBIsAlreadyRelated = relationsOfB.has(a2);
+            if (this.relations.cardinality === `1:n`) {
+              for (const previousOwner of relationsOfB) {
+                if (previousOwner === a2) {
+                  continue;
+                }
+                const previousOwnerRelations = getRelatedKeys(
+                  transactors,
+                  previousOwner
+                );
+                previousOwnerRelations.delete(newRelationB);
+              }
+              if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
+                relationsOfB.clear();
+              }
+            }
+            if (!newRelationBIsAlreadyRelated) {
+              relationsOfB.add(a2);
+            }
+            nextRelationsOfA.add(newRelationB);
+          }
+          return true;
+        });
+        return relationsOfA;
+      });
+    };
+    const replaceRelationsUnsafely = (transactors, a2, newRelationsOfA) => {
+      const { find, set } = transactors;
+      const relationsOfAState = find(relatedKeysAtoms, a2);
+      set(relationsOfAState, (relationsOfA) => {
+        relationsOfA.transaction((nextRelationsOfA) => {
+          for (const newRelationB of newRelationsOfA) {
+            nextRelationsOfA.add(newRelationB);
+          }
+          return true;
+        });
+        return relationsOfA;
+      });
+      for (const newRelationB of newRelationsOfA) {
+        const newRelationsBState = find(relatedKeysAtoms, newRelationB);
+        set(newRelationsBState, (newRelationsB) => {
+          newRelationsB.add(a2);
+          return newRelationsB;
+        });
+      }
+      return true;
+    };
+    const has = (transactors, a2, b2) => {
+      const aKeys = getRelatedKeys(transactors, a2);
+      return b2 ? aKeys.has(b2) : aKeys.size > 0;
+    };
+    const baseExternalStoreConfiguration = {
+      getRelatedKeys: (key) => getRelatedKeys(this.transactors, key),
+      addRelation: (a2, b2) => addRelation(this.transactors, a2, b2),
+      deleteRelation: (a2, b2) => deleteRelation(this.transactors, a2, b2),
+      replaceRelationsSafely: (a2, bs) => replaceRelationsSafely(this.transactors, a2, bs),
+      replaceRelationsUnsafely: (a2, bs) => replaceRelationsUnsafely(this.transactors, a2, bs),
+      has: (a2, b2) => has(this.transactors, a2, b2)
+    };
+    let externalStore;
+    let contentAtoms;
+    if (defaultContent) {
+      contentAtoms = createRegularAtomFamily(
+        {
+          key: `${options.key}/content`,
+          default: defaultContent
+        },
+        store
+      );
+      const getContent = ({ find, get }, key) => get(find(contentAtoms, key));
+      const setContent = ({ find, set }, key, content) => set(find(contentAtoms, key), content);
+      const deleteContent = ({ find }, key) => dispose(find(contentAtoms, key));
+      const externalStoreWithContentConfiguration = {
+        getContent: (contentKey) => {
+          const content = getContent(this.transactors, contentKey);
+          return content;
+        },
+        setContent: (contentKey, content) => {
+          setContent(this.transactors, contentKey, content);
+        },
+        deleteContent: (contentKey) => {
+          deleteContent(this.transactors, contentKey);
+        }
+      };
+      externalStore = Object.assign(
+        baseExternalStoreConfiguration,
+        externalStoreWithContentConfiguration
+      );
+    } else {
+      externalStore = baseExternalStoreConfiguration;
+    }
+    const relations = new Junction(options, {
+      externalStore,
+      makeContentKey: (...args) => args.sort().join(`:`)
+    });
+    const createSingleKeyStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/singleRelatedKey`,
+        get: (key) => ({ find, get }) => {
+          const relatedKeysState = find(relatedKeysAtoms, key);
+          const relatedKeys = get(relatedKeysState);
+          for (const relatedKey of relatedKeys) {
+            return relatedKey;
+          }
+          return null;
+        }
+      },
+      store
+    );
+    const getMultipleKeyStateFamily = () => {
+      return createSelectorFamily(
+        {
+          key: `${options.key}/multipleRelatedKeys`,
+          get: (key) => ({ find, get }) => {
+            const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+            const jsonState = find(jsonFamily, key);
+            const json = get(jsonState);
+            return json.members;
+          }
+        },
+        store
+      );
+    };
+    const createSingleEntryStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/singleRelatedEntry`,
+        get: (key) => ({ find, get }) => {
+          const relatedKeysState = find(relatedKeysAtoms, key);
+          const relatedKeys = get(relatedKeysState);
+          for (const relatedKey of relatedKeys) {
+            const contentKey = relations.makeContentKey(key, relatedKey);
+            const contentState = find(contentAtoms, contentKey);
+            const content = get(contentState);
+            return [relatedKey, content];
+          }
+          return null;
+        }
+      },
+      store
+    );
+    const getMultipleEntryStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/multipleRelatedEntries`,
+        get: (key) => ({ find, get }) => {
+          const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+          const json = get(jsonFamily(key));
+          return json.members.map((relatedKey) => {
+            const contentKey = relations.makeContentKey(key, relatedKey);
+            const contentState = find(contentAtoms, contentKey);
+            const content = get(contentState);
+            return [relatedKey, content];
+          });
+        }
+      },
+      store
+    );
+    switch (options.cardinality) {
+      case `1:1`: {
+        const findSingleRelatedKeyState = createSingleKeyStateFamily();
+        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeyOf${capitalize(a)}`;
+        const baseStates = {
+          [stateKeyA]: findSingleRelatedKeyState,
+          [stateKeyB]: findSingleRelatedKeyState
+        };
+        let states;
+        if (defaultContent) {
+          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntryOf${capitalize(a)}`;
+          const contentStates = {
+            [entriesStateKeyA]: findSingleRelatedEntryState,
+            [entriesStateKeyB]: findSingleRelatedEntryState
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+        break;
+      }
+      case `1:n`: {
+        const findSingleRelatedKeyState = createSingleKeyStateFamily();
+        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const baseStates = {
+          [stateKeyA]: findSingleRelatedKeyState,
+          [stateKeyB]: findMultipleRelatedKeysState
+        };
+        let states;
+        if (defaultContent) {
+          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const contentStates = {
+            [entriesStateKeyA]: findSingleRelatedEntryState,
+            [entriesStateKeyB]: findMultipleRelatedEntriesState
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+        break;
+      }
+      default: {
+        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+        const stateKeyA = `${a}KeysOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const baseStates = {
+          [stateKeyA]: findMultipleRelatedKeysState,
+          [stateKeyB]: findMultipleRelatedKeysState
+        };
+        let states;
+        if (defaultContent) {
+          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const contentStates = {
+            [entriesStateKeyA]: findMultipleRelatedEntriesState,
+            [entriesStateKeyB]: findMultipleRelatedEntriesState
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+      }
+    }
+  }
+};
+function join(options, defaultContent, store = IMPLICIT.STORE) {
+  const joins = getJoinMap(store);
+  joins.set(options.key, new Join(options, defaultContent, store));
+  const token = {
+    key: options.key,
+    type: `join`,
+    a: options.between[0],
+    b: options.between[1],
+    cardinality: options.cardinality
+  };
+  return token;
+}
+function getJoinMap(store) {
+  if (`joins` in store && store.joins instanceof Map) {
+    return store.joins;
+  }
+  const joins = /* @__PURE__ */ new Map();
+  store.joins = joins;
+  return joins;
+}
+function getJoin(token, store) {
+  var _a;
+  const joinMap = getJoinMap(store);
+  let join2 = joinMap.get(token.key);
+  if (join2 === void 0) {
+    const rootJoinMap = getJoinMap(IMPLICIT.STORE);
+    join2 = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (join2 === void 0) {
+      throw new Error(
+        `Join "${token.key}" not found in store "${store.config.name}"`
+      );
+    }
+    joinMap.set(token.key, join2);
+  }
+  return join2;
+}
+function findRelationsInStore(token, key, store) {
+  const join2 = getJoin(token, store);
+  let relations;
+  switch (token.cardinality) {
+    case `1:1`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = join2.states[keyAB];
+          const state = findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keyBA]() {
+          const familyBA = join2.states[keyBA];
+          const state = findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in join2.states) {
+        const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = join2.states[entryAB];
+            const state = findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entryBA]() {
+            const familyBA = join2.states[entryBA];
+            const state = findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+      break;
+    }
+    case `1:n`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = join2.states[keyAB];
+          const state = findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in join2.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = join2.states[entryAB];
+            const state = findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+      break;
+    }
+    case `n:n`: {
+      const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keysAB]() {
+          const familyAB = join2.states[keysAB];
+          const state = findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
+      if (entriesAB in join2.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entriesAB]() {
+            const familyAB = join2.states[entriesAB];
+            const state = findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+    }
+  }
+  return relations;
+}
+function findRelations(token, key) {
+  return findRelationsInStore(token, key, IMPLICIT.STORE);
+}
+function editRelationsInStore(token, change, store) {
+  const join2 = getJoin(token, store);
+  const target = newest(store);
+  if (isChildStore(target)) {
+    const { transactors } = target.transactionMeta;
+    join2.transact(transactors, ({ relations }) => {
+      change(relations);
+    });
+  } else {
+    change(join2.relations);
+  }
+}
+function editRelations(token, change) {
+  editRelationsInStore(token, change, IMPLICIT.STORE);
+}
+function getInternalRelationsFromStore(token, store) {
+  const join2 = getJoin(token, store);
+  const family = join2.core.findRelatedKeysState;
+  return family;
+}
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+}
+
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join };

package/dist/index.cjs

@@ -111,6 +111,7 @@ var Silo = class {
     this.selectorFamily = (options) => Internal.createSelectorFamily(options, s);
     this.transaction = (options) => Internal.createTransaction(options, s);
     this.timeline = (options) => Internal.createTimeline(options, s);
+    this.findState = (token, key) => Internal.findInStore(token, key, s);
     this.getState = (token) => Internal.getFromStore(token, s);
     this.setState = (token, newValue) => Internal.setIntoStore(token, newValue, s);
     this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);

package/dist/index.d.ts

@@ -254,6 +254,7 @@ declare class Silo {
     selectorFamily: typeof selectorFamily;
     transaction: typeof transaction;
     timeline: typeof timeline;
+    findState: typeof findState;
     getState: typeof getState;
     setState: typeof setState;
     subscribe: typeof subscribe;

package/dist/index.js

@@ -90,6 +90,7 @@ var Silo = class {
     this.selectorFamily = (options) => createSelectorFamily(options, s);
     this.transaction = (options) => createTransaction(options, s);
     this.timeline = (options) => createTimeline(options, s);
+    this.findState = (token, key) => findInStore(token, key, s);
     this.getState = (token) => getFromStore(token, s);
     this.setState = (token, newValue) => setIntoStore(token, newValue, s);
     this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);

package/internal/dist/index.cjs

@@ -2424,7 +2424,7 @@ var buildTransaction = (key, params, store, id) => {
     update: {
       key,
       id,
-      epoch: epoch === void 0 ? NaN : epoch + 1,
+      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
       updates: [],
       params,
       output: void 0

package/internal/dist/index.d.ts

@@ -437,7 +437,7 @@ declare const traceAllSelectorAtoms: (selector: Selector<any>, store: Store) =>
 declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, store: Store) => void;
 
 type Modify<T> = (thing: T) => T;
-declare const become: <T>(nextVersionOfThing: T | Modify<T>) => (originalThing: T) => T;
+declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing: T) => T;
 
 declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 

package/internal/dist/index.js

@@ -2146,7 +2146,7 @@ var buildTransaction = (key, params, store, id) => {
     update: {
       key,
       id,
-      epoch: epoch === void 0 ? NaN : epoch + 1,
+      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
       updates: [],
       params,
       output: void 0

package/internal/src/mutable/tracker.ts

@@ -32,7 +32,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			? {
 					key: `*${mutableState.family.key}`,
 					subKey: mutableState.family.subKey,
-			  }
+				}
 			: undefined
 		const latestUpdateState = createRegularAtom<
 			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null

package/internal/src/set-state/become.ts

@@ -6,5 +6,5 @@ export const become =
 		nextVersionOfThing instanceof Function
 			? nextVersionOfThing(
 					originalThing instanceof Function ? originalThing() : originalThing,
-			  )
+				)
 			: nextVersionOfThing

package/internal/src/subscribe/subscribe-to-state.ts

@@ -32,7 +32,7 @@ export function subscribeToState<T>(
 						`Removing subscription "${key}"`,
 					)
 					unsubFunction()
-			  }
+				}
 			: () => {
 					store.logger.info(
 						`🙈`,
@@ -44,7 +44,7 @@ export function subscribeToState<T>(
 					for (const unsubFromDependency of dependencyUnsubFunctions) {
 						unsubFromDependency()
 					}
-			  }
+				}
 
 	return unsubscribe
 }

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

@@ -51,8 +51,8 @@ export const addAtomToTimeline = (
 			currentTransactionKey
 				? `in transaction "${currentTransactionKey}"`
 				: currentSelectorKey
-				  ? `in selector "${currentSelectorKey}"`
-				  : ``,
+					? `in selector "${currentSelectorKey}"`
+					: ``,
 		)
 		if (tl.timeTraveling === null) {
 			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
@@ -106,7 +106,7 @@ export const addAtomToTimeline = (
 														(key) =>
 															key === updateFromTx.key ||
 															key === updateFromTx.family?.key,
-												  )
+													)
 												: false
 										})
 										.map((updateFromTx) => {

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

@@ -50,7 +50,7 @@ export const buildTransaction = (
 		update: {
 			key,
 			id,
-			epoch: epoch === undefined ? NaN : epoch + 1,
+			epoch: epoch === undefined ? Number.NaN : epoch + 1,
 			updates: [],
 			params,
 			output: undefined,

package/introspection/dist/index.cjs

@@ -42,12 +42,13 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var attachAtomIndex = (store = Internal.IMPLICIT.STORE) => {
+  console.log(store.config);
   const atomTokenIndexState__INTERNAL = Internal.createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
       default: () => {
-        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key]) => {
-          acc[key] = { key, type: `atom` };
+        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key, atom]) => {
+          acc[key] = { key, type: atom.type };
           return acc;
         }, {});
         return defaultAtomIndex;

package/introspection/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { RegularAtomToken, ReadonlySelectorToken, WritableSelectorToken, TransactionToken, ƒn as _n, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken } from 'atom.io';
+import { AtomToken, ReadonlySelectorToken, WritableSelectorToken, TransactionToken, ƒn as _n, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken } from 'atom.io';
 import * as Internal from 'atom.io/internal';
 import { Timeline } from 'atom.io/internal';
 
-type AtomTokenIndex = WritableTokenIndex<RegularAtomToken<unknown>>;
+type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
 
 type SelectorTokenIndex = WritableTokenIndex<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
 
@@ -15,10 +15,10 @@ declare const attachIntrospectionStates: (store?: Internal.Store) => {
     findTimelineState: ReadonlySelectorFamilyToken<Timeline<any>, string>;
 };
 
-type FamilyNode<Token extends ReadonlySelectorToken<unknown> | RegularAtomToken<unknown> | WritableSelectorToken<unknown>> = {
+type FamilyNode<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>> = {
     key: string;
     familyMembers: Record<string, Token>;
 };
-type WritableTokenIndex<Token extends ReadonlySelectorToken<unknown> | RegularAtomToken<unknown> | WritableSelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
+type WritableTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
 
 export { type FamilyNode, type WritableTokenIndex, attachIntrospectionStates };

package/introspection/dist/index.js

@@ -3,12 +3,13 @@ import * as Internal from 'atom.io/internal';
 import { createRegularAtom, newest, createStandaloneSelector, IMPLICIT, createRegularAtomFamily, Subject, createSelectorFamily } from 'atom.io/internal';
 
 var attachAtomIndex = (store = IMPLICIT.STORE) => {
+  console.log(store.config);
   const atomTokenIndexState__INTERNAL = createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
       default: () => {
-        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key]) => {
-          acc[key] = { key, type: `atom` };
+        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key, atom]) => {
+          acc[key] = { key, type: atom.type };
           return acc;
         }, {});
         return defaultAtomIndex;