atom.io 0.31.0 → 0.31.1

package/dist/{chunk-42UH5F5Q.js → chunk-Y5MBNTVU.js}

@@ -1,4 +1,3 @@
-import { deallocateFromStore, allocateIntoStore, claimWithinStore } from './chunk-ICGFFQ3H.js';
 import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 import { subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary as arbitrary$1 } from 'atom.io/internal';
@@ -511,19 +510,10 @@ function prettyPrintTokenType(token) {
 
 // internal/src/not-found-error.ts
 var NotFoundError = class extends Error {
-  constructor(...params) {
-    const token = params[0];
-    const store = params.length === 2 ? params[1] : params[2];
-    if (params.length === 2) {
-      super(
-        `${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`
-      );
-    } else {
-      const key = params[1];
-      super(
-        `${prettyPrintTokenType(token)} "${token.key}" member ${stringifyJson(key)} not found in store "${store.config.name}".`
-      );
-    }
+  constructor(token, store) {
+    super(
+      `${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`
+    );
   }
 };
 
@@ -954,11 +944,7 @@ var registerSelector = (selectorKey, covered, store) => ({
       const family = params[0];
       const key = params[1];
       value = params[2];
-      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(store, family, key) : seekInStore(store, family, key);
-      if (!maybeToken) {
-        throw new NotFoundError(family, key, store);
-      }
-      token = maybeToken;
+      token = findInStore(store, family, key);
     }
     const target = newest(store);
     const state = withdraw(token, target);
@@ -1444,6 +1430,240 @@ function ingestAtomUpdate(applying, atomUpdate, store) {
   }
   setIntoStore(store, token, value);
 }
+
+// internal/src/get-trace.ts
+function getTrace(error) {
+  const { stack } = error;
+  if (stack) {
+    return `
+` + stack.split(`
+`)?.slice(1)?.join(`
+`);
+  }
+  return ``;
+}
+
+// internal/src/molecule.ts
+function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
+  const molecule = {
+    key,
+    stringKey: stringifyJson(key),
+    dependsOn: `any`
+  };
+  store.molecules.set(stringifyJson(key), molecule);
+  return key;
+}
+function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
+  const origin = provenance;
+  const stringKey = stringifyJson(key);
+  const invalidKeys = [];
+  const target = newest(store);
+  if (Array.isArray(origin)) {
+    for (const formerClaim of origin) {
+      const claimString = stringifyJson(formerClaim);
+      const claim = target.molecules.get(claimString);
+      if (claim) {
+        store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+      } else {
+        invalidKeys.push(claimString);
+      }
+    }
+  } else {
+    const claimString = stringifyJson(origin);
+    const claim = target.molecules.get(claimString);
+    if (claim) {
+      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+    } else {
+      invalidKeys.push(claimString);
+    }
+  }
+  if (invalidKeys.length === 0) {
+    target.molecules.set(stringKey, { key, stringKey, dependsOn });
+  }
+  const creationEvent = {
+    type: `molecule_creation`,
+    key,
+    provenance: origin
+  };
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(creationEvent);
+  } else {
+    target.on.moleculeCreation.next(creationEvent);
+  }
+  for (const claim of invalidKeys) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === claim
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      key,
+      `allocation failed:`,
+      `Could not allocate to ${claim} in store "${store.config.name}".`,
+      disposal ? `
+   ${claim} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${claim} was found.`
+    );
+  }
+  return key;
+}
+function fuseWithinStore(store, type, sideA, sideB) {
+  const compoundKey = `T$--${type}==${sideA}++${sideB}`;
+  const above = [sideA, sideB];
+  allocateIntoStore(
+    store,
+    above,
+    compoundKey,
+    `all`
+  );
+  return compoundKey;
+}
+function deallocateFromStore(store, claim) {
+  const stringKey = stringifyJson(claim);
+  const molecule = store.molecules.get(stringKey);
+  if (!molecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === stringKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `deallocation failed:`,
+      `Could not find allocation for ${stringKey} in store "${store.config.name}".`,
+      disposal ? `
+   This state was most recently deallocated
+${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
+    );
+    return;
+  }
+  const joinKeys = store.moleculeJoins.getRelatedKeys(
+    molecule.key
+  );
+  if (joinKeys) {
+    for (const joinKey of joinKeys) {
+      const join = store.joins.get(joinKey);
+      if (join) {
+        join.relations.delete(molecule.key);
+        join.molecules.delete(molecule.stringKey);
+      }
+    }
+  }
+  store.moleculeJoins.delete(molecule.stringKey);
+  const provenance = [];
+  const values = [];
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    key: molecule.key,
+    values,
+    provenance
+  };
+  const target = newest(store);
+  target.molecules.delete(stringKey);
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(disposalEvent);
+  }
+  const relatedMolecules = store.moleculeGraph.getRelationEntries({
+    downstreamMoleculeKey: molecule.stringKey
+  });
+  if (relatedMolecules) {
+    for (const [relatedStringKey, { source }] of relatedMolecules) {
+      if (source === molecule.stringKey) {
+        const relatedKey = parseJson(relatedStringKey);
+        deallocateFromStore(store, relatedKey);
+      } else {
+        provenance.push(source);
+      }
+    }
+  }
+  const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
+  if (familyKeys) {
+    for (const familyKey of familyKeys) {
+      const family = target.families.get(familyKey);
+      const token = findInStore(store, family, molecule.key);
+      values.push([family.key, token]);
+      disposeFromStore(store, token);
+    }
+  }
+  target.moleculeGraph.delete(molecule.stringKey);
+  target.moleculeJoins.delete(molecule.stringKey);
+  target.moleculeData.delete(molecule.stringKey);
+  if (!isTransaction) {
+    target.on.moleculeDisposal.next(disposalEvent);
+  }
+  target.molecules.delete(molecule.stringKey);
+  const trace = getTrace(new Error());
+  store.disposalTraces.add({ key: stringKey, trace });
+}
+function claimWithinStore(store, newProvenance, claim, exclusive) {
+  const stringKey = stringifyJson(claim);
+  const target = newest(store);
+  const molecule = target.molecules.get(stringKey);
+  if (!molecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === stringKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `claim failed:`,
+      `Could not allocate to ${stringKey} in store "${store.config.name}".`,
+      disposal ? `
+   ${stringKey} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
+    );
+    return claim;
+  }
+  const newProvenanceKey = stringifyJson(newProvenance);
+  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
+  if (!newProvenanceMolecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === newProvenanceKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `claim failed:`,
+      `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,
+      disposal ? `
+   ${newProvenanceKey} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`
+    );
+    return claim;
+  }
+  const priorProvenance = store.moleculeGraph.getRelationEntries({
+    downstreamMoleculeKey: molecule.stringKey
+  }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
+  if (exclusive) {
+    target.moleculeGraph.delete(stringKey);
+  }
+  target.moleculeGraph.set(
+    {
+      upstreamMoleculeKey: newProvenanceMolecule.stringKey,
+      downstreamMoleculeKey: molecule.stringKey
+    },
+    {
+      source: newProvenanceMolecule.stringKey
+    }
+  );
+  const transferEvent = {
+    type: `molecule_transfer`,
+    key: molecule.key,
+    from: priorProvenance,
+    to: [newProvenanceMolecule.key]
+  };
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(transferEvent);
+  }
+  return claim;
+}
+
+// internal/src/ingest-updates/ingest-creation-disposal.ts
 function ingestCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
@@ -2786,18 +3006,6 @@ function disposeAtom(atomToken, store) {
   }
 }
 
-// internal/src/get-trace.ts
-function getTrace(error) {
-  const { stack } = error;
-  if (stack) {
-    return `
-` + stack.split(`
-`)?.slice(1)?.join(`
-`);
-  }
-  return ``;
-}
-
 // internal/src/timeline/create-timeline.ts
 function createTimeline(options, store, data) {
   const tl = {
@@ -3199,4 +3407,4 @@ var timeTravel = (store, action, token) => {
   );
 };
 
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState2 as subscribeToState, subscribeToTimeline2 as subscribeToTimeline, subscribeToTransaction2 as subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState2 as subscribeToState, subscribeToTimeline2 as subscribeToTimeline, subscribeToTransaction2 as subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };