atom.io 0.23.5 → 0.24.1

package/data/dist/index.cjs

@@ -1,8 +1,6 @@
 'use strict';
 
 var internal = require('atom.io/internal');
-var atom_io = require('atom.io');
-var immortal = require('atom.io/immortal');
 var json = require('atom.io/json');
 var setRtx = require('atom.io/transceivers/set-rtx');
 
@@ -301,7 +299,10 @@ var Join = class _Join {
       },
       find: (token, key) => internal.findInStore(token, key, store),
       seek: (token, key) => internal.seekInStore(token, key, store),
-      json: (token) => internal.getJsonToken(token, store)
+      json: (token) => internal.getJsonToken(token, store),
+      dispose: (token) => {
+        internal.disposeFromStore(token, store);
+      }
     };
     this.retrieve = (token, key) => {
       const maybeToken = this.transactors.seek(token, key);
@@ -309,13 +310,14 @@ var Join = class _Join {
         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);
+      if (molecule) {
+        const family = internal.withdraw(token, store);
+        return internal.growMoleculeInStore(molecule, family, store);
+      }
+      if (store.config.lifespan === `immortal`) {
+        throw new Error(`No molecule found for key "${json.stringifyJson(key)}"`);
       }
-      return molecule.bond(token);
+      return internal.initFamilyMemberInStore(token, key, store);
     };
     const aSide = options.between[0];
     const bSide = options.between[1];
@@ -339,7 +341,6 @@ var Join = class _Join {
       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);
@@ -359,13 +360,17 @@ var Join = class _Join {
         }
         return bKeys;
       });
-      if (stringA && this.molecules.has(stringA)) {
-        (_a = this.molecules.get(stringA)) == null ? void 0 : _a.clear();
-        this.molecules.delete(stringA);
+      if (stringA) {
+        const molecule = this.molecules.get(stringA);
+        if (molecule) {
+          this.transactors.dispose(molecule);
+        }
       }
-      if (stringB && this.molecules.has(stringB)) {
-        (_b = this.molecules.get(stringB)) == null ? void 0 : _b.clear();
-        this.molecules.delete(stringB);
+      if (stringB) {
+        const molecule = this.molecules.get(stringB);
+        if (molecule) {
+          this.transactors.dispose(molecule);
+        }
       }
     };
     const replaceRelationsSafely = (transactors, a, newRelationsOfA) => {
@@ -412,8 +417,9 @@ var Join = class _Join {
               }
               for (const previousOwner of previousOwnersToDispose) {
                 const molecule = this.molecules.get(previousOwner);
-                molecule == null ? void 0 : molecule.clear();
-                this.molecules.delete(previousOwner);
+                if (molecule) {
+                  this.transactors.dispose(molecule);
+                }
                 const sorted = [newRelationB, previousOwner].sort();
                 const compositeKey = `"${sorted[0]}:${sorted[1]}"`;
                 this.molecules.delete(compositeKey);
@@ -481,12 +487,20 @@ var Join = class _Join {
         },
         store
       );
-      contentMolecules = immortal.createMoleculeFamily(
+      const joinToken = {
+        key: options.key,
+        type: `join`,
+        a: options.between[0],
+        b: options.between[1],
+        cardinality: options.cardinality
+      };
+      contentMolecules = internal.createMoleculeFamily(
         {
           key: `${options.key}/content-molecules`,
-          new: (s) => class ContentMolecule extends immortal.Molecule {
-            constructor(context, token) {
-              super(s, context, token);
+          new: class ContentMolecule {
+            constructor(transactors, key) {
+              this.key = key;
+              transactors.join(joinToken);
             }
           }
         },
@@ -497,8 +511,11 @@ var Join = class _Join {
         set(this.retrieve(contentAtoms, key), content);
       };
       const deleteContent = (_, compositeKey) => {
-        atom_io.disposeState(this.retrieve(contentAtoms, compositeKey));
-        this.molecules.delete(`"${compositeKey}"`);
+        const contentMolecule = store.molecules.get(`"${compositeKey}"`);
+        if (contentMolecule) {
+          this.transactors.dispose(contentMolecule);
+          this.molecules.delete(`"${compositeKey}"`);
+        }
       };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {
@@ -528,10 +545,17 @@ var Join = class _Join {
           (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);
           const target = internal.newest(store);
-          immortal.makeMoleculeInStore(target, [m0, m1], contentMolecules, compositeKey);
+          const moleculeToken = internal.makeMoleculeInStore(
+            target,
+            [m0, m1],
+            contentMolecules,
+            compositeKey
+          );
+          this.molecules.set(
+            `"${compositeKey}"`,
+            internal.withdraw(moleculeToken, target)
+          );
         }
         return compositeKey;
       }

package/data/dist/index.d.ts

@@ -1,9 +1,8 @@
 import * as AtomIO from 'atom.io';
-import { ReadonlySelectorFamily, MutableAtomFamily, Transactors, ReadonlySelectorToken, MutableAtomFamilyToken } from 'atom.io';
-import { Store } from 'atom.io/internal';
+import { ReadonlySelectorFamily, MutableAtomFamily, Transactors, disposeState, ReadonlySelectorToken, MutableAtomFamilyToken } from 'atom.io';
+import { Store, Molecule } 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<{
@@ -128,7 +127,9 @@ declare class Join<const ASide extends string, const BSide extends string, const
     core: {
         findRelatedKeysState: MutableAtomFamily<SetRTX<string>, SetRTXJson<string>, string>;
     };
-    transact(transactors: Transactors, run: (join: Join<ASide, BSide, Cardinality, Content>) => void): void;
+    transact(transactors: Transactors & {
+        dispose: typeof disposeState;
+    }, run: (join: Join<ASide, BSide, Cardinality, Content>) => void): void;
     store: Store;
     alternates: Map<string, Join<ASide, BSide, Cardinality, Content>>;
     [Symbol.dispose](): void;