wevu 7.0.4 → 7.1.1

package/dist/dev/macros.d.mts

@@ -0,0 +1,71 @@
+import { HostMiniProgramComponentPropertyOption } from "./runtime/types/miniprogramHost.mjs";
+import { ComponentPropsOptions } from "./runtime/types/props/propTypes.mjs";
+import { Ref } from "./reactivity/ref.mjs";
+import "./reactivity/index.mjs";
+import { ComputedDefinitions, MethodDefinitions } from "./runtime/types/core.mjs";
+import "./runtime/index.mjs";
+import { BooleanKey, ComponentTypeEmits, DefineProps, DefinePropsFromArray, DefinePropsFromOptions, EmitFn, EmitsOptions, InferDefaults, PropsWithDefaults, ScriptSetupDefineOptions, ShortEmits } from "./macros/shared.mjs";
+//#region src/macros.d.ts
+/**
+ * defineProps 声明（类型层宏）。
+ */
+export declare function defineProps<PropNames extends string = string>(props: PropNames[]): DefinePropsFromArray<PropNames>;
+export declare function defineProps<PP extends ComponentPropsOptions = ComponentPropsOptions>(props: PP): DefinePropsFromOptions<PP>;
+export declare function defineProps<TypeProps>(): DefineProps<TypeProps, BooleanKey<TypeProps>>;
+/**
+ * withDefaults 为 defineProps 声明默认值（类型层）。
+ */
+export declare function withDefaults<T, BKeys extends keyof T, Defaults extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults): PropsWithDefaults<T, Defaults, BKeys>;
+/**
+ * defineEmits 声明（类型层宏）。
+ */
+export declare function defineEmits<EE extends string = string>(emits?: EE[]): EmitFn<EE[]>;
+export declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emits?: E): EmitFn<E>;
+export declare function defineEmits<T extends ComponentTypeEmits>(): T extends ((...args: any[]) => any) ? T : ShortEmits<T>;
+/**
+ * defineExpose 向父级 ref 暴露成员（仅类型层）。
+ */
+export declare function defineExpose<T extends Record<string, any> = Record<string, any>>(exposed?: T): void;
+/**
+ * defineOptions 设置 `<script setup>` 组件选项（仅类型层）。
+ */
+export declare function defineOptions<D extends object = Record<string, any>, C extends ComputedDefinitions = ComputedDefinitions, M extends MethodDefinitions = MethodDefinitions, P extends HostMiniProgramComponentPropertyOption = HostMiniProgramComponentPropertyOption>(options?: ScriptSetupDefineOptions<D, C, M, P>): void;
+export declare function defineOptions<D extends object = Record<string, any>, C extends ComputedDefinitions = ComputedDefinitions, M extends MethodDefinitions = MethodDefinitions, P extends HostMiniProgramComponentPropertyOption = HostMiniProgramComponentPropertyOption>(options?: () => ScriptSetupDefineOptions<D, C, M, P> | Promise<ScriptSetupDefineOptions<D, C, M, P>>): void;
+/**
+ * defineSlots 声明 slots 类型（仅类型层）。
+ */
+export declare function defineSlots<T extends Record<string, any> = Record<string, any>>(): T;
+export type PageLayoutMeta = string | false | {
+  name: string;
+  props?: Record<string, unknown>;
+};
+export interface PageMeta {
+  layout?: PageLayoutMeta;
+  [key: string]: unknown;
+}
+/**
+ * definePageMeta 声明页面级元信息（仅类型层）。
+ */
+export declare function definePageMeta(meta: PageMeta): void;
+/**
+ * defineModel 声明 v-model 绑定（类型层宏）。
+ */
+export type DefineModelModifiers<M extends PropertyKey = string> = Record<M, true | undefined>;
+export type ModelRef<T, M extends PropertyKey = string, G = T, S = T> = Ref<G, S> & [ModelRef<T, M, G, S>, DefineModelModifiers<M>];
+export interface DefineModelTransformOptions<T, M extends PropertyKey = string, G = T, S = T> {
+  get?: (value: T, modifiers: DefineModelModifiers<M>) => G;
+  set?: (value: S, modifiers: DefineModelModifiers<M>) => T;
+}
+type DefineModelBaseOptions<T, M extends PropertyKey = string, G = T, S = T> = Record<string, any> & DefineModelTransformOptions<T, M, G, S>;
+type DefineModelRequiredOptions<T> = {
+  default: T | (() => T);
+} | {
+  required: true;
+};
+export declare function defineModel<T = any, M extends PropertyKey = string, G = T, S = T>(options: DefineModelBaseOptions<T, M, G, S> & DefineModelRequiredOptions<T>): ModelRef<T, M, G, S>;
+export declare function defineModel<T = any, M extends PropertyKey = string, G = T, S = T>(name: string, options: DefineModelBaseOptions<T, M, G, S> & DefineModelRequiredOptions<T>): ModelRef<T, M, G, S>;
+export declare function defineModel<T = any, M extends PropertyKey = string, G = T, S = T>(options?: DefineModelBaseOptions<T | undefined, M, G | undefined, S | undefined>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
+export declare function defineModel<T = any, M extends PropertyKey = string, G = T, S = T>(name?: string, options?: DefineModelBaseOptions<T | undefined, M, G | undefined, S | undefined>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
+//#endregion
+export type { ComponentTypeEmits, EmitFn, EmitsOptions };
+//# sourceMappingURL=macros.d.mts.map

package/dist/dev/package.mjs

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "7.0.4";
+var version = "7.1.1";
 
 //#endregion
 export { version };

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

@@ -0,0 +1,41 @@
+//#region src/reactivity/asyncDerivation.d.ts
+/** 异步派生状态的生命周期阶段。 */
+export type AsyncDerivationStatus = 'idle' | 'initial-pending' | 'ready' | 'refreshing' | 'error' | 'disposed';
+/** 传给异步加载函数的当前任务上下文。 */
+export interface AsyncDerivationContext {
+  readonly signal: AbortSignal;
+}
+/** `useAsyncDerivation()` 的配置。 */
+export interface UseAsyncDerivationOptions {
+  immediate?: boolean;
+}
+type AsyncDerivationIdleState<TStatus extends 'idle' | 'initial-pending' | 'disposed'> = Readonly<{
+  status: TStatus;
+  value: undefined;
+  error: undefined;
+}>;
+type AsyncDerivationReadyState<T, TStatus extends 'ready' | 'refreshing'> = Readonly<{
+  status: TStatus;
+  value: T;
+  error: undefined;
+}>;
+type AsyncDerivationErrorState<T> = Readonly<{
+  status: 'error';
+  value: T | undefined;
+  error: unknown;
+}>;
+/** 模板可观察的只读异步派生状态。 */
+export type AsyncDerivationState<T> = AsyncDerivationIdleState<'idle'> | AsyncDerivationIdleState<'initial-pending'> | AsyncDerivationIdleState<'disposed'> | AsyncDerivationReadyState<T, 'ready'> | AsyncDerivationReadyState<T, 'refreshing'> | AsyncDerivationErrorState<T>;
+type AsyncDerivationControls = Readonly<{
+  refresh: () => Promise<void>;
+  dispose: () => void;
+}>;
+/** 异步派生状态及其非枚举控制方法。 */
+export type AsyncDerivation<T> = AsyncDerivationState<T> & AsyncDerivationControls;
+/**
+ * 创建面向静态 WXML 数据绑定的异步派生状态。
+ * 加载错误通过 `status` 与 `error` 暴露，`refresh()` 始终正常完成。
+ */
+export declare function useAsyncDerivation<T>(loader: (context: AsyncDerivationContext) => T | PromiseLike<T>, options?: UseAsyncDerivationOptions): AsyncDerivation<T>;
+//#endregion
+//# sourceMappingURL=asyncDerivation.d.mts.map

package/dist/dev/reactivity/asyncDerivation.mjs

@@ -0,0 +1,130 @@
+import { batch, onScopeDispose, runWithoutTracking } from "./core.mjs";
+import { reactive } from "./reactive.mjs";
+import { readonly } from "./readonly.mjs";
+import { AbortControllerPolyfill } from "@wevu/web-apis/abort";
+
+//#region src/reactivity/asyncDerivation.ts
+const RESOLVED_PROMISE = Promise.resolve();
+function createAsyncDerivationCycle() {
+	let resolve;
+	return {
+		promise: new Promise((settle) => {
+			resolve = settle;
+		}),
+		resolve
+	};
+}
+/**
+* 创建面向静态 WXML 数据绑定的异步派生状态。
+* 加载错误通过 `status` 与 `error` 暴露，`refresh()` 始终正常完成。
+*/
+function useAsyncDerivation(loader, options = {}) {
+	var _options$immediate;
+	const storage = {
+		status: "idle",
+		value: void 0,
+		error: void 0
+	};
+	const state = reactive(storage);
+	let activeController;
+	let activeCycle;
+	let generation = 0;
+	let hasValue = false;
+	let disposed = false;
+	function settleLatestCycle(completedGeneration) {
+		if (disposed || completedGeneration !== generation) return;
+		const cycle = activeCycle;
+		activeCycle = void 0;
+		cycle === null || cycle === void 0 || cycle.resolve();
+	}
+	function commitValue(completedGeneration, value) {
+		if (disposed || completedGeneration !== generation) return;
+		activeController = void 0;
+		hasValue = true;
+		try {
+			batch(() => {
+				state.status = "ready";
+				state.value = value;
+				state.error = void 0;
+			});
+		} finally {
+			settleLatestCycle(completedGeneration);
+		}
+	}
+	function commitError(completedGeneration, error) {
+		if (disposed || completedGeneration !== generation) return;
+		activeController = void 0;
+		try {
+			batch(() => {
+				state.status = "error";
+				state.error = error;
+				if (!hasValue) state.value = void 0;
+			});
+		} finally {
+			settleLatestCycle(completedGeneration);
+		}
+	}
+	function refresh() {
+		var _activeCycle;
+		if (disposed) return RESOLVED_PROMISE;
+		const cycle = (_activeCycle = activeCycle) !== null && _activeCycle !== void 0 ? _activeCycle : createAsyncDerivationCycle();
+		activeCycle = cycle;
+		const currentGeneration = ++generation;
+		const previousController = activeController;
+		const controller = new (typeof AbortController === "function" ? AbortController : AbortControllerPolyfill)();
+		activeController = controller;
+		try {
+			previousController === null || previousController === void 0 || previousController.abort();
+		} catch (_unused) {}
+		if (disposed || currentGeneration !== generation) return cycle.promise;
+		batch(() => {
+			state.status = hasValue ? "refreshing" : "initial-pending";
+			state.error = void 0;
+		});
+		if (disposed || currentGeneration !== generation) return cycle.promise;
+		runWithoutTracking(() => {
+			new Promise((resolve) => {
+				resolve(loader({ signal: controller.signal }));
+			}).then((value) => commitValue(currentGeneration, value), (error) => commitError(currentGeneration, error)).catch((error) => {
+				setTimeout(() => {
+					throw error;
+				}, 0);
+			});
+		});
+		return cycle.promise;
+	}
+	function dispose() {
+		if (disposed) return;
+		disposed = true;
+		generation += 1;
+		const controller = activeController;
+		activeController = void 0;
+		try {
+			controller === null || controller === void 0 || controller.abort();
+		} catch (_unused2) {}
+		try {
+			batch(() => {
+				state.status = "disposed";
+				state.value = void 0;
+				state.error = void 0;
+			});
+		} finally {
+			hasValue = false;
+			const cycle = activeCycle;
+			activeCycle = void 0;
+			cycle === null || cycle === void 0 || cycle.resolve();
+		}
+	}
+	Object.defineProperties(storage, {
+		refresh: { value: refresh },
+		dispose: { value: dispose }
+	});
+	const result = readonly(state);
+	onScopeDispose(dispose);
+	if ((_options$immediate = options.immediate) !== null && _options$immediate !== void 0 ? _options$immediate : true) refresh();
+	return result;
+}
+
+//#endregion
+export { useAsyncDerivation };
+//# sourceMappingURL=asyncDerivation.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"asyncDerivation.mjs","names":[],"sources":["../../../src/reactivity/asyncDerivation.ts"],"sourcesContent":["import { AbortControllerPolyfill } from '@wevu/web-apis/abort'\nimport { batch, onScopeDispose, runWithoutTracking } from './core'\nimport { reactive } from './reactive'\nimport { readonly } from './readonly'\n\n/** 异步派生状态的生命周期阶段。 */\nexport type AsyncDerivationStatus\n  = | 'idle'\n    | 'initial-pending'\n    | 'ready'\n    | 'refreshing'\n    | 'error'\n    | 'disposed'\n\n/** 传给异步加载函数的当前任务上下文。 */\nexport interface AsyncDerivationContext {\n  readonly signal: AbortSignal\n}\n\n/** `useAsyncDerivation()` 的配置。 */\nexport interface UseAsyncDerivationOptions {\n  immediate?: boolean\n}\n\ntype AsyncDerivationIdleState<TStatus extends 'idle' | 'initial-pending' | 'disposed'> = Readonly<{\n  status: TStatus\n  value: undefined\n  error: undefined\n}>\n\ntype AsyncDerivationReadyState<T, TStatus extends 'ready' | 'refreshing'> = Readonly<{\n  status: TStatus\n  value: T\n  error: undefined\n}>\n\ntype AsyncDerivationErrorState<T> = Readonly<{\n  status: 'error'\n  value: T | undefined\n  error: unknown\n}>\n\n/** 模板可观察的只读异步派生状态。 */\nexport type AsyncDerivationState<T>\n  = | AsyncDerivationIdleState<'idle'>\n    | AsyncDerivationIdleState<'initial-pending'>\n    | AsyncDerivationIdleState<'disposed'>\n    | AsyncDerivationReadyState<T, 'ready'>\n    | AsyncDerivationReadyState<T, 'refreshing'>\n    | AsyncDerivationErrorState<T>\n\ntype AsyncDerivationControls = Readonly<{\n  refresh: () => Promise<void>\n  dispose: () => void\n}>\n\n/** 异步派生状态及其非枚举控制方法。 */\nexport type AsyncDerivation<T> = AsyncDerivationState<T> & AsyncDerivationControls\n\ninterface MutableAsyncDerivationState<T> {\n  status: AsyncDerivationStatus\n  value: T | undefined\n  error: unknown\n}\n\ninterface AsyncDerivationCycle {\n  readonly promise: Promise<void>\n  readonly resolve: () => void\n}\n\nconst RESOLVED_PROMISE: Promise<void> = Promise.resolve()\n\nfunction createAsyncDerivationCycle(): AsyncDerivationCycle {\n  let resolve!: () => void\n  const promise = new Promise<void>((settle) => {\n    resolve = settle\n  })\n  return { promise, resolve }\n}\n\n/**\n * 创建面向静态 WXML 数据绑定的异步派生状态。\n * 加载错误通过 `status` 与 `error` 暴露，`refresh()` 始终正常完成。\n */\nexport function useAsyncDerivation<T>(\n  loader: (context: AsyncDerivationContext) => T | PromiseLike<T>,\n  options: UseAsyncDerivationOptions = {},\n): AsyncDerivation<T> {\n  const storage: MutableAsyncDerivationState<T> = {\n    status: 'idle',\n    value: undefined,\n    error: undefined,\n  }\n  const state = reactive(storage)\n  let activeController: AbortController | undefined\n  let activeCycle: AsyncDerivationCycle | undefined\n  let generation = 0\n  let hasValue = false\n  let disposed = false\n\n  function settleLatestCycle(completedGeneration: number) {\n    if (disposed || completedGeneration !== generation) {\n      return\n    }\n    const cycle = activeCycle\n    activeCycle = undefined\n    cycle?.resolve()\n  }\n\n  function commitValue(completedGeneration: number, value: T) {\n    if (disposed || completedGeneration !== generation) {\n      return\n    }\n    activeController = undefined\n    hasValue = true\n    try {\n      batch(() => {\n        state.status = 'ready'\n        state.value = value\n        state.error = undefined\n      })\n    }\n    finally {\n      settleLatestCycle(completedGeneration)\n    }\n  }\n\n  function commitError(completedGeneration: number, error: unknown) {\n    if (disposed || completedGeneration !== generation) {\n      return\n    }\n    activeController = undefined\n    try {\n      batch(() => {\n        state.status = 'error'\n        state.error = error\n        if (!hasValue) {\n          state.value = undefined\n        }\n      })\n    }\n    finally {\n      settleLatestCycle(completedGeneration)\n    }\n  }\n\n  function refresh(): Promise<void> {\n    if (disposed) {\n      return RESOLVED_PROMISE\n    }\n\n    const cycle = activeCycle ?? createAsyncDerivationCycle()\n    activeCycle = cycle\n    const currentGeneration = ++generation\n    const previousController = activeController\n    // eslint-disable-next-line mini-program/no-implicit-runtime-polyfill -- 缺失宿主实现时显式回退兼容层。\n    const Controller = typeof AbortController === 'function' ? AbortController : AbortControllerPolyfill\n    const controller = new Controller() as unknown as AbortController\n    activeController = controller\n    try {\n      previousController?.abort()\n    }\n    catch {\n      // 原生 EventTarget 不把 abort listener 异常传播给调用者，兼容实现保持相同控制流。\n    }\n\n    if (disposed || currentGeneration !== generation) {\n      return cycle.promise\n    }\n\n    batch(() => {\n      state.status = hasValue ? 'refreshing' : 'initial-pending'\n      state.error = undefined\n    })\n\n    if (disposed || currentGeneration !== generation) {\n      return cycle.promise\n    }\n\n    runWithoutTracking(() => {\n      // 自有 Promise 避免原生 Promise 的身份快路径把 then 访问移出收养边界。\n      const task = new Promise<T>((resolve) => {\n        resolve(loader({ signal: controller.signal }))\n      })\n      void task.then(\n        value => commitValue(currentGeneration, value),\n        error => commitError(currentGeneration, error),\n      ).catch((error) => {\n        // 观察者异常交给宿主报告，不改写加载结果，也不阻塞 refresh 的完成。\n        setTimeout(() => {\n          throw error\n        }, 0)\n      })\n    })\n    return cycle.promise\n  }\n\n  function dispose() {\n    if (disposed) {\n      return\n    }\n    disposed = true\n    generation += 1\n    const controller = activeController\n    activeController = undefined\n    try {\n      controller?.abort()\n    }\n    catch {\n      // dispose 必须完成状态清理和 waiter 结算，不能被 listener 异常中断。\n    }\n    try {\n      batch(() => {\n        state.status = 'disposed'\n        state.value = undefined\n        state.error = undefined\n      })\n    }\n    finally {\n      hasValue = false\n      const cycle = activeCycle\n      activeCycle = undefined\n      cycle?.resolve()\n    }\n  }\n\n  Object.defineProperties(storage, {\n    refresh: {\n      value: refresh,\n    },\n    dispose: {\n      value: dispose,\n    },\n  })\n\n  const result = readonly(state) as AsyncDerivation<T>\n  onScopeDispose(dispose)\n  if (options.immediate ?? true) {\n    void refresh()\n  }\n  return result\n}\n"],"mappings":";;;;;;AAsEA,MAAM,mBAAkC,QAAQ,QAAQ;AAExD,SAAS,6BAAmD;CAC1D,IAAI;CAIJ,OAAO;EAAE,aAHW,SAAe,WAAW;GAC5C,UAAU;EACZ,CACe;EAAG;CAAQ;AAC5B;;;;;AAMA,SAAgB,mBACd,QACA,UAAqC,CAAC,GAClB;;CACpB,MAAM,UAA0C;EAC9C,QAAQ;EACR,OAAO;EACP,OAAO;CACT;CACA,MAAM,QAAQ,SAAS,OAAO;CAC9B,IAAI;CACJ,IAAI;CACJ,IAAI,aAAa;CACjB,IAAI,WAAW;CACf,IAAI,WAAW;CAEf,SAAS,kBAAkB,qBAA6B;EACtD,IAAI,YAAY,wBAAwB,YACtC;EAEF,MAAM,QAAQ;EACd,cAAc;EACd,4CAAO,QAAQ;CACjB;CAEA,SAAS,YAAY,qBAA6B,OAAU;EAC1D,IAAI,YAAY,wBAAwB,YACtC;EAEF,mBAAmB;EACnB,WAAW;EACX,IAAI;GACF,YAAY;IACV,MAAM,SAAS;IACf,MAAM,QAAQ;IACd,MAAM,QAAQ;GAChB,CAAC;EACH,UACQ;GACN,kBAAkB,mBAAmB;EACvC;CACF;CAEA,SAAS,YAAY,qBAA6B,OAAgB;EAChE,IAAI,YAAY,wBAAwB,YACtC;EAEF,mBAAmB;EACnB,IAAI;GACF,YAAY;IACV,MAAM,SAAS;IACf,MAAM,QAAQ;IACd,IAAI,CAAC,UACH,MAAM,QAAQ;GAElB,CAAC;EACH,UACQ;GACN,kBAAkB,mBAAmB;EACvC;CACF;CAEA,SAAS,UAAyB;;EAChC,IAAI,UACF,OAAO;EAGT,MAAM,wBAAQ,kEAAe,2BAA2B;EACxD,cAAc;EACd,MAAM,oBAAoB,EAAE;EAC5B,MAAM,qBAAqB;EAG3B,MAAM,aAAa,KADA,OAAO,oBAAoB,aAAa,kBAAkB,yBAC3C;EAClC,mBAAmB;EACnB,IAAI;GACF,mFAAoB,MAAM;EAC5B,kBACM,CAEN;EAEA,IAAI,YAAY,sBAAsB,YACpC,OAAO,MAAM;EAGf,YAAY;GACV,MAAM,SAAS,WAAW,eAAe;GACzC,MAAM,QAAQ;EAChB,CAAC;EAED,IAAI,YAAY,sBAAsB,YACpC,OAAO,MAAM;EAGf,yBAAyB;GAKvB,AAAK,IAHY,SAAY,YAAY;IACvC,QAAQ,OAAO,EAAE,QAAQ,WAAW,OAAO,CAAC,CAAC;GAC/C,CACQ,CAAC,CAAC,MACR,UAAS,YAAY,mBAAmB,KAAK,IAC7C,UAAS,YAAY,mBAAmB,KAAK,CAC/C,CAAC,CAAC,OAAO,UAAU;IAEjB,iBAAiB;KACf,MAAM;IACR,GAAG,CAAC;GACN,CAAC;EACH,CAAC;EACD,OAAO,MAAM;CACf;CAEA,SAAS,UAAU;EACjB,IAAI,UACF;EAEF,WAAW;EACX,cAAc;EACd,MAAM,aAAa;EACnB,mBAAmB;EACnB,IAAI;GACF,2DAAY,MAAM;EACpB,mBACM,CAEN;EACA,IAAI;GACF,YAAY;IACV,MAAM,SAAS;IACf,MAAM,QAAQ;IACd,MAAM,QAAQ;GAChB,CAAC;EACH,UACQ;GACN,WAAW;GACX,MAAM,QAAQ;GACd,cAAc;GACd,4CAAO,QAAQ;EACjB;CACF;CAEA,OAAO,iBAAiB,SAAS;EAC/B,SAAS,EACP,OAAO,QACT;EACA,SAAS,EACP,OAAO,QACT;CACF,CAAC;CAED,MAAM,SAAS,SAAS,KAAK;CAC7B,eAAe,OAAO;CACtB,0BAAI,QAAQ,4EAAa,MACvB,AAAK,QAAQ;CAEf,OAAO;AACT"}

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

@@ -0,0 +1,21 @@
+import { Ref } from "./ref.mjs";
+//#region src/reactivity/computed.d.ts
+export type ComputedGetter<T> = () => T;
+export type ComputedSetter<T> = (value: T) => void;
+interface BaseComputedRef<T, S = T> extends Ref<T, S> {
+  [key: symbol]: any;
+}
+export interface ComputedRef<T = any> extends BaseComputedRef<T> {
+  readonly value: T;
+}
+export interface WritableComputedRef<T, S = T> extends BaseComputedRef<T, S> {
+  value: T;
+}
+export interface WritableComputedOptions<T> {
+  get: ComputedGetter<T>;
+  set: ComputedSetter<T>;
+}
+export declare function computed<T>(getter: ComputedGetter<T>): ComputedRef<T>;
+export declare function computed<T>(options: WritableComputedOptions<T>): WritableComputedRef<T>;
+//#endregion
+//# sourceMappingURL=computed.d.mts.map

package/dist/dev/reactivity/computed.mjs

@@ -1,4 +1,4 @@
-import { effect, track, trigger } from "./core.mjs";
+import { createComputedEffect, track, trigger } from "./core.mjs";
 import { markAsRef } from "./ref.mjs";
 
 //#region src/reactivity/computed.ts
@@ -32,7 +32,7 @@ function computed(getterOrOptions) {
 		}
 	};
 	markAsRef(obj);
-	runner = effect(getter, {
+	runner = createComputedEffect(getter, {
 		lazy: true,
 		scheduler: () => {
 			if (!dirty) {

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

@@ -1 +1 @@
-{"version":3,"file":"computed.mjs","names":[],"sources":["../../../src/reactivity/computed.ts"],"sourcesContent":["import type { ReactiveEffect } from './core'\nimport type { Ref } from './ref'\nimport { effect, track, trigger } from './core'\nimport { markAsRef } from './ref'\n\nexport type ComputedGetter<T> = () => T\nexport type ComputedSetter<T> = (value: T) => void\n\ninterface BaseComputedRef<T, S = T> extends Ref<T, S> {\n  [key: symbol]: any\n}\n\nexport interface ComputedRef<T = any> extends BaseComputedRef<T> {\n  readonly value: T\n}\n\nexport interface WritableComputedRef<T, S = T> extends BaseComputedRef<T, S> {\n  value: T\n}\n\nexport interface WritableComputedOptions<T> {\n  get: ComputedGetter<T>\n  set: ComputedSetter<T>\n}\n\nexport function computed<T>(getter: ComputedGetter<T>): ComputedRef<T>\nexport function computed<T>(options: WritableComputedOptions<T>): WritableComputedRef<T>\nexport function computed<T>(\n  getterOrOptions: ComputedGetter<T> | WritableComputedOptions<T>,\n): ComputedRef<T> | WritableComputedRef<T> {\n  let getter: ComputedGetter<T>\n  let setter: ComputedSetter<T>\n  const onlyGetter = typeof getterOrOptions === 'function'\n  if (onlyGetter) {\n    getter = getterOrOptions as ComputedGetter<T>\n    setter = () => {\n      throw new Error('计算属性是只读的')\n    }\n  }\n  else {\n    getter = (getterOrOptions as WritableComputedOptions<T>).get\n    setter = (getterOrOptions as WritableComputedOptions<T>).set\n  }\n  let value: T\n  let dirty = true\n  let runner: ReactiveEffect<T>\n  const obj: any = {\n    get value() {\n      if (dirty) {\n        value = runner()\n        dirty = false\n      }\n      track(obj, 'value')\n      return value\n    },\n    set value(newValue: T) {\n      setter(newValue)\n    },\n  }\n  markAsRef(obj)\n  runner = effect(getter, {\n    lazy: true,\n    scheduler: () => {\n      if (!dirty) {\n        dirty = true\n        trigger(obj, 'value')\n      }\n    },\n  })\n  return (onlyGetter ? obj as ComputedRef<T> : obj as WritableComputedRef<T>)\n}\n"],"mappings":";;;;AA2BA,SAAgB,SACd,iBACyC;CACzC,IAAI;CACJ,IAAI;CACJ,MAAM,aAAa,OAAO,oBAAoB;CAC9C,IAAI,YAAY;EACd,SAAS;EACT,eAAe;GACb,MAAM,IAAI,MAAM,UAAU;EAC5B;CACF,OACK;EACH,SAAU,gBAA+C;EACzD,SAAU,gBAA+C;CAC3D;CACA,IAAI;CACJ,IAAI,QAAQ;CACZ,IAAI;CACJ,MAAM,MAAW;EACf,IAAI,QAAQ;GACV,IAAI,OAAO;IACT,QAAQ,OAAO;IACf,QAAQ;GACV;GACA,MAAM,KAAK,OAAO;GAClB,OAAO;EACT;EACA,IAAI,MAAM,UAAa;GACrB,OAAO,QAAQ;EACjB;CACF;CACA,UAAU,GAAG;CACb,SAAS,OAAO,QAAQ;EACtB,MAAM;EACN,iBAAiB;GACf,IAAI,CAAC,OAAO;IACV,QAAQ;IACR,QAAQ,KAAK,OAAO;GACtB;EACF;CACF,CAAC;CACD,OAAQ,aAAa,MAAwB;AAC/C"}
+{"version":3,"file":"computed.mjs","names":[],"sources":["../../../src/reactivity/computed.ts"],"sourcesContent":["import type { ReactiveEffect } from './core'\nimport type { Ref } from './ref'\nimport { createComputedEffect, track, trigger } from './core'\nimport { markAsRef } from './ref'\n\nexport type ComputedGetter<T> = () => T\nexport type ComputedSetter<T> = (value: T) => void\n\ninterface BaseComputedRef<T, S = T> extends Ref<T, S> {\n  [key: symbol]: any\n}\n\nexport interface ComputedRef<T = any> extends BaseComputedRef<T> {\n  readonly value: T\n}\n\nexport interface WritableComputedRef<T, S = T> extends BaseComputedRef<T, S> {\n  value: T\n}\n\nexport interface WritableComputedOptions<T> {\n  get: ComputedGetter<T>\n  set: ComputedSetter<T>\n}\n\nexport function computed<T>(getter: ComputedGetter<T>): ComputedRef<T>\nexport function computed<T>(options: WritableComputedOptions<T>): WritableComputedRef<T>\nexport function computed<T>(\n  getterOrOptions: ComputedGetter<T> | WritableComputedOptions<T>,\n): ComputedRef<T> | WritableComputedRef<T> {\n  let getter: ComputedGetter<T>\n  let setter: ComputedSetter<T>\n  const onlyGetter = typeof getterOrOptions === 'function'\n  if (onlyGetter) {\n    getter = getterOrOptions as ComputedGetter<T>\n    setter = () => {\n      throw new Error('计算属性是只读的')\n    }\n  }\n  else {\n    getter = (getterOrOptions as WritableComputedOptions<T>).get\n    setter = (getterOrOptions as WritableComputedOptions<T>).set\n  }\n  let value: T\n  let dirty = true\n  let runner: ReactiveEffect<T>\n  const obj: any = {\n    get value() {\n      if (dirty) {\n        value = runner()\n        dirty = false\n      }\n      track(obj, 'value')\n      return value\n    },\n    set value(newValue: T) {\n      setter(newValue)\n    },\n  }\n  markAsRef(obj)\n  runner = createComputedEffect(getter, {\n    lazy: true,\n    scheduler: () => {\n      if (!dirty) {\n        dirty = true\n        trigger(obj, 'value')\n      }\n    },\n  })\n  return (onlyGetter ? obj as ComputedRef<T> : obj as WritableComputedRef<T>)\n}\n"],"mappings":";;;;AA2BA,SAAgB,SACd,iBACyC;CACzC,IAAI;CACJ,IAAI;CACJ,MAAM,aAAa,OAAO,oBAAoB;CAC9C,IAAI,YAAY;EACd,SAAS;EACT,eAAe;GACb,MAAM,IAAI,MAAM,UAAU;EAC5B;CACF,OACK;EACH,SAAU,gBAA+C;EACzD,SAAU,gBAA+C;CAC3D;CACA,IAAI;CACJ,IAAI,QAAQ;CACZ,IAAI;CACJ,MAAM,MAAW;EACf,IAAI,QAAQ;GACV,IAAI,OAAO;IACT,QAAQ,OAAO;IACf,QAAQ;GACV;GACA,MAAM,KAAK,OAAO;GAClB,OAAO;EACT;EACA,IAAI,MAAM,UAAa;GACrB,OAAO,QAAQ;EACjB;CACF;CACA,UAAU,GAAG;CACb,SAAS,qBAAqB,QAAQ;EACpC,MAAM;EACN,iBAAiB;GACf,IAAI,CAAC,OAAO;IACV,QAAQ;IACR,QAAQ,KAAK,OAAO;GACtB;EACF;CACF,CAAC;CACD,OAAQ,aAAa,MAAwB;AAC/C"}

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

@@ -0,0 +1,35 @@
+//#region src/reactivity/core.d.ts
+export type EffectScheduler = () => void;
+export type Dep = Set<ReactiveEffect>;
+export interface ReactiveEffect<T = any> {
+  (): T;
+  deps: Dep[];
+  scheduler?: EffectScheduler;
+  active: boolean;
+  _running: boolean;
+  _fn: () => T;
+  _computed?: boolean;
+  onStop?: () => void;
+}
+export declare function startBatch(): void;
+export declare function endBatch(): void;
+export declare function batch<T>(fn: () => T): T;
+export declare function stop(runner: ReactiveEffect): void;
+export interface EffectScope {
+  active: boolean;
+  effects: ReactiveEffect[];
+  cleanups: (() => void)[];
+  run: <T>(fn: () => T) => T | undefined;
+  stop: () => void;
+}
+export declare function effectScope(detached?: boolean): EffectScope;
+export declare function getCurrentScope(): EffectScope | undefined;
+export declare function onScopeDispose(fn: () => void): void;
+export interface EffectOptions {
+  scheduler?: EffectScheduler;
+  lazy?: boolean;
+  onStop?: () => void;
+}
+export declare function effect<T = any>(fn: () => T, options?: EffectOptions): ReactiveEffect<T>;
+//#endregion
+//# sourceMappingURL=core.d.mts.map

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