atom.io 0.23.4 → 0.24.0

package/internal/dist/index.cjs

@@ -2,28 +2,7 @@
 
 var json = require('atom.io/json');
 var atom_io = require('atom.io');
-var immortal = require('atom.io/immortal');
-var Internal = require('atom.io/internal');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
+var data = require('atom.io/data');
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -102,26 +81,14 @@ function newest(scion) {
 
 // internal/src/store/deposit.ts
 function deposit(state) {
-  const { type } = state;
-  switch (type) {
-    case `atom`:
-    case `molecule_family`:
-    case `mutable_atom`:
-    case `selector`:
-    case `readonly_selector`:
-    case `transaction`: {
-      const token = {
-        key: state.key,
-        type: state.type
-      };
-      if (`family` in state) {
-        token.family = state.family;
-      }
-      return token;
-    }
-    case `molecule`:
-      return state.token;
+  const token = {
+    key: state.key,
+    type: state.type
+  };
+  if (`family` in state) {
+    token.family = state.family;
   }
+  return token;
 }
 
 // ../rel8/junction/src/junction.ts
@@ -734,21 +701,27 @@ function createSelectorFamily(options, store) {
   }
   return createReadonlySelectorFamily(options, store);
 }
-function disposeFromStore(token, store = Internal__namespace.IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      Internal__namespace.disposeAtom(token, store);
-      break;
-    case `selector`:
-    case `readonly_selector`:
-      Internal__namespace.disposeSelector(token, store);
-      break;
-    case `molecule`:
-      immortal.disposeMolecule(token, store);
-      break;
+
+// internal/src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  const target = newest(store);
+  if (!isChildStore(target)) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+    );
+    return;
   }
-}
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    target.transactionMeta.update.key,
+    `Aborting transaction`
+  );
+  target.parent.child = null;
+};
 
 // internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
@@ -776,27 +749,6 @@ var NotFoundError = class extends Error {
   }
 };
 
