atom.io 0.23.4 → 0.24.0

package/dist/chunk-7DT3PVS3.js

@@ -1,598 +0,0 @@
-import { Junction } from './chunk-FTONNX2R.js';
-import { disposeState } from 'atom.io';
-import { createMoleculeFamily, Molecule, makeMoleculeInStore } from 'atom.io/immortal';
-import { getFromStore, setIntoStore, findInStore, seekInStore, getJsonToken, initFamilyMember, createMutableAtomFamily, createRegularAtomFamily, newest, IMPLICIT, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
-import { stringifyJson } from 'atom.io/json';
-import { SetRTX } from 'atom.io/transceivers/set-rtx';
-
-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)
-    };
-    this.retrieve = (token, key) => {
-      const maybeToken = this.transactors.seek(token, key);
-      if (maybeToken) {
-        return maybeToken;
-      }
-      const molecule = this.molecules.get(stringifyJson(key));
-      if (!molecule) {
-        if (store.config.lifespan === `immortal`) {
-          throw new Error(`No molecule found for key "${stringifyJson(key)}"`);
-        }
-        return initFamilyMember(token, key, store);
-      }
-      return molecule.bond(token);
-    };
-    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) => {
-      var _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 && this.molecules.has(stringA)) {
-        (_a = this.molecules.get(stringA)) == null ? void 0 : _a.clear();
-        this.molecules.delete(stringA);
-      }
-      if (stringB && this.molecules.has(stringB)) {
-        (_b = this.molecules.get(stringB)) == null ? void 0 : _b.clear();
-        this.molecules.delete(stringB);
-      }
-    };
-    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);
-                molecule == null ? void 0 : molecule.clear();
-                this.molecules.delete(previousOwner);
-                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
-      );
-      contentMolecules = createMoleculeFamily(
-        {
-          key: `${options.key}/content-molecules`,
-          new: (s) => class ContentMolecule extends Molecule {
-            constructor(context, token) {
-              super(s, context, token);
-            }
-          }
-        },
-        store
-      );
-      const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
-      const setContent = ({ set }, key, content) => {
-        set(this.retrieve(contentAtoms, key), content);
-      };
-      const deleteContent = (_, compositeKey) => {
-        disposeState(this.retrieve(contentAtoms, compositeKey));
-        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 composite = m0.with(m1)(compositeKey);
-          this.molecules.set(`"${compositeKey}"`, composite);
-          const target = newest(store);
-          makeMoleculeInStore(target, [m0, m1], contentMolecules, compositeKey);
-        }
-        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);
-}
-
-export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join };