wevu 0.0.0 → 0.0.2-alpha.0

package/dist/index.d.mts

@@ -1,97 +1,557 @@
+import { a as DefineStoreOptions, c as SubscriptionCallback, d as ref, f as unref, i as ActionSubscriber, l as Ref, n as createStore, o as MutationType, r as defineStore, s as StoreManager, t as storeToRefs, u as isRef } from "./index-DHBSC7mS.mjs";
+
+//#region src/reactivity/computed.d.ts
+type ComputedGetter<T$1> = () => T$1;
+type ComputedSetter<T$1> = (value: T$1) => void;
+interface ComputedRef<T$1> {
+  readonly value: T$1;
+}
+interface WritableComputedRef<T$1> {
+  value: T$1;
+}
+interface WritableComputedOptions<T$1> {
+  get: ComputedGetter<T$1>;
+  set: ComputedSetter<T$1>;
+}
+declare function computed<T$1>(getter: ComputedGetter<T$1>): ComputedRef<T$1>;
+declare function computed<T$1>(options: WritableComputedOptions<T$1>): WritableComputedRef<T$1>;
+//#endregion
+//#region src/scheduler.d.ts
+declare function nextTick<T$1>(fn?: () => T$1): Promise<T$1>;
+//#endregion
+//#region src/reactivity/core.d.ts
 type EffectScheduler = () => void;
 type Dep = Set<ReactiveEffect>;