-// internal/src/transaction/abort-transaction.ts
-var abortTransaction = (store) => {
-  const target = newest(store);
-  if (!isChildStore(target)) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `transaction`,
-      `???`,
-      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  store.logger.info(
-    `\u{1FA82}`,
-    `transaction`,
-    target.transactionMeta.update.key,
-    `Aborting transaction`
-  );
-  target.parent.child = null;
-};
-
 // internal/src/transaction/act-upon-store.ts
 function actUponStore(token, id, store) {
   return (...parameters) => {
@@ -1068,8 +1020,154 @@ function ingestAtomUpdate(applying, atomUpdate, store) {
   setIntoStore(token, value, store);
 }
 
-// ../anvl/src/json/index.ts
-var parseJson = (str) => JSON.parse(str);
+// internal/src/molecule/create-molecule-family.ts
+function createMoleculeFamily(options, store) {
+  var _a;
+  const subject = new Subject();
+  const token = {
+    type: `molecule_family`,
+    key: options.key,
+    dependsOn: (_a = options.dependsOn) != null ? _a : `all`
+  };
+  const family = __spreadProps(__spreadValues({}, token), {
+    subject,
+    new: options.new
+  });
+  store.moleculeFamilies.set(options.key, family);
+  return token;
+}
+
+// internal/src/molecule/grow-molecule-in-store.ts
+function growMoleculeInStore(molecule, family, store) {
+  const stateToken = initFamilyMemberInStore(family, molecule.key, store);
+  molecule.tokens.set(stateToken.key, stateToken);
+  const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    store.transactionMeta.update.updates.push({
+      type: `state_creation`,
+      token: stateToken
+    });
+  } else {
+    molecule.subject.next({ type: `state_creation`, token: stateToken });
+  }
+  return stateToken;
+}
+
+// internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
+    store
+  };
+}
+
+// internal/src/get-state/get-from-store.ts
+function getFromStore(token, store) {
+  const state = withdraw(token, store);
+  return readOrComputeValue(state, store);
+}
+var Molecule = class {
+  constructor(ctx, key, family) {
+    this.key = key;
+    this.type = `molecule`;
+    this.subject = new Subject();
+    this.tokens = /* @__PURE__ */ new Map();
+    this.above = /* @__PURE__ */ new Map();
+    this.below = /* @__PURE__ */ new Map();
+    this.joins = /* @__PURE__ */ new Map();
+    this.stringKey = json.stringifyJson(key);
+    if (family) {
+      this.family = family;
+    }
+    if (ctx) {
+      if (Array.isArray(ctx)) {
+        for (const molecule of ctx) {
+          this.above.set(molecule.stringKey, molecule);
+        }
+      } else {
+        this.above.set(ctx.stringKey, ctx);
+      }
+    }
+  }
+};
+
+// internal/src/molecule/make-molecule-in-store.ts
+function makeMoleculeInStore(store, context, familyToken, key, ...params) {
+  const target = newest(store);
+  const token = {
+    type: `molecule`,
+    key,
+    family: familyToken
+  };
+  const contextArray = Array.isArray(context) ? context : [context];
+  const owners = contextArray.map((ctx) => {
+    if (ctx instanceof Molecule) {
+      return ctx;
+    }
+    const stringKey = json.stringifyJson(ctx.key);
+    const molecule2 = store.molecules.get(stringKey);
+    if (!molecule2) {
+      throw new Error(
+        `Molecule ${stringKey} not found in store "${store.config.name}"`
+      );
+    }
+    return molecule2;
+  });
+  const family = withdraw(familyToken, store);
+  const molecule = new Molecule(owners, key, family);
+  target.molecules.set(json.stringifyJson(key), molecule);
+  for (const owner of owners) {
+    owner.below.set(molecule.stringKey, molecule);
+  }
+  const transactors = {
+    get: (t) => getFromStore(t, newest(store)),
+    set: (t, newValue) => {
+      setIntoStore(t, newValue, newest(store));
+    },
+    seek: (t, k) => seekInStore(t, k, newest(store)),
+    json: (t) => getJsonToken(t, newest(store)),
+    run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
+    make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(store), ctx, f, k, ...args),
+    dispose: (t) => {
+      disposeFromStore(t, newest(store));
+    },
+    env: () => getEnvironmentData(newest(store)),
+    bond: (f) => growMoleculeInStore(
+      molecule,
+      withdraw(f, store),
+      newest(store)
+    ),
+    join: (joinToken) => {
+      const join = data.getJoin(joinToken, store);
+      join.molecules.set(json.stringifyJson(key), molecule);
+      molecule.joins.set(joinToken.key, join);
+    },
+    spawn: (f, k, ...p) => makeMoleculeInStore(
+      newest(store),
+      [molecule],
+      withdraw(f, store),
+      k,
+      ...p
+    )
+  };
+  const Constructor = family.new;
+  molecule.instance = new Constructor(transactors, token.key, ...params);
+  const update = {
+    type: `molecule_creation`,
+    token,
+    family,
+    context: contextArray,
+    params
+  };
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(update);
+  } else {
+    family.subject.next(update);
+  }
+  return token;
+}
+
+// internal/src/ingest-updates/ingest-creation-disposal.ts
 function ingestCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
