atom.io 0.18.2 → 0.19.0

package/data/dist/index.cjs

@@ -596,7 +596,171 @@ var Join = class _Join {
   }
 };
 function join(options, defaultContent, store = internal.IMPLICIT.STORE) {
-  return new Join(options, defaultContent, 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(internal.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 = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keyBA]() {
+          const familyBA = join2.states[keyBA];
+          const state = internal.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 = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entryBA]() {
+            const familyBA = join2.states[entryBA];
+            const state = internal.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 = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = internal.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 = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = internal.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 = internal.findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = internal.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 = internal.findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = internal.findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+    }
+  }
+  return relations;
+}
+function findRelations(token, key) {
+  return findRelationsInStore(token, key, internal.IMPLICIT.STORE);
+}
+function editRelationsInStore(token, change, store) {
+  const join2 = getJoin(token, store);
+  const target = internal.newest(store);
+  if (internal.isChildStore(target)) {
+    const { transactors } = target.transactionMeta;
+    join2.transact(transactors, ({ relations }) => {
+      change(relations);
+    });
+  } else {
+    change(join2.relations);
+  }
+}
+function editRelations(token, change) {
+  editRelationsInStore(token, change, internal.IMPLICIT.STORE);
+}
+function getInternalRelationsFromStore(token, store) {
+  const join2 = getJoin(token, store);
+  const family = join2.core.findRelatedKeysState;
+  return family;
+}
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, internal.IMPLICIT.STORE);
 }
 var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
 function struct(options, store = internal.IMPLICIT.STORE) {
@@ -667,9 +831,15 @@ function until(loadable, fallback) {
 
 exports.Join = Join;
 exports.dict = dict;
+exports.editRelations = editRelations;
+exports.editRelationsInStore = editRelationsInStore;
+exports.findRelations = findRelations;
+exports.findRelationsInStore = findRelationsInStore;
+exports.getInternalRelations = getInternalRelations;
+exports.getInternalRelationsFromStore = getInternalRelationsFromStore;
+exports.getJoin = getJoin;
+exports.getJoinMap = getJoinMap;
 exports.join = join;
 exports.struct = struct;
 exports.structFamily = structFamily;
 exports.until = until;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/data/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as AtomIO from 'atom.io';
-import { ReadonlySelectorFamily, MutableAtomFamily, Transactors } from 'atom.io';
+import { ReadonlySelectorFamily, MutableAtomFamily, Transactors, ReadonlySelectorToken, MutableAtomFamilyToken } from 'atom.io';
 import { Store } from 'atom.io/internal';
 import { Json, Stringified } from 'atom.io/json';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
@@ -86,7 +86,7 @@ interface JoinOptions<ASide extends string, BSide extends string, Cardinality ex
     readonly key: string;
     readonly cardinality: Cardinality;
 }
-type JoinState<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+type JoinStateFamilies<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntryOf${Capitalize<BSide>}` : `${AB}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamily<[
         string,
         Content
@@ -120,7 +120,7 @@ declare class Join<const ASide extends string, const BSide extends string, const
     private defaultContent;
     private transactors;
     relations: Junction<ASide, BSide, Content>;
-    states: JoinState<ASide, BSide, Cardinality, Content>;
+    states: JoinStateFamilies<ASide, BSide, Cardinality, Content>;
     core: {
         findRelatedKeysState: MutableAtomFamily<SetRTX<string>, SetRTXJson<string>, string>;
     };
@@ -129,24 +129,55 @@ declare class Join<const ASide extends string, const BSide extends string, const
     in(store: Store): Join<ASide, BSide, Cardinality, Content>;
     constructor(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
 }
-declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, BSide, Cardinality, null>, defaultContent?: undefined, store?: Store): {
-    readonly relations: Junction<ASide, BSide, null>;
-    readonly states: JoinState<ASide, BSide, Cardinality, null>;
-    readonly in: (store: Store) => Join<ASide, BSide, Cardinality>;
-    readonly transact: (transactors: Transactors, run: (join: Join<ASide, BSide, Cardinality, null>) => void) => void;
-    readonly core: {
-        readonly findRelatedKeysState: MutableAtomFamily<SetRTX<string>, SetRTXJson<string>, string>;
-    };
-};
-declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content, store?: Store): {
-    readonly relations: Junction<ASide, BSide, Content>;
-    readonly states: JoinState<ASide, BSide, Cardinality, Content>;
-    readonly in: (store: Store) => Join<ASide, BSide, Cardinality, Content>;
-    readonly transact: (transactors: Transactors, run: (join: Join<ASide, BSide, Cardinality, Content>) => void) => void;
-    readonly core: {
-        readonly findRelatedKeysState: MutableAtomFamily<SetRTX<string>, SetRTXJson<string>, string>;
-    };
+type JoinToken<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
+    key: string;
+    type: `join`;
+    cardinality: Cardinality;
+    a: ASide;
+    b: BSide;
+    __content?: Content;
 };
+declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, BSide, Cardinality, null>, defaultContent?: undefined, store?: Store): JoinToken<ASide, BSide, Cardinality, null>;
+declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, BSide, Cardinality, Content>;
+declare function getJoinMap(store: Store & {
+    joins?: Map<string, Join<any, any, any, any>>;
+}): Map<string, Join<any, any, any, any>>;
+declare function getJoin<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, store: Store): Join<ASide, BSide, Cardinality, Content>;
+type JoinStates<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntryOf${Capitalize<BSide>}` : `${AB}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
+        string,
+        Content
+    ] | null>;
+} : {}) & {
+    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeyOf${Capitalize<BSide>}` : `${AB}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string | null>;
+} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
+        string,
+        Content
+    ] | null>;
+} & {
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
+        string,
+        Content
+    ][]>;
+} : {}) & {
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<string | null>;
+} & {
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string[]>;
+} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
+    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntriesOf${Capitalize<BSide>}` : `${AB}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
+        string,
+        Content
+    ][]>;
+} : {}) & {
+    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeysOf${Capitalize<BSide>}` : `${AB}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string[]>;
+} : never;
+declare function findRelationsInStore<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, key: string, store: Store): JoinStates<ASide, BSide, Cardinality, Content>;
+declare function findRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, key: string): JoinStates<ASide, BSide, Cardinality, Content>;
+declare function editRelationsInStore<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, change: (relations: Junction<ASide, BSide, Content>) => void, store: Store): void;
+declare function editRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, change: (relations: Junction<ASide, BSide, Content>) => void): void;
+declare function getInternalRelationsFromStore(token: JoinToken<any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+declare function getInternalRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
 
 declare function struct<Struct extends {
     [key: string]: unknown;
@@ -180,4 +211,4 @@ type Fated<T, E extends Error = Error> = Loadable<E | T>;
  */
 declare function until<T>(loadable: Loadable<T>, fallback: T): T;
 
-export { type Fated, Join, type JoinOptions, type JoinState, type Loadable, dict, join, struct, structFamily, until };
+export { type Fated, Join, type JoinOptions, type JoinStateFamilies, type JoinStates, type JoinToken, type Loadable, dict, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join, struct, structFamily, until };

package/data/dist/index.js

@@ -1,17 +1,16 @@
-import { Junction } from '../../dist/chunk-NYTGCPHB.js';
-import '../../dist/chunk-PZLG2HP3.js';
-import { createStandaloneSelector, findInStore, IMPLICIT, getFromStore, setIntoStore, createMutableAtomFamily, createRegularAtomFamily, createRegularAtom, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
-import { dispose } from 'atom.io';
-import { SetRTX } from 'atom.io/transceivers/set-rtx';
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-7ZR244C2.js';
+import '../../dist/chunk-WX2NCOZR.js';
+import '../../dist/chunk-U2IICNHQ.js';
+import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';
 
-function dict(findState2, index, store = IMPLICIT.STORE) {
+function dict(findState, index, store = IMPLICIT.STORE) {
   return createStandaloneSelector(
     {
-      key: `${findState2.key}Dict`,
+      key: `${findState.key}Dict`,
       get: ({ get }) => {
         const keys = get(index);
         return keys.reduce((acc, key) => {
-          acc[key] = get(findInStore(findState2, key, store));
+          acc[key] = get(findInStore(findState, key, store));
           return acc;
         }, {});
       }
@@ -19,328 +18,10 @@ function dict(findState2, index, store = IMPLICIT.STORE) {
     store
   );
 }
-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) {
-  return new Join(options, defaultContent, store);
-}
-var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
+var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function struct(options, store = IMPLICIT.STORE) {
   const atoms = Object.keys(options.default).reduce((acc, key) => {
-    const atomName = options.key + capitalize2(key) + `State`;
+    const atomName = options.key + capitalize(key) + `State`;
     acc[atomName] = createRegularAtom(
       {
         key: `${options.key}.${key}`,
@@ -356,7 +37,7 @@ function struct(options, store = IMPLICIT.STORE) {
       key: options.key,
       get: ({ get }) => {
         return Object.keys(options.default).reduce((acc, key) => {
-          acc[key] = get(atoms[options.key + capitalize2(key) + `State`]);
+          acc[key] = get(atoms[options.key + capitalize(key) + `State`]);
           return acc;
         }, {});
       }
@@ -365,8 +46,8 @@ function struct(options, store = IMPLICIT.STORE) {
   );
   return [atoms, structState];
 }
-var capitalize3 = (str) => str[0].toUpperCase() + str.slice(1);
-var nameFamily = (topKey, subKey) => `find` + capitalize3(topKey) + capitalize3(subKey) + `State`;
+var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
+var nameFamily = (topKey, subKey) => `find` + capitalize2(topKey) + capitalize2(subKey) + `State`;
 function structFamily(options) {
   const atoms = Object.keys(options.default).reduce((acc, subKey) => {
     const atomFamilyName = nameFamily(options.key, subKey);
@@ -404,6 +85,4 @@ function until(loadable, fallback) {
   return loadable;
 }
 
-export { Join, dict, join, struct, structFamily, until };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map
+export { dict, struct, structFamily, until };