atom.io 0.31.1 → 0.32.0

package/data/dist/index.js

@@ -1,9 +1,7 @@
+import { createStandaloneSelector, findInStore, IMPLICIT, capitalize, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from '../../dist/chunk-GY2XQYZY.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { createStandaloneSelector, findInStore, IMPLICIT, getFromStore, setIntoStore, seekInStore, getJsonToken, createMutableAtomFamily, createRegularAtomFamily, Junction, newest, isChildStore, createRegularAtom, createSelectorFamily, createReadonlySelectorFamily, getJsonFamily } from 'atom.io/internal';
-import { Anarchy } from 'atom.io';
-import { stringifyJson } from 'atom.io/json';
-import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
+// data/src/dict.ts
 function dict(family, index, store = IMPLICIT.STORE) {
   return createStandaloneSelector(store, {
     key: `${family.key}Dict`,
@@ -16,550 +14,11 @@ function dict(family, index, store = IMPLICIT.STORE) {
     }
   });
 }
-function capitalize(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
-var Join = class {
-  toolkit;
-  options;
-  defaultContent;
-  molecules = /* @__PURE__ */ new Map();
-  relations;
-  states;
-  core;
-  transact(toolkit, run) {
-    const originalToolkit = this.toolkit;
-    this.toolkit = toolkit;
-    run(this);
-    this.toolkit = originalToolkit;
-  }
-  store;
-  realm;
-  [Symbol.dispose]() {
-  }
-  constructor(options, defaultContent, store = IMPLICIT.STORE) {
-    this.store = store;
-    this.realm = new Anarchy(store);
-    this.options = options;
-    this.defaultContent = defaultContent;
-    this.store.miscResources.set(`join:${options.key}`, this);
-    this.realm.allocate(`root`, options.key);
-    this.toolkit = {
-      get: (...ps) => getFromStore(store, ...ps),
-      set: (...ps) => {
-        setIntoStore(store, ...ps);
-      },
-      find: (...ps) => findInStore(store, ...ps),
-      seek: (...ps) => seekInStore(store, ...ps),
-      json: (token) => getJsonToken(store, token)
-    };
-    const aSide = options.between[0];
-    const bSide = options.between[1];
-    const relatedKeysAtoms = createMutableAtomFamily(
-      store,
-      {
-        key: `${options.key}/relatedKeys`,
-        default: () => new SetRTX(),
-        mutable: true,
-        fromJson: (json) => SetRTX.fromJSON(json),
-        toJson: (set) => set.toJSON()
-      },
-      [`join`, `relations`]
-    );
-    this.core = { relatedKeysAtoms };
-    const getRelatedKeys = ({ get }, key) => get(relatedKeysAtoms, key);
-    const addRelation = ({ set }, a, b) => {
-      if (!this.store.molecules.has(stringifyJson(a))) {
-        this.realm.allocate(options.key, a);
-      }
-      set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b));
-      set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a));
-    };
-    const deleteRelation = ({ set }, a, b) => {
-      set(relatedKeysAtoms, a, (aKeys) => {
-        aKeys.delete(b);
-        return aKeys;
-      });
-      set(relatedKeysAtoms, b, (bKeys) => {
-        bKeys.delete(a);
-        return bKeys;
-      });
-    };
-    const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
-      const { find, get, set } = toolkit;
-      const relationsOfAState = find(relatedKeysAtoms, a);
-      const currentRelationsOfA = get(relationsOfAState);
-      for (const currentRelationB of currentRelationsOfA) {
-        const remainsRelated = newRelationsOfA.includes(currentRelationB);
-        if (remainsRelated) {
-          continue;
-        }
-        set(relatedKeysAtoms, currentRelationB, (relationsOfB) => {
-          relationsOfB.delete(a);
-          return relationsOfB;
-        });
-      }
-      set(relationsOfAState, (relationsOfA) => {
-        relationsOfA.transaction((nextRelationsOfA) => {
-          nextRelationsOfA.clear();
-          for (const newRelationB of newRelationsOfA) {
-            const relationsOfB = getRelatedKeys(toolkit, 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(
-                  toolkit,
-                  previousOwner
-                );
-                previousOwnerRelations.delete(newRelationB);
-                if (previousOwnerRelations.size === 0) {
-                  previousOwnersToDispose.push(previousOwner);
-                }
-              }
-              if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
-                relationsOfB.clear();
-              }
-              for (const previousOwner of previousOwnersToDispose) {
-                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 = (toolkit, a, newRelationsOfA) => {
-      const { set } = toolkit;
-      set(relatedKeysAtoms, a, (relationsOfA) => {
-        relationsOfA.transaction((nextRelationsOfA) => {
-          for (const newRelationB of newRelationsOfA) {
-            nextRelationsOfA.add(newRelationB);
-          }
-          return true;
-        });
-        return relationsOfA;
-      });
-      for (const newRelationB of newRelationsOfA) {
-        set(relatedKeysAtoms, newRelationB, (newRelationsB) => {
-          newRelationsB.add(a);
-          return newRelationsB;
-        });
-      }
-      return true;
-    };
-    const has = (toolkit, a, b) => {
-      const aKeys = getRelatedKeys(toolkit, a);
-      return b ? aKeys.has(b) : aKeys.size > 0;
-    };
-    const baseExternalStoreConfiguration = {
-      getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
-      addRelation: (a, b) => {
-        this.store.moleculeJoins.set(
-          a,
-          options.key
-        );
-        this.store.moleculeJoins.set(
-          b,
-          options.key
-        );
-        addRelation(this.toolkit, a, b);
-      },
-      deleteRelation: (a, b) => {
-        deleteRelation(this.toolkit, a, b);
-      },
-      replaceRelationsSafely: (a, bs) => {
-        replaceRelationsSafely(this.toolkit, a, bs);
-      },
-      replaceRelationsUnsafely: (a, bs) => {
-        replaceRelationsUnsafely(this.toolkit, a, bs);
-      },
-      has: (a, b) => has(this.toolkit, a, b)
-    };
-    let externalStore;
-    let contentAtoms;
-    if (defaultContent) {
-      contentAtoms = createRegularAtomFamily(
-        store,
-        {
-          key: `${options.key}/content`,
-          default: defaultContent
-        },
-        [`join`, `content`]
-      );
-      const getContent = ({ get }, key) => get(contentAtoms, key);
-      const setContent = ({ set }, key, content) => {
-        set(contentAtoms, key, content);
-      };
-      const externalStoreWithContentConfiguration = {
-        getContent: (contentKey) => {
-          const content = getContent(this.toolkit, contentKey);
-          return content;
-        },
-        setContent: (contentKey, content) => {
-          setContent(this.toolkit, contentKey, content);
-        },
-        deleteContent: (contentKey) => {
-          this.realm.deallocate(contentKey);
-        }
-      };
-      externalStore = Object.assign(
-        baseExternalStoreConfiguration,
-        externalStoreWithContentConfiguration
-      );
-    } else {
-      externalStore = baseExternalStoreConfiguration;
-    }
-    const relations = new Junction(
-      options,
-      {
-        externalStore,
-        isAType: options.isAType,
-        isBType: options.isBType,
-        makeContentKey: (...args) => {
-          const [a, b] = args;
-          const sorted = args.sort();
-          const compositeKey = `${sorted[0]}:${sorted[1]}`;
-          const aMolecule = store.molecules.get(stringifyJson(a));
-          const bMolecule = store.molecules.get(stringifyJson(b));
-          if (!aMolecule) {
-            this.realm.allocate(options.key, a);
-          }
-          if (!bMolecule) {
-            this.realm.allocate(options.key, b);
-          }
-          this.realm.allocate(a, compositeKey, `all`);
-          this.realm.claim(b, compositeKey);
-          this.store.moleculeJoins.set(compositeKey, options.key);
-          return compositeKey;
-        }
-      }
-    );
-    const createSingleKeySelectorFamily = () => createReadonlySelectorFamily(
-      store,
-      {
-        key: `${options.key}/singleRelatedKey`,
-        get: (key) => ({ get }) => {
-          const relatedKeys = get(relatedKeysAtoms, key);
-          for (const relatedKey of relatedKeys) {
-            return relatedKey;
-          }
-          return null;
-        }
-      },
-      [`join`, `keys`]
-    );
-    const getMultipleKeySelectorFamily = () => {
-      return createReadonlySelectorFamily(
-        store,
-        {
-          key: `${options.key}/multipleRelatedKeys`,
-          get: (key) => ({ get }) => {
-            const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-            const json = get(jsonFamily, key);
-            return json.members;
-          }
-        },
-        [`join`, `keys`]
-      );
-    };
-    const createSingleEntrySelectorFamily = () => createReadonlySelectorFamily(
-      store,
-      {
-        key: `${options.key}/singleRelatedEntry`,
-        get: (x) => ({ get }) => {
-          const relatedKeys = get(relatedKeysAtoms, x);
-          for (const y of relatedKeys) {
-            let a = relations.isAType?.(x) ? x : undefined;
-            let b = a === undefined ? x : undefined;
-            a ??= y;
-            b ??= y;
-            const contentKey = relations.makeContentKey(a, b);
-            const content = get(contentAtoms, contentKey);
-            return [y, content];
-          }
-          return null;
-        }
-      },
-      [`join`, `entries`]
-    );
-    const getMultipleEntrySelectorFamily = () => createReadonlySelectorFamily(
-      store,
-      {
-        key: `${options.key}/multipleRelatedEntries`,
-        get: (x) => ({ get }) => {
-          const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-          const json = get(jsonFamily, x);
-          return json.members.map((y) => {
-            let a = relations.isAType?.(x) ? x : undefined;
-            let b = a === undefined ? x : undefined;
-            a ??= y;
-            b ??= y;
-            const contentKey = relations.makeContentKey(a, b);
-            const content = get(contentAtoms, contentKey);
-            return [y, content];
-          });
-        }
-      },
-      [`join`, `entries`]
-    );
-    switch (options.cardinality) {
-      case `1:1`: {
-        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: singleRelatedKeySelectors,
-          [stateKeyB]: singleRelatedKeySelectors
-        };
-        let states;
-        if (defaultContent) {
-          const singleEntrySelectors = createSingleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
-          const contentStates = {
-            [entriesStateKeyA]: singleEntrySelectors,
-            [entriesStateKeyB]: singleEntrySelectors
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-        break;
-      }
-      case `1:n`: {
-        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
-        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: singleRelatedKeySelectors,
-          [stateKeyB]: multipleRelatedKeysSelectors
-        };
-        let states;
-        if (defaultContent) {
-          const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
-          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
-            aSide
-          )}`;
-          const contentStates = {
-            [entriesStateKeyA]: singleRelatedEntrySelectors,
-            [entriesStateKeyB]: multipleRelatedEntriesSelectors
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-        break;
-      }
-      default: {
-        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: multipleRelatedKeysSelectors,
-          [stateKeyB]: multipleRelatedKeysSelectors
-        };
-        let states;
-        if (defaultContent) {
-          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
-            bSide
-          )}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
-            aSide
-          )}`;
-          const contentStates = {
-            [entriesStateKeyA]: multipleRelatedEntriesSelectors,
-            [entriesStateKeyB]: multipleRelatedEntriesSelectors
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-      }
-    }
-  }
-};
-function join(options, defaultContent, store = IMPLICIT.STORE) {
-  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 getJoin(token, store) {
-  let myJoin = store.joins.get(token.key);
-  if (myJoin === undefined) {
-    const rootJoinMap = IMPLICIT.STORE.joins;
-    const rootJoin = rootJoinMap.get(token.key);
-    if (rootJoin === undefined) {
-      throw new Error(
-        `Join "${token.key}" not found in store "${store.config.name}"`
-      );
-    }
-    myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store);
-    store.joins.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 = findInStore(store, familyAB, key);
-          return state;
-        },
-        get [keyBA]() {
-          const familyBA = myJoin.states[keyBA];
-          const state = findInStore(store, 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 = findInStore(store, familyAB, key);
-            return state;
-          },
-          get [entryBA]() {
-            const familyBA = myJoin.states[entryBA];
-            const state = findInStore(store, 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 = findInStore(store, familyAB, key);
-          return state;
-        },
-        get [keysBA]() {
-          const familyBA = myJoin.states[keysBA];
-          const state = findInStore(store, 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 = findInStore(store, familyAB, key);
-            return state;
-          },
-          get [entriesBA]() {
-            const familyBA = myJoin.states[entriesBA];
-            const state = findInStore(store, 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 = findInStore(store, familyAB, key);
-          return state;
-        },
-        get [keysBA]() {
-          const familyBA = myJoin.states[keysBA];
-          const state = findInStore(store, 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 = findInStore(store, familyAB, key);
-            return state;
-          },
-          get [entriesBA]() {
-            const familyBA = myJoin.states[entriesBA];
-            const state = findInStore(store, 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 { toolkit } = target.transactionMeta;
-    myJoin.transact(toolkit, ({ 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.relatedKeysAtoms;
-  return family;
-}
-function getInternalRelations(token) {
-  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
-}
-var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
+
+// data/src/struct.ts
 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(
       store,
       {
@@ -574,15 +33,16 @@ 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;
       }, {});
     }
   });
   return [atoms, structState];
 }
-var capitalize3 = (str) => str[0].toUpperCase() + str.slice(1);
-var nameFamily = (topKey, subKey) => `find` + capitalize3(topKey) + capitalize3(subKey) + `State`;
+
+// data/src/struct-family.ts
+var nameFamily = (topKey, subKey) => `find` + capitalize(topKey) + capitalize(subKey) + `State`;
 function structFamily(options) {
   const atoms = Object.keys(options.default).reduce((acc, subKey) => {
     const atomFamilyName = nameFamily(options.key, subKey);
@@ -606,12 +66,4 @@ function structFamily(options) {
   return [atoms, findStructState];
 }
 
-// data/src/until.ts
-function until(loadable, fallback) {
-  if (loadable instanceof Promise) {
-    return fallback;
-  }
-  return loadable;
-}
-
-export { Join, dict, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, join, struct, structFamily, until };
+export { dict, struct, structFamily };

package/data/src/index.ts

@@ -1,5 +1,3 @@
 export * from "./dict"
-export * from "./join"
 export * from "./struct"
 export * from "./struct-family"
-export * from "./until"

package/data/src/struct-family.ts

@@ -1,11 +1,11 @@
 import type * as AtomIO from "atom.io"
 import {
+	capitalize,
 	createRegularAtomFamily,
 	createSelectorFamily,
 	IMPLICIT,
 } from "atom.io/internal"
 
-const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
 const nameFamily = (topKey: string, subKey: string) =>
 	`find` + capitalize(topKey) + capitalize(subKey) + `State`
 

package/data/src/struct.ts

@@ -1,13 +1,12 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
+	capitalize,
 	createRegularAtom,
 	createStandaloneSelector,
 	IMPLICIT,
 } from "atom.io/internal"
 
-const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
-
 export function struct<
 	Struct extends { [key: string]: unknown },
 	Key extends string,