@@ -1101,20 +1199,20 @@ function createInStore(token, store) {
     if (family) {
       const molecule = store.molecules.get(token.family.subKey);
       if (molecule) {
-        molecule.bond(family);
+        growMoleculeInStore(molecule, family, store);
         return;
       }
       if (store.config.lifespan === `immortal`) {
         throw new Error(`No molecule found for key "${token.family.subKey}"`);
       }
-      initFamilyMember(family, parseJson(token.family.subKey), store);
+      initFamilyMemberInStore(family, json.parseJson(token.family.subKey), store);
     }
   }
 }
 function ingestMoleculeCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`:
-      immortal.makeMoleculeInStore(
+      makeMoleculeInStore(
         store,
         update.context[0],
         update.family,
@@ -1123,17 +1221,17 @@ function ingestMoleculeCreationEvent(update, applying, store) {
       );
       break;
     case `oldValue`:
-      immortal.disposeMolecule(update.token, store);
+      disposeFromStore(update.token, store);
       break;
   }
 }
 function ingestMoleculeDisposalEvent(update, applying, store) {
   switch (applying) {
     case `newValue`:
-      immortal.disposeMolecule(update.token, store);
+      disposeFromStore(update.token, store);
       break;
     case `oldValue`:
-      immortal.makeMoleculeInStore(
+      makeMoleculeInStore(
         store,
         update.context[0],
         update.family,
@@ -1268,21 +1366,6 @@ function assignTransactionToContinuity(continuityKey, transactionKey, store) {
   }
 }
 
-// internal/src/get-environment-data.ts
-function getEnvironmentData(store) {
-  return {
-    window: typeof window === `undefined` ? void 0 : window,
-    global: typeof global === `undefined` ? void 0 : global,
-    store
-  };
-}
-
-// internal/src/get-state/get-from-store.ts
-function getFromStore(token, store) {
-  const state = withdraw(token, store);
-  return readOrComputeValue(state, store);
-}
-
 // internal/src/lazy-map.ts
 var LazyMap = class extends Map {
   constructor(source) {
@@ -1367,7 +1450,7 @@ var buildTransaction = (key, params, store, id) => {
       find: (token, k) => findInStore(token, k, child),
       seek: (token, k) => seekInStore(token, k, child),
       json: (token) => getJsonToken(token, child),
-      make: (context, family, k, ...args) => immortal.makeMoleculeInStore(child, context, family, k, ...args),
+      make: (context, family, k, ...args) => makeMoleculeInStore(child, context, family, k, ...args),
       dispose: (token) => {
         disposeFromStore(token, child);
       },
@@ -1438,8 +1521,88 @@ function getEpochNumberOfAction(transactionKey, store) {
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
+// internal/src/molecule/dispose-molecule.ts
+function disposeMolecule(token, store) {
+  var _a;
+  let molecule;
+  try {
+    molecule = withdraw(token, store);
+  } catch (thrown) {
+    if (thrown instanceof Error) {
+      store.logger.error(
+        `\u{1F41E}`,
+        `molecule`,
+        JSON.stringify(token.key),
+        `Failed to dispose molecule, because it was not found in the store.`,
+        thrown.message
+      );
+    }
+    return;
+  }
+  const { family } = token;
+  if (family) {
+    const Formula = withdraw(family, store);
+    const disposalEvent = {
+      type: `molecule_disposal`,
+      token,
+      family,
+      context: [...molecule.above.values()].map((m) => deposit(m)),
+      familyKeys: [...molecule.tokens.values()].map((t) => {
+        var _a2;
+        return (_a2 = t.family) == null ? void 0 : _a2.key;
+      }).filter((k) => typeof k === `string`)
+    };
+    if (token.family) {
+      disposalEvent.family = token.family;
+    }
+    const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
+    if (isTransaction) {
+      store.transactionMeta.update.updates.push(disposalEvent);
+    } else {
+      Formula.subject.next(disposalEvent);
+    }
+    store.molecules.delete(molecule.stringKey);
+  }
+  for (const state of molecule.tokens.values()) {
+    disposeFromStore(state, store);
+  }
+  for (const child of molecule.below.values()) {
+    if (((_a = child.family) == null ? void 0 : _a.dependsOn) === `all`) {
+      disposeMolecule(child, store);
+    } else {
+      child.above.delete(molecule.stringKey);
+      if (child.above.size === 0) {
+        disposeMolecule(child, store);
+      }
+    }
+  }
+  for (const join of molecule.joins.values()) {
+    join.molecules.delete(molecule.stringKey);
+  }
+  for (const parent of molecule.above.values()) {
+    parent.below.delete(molecule.stringKey);
+  }
+}
+
+// internal/src/families/dispose-from-store.ts
+function disposeFromStore(token, store = IMPLICIT.STORE) {
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+      disposeAtom(token, store);
+      break;
+    case `selector`:
+    case `readonly_selector`:
+      disposeSelector(token, store);
+      break;
+    case `molecule`:
+      disposeMolecule(token, store);
+      break;
+  }
+}
+
 // internal/src/families/init-family-member.ts
-function initFamilyMember(token, key, store) {
+function initFamilyMemberInStore(token, key, store) {
   const familyKey = token.key;
   const family = store.families.get(familyKey);
   if (family === void 0) {
@@ -1507,7 +1670,7 @@ function findInStore(token, key, store) {
   if (state) {
     return state;
   }
-  state = initFamilyMember(token, key, store);
+  state = initFamilyMemberInStore(token, key, store);
   return state;
 }
 
@@ -1724,7 +1887,7 @@ function createStandaloneSelector(options, store) {
 }
 
 // internal/src/selector/dispose-selector.ts
-function disposeSelector2(selectorToken, store) {
+function disposeSelector(selectorToken, store) {
   var _a;
   const target = newest(store);
   const { key } = selectorToken;
@@ -1782,7 +1945,7 @@ function disposeSelector2(selectorToken, store) {
     );
     for (const downstreamToken of downstreamTokens) {
       if (downstreamToken) {
-        disposeSelector2(downstreamToken, store);
+        disposeSelector(downstreamToken, store);
       }
     }
     target.selectorGraph.delete(key);
@@ -2420,7 +2583,7 @@ function createStandaloneAtom(options, store) {
 }
 
 // internal/src/atom/dispose-atom.ts
-function disposeAtom2(atomToken, store) {
+function disposeAtom(atomToken, store) {
   var _a, _b;
   const target = newest(store);
   const { key } = atomToken;
@@ -2450,7 +2613,7 @@ function disposeAtom2(atomToken, store) {
       for (const selectorKey of selectorKeys) {
         const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
         if (token) {
-          disposeSelector2(token, store);
+          disposeSelector(token, store);
         }
       }
     }
@@ -2459,7 +2622,7 @@ function disposeAtom2(atomToken, store) {
     target.timelineAtoms.delete(key);
     if (atomToken.type === `mutable_atom`) {
       const updateToken = getUpdateToken(atomToken);
-      disposeAtom2(updateToken, store);
+      disposeAtom(updateToken, store);
       store.trackers.delete(key);
     }
     store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
@@ -2794,7 +2957,7 @@ function createTimeline(options, store, data) {
                           tl.history.push(event);
                           tl.at = tl.history.length;
                           tl.subject.next(event);
-                          for (const token2 of molecule.tokens) {
+                          for (const token2 of molecule.tokens.values()) {
                             switch (token2.type) {
                               case `atom`:
                               case `mutable_atom`:
@@ -2948,6 +3111,7 @@ exports.FamilyTracker = FamilyTracker;
 exports.Future = Future;
 exports.IMPLICIT = IMPLICIT;
 exports.LazyMap = LazyMap;
+exports.Molecule = Molecule;
 exports.NotFoundError = NotFoundError;
 exports.StatefulSubject = StatefulSubject;
 exports.Store = Store;
@@ -2966,6 +3130,7 @@ exports.cacheValue = cacheValue;
 exports.clearStore = clearStore;
 exports.closeOperation = closeOperation;
 exports.createAtomFamily = createAtomFamily;
+exports.createMoleculeFamily = createMoleculeFamily;
 exports.createMutableAtom = createMutableAtom;
 exports.createMutableAtomFamily = createMutableAtomFamily;
 exports.createReadonlySelector = createReadonlySelector;
@@ -2979,9 +3144,10 @@ exports.createTimeline = createTimeline;
 exports.createTransaction = createTransaction;
 exports.createWritableSelector = createWritableSelector;
 exports.deposit = deposit;
-exports.disposeAtom = disposeAtom2;
+exports.disposeAtom = disposeAtom;
 exports.disposeFromStore = disposeFromStore;
-exports.disposeSelector = disposeSelector2;
+exports.disposeMolecule = disposeMolecule;
+exports.disposeSelector = disposeSelector;
 exports.evictCachedValue = evictCachedValue;
 exports.findInStore = findInStore;
 exports.getContinuityKey = getContinuityKey;
@@ -2993,6 +3159,7 @@ exports.getJsonFamily = getJsonFamily;
 exports.getJsonToken = getJsonToken;
 exports.getSelectorDependencyKeys = getSelectorDependencyKeys;
 exports.getUpdateToken = getUpdateToken;
+exports.growMoleculeInStore = growMoleculeInStore;
 exports.ingestAtomUpdate = ingestAtomUpdate;
 exports.ingestCreationEvent = ingestCreationEvent;
 exports.ingestDisposalEvent = ingestDisposalEvent;
@@ -3000,7 +3167,7 @@ exports.ingestMoleculeCreationEvent = ingestMoleculeCreationEvent;
 exports.ingestMoleculeDisposalEvent = ingestMoleculeDisposalEvent;
 exports.ingestSelectorUpdate = ingestSelectorUpdate;
 exports.ingestTransactionUpdate = ingestTransactionUpdate;
-exports.initFamilyMember = initFamilyMember;
+exports.initFamilyMemberInStore = initFamilyMemberInStore;
 exports.isAtomDefault = isAtomDefault;
 exports.isAtomKey = isAtomKey;
 exports.isChildStore = isChildStore;
@@ -3011,6 +3178,7 @@ exports.isRootStore = isRootStore;
 exports.isSelectorKey = isSelectorKey;
 exports.isStateKey = isStateKey;
 exports.isTransceiver = isTransceiver;
+exports.makeMoleculeInStore = makeMoleculeInStore;
 exports.markAtomAsDefault = markAtomAsDefault;
 exports.markAtomAsNotDefault = markAtomAsNotDefault;
 exports.markDone = markDone;