atom.io 0.6.6 → 0.6.8

package/dist/index.js

@@ -1,11 +1,9 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -45,14 +43,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -144,21 +134,17 @@ __export(internal_exports, {
   withdraw: () => withdraw
 });
 
-// src/internal/atom-internal.ts
-var import_hamt_plus5 = __toESM(require("hamt_plus"));
-
 // src/internal/get.ts
-var import_hamt_plus = __toESM(require("hamt_plus"));
 var computeSelectorState = (selector2) => selector2.get();
 function lookup(key, store) {
   const core = target(store);
-  const type = import_hamt_plus.default.has(key, core.atoms) ? `atom` : import_hamt_plus.default.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 = import_hamt_plus.default.get(token.key, core.atoms)) != null ? _a : import_hamt_plus.default.get(token.key, core.selectors)) != null ? _b : import_hamt_plus.default.get(token.key, core.readonlySelectors)) != null ? _c : import_hamt_plus.default.get(token.key, core.transactions)) != null ? _d : import_hamt_plus.default.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({
@@ -201,12 +187,6 @@ var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
   return roots.every((root) => isAtomDefault(root.key, store));
 };
 
-// src/internal/operation.ts
-var import_hamt_plus3 = __toESM(require("hamt_plus"));
-
-// src/internal/store.ts
-var import_hamt_plus2 = __toESM(require("hamt_plus"));
-
 // ../anvl/src/function/index.ts
 var doNothing = () => void 0;
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
@@ -659,17 +639,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: import_hamt_plus2.default.make()
+    selectorGraph: new Join({ relationType: `n:n` })
   }))()), {
-    atoms: import_hamt_plus2.default.make(),
-    readonlySelectors: import_hamt_plus2.default.make(),
-    selectors: import_hamt_plus2.default.make(),
-    transactions: import_hamt_plus2.default.make(),
-    timelines: import_hamt_plus2.default.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(),
@@ -695,21 +675,21 @@ var createStore = (name, store = null) => {
   });
   store == null ? void 0 : store.atoms.forEach((atom2) => {
     const copiedAtom = __spreadProps(__spreadValues({}, atom2), { subject: new Subject() });
-    copiedStore.atoms = import_hamt_plus2.default.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,
@@ -737,7 +717,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
   };
@@ -781,43 +761,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 import_hamt_plus3.default.get(state.key, core.valueMap);
+    return core.valueMap.get(state.key);
   }
-  return import_hamt_plus3.default.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 = import_hamt_plus3.default.set(key, value, core.valueMap);
+  core.valueMap.set(key, value);
 };
 var evictCachedValue = (key, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.valueMap = import_hamt_plus3.default.remove(key, core.valueMap);
+  core.valueMap.delete(key);
 };
-var readCachedValue = (key, store = IMPLICIT.STORE) => import_hamt_plus3.default.get(key, target(store).valueMap);
-var isValueCached = (key, store = IMPLICIT.STORE) => import_hamt_plus3.default.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 = import_hamt_plus3.default.set(atom2.key, atom2, core.atoms);
+  core.atoms.set(atom2.key, atom2);
 };
 var storeSelector = (selector2, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.selectors = import_hamt_plus3.default.set(selector2.key, selector2, core.selectors);
+  core.selectors.set(selector2.key, selector2);
 };
 var storeReadonlySelector = (selector2, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.readonlySelectors = import_hamt_plus3.default.set(
-    selector2.key,
-    selector2,
-    core.readonlySelectors
-  );
+  core.readonlySelectors.set(selector2.key, selector2);
 };
 var hasKeyBeenUsed = (key, store = IMPLICIT.STORE) => {
   const core = target(store);
-  return import_hamt_plus3.default.has(key, core.atoms) || import_hamt_plus3.default.has(key, core.selectors) || import_hamt_plus3.default.has(key, core.readonlySelectors);
+  return core.atoms.has(key) || core.selectors.has(key) || core.readonlySelectors.has(key);
 };
 
 // src/internal/transaction-internal.ts
