wevu 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/index.mjs

@@ -1,5 +1,485 @@
-import { C as onScopeDispose, D as queueJob, E as nextTick, S as getCurrentScope, T as stop, _ as computed, a as isRef, b as effectScope, c as isObject, d as isShallowReactive, f as markRaw, g as touchReactive, h as toRaw, i as customRef, l as isRaw, m as shallowReactive, n as defineStore, o as ref, p as reactive, r as createStore, s as unref, t as storeToRefs, u as isReactive, v as batch, w as startBatch, x as endBatch, y as effect } from "./store-2q4qcdBi.mjs";
+//#region src/scheduler.ts
+const resolvedPromise = Promise.resolve();
+const jobQueue = /* @__PURE__ */ new Set();
+let isFlushing = false;
+function flushJobs() {
+	isFlushing = true;
+	try {
+		jobQueue.forEach((job) => job());
+	} finally {
+		jobQueue.clear();
+		isFlushing = false;
+	}
+}
+function queueJob(job) {
+	jobQueue.add(job);
+	if (!isFlushing) resolvedPromise.then(flushJobs);
+}
+function nextTick(fn) {
+	return fn ? resolvedPromise.then(fn) : resolvedPromise;
+}
+
+//#endregion
+//#region src/reactivity/core.ts
+const targetMap = /* @__PURE__ */ new WeakMap();
+let activeEffect = null;
+const effectStack = [];
+let batchDepth = 0;
+const batchedEffects = /* @__PURE__ */ new Set();
+function startBatch() {
+	batchDepth++;
+}
+function endBatch() {
+	if (batchDepth === 0) return;
+	batchDepth--;
+	if (batchDepth === 0) flushBatchedEffects();
+}
+function batch(fn) {
+	startBatch();
+	try {
+		return fn();
+	} finally {
+		endBatch();
+	}
+}
+function flushBatchedEffects() {
+	while (batchedEffects.size) {
+		const effects = Array.from(batchedEffects);
+		batchedEffects.clear();
+		for (const ef of effects) ef();
+	}
+}
+let activeEffectScope;
+var EffectScopeImpl = class {
+	active = true;
+	effects = [];
+	cleanups = [];
+	parent;
+	scopes;
+	constructor(detached = false) {
+		this.detached = detached;
+		if (!detached && activeEffectScope) {
+			this.parent = activeEffectScope;
+			(activeEffectScope.scopes ||= []).push(this);
+		}
+	}
+	run(fn) {
+		if (!this.active) return;
+		const prev = activeEffectScope;
+		activeEffectScope = this;
+		try {
+			return fn();
+		} finally {
+			activeEffectScope = prev;
+		}
+	}
+	stop() {
+		if (!this.active) return;
+		this.active = false;
+		for (const effect$1 of this.effects) stop(effect$1);
+		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?.scopes) {
+			const index = this.parent.scopes.indexOf(this);
+			if (index >= 0) this.parent.scopes.splice(index, 1);
+		}
+		this.parent = void 0;
+	}
+};
+function effectScope(detached = false) {
+	return new EffectScopeImpl(detached);
+}
+function getCurrentScope() {
+	return activeEffectScope;
+}
+function onScopeDispose(fn) {
+	if (activeEffectScope?.active) activeEffectScope.cleanups.push(fn);
+}
+function recordEffectScope(effect$1) {
+	if (activeEffectScope?.active) activeEffectScope.effects.push(effect$1);
+}
+function cleanupEffect(effect$1) {
+	const { deps } = effect$1;
+	for (let i = 0; i < deps.length; i++) deps[i].delete(effect$1);
+	deps.length = 0;
+}
+function createReactiveEffect(fn, options = {}) {
+	const effect$1 = function reactiveEffect() {
+		if (!effect$1.active) return fn();
+		if (effect$1._running) return fn();
+		cleanupEffect(effect$1);
+		try {
+			effect$1._running = true;
+			effectStack.push(effect$1);
+			activeEffect = effect$1;
+			return fn();
+		} finally {
+			effectStack.pop();
+			activeEffect = effectStack[effectStack.length - 1] ?? null;
+			effect$1._running = false;
+		}
+	};
+	effect$1.deps = [];
+	effect$1.scheduler = options.scheduler;
+	effect$1.onStop = options.onStop;
+	effect$1.active = true;
+	effect$1._running = false;
+	effect$1._fn = fn;
+	return effect$1;
+}
+function effect(fn, options = {}) {
+	const _effect = createReactiveEffect(fn, options);
+	recordEffectScope(_effect);
+	if (!options.lazy) _effect();
+	return _effect;
+}
+function stop(runner) {
+	if (!runner.active) return;
+	runner.active = false;
+	cleanupEffect(runner);
+	runner.onStop?.();
+}
+function track(target, key) {
+	if (!activeEffect) return;
+	let depsMap = targetMap.get(target);
+	if (!depsMap) {
+		depsMap = /* @__PURE__ */ new Map();
+		targetMap.set(target, depsMap);
+	}
+	let dep = depsMap.get(key);
+	if (!dep) {
+		dep = /* @__PURE__ */ new Set();
+		depsMap.set(key, dep);
+	}
+	if (!dep.has(activeEffect)) {
+		dep.add(activeEffect);
+		activeEffect.deps.push(dep);
+	}
+}
+function trigger(target, key) {
+	const depsMap = targetMap.get(target);
+	if (!depsMap) return;
+	const effects = depsMap.get(key);
+	if (!effects) return;
+	const effectsToRun = /* @__PURE__ */ new Set();
+	effects.forEach((ef) => {
+		if (ef !== activeEffect) effectsToRun.add(ef);
+	});
+	effectsToRun.forEach(scheduleEffect);
+}
+function trackEffects(dep) {
+	if (!activeEffect) return;
+	if (!dep.has(activeEffect)) {
+		dep.add(activeEffect);
+		activeEffect.deps.push(dep);
+	}
+}
+function triggerEffects(dep) {
+	dep.forEach(scheduleEffect);
+}
+function scheduleEffect(ef) {
+	if (ef.scheduler) {
+		ef.scheduler();
+		return;
+	}
+	if (batchDepth > 0) {
+		batchedEffects.add(ef);
+		return;
+	}
+	ef();
+}
+
+//#endregion
+//#region src/reactivity/computed.ts
+function computed(getterOrOptions) {
+	let getter;
+	let setter;
+	const onlyGetter = typeof getterOrOptions === "function";
+	if (onlyGetter) {
+		getter = getterOrOptions;
+		setter = () => {
+			throw new Error("Computed value is readonly");
+		};
+	} else {
+		getter = getterOrOptions.get;
+		setter = getterOrOptions.set;
+	}
+	let value;
+	let dirty = true;
+	let runner;
+	const obj = {
+		get value() {
+			if (dirty) {
+				value = runner();
+				dirty = false;
+			}
+			track(obj, "value");
+			return value;
+		},
+		set value(newValue) {
+			setter(newValue);
+		}
+	};
+	runner = effect(getter, {
+		lazy: true,
+		scheduler: () => {
+			if (!dirty) {
+				dirty = true;
+				trigger(obj, "value");
+			}
+		}
+	});
+	return onlyGetter ? obj : obj;
+}
+
+//#endregion
+//#region src/reactivity/reactive.ts
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const rawMap = /* @__PURE__ */ new WeakMap();
+const rawRootMap = /* @__PURE__ */ new WeakMap();
+let ReactiveFlags = /* @__PURE__ */ function(ReactiveFlags$1) {
+	ReactiveFlags$1["IS_REACTIVE"] = "__r_isReactive";
+	ReactiveFlags$1["RAW"] = "__r_raw";
+	ReactiveFlags$1["SKIP"] = "__r_skip";
+	return ReactiveFlags$1;
+}({});
+function isObject$1(value) {
+	return typeof value === "object" && value !== null;
+}
+const VERSION_KEY = Symbol("wevu.version");
+const mutableHandlers = {
+	get(target, key, receiver) {
+		if (key === ReactiveFlags.IS_REACTIVE) return true;
+		if (key === ReactiveFlags.RAW) return target;
+		const res = Reflect.get(target, key, receiver);
+		track(target, key);
+		if (isObject$1(res)) {
+			if (res[ReactiveFlags.SKIP]) return res;
+			const child = res;
+			const parentRoot = rawRootMap.get(target) ?? target;
+			if (!rawRootMap.has(child)) rawRootMap.set(child, parentRoot);
+			return reactive(res);
+		}
+		return res;
+	},
+	set(target, key, value, receiver) {
+		const oldValue = Reflect.get(target, key, receiver);
+		const result = Reflect.set(target, key, value, receiver);
+		if (!Object.is(oldValue, value)) {
+			trigger(target, key);
+			trigger(target, VERSION_KEY);
+			const root = rawRootMap.get(target);
+			if (root && root !== target) trigger(root, VERSION_KEY);
+		}
+		return result;
+	},
+	deleteProperty(target, key) {
+		const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+		const result = Reflect.deleteProperty(target, key);
+		if (hadKey && result) {
+			trigger(target, key);
+			trigger(target, VERSION_KEY);
+			const root = rawRootMap.get(target);
+			if (root && root !== target) trigger(root, VERSION_KEY);
+		}
+		return result;
+	},
+	ownKeys(target) {
+		track(target, Symbol.iterator);
+		track(target, VERSION_KEY);
+		return Reflect.ownKeys(target);
+	}
+};
+function reactive(target) {
+	if (!isObject$1(target)) return target;
+	const existingProxy = reactiveMap.get(target);
+	if (existingProxy) return existingProxy;
+	if (target[ReactiveFlags.IS_REACTIVE]) return target;
+	const proxy = new Proxy(target, mutableHandlers);
+	reactiveMap.set(target, proxy);
+	rawMap.set(proxy, target);
+	if (!rawRootMap.has(target)) rawRootMap.set(target, target);
+	return proxy;
+}
+function isReactive(value) {
+	return Boolean(value && value[ReactiveFlags.IS_REACTIVE]);
+}
+function toRaw(observed) {
+	return observed?.[ReactiveFlags.RAW] ?? observed;
+}
+function convertToReactive(value) {
+	return isObject$1(value) ? reactive(value) : value;
+}
+/**
+* 让 effect 订阅整个对象的“版本号”，无需深度遍历即可对任何字段变化做出响应。
+*/
+function touchReactive(target) {
+	track(toRaw(target), VERSION_KEY);
+}
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowHandlers = {
+	get(target, key, receiver) {
+		if (key === ReactiveFlags.IS_REACTIVE) return true;
+		if (key === ReactiveFlags.RAW) return target;
+		const res = Reflect.get(target, key, receiver);
+		track(target, key);
+		return res;
+	},
+	set(target, key, value, receiver) {
+		const oldValue = Reflect.get(target, key, receiver);
+		const result = Reflect.set(target, key, value, receiver);
+		if (!Object.is(oldValue, value)) {
+			trigger(target, key);
+			trigger(target, VERSION_KEY);
+		}
+		return result;
+	},
+	deleteProperty(target, key) {
+		const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+		const result = Reflect.deleteProperty(target, key);
+		if (hadKey && result) {
+			trigger(target, key);
+			trigger(target, VERSION_KEY);
+		}
+		return result;
+	},
+	ownKeys(target) {
+		track(target, Symbol.iterator);
+		track(target, VERSION_KEY);
+		return Reflect.ownKeys(target);
+	}
+};
+/**
+* 创建一个浅层响应式代理：仅跟踪第一层属性变更，不深度递归嵌套对象。
+*
+* @param target 待转换的对象
+* @returns 浅层响应式代理
+*
+* @example
+* ```ts
+* const state = shallowReactive({ nested: { count: 0 } })
+*
+* state.nested.count++ // 不会触发 effect（嵌套对象未深度代理）
+* state.nested = { count: 1 } // 会触发 effect（顶层属性变更）
+* ```
+*/
+function shallowReactive(target) {
+	if (!isObject$1(target)) return target;
+	const existingProxy = shallowReactiveMap.get(target);
+	if (existingProxy) return existingProxy;
+	if (target[ReactiveFlags.IS_REACTIVE]) return target;
+	const proxy = new Proxy(target, shallowHandlers);
+	shallowReactiveMap.set(target, proxy);
+	rawMap.set(proxy, target);
+	return proxy;
+}
+/**
+* 判断一个值是否为 shallowReactive 创建的浅层响应式对象
+*/
+function isShallowReactive(value) {
+	const raw = toRaw(value);
+	return shallowReactiveMap.has(raw);
+}
+/**
+* 标记对象为“原始”状态，后续不会被转换为响应式，返回原对象本身。
+*
+* @param value 需要标记的对象
+* @returns 带有跳过标记的原对象
+*
+* @example
+* ```ts
+* const foo = markRaw({
+*   nested: {}
+* })
+*
+* const state = reactive({
+*   foo
+* })
+*
+* state.foo // 不是响应式对象
+* ```
+*/
+function markRaw(value) {
+	if (!isObject$1(value)) return value;
+	Object.defineProperty(value, ReactiveFlags.SKIP, {
+		value: true,
+		configurable: true,
+		enumerable: false,
+		writable: true
+	});
+	return value;
+}
+/**
+* 判断某个值是否被标记为原始（即不应转换为响应式）。
+*
+* @param value 待检测的值
+* @returns 若含有跳过标记则返回 true
+*/
+function isRaw(value) {
+	return isObject$1(value) && ReactiveFlags.SKIP in value;
+}
+
+//#endregion
+//#region src/reactivity/ref.ts
+function isRef(value) {
+	return Boolean(value && typeof value === "object" && "value" in value);
+}
+var RefImpl = class {
+	_value;
+	_rawValue;
+	dep;
+	constructor(value) {
+		this._rawValue = value;
+		this._value = convertToReactive(value);
+	}
+	get value() {
+		if (!this.dep) this.dep = /* @__PURE__ */ new Set();
+		trackEffects(this.dep);
+		return this._value;
+	}
+	set value(newValue) {
+		if (!Object.is(newValue, this._rawValue)) {
+			this._rawValue = newValue;
+			this._value = convertToReactive(newValue);
+			if (this.dep) triggerEffects(this.dep);
+		}
+	}
+};
+function ref(value) {
+	if (isRef(value)) return value;
+	return markRaw(new RefImpl(value));
+}
+function unref(value) {
+	return isRef(value) ? value.value : value;
+}
+var CustomRefImpl = class {
+	_value;
+	_factory;
+	dep;
+	constructor(factory, defaultValue) {
+		this._factory = factory;
+		this._value = defaultValue;
+	}
+	get value() {
+		if (!this.dep) this.dep = /* @__PURE__ */ new Set();
+		trackEffects(this.dep);
+		return this._factory.get();
+	}
+	set value(newValue) {
+		this._factory.set(newValue);
+		if (this.dep) triggerEffects(this.dep);
+	}
+};
+function customRef(factory, defaultValue) {
+	return markRaw(new CustomRefImpl(factory, defaultValue));
+}
 