-interface ReactiveEffect<T = any> {
-    (): T;
-    deps: Dep[];
-    scheduler?: EffectScheduler;
-    active: boolean;
-    _fn: () => T;
-    onStop?: () => void;
+interface ReactiveEffect<T$1 = any> {
+  (): T$1;
+  deps: Dep[];
+  scheduler?: EffectScheduler;
+  active: boolean;
+  _fn: () => T$1;
+  onStop?: () => void;
 }
 interface EffectOptions {
-    scheduler?: EffectScheduler;
-    lazy?: boolean;
-    onStop?: () => void;
+  scheduler?: EffectScheduler;
+  lazy?: boolean;
+  onStop?: () => void;
 }
-declare function effect<T = any>(fn: () => T, options?: EffectOptions): ReactiveEffect<T>;
+declare function effect<T$1 = any>(fn: () => T$1, options?: EffectOptions): ReactiveEffect<T$1>;
 declare function stop(runner: ReactiveEffect): void;
-declare function reactive<T extends object>(target: T): T;
+//#endregion
+//#region src/reactivity/reactive.d.ts
+declare function reactive<T$1 extends object>(target: T$1): T$1;
 declare function isReactive(value: unknown): boolean;
-declare function toRaw<T>(observed: T): T;
-interface Ref<T = any> {
-    value: T;
-}
-declare function isRef(value: unknown): value is Ref<any>;
-declare function ref<T>(value: T): Ref<T>;
-declare function unref<T>(value: T | Ref<T>): T;
-type ComputedGetter<T> = () => T;
-type ComputedSetter<T> = (value: T) => void;
-interface ComputedRef<T> {
-    readonly value: T;
-}
-interface WritableComputedRef<T> {
-    value: T;
-}
-interface WritableComputedOptions<T> {
-    get: ComputedGetter<T>;
-    set: ComputedSetter<T>;
-}
-declare function computed<T>(getter: ComputedGetter<T>): ComputedRef<T>;
-declare function computed<T>(options: WritableComputedOptions<T>): WritableComputedRef<T>;
+declare function toRaw<T$1>(observed: T$1): T$1;
+/**
+ * Establish a dependency on the whole reactive object "version".
+ * 让 effect 订阅整个对象的“版本号”，无需深度遍历即可对任何字段变化做出响应。
+ */
+declare function touchReactive(target: object): void;
+/**
+ * 创建一个浅层响应式代理：仅跟踪第一层属性变更，不深度递归嵌套对象。
+ *
+ * @param target 待转换的对象
+ * @returns 浅层响应式代理
+ *
+ * @example
+ * ```ts
+ * const state = shallowReactive({ nested: { count: 0 } })
+ *
+ * state.nested.count++ // 不会触发 effect（嵌套对象未深度代理）
+ * state.nested = { count: 1 } // 会触发 effect（顶层属性变更）
+ * ```
+ */
+declare function shallowReactive<T$1 extends object>(target: T$1): T$1;
+/**
+ * Checks if a value is a shallow reactive object
+ */
+declare function isShallowReactive(value: unknown): boolean;
+/**
+ * 标记对象为“原始”状态，后续不会被转换为响应式，返回原对象本身。
+ *
+ * @param value 需要标记的对象
+ * @returns 带有跳过标记的原对象
+ *
+ * @example
+ * ```ts
+ * const foo = markRaw({
+ *   nested: {}
+ * })
+ *
+ * const state = reactive({
+ *   foo
+ * })
+ *
+ * state.foo // 不是响应式对象
+ * ```
+ */
+declare function markRaw<T$1 extends object>(value: T$1): T$1;
+/**
+ * 判断某个值是否被标记为原始（即不应转换为响应式）。
+ *
+ * @param value 待检测的值
+ * @returns 若含有跳过标记则返回 true
+ */
+declare function isRaw(value: unknown): boolean;
+//#endregion
+//#region src/reactivity/readonly.d.ts
+/**
+ * readonly 会为对象/数组创建一个“浅层”只读代理，并为 Ref 创建只读包装。
+ * 选择浅层而非深层递归，是为了在小程序环境中保持实现和运行时开销最小，
+ * 仅阻止直接属性写入/删除，嵌套对象仍按原样透传。
+ */
+declare function readonly<T$1 extends object>(target: T$1): T$1;
+declare function readonly<T$1>(target: Ref<T$1>): Readonly<Ref<T$1>>;
+//#endregion
+//#region src/reactivity/shallowRef.d.ts
+/**
+ * 创建一个“浅层” ref：它只在 .value 被整体替换时触发依赖，不会对内部对象做深层响应式处理。
+ *
+ * @param value 初始值
+ * @param defaultValue 传递给 customRef 的默认值，可用于兜底
+ * @returns 仅跟踪自身 .value 变更的浅层 ref
+ *
+ * @example
+ * ```ts
+ * const state = shallowRef({ count: 0 })
+ * state.value = { count: 1 } // 会触发依赖
+ * state.value.count++ // 不会触发依赖（内部属性未被深度代理）
+ * ```
+ */
+declare function shallowRef<T$1>(value: T$1): Ref<T$1>;
+declare function shallowRef<T$1>(value: T$1, defaultValue: T$1): Ref<T$1>;
+/**
+ * 判断传入值是否为浅层 ref。
+ *
+ * @param r 待判断的值
+ * @returns 若为浅层 ref 则返回 true
+ */
+declare function isShallowRef(r: any): r is Ref<any>;
+/**
+ * 主动触发一次浅层 ref 的更新（无需深度比较）。
+ *
+ * @param ref 需要触发的 ref
+ */
+declare function triggerRef<T$1>(ref: Ref<T$1>): void;
+//#endregion
+//#region src/reactivity/toRefs.d.ts
+/**
+ * 将一个响应式对象转换成“同结构的普通对象”，其中每个字段都是指向原对象对应属性的 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
+ * ```
+ */
+declare function toRefs<T$1 extends object>(object: T$1): ToRefs<T$1>;
+/**
+ * 为源响应式对象的单个属性创建 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
+ * ```
+ */
+declare function toRef<T$1 extends object, K$1 extends keyof T$1>(object: T$1, key: K$1): Ref<T$1[K$1]>;
+declare function toRef<T$1 extends object, K$1 extends keyof T$1>(object: T$1, key: K$1, defaultValue: T$1[K$1]): Ref<T$1[K$1]>;
+/**
+ * toRefs 返回值的类型辅助
+ */
+type ToRefs<T$1 extends object> = { [K in keyof T$1]: Ref<T$1[K]> };
+//#endregion
+//#region src/reactivity/traverse.d.ts
+declare function traverse(value: any, seen?: Set<object>): any;
+//#endregion
+//#region src/reactivity/watch.d.ts
 interface WatchOptions {
-    immediate?: boolean;
-    deep?: boolean;
+  immediate?: boolean;
+  deep?: boolean;
 }
-type WatchSource<T = any> = (() => T) | Ref<T> | object;
+type WatchSource<T$1 = any> = (() => T$1) | Ref<T$1> | object;
 type WatchStopHandle = () => void;
-declare function traverse(value: any, seen?: Set<object>): any;
-declare function watch<T>(source: WatchSource<T>, cb: (value: T, oldValue: T, onCleanup: (cleanupFn: () => void) => void) => void, options?: WatchOptions): WatchStopHandle;
-
+type DeepWatchStrategy = 'version' | 'traverse';
+declare function setDeepWatchStrategy(strategy: DeepWatchStrategy): void;
+declare function getDeepWatchStrategy(): DeepWatchStrategy;
+declare function watch<T$1>(source: WatchSource<T$1>, cb: (value: T$1, oldValue: T$1, onCleanup: (cleanupFn: () => void) => void) => void, options?: WatchOptions): WatchStopHandle;
+/**
+ * watchEffect 注册一个响应式副作用，可选清理函数。
+ * 副作用会立即执行，并在依赖变化时重新运行。
+ */
+declare function watchEffect(effectFn: (onCleanup: (cleanupFn: () => void) => void) => void): WatchStopHandle;
+//#endregion
+//#region src/runtime/types.d.ts
 type ComputedDefinitions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
 type MethodDefinitions = Record<string, (...args: any[]) => any>;
-type ExtractComputed<C extends ComputedDefinitions> = {
-    [K in keyof C]: C[K] extends ComputedGetter<infer R> ? R : C[K] extends WritableComputedOptions<infer R> ? R : never;
-};
-type ExtractMethods<M extends MethodDefinitions> = {
-    [K in keyof M]: M[K] extends (...args: infer P) => infer R ? (...args: P) => R : never;
-};
+type ExtractComputed<C extends ComputedDefinitions> = { [K in keyof C]: C[K] extends ComputedGetter<infer R> ? R : C[K] extends WritableComputedOptions<infer R> ? R : never };
+type ExtractMethods<M extends MethodDefinitions> = { [K in keyof M]: M[K] extends ((...args: infer P) => infer R) ? (...args: P) => R : never };
 type ComponentPublicInstance<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions> = D & ExtractComputed<C> & ExtractMethods<M>;
 interface MiniProgramAdapter {
-    setData?: (payload: Record<string, any>) => void | Promise<void>;
+  setData?: (payload: Record<string, any>) => void | Promise<void>;
 }
-interface ModelBindingOptions<T = any> {
-    event?: string;
-    valueProp?: string;
-    parser?: (payload: any) => T;
-    formatter?: (value: T) => any;
+interface ModelBindingOptions<T$1 = any> {
+  event?: string;
+  valueProp?: string;
+  parser?: (payload: any) => T$1;
+  formatter?: (value: T$1) => any;
 }
-interface ModelBinding<T = any> {
-    value: T;
-    update: (value: T) => void;
-    model: (options?: ModelBindingOptions<T>) => Record<string, any>;
+interface ModelBinding<T$1 = any> {
+  value: T$1;
+  update: (value: T$1) => void;
+  model: (options?: ModelBindingOptions<T$1>) => Record<string, any>;
 }
-interface CreateAppOptions<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions> {
-    data?: () => D;
-    computed?: C;
-    methods?: M;
+interface AppConfig {
+  globalProperties: Record<string, any>;
 }
+type WevuPlugin = ((app: RuntimeApp<any, any, any>, ...options: any[]) => any) | {
+  install: (app: RuntimeApp<any, any, any>, ...options: any[]) => any;
+};
 interface RuntimeApp<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions> {
-    mount: (adapter?: MiniProgramAdapter) => RuntimeInstance<D, C, M>;
+  mount: (adapter?: MiniProgramAdapter) => RuntimeInstance<D, C, M>;
+  use: (plugin: WevuPlugin, ...options: any[]) => RuntimeApp<D, C, M>;
+  config: AppConfig;
 }
 interface RuntimeInstance<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions> {
-    readonly state: D;
-    readonly proxy: ComponentPublicInstance<D, C, M>;
-    readonly methods: ExtractMethods<M>;
-    readonly computed: Readonly<ExtractComputed<C>>;
-    readonly adapter?: MiniProgramAdapter;
-    bindModel: <T = any>(path: string, options?: ModelBindingOptions<T>) => ModelBinding<T>;
-    watch: <T>(source: (() => T) | Record<string, any>, cb: (value: T, oldValue: T) => void, options?: WatchOptions) => WatchStopHandle;
-    snapshot: () => Record<string, any>;
-    unmount: () => void;
+  readonly state: D;
+  readonly proxy: ComponentPublicInstance<D, C, M>;
+  readonly methods: ExtractMethods<M>;
+  readonly computed: Readonly<ExtractComputed<C>>;
+  readonly adapter?: MiniProgramAdapter;
+  bindModel: <T$1 = any>(path: string, options?: ModelBindingOptions<T$1>) => ModelBinding<T$1>;
+  watch: <T$1>(source: (() => T$1) | Record<string, any>, cb: (value: T$1, oldValue: T$1) => void, options?: WatchOptions) => WatchStopHandle;
+  snapshot: () => Record<string, any>;
+  unmount: () => void;
+}
+type PropMethod<T$1, TConstructor = any> = [T$1] extends [((...args: any) => any) | undefined] ? {
+  new (): TConstructor;
+  (): T$1;
+  readonly prototype: TConstructor;
+} : never;
+type PropConstructor<T$1 = any> = {
+  new (...args: any[]): T$1 & object;
+} | {
+  (): T$1;
+} | PropMethod<T$1>;
+type PropType<T$1> = PropConstructor<T$1> | PropConstructor<T$1>[];
+type ComponentPropsOptions = Record<string, PropOptions<any> | PropType<any> | null>;
+interface PropOptions<T$1 = any> {
+  type?: PropType<T$1> | true | null;
+  /**
+   * Default value (mirrors Vue `default`; will be assigned to mini-program property `value`)
+   */
+  default?: T$1 | (() => T$1);
+  /**
+   * Alias for mini-program `value`
+   */
+  value?: T$1 | (() => T$1);
+  required?: boolean;
 }
+type HasDefault<T$1> = T$1 extends {
+  default: infer D;
+} ? D extends (() => undefined) | undefined ? false : true : T$1 extends {
+  value: infer V;
+} ? V extends (() => undefined) | undefined ? false : true : false;
+type IsBooleanProp<T$1> = T$1 extends {
+  type?: infer U;
+} ? IsBooleanProp<U> : T$1 extends readonly any[] ? true extends IsBooleanProp<T$1[number]> ? true : false : T$1 extends BooleanConstructor ? true : false;
+type RequiredKeys<T$1> = { [K in keyof T$1]: T$1[K] extends {
+  required: true;
+} ? K : HasDefault<T$1[K]> extends true ? K : IsBooleanProp<T$1[K]> extends true ? K : never }[keyof T$1];
+type OptionalKeys<T$1> = Exclude<keyof T$1, RequiredKeys<T$1>>;
+type InferPropType<O> = O extends null ? any : O extends {
+  type?: infer T;
+} ? InferPropConstructor<T> : O extends PropType<infer V> ? V : InferPropConstructor<O>;
+type InferPropConstructor<T$1> = T$1 extends readonly any[] ? InferPropConstructor<T$1[number]> : T$1 extends undefined ? any : T$1 extends null ? any : T$1 extends BooleanConstructor ? boolean : T$1 extends NumberConstructor ? number : T$1 extends StringConstructor ? string : T$1 extends DateConstructor ? Date : T$1 extends ArrayConstructor ? any[] : T$1 extends ObjectConstructor ? Record<string, any> : T$1 extends PropConstructor<infer V> ? V : any;
+type InferProps<P$1 extends ComponentPropsOptions = ComponentPropsOptions> = { [K in keyof Pick<P$1, RequiredKeys<P$1>>]: HasDefault<P$1[K]> extends true ? Exclude<InferPropType<P$1[K]>, undefined> : InferPropType<P$1[K]> } & { [K in keyof Pick<P$1, OptionalKeys<P$1>>]?: InferPropType<P$1[K]> };
+type SetupFunction<P$1 extends ComponentPropsOptions, D extends object, C extends ComputedDefinitions, M extends MethodDefinitions> = (props: InferProps<P$1>, ctx: SetupContext<D, C, M, P$1>) => Record<string, any> | void;
+interface SetupContext<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions, P$1 extends ComponentPropsOptions = ComponentPropsOptions> {
+  /**
+   * Component props (from mini-program properties)
+   */
+  props: InferProps<P$1>;
+  /**
+   * Runtime instance
+   */
+  runtime: RuntimeInstance<D, C, M>;
+  /**
+   * Reactive state
+   */
+  state: D;
+  /**
+   * Public instance proxy
+   */
+  proxy: ComponentPublicInstance<D, C, M>;
+  /**
+   * Model binding helper
+   */
+  bindModel: RuntimeInstance<D, C, M>['bindModel'];
+  /**
+   * Watch helper
+   */
+  watch: RuntimeInstance<D, C, M>['watch'];
+  /**
+   * Internal mini-program instance
+   */
+  instance: InternalRuntimeState;
+  /**
+   * Vue 3 compatible: emit events
+   */
+  emit: (event: string, ...args: any[]) => void;
+  /**
+   * Vue 3 compatible: expose public properties
+   */
+  expose?: (exposed: Record<string, any>) => void;
+  /**
+   * Vue 3 compatible: attrs (fallback to empty object for mini-programs)
+   */
+  attrs?: Record<string, any>;
+}
+interface InternalRuntimeState {
+  __wevu?: RuntimeInstance<any, any, any>;
+  __wevuWatchStops?: WatchStopHandle[];
+  $wevu?: RuntimeInstance<any, any, any>;
+  __wevuHooks?: Record<string, any>;
+  __wevuExposed?: Record<string, any>;
+}
+interface DefineComponentOptions<P$1 extends ComponentPropsOptions = ComponentPropsOptions, D extends object = Record<string, any>, C extends ComputedDefinitions = ComputedDefinitions, M extends MethodDefinitions = MethodDefinitions> extends Omit<CreateAppOptions<D, C, M>, 'setup'> {
+  /**
+   * Vue-like props definition (will be normalized to mini-program `properties`)
+   */
+  props?: P$1;
+  watch?: Record<string, any>;
+  setup?: SetupFunction<P$1, D, C, M>;
+  [key: string]: any;
+}
+interface DefineAppOptions<D extends object = Record<string, any>, C extends ComputedDefinitions = ComputedDefinitions, M extends MethodDefinitions = MethodDefinitions> {
+  watch?: Record<string, any>;
+  setup?: (ctx: SetupContext<D, C, M>) => Record<string, any> | void;
+  [key: string]: any;
+}
+interface CreateAppOptions<D extends object = Record<string, any>, C extends ComputedDefinitions = ComputedDefinitions, M extends MethodDefinitions = MethodDefinitions> {
+  data?: () => D;
+  computed?: C;
+  methods?: M;
+  watch?: Record<string, any>;
+  setup?: (ctx: SetupContext<D, C, M>) => Record<string, any> | void;
+  [key: string]: any;
+}
+interface PageFeatures {
+  listenPageScroll?: boolean;
+  enableShareAppMessage?: boolean;
+  enableShareTimeline?: boolean;
+  enableAddToFavorites?: boolean;
+}
+//#endregion
+//#region src/runtime/app.d.ts
 declare function createApp<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions>(options: CreateAppOptions<D, C, M>): RuntimeApp<D, C, M>;
-
-declare function nextTick<T>(fn?: () => T): Promise<T>;
-
-export { computed, createApp, effect, isReactive, isRef, nextTick, reactive, ref, stop, toRaw, traverse, unref, watch };
-export type { ComponentPublicInstance, ComputedDefinitions, ComputedGetter, ComputedRef, ComputedSetter, CreateAppOptions, EffectOptions, EffectScheduler, MethodDefinitions, MiniProgramAdapter, ModelBinding, ModelBindingOptions, ReactiveEffect, Ref, RuntimeApp, RuntimeInstance, WatchOptions, WatchStopHandle, WritableComputedOptions, WritableComputedRef };
+//#endregion
+//#region src/runtime/define.d.ts
+/**
+ * defineComponent 返回的组件定义描述，用于手动注册或高级用法。
+ */
+interface ComponentDefinition<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions> {
+  /**
+   * 内部 runtime app（高级能力使用），不对外暴露正式 API。
+   * @internal
+   */
+  __wevu_runtime: RuntimeApp<D, C, M>;
+  /**
+   * 内部选项快照（高级能力使用），包含 data/computed/methods 等。
+   * @internal
+   */
+  __wevu_options: {
+    data: () => D;
+    computed: C;
+    methods: M;
+    watch: Record<string, any> | undefined;
+    setup: DefineComponentOptions<ComponentPropsOptions, D, C, M>['setup'];
+    mpOptions: Record<string, any>;
+  };
+}
+/**
+ * 按 Vue 3 风格定义一个小程序组件（始终注册为 Component，页面请用 definePage）。
+ *
+ * @param options 组件定义项
+ * @returns 可手动注册的组件定义
+ *
+ * @example
+ * ```ts
+ * defineComponent({
+ *   data: () => ({ count: 0 }),
+ *   setup() {
+ *     onMounted(() => console.log('mounted'))
+ *   }
+ * })
+ * ```
+ */
+declare function defineComponent<P$1 extends ComponentPropsOptions = ComponentPropsOptions, D extends object = Record<string, any>, C extends ComputedDefinitions = ComputedDefinitions, M extends MethodDefinitions = MethodDefinitions>(options: DefineComponentOptions<P$1, D, C, M>): ComponentDefinition<D, C, M>;
+/**
+ * 按 Vue 3 风格定义一个小程序页面
+ *
+ * @param options 页面定义
+ * @param features 页面特性（例如 listenPageScroll、enableShareAppMessage 等）
+ * @returns 页面定义
+ *
+ * @example
+ * ```ts
+ * definePage({
+ *   data: () => ({ count: 0 }),
+ *   setup() {
+ *     const count = ref(0)
+ *     onMounted(() => console.log('page mounted'))
+ *     return { count }
+ *   }
+ * }, {
+ *   listenPageScroll: true,
+ *   enableShareAppMessage: true
+ * })
+ * ```
+ */
+declare function definePage<P$1 extends ComponentPropsOptions = ComponentPropsOptions, D extends object = Record<string, any>, C extends ComputedDefinitions = ComputedDefinitions, M extends MethodDefinitions = MethodDefinitions>(options: Omit<DefineComponentOptions<P$1, D, C, M>, 'type'>, features?: PageFeatures): ComponentDefinition<D, C, M>;
+/**
+ * 从 Vue SFC 选项创建 wevu 组件，供 weapp-vite 编译产物直接调用的兼容入口。
+ *
+ * @param options 组件选项，可能包含小程序特有的 properties
+ */
+declare function createWevuComponent<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions>(options: DefineComponentOptions<ComponentPropsOptions, D, C, M> & {
+  properties?: Record<string, any>;
+}): void;
+//#endregion
+//#region src/runtime/hooks.d.ts
+declare function getCurrentInstance(): any;
+declare function setCurrentInstance(inst: InternalRuntimeState | undefined): void;
+declare function callHookList(target: InternalRuntimeState, name: string, args?: any[]): void;
+declare function callHookReturn(target: InternalRuntimeState, name: string, args?: any[]): any;
+declare function onAppShow(handler: () => void): void;
+declare function onAppHide(handler: () => void): void;
+declare function onAppError(handler: (err?: any) => void): void;
+declare function onShow(handler: () => void): void;
+declare function onHide(handler: () => void): void;
+declare function onUnload(handler: () => void): void;
+declare function onReady(handler: () => void): void;
+declare function onPageScroll(handler: (opt: any) => void): void;
+declare function onRouteDone(handler: (opt?: any) => void): void;
+declare function onTabItemTap(handler: (opt: any) => void): void;
+declare function onSaveExitState(handler: () => any): void;
+declare function onShareAppMessage(handler: (...args: any[]) => any): void;
+declare function onShareTimeline(handler: (...args: any[]) => any): void;
+declare function onAddToFavorites(handler: (...args: any[]) => any): void;
+/**
+ * Vue 3 对齐：组件/页面已挂载，映射小程序 onReady
+ */
+declare function onMounted(handler: () => void): void;
+/**
+ * Vue 3 对齐：组件/页面更新后触发。
+ * 小程序没有专用 update 生命周期，这里在每次 setData 完成后调用。
+ */
+declare function onUpdated(handler: () => void): void;
+/**
+ * Vue 3 对齐：卸载前触发。
+ * 小程序无 before-unload 生命周期，setup 时同步执行以保持语义。
+ */
+declare function onBeforeUnmount(handler: () => void): void;
+/**
+ * Vue 3 对齐：组件/页面卸载；映射到页面 onUnload 或组件 detached
+ */
+declare function onUnmounted(handler: () => void): void;
+/**
+ * Vue 3 对齐：挂载前；setup 时同步触发以模拟 beforeMount 语义
+ */
+declare function onBeforeMount(handler: () => void): void;
+/**
+ * Vue 3 对齐：更新前；在每次 setData 前触发
+ */
+declare function onBeforeUpdate(handler: () => void): void;
+/**
+ * Vue 3 对齐：错误捕获；映射到小程序 onError
+ */
+declare function onErrorCaptured(handler: (err: any, instance: any, info: string) => void): void;
+/**
+ * Vue 3 对齐：组件激活；映射到小程序 onShow
+ */
+declare function onActivated(handler: () => void): void;
+/**
+ * Vue 3 对齐：组件失活；映射到小程序 onHide
+ */
+declare function onDeactivated(handler: () => void): void;
+/**
+ * Vue 3 对齐：服务端渲染前置钩子。
+ * 小程序无此场景，保留空实现以保持 API 兼容。
+ */
+declare function onServerPrefetch(_handler: () => void): void;
+declare function callUpdateHooks(target: InternalRuntimeState, phase: 'before' | 'after'): void;
+//#endregion
+//#region src/runtime/provide.d.ts
+/**
+ * 在组件上下文中向后代注入值（与 Vue 3 行为兼容），若没有当前实例则回落到全局存储。
+ *
+ * @param key 注入键，可为字符串、Symbol 或对象
+ * @param value 提供的值
+ *
+ * @example
+ * ```ts
+ * defineComponent({
+ *   setup() {
+ *     provide(TOKEN_KEY, { data: 'value' })
+ *   }
+ * })
+ * ```
+ */
+declare function provide<T$1>(key: any, value: T$1): void;
+/**
+ * 从祖先组件（或全局存储）读取提供的值。
+ *
+ * @param key 注入键，需与 provide 使用的键保持一致
+ * @param defaultValue 未找到提供者时的默认值
+ * @returns 匹配到的值或默认值
+ *
+ * @example
+ * ```ts
+ * defineComponent({
+ *   setup() {
+ *     const data = inject(TOKEN_KEY)
+ *     const value = inject('key', 'default')
+ *   }
+ * })
+ * ```
+ */
+declare function inject<T$1>(key: any, defaultValue?: T$1): T$1;
+/**
+ * 全局注入值，适用于组件外部调用场景。
+ */
+declare function provideGlobal<T$1>(key: any, value: T$1): void;
+/**
+ * 从全局存储读取值，适用于组件外部调用场景。
+ */
+declare function injectGlobal<T$1>(key: any, defaultValue?: T$1): T$1;
+//#endregion
+//#region src/runtime/register.d.ts
+type WatchHandler = (this: any, value: any, oldValue: any) => void;
+type WatchDescriptor = WatchHandler | string | {
+  handler: WatchHandler | string;
+  immediate?: boolean;
+  deep?: boolean;
+};
+type WatchMap = Record<string, WatchDescriptor>;
+declare function runSetupFunction(setup: ((...args: any[]) => any) | undefined, props: Record<string, any>, context: any): any;
+declare function mountRuntimeInstance<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions>(target: InternalRuntimeState, runtimeApp: RuntimeApp<D, C, M>, watchMap: WatchMap | undefined, setup?: DefineComponentOptions<ComponentPropsOptions, D, C, M>['setup']): RuntimeInstance<D, C, M>;
+declare function teardownRuntimeInstance(target: InternalRuntimeState): void;
+declare function registerApp<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions>(runtimeApp: RuntimeApp<D, C, M>, methods: MethodDefinitions, watch: WatchMap | undefined, setup: DefineAppOptions<D, C, M>['setup'], mpOptions: Record<string, any>): void;
+declare function registerPage<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions>(runtimeApp: RuntimeApp<D, C, M>, methods: MethodDefinitions, watch: WatchMap | undefined, setup: DefineComponentOptions<ComponentPropsOptions, D, C, M>['setup'], mpOptions: Record<string, any>, features?: PageFeatures): void;
+declare function registerComponent<D extends object, C extends ComputedDefinitions, M extends MethodDefinitions>(runtimeApp: RuntimeApp<D, C, M>, methods: MethodDefinitions, watch: WatchMap | undefined, setup: DefineComponentOptions<ComponentPropsOptions, D, C, M>['setup'], mpOptions: Record<string, any>): void;
+//#endregion
+export { ActionSubscriber, AppConfig, ComponentDefinition, ComponentPropsOptions, ComponentPublicInstance, ComputedDefinitions, ComputedGetter, ComputedRef, ComputedSetter, CreateAppOptions, DefineAppOptions, DefineComponentOptions, DefineStoreOptions, ExtractComputed, ExtractMethods, InferPropType, InferProps, InternalRuntimeState, MethodDefinitions, MiniProgramAdapter, ModelBinding, ModelBindingOptions, MutationType, PageFeatures, PropConstructor, PropOptions, PropType, Ref, RuntimeApp, RuntimeInstance, SetupContext, SetupFunction, StoreManager, SubscriptionCallback, ToRefs, WatchOptions, WatchStopHandle, WevuPlugin, WritableComputedOptions, WritableComputedRef, callHookList, callHookReturn, callUpdateHooks, computed, createApp, createStore, createWevuComponent, defineComponent, definePage, defineStore, effect, getCurrentInstance, getDeepWatchStrategy, inject, injectGlobal, isRaw, isReactive, isRef, isShallowReactive, isShallowRef, markRaw, mountRuntimeInstance, nextTick, onActivated, onAddToFavorites, onAppError, onAppHide, onAppShow, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onHide, onMounted, onPageScroll, onReady, onRouteDone, onSaveExitState, onServerPrefetch, onShareAppMessage, onShareTimeline, onShow, onTabItemTap, onUnload, onUnmounted, onUpdated, provide, provideGlobal, reactive, readonly, ref, registerApp, registerComponent, registerPage, runSetupFunction, setCurrentInstance, setDeepWatchStrategy, shallowReactive, shallowRef, stop, storeToRefs, teardownRuntimeInstance, toRaw, toRef, toRefs, touchReactive, traverse, triggerRef, unref, watch, watchEffect };