atom.io 0.29.5 → 0.30.1

package/dist/chunk-ADMEAXYU.js

@@ -0,0 +1,167 @@
+import { createMoleculeFamily, IMPLICIT, makeMoleculeInStore, Molecule, newest, isChildStore, disposeFromStore } from 'atom.io/internal';
+import { stringifyJson } from 'atom.io/json';
+
+// src/molecule.ts
+function moleculeFamily(options) {
+  return createMoleculeFamily(IMPLICIT.STORE, options);
+}
+function makeMolecule(context, family, key, ...params) {
+  return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params);
+}
+function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
+  const molecule = new Molecule(void 0, key);
+  store.molecules.set(stringifyJson(key), molecule);
+  return {
+    key,
+    type: `molecule`
+  };
+}
+var $provenance = Symbol(`provenance`);
+function allocateIntoStore(store, provenance, key) {
+  const stringKey = stringifyJson(key);
+  try {
+    const above = [];
+    let allocationAttachmentStyle;
+    if (provenance === `root`) {
+      above.push(store.molecules.get(`"root"`));
+      allocationAttachmentStyle = `all`;
+    } else if (typeof provenance === `string` && provenance.startsWith(T$)) {
+      allocationAttachmentStyle = `any`;
+      const provenanceKey = stringifyJson(provenance);
+      const provenanceMolecule = store.molecules.get(provenanceKey);
+      if (!provenanceMolecule) {
+        throw new Error(
+          `Molecule ${provenanceKey} not found in store "${store.config.name}"`
+        );
+      }
+      above.push(provenanceMolecule);
+    } else {
+      const allocationIsCompound = key.startsWith(`T$--`);
+      if (allocationIsCompound) {
+        allocationAttachmentStyle = `all`;
+        for (const claim of provenance) {
+          const provenanceKey = stringifyJson(claim);
+          const provenanceMolecule = store.molecules.get(provenanceKey);
+          if (!provenanceMolecule) {
+            throw new Error(
+              `Molecule ${provenanceKey} not found in store "${store.config.name}"`
+            );
+          }
+          above.push(provenanceMolecule);
+        }
+      } else {
+        allocationAttachmentStyle = `any`;
+        const provenanceKey = stringifyJson(provenance);
+        const provenanceMolecule = store.molecules.get(provenanceKey);
+        if (!provenanceMolecule) {
+          throw new Error(
+            `Molecule ${provenanceKey} not found in store "${store.config.name}"`
+          );
+        }
+        above.push(provenanceMolecule);
+      }
+    }
+    const molecule = new Molecule(above, key);
+    molecule._dependsOn = allocationAttachmentStyle;
+    store.molecules.set(stringKey, molecule);
+    for (const aboveMolecule of above) {
+      aboveMolecule.below.set(molecule.stringKey, molecule);
+    }
+    const creationEvent = {
+      type: `molecule_creation`,
+      subType: `modern`,
+      key: molecule.key,
+      provenance
+    };
+    const target = newest(store);
+    const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+    if (isTransaction) {
+      target.transactionMeta.update.updates.push(creationEvent);
+    } else {
+      target.on.moleculeCreationStart.next(creationEvent);
+    }
+  } catch (thrown) {
+    if (thrown instanceof Error) {
+      store.logger.error(
+        `\u274C`,
+        `molecule`,
+        stringKey,
+        `allocation failed:`,
+        thrown.message
+      );
+    }
+  }
+  return key;
+}
+function deallocateFromStore(store, claim) {
+  const stringKey = stringifyJson(claim);
+  const molecule = store.molecules.get(stringKey);
+  if (!molecule) {
+    throw new Error(
+      `Molecule ${stringKey} not found in store "${store.config.name}"`
+    );
+  }
+  for (const join of molecule.joins.values()) {
+    join.relations.delete(molecule.key);
+    join.molecules.delete(molecule.stringKey);
+  }
+  let provenance;
+  if (molecule.above.size === 1) {
+    const above = molecule.above.values().next().value;
+    provenance = above.key;
+  } else {
+    provenance = [...molecule.above.values()].map(({ key }) => key);
+  }
+  const values = [];
+  for (const stateToken of molecule.tokens.values()) {
+    const tokenFamily = stateToken.family;
+    values.push([tokenFamily.key, store.valueMap.get(stateToken.key)]);
+  }
+  for (const state of molecule.tokens.values()) {
+    disposeFromStore(store, state);
+  }
+  for (const child of molecule.below.values()) {
+    if (child.dependsOn === `all`) {
+      deallocateFromStore(store, child.key);
+    } else {
+      child.above.delete(molecule.stringKey);
+      if (child.above.size === 0) {
+        deallocateFromStore(store, child.key);
+      }
+    }
+  }
+  molecule.below.clear();
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    subType: `modern`,
+    key: molecule.key,
+    values,
+    provenance
+  };
+  const target = newest(store);
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(disposalEvent);
+  } else {
+    target.on.moleculeDisposal.next(disposalEvent);
+  }
+  target.molecules.delete(molecule.stringKey);
+  for (const parent of molecule.above.values()) {
+    parent.below.delete(molecule.stringKey);
+  }
+}
+function realm(store) {
+  const root = makeRootMoleculeInStore(`root`, store);
+  return {
+    root,
+    allocate: (provenance, key) => {
+      return allocateIntoStore(store, provenance, key);
+    },
+    deallocate: (claim) => {
+      deallocateFromStore(store, claim);
+    }
+  };
+}
+var T$ = `T$`;
+
+export { $provenance, T$, allocateIntoStore, deallocateFromStore, makeMolecule, makeRootMoleculeInStore, moleculeFamily, realm };