atom.io 0.1.0 → 0.2.0

package/dist/index.js

@@ -63,7 +63,7 @@ __export(src_exports, {
   atomFamily: () => atomFamily,
   configure: () => configure,
   getState: () => getState,
-  registerSelector: () => registerSelector,
+  isDefault: () => isDefault,
   selector: () => selector,
   selectorFamily: () => selectorFamily,
   setState: () => setState,
@@ -81,24 +81,34 @@ __export(internal_exports, {
   configure: () => configure,
   createStore: () => createStore,
   deposit: () => deposit,
+  evictDownStream: () => evictDownStream,
   finishAction: () => finishAction,
   finishTransaction: () => finishTransaction,
   getCachedState: () => getCachedState,
   getSelectorState: () => getSelectorState,
   getState__INTERNAL: () => getState__INTERNAL,
+  isAtomDefault: () => isAtomDefault,
   isDone: () => isDone,
+  isSelectorDefault: () => isSelectorDefault,
+  lookup: () => lookup,
+  lookupSelectorSources: () => lookupSelectorSources,
   markDone: () => markDone,
-  propagateDown: () => propagateDown,
-  recall: () => recall,
+  recallState: () => recallState,
+  registerSelector: () => registerSelector,
   setAtomState: () => setAtomState,
   setSelectorState: () => setSelectorState,
   setState__INTERNAL: () => setState__INTERNAL,
   startAction: () => startAction,
   startTransaction: () => startTransaction,
+  subscribeToRootAtoms: () => subscribeToRootAtoms,
+  traceAllSelectorAtoms: () => traceAllSelectorAtoms,
+  traceSelectorAtoms: () => traceSelectorAtoms,
+  updateSelectorAtoms: () => updateSelectorAtoms,
   withdraw: () => withdraw
 });
 
 // src/internal/get.ts
+var import_function7 = require("fp-ts/function");
 var import_hamt_plus2 = __toESM(require("hamt_plus"));
 
 // src/internal/store.ts
@@ -494,7 +504,9 @@ var Join = class {
 var createStore = (name) => ({
   valueMap: import_hamt_plus.default.make(),
   selectorGraph: new Join({ relationType: `n:n` }),
+  selectorAtoms: new Join({ relationType: `n:n` }),
   atoms: import_hamt_plus.default.make(),
+  atomsAreDefault: import_hamt_plus.default.make(),
   selectors: import_hamt_plus.default.make(),
   readonlySelectors: import_hamt_plus.default.make(),
   operation: {
@@ -526,10 +538,25 @@ var clearStore = (store = IMPLICIT.STORE) => {
 
 // src/internal/get.ts
 var getCachedState = (state, store = IMPLICIT.STORE) => {
+  const path = [];
+  if (`default` in state) {
+    const atomKey = state.key;
+    store.selectorAtoms = (0, import_function7.pipe)(store.selectorAtoms, (oldValue) => {
+      let newValue = oldValue;
+      for (const selectorKey of path) {
+        newValue = newValue.set(selectorKey, atomKey);
+      }
+      return newValue;
+    });
+  }
   const value = import_hamt_plus2.default.get(state.key, store.valueMap);
   return value;
 };
 var getSelectorState = (selector2) => selector2.get();
+function lookup(key, store) {
+  const type = import_hamt_plus2.default.has(key, store.atoms) ? `atom` : import_hamt_plus2.default.has(key, store.selectors) ? `selector` : `readonly_selector`;
+  return { key, type };
+}
 function withdraw(token, store) {
   var _a, _b;
   return (_b = (_a = import_hamt_plus2.default.get(token.key, store.atoms)) != null ? _a : import_hamt_plus2.default.get(token.key, store.selectors)) != null ? _b : import_hamt_plus2.default.get(token.key, store.readonlySelectors);
@@ -544,14 +571,16 @@ function deposit(state) {
   return { key: state.key, type: `atom` };
 }
 var getState__INTERNAL = (state, store = IMPLICIT.STORE) => {
-  var _a;
+  var _a, _b, _c;
   if (import_hamt_plus2.default.has(state.key, store.valueMap)) {
+    (_a = store.config.logger) == null ? void 0 : _a.info(`>> read "${state.key}"`);
     return getCachedState(state, store);
   }
   if (`get` in state) {
+    (_b = store.config.logger) == null ? void 0 : _b.info(`-> calc "${state.key}"`);
     return getSelectorState(state);
   }
-  (_a = store.config.logger) == null ? void 0 : _a.error(
+  (_c = store.config.logger) == null ? void 0 : _c.error(
     `Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`
   );
   return state.default;
@@ -569,12 +598,12 @@ var startAction = (store) => {
     done: /* @__PURE__ */ new Set(),
     prev: store.valueMap
   };
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u2610`, `operation start`);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u2B55`, `operation start`);
 };
 var finishAction = (store) => {
   var _a;
   store.operation = { open: false };
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u2611\uFE0F`, `operation done`);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F534}`, `operation done`);
 };
 var isDone = (key, store = IMPLICIT.STORE) => {
   var _a;
@@ -596,7 +625,7 @@ var markDone = (key, store = IMPLICIT.STORE) => {
   }
   store.operation.done.add(key);
 };
-var recall = (state, store = IMPLICIT.STORE) => {
+var recallState = (state, store = IMPLICIT.STORE) => {
   var _a;
   if (!store.operation.open) {
     (_a = store.config.logger) == null ? void 0 : _a.warn(
@@ -608,87 +637,60 @@ var recall = (state, store = IMPLICIT.STORE) => {
 };
 
 // src/internal/set.ts
-var propagateDown = (state, store = IMPLICIT.STORE) => {
+var evictDownStream = (state, store = IMPLICIT.STORE) => {
   var _a, _b;
-  const relatedStateKeys = store.selectorGraph.getRelations(state.key);
+  const downstream = store.selectorAtoms.getRelations(state.key);
+  const downstreamKeys = downstream.map(({ id }) => id);
   (_a = store.config.logger) == null ? void 0 : _a.info(
-    `   ||`,
-    `bumping`,
-    relatedStateKeys.length,
-    `states:`,
-    relatedStateKeys.map(({ id }) => id)
+    `   || ${downstreamKeys.length} downstream:`,
+    downstreamKeys
   );
   if (store.operation.open) {
-    (_b = store.config.logger) == null ? void 0 : _b.info(`   ||`, `done:`, store.operation.done);
+    (_b = store.config.logger) == null ? void 0 : _b.info(`   ||`, [...store.operation.done], `already done`);
   }
-  relatedStateKeys.forEach(({ id: stateKey }) => {
-    var _a2, _b2, _c, _d, _e;
+  downstream.forEach(({ id: stateKey }) => {
+    var _a2, _b2, _c, _d;
     if (isDone(stateKey, store)) {
-      (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   ||`, stateKey, `already done`);
+      (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   || ${stateKey} already done`);
       return;
     }
-    (_b2 = store.config.logger) == null ? void 0 : _b2.info(`->`, `bumping`, stateKey);
-    const state2 = (_c = import_hamt_plus4.default.get(stateKey, store.selectors)) != null ? _c : import_hamt_plus4.default.get(stateKey, store.readonlySelectors);
+    const state2 = (_b2 = import_hamt_plus4.default.get(stateKey, store.selectors)) != null ? _b2 : import_hamt_plus4.default.get(stateKey, store.readonlySelectors);
     if (!state2) {
-      (_d = store.config.logger) == null ? void 0 : _d.info(
-        `   ||`,
-        stateKey,
-        `is an atom - no need to propagate down`
+      (_c = store.config.logger) == null ? void 0 : _c.info(
+        `   || ${stateKey} is an atom, and can't be downstream`
       );
       return;
     }
     store.valueMap = import_hamt_plus4.default.remove(stateKey, store.valueMap);
-    const newValue = getState__INTERNAL(state2, store);
-    (_e = store.config.logger) == null ? void 0 : _e.info(`   <-`, stateKey, `became`, newValue);
-    const oldValue = recall(state2, store);
-    state2.subject.next({ newValue, oldValue });
+    (_d = store.config.logger) == null ? void 0 : _d.info(`   xx evicted "${stateKey}"`);
     markDone(stateKey, store);
-    if (`set` in state2)
-      propagateDown(state2, store);
   });
 };
 var setAtomState = (atom2, next, store = IMPLICIT.STORE) => {
   var _a, _b;
   const oldValue = getState__INTERNAL(atom2, store);
   const newValue = become(next)(oldValue);
-  (_a = store.config.logger) == null ? void 0 : _a.info(
-    `->`,
-    `setting atom`,
-    `"${atom2.key}"`,
-    `to`,
-    newValue
-  );
+  (_a = store.config.logger) == null ? void 0 : _a.info(`-> setting atom "${atom2.key}" to`, newValue);
   store.valueMap = import_hamt_plus4.default.set(atom2.key, newValue, store.valueMap);
+  if (isAtomDefault(atom2.key)) {
+    store.atomsAreDefault = import_hamt_plus4.default.set(atom2.key, false, store.atomsAreDefault);
+  }
   markDone(atom2.key, store);
-  atom2.subject.next({ newValue, oldValue });
   (_b = store.config.logger) == null ? void 0 : _b.info(
-    `   ||`,
-    `propagating change made to`,
-    `"${atom2.key}"`
+    `   || evicting caches downstream from "${atom2.key}"`
   );
-  propagateDown(atom2, store);
+  evictDownStream(atom2, store);
+  atom2.subject.next({ newValue, oldValue });
 };
 var setSelectorState = (selector2, next, store = IMPLICIT.STORE) => {
   var _a, _b;
   const oldValue = getState__INTERNAL(selector2, store);
   const newValue = become(next)(oldValue);
-  (_a = store.config.logger) == null ? void 0 : _a.info(
-    `->`,
-    `setting selector`,
-    `"${selector2.key}"`,
-    `to`,
-    newValue
-  );
-  (_b = store.config.logger) == null ? void 0 : _b.info(
-    `   ||`,
-    `propagating change made to`,
-    `"${selector2.key}"`
-  );
+  (_a = store.config.logger) == null ? void 0 : _a.info(`-> setting selector "${selector2.key}" to`, newValue);
+  (_b = store.config.logger) == null ? void 0 : _b.info(`   || propagating change made to "${selector2.key}"`);
   selector2.set(newValue);
-  propagateDown(selector2, store);
 };
-var setState__INTERNAL = (token, value, store = IMPLICIT.STORE) => {
-  const state = withdraw(token, store);
+var setState__INTERNAL = (state, value, store = IMPLICIT.STORE) => {
   if (`set` in state) {
     setSelectorState(state, value, store);
   } else {
@@ -696,6 +698,114 @@ var setState__INTERNAL = (token, value, store = IMPLICIT.STORE) => {
   }
 };
 
+// src/internal/is-default.ts
+var import_hamt_plus5 = __toESM(require("hamt_plus"));
+var isAtomDefault = (key, store = IMPLICIT.STORE) => {
+  return import_hamt_plus5.default.get(key, store.atomsAreDefault);
+};
+var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
+  const roots = traceAllSelectorAtoms(key, store);
+  return roots.every((root) => isAtomDefault(root.key, store));
+};
+
+// src/internal/selector-internal.ts
+var lookupSelectorSources = (key, store) => store.selectorGraph.getRelations(key).filter(({ source }) => source !== key).map(({ source }) => lookup(source, store));
+var traceSelectorAtoms = (selectorKey, dependency, store) => {
+  const roots = [];
+  const sources = lookupSelectorSources(dependency.key, store);
+  let depth = 0;
+  while (sources.length > 0) {
+    const source = sources.shift();
+    ++depth;
+    if (depth > 999) {
+      throw new Error(
+        `Maximum selector dependency depth exceeded in selector "${selectorKey}".`
+      );
+    }
+    if (source.type !== `atom`) {
+      sources.push(...lookupSelectorSources(source.key, store));
+    } else {
+      roots.push(source);
+    }
+  }
+  return roots;
+};
+var traceAllSelectorAtoms = (selectorKey, store) => {
+  const sources = lookupSelectorSources(selectorKey, store);
+  return sources.flatMap(
+    (source) => source.type === `atom` ? source : traceSelectorAtoms(selectorKey, source, store)
+  );
+};
+var updateSelectorAtoms = (selectorKey, dependency, store) => {
+  var _a, _b;
+  if (dependency.type === `atom`) {
+    store.selectorAtoms = store.selectorAtoms.set(selectorKey, dependency.key);
+    (_a = store.config.logger) == null ? void 0 : _a.info(
+      `   || adding root for "${selectorKey}": ${dependency.key}`
+    );
+    return;
+  }
+  const roots = traceSelectorAtoms(selectorKey, dependency, store);
+  (_b = store.config.logger) == null ? void 0 : _b.info(`   || adding roots for "${selectorKey}":`, roots);
+  for (const root of roots) {
+    store.selectorAtoms = store.selectorAtoms.set(selectorKey, root.key);
+  }
+};
+var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
+  get: (dependency) => {
+    var _a, _b;
+    const alreadyRegistered = store.selectorGraph.getRelations(selectorKey).some(({ source }) => source === dependency.key);
+    const dependencyState = withdraw(dependency, store);
+    const dependencyValue = getState__INTERNAL(dependencyState, store);
+    if (alreadyRegistered) {
+      (_a = store.config.logger) == null ? void 0 : _a.info(
+        `   || ${selectorKey} <- ${dependency.key} =`,
+        dependencyValue
+      );
+    } else {
+      (_b = store.config.logger) == null ? void 0 : _b.info(
+        `\u{1F50C} registerSelector "${selectorKey}" <- "${dependency.key}" =`,
+        dependencyValue
+      );
+      store.selectorGraph = store.selectorGraph.set(
+        selectorKey,
+        dependency.key,
+        {
+          source: dependency.key
+        }
+      );
+    }
+    updateSelectorAtoms(selectorKey, dependency, store);
+    return dependencyValue;
+  },
+  set: (stateToken, newValue) => {
+    const state = withdraw(stateToken, store);
+    setState__INTERNAL(state, newValue, store);
+  }
+});
+
+// src/internal/subscribe-internal.ts
+var subscribeToRootAtoms = (state, store = IMPLICIT.STORE) => {
+  const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
+    const atom2 = withdraw(atomToken, store);
+    return atom2.subject.subscribe((atomChange) => {
+      var _a, _b;
+      (_a = store.config.logger) == null ? void 0 : _a.info(
+        `\u{1F4E2} atom changed: "${atomToken.key}" (`,
+        atomChange.oldValue,
+        `->`,
+        atomChange.newValue,
+        `) re-evaluating "${state.key}"`
+      );
+      const oldValue = recallState(state, store);
+      const newValue = getState__INTERNAL(state, store);
+      (_b = store.config.logger) == null ? void 0 : _b.info(`   <- ${state.key} became`, newValue);
+      state.subject.next({ newValue, oldValue });
+    });
+  });
+  return dependencySubscriptions;
+};
+
 // src/internal/transaction-internal.ts
 var finishTransaction = (store) => {
   var _a;
@@ -734,17 +844,17 @@ var abortTransaction = (store) => {
 };
 
 // src/atom.ts
-var import_hamt_plus5 = __toESM(require("hamt_plus"));
+var import_hamt_plus6 = __toESM(require("hamt_plus"));
 var Rx = __toESM(require("rxjs"));
 
 // ../anvl/src/json/index.ts
-var import_function8 = require("fp-ts/function");
+var import_function9 = require("fp-ts/function");
 var stringifyJson = (json) => JSON.stringify(json);
 
 // src/atom.ts
 var atom = (options, store = IMPLICIT.STORE) => {
   var _a, _b, _c;
-  if (import_hamt_plus5.default.has(options.key, store.atoms)) {
+  if (import_hamt_plus6.default.has(options.key, store.atoms)) {
     (_b = (_a = store.config.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
       _a,
       `Key "${options.key}" already exists in the store.`
@@ -753,12 +863,13 @@ var atom = (options, store = IMPLICIT.STORE) => {
   }
   const subject = new Rx.Subject();
   const newAtom = __spreadProps(__spreadValues({}, options), { subject });
-  store.atoms = import_hamt_plus5.default.set(options.key, newAtom, store.atoms);
-  store.valueMap = import_hamt_plus5.default.set(options.key, options.default, store.valueMap);
+  const initialValue = options.default instanceof Function ? options.default() : options.default;
+  store.atoms = import_hamt_plus6.default.set(options.key, newAtom, store.atoms);
+  store.atomsAreDefault = import_hamt_plus6.default.set(options.key, true, store.atomsAreDefault);
+  store.valueMap = import_hamt_plus6.default.set(options.key, initialValue, store.valueMap);
   const token = deposit(newAtom);
   const setSelf = (next) => setState(token, next, store);
   const onSet = (observe) => subscribe(token, observe, store);
-  setSelf(options.default);
   (_c = options.effects) == null ? void 0 : _c.forEach((effect) => effect({ setSelf, onSet }));
   return token;
 };
@@ -780,18 +891,18 @@ var atomFamily = (options, store = IMPLICIT.STORE) => (key) => {
 };
 
 // src/selector.ts
-var import_hamt_plus6 = __toESM(require("hamt_plus"));
+var import_hamt_plus7 = __toESM(require("hamt_plus"));
 var Rx2 = __toESM(require("rxjs"));
 function selector(options, store = IMPLICIT.STORE) {
   var _a, _b;
-  if (import_hamt_plus6.default.has(options.key, store.selectors)) {
+  if (import_hamt_plus7.default.has(options.key, store.selectors)) {
     throw new Error(`Key "${options.key}" already exists in the store.`);
   }
   const subject = new Rx2.Subject();
   const { get, set } = registerSelector(options.key, store);
   const getSelf = () => {
     const value = options.get({ get });
-    store.valueMap = import_hamt_plus6.default.set(options.key, value, store.valueMap);
+    store.valueMap = import_hamt_plus7.default.set(options.key, value, store.valueMap);
     return value;
   };
   if (!(`set` in options)) {
@@ -799,21 +910,21 @@ function selector(options, store = IMPLICIT.STORE) {
       subject,
       get: getSelf
     });
-    store.readonlySelectors = import_hamt_plus6.default.set(
+    store.readonlySelectors = import_hamt_plus7.default.set(
       options.key,
       readonlySelector,
       store.readonlySelectors
     );
     const initialValue2 = getSelf();
-    (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728`, options.key, `=`, initialValue2);
+    (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue2);
     return __spreadProps(__spreadValues({}, readonlySelector), { type: `readonly_selector` });
   }
   const setSelf = (next) => {
     var _a2;
-    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`${options.key}.set`, next);
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   <- "${options.key}" became`, next);
     const oldValue = getSelf();
     const newValue = become(next)(oldValue);
-    store.valueMap = import_hamt_plus6.default.set(options.key, newValue, store.valueMap);
+    store.valueMap = import_hamt_plus7.default.set(options.key, newValue, store.valueMap);
     markDone(options.key, store);
     subject.next({ newValue, oldValue });
     options.set({ get, set }, newValue);
@@ -823,9 +934,9 @@ function selector(options, store = IMPLICIT.STORE) {
     get: getSelf,
     set: setSelf
   });
-  store.selectors = import_hamt_plus6.default.set(options.key, mySelector, store.selectors);
+  store.selectors = import_hamt_plus7.default.set(options.key, mySelector, store.selectors);
   const initialValue = getSelf();
-  (_b = store.config.logger) == null ? void 0 : _b.info(`   \u2728`, options.key, `=`, initialValue);
+  (_b = store.config.logger) == null ? void 0 : _b.info(`   \u2728 "${options.key}" =`, initialValue);
   return __spreadProps(__spreadValues({}, mySelector), { type: `selector` });
 }
 function selectorFamily(options, store = IMPLICIT.STORE) {
@@ -854,30 +965,6 @@ function selectorFamily(options, store = IMPLICIT.STORE) {
     );
   };
 }
-var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
-  get: (state) => {
-    var _a, _b, _c;
-    const isRegistered = store.selectorGraph.getRelatedIds(selectorKey).includes(state.key);
-    if (isRegistered) {
-      (_a = store.config.logger) == null ? void 0 : _a.info(`   ||`, selectorKey, `<-`, state.key);
-    } else {
-      (_b = store.config.logger) == null ? void 0 : _b.info(
-        `\u{1F50C} registerSelector`,
-        selectorKey,
-        `<-`,
-        state.key
-      );
-      store.selectorGraph = store.selectorGraph.set(selectorKey, state.key);
-    }
-    const currentValue = getState(state, store);
-    (_c = store.config.logger) == null ? void 0 : _c.info(`   ||`, state.key, `=`, currentValue);
-    return currentValue;
-  },
-  set: (token, newValue) => {
-    store.selectorGraph.set(token.key, selectorKey);
-    setState__INTERNAL(token, newValue, store);
-  }
-});
 
 // src/transaction.ts
 var transaction = (options, store = IMPLICIT.STORE) => Object.assign(
@@ -908,15 +995,34 @@ var getState = (token, store = IMPLICIT.STORE) => {
   const state = withdraw(token, store);
   return getState__INTERNAL(state, store);
 };
-var setState = (state, value, store = IMPLICIT.STORE) => {
+var setState = (token, value, store = IMPLICIT.STORE) => {
   startAction(store);
+  const state = withdraw(token, store);
   setState__INTERNAL(state, value, store);
   finishAction(store);
 };
+var isDefault = (token, store = IMPLICIT.STORE) => token.type === `atom` ? isAtomDefault(token.key, store) : isSelectorDefault(token.key, store);
 var subscribe = (token, observe, store = IMPLICIT.STORE) => {
+  var _a;
   const state = withdraw(token, store);
   const subscription = state.subject.subscribe(observe);
-  return () => subscription.unsubscribe();
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F440} subscribe to "${state.key}"`);
+  const dependencySubscriptions = subscribeToRootAtoms(state, store);
+  const unsubscribe = dependencySubscriptions === null ? () => {
+    var _a2;
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`\u{1F648} unsubscribe from "${state.key}"`);
+    subscription.unsubscribe();
+  } : () => {
+    var _a2;
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+      `\u{1F648} unsubscribe from "${state.key}" and its dependencies`
+    );
+    subscription.unsubscribe();
+    for (const dependencySubscription of dependencySubscriptions) {
+      dependencySubscription.unsubscribe();
+    }
+  };
+  return unsubscribe;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -925,7 +1031,7 @@ var subscribe = (token, observe, store = IMPLICIT.STORE) => {
   atomFamily,
   configure,
   getState,
-  registerSelector,
+  isDefault,
   selector,
   selectorFamily,
   setState,