ccstate 4.1.0 → 4.2.0

package/core/index.cjs

@@ -1,17 +1,18 @@
 'use strict';
 
 var globalId = 0;
-var generateToString = function generateToString(prefix, debugLabel) {
-  var id = globalId++;
+var generateToString = function generateToString(id, prefix, debugLabel) {
   var label = "".concat(prefix).concat(String(id)).concat(debugLabel ? ':' + debugLabel : '');
   return function () {
     return label;
   };
 };
 function state(init, options) {
+  var id = globalId++;
   var ret = {
+    id: id,
     init: init,
-    toString: generateToString('V', options === null || options === void 0 ? void 0 : options.debugLabel)
+    toString: generateToString(id, 'S', options === null || options === void 0 ? void 0 : options.debugLabel)
   };
   if (options !== null && options !== void 0 && options.debugLabel) {
     ret.debugLabel = options.debugLabel;
@@ -19,9 +20,11 @@ function state(init, options) {
   return ret;
 }
 function computed(read, options) {
+  var id = globalId++;
   var ret = {
+    id: id,
     read: read,
-    toString: generateToString('C', options === null || options === void 0 ? void 0 : options.debugLabel)
+    toString: generateToString(id, 'CPT', options === null || options === void 0 ? void 0 : options.debugLabel)
   };
   if (options !== null && options !== void 0 && options.debugLabel) {
     ret.debugLabel = options.debugLabel;
@@ -29,9 +32,11 @@ function computed(read, options) {
   return ret;
 }
 function command(write, options) {
+  var id = globalId++;
   var ret = {
+    id: id,
     write: write,
-    toString: generateToString('F', options === null || options === void 0 ? void 0 : options.debugLabel)
+    toString: generateToString(id, 'CMD', options === null || options === void 0 ? void 0 : options.debugLabel)
   };
   if (options !== null && options !== void 0 && options.debugLabel) {
     ret.debugLabel = options.debugLabel;
@@ -156,307 +161,6 @@ function _nonIterableRest() {
 function _nonIterableSpread() {
   throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _regeneratorRuntime() {
-  _regeneratorRuntime = function () {
-    return e;
-  };
-  var t,
-    e = {},
-    r = Object.prototype,
-    n = r.hasOwnProperty,
-    o = Object.defineProperty || function (t, e, r) {
-      t[e] = r.value;
-    },
-    i = "function" == typeof Symbol ? Symbol : {},
-    a = i.iterator || "@@iterator",
-    c = i.asyncIterator || "@@asyncIterator",
-    u = i.toStringTag || "@@toStringTag";
-  function define(t, e, r) {
-    return Object.defineProperty(t, e, {
-      value: r,
-      enumerable: !0,
-      configurable: !0,
-      writable: !0
-    }), t[e];
-  }
-  try {
-    define({}, "");
-  } catch (t) {
-    define = function (t, e, r) {
-      return t[e] = r;
-    };
-  }
-  function wrap(t, e, r, n) {
-    var i = e && e.prototype instanceof Generator ? e : Generator,
-      a = Object.create(i.prototype),
-      c = new Context(n || []);
-    return o(a, "_invoke", {
-      value: makeInvokeMethod(t, r, c)
-    }), a;
-  }
-  function tryCatch(t, e, r) {
-    try {
-      return {
-        type: "normal",
-        arg: t.call(e, r)
-      };
-    } catch (t) {
-      return {
-        type: "throw",
-        arg: t
-      };
-    }
-  }
-  e.wrap = wrap;
-  var h = "suspendedStart",
-    l = "suspendedYield",
-    f = "executing",
-    s = "completed",
-    y = {};
-  function Generator() {}
-  function GeneratorFunction() {}
-  function GeneratorFunctionPrototype() {}
-  var p = {};
-  define(p, a, function () {
-    return this;
-  });
-  var d = Object.getPrototypeOf,
-    v = d && d(d(values([])));
-  v && v !== r && n.call(v, a) && (p = v);
-  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
-  function defineIteratorMethods(t) {
-    ["next", "throw", "return"].forEach(function (e) {
-      define(t, e, function (t) {
-        return this._invoke(e, t);
-      });
-    });
-  }
-  function AsyncIterator(t, e) {
-    function invoke(r, o, i, a) {
-      var c = tryCatch(t[r], t, o);
-      if ("throw" !== c.type) {
-        var u = c.arg,
-          h = u.value;
-        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
-          invoke("next", t, i, a);
-        }, function (t) {
-          invoke("throw", t, i, a);
-        }) : e.resolve(h).then(function (t) {
-          u.value = t, i(u);
-        }, function (t) {
-          return invoke("throw", t, i, a);
-        });
-      }
-      a(c.arg);
-    }
-    var r;
-    o(this, "_invoke", {
-      value: function (t, n) {
-        function callInvokeWithMethodAndArg() {
-          return new e(function (e, r) {
-            invoke(t, n, e, r);
-          });
-        }
-        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-      }
-    });
-  }
-  function makeInvokeMethod(e, r, n) {
-    var o = h;
-    return function (i, a) {
-      if (o === f) throw Error("Generator is already running");
-      if (o === s) {
-        if ("throw" === i) throw a;
-        return {
-          value: t,
-          done: !0
-        };
-      }
-      for (n.method = i, n.arg = a;;) {
-        var c = n.delegate;
-        if (c) {
-          var u = maybeInvokeDelegate(c, n);
-          if (u) {
-            if (u === y) continue;
-            return u;
-          }
-        }
-        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
-          if (o === h) throw o = s, n.arg;
-          n.dispatchException(n.arg);
-        } else "return" === n.method && n.abrupt("return", n.arg);
-        o = f;
-        var p = tryCatch(e, r, n);
-        if ("normal" === p.type) {
-          if (o = n.done ? s : l, p.arg === y) continue;
-          return {
-            value: p.arg,
-            done: n.done
-          };
-        }
-        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
-      }
-    };
-  }
-  function maybeInvokeDelegate(e, r) {
-    var n = r.method,
-      o = e.iterator[n];
-    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
-    var i = tryCatch(o, e.iterator, r.arg);
-    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
-    var a = i.arg;
-    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
-  }
-  function pushTryEntry(t) {
-    var e = {
-      tryLoc: t[0]
-    };
-    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
-  }
-  function resetTryEntry(t) {
-    var e = t.completion || {};
-    e.type = "normal", delete e.arg, t.completion = e;
-  }
-  function Context(t) {
-    this.tryEntries = [{
-      tryLoc: "root"
-    }], t.forEach(pushTryEntry, this), this.reset(!0);
-  }
-  function values(e) {
-    if (e || "" === e) {
-      var r = e[a];
-      if (r) return r.call(e);
-      if ("function" == typeof e.next) return e;
-      if (!isNaN(e.length)) {
-        var o = -1,
-          i = function next() {
-            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
-            return next.value = t, next.done = !0, next;
-          };
-        return i.next = i;
-      }
-    }
-    throw new TypeError(typeof e + " is not iterable");
-  }
-  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
-    value: GeneratorFunctionPrototype,
-    configurable: !0
-  }), o(GeneratorFunctionPrototype, "constructor", {
-    value: GeneratorFunction,
-    configurable: !0
-  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
-    var e = "function" == typeof t && t.constructor;
-    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
-  }, e.mark = function (t) {
-    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
-  }, e.awrap = function (t) {
-    return {
-      __await: t
-    };
-  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
-    return this;
-  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
-    void 0 === i && (i = Promise);
-    var a = new AsyncIterator(wrap(t, r, n, o), i);
-    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
-      return t.done ? t.value : a.next();
-    });
-  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
-    return this;
-  }), define(g, "toString", function () {
-    return "[object Generator]";
-  }), e.keys = function (t) {
-    var e = Object(t),
-      r = [];
-    for (var n in e) r.push(n);
-    return r.reverse(), function next() {
-      for (; r.length;) {
-        var t = r.pop();
-        if (t in e) return next.value = t, next.done = !1, next;
-      }
-      return next.done = !0, next;
-    };
-  }, e.values = values, Context.prototype = {
-    constructor: Context,
-    reset: function (e) {
-      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
-    },
-    stop: function () {
-      this.done = !0;
-      var t = this.tryEntries[0].completion;
-      if ("throw" === t.type) throw t.arg;
-      return this.rval;
-    },
-    dispatchException: function (e) {
-      if (this.done) throw e;
-      var r = this;
-      function handle(n, o) {
-        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
-      }
-      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
-        var i = this.tryEntries[o],
-          a = i.completion;
-        if ("root" === i.tryLoc) return handle("end");
-        if (i.tryLoc <= this.prev) {
-          var c = n.call(i, "catchLoc"),
-            u = n.call(i, "finallyLoc");
-          if (c && u) {
-            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-          } else if (c) {
-            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-          } else {
-            if (!u) throw Error("try statement without catch or finally");
-            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-          }
-        }
-      }
-    },
-    abrupt: function (t, e) {
-      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
-        var o = this.tryEntries[r];
-        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
-          var i = o;
-          break;
-        }
-      }
-      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
-      var a = i ? i.completion : {};
-      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
-    },
-    complete: function (t, e) {
-      if ("throw" === t.type) throw t.arg;
-      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
-    },
-    finish: function (t) {
-      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-        var r = this.tryEntries[e];
-        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
-      }
-    },
-    catch: function (t) {
-      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-        var r = this.tryEntries[e];
-        if (r.tryLoc === t) {
-          var n = r.completion;
-          if ("throw" === n.type) {
-            var o = n.arg;
-            resetTryEntry(r);
-          }
-          return o;
-        }
-      }
-      throw Error("illegal catch attempt");
-    },
-    delegateYield: function (e, r, n) {
-      return this.delegate = {
-        iterator: values(e),
-        resultName: r,
-        nextLoc: n
-      }, "next" === this.method && (this.arg = t), y;
-    }
-  }, e;
-}
 function _slicedToArray(r, e) {
   return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
@@ -485,536 +189,619 @@ function _unsupportedIterableToArray(r, a) {
   }
 }
 
