atom.io 0.6.6 → 0.6.7

package/dist/index.mjs

@@ -97,21 +97,17 @@ __export(internal_exports, {
   withdraw: () => withdraw
 });
 
-// src/internal/atom-internal.ts
-import HAMT5 from "hamt_plus";
-
 // src/internal/get.ts
-import HAMT from "hamt_plus";
 var computeSelectorState = (selector2) => selector2.get();
 function lookup(key, store) {
   const core = target(store);
-  const type = HAMT.has(key, core.atoms) ? `atom` : HAMT.has(key, core.selectors) ? `selector` : `readonly_selector`;
+  const type = core.atoms.has(key) ? `atom` : core.selectors.has(key) ? `selector` : `readonly_selector`;
   return { key, type };
 }
 function withdraw(token, store) {
   var _a, _b, _c, _d, _e;
   const core = target(store);
-  return (_e = (_d = (_c = (_b = (_a = HAMT.get(token.key, core.atoms)) != null ? _a : HAMT.get(token.key, core.selectors)) != null ? _b : HAMT.get(token.key, core.readonlySelectors)) != null ? _c : HAMT.get(token.key, core.transactions)) != null ? _d : HAMT.get(token.key, core.timelines)) != null ? _e : null;
+  return (_e = (_d = (_c = (_b = (_a = core.atoms.get(token.key)) != null ? _a : core.selectors.get(token.key)) != null ? _b : core.readonlySelectors.get(token.key)) != null ? _c : core.transactions.get(token.key)) != null ? _d : core.timelines.get(token.key)) != null ? _e : null;
 }
 function deposit(state) {
   return __spreadValues({
@@ -154,12 +150,6 @@ var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
   return roots.every((root) => isAtomDefault(root.key, store));
 };
 
-// src/internal/operation.ts
-import HAMT3 from "hamt_plus";
-
-// src/internal/store.ts
-import HAMT2 from "hamt_plus";
-
 // ../anvl/src/function/index.ts
 var doNothing = () => void 0;
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
@@ -612,17 +602,17 @@ var Join = class _Join {
 // src/internal/store.ts
 var createStore = (name, store = null) => {
   var _a;
-  const copiedStore = __spreadProps(__spreadValues({}, store != null ? store : (() => ({
+  const created = __spreadProps(__spreadValues({}, store != null ? store : (() => ({
     atomsThatAreDefault: /* @__PURE__ */ new Set(),
     selectorAtoms: new Join({ relationType: `n:n` }).from(`selectorKey`).to(`atomKey`),
-    selectorGraph: new Join({ relationType: `n:n` }),
-    valueMap: HAMT2.make()
+    selectorGraph: new Join({ relationType: `n:n` })
   }))()), {
-    atoms: HAMT2.make(),
-    readonlySelectors: HAMT2.make(),
-    selectors: HAMT2.make(),
-    transactions: HAMT2.make(),
-    timelines: HAMT2.make(),
+    valueMap: new Map(store == null ? void 0 : store.valueMap),
+    atoms: /* @__PURE__ */ new Map(),
+    readonlySelectors: /* @__PURE__ */ new Map(),
+    selectors: /* @__PURE__ */ new Map(),
+    transactions: /* @__PURE__ */ new Map(),
+    timelines: /* @__PURE__ */ new Map(),
     timelineAtoms: new Join({ relationType: `1:n` }).from(`timelineKey`).to(`atomKey`),
     subject: {
       atomCreation: new Subject(),
@@ -648,21 +638,21 @@ var createStore = (name, store = null) => {
   });
   store == null ? void 0 : store.atoms.forEach((atom2) => {
     const copiedAtom = __spreadProps(__spreadValues({}, atom2), { subject: new Subject() });
-    copiedStore.atoms = HAMT2.set(atom2.key, copiedAtom, copiedStore.atoms);
+    created.atoms.set(atom2.key, copiedAtom);
   });
   store == null ? void 0 : store.readonlySelectors.forEach((selector2) => {
-    selector2.install(copiedStore);
+    selector2.install(created);
   });
   store == null ? void 0 : store.selectors.forEach((selector2) => {
-    selector2.install(copiedStore);
+    selector2.install(created);
   });
   store == null ? void 0 : store.transactions.forEach((tx) => {
-    tx.install(copiedStore);
+    tx.install(created);
   });
   store == null ? void 0 : store.timelines.forEach((timeline2) => {
-    timeline2.install(copiedStore);
+    timeline2.install(created);
   });
-  return copiedStore;
+  return created;
 };
 var IMPLICIT = {
   STORE_INTERNAL: void 0,
@@ -690,7 +680,7 @@ var openOperation = (token, store) => {
   core.operation = {
     open: true,
     done: /* @__PURE__ */ new Set(),
-    prev: store.valueMap,
+    prev: new Map(store.valueMap),
     time: Date.now(),
     token
   };
@@ -734,43 +724,38 @@ var recallState = (state, store = IMPLICIT.STORE) => {
     (_a = store.config.logger) == null ? void 0 : _a.warn(
       `recall called outside of an operation. This is probably a bug.`
     );
-    return HAMT3.get(state.key, core.valueMap);
+    return core.valueMap.get(state.key);
   }
-  return HAMT3.get(state.key, core.operation.prev);
+  return core.operation.prev.get(state.key);
 };
 var cacheValue = (key, value, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.valueMap = HAMT3.set(key, value, core.valueMap);
+  core.valueMap.set(key, value);
 };
 var evictCachedValue = (key, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.valueMap = HAMT3.remove(key, core.valueMap);
+  core.valueMap.delete(key);
 };
-var readCachedValue = (key, store = IMPLICIT.STORE) => HAMT3.get(key, target(store).valueMap);
-var isValueCached = (key, store = IMPLICIT.STORE) => HAMT3.has(key, target(store).valueMap);
+var readCachedValue = (key, store = IMPLICIT.STORE) => target(store).valueMap.get(key);
+var isValueCached = (key, store = IMPLICIT.STORE) => target(store).valueMap.has(key);
 var storeAtom = (atom2, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.atoms = HAMT3.set(atom2.key, atom2, core.atoms);
+  core.atoms.set(atom2.key, atom2);
 };
 var storeSelector = (selector2, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.selectors = HAMT3.set(selector2.key, selector2, core.selectors);
+  core.selectors.set(selector2.key, selector2);
 };
 var storeReadonlySelector = (selector2, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.readonlySelectors = HAMT3.set(
-    selector2.key,
-    selector2,
-    core.readonlySelectors
-  );
+  core.readonlySelectors.set(selector2.key, selector2);
 };
 var hasKeyBeenUsed = (key, store = IMPLICIT.STORE) => {
   const core = target(store);
-  return HAMT3.has(key, core.atoms) || HAMT3.has(key, core.selectors) || HAMT3.has(key, core.readonlySelectors);
+  return core.atoms.has(key) || core.selectors.has(key) || core.readonlySelectors.has(key);
 };
 
 // src/internal/transaction-internal.ts
-import HAMT4 from "hamt_plus";
 function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
   const newTransaction = {
     key: options.key,
@@ -798,11 +783,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
     subject: new Subject()
   };
   const core = target(store);
-  core.transactions = HAMT4.set(
-    newTransaction.key,
-    newTransaction,
-    core.transactions
-  );
+  core.transactions.set(newTransaction.key, newTransaction);
   const token = deposit(newTransaction);
   store.subject.transactionCreation.next(token);
   return token;
@@ -813,12 +794,13 @@ var target = (store = IMPLICIT.STORE) => store.transactionStatus.phase === `buil
 function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
   var _a, _b, _c;
   const core = target(store);
-  if (hasKeyBeenUsed(options.key, store)) {
+  const existing = core.atoms.get(options.key);
+  if (existing) {
     (_b = (_a = store.config.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
       _a,
       `Key "${options.key}" already exists in the store.`
     );
-    return deposit(core.atoms.get(options.key));
+    return deposit(existing);
   }
   const subject = new Subject();
   const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
@@ -826,7 +808,7 @@ function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
     type: `atom`
   }), family && { family });
   const initialValue = options.default instanceof Function ? options.default() : options.default;
-  core.atoms = HAMT5.set(newAtom.key, newAtom, core.atoms);
+  core.atoms.set(newAtom.key, newAtom);
   markAtomAsDefault(options.key, store);
   cacheValue(options.key, initialValue, store);
   const token = deposit(newAtom);
@@ -936,11 +918,7 @@ function selectorFamily__INTERNAL(options, store = IMPLICIT.STORE) {
   );
 }
 
-// src/internal/selector-internal.ts
-import HAMT9 from "hamt_plus";
-
 // src/internal/selector/create-read-write-selector.ts
-import HAMT6 from "hamt_plus";
 var createReadWriteSelector = (options, family, store, core) => {
   var _a;
   const subject = new Subject();
@@ -952,8 +930,14 @@ var createReadWriteSelector = (options, family, store, core) => {
   };
   const setSelf = (next) => {
     var _a2;
-    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   <- "${options.key}" became`, next);
     const oldValue = getSelf();
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+      `   <- "${options.key}" went (`,
+      oldValue,
+      `->`,
+      next,
+      `)`
+    );
     const newValue = become(next)(oldValue);
     cacheValue(options.key, newValue, store);
     markDone(options.key, store);
@@ -969,7 +953,7 @@ var createReadWriteSelector = (options, family, store, core) => {
     set: setSelf,
     type: `selector`
   }), family && { family });
-  core.selectors = HAMT6.set(options.key, mySelector, core.selectors);
+  core.selectors.set(options.key, mySelector);
   const initialValue = getSelf();
   (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue);
   const token = {
@@ -981,9 +965,6 @@ var createReadWriteSelector = (options, family, store, core) => {
   return token;
 };
 
-// src/internal/selector/create-readonly-selector.ts
-import HAMT8 from "hamt_plus";
-
 // src/internal/selector/lookup-selector-sources.ts
 var lookupSelectorSources = (key, store) => target(store).selectorGraph.getRelations(key).filter(({ source }) => source !== key).map(({ source }) => lookup(source, store));
 
@@ -1043,7 +1024,6 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 };
 
 // src/internal/set.ts
-import HAMT7 from "hamt_plus";
 var evictDownStream = (state, store = IMPLICIT.STORE) => {
   var _a, _b;
   const core = target(store);
@@ -1062,7 +1042,7 @@ var evictDownStream = (state, store = IMPLICIT.STORE) => {
       (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   || ${stateKey} already done`);
       return;
     }
-    const state2 = (_b2 = HAMT7.get(stateKey, core.selectors)) != null ? _b2 : HAMT7.get(stateKey, core.readonlySelectors);
+    const state2 = (_b2 = core.selectors.get(stateKey)) != null ? _b2 : core.readonlySelectors.get(stateKey);
     if (!state2) {
       (_c = store.config.logger) == null ? void 0 : _c.info(
         `   || ${stateKey} is an atom, and can't be downstream`
@@ -1172,11 +1152,7 @@ var createReadonlySelector = (options, family, store, core) => {
     get: getSelf,
     type: `readonly_selector`
   }), family && { family });
-  core.readonlySelectors = HAMT8.set(
-    options.key,
-    readonlySelector,
-    core.readonlySelectors
-  );
+  core.readonlySelectors.set(options.key, readonlySelector);
   const initialValue = getSelf();
   (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue);
   const token = {
@@ -1192,7 +1168,7 @@ var createReadonlySelector = (options, family, store, core) => {
 function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
   var _a;
   const core = target(store);
-  if (HAMT9.has(options.key, core.selectors)) {
+  if (core.selectors.has(options.key)) {
     (_a = store.config.logger) == null ? void 0 : _a.error(
       `Key "${options.key}" already exists in the store.`
     );
@@ -1276,7 +1252,13 @@ var subscribeToRootAtoms = (state, store) => {
       );
       const oldValue = recallState(state, store);
       const newValue = getState__INTERNAL(state, store);
-      (_b = store.config.logger) == null ? void 0 : _b.info(`   <- ${state.key} became`, newValue);
+      (_b = store.config.logger) == null ? void 0 : _b.info(
+        `   <- "${state.key}" went (`,
+        oldValue,
+        `->`,
+        newValue,
+        `)`
+      );
       state.subject.next({ newValue, oldValue });
     });
   });
@@ -1365,9 +1347,6 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   );
 };
 
-// src/internal/timeline-internal.ts
-import HAMT10 from "hamt_plus";
-
 // src/internal/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
   const atom2 = withdraw(atomToken, store);
@@ -1549,7 +1528,7 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
       timelineKey: options.key
     });
   }
-  store.timelines = HAMT10.set(options.key, tl, store.timelines);
+  store.timelines.set(options.key, tl);
   const token = {
     key: options.key,
     type: `timeline`
@@ -1572,7 +1551,6 @@ var abortTransaction = (store) => {
 };
 
 // src/internal/transaction/apply-transaction.ts
-import HAMT11 from "hamt_plus";
 var applyTransaction = (output, store) => {
   var _a, _b, _c, _d;
   if (store.transactionStatus.phase !== `building`) {
@@ -1589,10 +1567,15 @@ var applyTransaction = (output, store) => {
   const { atomUpdates } = store.transactionStatus;
   for (const { key, newValue } of atomUpdates) {
     const token = { key, type: `atom` };
-    if (!HAMT11.has(token.key, store.valueMap)) {
-      const newAtom = HAMT11.get(token.key, store.transactionStatus.core.atoms);
-      store.atoms = HAMT11.set(newAtom.key, newAtom, store.atoms);
-      store.valueMap = HAMT11.set(newAtom.key, newAtom.default, store.valueMap);
+    if (!store.valueMap.has(token.key)) {
+      const newAtom = store.transactionStatus.core.atoms.get(token.key);
+      if (!newAtom) {
+        throw new Error(
+          `Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`
+        );
+      }
+      store.atoms.set(newAtom.key, newAtom);
+      store.valueMap.set(newAtom.key, newAtom.default);
       (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F527}`, `add atom "${newAtom.key}"`);
     }
     setState(token, newValue, store);
@@ -1624,17 +1607,17 @@ var buildTransaction = (key, params, store) => {
     phase: `building`,
     time: Date.now(),
     core: {
-      atoms: store.atoms,
+      atoms: new Map(store.atoms),
       atomsThatAreDefault: store.atomsThatAreDefault,
       operation: { open: false },
-      readonlySelectors: store.readonlySelectors,
-      timelines: store.timelines,
+      readonlySelectors: new Map(store.readonlySelectors),
+      timelines: new Map(store.timelines),
       timelineAtoms: store.timelineAtoms,
-      transactions: store.transactions,
+      transactions: new Map(store.transactions),
       selectorAtoms: store.selectorAtoms,
       selectorGraph: store.selectorGraph,
-      selectors: store.selectors,
-      valueMap: store.valueMap
+      selectors: new Map(store.selectors),
+      valueMap: new Map(store.valueMap)
     },
     atomUpdates: [],
     params,