+//#endregion
 //#region src/reactivity/readonly.ts
 function readonly(target) {
 	if (isRef(target)) {
@@ -13,7 +493,7 @@ function readonly(target) {
 			}
 		};
 	}
-	if (!isObject(target)) return target;
+	if (!isObject$1(target)) return target;
 	return new Proxy(target, {
 		set() {
 			throw new Error("Cannot set property on readonly object");
@@ -33,15 +513,15 @@ function readonly(target) {
 //#endregion
 //#region src/reactivity/shallowRef.ts
 function shallowRef(value, defaultValue) {
-	return customRef((track, trigger) => ({
+	return customRef((track$1, trigger$1) => ({
 		get() {
-			track();
+			track$1();
 			return value;
 		},
 		set(newValue) {
 			if (Object.is(value, newValue)) return;
 			value = newValue;
-			trigger();
+			trigger$1();
 		}
 	}), defaultValue);
 }
@@ -89,14 +569,14 @@ function toRefs(object) {
 function toRef(object, key, defaultValue) {
 	const value = object[key];
 	if (isRef(value)) return value;
-	return customRef((track, trigger) => ({
+	return customRef((track$1, trigger$1) => ({
 		get() {
-			track();
+			track$1();
 			return object[key];
 		},
 		set(newValue) {
 			object[key] = newValue;
-			trigger();
+			trigger$1();
 		}
 	}), defaultValue);
 }
@@ -104,7 +584,7 @@ function toRef(object, key, defaultValue) {
 //#endregion
 //#region src/reactivity/traverse.ts
 function traverse(value, seen = /* @__PURE__ */ new Set()) {
-	if (!isObject(value) || seen.has(value)) return value;
+	if (!isObject$1(value) || seen.has(value)) return value;
 	seen.add(value);
 	for (const key in value) traverse(value[key], seen);
 	return value;
@@ -374,12 +854,19 @@ function diffSnapshots(prev, next) {
 //#endregion
 //#region src/runtime/hooks.ts
 let __currentInstance;
+let __currentSetupContext;
 function getCurrentInstance() {
 	return __currentInstance;
 }
 function setCurrentInstance(inst) {
 	__currentInstance = inst;
 }
+function getCurrentSetupContext() {
+	return __currentSetupContext;
+}
+function setCurrentSetupContext(ctx) {
+	__currentSetupContext = ctx;
+}
 function ensureHookBucket(target) {
 	if (!target.__wevuHooks) target.__wevuHooks = Object.create(null);
 	return target.__wevuHooks;
@@ -437,6 +924,10 @@ function onShow(handler) {
 	if (!__currentInstance) throw new Error("onShow() must be called synchronously inside setup()");
 	pushHook(__currentInstance, "onShow", handler);
 }
+function onLoad(handler) {
+	if (!__currentInstance) throw new Error("onLoad() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onLoad", handler);
+}
 function onHide(handler) {
 	if (!__currentInstance) throw new Error("onHide() must be called synchronously inside setup()");
 	pushHook(__currentInstance, "onHide", handler);
@@ -449,6 +940,14 @@ function onReady(handler) {
 	if (!__currentInstance) throw new Error("onReady() must be called synchronously inside setup()");
 	pushHook(__currentInstance, "onReady", handler);
 }
+function onPullDownRefresh(handler) {
+	if (!__currentInstance) throw new Error("onPullDownRefresh() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onPullDownRefresh", handler);
+}
+function onReachBottom(handler) {
+	if (!__currentInstance) throw new Error("onReachBottom() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onReachBottom", handler);
+}
 function onPageScroll(handler) {
 	if (!__currentInstance) throw new Error("onPageScroll() must be called synchronously inside setup()");
 	pushHook(__currentInstance, "onPageScroll", handler);
@@ -461,6 +960,18 @@ function onTabItemTap(handler) {
 	if (!__currentInstance) throw new Error("onTabItemTap() must be called synchronously inside setup()");
 	pushHook(__currentInstance, "onTabItemTap", handler);
 }
+function onResize(handler) {
+	if (!__currentInstance) throw new Error("onResize() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onResize", handler);
+}
+function onMoved(handler) {
+	if (!__currentInstance) throw new Error("onMoved() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onMoved", handler);
+}
+function onError(handler) {
+	if (!__currentInstance) throw new Error("onError() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onError", handler);
+}
 function onSaveExitState(handler) {
 	if (!__currentInstance) throw new Error("onSaveExitState() must be called synchronously inside setup()");
 	pushHook(__currentInstance, "onSaveExitState", handler, { single: true });
@@ -633,11 +1144,35 @@ function registerWatches(runtime, watchMap, instance) {
 	}
 	return stops;
 }
-function mountRuntimeInstance(target, runtimeApp, watchMap, setup) {
+function mountRuntimeInstance(target, runtimeApp, watchMap, setup, options) {
 	if (target.__wevu) return target.__wevu;
-	const runtime = runtimeApp.mount({ setData(payload) {
-		if (typeof target.setData === "function") target.setData(payload);
-	} });
+	const createDeferredAdapter = (instance) => {
+		let pending;
+		let enabled = false;
+		const adapter$1 = { setData(payload) {
+			if (!enabled) {
+				pending = {
+					...pending ?? {},
+					...payload
+				};
+				return;
+			}
+			if (typeof instance.setData === "function") return instance.setData(payload);
+		} };
+		adapter$1.__wevu_enableSetData = () => {
+			enabled = true;
+			if (pending && Object.keys(pending).length && typeof instance.setData === "function") {
+				const payload = pending;
+				pending = void 0;
+				instance.setData(payload);
+			}
+		};
+		return adapter$1;
+	};
+	const adapter = options?.deferSetData ? createDeferredAdapter(target) : { setData(payload) {
+		if (typeof target.setData === "function") return target.setData(payload);
+	} };
+	const runtime = runtimeApp.mount({ ...adapter });
 	const runtimeProxy = runtime?.proxy ?? {};
 	const runtimeState = runtime?.state ?? {};
 	if (!runtime?.methods) try {
@@ -675,15 +1210,17 @@ function mountRuntimeInstance(target, runtimeApp, watchMap, setup) {
 			bindModel: runtimeBindModel.bind(runtimeWithDefaults),
 			watch: runtimeWatch.bind(runtimeWithDefaults),
 			instance: target,
-			emit: (event, ...args) => {
-				if (typeof target.triggerEvent === "function") target.triggerEvent(event, ...args);
+			emit: (event, detail, options$1) => {
+				if (typeof target.triggerEvent === "function") target.triggerEvent(event, detail, options$1);
 			},
 			expose: (exposed) => {
 				target.__wevuExposed = exposed;
 			},
-			attrs: {}
+			attrs: {},
+			slots: Object.create(null)
 		};
 		setCurrentInstance(target);
+		setCurrentSetupContext(context);
 		try {
 			const result = runSetupFunction(setup, props, context);
 			if (result && typeof result === "object") Object.keys(result).forEach((key) => {
@@ -692,6 +1229,7 @@ function mountRuntimeInstance(target, runtimeApp, watchMap, setup) {
 				else runtime.state[key] = val;
 			});
 		} finally {
+			setCurrentSetupContext(void 0);
 			setCurrentInstance(void 0);
 		}
 	}
@@ -704,6 +1242,10 @@ function mountRuntimeInstance(target, runtimeApp, watchMap, setup) {
 	} catch {}
 	return runtime;
 }
+function enableDeferredSetData(target) {
+	const adapter = target.__wevu?.adapter;
+	if (adapter && typeof adapter.__wevu_enableSetData === "function") adapter.__wevu_enableSetData();
+}
 function teardownRuntimeInstance(target) {
 	const runtime = target.__wevu;
 	if (runtime && target.__wevuHooks) callHookList(target, "onUnload", []);
@@ -743,7 +1285,7 @@ function registerApp(runtimeApp, methods, watch$1, setup, mpOptions) {
 		if (typeof userOnHide === "function") userOnHide.apply(this, args);
 	};
 	const userOnError = appOptions.onError;
-	appOptions.onError = function onError(...args) {
+	appOptions.onError = function onError$1(...args) {
 		callHookList(this, "onAppError", args);
 		if (typeof userOnError === "function") userOnError.apply(this, args);
 	};
@@ -760,7 +1302,7 @@ function registerApp(runtimeApp, methods, watch$1, setup, mpOptions) {
 	}
 	App(appOptions);
 }
-function registerComponent(runtimeApp, methods, watch$1, setup, mpOptions, features) {
+function registerComponent(runtimeApp, methods, watch$1, setup, mpOptions) {
 	const { methods: userMethods = {}, lifetimes: userLifetimes = {}, pageLifetimes: userPageLifetimes = {}, options: userOptions = {}, ...rest } = mpOptions;
 	const userOnLoad = rest.onLoad;
 	const userOnUnload = rest.onUnload;
@@ -768,21 +1310,68 @@ function registerComponent(runtimeApp, methods, watch$1, setup, mpOptions, featu
 	const userOnHide = rest.onHide;
 	const userOnReady = rest.onReady;
 	const userOnSaveExitState = rest.onSaveExitState;
+	const userOnPullDownRefresh = rest.onPullDownRefresh;
+	const userOnReachBottom = rest.onReachBottom;
 	const userOnPageScroll = rest.onPageScroll;
+	const userOnRouteDone = rest.onRouteDone;
+	const userOnTabItemTap = rest.onTabItemTap;
+	const userOnResize = rest.onResize;
 	const userOnShareAppMessage = rest.onShareAppMessage;
 	const userOnShareTimeline = rest.onShareTimeline;
 	const userOnAddToFavorites = rest.onAddToFavorites;
+	const features = rest.features ?? {};
 	const restOptions = { ...rest };
+	const legacyCreated = restOptions.created;
+	delete restOptions.features;
+	delete restOptions.created;
 	delete restOptions.onLoad;
 	delete restOptions.onUnload;
 	delete restOptions.onShow;
 	delete restOptions.onHide;
 	delete restOptions.onReady;
-	delete restOptions.onSaveExitState;
-	delete restOptions.onPageScroll;
-	delete restOptions.onShareAppMessage;
-	delete restOptions.onShareTimeline;
-	delete restOptions.onAddToFavorites;
+	const enableOnPullDownRefresh = typeof userOnPullDownRefresh === "function" || Boolean(features.enableOnPullDownRefresh);
+	const enableOnReachBottom = typeof userOnReachBottom === "function" || Boolean(features.enableOnReachBottom);
+	const enableOnPageScroll = typeof userOnPageScroll === "function" || Boolean(features.enableOnPageScroll);
+	const enableOnRouteDone = typeof userOnRouteDone === "function" || Boolean(features.enableOnRouteDone);
+	const enableOnTabItemTap = typeof userOnTabItemTap === "function" || Boolean(features.enableOnTabItemTap);
+	const enableOnResize = typeof userOnResize === "function" || Boolean(features.enableOnResize);
+	const enableOnShareAppMessage = typeof userOnShareAppMessage === "function" || Boolean(features.enableOnShareAppMessage);
+	const enableOnShareTimeline = typeof userOnShareTimeline === "function" || Boolean(features.enableOnShareTimeline);
+	const enableOnAddToFavorites = typeof userOnAddToFavorites === "function" || Boolean(features.enableOnAddToFavorites);
+	const enableOnSaveExitState = typeof userOnSaveExitState === "function" || Boolean(features.enableOnSaveExitState);
+	const fallbackNoop = () => {};
+	const fallbackShareContent = () => ({});
+	const fallbackTimelineContent = () => ({});
+	const effectiveOnSaveExitState = typeof userOnSaveExitState === "function" ? userOnSaveExitState : (() => ({ data: void 0 }));
+	const effectiveOnPullDownRefresh = typeof userOnPullDownRefresh === "function" ? userOnPullDownRefresh : fallbackNoop;
+	const effectiveOnReachBottom = typeof userOnReachBottom === "function" ? userOnReachBottom : fallbackNoop;
+	const effectiveOnPageScroll = typeof userOnPageScroll === "function" ? userOnPageScroll : fallbackNoop;
+	const effectiveOnRouteDone = typeof userOnRouteDone === "function" ? userOnRouteDone : fallbackNoop;
+	const effectiveOnTabItemTap = typeof userOnTabItemTap === "function" ? userOnTabItemTap : fallbackNoop;
+	const effectiveOnResize = typeof userOnResize === "function" ? userOnResize : fallbackNoop;
+	const effectiveOnShareAppMessage = typeof userOnShareAppMessage === "function" ? userOnShareAppMessage : fallbackShareContent;
+	const effectiveOnShareTimeline = typeof userOnShareTimeline === "function" ? userOnShareTimeline : fallbackTimelineContent;
+	const effectiveOnAddToFavorites = typeof userOnAddToFavorites === "function" ? userOnAddToFavorites : (() => ({}));
+	const hasHook = (target, name) => {
+		const hooks = target.__wevuHooks;
+		if (!hooks) return false;
+		const entry = hooks[name];
+		if (!entry) return false;
+		if (Array.isArray(entry)) return entry.length > 0;
+		return typeof entry === "function";
+	};
+	{
+		const userExport = restOptions.export;
+		restOptions.export = function __wevu_export() {
+			const exposed = this.__wevuExposed ?? {};
+			const base = typeof userExport === "function" ? userExport.call(this) : {};
+			if (base && typeof base === "object" && !Array.isArray(base)) return {
+				...exposed,
+				...base
+			};
+			return base ?? exposed;
+		};
+	}
 	const finalOptions = {
 		multipleSlots: userOptions.multipleSlots ?? true,
 		...userOptions
@@ -804,18 +1393,11 @@ function registerComponent(runtimeApp, methods, watch$1, setup, mpOptions, featu
 			return result;
 		};
 	}
-	const wrapSpecial = (name) => {
-		const user = userLifetimes[name] ?? userPageLifetimes[name];
-		finalMethods[name] = function wrapped(...args) {
-			callHookList(this, name, args);
-			if (typeof user === "function") return user.apply(this, args);
-		};
-	};
-	wrapSpecial("onTabItemTap");
-	wrapSpecial("onRouteDone");
 	const pageLifecycleHooks = {
 		onLoad(...args) {
 			mountRuntimeInstance(this, runtimeApp, watch$1, setup);
+			enableDeferredSetData(this);
+			callHookList(this, "onLoad", args);
 			if (typeof userOnLoad === "function") return userOnLoad.apply(this, args);
 		},
 		onUnload(...args) {
@@ -836,39 +1418,69 @@ function registerComponent(runtimeApp, methods, watch$1, setup, mpOptions, featu
 				callHookList(this, "onReady", args);
 			}
 			if (typeof userOnReady === "function") return userOnReady.apply(this, args);
-		},
-		onSaveExitState(...args) {
-			const ret = callHookReturn(this, "onSaveExitState", args);
-			if (ret !== void 0) return ret;
-			if (typeof userOnSaveExitState === "function") return userOnSaveExitState.apply(this, args);
 		}
 	};
-	if (features?.listenPageScroll) pageLifecycleHooks.onPageScroll = function onPageScroll$1(...args) {
+	if (enableOnSaveExitState) pageLifecycleHooks.onSaveExitState = function onSaveExitState$1(...args) {
+		const ret = callHookReturn(this, "onSaveExitState", args);
+		if (ret !== void 0) return ret;
+		return effectiveOnSaveExitState.apply(this, args);
+	};
+	if (enableOnPullDownRefresh) pageLifecycleHooks.onPullDownRefresh = function onPullDownRefresh$1(...args) {
+		callHookList(this, "onPullDownRefresh", args);
+		if (!hasHook(this, "onPullDownRefresh")) return effectiveOnPullDownRefresh.apply(this, args);
+	};
+	if (enableOnReachBottom) pageLifecycleHooks.onReachBottom = function onReachBottom$1(...args) {
+		callHookList(this, "onReachBottom", args);
+		if (!hasHook(this, "onReachBottom")) return effectiveOnReachBottom.apply(this, args);
+	};
+	if (enableOnPageScroll) pageLifecycleHooks.onPageScroll = function onPageScroll$1(...args) {
 		callHookList(this, "onPageScroll", args);
-		if (typeof userOnPageScroll === "function") return userOnPageScroll.apply(this, args);
+		if (!hasHook(this, "onPageScroll")) return effectiveOnPageScroll.apply(this, args);
+	};
+	if (enableOnRouteDone) pageLifecycleHooks.onRouteDone = function onRouteDone$1(...args) {
+		callHookList(this, "onRouteDone", args);
+		if (!hasHook(this, "onRouteDone")) return effectiveOnRouteDone.apply(this, args);
+	};
+	if (enableOnTabItemTap) pageLifecycleHooks.onTabItemTap = function onTabItemTap$1(...args) {
+		callHookList(this, "onTabItemTap", args);
+		if (!hasHook(this, "onTabItemTap")) return effectiveOnTabItemTap.apply(this, args);
 	};
-	if (features?.enableShareAppMessage) pageLifecycleHooks.onShareAppMessage = function onShareAppMessage$1(...args) {
+	if (enableOnResize) pageLifecycleHooks.onResize = function onResize$1(...args) {
+		callHookList(this, "onResize", args);
+		if (!hasHook(this, "onResize")) return effectiveOnResize.apply(this, args);
+	};
+	if (enableOnShareAppMessage) pageLifecycleHooks.onShareAppMessage = function onShareAppMessage$1(...args) {
 		const ret = callHookReturn(this, "onShareAppMessage", args);
 		if (ret !== void 0) return ret;
-		if (typeof userOnShareAppMessage === "function") return userOnShareAppMessage.apply(this, args);
+		return effectiveOnShareAppMessage.apply(this, args);
 	};
-	if (features?.enableShareTimeline) pageLifecycleHooks.onShareTimeline = function onShareTimeline$1(...args) {
+	if (enableOnShareTimeline) pageLifecycleHooks.onShareTimeline = function onShareTimeline$1(...args) {
 		const ret = callHookReturn(this, "onShareTimeline", args);
 		if (ret !== void 0) return ret;
-		if (typeof userOnShareTimeline === "function") return userOnShareTimeline.apply(this, args);
+		return effectiveOnShareTimeline.apply(this, args);
 	};
-	if (features?.enableAddToFavorites) pageLifecycleHooks.onAddToFavorites = function onAddToFavorites$1(...args) {
+	if (enableOnAddToFavorites) pageLifecycleHooks.onAddToFavorites = function onAddToFavorites$1(...args) {
 		const ret = callHookReturn(this, "onAddToFavorites", args);
 		if (ret !== void 0) return ret;
-		if (typeof userOnAddToFavorites === "function") return userOnAddToFavorites.apply(this, args);
+		return effectiveOnAddToFavorites.apply(this, args);
 	};
 	Component({
 		...restOptions,
 		...pageLifecycleHooks,
 		lifetimes: {
 			...userLifetimes,
+			created: function created(...args) {
+				mountRuntimeInstance(this, runtimeApp, watch$1, setup, { deferSetData: true });
+				if (typeof legacyCreated === "function") legacyCreated.apply(this, args);
+				if (typeof userLifetimes.created === "function") userLifetimes.created.apply(this, args);
+			},
+			moved: function moved(...args) {
+				callHookList(this, "onMoved", args);
+				if (typeof userLifetimes.moved === "function") userLifetimes.moved.apply(this, args);
+			},
 			attached: function attached(...args) {
 				mountRuntimeInstance(this, runtimeApp, watch$1, setup);
+				enableDeferredSetData(this);
 				if (typeof userLifetimes.attached === "function") userLifetimes.attached.apply(this, args);
 			},
 			ready: function ready(...args) {
@@ -881,6 +1493,10 @@ function registerComponent(runtimeApp, methods, watch$1, setup, mpOptions, featu
 			detached: function detached(...args) {
 				teardownRuntimeInstance(this);
 				if (typeof userLifetimes.detached === "function") userLifetimes.detached.apply(this, args);
+			},
+			error: function error(...args) {
+				callHookList(this, "onError", args);
+				if (typeof userLifetimes.error === "function") userLifetimes.error.apply(this, args);
 			}
 		},
 		pageLifetimes: {
@@ -892,6 +1508,10 @@ function registerComponent(runtimeApp, methods, watch$1, setup, mpOptions, featu
 			hide: function hide(...args) {
 				callHookList(this, "onHide", args);
 				if (typeof userPageLifetimes.hide === "function") userPageLifetimes.hide.apply(this, args);
+			},
+			resize: function resize(...args) {
+				callHookList(this, "onResize", args);
+				if (typeof userPageLifetimes.resize === "function") userPageLifetimes.resize.apply(this, args);
 			}
 		},
 		methods: finalMethods,
@@ -1126,7 +1746,6 @@ function setComputedValue(setters, key, value) {
 * @example
 * ```ts
 * defineComponent({
-*   features: { listenPageScroll: true },
 *   setup() {
 *     onPageScroll(() => {})
 *   }
@@ -1134,7 +1753,7 @@ function setComputedValue(setters, key, value) {
 * ```
 */
 function defineComponent(options) {
-	const { features, data, computed: computed$1, methods, watch: watch$1, setup, props, ...mpOptions } = options;
+	const { data, computed: computed$1, methods, watch: watch$1, setup, props, ...mpOptions } = options;
 	const runtimeApp = createApp({
 		data,
 		computed: computed$1,
@@ -1151,10 +1770,9 @@ function defineComponent(options) {
 		methods,
 		watch: watch$1,
 		setup: setupWrapper,
-		mpOptions: mpOptionsWithProps,
-		features
+		mpOptions: mpOptionsWithProps
 	};
-	registerComponent(runtimeApp, methods ?? {}, watch$1, setupWrapper, mpOptionsWithProps, features);
+	registerComponent(runtimeApp, methods ?? {}, watch$1, setupWrapper, mpOptionsWithProps);
 	return {
 		__wevu_runtime: runtimeApp,
 		__wevu_options: componentOptions
@@ -1224,6 +1842,13 @@ function normalizeProps(baseOptions, props, explicitProperties) {
 			return;
 		}
 		if (typeof definition === "object") {
+			if (key.endsWith("Modifiers") && Object.keys(definition).length === 0) {
+				properties[key] = {
+					type: Object,
+					value: {}
+				};
+				return;
+			}
 			const propOptions = {};
 			if ("type" in definition && definition.type !== void 0) propOptions.type = definition.type;
 			const defaultValue = "default" in definition ? definition.default : definition.value;
@@ -1314,4 +1939,281 @@ function injectGlobal(key, defaultValue) {
 }
 
 //#endregion
-export { batch, callHookList, callHookReturn, callUpdateHooks, computed, createApp, createStore, createWevuComponent, defineComponent, defineStore, effect, effectScope, endBatch, getCurrentInstance, getCurrentScope, 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, onScopeDispose, onServerPrefetch, onShareAppMessage, onShareTimeline, onShow, onTabItemTap, onUnload, onUnmounted, onUpdated, provide, provideGlobal, reactive, readonly, ref, registerApp, registerComponent, runSetupFunction, setCurrentInstance, setDeepWatchStrategy, shallowReactive, shallowRef, startBatch, stop, storeToRefs, teardownRuntimeInstance, toRaw, toRef, toRefs, touchReactive, traverse, triggerRef, unref, watch, watchEffect };
+//#region src/runtime/vueCompat.ts
+function useAttrs() {
+	const ctx = getCurrentSetupContext();
+	if (!ctx) throw new Error("useAttrs() must be called synchronously inside setup()");
+	return ctx.attrs ?? {};
+}
+function useSlots() {
+	const ctx = getCurrentSetupContext();
+	if (!ctx) throw new Error("useSlots() must be called synchronously inside setup()");
+	return ctx.slots ?? Object.create(null);
+}
+function useModel(props, name) {
+	const ctx = getCurrentSetupContext();
+	if (!ctx) throw new Error("useModel() must be called synchronously inside setup()");
+	const emit = ctx.emit;
+	const eventName = `update:${name}`;
+	return customRef({
+		get: () => props?.[name],
+		set: (value) => {
+			emit?.(eventName, value);
+		}
+	});
+}
+function mergeModels(a, b) {
+	if (a == null) return b;
+	if (b == null) return a;
+	if (Array.isArray(a) && Array.isArray(b)) return Array.from(new Set([...a, ...b]));
+	if (typeof a === "object" && typeof b === "object") return {
+		...a,
+		...b
+	};
+	return b;
+}
+
+//#endregion
+//#region src/store/actions.ts
+function wrapAction(store, name, action, actionSubs) {
+	return function wrapped(...args) {
+		const afterCbs = [];
+		const errorCbs = [];
+		const after = (cb) => afterCbs.push(cb);
+		const onError$1 = (cb) => errorCbs.push(cb);
+		actionSubs.forEach((sub) => {
+			try {
+				sub({
+					name,
+					store,
+					args,
+					after,
+					onError: onError$1
+				});
+			} catch {}
+		});
+		let res;
+		try {
+			res = action.apply(store, args);
+		} catch (e) {
+			errorCbs.forEach((cb) => cb(e));
+			throw e;
+		}
+		const finalize = (r) => {
+			afterCbs.forEach((cb) => cb(r));
+			return r;
+		};
+		if (res && typeof res.then === "function") return res.then((r) => finalize(r), (e) => {
+			errorCbs.forEach((cb) => cb(e));
+			return Promise.reject(e);
+		});
+		return finalize(res);
+	};
+}
+
+//#endregion
+//#region src/store/utils.ts
+function isObject(val) {
+	return typeof val === "object" && val !== null;
+}
+function mergeShallow(target, patch) {
+	for (const k in patch) target[k] = patch[k];
+}
+
+//#endregion
+//#region src/store/base.ts
+function createBaseApi(id, stateObj, notify, resetImpl) {
+	const api = { $id: id };
+	Object.defineProperty(api, "$state", {
+		get() {
+			return stateObj;
+		},
+		set(v) {
+			if (stateObj && isObject(v)) {
+				mergeShallow(stateObj, v);
+				notify("patch object");
+			}
+		}
+	});
+	api.$patch = (patch) => {
+		if (!stateObj) {
+			if (typeof patch === "function") {
+				patch(api);
+				notify("patch function");
+			} else {
+				mergeShallow(api, patch);
+				notify("patch object");
+			}
+			return;
+		}
+		if (typeof patch === "function") {
+			patch(stateObj);
+			notify("patch function");
+		} else {
+			mergeShallow(stateObj, patch);
+			notify("patch object");
+		}
+	};
+	if (resetImpl) api.$reset = () => resetImpl();
+	const subs = /* @__PURE__ */ new Set();
+	api.$subscribe = (cb, _opts) => {
+		subs.add(cb);
+		return () => subs.delete(cb);
+	};
+	const actionSubs = /* @__PURE__ */ new Set();
+	api.$onAction = (cb) => {
+		actionSubs.add(cb);
+		return () => actionSubs.delete(cb);
+	};
+	return {
+		api,
+		subs,
+		actionSubs
+	};
+}
+
+//#endregion
+//#region src/store/manager.ts
+function createStore() {
+	const manager = {
+		_stores: /* @__PURE__ */ new Map(),
+		_plugins: [],
+		install(_app) {},
+		use(plugin) {
+			if (typeof plugin === "function") manager._plugins.push(plugin);
+			return manager;
+		}
+	};
+	createStore._instance = manager;
+	return manager;
+}
+
+//#endregion
+//#region src/store/define.ts
+function defineStore(id, setupOrOptions) {
+	let instance;
+	let created = false;
+	const manager = createStore._instance;
+	return function useStore() {
+		if (created && instance) return instance;
+		created = true;
+		if (typeof setupOrOptions === "function") {
+			const result = setupOrOptions();
+			let notify$1 = () => {};
+			const base$1 = createBaseApi(id, void 0, (t) => notify$1(t));
+			notify$1 = (type) => {
+				base$1.subs.forEach((cb) => {
+					try {
+						cb({
+							type,
+							storeId: id
+						}, instance);
+					} catch {}
+				});
+			};
+			instance = Object.assign({}, result);
+			for (const key of Object.getOwnPropertyNames(base$1.api)) {
+				const d = Object.getOwnPropertyDescriptor(base$1.api, key);
+				if (d) Object.defineProperty(instance, key, d);
+			}
+			Object.keys(result).forEach((k) => {
+				const val = result[k];
+				if (typeof val === "function" && !k.startsWith("$")) instance[k] = wrapAction(instance, k, val, base$1.actionSubs);
+			});
+			const plugins$1 = manager?._plugins ?? [];
+			for (const plugin of plugins$1) try {
+				plugin({ store: instance });
+			} catch {}
+			return instance;
+		}
+		const options = setupOrOptions;
+		const rawState = options.state ? options.state() : {};
+		const state = reactive(rawState);
+		const initialSnapshot = { ...toRaw(rawState) };
+		let notify = () => {};
+		const base = createBaseApi(id, state, (t) => notify(t), () => {
+			mergeShallow(state, initialSnapshot);
+			notify("patch object");
+		});
+		notify = (type) => {
+			base.subs.forEach((cb) => {
+				try {
+					cb({
+						type,
+						storeId: id
+					}, state);
+				} catch {}
+			});
+		};
+		const store = {};
+		for (const key of Object.getOwnPropertyNames(base.api)) {
+			const d = Object.getOwnPropertyDescriptor(base.api, key);
+			if (d) Object.defineProperty(store, key, d);
+		}
+		const getterDefs = options.getters ?? {};
+		const computedMap = {};
+		Object.keys(getterDefs).forEach((key) => {
+			const getter = getterDefs[key];
+			if (typeof getter === "function") {
+				const c = computed(() => getter.call(store, state));
+				computedMap[key] = c;
+				Object.defineProperty(store, key, {
+					enumerable: true,
+					configurable: true,
+					get() {
+						return c.value;
+					}
+				});
+			}
+		});
+		const actionDefs = options.actions ?? {};
+		Object.keys(actionDefs).forEach((key) => {
+			const act = actionDefs[key];
+			if (typeof act === "function") store[key] = wrapAction(store, key, (...args) => {
+				return act.apply(store, args);
+			}, base.actionSubs);
+		});
+		Object.keys(state).forEach((k) => {
+			Object.defineProperty(store, k, {
+				enumerable: true,
+				configurable: true,
+				get() {
+					return state[k];
+				},
+				set(v) {
+					state[k] = v;
+				}
+			});
+		});
+		instance = store;
+		const plugins = manager?._plugins ?? [];
+		for (const plugin of plugins) try {
+			plugin({ store: instance });
+		} catch {}
+		return instance;
+	};
+}
+
+//#endregion
+//#region src/store/storeToRefs.ts
+function storeToRefs(store) {
+	const result = {};
+	for (const key in store) {
+		const value = store[key];
+		if (typeof value === "function") {
+			result[key] = value;
+			continue;
+		}
+		if (isRef(value)) result[key] = value;
+		else result[key] = computed({
+			get: () => store[key],
+			set: (v) => {
+				store[key] = v;
+			}
+		});
+	}
+	return result;
+}
+
+//#endregion
+export { batch, callHookList, callHookReturn, callUpdateHooks, computed, createApp, createStore, createWevuComponent, defineComponent, defineStore, effect, effectScope, endBatch, getCurrentInstance, getCurrentScope, getCurrentSetupContext, getDeepWatchStrategy, inject, injectGlobal, isRaw, isReactive, isRef, isShallowReactive, isShallowRef, markRaw, mergeModels, mountRuntimeInstance, nextTick, onActivated, onAddToFavorites, onAppError, onAppHide, onAppShow, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onError, onErrorCaptured, onHide, onLoad, onMounted, onMoved, onPageScroll, onPullDownRefresh, onReachBottom, onReady, onResize, onRouteDone, onSaveExitState, onScopeDispose, onServerPrefetch, onShareAppMessage, onShareTimeline, onShow, onTabItemTap, onUnload, onUnmounted, onUpdated, provide, provideGlobal, reactive, readonly, ref, registerApp, registerComponent, runSetupFunction, setCurrentInstance, setCurrentSetupContext, setDeepWatchStrategy, shallowReactive, shallowRef, startBatch, stop, storeToRefs, teardownRuntimeInstance, toRaw, toRef, toRefs, touchReactive, traverse, triggerRef, unref, useAttrs, useModel, useSlots, watch, watchEffect };