wevu 7.0.3 → 7.1.0

package/dist/dev/reactivity/core.mjs

@@ -1,26 +1,86 @@
 import { queueJob } from "../scheduler.mjs";
-import _defineProperty from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/defineProperty.mjs";
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/defineProperty.mjs";
 
 //#region src/reactivity/core.ts
 const targetMap = /* @__PURE__ */ new WeakMap();
 let activeEffect = null;
 const effectStack = [];
+let shouldTrack = true;
+let activeEffectScope;
 let batchDepth = 0;
+let isFlushingBatch = false;
 const batchedEffects = /* @__PURE__ */ new Set();
+const batchedCallbacks = /* @__PURE__ */ new Set();
+function runScheduledEffect(ef) {
+	if (!ef.active) return;
+	if (ef.scheduler) {
+		const previousScope = activeEffectScope;
+		activeEffectScope = ef._scope;
+		try {
+			ef.scheduler();
+		} finally {
+			activeEffectScope = previousScope;
+		}
+		return;
+	}
+	ef();
+}
+/** 在当前批次的同步副作用全部完成后执行包内通知。 */
+function queueBatchCallback(callback) {
+	if (batchDepth > 0 || isFlushingBatch) {
+		batchedCallbacks.add(callback);
+		return;
+	}
+	batchedCallbacks.delete(callback);
+	callback();
+}
 function startBatch() {
 	batchDepth++;
 }
