atom.io 0.21.0 → 0.22.0

package/data/dist/index.cjs

@@ -2,17 +2,18 @@
 
 var internal = require('atom.io/internal');
 var atom_io = require('atom.io');
+var json = require('atom.io/json');
 var setRtx = require('atom.io/transceivers/set-rtx');
 
 // data/src/dict.ts
-function dict(findState2, index, store = internal.IMPLICIT.STORE) {
+function dict(findState, index, store = internal.IMPLICIT.STORE) {
   return internal.createStandaloneSelector(
     {
-      key: `${findState2.key}Dict`,
+      key: `${findState.key}Dict`,
       get: ({ get }) => {
         const keys = get(index);
         return keys.reduce((acc, key) => {
-          acc[key] = get(internal.findInStore(findState2, key, store));
+          acc[key] = get(internal.findInStore(findState, key, store));
           return acc;
         }, {});
       }
@@ -284,34 +285,35 @@ 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 = internal.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) => internal.getFromStore(token, store),
       set: (token, value) => {
         internal.setIntoStore(token, value, store);
       },
-      find: (token, key) => internal.findInStore(token, key, store)
+      find: (token, key) => internal.findInStore(token, key, store),
+      seek: (token, key) => internal.seekInStore(token, key, store)
+    };
+    this.retrieve = (token, key) => {
+      const maybeToken = this.transactors.seek(token, key);
+      if (maybeToken) {
+        return maybeToken;
+      }
+      const molecule = this.molecules.get(json.stringifyJson(key));
+      if (!molecule) {
+        if (store.config.lifespan === `immortal`) {
+          throw new Error(`No molecule found for key "${json.stringifyJson(key)}"`);
+        }
+        return internal.initFamilyMember(token, key, store);
+      }
+      return molecule.bond(token);
     };
     const aSide = options.between[0];
     const bSide = options.between[1];
@@ -326,31 +328,57 @@ var Join = class _Join {
       store
     );
     this.core = { findRelatedKeysState: relatedKeysAtoms };
-    const getRelatedKeys = ({ find, get }, key) => get(find(relatedKeysAtoms, key));
+    const getRelatedKeys = ({ get }, key) => get(this.retrieve(relatedKeysAtoms, key));
     const addRelation = (transactors, a, b) => {
-      const { set, find } = transactors;
-      const aKeysState = find(relatedKeysAtoms, a);
-      const bKeysState = find(relatedKeysAtoms, 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 { find, set } = transactors;
-      const aKeysState = find(relatedKeysAtoms, a);
-      const bKeysState = find(relatedKeysAtoms, b);
-      set(aKeysState, (aKeys) => (aKeys.delete(b), aKeys));
-      set(bKeysState, (bKeys) => (bKeys.delete(a), bKeys));
+      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 { find, get, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a);
+      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 = find(relatedKeysAtoms, currentRelationB);
+        const relationsOfBState = this.retrieve(
+          relatedKeysAtoms,
+          currentRelationB
+        );
         set(relationsOfBState, (relationsOfB) => {
           relationsOfB.delete(a);
           return relationsOfB;
@@ -363,6 +391,7 @@ var Join = class _Join {
             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;
@@ -372,10 +401,21 @@ var Join = class _Join {
                   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);
@@ -388,8 +428,8 @@ var Join = class _Join {
       });
     };
     const replaceRelationsUnsafely = (transactors, a, newRelationsOfA) => {
-      const { find, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a);
+      const { set } = transactors;
+      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
       set(relationsOfAState, (relationsOfA) => {
         relationsOfA.transaction((nextRelationsOfA) => {
           for (const newRelationB of newRelationsOfA) {
@@ -400,7 +440,7 @@ var Join = class _Join {
         return relationsOfA;
       });
       for (const newRelationB of newRelationsOfA) {
-        const newRelationsBState = find(relatedKeysAtoms, newRelationB);
+        const newRelationsBState = this.retrieve(relatedKeysAtoms, newRelationB);
         set(newRelationsBState, (newRelationsB) => {
           newRelationsB.add(a);
           return newRelationsB;
@@ -438,12 +478,13 @@ var Join = class _Join {
         },
         store
       );
-      const getContent = ({ find, get }, key) => get(find(contentAtoms, key));
-      const setContent = ({ find, set }, key, content) => {
-        set(find(contentAtoms, key), content);
+      const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
+      const setContent = ({ set }, key, content) => {
+        set(this.retrieve(contentAtoms, key), content);
       };
-      const deleteContent = ({ find }, key) => {
-        atom_io.disposeState(find(contentAtoms, key));
+      const deleteContent = (_, compositeKey) => {
+        atom_io.disposeState(this.retrieve(contentAtoms, compositeKey));
+        this.molecules.delete(`"${compositeKey}"`);
       };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {
@@ -466,13 +507,24 @@ var Join = class _Join {
     }
     const relations = new Junction(options, {
       externalStore,
-      makeContentKey: (...args) => args.sort().join(`:`)
+      makeContentKey: (...args) => {
+        const sorted = args.sort();
+        const compositeKey = `${sorted[0]}:${sorted[1]}`;
+        const [m0, m1] = sorted.map(
+          (key) => this.molecules.get(json.stringifyJson(key))
+        );
+        if (store.config.lifespan === `immortal` && m0 && m1) {
+          const composite = m0.with(m1)(compositeKey);
+          this.molecules.set(`"${compositeKey}"`, composite);
+        }
+        return compositeKey;
+      }
     });
     const createSingleKeyStateFamily = () => internal.createSelectorFamily(
       {
         key: `${options.key}/singleRelatedKey`,
-        get: (key) => ({ find, get }) => {
-          const relatedKeysState = find(relatedKeysAtoms, key);
+        get: (key) => ({ get }) => {
+          const relatedKeysState = this.retrieve(relatedKeysAtoms, key);
           const relatedKeys = get(relatedKeysState);
           for (const relatedKey of relatedKeys) {
             return relatedKey;
@@ -486,9 +538,9 @@ var Join = class _Join {
       return internal.createSelectorFamily(
         {
           key: `${options.key}/multipleRelatedKeys`,
-          get: (key) => ({ find, get }) => {
+          get: (key) => ({ get }) => {
             const jsonFamily = internal.getJsonFamily(relatedKeysAtoms, store);
-            const jsonState = find(jsonFamily, key);
+            const jsonState = this.retrieve(jsonFamily, key);
             const json = get(jsonState);
             return json.members;
           }
@@ -499,12 +551,12 @@ var Join = class _Join {
     const createSingleEntryStateFamily = () => internal.createSelectorFamily(
       {
         key: `${options.key}/singleRelatedEntry`,
-        get: (key) => ({ find, get }) => {
-          const relatedKeysState = find(relatedKeysAtoms, key);
+        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 = find(contentAtoms, contentKey);
+            const contentState = this.retrieve(contentAtoms, contentKey);
             const content = get(contentState);
             return [relatedKey, content];
           }
@@ -516,12 +568,13 @@ var Join = class _Join {
     const getMultipleEntryStateFamily = () => internal.createSelectorFamily(
       {
         key: `${options.key}/multipleRelatedEntries`,
-        get: (key) => ({ find, get }) => {
+        get: (key) => ({ get }) => {
           const jsonFamily = internal.getJsonFamily(relatedKeysAtoms, store);
-          const json = get(jsonFamily(key));
+          const jsonState = this.retrieve(jsonFamily, key);
+          const json = get(jsonState);
           return json.members.map((relatedKey) => {
             const contentKey = relations.makeContentKey(key, relatedKey);
-            const contentState = find(contentAtoms, contentKey);
+            const contentState = this.retrieve(contentAtoms, contentKey);
             const content = get(contentState);
             return [relatedKey, content];
           });
@@ -614,6 +667,26 @@ var Join = class _Join {
       }
     }
   }
+  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 = internal.IMPLICIT.STORE) {
   const joins = getJoinMap(store);
@@ -661,12 +734,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keyAB]() {
           const familyAB = myJoin.states[keyAB];
-          const state = internal.findInStore(familyAB, key, store);
+          const state = myJoin.retrieve(familyAB, key);
           return state;
         },
         get [keyBA]() {
           const familyBA = myJoin.states[keyBA];
-          const state = internal.findInStore(familyBA, key, store);
+          const state = myJoin.retrieve(familyBA, key);
           return state;
         }
       };
@@ -676,12 +749,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entryAB]() {
             const familyAB = myJoin.states[entryAB];
-            const state = internal.findInStore(familyAB, key, store);
+            const state = myJoin.retrieve(familyAB, key);
             return state;
           },
           get [entryBA]() {
             const familyBA = myJoin.states[entryBA];
-            const state = internal.findInStore(familyBA, key, store);
+            const state = myJoin.retrieve(familyBA, key);
             return state;
           }
         });
@@ -694,12 +767,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keyAB]() {
           const familyAB = myJoin.states[keyAB];
-          const state = internal.findInStore(familyAB, key, store);
+          const state = myJoin.retrieve(familyAB, key);
           return state;
         },
         get [keysBA]() {
           const familyBA = myJoin.states[keysBA];
-          const state = internal.findInStore(familyBA, key, store);
+          const state = myJoin.retrieve(familyBA, key);
           return state;
         }
       };
@@ -709,12 +782,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entryAB]() {
             const familyAB = myJoin.states[entryAB];
-            const state = internal.findInStore(familyAB, key, store);
+            const state = myJoin.retrieve(familyAB, key);
             return state;
           },
           get [entriesBA]() {
             const familyBA = myJoin.states[entriesBA];
-            const state = internal.findInStore(familyBA, key, store);
+            const state = myJoin.retrieve(familyBA, key);
             return state;
           }
         });
@@ -727,12 +800,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keysAB]() {
           const familyAB = myJoin.states[keysAB];
-          const state = internal.findInStore(familyAB, key, store);
+          const state = myJoin.retrieve(familyAB, key);
           return state;
         },
         get [keysBA]() {
           const familyBA = myJoin.states[keysBA];
-          const state = internal.findInStore(familyBA, key, store);
+          const state = myJoin.retrieve(familyBA, key);
           return state;
         }
       };
@@ -742,12 +815,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entriesAB]() {
             const familyAB = myJoin.states[entriesAB];
-            const state = internal.findInStore(familyAB, key, store);
+            const state = myJoin.retrieve(familyAB, key);
             return state;
           },
           get [entriesBA]() {
             const familyBA = myJoin.states[entriesBA];
-            const state = internal.findInStore(familyBA, key, store);
+            const state = myJoin.retrieve(familyBA, key);
             return state;
           }
         });
@@ -827,10 +900,10 @@ function structFamily(options) {
   const findStructState = internal.createSelectorFamily(
     {
       key: options.key,
-      get: (id) => ({ get }) => {
+      get: (id) => ({ find, get }) => {
         return Object.keys(options.default).reduce((acc, subKey) => {
           acc[subKey] = get(
-            atoms[nameFamily(options.key, subKey)](id)
+            find(atoms[nameFamily(options.key, subKey)], id)
           );
           return acc;
         }, {});

package/data/dist/index.d.ts

@@ -2,6 +2,8 @@ import * as AtomIO 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 { findState } from 'atom.io/ephemeral';
+import { Molecule } from 'atom.io/immortal';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 declare function dict<State, Key extends Json.Serializable>(findState: AtomIO.ReadonlySelectorFamilyToken<State, Key> | AtomIO.RegularAtomFamilyToken<State, Key> | AtomIO.WritableSelectorFamily<State, Key>, index: AtomIO.ReadonlySelectorToken<Key[]> | AtomIO.RegularAtomToken<Key[]> | AtomIO.WritableSelectorToken<Key[]>, store?: Store): AtomIO.ReadonlySelectorToken<{
@@ -119,13 +121,17 @@ declare class Join<const ASide extends string, const BSide extends string, const
     private options;
     private defaultContent;
     private transactors;
+    retrieve: typeof findState;
+    molecules: Map<string, Molecule<any>>;
     relations: Junction<ASide, BSide, Content>;
     states: JoinStateFamilies<ASide, BSide, Cardinality, Content>;
     core: {
         findRelatedKeysState: MutableAtomFamily<SetRTX<string>, SetRTXJson<string>, string>;
     };
     transact(transactors: Transactors, run: (join: Join<ASide, BSide, Cardinality, Content>) => void): void;
+    store: Store;
     alternates: Map<string, Join<ASide, BSide, Cardinality, Content>>;
+    [Symbol.dispose](): void;
     in(store: Store): Join<ASide, BSide, Cardinality, Content>;
     constructor(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
 }

package/data/dist/index.js

@@ -1,4 +1,4 @@
-export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-KGZGBCYS.js';
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-JA4V7TJY.js';
 import '../../dist/chunk-FTONNX2R.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';
@@ -63,10 +63,10 @@ function structFamily(options) {
   const findStructState = createSelectorFamily(
     {
       key: options.key,
-      get: (id) => ({ get }) => {
+      get: (id) => ({ find, get }) => {
         return Object.keys(options.default).reduce((acc, subKey) => {
           acc[subKey] = get(
-            atoms[nameFamily(options.key, subKey)](id)
+            find(atoms[nameFamily(options.key, subKey)], id)
           );
           return acc;
         }, {});