atom.io 0.18.3 → 0.19.0

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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "atom.io",
-	"version": "0.18.3",
+	"version": "0.19.0",
 	"description": "Composable and testable reactive data library.",
 	"homepage": "https://atom.io.fyi",
 	"sideEffects": false,
@@ -78,7 +78,7 @@
 		"@testing-library/react": "14.2.1",
 		"@types/http-proxy": "1.17.14",
 		"@types/npmlog": "7.0.0",
-		"@types/react": "18.2.61",
+		"@types/react": "18.2.62",
 		"@types/tmp": "0.2.6",
 		"@vitest/coverage-v8": "1.3.1",
 		"@vitest/ui": "1.3.1",
@@ -100,7 +100,7 @@
 		"tmp": "0.2.3",
 		"tsup": "8.0.2",
 		"typescript": "5.3.3",
-		"vite": "5.1.4",
+		"vite": "5.1.5",
 		"vite-tsconfig-paths": "4.3.1",
 		"vitest": "1.3.1"
 	},

package/realtime/dist/index.cjs

@@ -103,8 +103,10 @@ var usersInRooms = data.join(
 );
 var usersInMyRoomView = atom_io.selectorFamily({
   key: `usersInMyRoomView`,
-  get: (username) => ({ find }) => {
-    return [find(usersInRooms.core.findRelatedKeysState, username)];
+  get: (myUsername) => ({ find }) => {
+    const usersInRoomsAtoms = data.getInternalRelations(usersInRooms);
+    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
+    return [myRoomIndex];
   }
 });
 

package/realtime/dist/index.d.ts

@@ -2,7 +2,6 @@ import * as atom_io from 'atom.io';
 import { AtomFamilyToken, ReadableFamilyToken, ReadableToken, AtomToken, TransactionToken, MutableAtomToken } from 'atom.io';
 import { Json } from 'atom.io/json';
 import * as atom_io_data from 'atom.io/data';
-import * as atom_io_internal from 'atom.io/internal';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 declare class InvariantMap<K, V> extends Map<K, V> {
@@ -40,107 +39,13 @@ type ContinuityOptions = {
 };
 declare function continuity(options: ContinuityOptions): ContinuityToken;
 
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-
-type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
-type Cardinality = `1:1` | `1:n` | `n:n`;
-
-interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
-    readonly relations: [string, string[]][];
-    readonly contents: [string, Content][];
-}
-interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
-    readonly between: [a: ASide, b: BSide];
-    readonly cardinality: Cardinality;
-}
-type BaseExternalStoreConfiguration = {
-    addRelation: (a: string, b: string) => void;
-    deleteRelation: (a: string, b: string) => void;
-    replaceRelationsSafely: (a: string, bs: string[]) => void;
-    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
-    getRelatedKeys: (key: string) => Set<string> | undefined;
-    has: (a: string, b?: string) => boolean;
-};
-type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
-    getContent: (contentKey: string) => Content | undefined;
-    setContent: (contentKey: string, content: Content) => void;
-    deleteContent: (contentKey: string) => void;
-};
-type Empty<Obj extends object> = {
-    [Key in keyof Obj]?: undefined;
-};
-type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
-    externalStore?: ExternalStoreConfiguration<Content>;
-    isContent?: Refinement<unknown, Content>;
-    makeContentKey?: (a: string, b: string) => string;
-};
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
-    readonly a: ASide;
-    readonly b: BSide;
-    readonly cardinality: Cardinality;
-    readonly relations: Map<string, Set<string>>;
-    readonly contents: Map<string, Content>;
-    isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: string, b: string) => string;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    protected addRelation(a: string, b: string): void;
-    protected deleteRelation(a: string, b: string): void;
-    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
-    protected replaceRelationsSafely(a: string, bs: string[]): void;
-    protected getContentInternal(contentKey: string): Content | undefined;
-    protected setContent(contentKey: string, content: Content): void;
-    protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
-    toJSON(): JunctionJSON<ASide, BSide, Content>;
-    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
-    set(relation: {
-        [Key in ASide | BSide]: string;
-    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
-    delete(a: string, b?: string): this;
-    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
-    getRelatedKey(key: string): string | undefined;
-    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    getContent(a: string, b: string): Content | undefined;
-    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
-    has(a: string, b?: string): boolean;
-}
-
 declare const usersInThisRoomIndex: MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
 declare const roomIndex: MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
 type UserInRoomMeta = {
     enteredAtEpoch: number;
 };
 declare const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta;
-declare const usersInRooms: {
-    readonly relations: Junction<"room", "user", UserInRoomMeta>;
-    readonly states: {
-        readonly roomEntryOfUser: atom_io.ReadonlySelectorFamily<[string, UserInRoomMeta] | null, string>;
-    } & {
-        readonly userEntriesOfRoom: atom_io.ReadonlySelectorFamily<[string, UserInRoomMeta][], string>;
-    } & {
-        readonly roomKeyOfUser: atom_io.ReadonlySelectorFamily<string | null, string>;
-    } & {
-        readonly userKeysOfRoom: atom_io.ReadonlySelectorFamily<string[], string>;
-    };
-    readonly in: (store: atom_io_internal.Store) => atom_io_data.Join<"room", "user", "1:n", UserInRoomMeta>;
-    readonly transact: (transactors: Readonly<{
-        get: <S>(state: atom_io.ReadonlySelectorToken<S> | atom_io.WritableToken<S>) => S;
-        set: <S_1, New extends S_1>(state: atom_io.WritableToken<S_1>, newValue: New | ((oldValue: S_1) => New)) => void;
-        find: typeof atom_io.findState;
-    }>, run: (join: atom_io_data.Join<"room", "user", "1:n", UserInRoomMeta>) => void) => void;
-    readonly core: {
-        readonly findRelatedKeysState: atom_io.MutableAtomFamily<SetRTX<string>, SetRTXJson<string>, string>;
-    };
-};
+declare const usersInRooms: atom_io_data.JoinToken<"room", "user", "1:n", UserInRoomMeta>;
 declare const usersInMyRoomView: atom_io.ReadonlySelectorFamilyTokenWithCall<MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[], string>;
 
 export { type ContinuityOptions, type ContinuityToken, DEFAULT_USER_IN_ROOM_META, InvariantMap, type PerspectiveToken, SyncGroup, type UserInRoomMeta, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex };

package/realtime/dist/index.js

@@ -1,7 +1,7 @@
 import '../../dist/chunk-U2IICNHQ.js';
 import { assignTransactionToContinuity, IMPLICIT, setEpochNumberOfContinuity, getUpdateToken } from 'atom.io/internal';
 import { atom, selectorFamily } from 'atom.io';
-import { join } from 'atom.io/data';
+import { join, getInternalRelations } from 'atom.io/data';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
 var InvariantMap = class extends Map {
@@ -101,8 +101,10 @@ var usersInRooms = join(
 );
 var usersInMyRoomView = selectorFamily({
   key: `usersInMyRoomView`,
-  get: (username) => ({ find }) => {
-    return [find(usersInRooms.core.findRelatedKeysState, username)];
+  get: (myUsername) => ({ find }) => {
+    const usersInRoomsAtoms = getInternalRelations(usersInRooms);
+    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
+    return [myRoomIndex];
   }
 });
 

package/realtime/src/shared-room-store.ts

@@ -1,6 +1,6 @@
 import type { MutableAtomToken } from "atom.io"
 import { atom, selectorFamily } from "atom.io"
-import { join } from "atom.io/data"
+import { getInternalRelations, join } from "atom.io/data"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
@@ -41,8 +41,10 @@ export const usersInMyRoomView = selectorFamily<
 >({
 	key: `usersInMyRoomView`,
 	get:
-		(username) =>
+		(myUsername) =>
 		({ find }) => {
-			return [find(usersInRooms.core.findRelatedKeysState, username)]
+			const usersInRoomsAtoms = getInternalRelations(usersInRooms)
+			const myRoomIndex = find(usersInRoomsAtoms, myUsername)
+			return [myRoomIndex]
 		},
 })