+function takeBatchedEffect(effects) {
+	const next = effects.values().next();
+	if (next.done) return;
+	effects.delete(next.value);
+	return next.value;
+}
 function flushBatchedEffects() {
-	while (batchedEffects.size) {
-		const effects = [...batchedEffects];
-		batchedEffects.clear();
-		for (const ef of effects) ef();
+	let firstError;
+	let hasError = false;
+	isFlushingBatch = true;
+	try {
+		while (batchedEffects.size) {
+			const effect = takeBatchedEffect(batchedEffects);
+			if (!effect) continue;
+			try {
+				runScheduledEffect(effect);
+			} catch (error) {
+				if (!hasError) {
+					firstError = error;
+					hasError = true;
+				}
+			}
+		}
+	} finally {
+		isFlushingBatch = false;
+	}
+	while (batchedCallbacks.size) {
+		const callback = batchedCallbacks.values().next().value;
+		batchedCallbacks.delete(callback);
+		try {
+			callback();
+		} catch (error) {
+			if (!hasError) {
+				firstError = error;
+				hasError = true;
+			}
+		}
 	}
+	if (hasError) throw firstError;
 }
 function endBatch() {
 	if (batchDepth === 0) return;
 	batchDepth--;
-	if (batchDepth === 0) flushBatchedEffects();
+	if (batchDepth === 0 && !isFlushingBatch) flushBatchedEffects();
 }
 function batch(fn) {
 	startBatch();
@@ -42,7 +102,6 @@ function stop(runner) {
 	cleanupEffect(runner);
 	(_runner$onStop = runner.onStop) === null || _runner$onStop === void 0 || _runner$onStop.call(runner);
 }
-let activeEffectScope;
 var EffectScopeImpl = class {
 	constructor(detached = false) {
 		this.detached = detached;
@@ -53,6 +112,10 @@ var EffectScopeImpl = class {
 		_defineProperty(this, "scopes", void 0);
 		if (!detached && activeEffectScope) {
 			var _activeEffectScope;
+			if (!activeEffectScope.active) {
+				this.active = false;
+				return;
+			}
 			this.parent = activeEffectScope;
 			((_activeEffectScope = activeEffectScope).scopes || (_activeEffectScope.scopes = [])).push(this);
 		}
@@ -68,22 +131,50 @@ var EffectScopeImpl = class {
 		}
 	}
 	stop() {
-		var _this$parent;
 		if (!this.active) return;
 		this.active = false;
-		for (const effect of this.effects) stop(effect);
-		this.effects.length = 0;
-		for (const cleanup of this.cleanups) cleanup();
-		this.cleanups.length = 0;
-		if (this.scopes) {
-			for (const scope of this.scopes) scope.stop();
-			this.scopes.length = 0;
-		}
-		if ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.scopes) {
-			const index = this.parent.scopes.indexOf(this);
-			if (index >= 0) this.parent.scopes.splice(index, 1);
+		const prev = activeEffectScope;
+		activeEffectScope = this;
+		let firstError;
+		let hasError = false;
+		const recordError = (error) => {
+			if (hasError) return;
+			firstError = error;
+			hasError = true;
+		};
+		try {
+			const effects = this.effects.splice(0);
+			for (const effect of effects) try {
+				stop(effect);
+			} catch (error) {
+				recordError(error);
+			}
+			const cleanups = this.cleanups.splice(0);
+			for (const cleanup of cleanups) try {
+				cleanup();
+			} catch (error) {
+				recordError(error);
+			}
+			const scopes = this.scopes;
+			this.scopes = void 0;
+			if (scopes) {
+				for (const scope of scopes) try {
+					scope.stop();
+				} catch (error) {
+					recordError(error);
+				}
+				scopes.length = 0;
+			}
+		} finally {
+			var _this$parent;
+			if ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.scopes) {
+				const index = this.parent.scopes.indexOf(this);
+				if (index >= 0) this.parent.scopes.splice(index, 1);
+			}
+			this.parent = void 0;
+			activeEffectScope = prev;
 		}
-		this.parent = void 0;
+		if (hasError) throw firstError;
 	}
 };
 function effectScope(detached = false) {
@@ -95,15 +186,37 @@ function getCurrentScope() {
 function onScopeDispose(fn) {
 	if (activeEffectScope === null || activeEffectScope === void 0 ? void 0 : activeEffectScope.active) activeEffectScope.cleanups.push(fn);
 }
+/**
+* 在不把读取记录到当前副作用的情况下执行函数。
+* 函数内部主动运行的新副作用仍会正常收集自己的依赖。
+*/
+function runWithoutTracking(fn) {
+	const previousShouldTrack = shouldTrack;
+	shouldTrack = false;
+	try {
+		return fn();
+	} finally {
+		shouldTrack = previousShouldTrack;
+	}
+}
 function recordEffectScope(effect) {
-	if (activeEffectScope === null || activeEffectScope === void 0 ? void 0 : activeEffectScope.active) activeEffectScope.effects.push(effect);
+	if (!activeEffectScope) return;
+	if (activeEffectScope.active) {
+		activeEffectScope.effects.push(effect);
+		return;
+	}
+	stop(effect);
 }
 function createReactiveEffect(fn, options = {}) {
 	const effect = function reactiveEffect() {
 		if (!effect.active) return fn();
 		if (effect._running) return fn();
 		cleanupEffect(effect);
+		const previousScope = activeEffectScope;
+		activeEffectScope = effect._scope;
+		const previousShouldTrack = shouldTrack;
 		try {
+			shouldTrack = true;
 			effect._running = true;
 			effectStack.push(effect);
 			activeEffect = effect;
@@ -113,6 +226,8 @@ function createReactiveEffect(fn, options = {}) {
 			effectStack.pop();
 			activeEffect = (_effectStack = effectStack[effectStack.length - 1]) !== null && _effectStack !== void 0 ? _effectStack : null;
 			effect._running = false;
+			activeEffectScope = previousScope;
+			shouldTrack = previousShouldTrack;
 		}
 	};
 	effect.deps = [];
@@ -121,16 +236,24 @@ function createReactiveEffect(fn, options = {}) {
 	effect.active = true;
 	effect._running = false;
 	effect._fn = fn;
+	effect._scope = activeEffectScope;
 	return effect;
 }
+function createEffect(fn, options, computed) {
+	const runner = createReactiveEffect(fn, options);
+	runner._computed = computed;
+	recordEffectScope(runner);
+	if (!options.lazy) runner();
+	return runner;
+}
 function effect(fn, options = {}) {
-	const _effect = createReactiveEffect(fn, options);
-	recordEffectScope(_effect);
-	if (!options.lazy) _effect();
-	return _effect;
+	return createEffect(fn, options, false);
+}
+function createComputedEffect(fn, options = {}) {
+	return createEffect(fn, options, true);
 }
 function track(target, key) {
-	if (!activeEffect) return;
+	if (!shouldTrack || !activeEffect) return;
 	let depsMap = targetMap.get(target);
 	if (!depsMap) {
 		depsMap = /* @__PURE__ */ new Map();
@@ -147,15 +270,16 @@ function track(target, key) {
 	}
 }
 function scheduleEffect(ef) {
-	if (ef.scheduler) {
-		ef.scheduler();
+	if (ef._running) return;
+	if (ef._computed) {
+		runScheduledEffect(ef);
 		return;
 	}
-	if (batchDepth > 0) {
+	if (batchDepth > 0 || isFlushingBatch) {
 		batchedEffects.add(ef);
 		return;
 	}
-	ef();
+	runScheduledEffect(ef);
 }
 function trigger(target, key) {
 	const depsMap = targetMap.get(target);
@@ -169,7 +293,7 @@ function trigger(target, key) {
 	effectsToRun.forEach(scheduleEffect);
 }
 function trackEffects(dep) {
-	if (!activeEffect) return;
+	if (!shouldTrack || !activeEffect) return;
 	if (!dep.has(activeEffect)) {
 		dep.add(activeEffect);
 		activeEffect.deps.push(dep);
@@ -180,5 +304,5 @@ function triggerEffects(dep) {
 }
 
 //#endregion
-export { batch, createReactiveEffect, effect, effectScope, endBatch, getCurrentScope, onScopeDispose, queueJob, startBatch, stop, track, trackEffects, trigger, triggerEffects };
+export { batch, createComputedEffect, createReactiveEffect, effect, effectScope, endBatch, getCurrentScope, onScopeDispose, queueBatchCallback, queueJob, runWithoutTracking, startBatch, stop, track, trackEffects, trigger, triggerEffects };
 //# sourceMappingURL=core.mjs.map

package/dist/dev/reactivity/core.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"core.mjs","names":[],"sources":["../../../src/reactivity/core.ts"],"sourcesContent":["import { queueJob } from '../scheduler'\n\nexport type EffectScheduler = () => void\n\nexport type Dep = Set<ReactiveEffect>\n\nexport interface ReactiveEffect<T = any> {\n  (): T\n  deps: Dep[]\n  scheduler?: EffectScheduler\n  active: boolean\n  _running: boolean\n  _fn: () => T\n  onStop?: () => void\n}\n\nconst targetMap = new WeakMap<object, Map<PropertyKey, Dep>>()\n\nlet activeEffect: ReactiveEffect | null = null\nconst effectStack: ReactiveEffect[] = []\n\nlet batchDepth = 0\nconst batchedEffects = new Set<ReactiveEffect>()\n\nexport function startBatch() {\n  batchDepth++\n}\n\nfunction flushBatchedEffects() {\n  while (batchedEffects.size) {\n    const effects = [...batchedEffects]\n    batchedEffects.clear()\n    for (const ef of effects) {\n      ef()\n    }\n  }\n}\n\nexport function endBatch() {\n  if (batchDepth === 0) {\n    return\n  }\n  batchDepth--\n  if (batchDepth === 0) {\n    flushBatchedEffects()\n  }\n}\n\nexport function batch<T>(fn: () => T): T {\n  startBatch()\n  try {\n    return fn()\n  }\n  finally {\n    endBatch()\n  }\n}\n\nfunction cleanupEffect(effect: ReactiveEffect) {\n  const { deps } = effect\n  for (let i = 0; i < deps.length; i++) {\n    deps[i].delete(effect)\n  }\n  deps.length = 0\n}\n\nexport function stop(runner: ReactiveEffect) {\n  if (!runner.active) {\n    return\n  }\n  runner.active = false\n  cleanupEffect(runner)\n  runner.onStop?.()\n}\n\nexport interface EffectScope {\n  active: boolean\n  effects: ReactiveEffect[]\n  cleanups: (() => void)[]\n  run: <T>(fn: () => T) => T | undefined\n  stop: () => void\n}\n\nlet activeEffectScope: EffectScopeImpl | undefined\n\nclass EffectScopeImpl implements EffectScope {\n  active = true\n  effects: ReactiveEffect[] = []\n  cleanups: (() => void)[] = []\n  private parent: EffectScopeImpl | undefined\n  private scopes: EffectScopeImpl[] | undefined\n\n  constructor(private detached = false) {\n    if (!detached && activeEffectScope) {\n      this.parent = activeEffectScope\n      ;(activeEffectScope.scopes ||= []).push(this)\n    }\n  }\n\n  run<T>(fn: () => T): T | undefined {\n    if (!this.active) {\n      return\n    }\n    const prev = activeEffectScope\n    // eslint-disable-next-line ts/no-this-alias -- 允许 this 临时别名\n    activeEffectScope = this\n    try {\n      return fn()\n    }\n    finally {\n      activeEffectScope = prev\n    }\n  }\n\n  stop(): void {\n    if (!this.active) {\n      return\n    }\n    this.active = false\n\n    for (const effect of this.effects) {\n      stop(effect)\n    }\n    this.effects.length = 0\n\n    for (const cleanup of this.cleanups) {\n      cleanup()\n    }\n    this.cleanups.length = 0\n\n    if (this.scopes) {\n      for (const scope of this.scopes) {\n        scope.stop()\n      }\n      this.scopes.length = 0\n    }\n\n    if (this.parent?.scopes) {\n      const index = this.parent.scopes.indexOf(this)\n      if (index >= 0) {\n        this.parent.scopes.splice(index, 1)\n      }\n    }\n    this.parent = undefined\n  }\n}\n\nexport function effectScope(detached = false): EffectScope {\n  return new EffectScopeImpl(detached)\n}\n\nexport function getCurrentScope(): EffectScope | undefined {\n  return activeEffectScope\n}\n\nexport function onScopeDispose(fn: () => void): void {\n  if (activeEffectScope?.active) {\n    activeEffectScope.cleanups.push(fn)\n  }\n}\n\nfunction recordEffectScope(effect: ReactiveEffect) {\n  if (activeEffectScope?.active) {\n    activeEffectScope.effects.push(effect)\n  }\n}\n\nexport interface EffectOptions {\n  scheduler?: EffectScheduler\n  lazy?: boolean\n  onStop?: () => void\n}\n\nexport function createReactiveEffect<T>(fn: () => T, options: EffectOptions = {}): ReactiveEffect<T> {\n  const effect = function reactiveEffect() {\n    if (!effect.active) {\n      return fn()\n    }\n    if (effect._running) {\n      return fn()\n    }\n    cleanupEffect(effect)\n    try {\n      effect._running = true\n      effectStack.push(effect)\n      activeEffect = effect\n      return fn()\n    }\n    finally {\n      effectStack.pop()\n      activeEffect = effectStack[effectStack.length - 1] ?? null\n      effect._running = false\n    }\n  } as ReactiveEffect<T>\n\n  effect.deps = []\n  effect.scheduler = options.scheduler\n  effect.onStop = options.onStop\n  effect.active = true\n  effect._running = false\n  effect._fn = fn\n\n  return effect\n}\n\nexport function effect<T = any>(fn: () => T, options: EffectOptions = {}): ReactiveEffect<T> {\n  const _effect = createReactiveEffect(fn, options)\n  recordEffectScope(_effect)\n  if (!options.lazy) {\n    _effect()\n  }\n  return _effect\n}\n\nexport function track(target: object, key: PropertyKey) {\n  if (!activeEffect) {\n    return\n  }\n  let depsMap = targetMap.get(target)\n  if (!depsMap) {\n    depsMap = new Map()\n    targetMap.set(target, depsMap)\n  }\n  let dep = depsMap.get(key)\n  if (!dep) {\n    dep = new Set()\n    depsMap.set(key, dep)\n  }\n  if (!dep.has(activeEffect)) {\n    dep.add(activeEffect)\n    activeEffect.deps.push(dep)\n  }\n}\n\nfunction scheduleEffect(ef: ReactiveEffect) {\n  if (ef.scheduler) {\n    ef.scheduler()\n    return\n  }\n  if (batchDepth > 0) {\n    batchedEffects.add(ef)\n    return\n  }\n  ef()\n}\n\nexport function trigger(target: object, key: PropertyKey) {\n  const depsMap = targetMap.get(target)\n  if (!depsMap) {\n    return\n  }\n  const effects = depsMap.get(key)\n  if (!effects) {\n    return\n  }\n  const effectsToRun = new Set<ReactiveEffect>()\n  effects.forEach((ef) => {\n    if (ef !== activeEffect) {\n      effectsToRun.add(ef)\n    }\n  })\n  effectsToRun.forEach(scheduleEffect)\n}\n\nexport function trackEffects(dep: Dep) {\n  if (!activeEffect) {\n    return\n  }\n  if (!dep.has(activeEffect)) {\n    dep.add(activeEffect)\n    activeEffect.deps.push(dep)\n  }\n}\n\nexport function triggerEffects(dep: Dep) {\n  // 迭代时复制依赖集合，避免遍历过程中被重新加入导致死循环。\n  const effectsToRun = new Set(dep)\n  effectsToRun.forEach(scheduleEffect)\n}\n\n// 导出队列调度工具，供 watch/watchEffect 等高层 API 复用同一批处理逻辑\nexport { queueJob }\n"],"mappings":"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"}
+{"version":3,"file":"core.mjs","names":[],"sources":["../../../src/reactivity/core.ts"],"sourcesContent":["import { queueJob } from '../scheduler'\n\nexport type EffectScheduler = () => void\n\nexport type Dep = Set<ReactiveEffect>\n\nexport interface ReactiveEffect<T = any> {\n  (): T\n  deps: Dep[]\n  scheduler?: EffectScheduler\n  active: boolean\n  _running: boolean\n  _fn: () => T\n  _computed?: boolean\n  onStop?: () => void\n}\n\nconst targetMap = new WeakMap<object, Map<PropertyKey, Dep>>()\n\nlet activeEffect: ReactiveEffect | null = null\nconst effectStack: ReactiveEffect[] = []\nlet shouldTrack = true\nlet activeEffectScope: EffectScopeImpl | undefined\n\nlet batchDepth = 0\nlet isFlushingBatch = false\nconst batchedEffects = new Set<ReactiveEffect>()\nconst batchedCallbacks = new Set<() => void>()\n\nfunction runScheduledEffect(ef: ReactiveEffect) {\n  if (!ef.active) {\n    return\n  }\n  if (ef.scheduler) {\n    const previousScope = activeEffectScope\n    activeEffectScope = (ef as ScopedReactiveEffect)._scope\n    try {\n      ef.scheduler()\n    }\n    finally {\n      activeEffectScope = previousScope\n    }\n    return\n  }\n  ef()\n}\n\n/** 在当前批次的同步副作用全部完成后执行包内通知。 */\nexport function queueBatchCallback(callback: () => void) {\n  if (batchDepth > 0 || isFlushingBatch) {\n    batchedCallbacks.add(callback)\n    return\n  }\n  batchedCallbacks.delete(callback)\n  callback()\n}\n\nexport function startBatch() {\n  batchDepth++\n}\n\nfunction takeBatchedEffect(effects: Set<ReactiveEffect>): ReactiveEffect | undefined {\n  const next = effects.values().next()\n  if (next.done) {\n    return undefined\n  }\n  effects.delete(next.value)\n  return next.value\n}\n\nfunction flushBatchedEffects() {\n  let firstError: unknown\n  let hasError = false\n  isFlushingBatch = true\n  try {\n    while (batchedEffects.size) {\n      const effect = takeBatchedEffect(batchedEffects)\n      if (!effect) {\n        continue\n      }\n      try {\n        runScheduledEffect(effect)\n      }\n      catch (error) {\n        if (!hasError) {\n          firstError = error\n          hasError = true\n        }\n      }\n    }\n  }\n  finally {\n    isFlushingBatch = false\n  }\n  // 通知属于已完成批次之后的操作，保留订阅回调内同步变更的重入保护。\n  while (batchedCallbacks.size) {\n    const callback = batchedCallbacks.values().next().value!\n    batchedCallbacks.delete(callback)\n    try {\n      callback()\n    }\n    catch (error) {\n      if (!hasError) {\n        firstError = error\n        hasError = true\n      }\n    }\n  }\n  if (hasError) {\n    throw firstError\n  }\n}\n\nexport function endBatch() {\n  if (batchDepth === 0) {\n    return\n  }\n  batchDepth--\n  if (batchDepth === 0 && !isFlushingBatch) {\n    flushBatchedEffects()\n  }\n}\n\nexport function batch<T>(fn: () => T): T {\n  startBatch()\n  try {\n    return fn()\n  }\n  finally {\n    endBatch()\n  }\n}\n\nfunction cleanupEffect(effect: ReactiveEffect) {\n  const { deps } = effect\n  for (let i = 0; i < deps.length; i++) {\n    deps[i].delete(effect)\n  }\n  deps.length = 0\n}\n\nexport function stop(runner: ReactiveEffect) {\n  if (!runner.active) {\n    return\n  }\n  runner.active = false\n  cleanupEffect(runner)\n  runner.onStop?.()\n}\n\nexport interface EffectScope {\n  active: boolean\n  effects: ReactiveEffect[]\n  cleanups: (() => void)[]\n  run: <T>(fn: () => T) => T | undefined\n  stop: () => void\n}\n\nclass EffectScopeImpl implements EffectScope {\n  active = true\n  effects: ReactiveEffect[] = []\n  cleanups: (() => void)[] = []\n  private parent: EffectScopeImpl | undefined\n  private scopes: EffectScopeImpl[] | undefined\n\n  constructor(private detached = false) {\n    if (!detached && activeEffectScope) {\n      if (!activeEffectScope.active) {\n        this.active = false\n        return\n      }\n      this.parent = activeEffectScope\n      ;(activeEffectScope.scopes ||= []).push(this)\n    }\n  }\n\n  run<T>(fn: () => T): T | undefined {\n    if (!this.active) {\n      return\n    }\n    const prev = activeEffectScope\n    // eslint-disable-next-line ts/no-this-alias -- 允许 this 临时别名\n    activeEffectScope = this\n    try {\n      return fn()\n    }\n    finally {\n      activeEffectScope = prev\n    }\n  }\n\n  stop(): void {\n    if (!this.active) {\n      return\n    }\n    this.active = false\n    const prev = activeEffectScope\n    // eslint-disable-next-line ts/no-this-alias -- teardown 期间需要把新建 scope 绑定到当前停止中的 scope\n    activeEffectScope = this\n\n    let firstError: unknown\n    let hasError = false\n    const recordError = (error: unknown) => {\n      if (hasError) {\n        return\n      }\n      firstError = error\n      hasError = true\n    }\n\n    try {\n      const effects = this.effects.splice(0)\n      for (const effect of effects) {\n        try {\n          stop(effect)\n        }\n        catch (error) {\n          recordError(error)\n        }\n      }\n\n      const cleanups = this.cleanups.splice(0)\n      for (const cleanup of cleanups) {\n        try {\n          cleanup()\n        }\n        catch (error) {\n          recordError(error)\n        }\n      }\n\n      const scopes = this.scopes\n      this.scopes = undefined\n      if (scopes) {\n        for (const scope of scopes) {\n          try {\n            scope.stop()\n          }\n          catch (error) {\n            recordError(error)\n          }\n        }\n        scopes.length = 0\n      }\n    }\n    finally {\n      if (this.parent?.scopes) {\n        const index = this.parent.scopes.indexOf(this)\n        if (index >= 0) {\n          this.parent.scopes.splice(index, 1)\n        }\n      }\n      this.parent = undefined\n      activeEffectScope = prev\n    }\n\n    if (hasError) {\n      throw firstError\n    }\n  }\n}\n\ninterface ScopedReactiveEffect<T = any> extends ReactiveEffect<T> {\n  _scope: EffectScopeImpl | undefined\n}\n\nexport function effectScope(detached = false): EffectScope {\n  return new EffectScopeImpl(detached)\n}\n\nexport function getCurrentScope(): EffectScope | undefined {\n  return activeEffectScope\n}\n\nexport function onScopeDispose(fn: () => void): void {\n  if (activeEffectScope?.active) {\n    activeEffectScope.cleanups.push(fn)\n  }\n}\n\n/**\n * 在不把读取记录到当前副作用的情况下执行函数。\n * 函数内部主动运行的新副作用仍会正常收集自己的依赖。\n */\nexport function runWithoutTracking<T>(fn: () => T): T {\n  const previousShouldTrack = shouldTrack\n  shouldTrack = false\n  try {\n    return fn()\n  }\n  finally {\n    shouldTrack = previousShouldTrack\n  }\n}\n\nfunction recordEffectScope(effect: ReactiveEffect) {\n  if (!activeEffectScope) {\n    return\n  }\n  if (activeEffectScope.active) {\n    activeEffectScope.effects.push(effect)\n    return\n  }\n  stop(effect)\n}\n\nexport interface EffectOptions {\n  scheduler?: EffectScheduler\n  lazy?: boolean\n  onStop?: () => void\n}\n\nexport function createReactiveEffect<T>(fn: () => T, options: EffectOptions = {}): ReactiveEffect<T> {\n  const effect = function reactiveEffect() {\n    if (!effect.active) {\n      return fn()\n    }\n    if (effect._running) {\n      return fn()\n    }\n    cleanupEffect(effect)\n    const previousScope = activeEffectScope\n    activeEffectScope = effect._scope\n    const previousShouldTrack = shouldTrack\n    try {\n      shouldTrack = true\n      effect._running = true\n      effectStack.push(effect)\n      activeEffect = effect\n      return fn()\n    }\n    finally {\n      effectStack.pop()\n      activeEffect = effectStack[effectStack.length - 1] ?? null\n      effect._running = false\n      activeEffectScope = previousScope\n      shouldTrack = previousShouldTrack\n    }\n  } as ScopedReactiveEffect<T>\n\n  effect.deps = []\n  effect.scheduler = options.scheduler\n  effect.onStop = options.onStop\n  effect.active = true\n  effect._running = false\n  effect._fn = fn\n  effect._scope = activeEffectScope\n\n  return effect\n}\n\nfunction createEffect<T>(\n  fn: () => T,\n  options: EffectOptions,\n  computed: boolean,\n): ReactiveEffect<T> {\n  const runner = createReactiveEffect(fn, options)\n  runner._computed = computed\n  recordEffectScope(runner)\n  if (!options.lazy) {\n    runner()\n  }\n  return runner\n}\n\nexport function effect<T = any>(fn: () => T, options: EffectOptions = {}): ReactiveEffect<T> {\n  return createEffect(fn, options, false)\n}\n\nexport function createComputedEffect<T>(\n  fn: () => T,\n  options: EffectOptions = {},\n): ReactiveEffect<T> {\n  return createEffect(fn, options, true)\n}\n\nexport function track(target: object, key: PropertyKey) {\n  if (!shouldTrack || !activeEffect) {\n    return\n  }\n  let depsMap = targetMap.get(target)\n  if (!depsMap) {\n    depsMap = new Map()\n    targetMap.set(target, depsMap)\n  }\n  let dep = depsMap.get(key)\n  if (!dep) {\n    dep = new Set()\n    depsMap.set(key, dep)\n  }\n  if (!dep.has(activeEffect)) {\n    dep.add(activeEffect)\n    activeEffect.deps.push(dep)\n  }\n}\n\nfunction scheduleEffect(ef: ReactiveEffect) {\n  if (ef._running) {\n    return\n  }\n  // 计算属性只同步失效缓存，普通消费者仍由批处理队列合并。\n  if (ef._computed) {\n    runScheduledEffect(ef)\n    return\n  }\n  if (batchDepth > 0 || isFlushingBatch) {\n    batchedEffects.add(ef)\n    return\n  }\n  runScheduledEffect(ef)\n}\n\nexport function trigger(target: object, key: PropertyKey) {\n  const depsMap = targetMap.get(target)\n  if (!depsMap) {\n    return\n  }\n  const effects = depsMap.get(key)\n  if (!effects) {\n    return\n  }\n  const effectsToRun = new Set<ReactiveEffect>()\n  effects.forEach((ef) => {\n    if (ef !== activeEffect) {\n      effectsToRun.add(ef)\n    }\n  })\n  effectsToRun.forEach(scheduleEffect)\n}\n\nexport function trackEffects(dep: Dep) {\n  if (!shouldTrack || !activeEffect) {\n    return\n  }\n  if (!dep.has(activeEffect)) {\n    dep.add(activeEffect)\n    activeEffect.deps.push(dep)\n  }\n}\n\nexport function triggerEffects(dep: Dep) {\n  // 迭代时复制依赖集合，避免遍历过程中被重新加入导致死循环。\n  const effectsToRun = new Set(dep)\n  effectsToRun.forEach(scheduleEffect)\n}\n\n// 导出队列调度工具，供 watch/watchEffect 等高层 API 复用同一批处理逻辑\nexport { queueJob }\n"],"mappings":"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"}

package/dist/dev/reactivity/index.d.mts

@@ -0,0 +1,16 @@
+import { AsyncDerivation, AsyncDerivationContext, AsyncDerivationState, AsyncDerivationStatus, UseAsyncDerivationOptions, useAsyncDerivation } from "./asyncDerivation.mjs";
+import { CustomRefFactory, CustomRefOptions, CustomRefSource, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef, customRef, isRef, ref, toValue, unref } from "./ref.mjs";
+import { ComputedGetter, ComputedRef, ComputedSetter, WritableComputedOptions, WritableComputedRef, computed } from "./computed.mjs";
+import { EffectScope, batch, effect, effectScope, endBatch, getCurrentScope, onScopeDispose, startBatch, stop } from "./core.mjs";
+import { MutationKind, MutationOp, MutationRecord, addMutationRecorder, removeMutationRecorder } from "./reactive/mutation.mjs";
+import { PrelinkReactiveTreeOptions, prelinkReactiveTree, touchReactive } from "./reactive/patch.mjs";
+import { isShallowReactive, shallowReactive } from "./reactive/shallow.mjs";
+import { toRaw } from "./reactive/shared.mjs";
+import { getReactiveVersion, isRaw, isReactive, markRaw, reactive } from "./reactive.mjs";
+import { isProxy, isReadonly, readonly, shallowReadonly } from "./readonly.mjs";
+import { isShallowRef, shallowRef, triggerRef } from "./shallowRef.mjs";
+import { ToRefs, toRef, toRefs } from "./toRefs.mjs";
+import { traverse } from "./traverse.mjs";
+import { MapSources, MaybeUndefined, MultiWatchSources, OnCleanup, WatchCallback, WatchEffect, WatchEffectOptions, WatchMultiSources, WatchOptions, WatchScheduler, WatchSource, WatchSourceValue, WatchSources, WatchStopHandle, getDeepWatchStrategy, setDeepWatchStrategy } from "./watch/types.mjs";
+import { watch, watchEffect, watchPostEffect, watchSyncEffect } from "./watch.mjs";
+export { type AsyncDerivation, type AsyncDerivationContext, type AsyncDerivationState, type AsyncDerivationStatus, type ComputedGetter, type ComputedRef, type ComputedSetter, type CustomRefFactory, type CustomRefOptions, type CustomRefSource, type EffectScope, type MapSources, type MaybeRef, type MaybeRefOrGetter, type MaybeUndefined, type MultiWatchSources, type MutationKind, type MutationOp, type MutationRecord, type OnCleanup, type PrelinkReactiveTreeOptions, type Ref, type ShallowRef, type ToRefs, type UseAsyncDerivationOptions, type WatchCallback, type WatchEffect, type WatchEffectOptions, type WatchMultiSources, type WatchOptions, type WatchScheduler, type WatchSource, type WatchSourceValue, type WatchSources, type WatchStopHandle, type WritableComputedOptions, type WritableComputedRef, addMutationRecorder, batch, computed, customRef, effect, effectScope, endBatch, getCurrentScope, getDeepWatchStrategy, getReactiveVersion, isProxy, isRaw, isReactive, isReadonly, isRef, isShallowReactive, isShallowRef, markRaw, onScopeDispose, prelinkReactiveTree, reactive, readonly, ref, removeMutationRecorder, setDeepWatchStrategy, shallowReactive, shallowReadonly, shallowRef, startBatch, stop, toRaw, toRef, toRefs, toValue, touchReactive, traverse, triggerRef, unref, useAsyncDerivation, watch, watchEffect, watchPostEffect, watchSyncEffect };

package/dist/dev/reactivity/reactive/mutation.d.mts

@@ -0,0 +1,21 @@
+//#region src/reactivity/reactive/mutation.d.ts
+export type MutationOp = 'set' | 'delete';
+export type MutationKind = 'property' | 'array';
+export interface MutationRecord {
+  root: object;
+  kind: MutationKind;
+  op: MutationOp;
+  /**
+   * 点路径（例如 `a.b.c`）；当路径不可靠时为 undefined。
+   */
+  path?: string;
+  /**
+   * 当路径不唯一时回退使用的顶层键列表。
+   */
+  fallbackTopKeys?: string[];
+}
+type MutationRecorder = (record: MutationRecord) => void;
+export declare function addMutationRecorder(recorder: MutationRecorder): void;
+export declare function removeMutationRecorder(recorder: MutationRecorder): void;
+//#endregion
+//# sourceMappingURL=mutation.d.mts.map

package/dist/dev/reactivity/reactive/patch.d.mts

@@ -0,0 +1,18 @@
+//#region src/reactivity/reactive/patch.d.ts
+export interface PrelinkReactiveTreeOptions {
+  shouldIncludeTopKey?: (key: string) => boolean;
+  maxDepth?: number;
+  maxKeys?: number;
+}
+/**
+ * 预链接响应式树结构，供运行时差量路径追踪使用。
+ * @internal
+ */
+export declare function prelinkReactiveTree(root: object, options?: PrelinkReactiveTreeOptions): void;
+/**
+ * 让 effect 订阅整个对象的“版本号”，无需深度遍历即可对任何字段变化做出响应。
+ * @internal
+ */
+export declare function touchReactive(target: object): void;
+//#endregion
+//# sourceMappingURL=patch.d.mts.map

package/dist/dev/reactivity/reactive/shallow.d.mts

@@ -0,0 +1,22 @@
+//#region src/reactivity/reactive/shallow.d.ts
+/**
+ * 创建一个浅层响应式代理：仅跟踪第一层属性变更，不深度递归嵌套对象。
+ *
+ * @param target 待转换的对象
+ * @returns 浅层响应式代理
+ *
+ * @example
+ * ```ts
+ * const state = shallowReactive({ nested: { count: 0 } })
+ *
+ * state.nested.count++ // 不会触发 effect（嵌套对象未深度代理）
+ * state.nested = { count: 1 } // 会触发 effect（顶层属性变更）
+ * ```
+ */
+export declare function shallowReactive<T extends object>(target: T): T;
+/**
+ * 判断一个值是否为 shallowReactive 创建的浅层响应式对象
+ */
+export declare function isShallowReactive(value: unknown): boolean;
+//#endregion
+//# sourceMappingURL=shallow.d.mts.map

package/dist/dev/reactivity/reactive/shared.d.mts

@@ -0,0 +1,4 @@
+//#region src/reactivity/reactive/shared.d.ts
+export declare function toRaw<T>(observed: T): T;
+//#endregion
+//# sourceMappingURL=shared.d.mts.map

package/dist/dev/reactivity/reactive.d.mts

@@ -0,0 +1,42 @@
+import { MutationKind, MutationOp, MutationRecord, addMutationRecorder, removeMutationRecorder } from "./reactive/mutation.mjs";
+import { PrelinkReactiveTreeOptions, prelinkReactiveTree, touchReactive } from "./reactive/patch.mjs";
+import { isShallowReactive, shallowReactive } from "./reactive/shallow.mjs";
+import { toRaw } from "./reactive/shared.mjs";
+//#region src/reactivity/reactive.d.ts
+/**
+ * 读取响应式版本号（框架内部调试能力）。
+ * @internal
+ */
+export declare function getReactiveVersion(target: object): number;
+export declare function reactive<T extends object>(target: T): T;
+export declare function isReactive(value: unknown): boolean;
+/**
+ * 标记对象为“原始”状态，后续不会被转换为响应式，返回原对象本身。
+ *
+ * @param value 需要标记的对象
+ * @returns 带有跳过标记的原对象
+ *
+ * @example
+ * ```ts
+ * const foo = markRaw({
+ *   nested: {}
+ * })
+ *
+ * const state = reactive({
+ *   foo
+ * })
+ *
+ * state.foo // 不是响应式对象
+ * ```
+ */
+export declare function markRaw<T extends object>(value: T): T;
+/**
+ * 判断某个值是否被标记为原始（即不应转换为响应式）。
+ *
+ * @param value 待检测的值
+ * @returns 若含有跳过标记则返回 true
+ */
+export declare function isRaw(value: unknown): boolean;
+//#endregion
+export { type MutationKind, type MutationOp, type MutationRecord, type PrelinkReactiveTreeOptions, addMutationRecorder, isShallowReactive, prelinkReactiveTree, removeMutationRecorder, shallowReactive, toRaw, touchReactive };
+//# sourceMappingURL=reactive.d.mts.map

package/dist/dev/reactivity/readonly.d.mts

@@ -0,0 +1,27 @@
+import { Ref } from "./ref.mjs";
+//#region src/reactivity/readonly.d.ts
+/**
+ * readonly 会为对象/数组创建一个“浅层”只读代理，并为 Ref 创建只读包装。
+ * 选择浅层而非深层递归，是为了在小程序环境中保持实现和运行时开销最小，
+ * 仅阻止直接属性写入/删除，嵌套对象仍按原样透传。
+ */
+export declare function readonly<T extends object>(target: T): Readonly<T>;
+export declare function readonly<T>(target: Ref<T>): Readonly<Ref<T>>;
+/**
+ * 与 Vue 3 的 `shallowReadonly()` 对齐。
+ *
+ * 当前 wevu 的只读语义本身就是浅层只读，因此这里直接复用同一套实现，
+ * 让依赖 Vue 兼容 API 的代码可以无缝迁移。
+ */
+export declare function shallowReadonly<T extends object>(target: T): Readonly<T>;
+export declare function shallowReadonly<T>(target: Ref<T>): Readonly<Ref<T>>;
+/**
+ * 判断值是否为只读代理或只读 ref 包装。
+ */
+export declare function isReadonly(value: unknown): boolean;
+/**
+ * 判断值是否为响应式代理或只读代理。
+ */
+export declare function isProxy(value: unknown): boolean;
+//#endregion
+//# sourceMappingURL=readonly.d.mts.map

package/dist/dev/reactivity/readonly.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"readonly.mjs","names":[],"sources":["../../../src/reactivity/readonly.ts"],"sourcesContent":["import type { Ref } from './ref'\nimport { isObject, isReactive } from './reactive'\nimport { getTargetType, ReactiveFlags, TargetType } from './reactive/shared'\nimport { isRef, markAsRef } from './ref'\n\nfunction createReadonlyWrapper(target: any): any {\n  if (isRef(target)) {\n    const source = target\n    const readonlyRef = markAsRef({\n      get value() {\n        return source.value\n      },\n      set value(_v: any) {\n        throw new Error('无法给只读 ref 赋值')\n      },\n    })\n    Object.defineProperties(readonlyRef, {\n      [ReactiveFlags.IS_READONLY]: {\n        value: true,\n        configurable: true,\n      },\n      [ReactiveFlags.RAW]: {\n        value: source,\n        configurable: true,\n      },\n    })\n    return readonlyRef\n  }\n  if (!isObject(target)) {\n    return target\n  }\n  if (getTargetType(target as object) === TargetType.INVALID) {\n    return target\n  }\n  return new Proxy(target as object, {\n    set() {\n      throw new Error('无法在只读对象上设置属性')\n    },\n    deleteProperty() {\n      throw new Error('无法在只读对象上删除属性')\n    },\n    defineProperty() {\n      throw new Error('无法在只读对象上定义属性')\n    },\n    get(target, key, receiver) {\n      if (key === ReactiveFlags.IS_READONLY) {\n        return true\n      }\n      if (key === ReactiveFlags.RAW) {\n        return target\n      }\n      const res = Reflect.get(target, key, receiver)\n      // 仅处理顶层属性，嵌套对象维持原引用以避免深拷贝和额外代理\n      return res\n    },\n  })\n}\n\n/**\n * readonly 会为对象/数组创建一个“浅层”只读代理，并为 Ref 创建只读包装。\n * 选择浅层而非深层递归，是为了在小程序环境中保持实现和运行时开销最小，\n * 仅阻止直接属性写入/删除，嵌套对象仍按原样透传。\n */\nexport function readonly<T extends object>(target: T): T\nexport function readonly<T>(target: Ref<T>): Readonly<Ref<T>>\nexport function readonly(target: any): any {\n  return createReadonlyWrapper(target)\n}\n\n/**\n * 与 Vue 3 的 `shallowReadonly()` 对齐。\n *\n * 当前 wevu 的只读语义本身就是浅层只读，因此这里直接复用同一套实现，\n * 让依赖 Vue 兼容 API 的代码可以无缝迁移。\n */\nexport function shallowReadonly<T extends object>(target: T): Readonly<T>\nexport function shallowReadonly<T>(target: Ref<T>): Readonly<Ref<T>>\nexport function shallowReadonly(target: any): any {\n  return createReadonlyWrapper(target)\n}\n\n/**\n * 判断值是否为只读代理或只读 ref 包装。\n */\nexport function isReadonly(value: unknown): boolean {\n  return Boolean(value && (value as any)[ReactiveFlags.IS_READONLY])\n}\n\n/**\n * 判断值是否为响应式代理或只读代理。\n */\nexport function isProxy(value: unknown): boolean {\n  return isReactive(value) || isReadonly(value)\n}\n"],"mappings":";;;;;AAKA,SAAS,sBAAsB,QAAkB;CAC/C,IAAI,MAAM,MAAM,GAAG;EACjB,MAAM,SAAS;EACf,MAAM,cAAc,UAAU;GAC5B,IAAI,QAAQ;IACV,OAAO,OAAO;GAChB;GACA,IAAI,MAAM,IAAS;IACjB,MAAM,IAAI,MAAM,cAAc;GAChC;EACF,CAAC;EACD,OAAO,iBAAiB,aAAa;uBACN;IAC3B,OAAO;IACP,cAAc;GAChB;gBACqB;IACnB,OAAO;IACP,cAAc;GAChB;EACF,CAAC;EACD,OAAO;CACT;CACA,IAAI,CAAC,SAAS,MAAM,GAClB,OAAO;CAET,IAAI,cAAc,MAAgB,SAChC,OAAO;CAET,OAAO,IAAI,MAAM,QAAkB;EACjC,MAAM;GACJ,MAAM,IAAI,MAAM,cAAc;EAChC;EACA,iBAAiB;GACf,MAAM,IAAI,MAAM,cAAc;EAChC;EACA,iBAAiB;GACf,MAAM,IAAI,MAAM,cAAc;EAChC;EACA,IAAI,QAAQ,KAAK,UAAU;GACzB,IAAI,0BACF,OAAO;GAET,IAAI,mBACF,OAAO;GAIT,OAFY,QAAQ,IAAI,QAAQ,KAAK,QAE5B;EACX;CACF,CAAC;AACH;AASA,SAAgB,SAAS,QAAkB;CACzC,OAAO,sBAAsB,MAAM;AACrC;AAUA,SAAgB,gBAAgB,QAAkB;CAChD,OAAO,sBAAsB,MAAM;AACrC;;;;AAKA,SAAgB,WAAW,OAAyB;CAClD,OAAO,QAAQ,SAAU,uBAAwC;AACnE;;;;AAKA,SAAgB,QAAQ,OAAyB;CAC/C,OAAO,WAAW,KAAK,KAAK,WAAW,KAAK;AAC9C"}
+{"version":3,"file":"readonly.mjs","names":[],"sources":["../../../src/reactivity/readonly.ts"],"sourcesContent":["import type { Ref } from './ref'\nimport { isObject, isReactive } from './reactive'\nimport { getTargetType, ReactiveFlags, TargetType } from './reactive/shared'\nimport { isRef, markAsRef } from './ref'\n\nfunction createReadonlyWrapper(target: any): any {\n  if (isRef(target)) {\n    const source = target\n    const readonlyRef = markAsRef({\n      get value() {\n        return source.value\n      },\n      set value(_v: any) {\n        throw new Error('无法给只读 ref 赋值')\n      },\n    })\n    Object.defineProperties(readonlyRef, {\n      [ReactiveFlags.IS_READONLY]: {\n        value: true,\n        configurable: true,\n      },\n      [ReactiveFlags.RAW]: {\n        value: source,\n        configurable: true,\n      },\n    })\n    return readonlyRef\n  }\n  if (!isObject(target)) {\n    return target\n  }\n  if (getTargetType(target as object) === TargetType.INVALID) {\n    return target\n  }\n  return new Proxy(target as object, {\n    set() {\n      throw new Error('无法在只读对象上设置属性')\n    },\n    deleteProperty() {\n      throw new Error('无法在只读对象上删除属性')\n    },\n    defineProperty() {\n      throw new Error('无法在只读对象上定义属性')\n    },\n    get(target, key, receiver) {\n      if (key === ReactiveFlags.IS_READONLY) {\n        return true\n      }\n      if (key === ReactiveFlags.RAW) {\n        return target\n      }\n      const res = Reflect.get(target, key, receiver)\n      // 仅处理顶层属性，嵌套对象维持原引用以避免深拷贝和额外代理\n      return res\n    },\n  })\n}\n\n/**\n * readonly 会为对象/数组创建一个“浅层”只读代理，并为 Ref 创建只读包装。\n * 选择浅层而非深层递归，是为了在小程序环境中保持实现和运行时开销最小，\n * 仅阻止直接属性写入/删除，嵌套对象仍按原样透传。\n */\nexport function readonly<T extends object>(target: T): Readonly<T>\nexport function readonly<T>(target: Ref<T>): Readonly<Ref<T>>\nexport function readonly(target: any): any {\n  return createReadonlyWrapper(target)\n}\n\n/**\n * 与 Vue 3 的 `shallowReadonly()` 对齐。\n *\n * 当前 wevu 的只读语义本身就是浅层只读，因此这里直接复用同一套实现，\n * 让依赖 Vue 兼容 API 的代码可以无缝迁移。\n */\nexport function shallowReadonly<T extends object>(target: T): Readonly<T>\nexport function shallowReadonly<T>(target: Ref<T>): Readonly<Ref<T>>\nexport function shallowReadonly(target: any): any {\n  return createReadonlyWrapper(target)\n}\n\n/**\n * 判断值是否为只读代理或只读 ref 包装。\n */\nexport function isReadonly(value: unknown): boolean {\n  return Boolean(value && (value as any)[ReactiveFlags.IS_READONLY])\n}\n\n/**\n * 判断值是否为响应式代理或只读代理。\n */\nexport function isProxy(value: unknown): boolean {\n  return isReactive(value) || isReadonly(value)\n}\n"],"mappings":";;;;;AAKA,SAAS,sBAAsB,QAAkB;CAC/C,IAAI,MAAM,MAAM,GAAG;EACjB,MAAM,SAAS;EACf,MAAM,cAAc,UAAU;GAC5B,IAAI,QAAQ;IACV,OAAO,OAAO;GAChB;GACA,IAAI,MAAM,IAAS;IACjB,MAAM,IAAI,MAAM,cAAc;GAChC;EACF,CAAC;EACD,OAAO,iBAAiB,aAAa;uBACN;IAC3B,OAAO;IACP,cAAc;GAChB;gBACqB;IACnB,OAAO;IACP,cAAc;GAChB;EACF,CAAC;EACD,OAAO;CACT;CACA,IAAI,CAAC,SAAS,MAAM,GAClB,OAAO;CAET,IAAI,cAAc,MAAgB,SAChC,OAAO;CAET,OAAO,IAAI,MAAM,QAAkB;EACjC,MAAM;GACJ,MAAM,IAAI,MAAM,cAAc;EAChC;EACA,iBAAiB;GACf,MAAM,IAAI,MAAM,cAAc;EAChC;EACA,iBAAiB;GACf,MAAM,IAAI,MAAM,cAAc;EAChC;EACA,IAAI,QAAQ,KAAK,UAAU;GACzB,IAAI,0BACF,OAAO;GAET,IAAI,mBACF,OAAO;GAIT,OAFY,QAAQ,IAAI,QAAQ,KAAK,QAE5B;EACX;CACF,CAAC;AACH;AASA,SAAgB,SAAS,QAAkB;CACzC,OAAO,sBAAsB,MAAM;AACrC;AAUA,SAAgB,gBAAgB,QAAkB;CAChD,OAAO,sBAAsB,MAAM;AACrC;;;;AAKA,SAAgB,WAAW,OAAyB;CAClD,OAAO,QAAQ,SAAU,uBAAwC;AACnE;;;;AAKA,SAAgB,QAAQ,OAAyB;CAC/C,OAAO,WAAW,KAAK,KAAK,WAAW,KAAK;AAC9C"}

package/dist/dev/reactivity/ref.d.mts

@@ -0,0 +1,27 @@
+import { ComputedRef, WritableComputedRef } from "./computed.mjs";
+import { Ref as Ref$1, ShallowRef as ShallowRef$1 } from "../vue-types.mjs";
+//#region src/reactivity/ref.d.ts
+export type Ref<T = any, S = T> = Ref$1<T, S>;
+export type ShallowRef<T = any> = ShallowRef$1<T>;
+export type MaybeRef<T = any> = T | Ref<T> | ShallowRef<T> | WritableComputedRef<T>;
+export type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T);
+export declare function isRef(value: unknown): value is Ref<any>;
+export declare function ref<T = any>(): Ref<T | undefined>;
+export declare function ref<T>(value: T): Ref<T>;
+export declare function unref<T>(value: MaybeRef<T> | ComputedRef<T>): T;
+export declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
+/**
+ * 自定义 ref 工厂：用于创建可显式控制 track/trigger 的自定义 ref
+ */
+export type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
+  get: () => T;
+  set: (value: T) => void;
+};
+export interface CustomRefOptions<T> {
+  get: () => T;
+  set: (value: T) => void;
+}
+export type CustomRefSource<T> = CustomRefFactory<T> | CustomRefOptions<T>;
+export declare function customRef<T>(factory: CustomRefSource<T>, defaultValue?: T): Ref<T>;
+//#endregion
+//# sourceMappingURL=ref.d.mts.map

package/dist/dev/reactivity/ref.mjs

@@ -1,4 +1,4 @@
-import _defineProperty from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/defineProperty.mjs";
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/defineProperty.mjs";
 import { trackEffects, triggerEffects } from "./core.mjs";
 import { convertToReactive, markRaw } from "./reactive.mjs";
 

package/dist/dev/reactivity/shallowRef.d.mts

@@ -0,0 +1,19 @@
+import { Ref } from "./ref.mjs";
+//#region src/reactivity/shallowRef.d.ts
+export declare function shallowRef<T>(value: T): Ref<T>;
+export declare function shallowRef<T>(value: T, defaultValue: T): Ref<T>;
+/**
+ * 判断传入值是否为浅层 ref。
+ *
+ * @param r 待判断的值
+ * @returns 若为浅层 ref 则返回 true
+ */
+export declare function isShallowRef(r: any): r is Ref<any>;
+/**
+ * 主动触发一次浅层 ref 的更新（无需深度比较）。
+ *
+ * @param ref 需要触发的 ref
+ */
+export declare function triggerRef<T>(ref: Ref<T>): void;
+//#endregion
+//# sourceMappingURL=shallowRef.d.mts.map

package/dist/dev/reactivity/toRefs.d.mts

@@ -0,0 +1,43 @@
+import { Ref } from "./ref.mjs";
+//#region src/reactivity/toRefs.d.ts
+/**
+ * 为源响应式对象的单个属性创建 ref，可读可写并与原属性保持同步。
+ *
+ * @param object 源响应式对象
+ * @param key 属性名
+ * @returns 指向该属性的 ref
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ foo: 1 })
+ * const fooRef = toRef(state, 'foo')
+ *
+ * fooRef.value++
+ * console.log(state.foo) // 2
+ * ```
+ */
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<T[K]>;
+/**
+ * 将一个响应式对象转换成“同结构的普通对象”，其中每个字段都是指向原对象对应属性的 ref。
+ *
+ * @param object 待转换的响应式对象
+ * @returns 包含若干 ref 的普通对象
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ foo: 1, bar: 2 })
+ * const stateAsRefs = toRefs(state)
+ *
+ * stateAsRefs.foo.value++ // 2
+ * state.foo // 2
+ * ```
+ */
+export declare function toRefs<T extends object>(object: T): ToRefs<T>;
+/**
+ * toRefs 返回值的类型辅助
+ */
+type ToRef<T> = T extends Ref<any> ? T : Ref<T>;
+export type ToRefs<T extends object> = { [K in keyof T]: ToRef<T[K]>; };
+//#endregion
+//# sourceMappingURL=toRefs.d.mts.map

package/dist/dev/reactivity/traverse.d.mts

@@ -0,0 +1,8 @@
+//#region src/reactivity/traverse.d.ts
+/**
+ * 深度遍历工具（框架内部依赖收集使用）。
+ * @internal
+ */
+export declare function traverse(value: any, depth?: number, seen?: Map<object, number>): any;
+//#endregion
+//# sourceMappingURL=traverse.d.mts.map