-var import_hamt_plus4 = __toESM(require("hamt_plus"));
 function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
   const newTransaction = {
     key: options.key,
@@ -845,11 +820,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
     subject: new Subject()
   };
   const core = target(store);
-  core.transactions = import_hamt_plus4.default.set(
-    newTransaction.key,
-    newTransaction,
-    core.transactions
-  );
+  core.transactions.set(newTransaction.key, newTransaction);
   const token = deposit(newTransaction);
   store.subject.transactionCreation.next(token);
   return token;
@@ -860,12 +831,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), {
@@ -873,7 +845,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 = import_hamt_plus5.default.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);
@@ -888,7 +860,6 @@ function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
 }
 
 // ../anvl/src/json/index.ts
-var import_function8 = require("fp-ts/function");
 var stringifyJson = (json) => JSON.stringify(json);
 
 // src/internal/families-internal.ts
@@ -896,20 +867,23 @@ function atomFamily__INTERNAL(options, store = IMPLICIT.STORE) {
   const subject = new Subject();
   return Object.assign(
     (key) => {
-      var _a;
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
       const existing = withdraw({ key: fullKey, type: `atom` }, store);
-      const token = existing ? deposit(existing) : atom__INTERNAL(
-        {
+      let token;
+      if (existing) {
+        token = deposit(existing);
+      } else {
+        const individualOptions = {
           key: fullKey,
-          default: options.default instanceof Function ? options.default(key) : options.default,
-          effects: (_a = options.effects) == null ? void 0 : _a.call(options, key)
-        },
-        family,
-        store
-      );
+          default: options.default instanceof Function ? options.default(key) : options.default
+        };
+        if (options.effects) {
+          individualOptions.effects = options.effects(key);
+        }
+        token = atom__INTERNAL(individualOptions, family, store);
+      }
       subject.next(token);
       return token;
     },
@@ -983,11 +957,7 @@ function selectorFamily__INTERNAL(options, store = IMPLICIT.STORE) {
   );
 }
 
-// src/internal/selector-internal.ts
-var import_hamt_plus9 = __toESM(require("hamt_plus"));
-
 // src/internal/selector/create-read-write-selector.ts
-var import_hamt_plus6 = __toESM(require("hamt_plus"));
 var createReadWriteSelector = (options, family, store, core) => {
   var _a;
   const subject = new Subject();
@@ -999,8 +969,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);
@@ -1016,21 +992,20 @@ var createReadWriteSelector = (options, family, store, core) => {
     set: setSelf,
     type: `selector`
   }), family && { family });
-  core.selectors = import_hamt_plus6.default.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 = {
     key: options.key,
-    type: `selector`,
-    family
+    type: `selector`
   };
+  if (family) {
+    token.family = family;
+  }
   store.subject.selectorCreation.next(token);
   return token;
 };
 
-// src/internal/selector/create-readonly-selector.ts
-var import_hamt_plus8 = __toESM(require("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));
 
@@ -1090,7 +1065,6 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 };
 
 // src/internal/set.ts
-var import_hamt_plus7 = __toESM(require("hamt_plus"));
 var evictDownStream = (state, store = IMPLICIT.STORE) => {
   var _a, _b;
   const core = target(store);
@@ -1109,7 +1083,7 @@ var evictDownStream = (state, store = IMPLICIT.STORE) => {
       (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   || ${stateKey} already done`);
       return;
     }
-    const state2 = (_b2 = import_hamt_plus7.default.get(stateKey, core.selectors)) != null ? _b2 : import_hamt_plus7.default.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`
@@ -1219,18 +1193,16 @@ var createReadonlySelector = (options, family, store, core) => {
     get: getSelf,
     type: `readonly_selector`
   }), family && { family });
-  core.readonlySelectors = import_hamt_plus8.default.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 = {
     key: options.key,
-    type: `readonly_selector`,
-    family
+    type: `readonly_selector`
   };
+  if (family) {
+    token.family = family;
+  }
   store.subject.selectorCreation.next(token);
   return token;
 };
@@ -1239,7 +1211,7 @@ var createReadonlySelector = (options, family, store, core) => {
 function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
   var _a;
   const core = target(store);
-  if (import_hamt_plus9.default.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.`
     );
@@ -1250,7 +1222,7 @@ function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
   return createReadWriteSelector(options, family, store, core);
 }
 
-// src/internal/subject.ts
+// ../anvl/reactivity/subject.ts
 var Subject = class {
   constructor() {
     this.subscribers = [];
@@ -1323,7 +1295,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 });
     });
   });
@@ -1347,7 +1325,7 @@ var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
     );
     return;
   }
-  timelineData.timeTraveling = true;
+  timelineData.timeTraveling = `into_future`;
   const update = timelineData.history[timelineData.at];
   switch (update.type) {
     case `atom_update`: {
@@ -1366,7 +1344,7 @@ var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   }
   ++timelineData.at;
   timelineData.subject.next(`redo`);
-  timelineData.timeTraveling = false;
+  timelineData.timeTraveling = null;
   (_d = store.config.logger) == null ? void 0 : _d.info(
     `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
   );
@@ -1387,7 +1365,7 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
     );
     return;
   }
