atom.io 0.23.5 → 0.24.1

package/data/dist/index.js

@@ -1,7 +1,8 @@
-export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-7DT3PVS3.js';
-import '../../dist/chunk-FTONNX2R.js';
+import { Junction } from '../../dist/chunk-FTONNX2R.js';
 import '../../dist/chunk-F2X4B4VY.js';
-import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';
+import { createStandaloneSelector, findInStore, IMPLICIT, getFromStore, setIntoStore, seekInStore, getJsonToken, disposeFromStore, withdraw, growMoleculeInStore, initFamilyMemberInStore, createMutableAtomFamily, createRegularAtomFamily, createMoleculeFamily, newest, makeMoleculeInStore, isChildStore, createRegularAtom, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { stringifyJson } from 'atom.io/json';
+import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
 function dict(findState, index, store = IMPLICIT.STORE) {
   return createStandaloneSelector(
@@ -18,10 +19,625 @@ function dict(findState, index, store = IMPLICIT.STORE) {
     store
   );
 }
-var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+var Join = class _Join {
+  constructor(options, defaultContent, store = IMPLICIT.STORE) {
+    this.molecules = /* @__PURE__ */ new Map();
+    this.store = store;
+    this.options = options;
+    this.defaultContent = defaultContent;
+    this.alternates = /* @__PURE__ */ new Map();
+    this.alternates.set(store.config.name, this);
+    this.store.miscResources.set(`join:${options.key}`, this);
+    this.transactors = {
+      get: (token) => getFromStore(token, store),
+      set: (token, value) => {
+        setIntoStore(token, value, store);
+      },
+      find: (token, key) => findInStore(token, key, store),
+      seek: (token, key) => seekInStore(token, key, store),
+      json: (token) => getJsonToken(token, store),
+      dispose: (token) => {
+        disposeFromStore(token, store);
+      }
+    };
+    this.retrieve = (token, key) => {
+      const maybeToken = this.transactors.seek(token, key);
+      if (maybeToken) {
+        return maybeToken;
+      }
+      const molecule = this.molecules.get(stringifyJson(key));
+      if (molecule) {
+        const family = withdraw(token, store);
+        return growMoleculeInStore(molecule, family, store);
+      }
+      if (store.config.lifespan === `immortal`) {
+        throw new Error(`No molecule found for key "${stringifyJson(key)}"`);
+      }
+      return initFamilyMemberInStore(token, key, store);
+    };
+    const aSide = options.between[0];
+    const bSide = 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 = ({ get }, key) => get(this.retrieve(relatedKeysAtoms, key));
+    const addRelation = (transactors, a, b) => {
+      const { set } = transactors;
+      const aKeysState = this.retrieve(relatedKeysAtoms, a);
+      const bKeysState = this.retrieve(relatedKeysAtoms, b);
+      set(aKeysState, (aKeys) => aKeys.add(b));
+      set(bKeysState, (bKeys) => bKeys.add(a));
+    };
+    const deleteRelation = (transactors, a, b) => {
+      const { set } = transactors;
+      const aKeysState = this.retrieve(relatedKeysAtoms, a);
+      const bKeysState = this.retrieve(relatedKeysAtoms, b);
+      let stringA;
+      let stringB;
+      set(aKeysState, (aKeys) => {
+        aKeys.delete(b);
+        if (aKeys.size === 0) {
+          stringA = `"${a}"`;
+        }
+        return aKeys;
+      });
+      set(bKeysState, (bKeys) => {
+        bKeys.delete(a);
+        if (bKeys.size === 0) {
+          stringB = `"${b}"`;
+        }
+        return bKeys;
+      });
+      if (stringA) {
+        const molecule = this.molecules.get(stringA);
+        if (molecule) {
+          this.transactors.dispose(molecule);
+        }
+      }
+      if (stringB) {
+        const molecule = this.molecules.get(stringB);
+        if (molecule) {
+          this.transactors.dispose(molecule);
+        }
+      }
+    };
+    const replaceRelationsSafely = (transactors, a, newRelationsOfA) => {
+      const { get, set } = transactors;
+      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
+      const currentRelationsOfA = get(relationsOfAState);
+      for (const currentRelationB of currentRelationsOfA) {
+        const remainsRelated = newRelationsOfA.includes(currentRelationB);
+        if (remainsRelated) {
+          continue;
+        }
+        const relationsOfBState = this.retrieve(
+          relatedKeysAtoms,
+          currentRelationB
+        );
+        set(relationsOfBState, (relationsOfB) => {
+          relationsOfB.delete(a);
+          return relationsOfB;
+        });
+      }
+      set(relationsOfAState, (relationsOfA) => {
+        relationsOfA.transaction((nextRelationsOfA) => {
+          nextRelationsOfA.clear();
+          for (const newRelationB of newRelationsOfA) {
+            const relationsOfB = getRelatedKeys(transactors, newRelationB);
+            const newRelationBIsAlreadyRelated = relationsOfB.has(a);
+            if (this.relations.cardinality === `1:n`) {
+              const previousOwnersToDispose = [];
+              for (const previousOwner of relationsOfB) {
+                if (previousOwner === a) {
+                  continue;
+                }
+                const previousOwnerRelations = getRelatedKeys(
+                  transactors,
+                  previousOwner
+                );
+                previousOwnerRelations.delete(newRelationB);
+                if (previousOwnerRelations.size === 0) {
+                  previousOwnersToDispose.push(previousOwner);
+                }
+              }
+              if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
+                relationsOfB.clear();
+              }
+              for (const previousOwner of previousOwnersToDispose) {
+                const molecule = this.molecules.get(previousOwner);
+                if (molecule) {
+                  this.transactors.dispose(molecule);
+                }
+                const sorted = [newRelationB, previousOwner].sort();
+                const compositeKey = `"${sorted[0]}:${sorted[1]}"`;
+                this.molecules.delete(compositeKey);
+              }
+            }
+            if (!newRelationBIsAlreadyRelated) {
+              relationsOfB.add(a);
+            }
+            nextRelationsOfA.add(newRelationB);
+          }
+          return true;
+        });
+        return relationsOfA;
+      });
+    };
+    const replaceRelationsUnsafely = (transactors, a, newRelationsOfA) => {
+      const { set } = transactors;
+      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
+      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 = this.retrieve(relatedKeysAtoms, newRelationB);
+        set(newRelationsBState, (newRelationsB) => {
+          newRelationsB.add(a);
+          return newRelationsB;
+        });
+      }
+      return true;
+    };
+    const has = (transactors, a, b) => {
+      const aKeys = getRelatedKeys(transactors, a);
+      return b ? aKeys.has(b) : aKeys.size > 0;
+    };
+    const baseExternalStoreConfiguration = {
+      getRelatedKeys: (key) => getRelatedKeys(this.transactors, key),
+      addRelation: (a, b) => {
+        addRelation(this.transactors, a, b);
+      },
+      deleteRelation: (a, b) => {
+        deleteRelation(this.transactors, a, b);
+      },
+      replaceRelationsSafely: (a, bs) => {
+        replaceRelationsSafely(this.transactors, a, bs);
+      },
+      replaceRelationsUnsafely: (a, bs) => {
+        replaceRelationsUnsafely(this.transactors, a, bs);
+      },
+      has: (a, b) => has(this.transactors, a, b)
+    };
+    let externalStore;
+    let contentAtoms;
+    let contentMolecules;
+    if (defaultContent) {
+      contentAtoms = createRegularAtomFamily(
+        {
+          key: `${options.key}/content`,
+          default: defaultContent
+        },
+        store
+      );
+      const joinToken = {
+        key: options.key,
+        type: `join`,
+        a: options.between[0],
+        b: options.between[1],
+        cardinality: options.cardinality
+      };
+      contentMolecules = createMoleculeFamily(
+        {
+          key: `${options.key}/content-molecules`,
+          new: class ContentMolecule {
+            constructor(transactors, key) {
+              this.key = key;
+              transactors.join(joinToken);
+            }
+          }
+        },
+        store
+      );
+      const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
+      const setContent = ({ set }, key, content) => {
+        set(this.retrieve(contentAtoms, key), content);
+      };
+      const deleteContent = (_, compositeKey) => {
+        const contentMolecule = store.molecules.get(`"${compositeKey}"`);
+        if (contentMolecule) {
+          this.transactors.dispose(contentMolecule);
+          this.molecules.delete(`"${compositeKey}"`);
+        }
+      };
+      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) => {
+        const sorted = args.sort();
+        const compositeKey = `${sorted[0]}:${sorted[1]}`;
+        const [m0, m1] = sorted.map(
+          (key) => this.molecules.get(stringifyJson(key))
+        );
+        if (store.config.lifespan === `immortal` && m0 && m1) {
+          const target = newest(store);
+          const moleculeToken = makeMoleculeInStore(
+            target,
+            [m0, m1],
+            contentMolecules,
+            compositeKey
+          );
+          this.molecules.set(
+            `"${compositeKey}"`,
+            withdraw(moleculeToken, target)
+          );
+        }
+        return compositeKey;
+      }
+    });
+    const createSingleKeyStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/singleRelatedKey`,
+        get: (key) => ({ get }) => {
+          const relatedKeysState = this.retrieve(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) => ({ get }) => {
+            const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+            const jsonState = this.retrieve(jsonFamily, key);
+            const json = get(jsonState);
+            return json.members;
+          }
+        },
+        store
+      );
+    };
+    const createSingleEntryStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/singleRelatedEntry`,
+        get: (key) => ({ get }) => {
+          const relatedKeysState = this.retrieve(relatedKeysAtoms, key);
+          const relatedKeys = get(relatedKeysState);
+          for (const relatedKey of relatedKeys) {
+            const contentKey = relations.makeContentKey(key, relatedKey);
+            const contentState = this.retrieve(contentAtoms, contentKey);
+            const content = get(contentState);
+            return [relatedKey, content];
+          }
+          return null;
+        }
+      },
+      store
+    );
+    const getMultipleEntryStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/multipleRelatedEntries`,
+        get: (key) => ({ get }) => {
+          const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+          const jsonState = this.retrieve(jsonFamily, key);
+          const json = get(jsonState);
+          return json.members.map((relatedKey) => {
+            const contentKey = relations.makeContentKey(key, relatedKey);
+            const contentState = this.retrieve(contentAtoms, contentKey);
+            const content = get(contentState);
+            return [relatedKey, content];
+          });
+        }
+      },
+      store
+    );
+    switch (options.cardinality) {
+      case `1:1`: {
+        const findSingleRelatedKeyState = createSingleKeyStateFamily();
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: findSingleRelatedKeyState,
+          [stateKeyB]: findSingleRelatedKeyState
+        };
+        let states;
+        if (defaultContent) {
+          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
+          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 = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: findSingleRelatedKeyState,
+          [stateKeyB]: findMultipleRelatedKeysState
+        };
+        let states;
+        if (defaultContent) {
+          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
+          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 = `${aSide}KeysOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: findMultipleRelatedKeysState,
+          [stateKeyB]: findMultipleRelatedKeysState
+        };
+        let states;
+        if (defaultContent) {
+          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
+            bSide
+          )}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
+          const contentStates = {
+            [entriesStateKeyA]: findMultipleRelatedEntriesState,
+            [entriesStateKeyB]: findMultipleRelatedEntriesState
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+      }
+    }
+  }
+  transact(transactors, run) {
+    const originalTransactors = this.transactors;
+    this.transactors = transactors;
+    run(this);
+    this.transactors = originalTransactors;
+  }
+  [Symbol.dispose]() {
+    this.alternates.delete(this.store.config.name);
+  }
+  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;
+  }
+};
+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 myJoin = joinMap.get(token.key);
+  if (myJoin === void 0) {
+    const rootJoinMap = getJoinMap(IMPLICIT.STORE);
+    myJoin = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (myJoin === void 0) {
+      throw new Error(
+        `Join "${token.key}" not found in store "${store.config.name}"`
+      );
+    }
+    joinMap.set(token.key, myJoin);
+  }
+  return myJoin;
+}
+function findRelationsInStore(token, key, store) {
+  const myJoin = 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 = myJoin.states[keyAB];
+          const state = myJoin.retrieve(familyAB, key);
+          return state;
+        },
+        get [keyBA]() {
+          const familyBA = myJoin.states[keyBA];
+          const state = myJoin.retrieve(familyBA, key);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in myJoin.states) {
+        const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = myJoin.states[entryAB];
+            const state = myJoin.retrieve(familyAB, key);
+            return state;
+          },
+          get [entryBA]() {
+            const familyBA = myJoin.states[entryBA];
+            const state = myJoin.retrieve(familyBA, key);
+            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 = myJoin.states[keyAB];
+          const state = myJoin.retrieve(familyAB, key);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = myJoin.states[keysBA];
+          const state = myJoin.retrieve(familyBA, key);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in myJoin.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = myJoin.states[entryAB];
+            const state = myJoin.retrieve(familyAB, key);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = myJoin.states[entriesBA];
+            const state = myJoin.retrieve(familyBA, key);
+            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 = myJoin.states[keysAB];
+          const state = myJoin.retrieve(familyAB, key);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = myJoin.states[keysBA];
+          const state = myJoin.retrieve(familyBA, key);
+          return state;
+        }
+      };
+      const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
+      if (entriesAB in myJoin.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entriesAB]() {
+            const familyAB = myJoin.states[entriesAB];
+            const state = myJoin.retrieve(familyAB, key);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = myJoin.states[entriesBA];
+            const state = myJoin.retrieve(familyBA, key);
+            return state;
+          }
+        });
+      }
+    }
+  }
+  return relations;
+}
+function findRelations(token, key) {
+  return findRelationsInStore(token, key, IMPLICIT.STORE);
+}
+function editRelationsInStore(token, change, store) {
+  const myJoin = getJoin(token, store);
+  const target = newest(store);
+  if (isChildStore(target)) {
+    const { transactors } = target.transactionMeta;
+    myJoin.transact(transactors, ({ relations }) => {
+      change(relations);
+    });
+  } else {
+    change(myJoin.relations);
+  }
+}
+function editRelations(token, change) {
+  editRelationsInStore(token, change, IMPLICIT.STORE);
+}
+function getInternalRelationsFromStore(token, store) {
+  const myJoin = getJoin(token, store);
+  const family = myJoin.core.findRelatedKeysState;
+  return family;
+}
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+}
+var capitalize2 = (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 + capitalize(key) + `State`;
+    const atomName = options.key + capitalize2(key) + `State`;
     acc[atomName] = createRegularAtom(
       {
         key: `${options.key}.${key}`,
@@ -37,7 +653,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 + capitalize(key) + `State`]);
+          acc[key] = get(atoms[options.key + capitalize2(key) + `State`]);
           return acc;
         }, {});
       }
@@ -46,8 +662,8 @@ function struct(options, store = IMPLICIT.STORE) {
   );
   return [atoms, structState];
 }
-var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
-var nameFamily = (topKey, subKey) => `find` + capitalize2(topKey) + capitalize2(subKey) + `State`;
+var capitalize3 = (str) => str[0].toUpperCase() + str.slice(1);
+var nameFamily = (topKey, subKey) => `find` + capitalize3(topKey) + capitalize3(subKey) + `State`;
 function structFamily(options) {
   const atoms = Object.keys(options.default).reduce((acc, subKey) => {
     const atomFamilyName = nameFamily(options.key, subKey);
@@ -85,4 +701,4 @@ function until(loadable, fallback) {
   return loadable;
 }
 
-export { dict, struct, structFamily, until };
+export { Join, dict, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join, struct, structFamily, until };