@flowgram-vue/reactive 0.2.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+Copyright (c) 2026 Crayon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# Reactive
+
+## Usage
+
+### 创建响应式数据并做依赖追踪
+
+```typescript
+
+import { ReactiveState, Tracker } from '@flowgram-vue/reactive'
+
+// 创建 数据
+const reactiveState = new ReactiveState<{ a: number, b: number }>({ a: 0, b: 0 })
+
+// 监听函数
+const result = Tracker.autorun(() => {
+  console.log('run: ', reactiveState.value, reactiveState.value.a)
+})
+
+// 更新字典数据 a 会自动执行上边的 autorun
+reactiveState.value.a = 1
+
+// 更新数据 b 则不会执行，因为 autorun 函数里没有依赖
+reactiveState.value.b = 1
+```
+
+
+### Vue 中使用
+
+```vue
+<script setup lang="ts">
+import { h } from 'vue'
+import { useReactiveState, observe } from '@flowgram-vue/reactive'
+
+const SomeComp = observe((props: { state: { a: number } }) => h('div', props.state.a))
+
+const state = useReactiveState<{ a: number, b: number }>({ a: 0, b: 0 })
+</script>
+```

package/dist/index.cjs

@@ -0,0 +1,526 @@
+'use strict';
+
+var vue = require('vue');
+
+// src/core/tracker.ts
+exports.Tracker = void 0;
+((Tracker2) => {
+  const _pendingComputations = [];
+  const _afterFlushCallbacks = [];
+  let _willFlush = false;
+  let _inFlush = false;
+  let _inCompute = false;
+  let _currentComputation = void 0;
+  let _throwFirstError = false;
+  function _throwOrLog(msg, e) {
+    if (_throwFirstError) {
+      throw e;
+    } else {
+      console.error(`[Tracker error] ${msg}`, e);
+    }
+  }
+  function _runFlush(options) {
+    if (inFlush()) throw new Error("Can't call Tracker.flush while flushing");
+    if (_inCompute) throw new Error("Can't flush inside Tracker.autorun");
+    options = options || {};
+    _inFlush = true;
+    _willFlush = true;
+    _throwFirstError = !!options.throwFirstError;
+    var recomputedCount = 0;
+    var finishedTry = false;
+    try {
+      while (_pendingComputations.length || _afterFlushCallbacks.length) {
+        while (_pendingComputations.length) {
+          var comp = _pendingComputations.shift();
+          comp._recompute();
+          if (comp._needsRecompute()) {
+            _pendingComputations.unshift(comp);
+          }
+          if (!options.finishSynchronously && ++recomputedCount > 100) {
+            finishedTry = true;
+            return;
+          }
+        }
+        if (_afterFlushCallbacks.length) {
+          var func = _afterFlushCallbacks.shift();
+          try {
+            func();
+          } catch (e) {
+            _throwOrLog("afterFlush", e);
+          }
+        }
+      }
+      finishedTry = true;
+    } finally {
+      if (!finishedTry) {
+        _inFlush = false;
+        _runFlush({
+          finishSynchronously: options.finishSynchronously,
+          throwFirstError: false
+        });
+      }
+      _willFlush = false;
+      _inFlush = false;
+      if (_pendingComputations.length || _afterFlushCallbacks.length) {
+        if (options.finishSynchronously) {
+          throw new Error("still have more to do?");
+        }
+        setTimeout(_requireFlush, 10);
+      }
+    }
+  }
+  function _requireFlush() {
+    if (!_willFlush) {
+      setTimeout(_runFlush, 0);
+      _willFlush = true;
+    }
+  }
+  function withComputation(computation, f) {
+    let previousComputation = _currentComputation;
+    _currentComputation = computation;
+    try {
+      return f.call(null, computation);
+    } finally {
+      _currentComputation = previousComputation;
+    }
+  }
+  Tracker2.withComputation = withComputation;
+  function withoutComputation(f) {
+    let previousComputation = _currentComputation;
+    _currentComputation = void 0;
+    try {
+      return f(void 0);
+    } finally {
+      _currentComputation = previousComputation;
+    }
+  }
+  Tracker2.withoutComputation = withoutComputation;
+  function isActive() {
+    return !!_currentComputation;
+  }
+  Tracker2.isActive = isActive;
+  function getCurrentComputation() {
+    return _currentComputation;
+  }
+  Tracker2.getCurrentComputation = getCurrentComputation;
+  function autorun(f, options) {
+    var c = new Computation2(f, _currentComputation, options?.onError);
+    if (isActive())
+      Tracker2.onInvalidate(function() {
+        c.stop();
+      });
+    return c;
+  }
+  Tracker2.autorun = autorun;
+  function onInvalidate(f) {
+    if (!_currentComputation) {
+      throw new Error("Tracker.onInvalidate requires a currentComputation");
+    }
+    _currentComputation.onInvalidate(f);
+  }
+  Tracker2.onInvalidate = onInvalidate;
+  function inFlush() {
+    return _inFlush;
+  }
+  Tracker2.inFlush = inFlush;
+  function flush(options) {
+    _runFlush({
+      finishSynchronously: true,
+      throwFirstError: options && options.throwFirstError
+    });
+  }
+  Tracker2.flush = flush;
+  function afterFlush(f) {
+    _afterFlushCallbacks.push(f);
+    _requireFlush();
+  }
+  Tracker2.afterFlush = afterFlush;
+  class Computation2 {
+    constructor(_fn, parent, _onError) {
+      this._fn = _fn;
+      this.parent = parent;
+      this._onError = _onError;
+      this._onInvalidateCallbacks = [];
+      this._onStopCallbacks = [];
+      this._recomputing = false;
+      /**
+       * 是否停止
+       */
+      this.stopped = false;
+      /**
+       * 未开始执行则返回 false
+       */
+      this.invalidated = false;
+      /**
+       * 是否第一次执行
+       */
+      this.firstRun = true;
+      let hasError = true;
+      try {
+        this._compute();
+        hasError = false;
+      } finally {
+        this.firstRun = false;
+        if (hasError) {
+          this.stop();
+        }
+      }
+    }
+    onInvalidate(f) {
+      if (this.invalidated) {
+        withoutComputation(f.bind(null, this));
+      } else {
+        this._onInvalidateCallbacks.push(f);
+      }
+    }
+    /**
+     * @summary Invalidates this computation so that it will be rerun.
+     */
+    invalidate() {
+      if (!this.invalidated) {
+        if (!this._recomputing && !this.stopped) {
+          _requireFlush();
+          _pendingComputations.push(this);
+        }
+        this.invalidated = true;
+        for (var i = 0, f; f = this._onInvalidateCallbacks[i]; i++) {
+          withoutComputation(f.bind(null, this));
+        }
+        this._onInvalidateCallbacks = [];
+      }
+    }
+    /**
+     * @summary Prevents this computation from rerunning.
+     * @locus Client
+     */
+    stop() {
+      if (!this.stopped) {
+        this.stopped = true;
+        this.invalidate();
+        for (let i = 0, f; f = this._onStopCallbacks[i]; i++) {
+          withoutComputation(f.bind(null, this));
+        }
+        this._onStopCallbacks = [];
+      }
+    }
+    onStop(f) {
+      if (this.stopped) {
+        withoutComputation(f.bind(null, this));
+      } else {
+        this._onStopCallbacks.push(f);
+      }
+    }
+    _compute() {
+      this.invalidated = false;
+      var previousInCompute = _inCompute;
+      _inCompute = true;
+      try {
+        this._result = Tracker2.withComputation(this, this._fn);
+      } finally {
+        _inCompute = previousInCompute;
+      }
+    }
+    _needsRecompute() {
+      return this.invalidated && !this.stopped;
+    }
+    _recompute() {
+      this._recomputing = true;
+      try {
+        if (this._needsRecompute()) {
+          try {
+            this._compute();
+          } catch (e) {
+            if (this._onError) {
+              this._onError(e);
+            } else {
+              _throwOrLog("recompute", e);
+            }
+          }
+        }
+      } finally {
+        this._recomputing = false;
+      }
+    }
+    /**
+     * @summary Process the reactive updates for this computation immediately
+     * and ensure that the computation is rerun. The computation is rerun only
+     * if it is invalidated.
+     */
+    flush() {
+      if (this._recomputing) return;
+      this._recompute();
+    }
+    /**
+     * @summary Causes the function inside this computation to run and
+     * synchronously process all reactive updtes.
+     * @locus Client
+     */
+    run() {
+      this.invalidate();
+      this.flush();
+    }
+    get result() {
+      return this._result;
+    }
+  }
+  Tracker2.Computation = Computation2;
+  class Dependency3 {
+    constructor() {
+      this._dependents = /* @__PURE__ */ new Set();
+    }
+    /**
+     * Declares that the current computation (or `fromComputation` if given) depends on `dependency`.  The computation will be invalidated the next time `dependency` changes.
+     * If there is no current computation and `depend()` is called with no arguments, it does nothing and returns false.
+     * Returns true if the computation is a new dependent of `dependency` rather than an existing one.
+     */
+    depend(computation) {
+      if (!computation) {
+        if (!isActive()) {
+          return false;
+        }
+        computation = _currentComputation;
+      }
+      if (!this._dependents.has(computation)) {
+        this._dependents.add(computation);
+        computation.onInvalidate(() => {
+          this._dependents.delete(computation);
+        });
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Invalidate all dependent computations immediately and remove them as dependents.
+     */
+    changed() {
+      for (const dep of this._dependents) {
+        dep.invalidate();
+      }
+    }
+    /**
+     * True if this Dependency has one or more dependent Computations, which would be invalidated if this Dependency were to change.
+     */
+    hasDependents() {
+      return this._dependents.size !== 0;
+    }
+  }
+  Tracker2.Dependency = Dependency3;
+})(exports.Tracker || (exports.Tracker = {}));
+
+// src/core/reactive-base-state.ts
+var ReactiveBaseState = class {
+  constructor(initialValue, opts) {
+    this._dep = new exports.Tracker.Dependency();
+    this._isEqual = (a, b) => a == b;
+    this._value = initialValue;
+    if (opts?.isEqual) {
+      this._isEqual = opts.isEqual;
+    }
+  }
+  _addDepend(dep) {
+    if (exports.Tracker.isActive()) {
+      dep.depend();
+    }
+  }
+  hasDependents() {
+    return this._dep.hasDependents();
+  }
+  get value() {
+    this._addDepend(this._dep);
+    return this._value;
+  }
+  set value(newValue) {
+    if (!this._isEqual(this._value, newValue)) {
+      this._value = newValue;
+      this._dep.changed();
+    }
+  }
+};
+
+// src/utils/create-proxy.ts
+function createProxy(target, opts) {
+  let useProxy = "Proxy" in window;
+  if (process.env.NODE_ENV === "test") {
+    if (global.__ignoreProxy) {
+      useProxy = false;
+    }
+  }
+  if (useProxy) {
+    return new Proxy(target, opts);
+  }
+  const result = {};
+  for (const key in target) {
+    Object.defineProperty(result, key, {
+      enumerable: true,
+      get: opts.get ? () => opts.get(target, key) : void 0,
+      set: opts.set ? (newValue) => opts.set(target, key, newValue) : void 0
+    });
+  }
+  return result;
+}
+
+// src/core/reactive-state.ts
+var Dependency = exports.Tracker.Dependency;
+var ReactiveState = class extends ReactiveBaseState {
+  constructor() {
+    super(...arguments);
+    this._keyDeps = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this._ensureKey(key);
+    const oldValue = this._value[key];
+    if (!this._isEqual(oldValue, value)) {
+      this._value[key] = value;
+      this._keyDeps.get(key).changed();
+      return true;
+    }
+    return false;
+  }
+  get(key) {
+    this._ensureKey(key);
+    this._addDepend(this._keyDeps.get(key));
+    return this._value[key];
+  }
+  _ensureKey(key) {
+    if (!this._keyDeps.has(key)) {
+      this._keyDeps.set(key, new Dependency());
+    }
+  }
+  hasDependents() {
+    if (this._dep.hasDependents()) return true;
+    for (const dep of this._keyDeps.values()) {
+      if (dep.hasDependents()) return true;
+    }
+    return false;
+  }
+  keys() {
+    return Object.keys(this._value);
+  }
+  set value(newValue) {
+    if (!this._isEqual(this._value, newValue)) {
+      this._value = newValue;
+      this._keyDeps.clear();
+      this._dep.changed();
+    }
+  }
+  get value() {
+    this._addDepend(this._dep);
+    if (!this._proxyValue) {
+      this._proxyValue = createProxy(this._value, {
+        get: (target, key) => this.get(key),
+        set: (target, key, newValue) => {
+          this.set(key, newValue);
+          return true;
+        }
+      });
+    }
+    return this._proxyValue;
+  }
+  get readonlyValue() {
+    this._addDepend(this._dep);
+    if (!this._proxyReadonlyValue) {
+      this._proxyReadonlyValue = createProxy(this._value, {
+        get: (target, key) => this.get(key),
+        set: (newValue, key) => {
+          throw new Error(`[ReactiveState] Cannnot set readonly field "${key}"`);
+        }
+      });
+    }
+    return this._proxyReadonlyValue;
+  }
+};
+function useObserve(value) {
+  const instance = vue.getCurrentInstance();
+  const tick = vue.shallowRef(0);
+  const computationMap = /* @__PURE__ */ new Map();
+  const refresh = () => {
+    tick.value += 1;
+    instance?.update();
+  };
+  const clear = () => {
+    computationMap.forEach((comp) => comp.stop());
+    computationMap.clear();
+  };
+  vue.onBeforeUpdate(clear);
+  vue.onBeforeUnmount(clear);
+  if (value === void 0) return {};
+  return createProxy(value, {
+    get(_target, key) {
+      void tick.value;
+      let computation = computationMap.get(key);
+      if (!computation) {
+        computation = new exports.Tracker.Computation((c) => {
+          if (!c.firstRun) {
+            refresh();
+            return;
+          }
+          return value[key];
+        });
+        computationMap.set(key, computation);
+      }
+      return value[key];
+    }
+  });
+}
+
+// src/hooks/use-reactive-state.ts
+function useReactiveState(v) {
+  const state = v instanceof ReactiveState ? v : new ReactiveState(v);
+  return useObserve(state.value);
+}
+
+// src/hooks/use-readonly-reactive-state.ts
+function useReadonlyReactiveState(state) {
+  return useObserve(state.readonlyValue);
+}
+function observe(fc) {
+  return vue.defineComponent({
+    name: "ReactiveObserver",
+    inheritAttrs: false,
+    setup(_, { attrs, slots }) {
+      const instance = vue.getCurrentInstance();
+      const tick = vue.shallowRef(0);
+      const childrenRef = { current: null };
+      const computationRef = { current: void 0 };
+      const refresh = () => {
+        tick.value += 1;
+        instance?.update();
+      };
+      vue.onBeforeUnmount(() => {
+        computationRef.current?.stop();
+      });
+      return () => {
+        void tick.value;
+        computationRef.current?.stop();
+        const slotChildren = slots.default?.();
+        const childrenFromSlot = slotChildren && slotChildren.length === 1 ? slotChildren[0] : slotChildren;
+        const props = {
+          ...attrs,
+          children: childrenFromSlot ?? attrs.children
+        };
+        computationRef.current = new exports.Tracker.Computation((c) => {
+          if (c.firstRun) {
+            childrenRef.current = fc(props);
+          } else {
+            refresh();
+          }
+        });
+        return childrenRef.current ?? null;
+      };
+    }
+  });
+}
+
+// src/index.ts
+var { Dependency: Dependency2, Computation } = exports.Tracker;
+
+exports.Computation = Computation;
+exports.Dependency = Dependency2;
+exports.ReactiveBaseState = ReactiveBaseState;
+exports.ReactiveState = ReactiveState;
+exports.observe = observe;
+exports.useObserve = useObserve;
+exports.useReactiveState = useReactiveState;
+exports.useReadonlyReactiveState = useReadonlyReactiveState;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/tracker.ts","../src/core/reactive-base-state.ts","../src/utils/create-proxy.ts","../src/core/reactive-state.ts","../src/hooks/use-observe.ts","../src/hooks/use-reactive-state.ts","../src/hooks/use-readonly-reactive-state.ts","../src/vue/observe.ts","../src/index.ts"],"names":["Tracker","Computation","Dependency","getCurrentInstance","shallowRef","onBeforeUpdate","onBeforeUnmount","defineComponent"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\n/**\n * Fork from: https://github.com/meteor/meteor/blob/devel/packages/tracker/tracker.js\n */\ntype ICallback<ARG = void, RET = void> = (arg: ARG) => RET;\n\n/**\n * Tracker 是一套 响应式依赖追踪 库，来源于 Meteor.Tracker\n * https://docs.meteor.com/api/Tracker.html#tracker-autorun-and-async-callbacks\n * https://github.com/meteor/meteor/blob/devel/packages/tracker/tracker.js\n *\n * 相关论文：https://dl.acm.org/doi/fullHtml/10.1145/3184558.3185978\n */\nexport namespace Tracker {\n  const _pendingComputations: Computation[] = [];\n  const _afterFlushCallbacks: ICallback[] = [];\n  // `true` if a Tracker.flush is scheduled, or if we are in Tracker.flush now\n  let _willFlush = false;\n  // `true` if we are in Tracker.flush now\n  let _inFlush = false;\n  // `true` if we are computing a computation now, either first time\n  // or recompute.  This matches Tracker.active unless we are inside\n  // Tracker.nonreactive, which nullfies currentComputation even though\n  // an enclosing computation may still be running.\n  let _inCompute = false;\n  let _currentComputation: Computation | undefined = undefined;\n  // `true` if the `_throwFirstError` option was passed in to the call\n  // to Tracker.flush that we are in. When set, throw rather than log the\n  // first error encountered while flushing. Before throwing the error,\n  // finish flushing (from a finally block), logging any subsequent\n  // errors.\n  let _throwFirstError = false;\n\n  export interface FlushOptions {\n    finishSynchronously?: boolean;\n    throwFirstError?: boolean;\n  }\n\n  function _throwOrLog(msg: string, e: any) {\n    if (_throwFirstError) {\n      throw e;\n    } else {\n      console.error(`[Tracker error] ${msg}`, e);\n    }\n  }\n\n  // Run all pending computations and afterFlush callbacks.  If we were not called\n  // directly via Tracker.flush, this may return before they're all done to allow\n  // the event loop to run a little before continuing.\n  function _runFlush(options?: FlushOptions) {\n    // Nested flush could plausibly happen if, say, a flush causes\n    // DOM mutation, which causes a \"blur\" event, which runs an\n    // app event handler that calls Tracker.flush.  At the moment\n    // Spark blocks event handlers during DOM mutation anyway,\n    // because the LiveRange tree isn't valid.  And we don't have\n    // any useful notion of a nested flush.\n    if (inFlush()) throw new Error(\"Can't call Tracker.flush while flushing\");\n\n    if (_inCompute) throw new Error(\"Can't flush inside Tracker.autorun\");\n\n    options = options || {};\n\n    _inFlush = true;\n    _willFlush = true;\n    _throwFirstError = !!options.throwFirstError;\n\n    var recomputedCount = 0;\n    var finishedTry = false;\n    try {\n      while (_pendingComputations.length || _afterFlushCallbacks.length) {\n        // recompute all pending computations\n        while (_pendingComputations.length) {\n          var comp = _pendingComputations.shift()!;\n          comp._recompute();\n          if (comp._needsRecompute()) {\n            _pendingComputations.unshift(comp);\n          }\n\n          if (!options.finishSynchronously && ++recomputedCount > 100) {\n            finishedTry = true;\n            return;\n          }\n        }\n\n        if (_afterFlushCallbacks.length) {\n          // call one afterFlush callback, which may\n          // invalidate more computations\n          var func = _afterFlushCallbacks.shift()!;\n          try {\n            func();\n          } catch (e: any) {\n            _throwOrLog('afterFlush', e);\n          }\n        }\n      }\n      finishedTry = true;\n    } finally {\n      if (!finishedTry) {\n        // we're erroring due to throwFirstError being true.\n        _inFlush = false; // needed before calling `Tracker.flush()` again\n        // finish flushing\n        _runFlush({\n          finishSynchronously: options.finishSynchronously,\n          throwFirstError: false,\n        });\n      }\n      _willFlush = false;\n      _inFlush = false;\n      if (_pendingComputations.length || _afterFlushCallbacks.length) {\n        // We're yielding because we ran a bunch of computations and we aren't\n        // required to finish synchronously, so we'd like to give the event loop a\n        // chance. We should flush again soon.\n        if (options.finishSynchronously) {\n          throw new Error('still have more to do?'); // shouldn't happen\n        }\n        setTimeout(_requireFlush, 10);\n      }\n    }\n  }\n\n  function _requireFlush() {\n    if (!_willFlush) {\n      setTimeout(_runFlush, 0);\n      _willFlush = true;\n    }\n  }\n\n  /******************************** Tracker Base API ******************************************/\n\n  /**\n   * 函数在响应式模块中执行\n   * @param computation\n   * @param f\n   */\n  export function withComputation<T = any>(\n    computation: Computation,\n    f: ICallback<Computation, T>,\n  ): T {\n    let previousComputation = _currentComputation;\n    _currentComputation = computation;\n    try {\n      return f.call(null, computation);\n    } finally {\n      _currentComputation = previousComputation;\n    }\n  }\n\n  /**\n   * 函数在非响应式模块中执行\n   */\n  export function withoutComputation<T = any>(f: ICallback<undefined, T>): T {\n    let previousComputation = _currentComputation;\n    _currentComputation = undefined;\n    try {\n      return f(undefined);\n    } finally {\n      _currentComputation = previousComputation;\n    }\n  }\n\n  export function isActive(): boolean {\n    return !!_currentComputation;\n  }\n\n  export function getCurrentComputation(): Computation | undefined {\n    return _currentComputation;\n  }\n\n  /**\n   * Run a function now and rerun it later whenever its dependencies\n   * change. Returns a Computation object that can be used to stop or observe the\n   * rerunning.\n   */\n  export function autorun<T = any>(\n    f: IComputationCallback<T>,\n    options?: { onError: ICallback<Error> },\n  ): Computation<T> {\n    var c = new Computation<T>(f, _currentComputation, options?.onError);\n\n    if (isActive())\n      Tracker.onInvalidate(function () {\n        c.stop();\n      });\n\n    return c;\n  }\n\n  export function onInvalidate(f: ICallback<Computation | undefined>) {\n    if (!_currentComputation) {\n      throw new Error('Tracker.onInvalidate requires a currentComputation');\n    }\n    _currentComputation.onInvalidate(f);\n  }\n\n  /**\n   * True if we are computing a computation now, either first time or recompute.  This matches Tracker.active unless we are inside Tracker.nonreactive, which nullfies currentComputation even though an enclosing computation may still be running.\n   */\n  export function inFlush(): boolean {\n    return _inFlush;\n  }\n\n  /**\n   * Process all reactive updates immediately and ensure that all invalidated computations are rerun.\n   */\n  export function flush(options?: Omit<FlushOptions, 'finishSynchronously'>) {\n    _runFlush({\n      finishSynchronously: true,\n      throwFirstError: options && options.throwFirstError,\n    });\n  }\n\n  /**\n   * Schedules a function to be called during the next flush, or later in the current flush if one is in progress, after all invalidated computations have been rerun.  The function will be run once and not on subsequent flushes unless `afterFlush` is called again.\n   */\n  export function afterFlush(f: ICallback) {\n    _afterFlushCallbacks.push(f);\n    _requireFlush();\n  }\n\n  /********************************************************************************************/\n\n  export type IComputationCallback<V = any> = ICallback<Computation, V>;\n\n  /**\n   * A Computation object represents code that is repeatedly rerun\n   * in response to\n   * reactive data changes. Computations don't have return values; they just\n   * perform actions, such as rerendering a template on the screen. Computations\n   * are created using Tracker.autorun. Use stop to prevent further rerunning of a\n   * computation.\n   */\n  export class Computation<V = any> {\n    private _onInvalidateCallbacks: IComputationCallback[] = [];\n\n    private _onStopCallbacks: IComputationCallback[] = [];\n\n    private _recomputing = false;\n\n    private _result: V;\n\n    /**\n     * 是否停止\n     */\n    public stopped = false;\n\n    /**\n     * 未开始执行则返回 false\n     */\n    public invalidated = false;\n\n    /**\n     * 是否第一次执行\n     */\n    public firstRun = true;\n\n    constructor(\n      private _fn: IComputationCallback<V>,\n      public readonly parent?: Computation,\n      private readonly _onError?: ICallback<Error>,\n    ) {\n      let hasError = true;\n      try {\n        this._compute();\n        hasError = false;\n      } finally {\n        this.firstRun = false;\n        if (hasError) {\n          this.stop();\n        }\n      }\n    }\n\n    onInvalidate(f: IComputationCallback): void {\n      if (this.invalidated) {\n        withoutComputation(f.bind(null, this));\n      } else {\n        this._onInvalidateCallbacks.push(f);\n      }\n    }\n\n    /**\n     * @summary Invalidates this computation so that it will be rerun.\n     */\n    invalidate() {\n      if (!this.invalidated) {\n        // if we're currently in _recompute(), don't enqueue\n        // ourselves, since we'll rerun immediately anyway.\n        if (!this._recomputing && !this.stopped) {\n          _requireFlush();\n          _pendingComputations.push(this);\n        }\n\n        this.invalidated = true;\n\n        // callbacks can't add callbacks, because\n        // this.invalidated === true.\n        for (var i = 0, f: IComputationCallback; (f = this._onInvalidateCallbacks[i]); i++) {\n          withoutComputation(f.bind(null, this));\n        }\n        this._onInvalidateCallbacks = [];\n      }\n    }\n\n    /**\n     * @summary Prevents this computation from rerunning.\n     * @locus Client\n     */\n    stop() {\n      if (!this.stopped) {\n        this.stopped = true;\n        this.invalidate();\n        for (let i = 0, f: IComputationCallback; (f = this._onStopCallbacks[i]); i++) {\n          withoutComputation(f.bind(null, this));\n        }\n        this._onStopCallbacks = [];\n      }\n    }\n\n    onStop(f: IComputationCallback): void {\n      if (this.stopped) {\n        withoutComputation(f.bind(null, this));\n      } else {\n        this._onStopCallbacks.push(f);\n      }\n    }\n\n    private _compute(): void {\n      this.invalidated = false;\n\n      var previousInCompute = _inCompute;\n      _inCompute = true;\n      try {\n        this._result = Tracker.withComputation<V>(this, this._fn);\n      } finally {\n        _inCompute = previousInCompute;\n      }\n    }\n\n    _needsRecompute() {\n      return this.invalidated && !this.stopped;\n    }\n\n    _recompute() {\n      this._recomputing = true;\n      try {\n        if (this._needsRecompute()) {\n          try {\n            this._compute();\n          } catch (e: any) {\n            if (this._onError) {\n              this._onError(e);\n            } else {\n              _throwOrLog('recompute', e);\n            }\n          }\n        }\n      } finally {\n        this._recomputing = false;\n      }\n    }\n\n    /**\n     * @summary Process the reactive updates for this computation immediately\n     * and ensure that the computation is rerun. The computation is rerun only\n     * if it is invalidated.\n     */\n    flush() {\n      if (this._recomputing) return;\n\n      this._recompute();\n    }\n\n    /**\n     * @summary Causes the function inside this computation to run and\n     * synchronously process all reactive updtes.\n     * @locus Client\n     */\n    run() {\n      this.invalidate();\n      this.flush();\n    }\n\n    get result(): V {\n      return this._result;\n    }\n  }\n\n  /**\n   * A Dependency represents an atomic unit of reactive data that a\n   * computation might depend on. Reactive data sources such as Session or\n   * Minimongo internally create different Dependency objects for different\n   * pieces of data, each of which may be depended on by multiple computations.\n   * When the data changes, the computations are invalidated.\n   */\n  export class Dependency {\n    private _dependents: Set<Computation> = new Set<Computation>();\n\n    /**\n     * Declares that the current computation (or `fromComputation` if given) depends on `dependency`.  The computation will be invalidated the next time `dependency` changes.\n     * If there is no current computation and `depend()` is called with no arguments, it does nothing and returns false.\n     * Returns true if the computation is a new dependent of `dependency` rather than an existing one.\n     */\n    depend(computation?: Computation): boolean {\n      if (!computation) {\n        if (!isActive()) {\n          return false;\n        }\n        computation = _currentComputation;\n      }\n      if (!this._dependents.has(computation!)) {\n        this._dependents.add(computation!);\n        computation!.onInvalidate(() => {\n          this._dependents.delete(computation!);\n        });\n        return true;\n      }\n      return false;\n    }\n\n    /**\n     * Invalidate all dependent computations immediately and remove them as dependents.\n     */\n    changed() {\n      for (const dep of this._dependents) {\n        dep.invalidate();\n      }\n    }\n\n    /**\n     * True if this Dependency has one or more dependent Computations, which would be invalidated if this Dependency were to change.\n     */\n    hasDependents() {\n      return this._dependents.size !== 0;\n    }\n  }\n}\n","/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\nimport { Tracker } from './tracker';\n\ntype IStateEqual = (a: any, b: any) => boolean;\n\nexport class ReactiveBaseState<V> {\n  protected _dep = new Tracker.Dependency();\n\n  protected _value: V;\n\n  protected _isEqual: IStateEqual = (a: any, b: any) => a == b;\n\n  protected _addDepend(dep: Tracker.Dependency): void {\n    if (Tracker.isActive()) {\n      dep.depend();\n    }\n  }\n\n  constructor(initialValue: V, opts?: { isEqual?: IStateEqual }) {\n    this._value = initialValue;\n    if (opts?.isEqual) {\n      this._isEqual = opts.isEqual;\n    }\n  }\n\n  hasDependents(): boolean {\n    return this._dep.hasDependents();\n  }\n\n  get value(): V {\n    this._addDepend(this._dep);\n    return this._value;\n  }\n\n  set value(newValue: V) {\n    if (!this._isEqual(this._value, newValue)) {\n      this._value = newValue;\n      this._dep.changed();\n    }\n  }\n}\n","/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\ninterface ProxyOptions<V> {\n  get?: (target: V, key: string) => any;\n  set?: (target: V, key: string, newValue: any) => boolean;\n}\n\nexport function createProxy<V extends Record<string, any>>(target: V, opts: ProxyOptions<V>): V {\n  let useProxy = 'Proxy' in window;\n  if (process.env.NODE_ENV === 'test') {\n    if ((global as any).__ignoreProxy) {\n      useProxy = false;\n    }\n  }\n  if (useProxy) {\n    return new Proxy<V>(target, opts);\n  }\n  const result: V = {} as V;\n  for (const key in target) {\n    Object.defineProperty(result, key, {\n      enumerable: true,\n      get: opts.get ? () => opts.get!(target, key) : undefined,\n      set: opts.set ? (newValue: any) => opts.set!(target, key, newValue) : undefined,\n    });\n  }\n  return result;\n}\n","/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\nimport { Tracker } from './tracker';\n\nimport Dependency = Tracker.Dependency;\n\nimport { ReactiveBaseState } from './reactive-base-state';\nimport { createProxy } from '../utils/create-proxy';\n\nexport class ReactiveState<V extends Record<string, any>> extends ReactiveBaseState<V> {\n  private _keyDeps: Map<string, Dependency> = new Map();\n\n  set<K extends keyof V & string>(key: K, value: V[K]): boolean {\n    this._ensureKey(key);\n    const oldValue = this._value[key];\n    if (!this._isEqual(oldValue, value)) {\n      this._value[key] = value;\n      this._keyDeps.get(key)!.changed();\n      return true;\n    }\n    return false;\n  }\n\n  get<K extends keyof V & string>(key: K): V[K] {\n    this._ensureKey(key);\n    this._addDepend(this._keyDeps.get(key)!);\n    return this._value[key];\n  }\n\n  protected _ensureKey(key: keyof V & string) {\n    if (!this._keyDeps.has(key)) {\n      this._keyDeps.set(key, new Dependency());\n    }\n  }\n\n  hasDependents(): boolean {\n    if (this._dep.hasDependents()) return true;\n    for (const dep of this._keyDeps.values()) {\n      if (dep.hasDependents()) return true;\n    }\n    return false;\n  }\n\n  keys(): string[] {\n    return Object.keys(this._value);\n  }\n\n  set value(newValue: V) {\n    if (!this._isEqual(this._value, newValue)) {\n      this._value = newValue;\n      this._keyDeps.clear();\n      this._dep.changed();\n    }\n  }\n\n  private _proxyValue: V;\n\n  get value(): V {\n    this._addDepend(this._dep);\n    if (!this._proxyValue) {\n      this._proxyValue = createProxy<V>(this._value, {\n        get: (target, key: string) => this.get(key),\n        set: (target, key: string, newValue) => {\n          this.set(key, newValue);\n          return true;\n        },\n      });\n    }\n    return this._proxyValue;\n  }\n\n  private _proxyReadonlyValue: V;\n\n  get readonlyValue(): Readonly<V> {\n    this._addDepend(this._dep);\n    if (!this._proxyReadonlyValue) {\n      this._proxyReadonlyValue = createProxy(this._value, {\n        get: (target, key: string) => this.get(key),\n        set: (newValue, key: string) => {\n          throw new Error(`[ReactiveState] Cannnot set readonly field \"${key}\"`);\n        },\n      });\n    }\n    return this._proxyReadonlyValue;\n  }\n}\n","/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\nimport { getCurrentInstance, onBeforeUnmount, onBeforeUpdate, shallowRef } from 'vue';\n\nimport { createProxy } from '../utils/create-proxy';\nimport { Tracker } from '../core/tracker';\n\nimport Computation = Tracker.Computation;\n\nexport function useObserve<T extends Record<string, any>>(value: T | undefined): T {\n  const instance = getCurrentInstance();\n  const tick = shallowRef(0);\n  const computationMap = new Map<string, Computation>();\n  const refresh = () => {\n    tick.value += 1;\n    instance?.update();\n  };\n  const clear = () => {\n    computationMap.forEach((comp) => comp.stop());\n    computationMap.clear();\n  };\n  onBeforeUpdate(clear);\n  onBeforeUnmount(clear);\n  if (value === undefined) return {} as T;\n  return createProxy(value, {\n    get(_target, key: string) {\n      void tick.value;\n      let computation = computationMap.get(key);\n      if (!computation) {\n        computation = new Tracker.Computation((c) => {\n          if (!c.firstRun) {\n            refresh();\n            return;\n          }\n          return value[key];\n        });\n        computationMap.set(key, computation);\n      }\n      return value[key];\n    },\n  });\n}\n","/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\nimport { ReactiveState } from '../core/reactive-state';\nimport { useObserve } from './use-observe';\n\nexport function useReactiveState<T extends Record<string, any>>(v: ReactiveState<T> | T): T {\n  const state = v instanceof ReactiveState ? v : new ReactiveState(v);\n  return useObserve<T>(state.value);\n}\n","/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\nimport { ReactiveState } from '../core/reactive-state';\nimport { useObserve } from './use-observe';\n\nexport function useReadonlyReactiveState<T extends Record<string, any>>(\n  state: ReactiveState<T>,\n): Readonly<T> {\n  return useObserve<T>(state.readonlyValue);\n}\n","/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\nimport {\n  defineComponent,\n  getCurrentInstance,\n  onBeforeUnmount,\n  shallowRef,\n  type Component,\n  type VNode,\n} from 'vue';\n\nimport { Tracker } from '../core/tracker';\n\nimport Computation = Tracker.Computation;\n\nexport function observe<T = any>(fc: (props: T) => VNode | null | undefined): Component {\n  return defineComponent({\n    name: 'ReactiveObserver',\n    inheritAttrs: false,\n    setup(_, { attrs, slots }) {\n      const instance = getCurrentInstance();\n      const tick = shallowRef(0);\n      const childrenRef: { current: VNode | null | undefined } = { current: null };\n      const computationRef: { current: Computation | undefined } = { current: undefined };\n      const refresh = () => {\n        tick.value += 1;\n        instance?.update();\n      };\n\n      onBeforeUnmount(() => {\n        computationRef.current?.stop();\n      });\n\n      return () => {\n        void tick.value;\n        computationRef.current?.stop();\n        const slotChildren = slots.default?.();\n        const childrenFromSlot =\n          slotChildren && slotChildren.length === 1 ? slotChildren[0] : slotChildren;\n        const props = {\n          ...attrs,\n          children: childrenFromSlot ?? (attrs as { children?: unknown }).children,\n        } as T;\n        computationRef.current = new Tracker.Computation((c) => {\n          if (c.firstRun) {\n            childrenRef.current = fc(props);\n          } else {\n            refresh();\n          }\n        });\n        return childrenRef.current ?? null;\n      };\n    },\n  });\n}\n","/**\n * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n */\n\nimport { Tracker } from './core/tracker';\n\nexport { Tracker } from './core/tracker';\nexport { ReactiveState } from './core/reactive-state';\nexport { ReactiveBaseState } from './core/reactive-base-state';\nexport { useReactiveState } from './hooks/use-reactive-state';\nexport { useReadonlyReactiveState } from './hooks/use-readonly-reactive-state';\nexport { useObserve } from './hooks/use-observe';\nexport { observe } from './vue/observe';\nexport const { Dependency, Computation } = Tracker;\n"]}