+function withSetInterceptor(fn, writable$, interceptor) {
+  if (!interceptor) {
+    return fn();
+  }
+  var result = {
+    called: false
+  };
+  var wrappedFn = function wrappedFn() {
+    result = {
+      called: true,
+      data: fn()
+    };
+    return result.data;
+  };
+  for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+    args[_key - 3] = arguments[_key];
+  }
+  if ('write' in writable$) {
+    interceptor.apply(void 0, [writable$, wrappedFn].concat(_toConsumableArray(args)));
+  } else {
+    interceptor(writable$, wrappedFn, args[0]);
+  }
+  if (!result.called) {
+    throw new Error('interceptor must call fn sync');
+  }
+  return result.data;
+}
+function withGetInterceptor(fn, signal, interceptor) {
+  if (!interceptor) {
+    return fn();
+  }
+  var result = {
+    called: false
+  };
+  interceptor(signal, function () {
+    result = {
+      called: true,
+      data: fn()
+    };
+    return result.data;
+  });
+  if (!result.called) {
+    throw new Error('interceptor must call fn sync');
+  }
+  return result.data;
+}
+function withComputedInterceptor(fn, signal, interceptor) {
+  if (!interceptor) {
+    return fn();
+  }
+  var result = {
+    called: false
+  };
+  interceptor(signal, function () {
+    result = {
+      called: true,
+      data: fn()
+    };
+    return result.data.val;
+  });
+  if (!result.called) {
+    throw new Error('interceptor must call fn sync');
+  }
+  return result.data;
+}
+function withGeValInterceptor(fn, signal, interceptor) {
+  if (!interceptor) {
+    return fn();
+  }
+  var result = {
+    called: false
+  };
+  interceptor(signal, function () {
+    result = {
+      called: true,
+      data: fn()
+    };
+    return result.data;
+  });
+  if (!result.called) {
+    throw new Error('interceptor must call fn sync');
+  }
+  return result.data;
+}
+function withSubInterceptor(fn, signal, callback$, interceptor) {
+  if (!interceptor) {
+    fn();
+    return;
+  }
+  var result = {
+    called: false
+  };
+  interceptor(signal, callback$, function () {
+    result = {
+      called: true,
+      data: undefined
+    };
+    fn();
+  });
+  if (!result.called) {
+    throw new Error('interceptor must call fn sync');
+  }
+}
+function withUnsubInterceptor(fn, signal, callback$, interceptor) {
+  if (!interceptor) {
+    fn();
+    return;
+  }
+  var result = {
+    called: false
+  };
+  interceptor(signal, callback$, function () {
+    result = {
+      called: true,
+      data: undefined
+    };
+    fn();
+  });
+  if (!result.called) {
+    throw new Error('interceptor must call fn sync');
+  }
+}
+function withNotifyInterceptor(fn, callback$, interceptor) {
+  if (!interceptor) {
+    return fn();
+  }
+  var result = {
+    called: false
+  };
+  interceptor(callback$, function () {
+    result = {
+      called: true,
+      data: fn()
+    };
+    return result.data;
+  });
+  if (!result.called) {
+    throw new Error('interceptor must call fn sync');
+  }
+  return result.data;
+}
+
 function canReadAsCompute(atom) {
   return 'read' in atom;
 }
 function isComputedState(state) {
   return 'dependencies' in state;
 }
