wevu 1.0.0-alpha.3 → 1.0.0-alpha.4

package/dist/index.cjs

@@ -1,8 +1,489 @@
-const require_store = require('./store-DTqmKv0w.cjs');
 
+//#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 (require_store.isRef(target)) {
+	if (isRef(target)) {
 		const source = target;
 		return {
 			get value() {
@@ -13,7 +494,7 @@ function readonly(target) {
 			}
 		};
 	}
-	if (!require_store.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 +514,15 @@ function readonly(target) {
 //#endregion
 //#region src/reactivity/shallowRef.ts
 function shallowRef(value, defaultValue) {
-	return require_store.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);
 }
@@ -81,22 +562,22 @@ function triggerRef(ref$1) {
 * ```
 */
 function toRefs(object) {
-	if (!require_store.isReactive(object)) console.warn(`toRefs() expects a reactive object but received a plain one.`);
+	if (!isReactive(object)) console.warn(`toRefs() expects a reactive object but received a plain one.`);
 	const result = Array.isArray(object) ? Array.from({ length: object.length }) : {};
 	for (const key in object) result[key] = toRef(object, key);
 	return result;
 }
 function toRef(object, key, defaultValue) {
 	const value = object[key];
-	if (require_store.isRef(value)) return value;
-	return require_store.customRef((track, trigger) => ({
+	if (isRef(value)) return value;
+	return customRef((track$1, trigger$1) => ({
 		get() {
-			track();
+			track$1();
 			return object[key];
 		},
 		set(newValue) {
 			object[key] = newValue;
-			trigger();
+			trigger$1();
 		}
 	}), defaultValue);
 }
@@ -104,7 +585,7 @@ function toRef(object, key, defaultValue) {
 //#endregion
 //#region src/reactivity/traverse.ts
 function traverse(value, seen = /* @__PURE__ */ new Set()) {
-	if (!require_store.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;
@@ -122,15 +603,15 @@ function getDeepWatchStrategy() {
 function watch(source, cb, options = {}) {
 	let getter;
 	if (typeof source === "function") getter = source;
-	else if (require_store.isRef(source)) getter = () => source.value;
-	else if (require_store.isReactive(source)) getter = () => source;
+	else if (isRef(source)) getter = () => source.value;
+	else if (isReactive(source)) getter = () => source;
 	else throw new Error("Invalid watch source");
 	if (options.deep) {
 		const baseGetter = getter;
 		getter = () => {
 			const val = baseGetter();
-			if (__deepWatchStrategy === "version" && require_store.isReactive(val)) {
-				require_store.touchReactive(val);
+			if (__deepWatchStrategy === "version" && isReactive(val)) {
+				touchReactive(val);
 				return val;
 			}
 			return traverse(val);
@@ -149,8 +630,8 @@ function watch(source, cb, options = {}) {
 		cb(newValue, oldValue, onCleanup);
 		oldValue = newValue;
 	};
-	runner = require_store.effect(() => getter(), {
-		scheduler: () => require_store.queueJob(job),
+	runner = effect(() => getter(), {
+		scheduler: () => queueJob(job),
 		lazy: true
 	});
 	if (options.immediate) job();
@@ -158,9 +639,9 @@ function watch(source, cb, options = {}) {
 	const stopHandle = () => {
 		cleanup?.();
 		cleanup = void 0;
-		require_store.stop(runner);
+		stop(runner);
 	};
-	require_store.onScopeDispose(stopHandle);
+	onScopeDispose(stopHandle);
 	return stopHandle;
 }
 /**
@@ -172,13 +653,13 @@ function watchEffect(effectFn) {
 	const onCleanup = (fn) => {
 		cleanup = fn;
 	};
-	const runner = require_store.effect(() => {
+	const runner = effect(() => {
 		cleanup?.();
 		cleanup = void 0;
 		effectFn(onCleanup);
 	}, {
 		lazy: true,
-		scheduler: () => require_store.queueJob(() => {
+		scheduler: () => queueJob(() => {
 			if (runner.active) runner();
 		})
 	});
@@ -186,9 +667,9 @@ function watchEffect(effectFn) {
 	const stopHandle = () => {
 		cleanup?.();
 		cleanup = void 0;
-		require_store.stop(runner);
+		stop(runner);
 	};
-	require_store.onScopeDispose(stopHandle);
+	onScopeDispose(stopHandle);
 	return stopHandle;
 }
 
@@ -298,9 +779,9 @@ function isPlainObject$1(value) {
 	return proto === null || proto === Object.prototype;
 }
 function toPlain(value, seen = /* @__PURE__ */ new WeakMap()) {
-	const unwrapped = require_store.unref(value);
+	const unwrapped = unref(value);
 	if (typeof unwrapped !== "object" || unwrapped === null) return unwrapped;
-	const raw = require_store.isReactive(unwrapped) ? require_store.toRaw(unwrapped) : unwrapped;
+	const raw = isReactive(unwrapped) ? toRaw(unwrapped) : unwrapped;
 	if (seen.has(raw)) return seen.get(raw);
 	if (Array.isArray(raw)) {
 		const arr = [];
@@ -374,12 +855,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 +1217,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 +1230,7 @@ function mountRuntimeInstance(target, runtimeApp, watchMap, setup, options) {
 				else runtime.state[key] = val;
 			});
 		} finally {
+			setCurrentSetupContext(void 0);
 			setCurrentInstance(void 0);
 		}
 	}
@@ -1039,7 +1530,7 @@ function createApp(options) {
 	const appConfig = { globalProperties: {} };
 	const runtimeApp = {
 		mount(adapter) {
-			const state = require_store.reactive((data ?? (() => ({})))());
+			const state = reactive((data ?? (() => ({})))());
 			const computedDefs = resolvedComputed;
 			const methodDefs = resolvedMethods;
 			const computedRefs = Object.create(null);
@@ -1124,18 +1615,18 @@ function createApp(options) {
 			});
 			Object.keys(computedDefs).forEach((key) => {
 				const definition = computedDefs[key];
-				if (typeof definition === "function") computedRefs[key] = require_store.computed(() => definition.call(publicInstance));
+				if (typeof definition === "function") computedRefs[key] = computed(() => definition.call(publicInstance));
 				else {
 					const getter = definition.get?.bind(publicInstance);
 					if (!getter) throw new Error(`Computed property "${key}" requires a getter`);
 					const setter = definition.set?.bind(publicInstance);
 					if (setter) {
 						computedSetters[key] = setter;
-						computedRefs[key] = require_store.computed({
+						computedRefs[key] = computed({
 							get: getter,
 							set: setter
 						});
-					} else computedRefs[key] = require_store.computed(getter);
+					} else computedRefs[key] = computed(getter);
 				}
 			});
 			const currentAdapter = adapter ?? { setData: () => {} };
@@ -1159,19 +1650,19 @@ function createApp(options) {
 				}
 			};
 			let tracker;
-			tracker = require_store.effect(() => {
-				require_store.touchReactive(state);
+			tracker = effect(() => {
+				touchReactive(state);
 				Object.keys(state).forEach((key) => {
 					const v = state[key];
-					if (require_store.isRef(v)) v.value;
+					if (isRef(v)) v.value;
 				});
 				Object.keys(computedRefs).forEach((key) => computedRefs[key].value);
 			}, {
 				lazy: true,
-				scheduler: () => require_store.queueJob(job)
+				scheduler: () => queueJob(job)
 			});
 			job();
-			stopHandles.push(() => require_store.stop(tracker));
+			stopHandles.push(() => stop(tracker));
 			function registerWatch(source, cb, watchOptions) {
 				const stopHandle = watch(source, (value, oldValue) => cb(value, oldValue), watchOptions);
 				stopHandles.push(stopHandle);
@@ -1291,7 +1782,7 @@ function defineComponent(options) {
 function applySetupResult(runtime, _target, result) {
 	const methods = runtime?.methods ?? Object.create(null);
 	const state = runtime?.state ?? Object.create(null);
-	const rawState = require_store.isReactive(state) ? require_store.toRaw(state) : state;
+	const rawState = isReactive(state) ? toRaw(state) : state;
 	if (runtime && !runtime.methods) try {
 		runtime.methods = methods;
 	} catch {}
@@ -1326,7 +1817,7 @@ function isPlainObject(value) {
 function shouldExposeInSnapshot(value) {
 	if (value == null) return true;
 	if (typeof value !== "object") return true;
-	if (require_store.isRef(value) || require_store.isReactive(value)) return true;
+	if (isRef(value) || isReactive(value)) return true;
 	if (Array.isArray(value)) return true;
 	return isPlainObject(value);
 }
@@ -1352,6 +1843,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,32 +1940,311 @@ function injectGlobal(key, defaultValue) {
 }
 
 //#endregion
-exports.batch = require_store.batch;
+//#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
+exports.batch = batch;
 exports.callHookList = callHookList;
 exports.callHookReturn = callHookReturn;
 exports.callUpdateHooks = callUpdateHooks;
-exports.computed = require_store.computed;
+exports.computed = computed;
 exports.createApp = createApp;
-exports.createStore = require_store.createStore;
+exports.createStore = createStore;
 exports.createWevuComponent = createWevuComponent;
 exports.defineComponent = defineComponent;
-exports.defineStore = require_store.defineStore;
-exports.effect = require_store.effect;
-exports.effectScope = require_store.effectScope;
-exports.endBatch = require_store.endBatch;
+exports.defineStore = defineStore;
+exports.effect = effect;
+exports.effectScope = effectScope;
+exports.endBatch = endBatch;
 exports.getCurrentInstance = getCurrentInstance;
-exports.getCurrentScope = require_store.getCurrentScope;
+exports.getCurrentScope = getCurrentScope;
+exports.getCurrentSetupContext = getCurrentSetupContext;
 exports.getDeepWatchStrategy = getDeepWatchStrategy;
 exports.inject = inject;
 exports.injectGlobal = injectGlobal;
-exports.isRaw = require_store.isRaw;
-exports.isReactive = require_store.isReactive;
-exports.isRef = require_store.isRef;
-exports.isShallowReactive = require_store.isShallowReactive;
+exports.isRaw = isRaw;
+exports.isReactive = isReactive;
+exports.isRef = isRef;
+exports.isShallowReactive = isShallowReactive;
 exports.isShallowRef = isShallowRef;
-exports.markRaw = require_store.markRaw;
+exports.markRaw = markRaw;
+exports.mergeModels = mergeModels;
 exports.mountRuntimeInstance = mountRuntimeInstance;
-exports.nextTick = require_store.nextTick;
+exports.nextTick = nextTick;
 exports.onActivated = onActivated;
 exports.onAddToFavorites = onAddToFavorites;
 exports.onAppError = onAppError;
@@ -1490,7 +2267,7 @@ exports.onReady = onReady;
 exports.onResize = onResize;
 exports.onRouteDone = onRouteDone;
 exports.onSaveExitState = onSaveExitState;
-exports.onScopeDispose = require_store.onScopeDispose;
+exports.onScopeDispose = onScopeDispose;
 exports.onServerPrefetch = onServerPrefetch;
 exports.onShareAppMessage = onShareAppMessage;
 exports.onShareTimeline = onShareTimeline;
@@ -1501,26 +2278,30 @@ exports.onUnmounted = onUnmounted;
 exports.onUpdated = onUpdated;
 exports.provide = provide;
 exports.provideGlobal = provideGlobal;
-exports.reactive = require_store.reactive;
+exports.reactive = reactive;
 exports.readonly = readonly;
-exports.ref = require_store.ref;
+exports.ref = ref;
 exports.registerApp = registerApp;
 exports.registerComponent = registerComponent;
 exports.runSetupFunction = runSetupFunction;
 exports.setCurrentInstance = setCurrentInstance;
+exports.setCurrentSetupContext = setCurrentSetupContext;
 exports.setDeepWatchStrategy = setDeepWatchStrategy;
-exports.shallowReactive = require_store.shallowReactive;
+exports.shallowReactive = shallowReactive;
 exports.shallowRef = shallowRef;
-exports.startBatch = require_store.startBatch;
-exports.stop = require_store.stop;
-exports.storeToRefs = require_store.storeToRefs;
+exports.startBatch = startBatch;
+exports.stop = stop;
+exports.storeToRefs = storeToRefs;
 exports.teardownRuntimeInstance = teardownRuntimeInstance;
-exports.toRaw = require_store.toRaw;
+exports.toRaw = toRaw;
 exports.toRef = toRef;
 exports.toRefs = toRefs;
-exports.touchReactive = require_store.touchReactive;
+exports.touchReactive = touchReactive;
 exports.traverse = traverse;
 exports.triggerRef = triggerRef;
-exports.unref = require_store.unref;
+exports.unref = unref;
+exports.useAttrs = useAttrs;
+exports.useModel = useModel;
+exports.useSlots = useSlots;
 exports.watch = watch;
 exports.watchEffect = watchEffect;