wevu 1.0.0-alpha.3 → 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-YHZDsE3y.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;
@@ -729,9 +1216,11 @@ function mountRuntimeInstance(target, runtimeApp, watchMap, setup, options) {
 			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) => {
@@ -740,6 +1229,7 @@ function mountRuntimeInstance(target, runtimeApp, watchMap, setup, options) {
 				else runtime.state[key] = val;
 			});
 		} finally {
+			setCurrentSetupContext(void 0);
 			setCurrentInstance(void 0);
 		}
 	}
@@ -1352,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;
@@ -1442,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, 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, 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 };