atom.io 0.1.0 → 0.2.0

package/dist/react/index.mjs

@@ -34,29 +34,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/react/useSubject.ts
-var eq = (oldValue, newValue) => oldValue === newValue;
-var composeSubjectHook = (useState, useEffect) => {
-  function useSubject(subject, initialValue, compareFn = eq) {
-    const [state, setState2] = useState(initialValue);
-    useEffect(() => {
-      const subscription = subject.subscribe(({ newValue, oldValue }) => {
-        if (!compareFn(oldValue, newValue)) {
-          setState2(newValue);
-        }
-      });
-      return () => {
-        subscription.unsubscribe();
-      };
-    }, [state, compareFn, subject]);
-    const updateState = (newValue) => {
-      subject.next({ newValue, oldValue: state });
-    };
-    return [state, updateState];
-  }
-  return useSubject;
-};
-
 // src/internal/index.ts
 var internal_exports = {};
 __export(internal_exports, {
@@ -66,24 +43,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
+import { pipe as pipe6 } from "fp-ts/function";
 import HAMT2 from "hamt_plus";
 
 // src/internal/store.ts
@@ -479,7 +466,9 @@ var Join = class {
 var createStore = (name) => ({
   valueMap: HAMT.make(),
   selectorGraph: new Join({ relationType: `n:n` }),
+  selectorAtoms: new Join({ relationType: `n:n` }),
   atoms: HAMT.make(),
+  atomsAreDefault: HAMT.make(),
   selectors: HAMT.make(),
   readonlySelectors: HAMT.make(),
   operation: {
@@ -511,10 +500,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 = pipe6(store.selectorAtoms, (oldValue) => {
+      let newValue = oldValue;
+      for (const selectorKey of path) {
+        newValue = newValue.set(selectorKey, atomKey);
+      }
+      return newValue;
+    });
+  }
   const value = HAMT2.get(state.key, store.valueMap);
   return value;
 };
 var getSelectorState = (selector) => selector.get();
+function lookup(key, store) {
+  const type = HAMT2.has(key, store.atoms) ? `atom` : HAMT2.has(key, store.selectors) ? `selector` : `readonly_selector`;
+  return { key, type };
+}
 function withdraw(token, store) {
   var _a, _b;
   return (_b = (_a = HAMT2.get(token.key, store.atoms)) != null ? _a : HAMT2.get(token.key, store.selectors)) != null ? _b : HAMT2.get(token.key, store.readonlySelectors);
@@ -529,14 +533,16 @@ function deposit(state) {
   return { key: state.key, type: `atom` };
 }
 var getState__INTERNAL = (state, store = IMPLICIT.STORE) => {
-  var _a;
+  var _a, _b, _c;
   if (HAMT2.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;
@@ -554,12 +560,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;
@@ -581,7 +587,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(
@@ -593,87 +599,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 = HAMT4.get(stateKey, store.selectors)) != null ? _c : HAMT4.get(stateKey, store.readonlySelectors);
+    const state2 = (_b2 = HAMT4.get(stateKey, store.selectors)) != null ? _b2 : HAMT4.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 = HAMT4.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 = (atom, next, store = IMPLICIT.STORE) => {
   var _a, _b;
   const oldValue = getState__INTERNAL(atom, store);
   const newValue = become(next)(oldValue);
-  (_a = store.config.logger) == null ? void 0 : _a.info(
-    `->`,
-    `setting atom`,
-    `"${atom.key}"`,
-    `to`,
-    newValue
-  );
+  (_a = store.config.logger) == null ? void 0 : _a.info(`-> setting atom "${atom.key}" to`, newValue);
   store.valueMap = HAMT4.set(atom.key, newValue, store.valueMap);
+  if (isAtomDefault(atom.key)) {
+    store.atomsAreDefault = HAMT4.set(atom.key, false, store.atomsAreDefault);
+  }
   markDone(atom.key, store);
-  atom.subject.next({ newValue, oldValue });
   (_b = store.config.logger) == null ? void 0 : _b.info(
-    `   ||`,
-    `propagating change made to`,
-    `"${atom.key}"`
+    `   || evicting caches downstream from "${atom.key}"`
   );
-  propagateDown(atom, store);
+  evictDownStream(atom, store);
+  atom.subject.next({ newValue, oldValue });
 };
 var setSelectorState = (selector, next, store = IMPLICIT.STORE) => {
   var _a, _b;
   const oldValue = getState__INTERNAL(selector, store);
   const newValue = become(next)(oldValue);
-  (_a = store.config.logger) == null ? void 0 : _a.info(
-    `->`,
-    `setting selector`,
-    `"${selector.key}"`,
-    `to`,
-    newValue
-  );
-  (_b = store.config.logger) == null ? void 0 : _b.info(
-    `   ||`,
-    `propagating change made to`,
-    `"${selector.key}"`
-  );
+  (_a = store.config.logger) == null ? void 0 : _a.info(`-> setting selector "${selector.key}" to`, newValue);
+  (_b = store.config.logger) == null ? void 0 : _b.info(`   || propagating change made to "${selector.key}"`);
   selector.set(newValue);
-  propagateDown(selector, 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 {
@@ -681,6 +660,114 @@ var setState__INTERNAL = (token, value, store = IMPLICIT.STORE) => {
   }
 };
 
+// src/internal/is-default.ts
+import HAMT5 from "hamt_plus";
+var isAtomDefault = (key, store = IMPLICIT.STORE) => {
+  return HAMT5.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 atom = withdraw(atomToken, store);
+    return atom.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;
@@ -719,33 +806,75 @@ var abortTransaction = (store) => {
 };
 
 // src/index.ts
-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 subscribe = (token, observe, store = IMPLICIT.STORE) => {
+  var _a;
+  const state = withdraw(token, store);
+  const subscription = state.subject.subscribe(observe);
+  (_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;
+};
 
 // src/react/index.ts
-var composeStoreHook = ({
+var composeStoreHooks = ({
   useState,
   useEffect,
   store = internal_exports.IMPLICIT.STORE
 }) => {
-  const useSubject = composeSubjectHook(useState, useEffect);
-  function useStore(token) {
-    const { type } = token;
+  function useI(token) {
+    const updateState = (next) => setState(token, next, store);
+    return updateState;
+  }
+  function useO(token) {
     const state = withdraw(token, store);
     const initialValue = internal_exports.getState__INTERNAL(state, store);
-    const [value] = useSubject(state.subject, initialValue);
-    if (type === `readonly_selector`) {
-      return value;
+    const [current, dispatch] = useState(initialValue);
+    useEffect(() => {
+      const unsubscribe = subscribe(
+        token,
+        ({ newValue, oldValue }) => {
+          if (oldValue !== newValue) {
+            dispatch(newValue);
+          }
+        },
+        store
+      );
+      return unsubscribe;
+    }, [current, dispatch]);
+    return current;
+  }
+  function useIO(token) {
+    return [useO(token), useI(token)];
+  }
+  function useStore(token) {
+    if (token.type === `readonly_selector`) {
+      return useO(token);
     }
-    const updateState = (next) => setState(token, next, store);
-    return [value, updateState];
+    return useIO(token);
   }
-  return { useStore };
+  return { useI, useO, useIO, useStore };
 };
 export {
-  composeStoreHook
+  composeStoreHooks
 };
 //# sourceMappingURL=index.mjs.map