-  timelineData.timeTraveling = true;
+  timelineData.timeTraveling = `into_past`;
   --timelineData.at;
   const update = timelineData.history[timelineData.at];
   switch (update.type) {
@@ -1406,15 +1384,12 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
     }
   }
   timelineData.subject.next(`undo`);
-  timelineData.timeTraveling = false;
+  timelineData.timeTraveling = null;
   (_d = store.config.logger) == null ? void 0 : _d.info(
     `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
   );
 };
 
-// src/internal/timeline-internal.ts
-var import_hamt_plus10 = __toESM(require("hamt_plus"));
-
 // src/internal/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
   const atom2 = withdraw(atomToken, store);
@@ -1436,7 +1411,7 @@ var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
       update.newValue,
       currentTransactionKey ? `) in transaction "${currentTransactionKey}"` : currentSelectorKey ? `) in selector "${currentSelectorKey}"` : `)`
     );
-    if (tl.timeTraveling === false) {
+    if (tl.timeTraveling === null) {
       if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
         const mostRecentUpdate = tl.history.at(-1);
         if (mostRecentUpdate === void 0) {
@@ -1465,7 +1440,7 @@ var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
           const subscription = currentTransaction.subject.subscribe((update2) => {
             var _a2;
             subscription.unsubscribe();
-            if (tl.timeTraveling === false && currentTransactionTime) {
+            if (tl.timeTraveling === null && currentTransactionTime) {
               if (tl.at !== tl.history.length) {
                 tl.history.splice(tl.at);
               }
@@ -1554,7 +1529,7 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
   const tl = __spreadProps(__spreadValues({
     key: options.key,
     at: 0,
-    timeTraveling: false,
+    timeTraveling: null,
     selectorTime: null,
     transactionKey: null
   }, data), {
@@ -1596,7 +1571,7 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
       timelineKey: options.key
     });
   }
-  store.timelines = import_hamt_plus10.default.set(options.key, tl, store.timelines);
+  store.timelines.set(options.key, tl);
   const token = {
     key: options.key,
     type: `timeline`
@@ -1619,7 +1594,6 @@ var abortTransaction = (store) => {
 };
 
 // src/internal/transaction/apply-transaction.ts
-var import_hamt_plus11 = __toESM(require("hamt_plus"));
 var applyTransaction = (output, store) => {
   var _a, _b, _c, _d;
   if (store.transactionStatus.phase !== `building`) {
@@ -1636,10 +1610,15 @@ var applyTransaction = (output, store) => {
   const { atomUpdates } = store.transactionStatus;
   for (const { key, newValue } of atomUpdates) {
     const token = { key, type: `atom` };
-    if (!import_hamt_plus11.default.has(token.key, store.valueMap)) {
-      const newAtom = import_hamt_plus11.default.get(token.key, store.transactionStatus.core.atoms);
-      store.atoms = import_hamt_plus11.default.set(newAtom.key, newAtom, store.atoms);
-      store.valueMap = import_hamt_plus11.default.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);
@@ -1671,17 +1650,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,