wevu 0.0.0 → 0.0.2-alpha.0

package/dist/store-Cmw9vWBT.cjs

@@ -0,0 +1,764 @@
+
+//#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 = [];
+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 (effectStack.includes(effect$1)) return fn();
+		cleanupEffect(effect$1);
+		try {
+			effectStack.push(effect$1);
+			activeEffect = effect$1;
+			return fn();
+		} finally {
+			effectStack.pop();
+			activeEffect = effectStack[effectStack.length - 1] ?? null;
+		}
+	};
+	effect$1.deps = [];
+	effect$1.scheduler = options.scheduler;
+	effect$1.onStop = options.onStop;
+	effect$1.active = true;
+	effect$1._fn = fn;
+	return effect$1;
+}
+function effect(fn, options = {}) {
+	const _effect = createReactiveEffect(fn, options);
+	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((ef) => {
+		if (ef.scheduler) ef.scheduler();
+		else ef();
+	});
+}
+function trackEffects(dep) {
+	if (!activeEffect) return;
+	if (!dep.has(activeEffect)) {
+		dep.add(activeEffect);
+		activeEffect.deps.push(dep);
+	}
+}
+function triggerEffects(dep) {
+	dep.forEach((ef) => {
+		if (ef.scheduler) ef.scheduler();
+		else 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;
+}
+/**
+* Establish a dependency on the whole reactive object "version".
+* 让 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;
+}
+/**
+* Checks if a value is a shallow reactive object
+*/
+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 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 new CustomRefImpl(factory, defaultValue);
+}
+
+//#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 = (cb) => errorCbs.push(cb);
+		actionSubs.forEach((sub) => {
+			try {
+				sub({
+					name,
+					store,
+					args,
+					after,
+					onError
+				});
+			} 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
+Object.defineProperty(exports, 'computed', {
+  enumerable: true,
+  get: function () {
+    return computed;
+  }
+});
+Object.defineProperty(exports, 'createStore', {
+  enumerable: true,
+  get: function () {
+    return createStore;
+  }
+});
+Object.defineProperty(exports, 'customRef', {
+  enumerable: true,
+  get: function () {
+    return customRef;
+  }
+});
+Object.defineProperty(exports, 'defineStore', {
+  enumerable: true,
+  get: function () {
+    return defineStore;
+  }
+});
+Object.defineProperty(exports, 'effect', {
+  enumerable: true,
+  get: function () {
+    return effect;
+  }
+});
+Object.defineProperty(exports, 'isObject', {
+  enumerable: true,
+  get: function () {
+    return isObject$1;
+  }
+});
+Object.defineProperty(exports, 'isRaw', {
+  enumerable: true,
+  get: function () {
+    return isRaw;
+  }
+});
+Object.defineProperty(exports, 'isReactive', {
+  enumerable: true,
+  get: function () {
+    return isReactive;
+  }
+});
+Object.defineProperty(exports, 'isRef', {
+  enumerable: true,
+  get: function () {
+    return isRef;
+  }
+});
+Object.defineProperty(exports, 'isShallowReactive', {
+  enumerable: true,
+  get: function () {
+    return isShallowReactive;
+  }
+});
+Object.defineProperty(exports, 'markRaw', {
+  enumerable: true,
+  get: function () {
+    return markRaw;
+  }
+});
+Object.defineProperty(exports, 'nextTick', {
+  enumerable: true,
+  get: function () {
+    return nextTick;
+  }
+});
+Object.defineProperty(exports, 'queueJob', {
+  enumerable: true,
+  get: function () {
+    return queueJob;
+  }
+});
+Object.defineProperty(exports, 'reactive', {
+  enumerable: true,
+  get: function () {
+    return reactive;
+  }
+});
+Object.defineProperty(exports, 'ref', {
+  enumerable: true,
+  get: function () {
+    return ref;
+  }
+});
+Object.defineProperty(exports, 'shallowReactive', {
+  enumerable: true,
+  get: function () {
+    return shallowReactive;
+  }
+});
+Object.defineProperty(exports, 'stop', {
+  enumerable: true,
+  get: function () {
+    return stop;
+  }
+});
+Object.defineProperty(exports, 'storeToRefs', {
+  enumerable: true,
+  get: function () {
+    return storeToRefs;
+  }
+});
+Object.defineProperty(exports, 'toRaw', {
+  enumerable: true,
+  get: function () {
+    return toRaw;
+  }
+});
+Object.defineProperty(exports, 'touchReactive', {
+  enumerable: true,
+  get: function () {
+    return touchReactive;
+  }
+});
+Object.defineProperty(exports, 'unref', {
+  enumerable: true,
+  get: function () {
+    return unref;
+  }
+});