wevu 6.7.2 → 6.7.4

package/dist/store-DFP_p2kt.mjs

@@ -0,0 +1,504 @@
+import { A as track, C as effect, d as reactive, g as touchReactive, j as trigger, l as isReactive, n as isRef, r as markAsRef, y as toRaw } from "./ref-BeA_Is-2.mjs";
+//#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("计算属性是只读的");
+		};
+	} 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);
+		}
+	};
+	markAsRef(obj);
+	runner = effect(getter, {
+		lazy: true,
+		scheduler: () => {
+			if (!dirty) {
+				dirty = true;
+				trigger(obj, "value");
+			}
+		}
+	});
+	return onlyGetter ? obj : obj;
+}
+//#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 (_unused) {}
+		});
+		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 isPlainObject(val) {
+	if (!isObject(val)) return false;
+	const proto = Object.getPrototypeOf(val);
+	return proto === Object.prototype || proto === null;
+}
+function mergeShallow(target, patch) {
+	for (const k in patch) target[k] = patch[k];
+}
+function cloneDeep(value) {
+	if (Array.isArray(value)) return value.map((item) => cloneDeep(item));
+	if (isPlainObject(value)) {
+		const result = {};
+		for (const key in value) result[key] = cloneDeep(value[key]);
+		return result;
+	}
+	return value;
+}
+function resetObject(target, snapshot) {
+	if (Array.isArray(target) && Array.isArray(snapshot)) {
+		target.length = 0;
+		snapshot.forEach((item, index) => {
+			target[index] = cloneDeep(item);
+		});
+		return;
+	}
+	if (!isObject(snapshot)) return;
+	for (const key in target) if (!(key in snapshot)) delete target[key];
+	for (const key in snapshot) {
+		const snapValue = snapshot[key];
+		const currentValue = target[key];
+		if (Array.isArray(snapValue) && Array.isArray(currentValue)) {
+			resetObject(currentValue, snapValue);
+			continue;
+		}
+		if (isPlainObject(snapValue) && isPlainObject(currentValue)) {
+			resetObject(currentValue, snapValue);
+			continue;
+		}
+		target[key] = cloneDeep(snapValue);
+	}
+}
+//#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/define/shared.ts
+const hasOwn = Object.prototype.hasOwnProperty;
+function isTrackableRef(value) {
+	return isRef(value) && hasOwn.call(value, "dep");
+}
+function snapshotValue(value) {
+	if (isReactive(value)) return cloneDeep(toRaw(value));
+	if (isTrackableRef(value)) return cloneDeep(value.value);
+	return cloneDeep(value);
+}
+function createSafeNotifier(storeId, subs, getState) {
+	let notifying = false;
+	return (type) => {
+		if (notifying) return;
+		notifying = true;
+		try {
+			const state = getState();
+			subs.forEach((cb) => {
+				try {
+					cb({
+						type,
+						storeId
+					}, state);
+				} catch (_unused) {}
+			});
+		} finally {
+			notifying = false;
+		}
+	};
+}
+//#endregion
+//#region src/store/define/optionsStyle.ts
+function createOptionsStyleStore(id, options, manager) {
+	var _options$getters, _options$actions, _manager$_plugins;
+	const rawState = options.state ? options.state() : {};
+	const state = reactive(rawState);
+	const initialSnapshot = cloneDeep(toRaw(rawState));
+	let notify = () => {};
+	const base = createBaseApi(id, state, (t) => notify(t), () => {
+		resetObject(state, initialSnapshot);
+		notify("patch object");
+	});
+	let isPatching = false;
+	const rawPatch = base.api.$patch;
+	base.api.$patch = (patch) => {
+		isPatching = true;
+		try {
+			rawPatch(patch);
+		} finally {
+			isPatching = false;
+		}
+	};
+	if (typeof base.api.$reset === "function") {
+		const rawReset = base.api.$reset;
+		base.api.$reset = () => {
+			isPatching = true;
+			try {
+				rawReset();
+			} finally {
+				isPatching = false;
+			}
+		};
+	}
+	notify = createSafeNotifier(id, base.subs, () => state);
+	const store = {};
+	for (const key of Object.getOwnPropertyNames(base.api)) {
+		const d = Object.getOwnPropertyDescriptor(base.api, key);
+		if (d) if (key === "$state") Object.defineProperty(store, key, {
+			enumerable: d.enumerable,
+			configurable: d.configurable,
+			get() {
+				return base.api.$state;
+			},
+			set(v) {
+				isPatching = true;
+				try {
+					base.api.$state = v;
+				} finally {
+					isPatching = false;
+				}
+			}
+		});
+		else Object.defineProperty(store, key, d);
+	}
+	const getterDefs = (_options$getters = options.getters) !== null && _options$getters !== void 0 ? _options$getters : {};
+	Object.keys(getterDefs).forEach((key) => {
+		const getter = getterDefs[key];
+		if (typeof getter === "function") {
+			const c = computed(() => getter.call(store, state));
+			Object.defineProperty(store, key, {
+				enumerable: true,
+				configurable: true,
+				get() {
+					return c.value;
+				}
+			});
+		}
+	});
+	const actionDefs = (_options$actions = options.actions) !== null && _options$actions !== void 0 ? _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;
+			}
+		});
+	});
+	let initialized = false;
+	let dispatchingDirect = false;
+	effect(() => {
+		touchReactive(state);
+		if (!initialized) {
+			initialized = true;
+			return;
+		}
+		if (isPatching || dispatchingDirect) return;
+		dispatchingDirect = true;
+		try {
+			notify("direct");
+		} finally {
+			dispatchingDirect = false;
+		}
+	});
+	const plugins = (_manager$_plugins = manager === null || manager === void 0 ? void 0 : manager._plugins) !== null && _manager$_plugins !== void 0 ? _manager$_plugins : [];
+	for (const plugin of plugins) try {
+		plugin({ store });
+	} catch (_unused) {}
+	return store;
+}
+//#endregion
+//#region src/store/define/setupStyle.ts
+function createSetupStyleStore(id, setupFactory, manager) {
+	var _manager$_plugins;
+	const result = setupFactory();
+	let notify = () => {};
+	const initialSnapshot = /* @__PURE__ */ new Map();
+	Object.keys(result).forEach((k) => {
+		const val = result[k];
+		if (typeof val === "function" || k.startsWith("$")) return;
+		if (isRef(val) && !isTrackableRef(val)) return;
+		initialSnapshot.set(k, snapshotValue(val));
+	});
+	let instance = {};
+	const resetImpl = () => {
+		initialSnapshot.forEach((snapValue, key) => {
+			const current = instance[key];
+			if (isTrackableRef(current)) {
+				current.value = cloneDeep(snapValue);
+				return;
+			}
+			if (isReactive(current)) {
+				resetObject(current, snapValue);
+				return;
+			}
+			if (isRef(current)) return;
+			instance[key] = cloneDeep(snapValue);
+		});
+		notify("patch object");
+	};
+	const base = createBaseApi(id, void 0, (t) => notify(t), resetImpl);
+	let isPatching = false;
+	const rawPatch = base.api.$patch;
+	base.api.$patch = (patch) => {
+		isPatching = true;
+		try {
+			rawPatch(patch);
+		} finally {
+			isPatching = false;
+		}
+	};
+	if (typeof base.api.$reset === "function") {
+		const rawReset = base.api.$reset;
+		base.api.$reset = () => {
+			isPatching = true;
+			try {
+				rawReset();
+			} finally {
+				isPatching = false;
+			}
+		};
+	}
+	instance = Object.assign({}, result);
+	notify = createSafeNotifier(id, base.subs, () => instance);
+	for (const key of Object.getOwnPropertyNames(base.api)) {
+		const d = Object.getOwnPropertyDescriptor(base.api, key);
+		if (d) if (key === "$state") Object.defineProperty(instance, key, {
+			enumerable: d.enumerable,
+			configurable: d.configurable,
+			get() {
+				return base.api.$state;
+			},
+			set(v) {
+				isPatching = true;
+				try {
+					base.api.$state = v;
+				} finally {
+					isPatching = false;
+				}
+			}
+		});
+		else Object.defineProperty(instance, key, d);
+	}
+	const directSources = [];
+	Object.keys(result).forEach((k) => {
+		const val = result[k];
+		if (typeof val === "function" && !k.startsWith("$")) {
+			instance[k] = wrapAction(instance, k, val, base.actionSubs);
+			return;
+		}
+		if (isTrackableRef(val)) {
+			directSources.push(val);
+			return;
+		}
+		if (isReactive(val)) {
+			directSources.push(val);
+			return;
+		}
+		if (isRef(val)) return;
+		if (!k.startsWith("$")) {
+			let innerValue = val;
+			Object.defineProperty(instance, k, {
+				enumerable: true,
+				configurable: true,
+				get() {
+					return innerValue;
+				},
+				set(next) {
+					innerValue = next;
+					if (!isPatching) notify("direct");
+				}
+			});
+		}
+	});
+	let dispatchingDirect = false;
+	if (directSources.length > 0) {
+		let initialized = false;
+		effect(() => {
+			directSources.forEach((source) => {
+				if (isTrackableRef(source)) source.value;
+				else touchReactive(source);
+			});
+			if (!initialized) {
+				initialized = true;
+				return;
+			}
+			if (isPatching || dispatchingDirect) return;
+			dispatchingDirect = true;
+			try {
+				notify("direct");
+			} finally {
+				dispatchingDirect = false;
+			}
+		});
+	}
+	const plugins = (_manager$_plugins = manager === null || manager === void 0 ? void 0 : manager._plugins) !== null && _manager$_plugins !== void 0 ? _manager$_plugins : [];
+	for (const plugin of plugins) try {
+		plugin({ store: instance });
+	} catch (_unused) {}
+	return instance;
+}
+//#endregion
+//#region src/store/manager.ts
+/**
+* @description 创建 store 管理器（插件与共享实例入口）
+*/
+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;
+		instance = typeof setupOrOptions === "function" ? createSetupStyleStore(id, setupOrOptions, manager) : createOptionsStyleStore(id, setupOrOptions, manager);
+		return instance;
+	};
+}
+//#endregion
+//#region src/store/storeToRefs.ts
+/**
+* @description 将 store 状态转换为 Ref
+*/
+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 { computed as i, defineStore as n, createStore as r, storeToRefs as t };