-var AtomManager = /*#__PURE__*/function () {
-  function AtomManager(options) {
-    var _this = this;
-    _classCallCheck(this, AtomManager);
-    _defineProperty(this, "atomStateMap", new WeakMap());
-    _defineProperty(this, "tryGetCachedState", function (atom, ignoreMounted) {
-      var atomState = _this.atomStateMap.get(atom);
-      if (!atomState) {
-        return undefined;
-      }
-      if (atomState.mounted && !ignoreMounted) {
-        return atomState;
-      }
-      var _iterator = _createForOfIteratorHelper(atomState.dependencies.entries()),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _step$value = _slicedToArray(_step.value, 2),
-            dep = _step$value[0],
-            epoch = _step$value[1];
-          var depState = _this.readAtomState(dep);
-          if (depState.epoch !== epoch) {
-            return undefined;
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+
+function checkEpoch(readComputed, computedState, context, mutation) {
+  var _iterator = _createForOfIteratorHelper(computedState.dependencies.entries()),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _context$stateMap$get;
+      var _step$value = _slicedToArray(_step.value, 2),
+        dep = _step$value[0],
+        epoch = _step$value[1];
+      var depEpoch = canReadAsCompute(dep) ? readComputed(dep, context, mutation).epoch : (_context$stateMap$get = context.stateMap.get(dep)) === null || _context$stateMap$get === void 0 ? void 0 : _context$stateMap$get.epoch;
+      if (depEpoch !== epoch) {
+        return false;
       }
-      return atomState;
-    });
-    this.options = options;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
-  return _createClass(AtomManager, [{
-    key: "readComputedAtom",
-    value: function readComputedAtom(atom) {
-      var _this$options,
-        _this2 = this;
-      var ignoreMounted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      var cachedState = this.tryGetCachedState(atom, ignoreMounted);
-      if (cachedState) {
-        return cachedState;
-      }
-      var computedInterceptor = (_this$options = this.options) === null || _this$options === void 0 || (_this$options = _this$options.interceptor) === null || _this$options === void 0 ? void 0 : _this$options.computed;
-      if (!computedInterceptor) {
-        return this.computeComputedAtom(atom, ignoreMounted);
+  return true;
+}
+function tryGetCached(readComputed, computed$, context, mutation) {
+  var signalState = context.stateMap.get(computed$);
+  if (!signalState) {
+    return undefined;
+  }
+  if (mutation !== null && mutation !== void 0 && mutation.dirtyMarkers.has(computed$.id)) {
+    return undefined;
+  }
+  if (signalState.mounted) {
+    return signalState;
+  }
+  if (checkEpoch(readComputed, signalState, context, mutation)) {
+    return signalState;
+  }
+  return undefined;
+}
+function wrapGet(readSignal, mount, callerComputed$, callerState, context, mutation) {
+  var readDeps = new Map();
+  return [function (dep$) {
+    var depState = readSignal(dep$, context, mutation);
+    if (callerState.dependencies === readDeps) {
+      readDeps.set(dep$, depState.epoch);
+      var callerMounted = !!callerState.mounted;
+      if (callerMounted && !depState.mounted) {
+        mount(dep$, context, mutation).readDepts.add(callerComputed$);
+      } else if (callerMounted && depState.mounted) {
+        depState.mounted.readDepts.add(callerComputed$);
       }
-      var result = {
-        called: false
-      };
-      computedInterceptor(atom, function () {
-        result = {
-          called: true,
-          data: _this2.computeComputedAtom(atom, ignoreMounted)
-        };
-        return result.data.val;
-      });
-      if (!result.called) {
-        throw new Error('interceptor must call fn sync');
+    }
+    return depState.val;
+  }, readDeps];
+}
+function getOrInitComputedState(computed$, context) {
+  var computedState = context.stateMap.get(computed$);
+  if (!computedState) {
+    computedState = {
+      dependencies: new Map(),
+      epoch: -1
+    };
+    context.stateMap.set(computed$, computedState);
+  }
+  return computedState;
+}
+function cleanupMissingDependencies(unmount, computed$, lastDeps, currDeps, context, mutation) {
+  var _iterator2 = _createForOfIteratorHelper(lastDeps.keys()),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var key = _step2.value;
+      if (!currDeps.has(key)) {
+        var _depState$mounted;
+        var depState = context.stateMap.get(key);
+        depState === null || depState === void 0 || (_depState$mounted = depState.mounted) === null || _depState$mounted === void 0 || _depState$mounted.readDepts["delete"](computed$);
+        unmount(key, context, mutation);
       }
-      return result.data;
     }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+}
+function evaluateComputed(readSignal, mount, unmount, computed$, context, mutation) {
+  var computedState = getOrInitComputedState(computed$, context);
+  var lastDeps = computedState.dependencies;
+  var _wrapGet = wrapGet(readSignal, mount, computed$, computedState, context, mutation),
+    _wrapGet2 = _slicedToArray(_wrapGet, 2),
+    _get = _wrapGet2[0],
+    dependencies = _wrapGet2[1];
+  computedState.dependencies = dependencies;
+  var evalVal = computed$.read(function (depAtom) {
+    var _context$interceptor;
+    return withGeValInterceptor(function () {
+      return _get(depAtom);
+    }, depAtom, (_context$interceptor = context.interceptor) === null || _context$interceptor === void 0 ? void 0 : _context$interceptor.get);
   }, {
-    key: "computeComputedAtom",
-    value: function computeComputedAtom(atom) {
-      var _this3 = this,
-        _this$options2;
-      var ignoreMounted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      var self = atom;
-      var atomState = this.atomStateMap.get(self);
-      if (!atomState) {
-        atomState = {
-          dependencies: new Map(),
-          epoch: -1
-        };
-        this.atomStateMap.set(self, atomState);
-      }
-      var lastDeps = atomState.dependencies;
-      var readDeps = new Map();
-      atomState.dependencies = readDeps;
-      var wrappedGet = function wrappedGet(depAtom) {
-        var depState = _this3.readAtomState(depAtom, ignoreMounted);
+    get signal() {
+      var _computedState$abortC, _computed$$debugLabel;
+      (_computedState$abortC = computedState.abortController) === null || _computedState$abortC === void 0 || _computedState$abortC.abort("abort ".concat((_computed$$debugLabel = computed$.debugLabel) !== null && _computed$$debugLabel !== void 0 ? _computed$$debugLabel : 'anonymous', " atom"));
+      computedState.abortController = new AbortController();
+      return computedState.abortController.signal;
+    }
+  });
+  cleanupMissingDependencies(unmount, computed$, lastDeps, dependencies, context, mutation);
+  computedState.val = evalVal;
+  computedState.epoch += 1;
+  return computedState;
+}
 
-        // get 可能发生在异步过程中，当重复调用时，只有最新的 get 过程会修改 deps
-        if (atomState.dependencies === readDeps) {
-          readDeps.set(depAtom, depState.epoch);
-          var selfMounted = !!atomState.mounted;
-          if (selfMounted && !depState.mounted) {
-            _this3.mount(depAtom).readDepts.add(self);
-          } else if (selfMounted && depState.mounted) {
-            depState.mounted.readDepts.add(self);
+function pushDirtyMarkers(signalState, context, mutation) {
+  var _signalState$mounted$, _signalState$mounted;
+  var queue = Array.from((_signalState$mounted$ = (_signalState$mounted = signalState.mounted) === null || _signalState$mounted === void 0 ? void 0 : _signalState$mounted.readDepts) !== null && _signalState$mounted$ !== void 0 ? _signalState$mounted$ : []);
+  while (queue.length > 0) {
+    var nextQueue = [];
+    var _iterator = _createForOfIteratorHelper(queue),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var computed$ = _step.value;
+        mutation.dirtyMarkers.add(computed$.id);
+        var computedState = context.stateMap.get(computed$);
+        // This computed$ is read from other computed$'s readDepts, so it must not be null and must have mounted
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        var _iterator2 = _createForOfIteratorHelper(computedState.mounted.readDepts),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var dep = _step2.value;
+            nextQueue.push(dep);
           }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
         }
-        return depState.val;
-      };
-      var getInterceptor = (_this$options2 = this.options) === null || _this$options2 === void 0 || (_this$options2 = _this$options2.interceptor) === null || _this$options2 === void 0 ? void 0 : _this$options2.get;
-      var ret = self.read(function (depAtom) {
-        if (!getInterceptor) {
-          return wrappedGet(depAtom);
-        }
-        var result = {
-          called: false
-        };
-        var fn = function fn() {
-          result = {
-            called: true,
-            data: wrappedGet(depAtom)
-          };
-          return result.data;
-        };
-        getInterceptor(depAtom, fn);
-        if (!result.called) {
-          throw new Error('interceptor must call fn sync');
-        }
-        return result.data;
-      }, {
-        get signal() {
-          var _atomState$abortContr, _self$debugLabel;
-          (_atomState$abortContr = atomState.abortController) === null || _atomState$abortContr === void 0 || _atomState$abortContr.abort("abort ".concat((_self$debugLabel = self.debugLabel) !== null && _self$debugLabel !== void 0 ? _self$debugLabel : 'anonymous', " atom"));
-          atomState.abortController = new AbortController();
-          return atomState.abortController.signal;
-        }
-      });
-      if (atomState.val !== ret) {
-        atomState.val = ret;
-        atomState.epoch += 1;
       }
-      var _iterator2 = _createForOfIteratorHelper(lastDeps.keys()),
-        _step2;
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var key = _step2.value;
-          if (!readDeps.has(key)) {
-            var depState = this.atomStateMap.get(key);
-            if (depState !== null && depState !== void 0 && depState.mounted) {
-              depState.mounted.readDepts["delete"](self);
-              this.tryUnmount(key);
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    queue = nextQueue;
+  }
+}
+function pullEvaluate(readComputed, signalState, context, mutation) {
+  var _signalState$mounted$2, _signalState$mounted2, _signalState$mounted$3, _signalState$mounted3;
+  var queue = Array.from((_signalState$mounted$2 = (_signalState$mounted2 = signalState.mounted) === null || _signalState$mounted2 === void 0 ? void 0 : _signalState$mounted2.readDepts) !== null && _signalState$mounted$2 !== void 0 ? _signalState$mounted$2 : []);
+  var _iterator3 = _createForOfIteratorHelper((_signalState$mounted$3 = (_signalState$mounted3 = signalState.mounted) === null || _signalState$mounted3 === void 0 ? void 0 : _signalState$mounted3.listeners) !== null && _signalState$mounted$3 !== void 0 ? _signalState$mounted$3 : []),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _listener = _step3.value;
+      mutation.pendingListeners.add(_listener);
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  while (queue.length > 0) {
+    var nextQueue = [];
+    var _iterator4 = _createForOfIteratorHelper(queue),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _computedState$mounte, _computedState$mounte2;
+        var computed$ = _step4.value;
+        var computedState = readComputed(computed$, context, mutation);
+        if ((_computedState$mounte = computedState.mounted) !== null && _computedState$mounte !== void 0 && _computedState$mounte.listeners) {
+          var _iterator5 = _createForOfIteratorHelper(computedState.mounted.listeners),
+            _step5;
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var listener = _step5.value;
+              mutation.pendingListeners.add(listener);
             }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
           }
         }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
-      }
-      return atomState;
-    }
-  }, {
-    key: "readStateAtom",
-    value: function readStateAtom(atom) {
-      var atomState = this.atomStateMap.get(atom);
-      if (!atomState) {
-        var initState = {
-          val: atom.init,
-          epoch: 0
-        };
-        this.atomStateMap.set(atom, initState);
-        return initState;
-      }
-      return atomState;
-    }
-  }, {
-    key: "readAtomState",
-    value: function readAtomState(atom) {
-      var ignoreMounted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      if (canReadAsCompute(atom)) {
-        return this.readComputedAtom(atom, ignoreMounted);
-      }
-      return this.readStateAtom(atom);
-    }
-  }, {
-    key: "tryGetMount",
-    value: function tryGetMount(atom) {
-      var _this$atomStateMap$ge;
-      return (_this$atomStateMap$ge = this.atomStateMap.get(atom)) === null || _this$atomStateMap$ge === void 0 ? void 0 : _this$atomStateMap$ge.mounted;
-    }
-  }, {
-    key: "mount",
-    value: function mount(atom) {
-      var _this$options3, _this$options3$mount, _atomState$mounted;
-      var mounted = this.tryGetMount(atom);
-      if (mounted) {
-        return mounted;
-      }
-      (_this$options3 = this.options) === null || _this$options3 === void 0 || (_this$options3 = _this$options3.interceptor) === null || _this$options3 === void 0 || (_this$options3$mount = _this$options3.mount) === null || _this$options3$mount === void 0 || _this$options3$mount.call(_this$options3, atom);
-      var atomState = this.readAtomState(atom);
-      atomState.mounted = (_atomState$mounted = atomState.mounted) !== null && _atomState$mounted !== void 0 ? _atomState$mounted : {
-        listeners: new Set(),
-        readDepts: new Set()
-      };
-      if (isComputedState(atomState)) {
-        for (var _i = 0, _Array$from = Array.from(atomState.dependencies); _i < _Array$from.length; _i++) {
-          var _Array$from$_i = _slicedToArray(_Array$from[_i], 1),
-            dep = _Array$from$_i[0];
-          var _mounted = this.mount(dep);
-          _mounted.readDepts.add(atom);
+        var readDepts = (_computedState$mounte2 = computedState.mounted) === null || _computedState$mounte2 === void 0 ? void 0 : _computedState$mounte2.readDepts;
+        if (readDepts) {
+          for (var _i = 0, _Array$from = Array.from(readDepts); _i < _Array$from.length; _i++) {
+            var dep = _Array$from[_i];
+            nextQueue.push(dep);
+          }
         }
       }
-      return atomState.mounted;
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
     }
-  }, {
-    key: "tryUnmount",
-    value: function tryUnmount(atom) {
-      var _this$options4, _this$options4$unmoun;
-      var atomState = this.atomStateMap.get(atom);
-      if (!(atomState !== null && atomState !== void 0 && atomState.mounted) || atomState.mounted.listeners.size || atomState.mounted.readDepts.size) {
-        return;
-      }
-      (_this$options4 = this.options) === null || _this$options4 === void 0 || (_this$options4 = _this$options4.interceptor) === null || _this$options4 === void 0 || (_this$options4$unmoun = _this$options4.unmount) === null || _this$options4$unmoun === void 0 || _this$options4$unmoun.call(_this$options4, atom);
-      if (isComputedState(atomState)) {
-        for (var _i2 = 0, _Array$from2 = Array.from(atomState.dependencies); _i2 < _Array$from2.length; _i2++) {
-          var _depState$mounted;
-          var _Array$from2$_i = _slicedToArray(_Array$from2[_i2], 1),
-            dep = _Array$from2$_i[0];
-          var depState = this.readAtomState(dep);
-          (_depState$mounted = depState.mounted) === null || _depState$mounted === void 0 || _depState$mounted.readDepts["delete"](atom);
-          this.tryUnmount(dep);
+    queue = nextQueue;
+  }
+}
+function propagationChanges(readComputed, signalState, context, mutation) {
+  pushDirtyMarkers(signalState, context, mutation);
+  pullEvaluate(readComputed, signalState, context, mutation);
+}
+function innerSetState(readComputed, signal$, context, mutation, val) {
+  var _ref, _context$stateMap$get;
+  var newValue = typeof val === 'function' ? val((_ref = (_context$stateMap$get = context.stateMap.get(signal$)) === null || _context$stateMap$get === void 0 ? void 0 : _context$stateMap$get.val) !== null && _ref !== void 0 ? _ref : signal$.init) : val;
+  var signalState = context.stateMap.get(signal$);
+  if (!signalState) {
+    context.stateMap.set(signal$, {
+      val: newValue,
+      epoch: 0
+    });
+    return;
+  }
+  signalState.val = newValue;
+  signalState.epoch += 1;
+  propagationChanges(readComputed, signalState, context, mutation);
+  return undefined;
+}
+function set(readComputed, writable$, context, mutation) {
+  if ('read' in writable$) {
+    return;
+  }
+  for (var _len = arguments.length, args = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
+    args[_key - 4] = arguments[_key];
+  }
+  if ('write' in writable$) {
+    return writable$.write.apply(writable$, [mutation.visitor].concat(_toConsumableArray(args)));
+  }
+  innerSetState(readComputed, writable$, context, mutation, args[0]);
+  return;
+}
+
+/**
+ * Creates a mutation operation context. The Mutation remains unique throughout
+ * the mutation cycle and can track side effects produced by this mutation operation
+ *
+ * This tracking is implemented by coloring the visitor function, so the Mutation
+ * needs to wrap get & set functions and ensure that all get & set operations
+ * executed in the mutation context come from the same Mutation
+ *
+ * @param context
+ * @param get
+ * @param set
+ * @returns
+ */
+function createMutation(context, _get, _set) {
+  var mutation = {
+    dirtyMarkers: new Set(),
+    pendingListeners: new Set(),
+    visitor: {
+      get: function get(signal$) {
+        return _get(signal$, context, mutation);
+      },
+      set: function set(signal$) {
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
         }
+        return _set.apply(void 0, [signal$, context].concat(args));
       }
-      atomState.mounted = undefined;
     }
-  }, {
-    key: "inited",
-    value: function inited(atom) {
-      return this.atomStateMap.has(atom);
-    }
-  }]);
-}();
-var ListenerManager = /*#__PURE__*/function () {
-  function ListenerManager() {
-    _classCallCheck(this, ListenerManager);
-    _defineProperty(this, "pendingListeners", new Set());
+  };
+  return mutation;
+}
+
+function readState(state, context) {
+  var atomState = context.stateMap.get(state);
+  if (!atomState) {
+    var initState = {
+      val: state.init,
+      epoch: 0
+    };
+    context.stateMap.set(state, initState);
+    return initState;
   }
-  return _createClass(ListenerManager, [{
-    key: "markPendingListeners",
-    value: function markPendingListeners(atomManager, atom) {
-      var queue = [atom];
-      while (queue.length > 0) {
-        var nextQueue = [];
-        var _iterator3 = _createForOfIteratorHelper(queue),
-          _step3;
-        try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var _atomState$mounted2, _atomState$mounted3;
-            var _atom = _step3.value;
-            var atomState = atomManager.readAtomState(_atom, true);
-            if ((_atomState$mounted2 = atomState.mounted) !== null && _atomState$mounted2 !== void 0 && _atomState$mounted2.listeners) {
-              var _iterator4 = _createForOfIteratorHelper(atomState.mounted.listeners),
-                _step4;
-              try {
-                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-                  var listener = _step4.value;
-                  this.pendingListeners.add(listener);
-                }
-              } catch (err) {
-                _iterator4.e(err);
-              } finally {
-                _iterator4.f();
-              }
-            }
-            var readDepts = (_atomState$mounted3 = atomState.mounted) === null || _atomState$mounted3 === void 0 ? void 0 : _atomState$mounted3.readDepts;
-            if (readDepts) {
-              for (var _i3 = 0, _Array$from3 = Array.from(readDepts); _i3 < _Array$from3.length; _i3++) {
-                var dep = _Array$from3[_i3];
-                nextQueue.push(dep);
-              }
-            }
-          }
-        } catch (err) {
-          _iterator3.e(err);
-        } finally {
-          _iterator3.f();
+  return atomState;
+}
+
+function unmountComputedDependencies(computed$, computedState, context, mutation) {
+  for (var _i = 0, _Array$from = Array.from(computedState.dependencies); _i < _Array$from.length; _i++) {
+    var _context$stateMap$get;
+    var _Array$from$_i = _slicedToArray(_Array$from[_i], 1),
+      dep = _Array$from$_i[0];
+    (_context$stateMap$get = context.stateMap.get(dep)) === null || _context$stateMap$get === void 0 || (_context$stateMap$get = _context$stateMap$get.mounted) === null || _context$stateMap$get === void 0 || _context$stateMap$get.readDepts["delete"](computed$);
+    unmount(dep, context);
+  }
+}
+function mountComputedDependencies(readSignal, computed$, computedState, context, mutation) {
+  for (var _i2 = 0, _Array$from2 = Array.from(computedState.dependencies); _i2 < _Array$from2.length; _i2++) {
+    var _Array$from2$_i = _slicedToArray(_Array$from2[_i2], 1),
+      dep = _Array$from2$_i[0];
+    var mounted = mount$1(readSignal, dep, context, mutation);
+    mounted.readDepts.add(computed$);
+  }
+}
+function initMount(readSignal, signal$, context, mutation) {
+  var _context$interceptor, _context$interceptor$, _signalState$mounted;
+  (_context$interceptor = context.interceptor) === null || _context$interceptor === void 0 || (_context$interceptor$ = _context$interceptor.mount) === null || _context$interceptor$ === void 0 || _context$interceptor$.call(_context$interceptor, signal$);
+  var signalState = readSignal(signal$, context, mutation);
+  signalState.mounted = (_signalState$mounted = signalState.mounted) !== null && _signalState$mounted !== void 0 ? _signalState$mounted : {
+    listeners: new Set(),
+    readDepts: new Set()
+  };
+  if (isComputedState(signalState)) {
+    mountComputedDependencies(readSignal, signal$, signalState, context, mutation);
+  }
+  return signalState.mounted;
+}
+function mount$1(readSignal, signal$, context, mutation) {
+  var _context$stateMap$get2;
+  var mounted = (_context$stateMap$get2 = context.stateMap.get(signal$)) === null || _context$stateMap$get2 === void 0 ? void 0 : _context$stateMap$get2.mounted;
+  if (mounted) {
+    return mounted;
+  }
+  return initMount(readSignal, signal$, context, mutation);
+}
+function doUnmount(signal$, signalState, context, mutation) {
+  var _context$interceptor2, _context$interceptor3;
+  (_context$interceptor2 = context.interceptor) === null || _context$interceptor2 === void 0 || (_context$interceptor3 = _context$interceptor2.unmount) === null || _context$interceptor3 === void 0 || _context$interceptor3.call(_context$interceptor2, signal$);
+  if (isComputedState(signalState)) {
+    unmountComputedDependencies(signal$, signalState, context);
+  }
+  signalState.mounted = undefined;
+}
+function unmount(signal$, context, mutation) {
+  var signalState = context.stateMap.get(signal$);
+  if (!(signalState !== null && signalState !== void 0 && signalState.mounted) || signalState.mounted.listeners.size || signalState.mounted.readDepts.size) {
+    return;
+  }
+  doUnmount(signal$, signalState, context);
+}
+function subSingleSignal(readSignal, signal$, callback$, context, signal) {
+  var _context$interceptor5;
+  withSubInterceptor(function () {
+    var mounted = mount$1(readSignal, signal$, context);
+    mounted.listeners.add(callback$);
+    var unsub = function unsub() {
+      var _context$interceptor4;
+      withUnsubInterceptor(function () {
+        mounted.listeners["delete"](callback$);
+        if (mounted.readDepts.size === 0 && mounted.listeners.size === 0) {
+          unmount(signal$, context);
         }
-        queue = nextQueue;
-      }
+      }, signal$, callback$, (_context$interceptor4 = context.interceptor) === null || _context$interceptor4 === void 0 ? void 0 : _context$interceptor4.unsub);
+    };
+    signal.addEventListener('abort', unsub, {
+      once: true
+    });
+  }, signal$, callback$, (_context$interceptor5 = context.interceptor) === null || _context$interceptor5 === void 0 ? void 0 : _context$interceptor5.sub);
+}
+function notify(context, mutation) {
+  var pendingListeners = mutation.pendingListeners;
+  mutation.pendingListeners = new Set();
+  var _iterator = _createForOfIteratorHelper(pendingListeners),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var _context$interceptor6;
+      var listener = _step.value;
+      withNotifyInterceptor(function () {
+        return listener.write(mutation.visitor);
+      }, listener, (_context$interceptor6 = context.interceptor) === null || _context$interceptor6 === void 0 ? void 0 : _context$interceptor6.notify);
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
     }
-  }, {
-    key: "notify",
-    value: /*#__PURE__*/_regeneratorRuntime().mark(function notify() {
-      var pendingListeners, _iterator5, _step5, listener;
-      return _regeneratorRuntime().wrap(function notify$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            pendingListeners = this.pendingListeners;
-            this.pendingListeners = new Set();
-            _iterator5 = _createForOfIteratorHelper(pendingListeners);
-            _context.prev = 3;
-            _iterator5.s();
-          case 5:
-            if ((_step5 = _iterator5.n()).done) {
-              _context.next = 11;
-              break;
-            }
-            listener = _step5.value;
-            _context.next = 9;
-            return listener;
-          case 9:
-            _context.next = 5;
-            break;
-          case 11:
-            _context.next = 16;
-            break;
-          case 13:
-            _context.prev = 13;
-            _context.t0 = _context["catch"](3);
-            _iterator5.e(_context.t0);
-          case 16:
-            _context.prev = 16;
-            _iterator5.f();
-            return _context.finish(16);
-          case 19:
-          case "end":
-            return _context.stop();
-        }
-      }, notify, this, [[3, 13, 16, 19]]);
-    })
-  }]);
-}();
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
 
+var _readComputed = function readComputed(computed$, context, mutation) {
+  var _context$interceptor;
+  var cachedState = tryGetCached(_readComputed, computed$, context, mutation);
+  if (cachedState) {
+    return cachedState;
+  }
+  mutation === null || mutation === void 0 || mutation.dirtyMarkers["delete"](computed$.id);
+  return withComputedInterceptor(function () {
+    return evaluateComputed(readSignal, mount, unmount, computed$, context, mutation);
+  }, computed$, (_context$interceptor = context.interceptor) === null || _context$interceptor === void 0 ? void 0 : _context$interceptor.computed);
+};
+function readSignal(signal$, context, mutation) {
+  if (canReadAsCompute(signal$)) {
+    return _readComputed(signal$, context, mutation);
+  }
+  return readState(signal$, context);
+}
+function mount(signal$, context, mutation) {
+  return mount$1(readSignal, signal$, context, mutation);
+}
+function _sub(signals$, callback$, context, options) {
+  if (Array.isArray(signals$) && signals$.length === 0) {
+    return function () {
+      return void 0;
+    };
+  }
+  var controller = new AbortController();
+  var signal = options !== null && options !== void 0 && options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+  if (!Array.isArray(signals$)) {
+    subSingleSignal(readSignal, signals$, callback$, context, signal);
+  } else {
+    signals$.forEach(function (atom) {
+      subSingleSignal(readSignal, atom, callback$, context, signal);
+    });
+  }
+  return function () {
+    controller.abort();
+  };
+}
+var get = function get(signal, context, mutation) {
+  var _context$interceptor2;
+  return withGetInterceptor(function () {
+    return readSignal(signal, context, mutation).val;
+  }, signal, (_context$interceptor2 = context.interceptor) === null || _context$interceptor2 === void 0 ? void 0 : _context$interceptor2.get);
+};
+var _set = function set$1(atom, context) {
+  var _context$interceptor3;
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+  return withSetInterceptor.apply(void 0, [function () {
+    var mutation = createMutation(context, get, _set);
+    var ret;
+    try {
+      ret = set.apply(void 0, [_readComputed, atom, context, mutation].concat(args));
+    } finally {
+      notify(context, mutation);
+    }
+    return ret;
+  }, atom, (_context$interceptor3 = context.interceptor) === null || _context$interceptor3 === void 0 ? void 0 : _context$interceptor3.set].concat(args));
+};
 var StoreImpl = /*#__PURE__*/function () {
-  function StoreImpl(atomManager, listenerManager, options) {
-    var _this = this;
+  function StoreImpl(options) {
+    var _this = this,
+      _this$options;
     _classCallCheck(this, StoreImpl);
-    _defineProperty(this, "innerSet", function (atom) {
-      if ('read' in atom) {
-        return;
-      }
-      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        args[_key - 1] = arguments[_key];
-      }
-      if ('write' in atom) {
-        var ret = atom.write.apply(atom, [{
-          get: _this.get,
-          set: _this.set
-        }].concat(_toConsumableArray(args)));
-        return ret;
-      }
-      var newValue = typeof args[0] === 'function' ? args[0](_this.atomManager.readAtomState(atom).val) : args[0];
-      if (!_this.atomManager.inited(atom)) {
-        _this.atomManager.readAtomState(atom).val = newValue;
-        _this.listenerManager.markPendingListeners(_this.atomManager, atom);
-        return;
-      }
-      var atomState = _this.atomManager.readAtomState(atom);
-      atomState.val = newValue;
-      atomState.epoch += 1;
-      _this.listenerManager.markPendingListeners(_this.atomManager, atom);
-      return undefined;
-    });
+    _defineProperty(this, "stateMap", new WeakMap());
     _defineProperty(this, "get", function (atom) {
-      var _this$options;
-      if (!((_this$options = _this.options) !== null && _this$options !== void 0 && (_this$options = _this$options.interceptor) !== null && _this$options !== void 0 && _this$options.get)) {
-        return _this.atomManager.readAtomState(atom).val;
-      }
-      var result = {
-        called: false
-      };
-      var fnWithRet = function fnWithRet() {
-        result = {
-          called: true,
-          data: _this.atomManager.readAtomState(atom).val
-        };
-        return result.data;
-      };
-      _this.options.interceptor.get(atom, fnWithRet);
-      if (!result.called) {
-        throw new Error('interceptor must call fn sync');
-      }
-      return result.data;
-    });
-    _defineProperty(this, "notify", function () {
-      var _iterator = _createForOfIteratorHelper(_this.listenerManager.notify()),
-        _step;
-      try {
-        var _loop = function _loop() {
-          var _this$options2;
-          var listener = _step.value;
-          var notifyed = false;
-          var fn = function fn() {
-            notifyed = true;
-            return listener.write({
-              get: _this.get,
-              set: _this.set
-            });
-          };
-          if ((_this$options2 = _this.options) !== null && _this$options2 !== void 0 && (_this$options2 = _this$options2.interceptor) !== null && _this$options2 !== void 0 && _this$options2.notify) {
-            _this.options.interceptor.notify(listener, fn);
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- notify must call fn sync
-            if (!notifyed) {
-              throw new Error('interceptor must call fn sync');
-            }
-          } else {
-            fn();
-          }
-        };
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          _loop();
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
+      return get(atom, _this.context);
     });
     _defineProperty(this, "set", function (atom) {
-      var _this$options3;
       for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
         args[_key2 - 1] = arguments[_key2];
       }
-      var ret;
-      var fn = function fn() {
-        try {
-          ret = _this.innerSet.apply(_this, [atom].concat(args));
-        } finally {
-          _this.notify();
-        }
-        return ret;
-      };
-      if ((_this$options3 = _this.options) !== null && _this$options3 !== void 0 && (_this$options3 = _this$options3.interceptor) !== null && _this$options3 !== void 0 && _this$options3.set) {
-        if ('write' in atom) {
-          var _this$options$interce;
-          (_this$options$interce = _this.options.interceptor).set.apply(_this$options$interce, [atom, fn].concat(_toConsumableArray(args)));
-        } else {
-          _this.options.interceptor.set(atom, fn, args[0]);
-        }
-      } else {
-        fn();
-      }
-      return ret;
+      return _set.apply(void 0, [atom, _this.context].concat(args));
     });
-    this.atomManager = atomManager;
-    this.listenerManager = listenerManager;
     this.options = options;
+    this.context = {
+      stateMap: this.stateMap,
+      interceptor: (_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.interceptor
+    };
   }
   return _createClass(StoreImpl, [{
-    key: "_subSingleAtom",
-    value: function _subSingleAtom(target$, cb$, options) {
-      var _this2 = this,
-        _this$options4;
-      var unsub;
-      var _fn2 = function fn() {
-        var _options$signal2;
-        var subscribed = true;
-        var mounted = _this2.atomManager.mount(target$);
-        mounted.listeners.add(cb$);
-        unsub = function unsub() {
-          var _this2$options;
-          if (!subscribed) {
-            return;
-          }
-          var _fn = function fn() {
-            var _options$signal;
-            subscribed = false;
-            mounted.listeners["delete"](cb$);
-            if (mounted.readDepts.size === 0 && mounted.listeners.size === 0) {
-              _this2.atomManager.tryUnmount(target$);
-            }
-            options === null || options === void 0 || (_options$signal = options.signal) === null || _options$signal === void 0 || _options$signal.addEventListener('abort', _fn);
-          };
-          if ((_this2$options = _this2.options) !== null && _this2$options !== void 0 && (_this2$options = _this2$options.interceptor) !== null && _this2$options !== void 0 && _this2$options.unsub) {
-            _this2.options.interceptor.unsub(target$, cb$, _fn);
-
-            // subscribed should be false if interceptor called fn sync
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            if (subscribed) {
-              throw new Error('interceptor must call fn sync');
-            }
-          } else {
-            _fn();
-          }
-        };
-        options === null || options === void 0 || (_options$signal2 = options.signal) === null || _options$signal2 === void 0 || _options$signal2.addEventListener('abort', unsub);
-      };
-      if ((_this$options4 = this.options) !== null && _this$options4 !== void 0 && (_this$options4 = _this$options4.interceptor) !== null && _this$options4 !== void 0 && _this$options4.sub) {
-        this.options.interceptor.sub(target$, cb$, _fn2);
-      } else {
-        _fn2();
-      }
-      if (!unsub) {
-        throw new Error('interceptor must call fn sync');
-      }
-      return unsub;
-    }
-  }, {
     key: "sub",
     value: function sub(targets$, cb$, options) {
-      var _this3 = this;
-      if (Array.isArray(targets$) && targets$.length === 0) {
-        return function () {
-          return void 0;
-        };
-      }
-      if (Array.isArray(targets$) && targets$.length === 1) {
-        return this._subSingleAtom(targets$[0], cb$, options);
-      } else if (!Array.isArray(targets$)) {
-        return this._subSingleAtom(targets$, cb$, options);
-      }
-      var unsubscribes = new Set();
-      targets$.forEach(function (atom) {
-        unsubscribes.add(_this3._subSingleAtom(atom, cb$, options));
-      });
-      var unsub = function unsub() {
-        var _iterator2 = _createForOfIteratorHelper(unsubscribes),
-          _step2;
-        try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var unsubscribe = _step2.value;
-            unsubscribe();
-          }
-        } catch (err) {
-          _iterator2.e(err);
-        } finally {
-          _iterator2.f();
-        }
-      };
-      return unsub;
+      return _sub(targets$, cb$, this.context, options);
     }
   }]);
 }();
 function createStore() {
-  var atomManager = new AtomManager();
-  var listenerManager = new ListenerManager();
-  return new StoreImpl(atomManager, listenerManager);
+  return new StoreImpl();
 }
 var defaultStore = undefined;
 function getDefaultStore() {