package/dist/store.d.mts

@@ -0,0 +1,2 @@
+import { a as ActionContext, c as MutationType, d as SubscriptionCallback, i as defineStore, l as StoreManager, n as storeToRefs, o as ActionSubscriber, r as createStore, s as DefineStoreOptions, t as StoreToRefsResult, u as StoreSubscribeOptions } from "./index-Ciz2Ye1L.mjs";
+export { ActionContext, ActionSubscriber, DefineStoreOptions, MutationType, StoreManager, StoreSubscribeOptions, StoreToRefsResult, SubscriptionCallback, createStore, defineStore, storeToRefs };

package/dist/store.mjs

@@ -0,0 +1,2 @@
+import { n as defineStore, r as createStore, t as storeToRefs } from "./store-DFP_p2kt.mjs";
+export { createStore, defineStore, storeToRefs };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wevu",
   "type": "module",
-  "version": "6.7.2",
+  "version": "6.7.4",
   "description": "Vue 3 风格的小程序运行时，包含响应式、diff+setData 与轻量状态管理",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -47,6 +47,34 @@
         "types": "./dist/jsx-runtime.d.mts",
         "default": "./dist/jsx-runtime.mjs"
       }
+    },
+    "./store": {
+      "types": "./dist/store.d.mts",
+      "import": {
+        "types": "./dist/store.d.mts",
+        "default": "./dist/store.mjs"
+      }
+    },
+    "./api": {
+      "types": "./dist/api.d.mts",
+      "import": {
+        "types": "./dist/api.d.mts",
+        "default": "./dist/api.mjs"
+      }
+    },
+    "./fetch": {
+      "types": "./dist/fetch.d.mts",
+      "import": {
+        "types": "./dist/fetch.d.mts",
+        "default": "./dist/fetch.mjs"
+      }
+    },
+    "./router": {
+      "types": "./dist/router.d.mts",
+      "import": {
+        "types": "./dist/router.d.mts",
+        "default": "./dist/router.mjs"
+      }
     }
   },
   "main": "./dist/index.mjs",
@@ -67,7 +95,8 @@
   },
   "dependencies": {
     "vue": "^3.5.29",
-    "@wevu/compiler": "6.7.2"
+    "@wevu/api": "0.2.0",
+    "@wevu/compiler": "6.7.4"
   },
   "scripts": {
     "dev": "tsdown -w",