@composy/store-vue 0.0.1

package/dist/index.js

@@ -0,0 +1,1536 @@
+/*!
+* ***********************************
+* @composy/store-vue v0.0.1       *
+* Built with rollup               *
+* Build time: 2024-08-17 11:39:29 *
+* Build mode: production          *
+* Minified: No                    *
+* ***********************************
+*/
+"use strict";
+(function(global, factory) {
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("pinia"), require("vue"), require("@composy/store-core"), require("@composy/store-core/engine")) : typeof define === "function" && define.amd ? define([
+		"exports",
+		"pinia",
+		"vue",
+		"@composy/store-core",
+		"@composy/store-core/engine"
+	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.LDesignStoreVue = {}, global.Pinia, global.Vue, global.ComposyStoreCore, global.ComposyStoreCore));
+})(this, function(exports, pinia, vue, _composy_store_core, _composy_store_core_engine) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region src/composables/defineSetupStore.ts
+	function defineSetupStore(id, setup) {
+		return (0, pinia.defineStore)(id, setup);
+	}
+	function createStoreState(initial) {
+		const result = {};
+		for (const key of Object.keys(initial)) result[key] = (0, vue.ref)(initial[key]);
+		return result;
+	}
+	function createStoreGetters(getters) {
+		const result = {};
+		for (const key of Object.keys(getters)) result[key] = (0, vue.computed)(getters[key]);
+		return result;
+	}
+	//#endregion
+	//#region src/composables/useFormStore.ts
+	const DEFAULT_REQUIRED_MESSAGE = "此字段为必填项";
+	const DEFAULT_PATTERN_MESSAGE = "格式不正确";
+	const DEFAULT_EMAIL_MESSAGE = "邮箱格式不正确";
+	const EMAIL_PATTERN = /^[^\s@]+@[^@][^.@]*\.[^\s@]+$/;
+	function useFormStore(options) {
+		const { initialValues, validationRules = {}, onSubmit, validateOn = "blur" } = options;
+		const storedInitialValues = (0, _composy_store_core.deepClone)(initialValues);
+		const values = (0, vue.reactive)((0, _composy_store_core.deepClone)(storedInitialValues));
+		const valueRecord = values;
+		const initialValueRecord = storedInitialValues;
+		const fieldKeys = Object.keys(storedInitialValues);
+		const fields = (0, vue.reactive)(fieldKeys.reduce((acc, key) => {
+			acc[key] = {
+				touched: false,
+				dirty: false,
+				error: null,
+				validating: false
+			};
+			return acc;
+		}, {}));
+		const isSubmitting = (0, vue.ref)(false);
+		const submitError = (0, vue.ref)(null);
+		const submitCount = (0, vue.ref)(0);
+		const isDirty = (0, vue.computed)(() => fieldKeys.some((key) => fields[key]?.dirty));
+		const isValid = (0, vue.computed)(() => fieldKeys.every((key) => !fields[key]?.error));
+		const errors = (0, vue.computed)(() => {
+			return fieldKeys.reduce((acc, key) => {
+				acc[key] = fields[key]?.error ?? null;
+				return acc;
+			}, {});
+		});
+		fieldKeys.forEach((key) => {
+			(0, vue.watch)(() => valueRecord[key], (newValue) => {
+				const field = fields[key];
+				if (field) field.dirty = !(0, _composy_store_core.deepEqual)(newValue, initialValueRecord[key]);
+				if (validateOn === "change" && field?.touched) validateField(key);
+			}, { deep: true });
+		});
+		function setFieldValue(field, value) {
+			valueRecord[field] = value;
+		}
+		function setFieldTouched(field) {
+			const fieldState = fields[field];
+			if (fieldState) fieldState.touched = true;
+			if (validateOn === "blur") validateField(field);
+		}
+		async function validateField(field) {
+			const fieldState = fields[field];
+			if (!fieldState) return null;
+			const fieldRules = validationRules[field];
+			if (!fieldRules) {
+				fieldState.error = null;
+				return null;
+			}
+			fieldState.validating = true;
+			try {
+				const value = values[field];
+				if (fieldRules.required) {
+					if (value === "" || value === null || value === void 0) {
+						const message = typeof fieldRules.required === "string" ? fieldRules.required : DEFAULT_REQUIRED_MESSAGE;
+						fieldState.error = message;
+						return message;
+					}
+				}
+				if (fieldRules.rules) for (const rule of fieldRules.rules) {
+					const error = await rule(value, valueRecord);
+					if (error) {
+						fieldState.error = error;
+						return error;
+					}
+				}
+				fieldState.error = null;
+				return null;
+			} finally {
+				fieldState.validating = false;
+			}
+		}
+		async function validateAll() {
+			return (await Promise.all(fieldKeys.map((key) => validateField(key)))).every((result) => result === null);
+		}
+		async function handleSubmit() {
+			submitCount.value++;
+			submitError.value = null;
+			fieldKeys.forEach((key) => {
+				const field = fields[key];
+				if (field) field.touched = true;
+			});
+			if (!await validateAll() || !onSubmit) return;
+			isSubmitting.value = true;
+			try {
+				await onSubmit((0, _composy_store_core.deepClone)(values));
+			} catch (error) {
+				submitError.value = error instanceof Error ? error.message : String(error);
+			} finally {
+				isSubmitting.value = false;
+			}
+		}
+		function reset(newInitialValues) {
+			if (newInitialValues) Object.assign(initialValueRecord, (0, _composy_store_core.deepClone)(newInitialValues));
+			fieldKeys.forEach((key) => {
+				valueRecord[key] = (0, _composy_store_core.deepClone)(initialValueRecord[key]);
+				const field = fields[key];
+				if (field) {
+					field.touched = false;
+					field.dirty = false;
+					field.error = null;
+					field.validating = false;
+				}
+			});
+			submitError.value = null;
+		}
+		function resetField(field) {
+			const fieldKey = field;
+			valueRecord[fieldKey] = (0, _composy_store_core.deepClone)(initialValueRecord[fieldKey]);
+			const fieldState = fields[fieldKey];
+			if (fieldState) {
+				fieldState.touched = false;
+				fieldState.dirty = false;
+				fieldState.error = null;
+				fieldState.validating = false;
+			}
+		}
+		return {
+			values,
+			fields,
+			isDirty,
+			isValid,
+			isSubmitting,
+			submitError,
+			submitCount,
+			setFieldValue,
+			setFieldTouched,
+			validateField,
+			validateAll,
+			handleSubmit,
+			reset,
+			resetField,
+			errors
+		};
+	}
+	function required(message = DEFAULT_REQUIRED_MESSAGE) {
+		return (value) => {
+			if (value === "" || value === null || value === void 0) return message;
+			return null;
+		};
+	}
+	function minLength(min, message) {
+		return (value) => {
+			if (typeof value === "string" && value.length < min) return message ?? `\u81F3\u5C11\u9700\u8981 ${min} \u4E2A\u5B57\u7B26`;
+			return null;
+		};
+	}
+	function maxLength(max, message) {
+		return (value) => {
+			if (typeof value === "string" && value.length > max) return message ?? `\u4E0D\u80FD\u8D85\u8FC7 ${max} \u4E2A\u5B57\u7B26`;
+			return null;
+		};
+	}
+	function pattern(regex, message = DEFAULT_PATTERN_MESSAGE) {
+		return (value) => {
+			if (typeof value === "string" && !regex.test(value)) return message;
+			return null;
+		};
+	}
+	function email(message = DEFAULT_EMAIL_MESSAGE) {
+		return pattern(EMAIL_PATTERN, message);
+	}
+	function numberRange(min, max, message) {
+		return (value) => {
+			if (typeof value === "number" && (value < min || value > max)) return message ?? `\u5FC5\u987B\u5728 ${min} \u5230 ${max} \u4E4B\u95F4`;
+			return null;
+		};
+	}
+	//#endregion
+	//#region src/composables/useOptimistic.ts
+	function uid() {
+		return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+	}
+	function useOptimistic(initialState) {
+		const state = (0, vue.ref)((0, _composy_store_core.deepClone)(initialState));
+		const isPending = (0, vue.ref)(false);
+		const isRolledBack = (0, vue.ref)(false);
+		const pending = (0, vue.ref)([]);
+		async function mutate(optimisticValue, confirm) {
+			const snapshot = (0, _composy_store_core.deepClone)(state.value);
+			const entryId = uid();
+			const entry = {
+				id: entryId,
+				snapshot,
+				status: "pending",
+				timestamp: Date.now()
+			};
+			pending.value = [...pending.value, entry];
+			isPending.value = true;
+			isRolledBack.value = false;
+			if (typeof optimisticValue === "function") state.value = optimisticValue(state.value);
+			else state.value = optimisticValue;
+			try {
+				await confirm();
+				pending.value = pending.value.map((e) => e.id === entryId ? {
+					...e,
+					status: "confirmed"
+				} : e);
+			} catch {
+				state.value = snapshot;
+				isRolledBack.value = true;
+				pending.value = pending.value.map((e) => e.id === entryId ? {
+					...e,
+					status: "rolled-back"
+				} : e);
+			} finally {
+				pending.value = pending.value.filter((e) => e.status === "pending");
+				isPending.value = pending.value.length > 0;
+			}
+		}
+		return {
+			state,
+			isPending,
+			pending,
+			isRolledBack,
+			mutate
+		};
+	}
+	//#endregion
+	//#region src/composables/usePersist.ts
+	function getStorage$2(type) {
+		if (typeof window === "undefined") return null;
+		return type === "localStorage" ? localStorage : sessionStorage;
+	}
+	function usePersist(options) {
+		const { key, storage: storageType = "localStorage", defaultValue, serialize = JSON.stringify, deserialize = JSON.parse } = options;
+		const storage = getStorage$2(storageType);
+		const value = (0, vue.ref)(defaultValue);
+		const restore = () => {
+			if (!storage) return;
+			try {
+				const stored = storage.getItem(key);
+				if (stored !== null) value.value = deserialize(stored);
+			} catch (error) {
+				console.error(`[usePersist] \u6062\u590D\u5931\u8D25 (${key}):`, error);
+			}
+		};
+		const save = () => {
+			if (!storage) return;
+			try {
+				storage.setItem(key, serialize(value.value));
+			} catch (error) {
+				console.error(`[usePersist] \u4FDD\u5B58\u5931\u8D25 (${key}):`, error);
+			}
+		};
+		const clear = () => {
+			if (!storage) return;
+			try {
+				storage.removeItem(key);
+				value.value = defaultValue;
+			} catch (error) {
+				console.error(`[usePersist] \u6E05\u9664\u5931\u8D25 (${key}):`, error);
+			}
+		};
+		(0, vue.onMounted)(() => {
+			restore();
+		});
+		(0, vue.watch)(value, () => {
+			save();
+		}, { deep: true });
+		return {
+			value,
+			save,
+			restore,
+			clear
+		};
+	}
+	function usePersistedRef(key, defaultValue, storage = "localStorage") {
+		const { value } = usePersist({
+			key,
+			storage,
+			defaultValue
+		});
+		return value;
+	}
+	function usePersistedRefWithTTL(key, defaultValue, ttl) {
+		const { value } = usePersist({
+			key,
+			defaultValue: {
+				value: defaultValue,
+				expiry: 0
+			},
+			serialize: (data) => JSON.stringify(data),
+			deserialize: (str) => {
+				const data = JSON.parse(str);
+				if (data.expiry && Date.now() > data.expiry) return {
+					value: defaultValue,
+					expiry: 0
+				};
+				return data;
+			}
+		});
+		const wrappedRef = (0, vue.ref)(value.value.value);
+		(0, vue.watch)(wrappedRef, (newValue) => {
+			value.value = {
+				value: newValue,
+				expiry: Date.now() + ttl
+			};
+		});
+		return wrappedRef;
+	}
+	//#endregion
+	//#region src/composables/usePersistedState.ts
+	function defaultSerializer(value) {
+		return JSON.stringify(value);
+	}
+	function defaultDeserializer(value) {
+		try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+	}
+	function getStorage$1(type) {
+		if (typeof window === "undefined") return null;
+		return type === "localStorage" ? window.localStorage : window.sessionStorage;
+	}
+	function usePersistedState(options) {
+		const { key, storage: storageType = "localStorage", defaultValue, serializer = defaultSerializer, deserializer = defaultDeserializer, syncTabs = false, debounce: debounceDelay = 0, deep = true, ttl, onBeforeChange, onAfterChange, onBeforeRestore, onAfterRestore } = options;
+		const storage = getStorage$1(storageType);
+		const createDefaultValue = () => (0, _composy_store_core.deepClone)(defaultValue);
+		const state = (0, vue.ref)(createDefaultValue());
+		const save = () => {
+			if (!storage) return;
+			try {
+				const item = {
+					value: serializer(state.value),
+					timestamp: Date.now(),
+					expiresAt: ttl ? Date.now() + ttl : void 0
+				};
+				storage.setItem(key, JSON.stringify(item));
+			} catch (error) {
+				console.error(`[usePersistedState] \u4FDD\u5B58\u5931\u8D25 (${key}):`, error);
+			}
+		};
+		const clear = () => {
+			if (!storage) return;
+			try {
+				storage.removeItem(key);
+			} catch (error) {
+				console.error(`[usePersistedState] \u6E05\u9664\u5931\u8D25 (${key}):`, error);
+			}
+		};
+		const restore = () => {
+			if (!storage) return;
+			try {
+				const stored = storage.getItem(key);
+				if (!stored) return;
+				const item = JSON.parse(stored);
+				if (item.expiresAt && Date.now() > item.expiresAt) {
+					clear();
+					return;
+				}
+				let value = deserializer(item.value);
+				if (onBeforeRestore) value = onBeforeRestore(value);
+				state.value = value;
+				onAfterRestore?.(value);
+			} catch (error) {
+				console.error(`[usePersistedState] \u6062\u590D\u5931\u8D25 (${key}):`, error);
+			}
+		};
+		const reset = () => {
+			state.value = createDefaultValue();
+			clear();
+		};
+		const isExpired = () => {
+			if (!storage || !ttl) return false;
+			try {
+				const stored = storage.getItem(key);
+				if (!stored) return false;
+				const item = JSON.parse(stored);
+				return item.expiresAt ? Date.now() > item.expiresAt : false;
+			} catch {
+				return false;
+			}
+		};
+		const debouncedSave = debounceDelay > 0 ? (0, _composy_store_core.debounce)(save, debounceDelay) : null;
+		const handleStorageEvent = (event) => {
+			if (event.key !== key || !event.newValue) return;
+			try {
+				const item = JSON.parse(event.newValue);
+				if (item.expiresAt && Date.now() > item.expiresAt) return;
+				state.value = deserializer(item.value);
+			} catch (error) {
+				console.error(`[usePersistedState] \u540C\u6B65\u5931\u8D25 (${key}):`, error);
+			}
+		};
+		restore();
+		(0, vue.watch)(state, (newValue, oldValue) => {
+			if (onBeforeChange?.(newValue, oldValue) === false) return;
+			if (debouncedSave) debouncedSave();
+			else save();
+			onAfterChange?.(newValue, oldValue);
+		}, { deep });
+		if (syncTabs && typeof window !== "undefined") window.addEventListener("storage", handleStorageEvent);
+		(0, vue.onUnmounted)(() => {
+			debouncedSave?.cancel();
+			if (syncTabs && typeof window !== "undefined") window.removeEventListener("storage", handleStorageEvent);
+		});
+		return {
+			state,
+			save,
+			restore,
+			clear,
+			reset,
+			isExpired
+		};
+	}
+	//#endregion
+	//#region src/composables/useSharedState.ts
+	function useSharedState(channelName, initialState, options = {}) {
+		const { immediate = false, deep = true } = options;
+		const state = (0, vue.ref)((0, _composy_store_core.deepClone)(initialState));
+		const peerCount = (0, vue.ref)(0);
+		const lastSyncAt = (0, vue.ref)(null);
+		let channel = null;
+		let isReceiving = false;
+		if (typeof BroadcastChannel === "undefined") {
+			console.warn("[useSharedState] BroadcastChannel not supported in this environment");
+			return {
+				state,
+				broadcast: () => {},
+				peerCount,
+				lastSyncAt,
+				close: () => {}
+			};
+		}
+		try {
+			channel = new BroadcastChannel(channelName);
+		} catch (e) {
+			console.warn("[useSharedState] Failed to create BroadcastChannel:", e);
+			return {
+				state,
+				broadcast: () => {},
+				peerCount,
+				lastSyncAt,
+				close: () => {}
+			};
+		}
+		function broadcast() {
+			if (!channel) return;
+			try {
+				channel.postMessage({
+					type: "state-update",
+					payload: (0, _composy_store_core.deepClone)(state.value),
+					timestamp: Date.now()
+				});
+			} catch (e) {
+				console.warn("[useSharedState] broadcast error:", e);
+			}
+		}
+		channel.onmessage = (event) => {
+			const msg = event.data;
+			if (!msg || typeof msg !== "object") return;
+			if (msg.type === "state-update") {
+				isReceiving = true;
+				state.value = msg.payload;
+				lastSyncAt.value = msg.timestamp || Date.now();
+				isReceiving = false;
+			} else if (msg.type === "ping") channel?.postMessage({ type: "pong" });
+			else if (msg.type === "pong") peerCount.value++;
+		};
+		const stopWatch = (0, vue.watch)(state, () => {
+			if (!isReceiving) broadcast();
+		}, { deep });
+		function close() {
+			stopWatch();
+			if (channel) {
+				channel.close();
+				channel = null;
+			}
+		}
+		if (immediate) broadcast();
+		if (channel) {
+			peerCount.value = 0;
+			channel.postMessage({ type: "ping" });
+		}
+		(0, vue.onUnmounted)(() => {
+			close();
+		});
+		return {
+			state,
+			broadcast,
+			peerCount,
+			lastSyncAt,
+			close
+		};
+	}
+	//#endregion
+	//#region src/composables/useStore.ts
+	function useStore(useStoreHook, _options = {}) {
+		const store = useStoreHook();
+		const refs = (0, pinia.storeToRefs)(store);
+		const reset = () => {
+			if ("$reset" in store && typeof store.$reset === "function") store.$reset();
+		};
+		const patch = (partial) => {
+			if ("$patch" in store && typeof store.$patch === "function") store.$patch(partial);
+		};
+		return {
+			store,
+			refs,
+			reset,
+			patch
+		};
+	}
+	function useSimpleStore(initialState) {
+		const state = (0, vue.ref)({ ...initialState });
+		const initialStateCopy = { ...initialState };
+		const setState = (partial) => {
+			Object.assign(state.value, partial);
+		};
+		const reset = () => {
+			state.value = { ...initialStateCopy };
+		};
+		const subscribe = (callback) => {
+			return (0, vue.watch)(state, (newState) => {
+				callback(newState);
+			}, { deep: true });
+		};
+		return {
+			state,
+			setState,
+			reset,
+			subscribe
+		};
+	}
+	function useComputedStore(state, getters) {
+		const computedGetters = {};
+		for (const key in getters) computedGetters[key] = (0, vue.computed)(() => getters[key](state.value));
+		return {
+			state,
+			getters: computedGetters
+		};
+	}
+	//#endregion
+	//#region src/composables/useStoreDevtools.ts
+	const STORE_REFRESH_EVENTS = /* @__PURE__ */ new Set([
+		"store:created",
+		"store:disposed",
+		"state:changed"
+	]);
+	function formatTime(timestamp) {
+		const date = new Date(timestamp);
+		return `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}:${date.getSeconds().toString().padStart(2, "0")}.${date.getMilliseconds().toString().padStart(3, "0")}`;
+	}
+	function getPinia() {
+		return (0, pinia.getActivePinia)() ?? null;
+	}
+	function snapshotStore(store, id) {
+		return {
+			id,
+			state: (0, _composy_store_core.deepClone)(store.$state),
+			active: true
+		};
+	}
+	function useStoreDevtools(options = {}) {
+		const { maxLogEntries = 200 } = options;
+		const stores = (0, vue.ref)([]);
+		const eventLog = (0, vue.ref)([]);
+		const isMonitoring = (0, vue.ref)(false);
+		let unsubscribe = null;
+		function refreshStores() {
+			const pinia$2 = getPinia();
+			if (!pinia$2?._s) {
+				stores.value = [];
+				return;
+			}
+			stores.value = Array.from(pinia$2._s.entries(), ([id, store]) => {
+				return snapshotStore(store, id);
+			});
+		}
+		function startMonitoring() {
+			if (isMonitoring.value) return;
+			isMonitoring.value = true;
+			unsubscribe = _composy_store_core.globalEventBus.on("*", (data) => {
+				const entry = {
+					type: data.type,
+					payload: data.payload,
+					timestamp: data.timestamp,
+					time: formatTime(data.timestamp)
+				};
+				eventLog.value = [entry, ...eventLog.value].slice(0, maxLogEntries);
+				if (STORE_REFRESH_EVENTS.has(data.type)) refreshStores();
+			});
+		}
+		function stopMonitoring() {
+			if (!isMonitoring.value) return;
+			isMonitoring.value = false;
+			unsubscribe?.();
+			unsubscribe = null;
+		}
+		function clearLog() {
+			eventLog.value = [];
+		}
+		function getStoreState(id) {
+			const store = getPinia()?._s?.get(id);
+			if (!store) return null;
+			return (0, _composy_store_core.deepClone)(store.$state);
+		}
+		function resetStore(id) {
+			const store = getPinia()?._s?.get(id);
+			if (!store || typeof store.$reset !== "function") return false;
+			store.$reset();
+			refreshStores();
+			return true;
+		}
+		function resetAllStores() {
+			const pinia$3 = getPinia();
+			if (!pinia$3?._s) return;
+			pinia$3._s.forEach((store) => {
+				if (typeof store.$reset === "function") store.$reset();
+			});
+			refreshStores();
+		}
+		refreshStores();
+		(0, vue.onUnmounted)(() => {
+			stopMonitoring();
+		});
+		return {
+			stores,
+			eventLog,
+			isMonitoring,
+			startMonitoring,
+			stopMonitoring,
+			clearLog,
+			refreshStores,
+			getStoreState,
+			resetStore,
+			resetAllStores
+		};
+	}
+	//#endregion
+	//#region src/composables/useStoreSnapshot.ts
+	function generateId() {
+		return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+	}
+	function computeDiff(oldObj, newObj, path = "") {
+		const diffs = [];
+		if (typeof oldObj !== typeof newObj) {
+			diffs.push({
+				path: path || ".",
+				oldValue: oldObj,
+				newValue: newObj,
+				type: "change"
+			});
+			return diffs;
+		}
+		if (typeof oldObj !== "object" || oldObj === null || newObj === null) {
+			if (!Object.is(oldObj, newObj)) diffs.push({
+				path: path || ".",
+				oldValue: oldObj,
+				newValue: newObj,
+				type: "change"
+			});
+			return diffs;
+		}
+		if (Array.isArray(oldObj) && Array.isArray(newObj)) {
+			const maxLen = Math.max(oldObj.length, newObj.length);
+			for (let i = 0; i < maxLen; i++) {
+				const itemPath = path ? `${path}[${i}]` : `[${i}]`;
+				if (i >= oldObj.length) diffs.push({
+					path: itemPath,
+					oldValue: void 0,
+					newValue: newObj[i],
+					type: "add"
+				});
+				else if (i >= newObj.length) diffs.push({
+					path: itemPath,
+					oldValue: oldObj[i],
+					newValue: void 0,
+					type: "remove"
+				});
+				else diffs.push(...computeDiff(oldObj[i], newObj[i], itemPath));
+			}
+			return diffs;
+		}
+		const oldKeys = new Set(Object.keys(oldObj));
+		const newKeys = new Set(Object.keys(newObj));
+		for (const key of newKeys) if (!oldKeys.has(key)) diffs.push({
+			path: path ? `${path}.${key}` : key,
+			oldValue: void 0,
+			newValue: newObj[key],
+			type: "add"
+		});
+		for (const key of oldKeys) if (!newKeys.has(key)) diffs.push({
+			path: path ? `${path}.${key}` : key,
+			oldValue: oldObj[key],
+			newValue: void 0,
+			type: "remove"
+		});
+		for (const key of oldKeys) if (newKeys.has(key)) diffs.push(...computeDiff(oldObj[key], newObj[key], path ? `${path}.${key}` : key));
+		return diffs;
+	}
+	function useStoreSnapshot(state, setState, options = {}) {
+		const { maxSnapshots = 100, autoRecord = false, debounceMs = 300, deep = true } = options;
+		const snapshots = (0, vue.ref)([]);
+		const currentIndex = (0, vue.ref)(-1);
+		let debounceTimer;
+		let isRestoring = false;
+		const getState = () => {
+			return typeof state === "function" ? state() : state.value;
+		};
+		const canUndo = (0, vue.computed)(() => currentIndex.value > 0);
+		const canRedo = (0, vue.computed)(() => currentIndex.value < snapshots.value.length - 1);
+		const takeSnapshot = (label, meta) => {
+			const currentState = getState();
+			const snapshot = {
+				id: generateId(),
+				state: (0, _composy_store_core.deepClone)(currentState),
+				timestamp: Date.now(),
+				label,
+				meta
+			};
+			if (currentIndex.value < snapshots.value.length - 1) snapshots.value = snapshots.value.slice(0, currentIndex.value + 1);
+			snapshots.value.push(snapshot);
+			currentIndex.value = snapshots.value.length - 1;
+			if (snapshots.value.length > maxSnapshots) {
+				snapshots.value.shift();
+				currentIndex.value--;
+			}
+			return snapshot;
+		};
+		const restoreSnapshot = (id) => {
+			const index = snapshots.value.findIndex((s) => s.id === id);
+			if (index === -1) return false;
+			isRestoring = true;
+			try {
+				setState((0, _composy_store_core.deepClone)(snapshots.value[index].state));
+				currentIndex.value = index;
+				return true;
+			} finally {
+				isRestoring = false;
+			}
+		};
+		const undo = () => {
+			if (!canUndo.value) return false;
+			currentIndex.value--;
+			isRestoring = true;
+			try {
+				setState((0, _composy_store_core.deepClone)(snapshots.value[currentIndex.value].state));
+				return true;
+			} finally {
+				isRestoring = false;
+			}
+		};
+		const redo = () => {
+			if (!canRedo.value) return false;
+			currentIndex.value++;
+			isRestoring = true;
+			try {
+				setState((0, _composy_store_core.deepClone)(snapshots.value[currentIndex.value].state));
+				return true;
+			} finally {
+				isRestoring = false;
+			}
+		};
+		const goto = (index) => {
+			if (index < 0 || index >= snapshots.value.length) return false;
+			currentIndex.value = index;
+			isRestoring = true;
+			try {
+				setState((0, _composy_store_core.deepClone)(snapshots.value[index].state));
+				return true;
+			} finally {
+				isRestoring = false;
+			}
+		};
+		const clearSnapshots = () => {
+			snapshots.value = [];
+			currentIndex.value = -1;
+		};
+		const getDiff = (snapshotId1, snapshotId2) => {
+			const snapshot1 = snapshots.value.find((s) => s.id === snapshotId1);
+			const snapshot2 = snapshots.value.find((s) => s.id === snapshotId2);
+			if (!snapshot1 || !snapshot2) return [];
+			return computeDiff(snapshot1.state, snapshot2.state);
+		};
+		const exportSnapshots = () => {
+			return JSON.stringify({
+				snapshots: snapshots.value,
+				currentIndex: currentIndex.value,
+				exportedAt: Date.now()
+			});
+		};
+		const importSnapshots = (data) => {
+			try {
+				const parsed = JSON.parse(data);
+				if (!Array.isArray(parsed.snapshots)) return false;
+				snapshots.value = parsed.snapshots;
+				currentIndex.value = Math.min(parsed.currentIndex ?? snapshots.value.length - 1, snapshots.value.length - 1);
+				return true;
+			} catch {
+				return false;
+			}
+		};
+		if (autoRecord) {
+			const stopWatch = (0, vue.watch)(typeof state === "function" ? (0, vue.computed)(state) : state, (newState, oldState) => {
+				if (isRestoring) return;
+				if ((0, _composy_store_core.deepEqual)(newState, oldState)) return;
+				if (debounceTimer) clearTimeout(debounceTimer);
+				debounceTimer = setTimeout(() => {
+					takeSnapshot();
+				}, debounceMs);
+			}, { deep });
+			takeSnapshot("初始状态");
+			(0, vue.onUnmounted)(() => {
+				stopWatch();
+				if (debounceTimer) clearTimeout(debounceTimer);
+			});
+		}
+		return {
+			snapshots,
+			currentIndex,
+			canUndo,
+			canRedo,
+			takeSnapshot,
+			restoreSnapshot,
+			undo,
+			redo,
+			goto,
+			clearSnapshots,
+			getDiff,
+			exportSnapshots,
+			importSnapshots
+		};
+	}
+	//#endregion
+	//#region src/composables/useSubscribe.ts
+	function useSubscribe(store, callback, options = {}) {
+		const { detached = false } = options;
+		if (store.$subscribe) {
+			const unsubscribe = store.$subscribe((mutation, state) => {
+				callback(mutation, state);
+			}, { detached });
+			if (!detached) (0, vue.onUnmounted)(() => {
+				unsubscribe();
+			});
+			return unsubscribe;
+		}
+		console.warn("[useSubscribe] Store 不支持 $subscribe 方法");
+		return () => {};
+	}
+	function useOnAction(store, callback, detached = false) {
+		if (store.$onAction) {
+			const unsubscribe = store.$onAction(callback, detached);
+			if (!detached) (0, vue.onUnmounted)(() => {
+				unsubscribe();
+			});
+			return unsubscribe;
+		}
+		console.warn("[useOnAction] Store 不支持 $onAction 方法");
+		return () => {};
+	}
+	function useWatch(source, callback, options = {}) {
+		const { immediate = false, deep = false, detached = false } = options;
+		const stop = (0, vue.watch)(source, (newValue, oldValue) => {
+			callback(newValue, oldValue);
+		}, {
+			immediate,
+			deep
+		});
+		if (!detached) (0, vue.onUnmounted)(() => {
+			stop();
+		});
+		return stop;
+	}
+	//#endregion
+	//#region src/context/injection-keys.ts
+	const STORE_API_SYMBOL = /* @__PURE__ */ Symbol("ldesign-store-api");
+	const STORE_PINIA_SYMBOL = /* @__PURE__ */ Symbol("ldesign-store-pinia");
+	const STORE_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol("ldesign-store-runtime");
+	//#endregion
+	//#region src/plugins/pinia-plugin.ts
+	const STORE_PERSIST_DISPOSE_KEY = /* @__PURE__ */ Symbol("ldesign-store-persist-dispose");
+	const activePersistControllers = /* @__PURE__ */ new Set();
+	function getStorage(type) {
+		if (typeof window === "undefined") return null;
+		return type === "localStorage" ? window.localStorage : window.sessionStorage;
+	}
+	function normalizePersistConfig(value) {
+		if (!value) return null;
+		return typeof value === "boolean" ? {} : value;
+	}
+	function filterState(state, includePaths, excludePaths) {
+		if (includePaths?.length) {
+			const pickedState = {};
+			includePaths.forEach((path) => {
+				const value = (0, _composy_store_core.getByPath)(state, path);
+				if (value !== void 0) (0, _composy_store_core.setByPath)(pickedState, path, (0, _composy_store_core.deepClone)(value));
+			});
+			return pickedState;
+		}
+		if (excludePaths?.length) {
+			const nextState = (0, _composy_store_core.deepClone)(state);
+			excludePaths.forEach((path) => {
+				(0, _composy_store_core.deleteByPath)(nextState, path);
+			});
+			return nextState;
+		}
+		return (0, _composy_store_core.deepClone)(state);
+	}
+	function restoreStoreState(store, nextState) {
+		store.$patch((state) => {
+			(0, _composy_store_core.deepMerge)(state, nextState);
+		});
+	}
+	function patchPersistDispose(store, cleanup) {
+		const restorePatchedDispose = store[STORE_PERSIST_DISPOSE_KEY];
+		if (restorePatchedDispose) restorePatchedDispose();
+		const originalDispose = store.$dispose;
+		store.$dispose = function patchedDispose() {
+			cleanup();
+			return originalDispose.call(this);
+		};
+		store[STORE_PERSIST_DISPOSE_KEY] = () => {
+			store.$dispose = originalDispose;
+			delete store[STORE_PERSIST_DISPOSE_KEY];
+		};
+	}
+	function createPersistPluginController(options = {}) {
+		const { storage: defaultStorage = "localStorage", keyPrefix = "ldesign-store:", debounce: debounceDelay = 100, debug = false, syncTabs: defaultSyncTabs = false, defaultTTL } = options;
+		const cleanupMap = /* @__PURE__ */ new Map();
+		const dispose = () => {
+			cleanupMap.forEach((cleanup) => cleanup());
+			cleanupMap.clear();
+			activePersistControllers.delete(dispose);
+		};
+		activePersistControllers.add(dispose);
+		const plugin = (context) => {
+			const { store, options: storeOptions } = context;
+			const config = normalizePersistConfig(storeOptions.persist);
+			if (!config) return;
+			const storage = getStorage(config.storage === "sessionStorage" ? "sessionStorage" : defaultStorage);
+			const serializer = config.serializer?.serialize ?? JSON.stringify;
+			const deserialize = config.serializer?.deserialize ?? JSON.parse;
+			const syncTabs = config.syncTabs ?? defaultSyncTabs;
+			const ttl = config.ttl ?? defaultTTL;
+			const key = `${keyPrefix}${config.key || store.$id}`;
+			if (!storage) {
+				if (debug) console.warn(`[PersistPlugin] Storage \u4E0D\u53EF\u7528 (${store.$id})`);
+				return;
+			}
+			let isRestoring = false;
+			const applyPersistedValue = (rawState) => {
+				const nextState = deserialize(rawState);
+				isRestoring = true;
+				try {
+					config.beforeRestore?.({ store });
+					restoreStoreState(store, nextState);
+					config.afterRestore?.({ store });
+				} finally {
+					isRestoring = false;
+				}
+			};
+			const restoreState = () => {
+				try {
+					const stored = storage.getItem(key);
+					if (!stored) return;
+					const storageItem = JSON.parse(stored);
+					if (storageItem.expiresAt && Date.now() > storageItem.expiresAt) {
+						storage.removeItem(key);
+						return;
+					}
+					applyPersistedValue(storageItem.state);
+					if (debug) console.info(`[PersistPlugin] \u5DF2\u6062\u590D\u72B6\u6001 (${store.$id})`);
+				} catch (error) {
+					console.error(`[PersistPlugin] \u6062\u590D\u72B6\u6001\u5931\u8D25 (${store.$id}):`, error);
+				}
+			};
+			const persistState = () => {
+				if (isRestoring) return;
+				try {
+					const filteredState = filterState(store.$state, config.paths, config.excludePaths);
+					const payload = {
+						state: serializer(filteredState),
+						timestamp: Date.now(),
+						expiresAt: ttl ? Date.now() + ttl : void 0,
+						version: 1
+					};
+					storage.setItem(key, JSON.stringify(payload));
+					if (debug) console.info(`[PersistPlugin] \u5DF2\u4FDD\u5B58\u72B6\u6001 (${store.$id})`);
+				} catch (error) {
+					console.error(`[PersistPlugin] \u4FDD\u5B58\u72B6\u6001\u5931\u8D25 (${store.$id}):`, error);
+				}
+			};
+			const saveState = (0, _composy_store_core.debounce)(persistState, config.debounce ?? debounceDelay);
+			const stopSubscribe = store.$subscribe(() => {
+				if (!isRestoring) saveState();
+			});
+			let stopStorageSync = () => {};
+			if (syncTabs && typeof window !== "undefined") {
+				const handleStorage = (event) => {
+					if (event.key !== key || !event.newValue) return;
+					try {
+						const storageItem = JSON.parse(event.newValue);
+						if (storageItem.expiresAt && Date.now() > storageItem.expiresAt) return;
+						applyPersistedValue(storageItem.state);
+					} catch (error) {
+						console.error(`[PersistPlugin] \u540C\u6B65\u72B6\u6001\u5931\u8D25 (${store.$id}):`, error);
+					}
+				};
+				window.addEventListener("storage", handleStorage);
+				stopStorageSync = () => {
+					window.removeEventListener("storage", handleStorage);
+				};
+			}
+			const cleanup = () => {
+				saveState.cancel();
+				stopSubscribe();
+				stopStorageSync();
+				cleanupMap.delete(key);
+			};
+			cleanupMap.set(key, cleanup);
+			patchPersistDispose(store, cleanup);
+			restoreState();
+		};
+		return {
+			plugin,
+			dispose
+		};
+	}
+	function createPersistPlugin(options = {}) {
+		return createPersistPluginController(options).plugin;
+	}
+	function createEnhancedPersistPlugin(options = {}) {
+		return createPersistPluginController(options).plugin;
+	}
+	function cleanupEnhancedPersist() {
+		Array.from(activePersistControllers).forEach((dispose) => dispose());
+	}
+	//#endregion
+	//#region src/runtime/store-plugin-options.ts
+	function normalizeStoreRuntimeOptions(options = {}) {
+		return {
+			pinia: options.pinia,
+			persist: options.persist ?? false,
+			persistOptions: options.persistOptions ?? {},
+			globalProperties: options.globalProperties ?? true,
+			provide: options.provide ?? true,
+			debug: options.debug ?? false
+		};
+	}
+	//#endregion
+	//#region src/runtime/store-registry.ts
+	const STORE_DISPOSE_PATCH_KEY = /* @__PURE__ */ Symbol("ldesign-store-registry-dispose");
+	function patchStoreDispose(store, unregister) {
+		const restorePatchedDispose = store[STORE_DISPOSE_PATCH_KEY];
+		if (restorePatchedDispose) restorePatchedDispose();
+		const originalDispose = store.$dispose;
+		store.$dispose = function patchedDispose() {
+			unregister(store.$id);
+			return originalDispose.call(this);
+		};
+		store[STORE_DISPOSE_PATCH_KEY] = () => {
+			store.$dispose = originalDispose;
+			delete store[STORE_DISPOSE_PATCH_KEY];
+		};
+	}
+	function createStoreRegistry() {
+		const stores = /* @__PURE__ */ new Map();
+		const unregister = (storeId) => {
+			stores.delete(storeId);
+		};
+		const register = (store) => {
+			stores.set(store.$id, store);
+			patchStoreDispose(store, unregister);
+		};
+		const hasStore = (storeId) => {
+			return stores.has(storeId);
+		};
+		const getStore = (storeId) => {
+			return stores.get(storeId);
+		};
+		const getStoreIds = () => {
+			return Array.from(stores.keys());
+		};
+		const resetAll = () => {
+			stores.forEach((store) => {
+				if (typeof store.$reset !== "function") return;
+				try {
+					store.$reset();
+				} catch {}
+			});
+		};
+		const clear = () => {
+			stores.clear();
+		};
+		const registerExistingStores = (pinia) => {
+			pinia._s?.forEach((store) => register(store));
+		};
+		const createStoreAPI = (pinia) => {
+			return {
+				pinia,
+				getStore,
+				hasStore,
+				getStoreIds,
+				resetAll
+			};
+		};
+		return {
+			stores,
+			register,
+			unregister,
+			hasStore,
+			getStore,
+			getStoreIds,
+			resetAll,
+			clear,
+			registerExistingStores,
+			createStoreAPI
+		};
+	}
+	let globalRegistry = createStoreRegistry();
+	function setGlobalStoreRegistry(registry) {
+		globalRegistry = registry ?? createStoreRegistry();
+	}
+	function getStoreRegistry() {
+		return globalRegistry.stores;
+	}
+	function createStoreRegistryPlugin(registry = globalRegistry) {
+		return ({ store }) => {
+			registry.register(store);
+		};
+	}
+	//#endregion
+	//#region src/runtime/store-runtime.ts
+	const STORE_RUNTIME_KEY = /* @__PURE__ */ Symbol("ldesign-store-runtime");
+	let globalStoreRuntime = null;
+	function getGlobalStoreAPI$1() {
+		return globalStoreRuntime?.storeAPI ?? null;
+	}
+	function setGlobalStoreRuntime(runtime) {
+		globalStoreRuntime = runtime;
+		setGlobalStoreRegistry(runtime?.registry ?? null);
+	}
+	function createStoreRuntime(options = {}) {
+		const resolvedOptions = normalizeStoreRuntimeOptions(options);
+		const pinia$1 = resolvedOptions.pinia ?? (0, pinia.createPinia)();
+		if (pinia$1[STORE_RUNTIME_KEY]) return pinia$1[STORE_RUNTIME_KEY];
+		const registry = createStoreRegistry();
+		const persistController = resolvedOptions.persist ? createPersistPluginController({
+			...resolvedOptions.persistOptions,
+			debug: resolvedOptions.debug || resolvedOptions.persistOptions.debug
+		}) : null;
+		pinia$1.use(createStoreRegistryPlugin(registry));
+		persistController && pinia$1.use(persistController.plugin);
+		registry.registerExistingStores(pinia$1);
+		const runtime = {
+			pinia: pinia$1,
+			registry,
+			storeAPI: registry.createStoreAPI(pinia$1),
+			options: resolvedOptions,
+			/**
+			* 清理函数
+			* 释放所有资源：清除运行时标记、持久化插件、注册表
+			*/
+			dispose: () => {
+				if (pinia$1[STORE_RUNTIME_KEY] === runtime) delete pinia$1[STORE_RUNTIME_KEY];
+				persistController?.dispose();
+				registry.clear();
+				if (globalStoreRuntime === runtime) setGlobalStoreRuntime(null);
+			}
+		};
+		pinia$1[STORE_RUNTIME_KEY] = runtime;
+		return runtime;
+	}
+	//#endregion
+	//#region src/runtime/install-store-app.ts
+	const STORE_APP_RUNTIME_KEY = /* @__PURE__ */ Symbol("ldesign-store-app-runtime");
+	function isPiniaInstalled(app, runtime) {
+		return app.config.globalProperties.$pinia === runtime.pinia;
+	}
+	function patchUnmount(app, runtime) {
+		const originalUnmount = app.unmount;
+		app.unmount = function patchedUnmount() {
+			if (app[STORE_APP_RUNTIME_KEY] === runtime) {
+				delete app[STORE_APP_RUNTIME_KEY];
+				runtime.dispose();
+			}
+			return originalUnmount.call(this);
+		};
+	}
+	function getInstalledStoreRuntime(app) {
+		return app[STORE_APP_RUNTIME_KEY];
+	}
+	function installStoreRuntime(app, runtime) {
+		const storeApp = app;
+		const installedRuntime = storeApp[STORE_APP_RUNTIME_KEY];
+		if (installedRuntime) {
+			setGlobalStoreRuntime(installedRuntime);
+			return installedRuntime;
+		}
+		if (!isPiniaInstalled(app, runtime)) app.use(runtime.pinia);
+		storeApp[STORE_APP_RUNTIME_KEY] = runtime;
+		if (runtime.options.provide) {
+			app.provide(STORE_RUNTIME_SYMBOL, runtime);
+			app.provide(STORE_API_SYMBOL, runtime.storeAPI);
+			app.provide(STORE_PINIA_SYMBOL, runtime.pinia);
+			app.provide("store", runtime.storeAPI);
+			app.provide("pinia", runtime.pinia);
+		}
+		if (runtime.options.globalProperties) app.config.globalProperties.$store = runtime.storeAPI;
+		patchUnmount(storeApp, runtime);
+		setGlobalStoreRuntime(runtime);
+		return runtime;
+	}
+	//#endregion
+	//#region src/plugins/engine-plugin.ts
+	function isVueApp(value) {
+		return !!value && typeof value.use === "function";
+	}
+	function resolveVueApp(engine, context, payload) {
+		const appPayload = payload;
+		const app = appPayload?.app ?? appPayload?.framework?.app ?? engine.getApp?.() ?? context.framework?.app;
+		return isVueApp(app) ? app : void 0;
+	}
+	function getGlobalStoreAPI() {
+		return getGlobalStoreAPI$1();
+	}
+	function createStoreEnginePlugin(options = {}) {
+		const { debug = false, dependencies = [], name = "store", version = "1.0.0" } = options;
+		let bridge = null;
+		const createBridge = () => {
+			const activeBridge = (0, _composy_store_core_engine.createStoreEngineBridge)({
+				name,
+				version,
+				debug,
+				createRuntime: () => createStoreRuntime({
+					pinia: options.pinia,
+					persist: options.persist,
+					persistOptions: options.persistOptions,
+					globalProperties: options.globalProperties,
+					provide: options.provide,
+					debug
+				}),
+				attachToApp: (app, runtime) => installStoreRuntime(app, runtime),
+				getRuntimeFromApp: (app) => getInstalledStoreRuntime(app),
+				isApp: isVueApp,
+				resolveApp: resolveVueApp
+			});
+			bridge = activeBridge;
+			return activeBridge;
+		};
+		const getBridge = () => {
+			return bridge ?? createBridge();
+		};
+		return {
+			name,
+			version,
+			dependencies,
+			/**
+			* 安装到引擎上下文（异步）
+			* 通过 bridge 将 store 能力注册到引擎
+			*/
+			async install(context) {
+				await getBridge().install(context);
+			},
+			/**
+			* 安装到 Vue App
+			* 将 store 运行时连接到 Vue 应用实例
+			*/
+			installVue(app) {
+				getBridge().attachToApp(app);
+			},
+			/**
+			* 从引擎上下文卸载（异步）
+			* 清理 bridge 引用
+			*/
+			async uninstall(context) {
+				await getBridge().uninstall(context);
+				bridge = null;
+			}
+		};
+	}
+	//#endregion
+	//#region src/plugins/vue-plugin.ts
+	function createStoreVuePlugin(options = {}) {
+		return { install(app) {
+			const runtime = createStoreRuntime(options);
+			const installedRuntime = installStoreRuntime(app, runtime);
+			if (installedRuntime !== runtime) runtime.dispose();
+			if (installedRuntime.options.debug) console.info("[StoreVuePlugin] installed");
+		} };
+	}
+	//#endregion
+	//#region src/index.ts
+	const version = "1.0.0";
+	const name = "@composy/store-vue";
+	//#endregion
+	Object.defineProperty(exports, "batch", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.batch;
+		}
+	});
+	exports.cleanupEnhancedPersist = cleanupEnhancedPersist;
+	Object.defineProperty(exports, "combineSelectors", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.combineSelectors;
+		}
+	});
+	Object.defineProperty(exports, "composePlugins", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.composePlugins;
+		}
+	});
+	Object.defineProperty(exports, "createAsyncAction", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createAsyncAction;
+		}
+	});
+	Object.defineProperty(exports, "createBatchManager", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createBatchManager;
+		}
+	});
+	exports.createEnhancedPersistPlugin = createEnhancedPersistPlugin;
+	Object.defineProperty(exports, "createEventBus", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createEventBus;
+		}
+	});
+	Object.defineProperty(exports, "createLoggerMiddleware", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createLoggerMiddleware;
+		}
+	});
+	Object.defineProperty(exports, "createMiddlewareManager", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createMiddlewareManager;
+		}
+	});
+	exports.createPersistPlugin = createPersistPlugin;
+	Object.defineProperty(exports, "createPinia", {
+		enumerable: true,
+		get: function() {
+			return pinia.createPinia;
+		}
+	});
+	Object.defineProperty(exports, "createPluginFactory", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createPluginFactory;
+		}
+	});
+	Object.defineProperty(exports, "createPubSub", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createPubSub;
+		}
+	});
+	Object.defineProperty(exports, "createPubSubWithValue", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createPubSubWithValue;
+		}
+	});
+	Object.defineProperty(exports, "createSelector", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createSelector;
+		}
+	});
+	exports.createStoreEnginePlugin = createStoreEnginePlugin;
+	exports.createStoreGetters = createStoreGetters;
+	exports.createStoreRegistryPlugin = createStoreRegistryPlugin;
+	exports.createStoreState = createStoreState;
+	exports.createStoreVuePlugin = createStoreVuePlugin;
+	Object.defineProperty(exports, "createTimeTravelMiddleware", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createTimeTravelMiddleware;
+		}
+	});
+	Object.defineProperty(exports, "createValidationMiddleware", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.createValidationMiddleware;
+		}
+	});
+	Object.defineProperty(exports, "deepClone", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.deepClone;
+		}
+	});
+	Object.defineProperty(exports, "deepMerge", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.deepMerge;
+		}
+	});
+	exports.defineSetupStore = defineSetupStore;
+	Object.defineProperty(exports, "defineStore", {
+		enumerable: true,
+		get: function() {
+			return pinia.defineStore;
+		}
+	});
+	Object.defineProperty(exports, "defineStorePlugin", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.defineStorePlugin;
+		}
+	});
+	exports.email = email;
+	Object.defineProperty(exports, "getActivePinia", {
+		enumerable: true,
+		get: function() {
+			return pinia.getActivePinia;
+		}
+	});
+	exports.getGlobalStoreAPI = getGlobalStoreAPI;
+	exports.getStoreRegistry = getStoreRegistry;
+	Object.defineProperty(exports, "globalEventBus", {
+		enumerable: true,
+		get: function() {
+			return _composy_store_core.globalEventBus;
+		}
+	});
+	Object.defineProperty(exports, "mapActions", {
+		enumerable: true,
+		get: function() {
+			return pinia.mapActions;
+		}
+	});
+	Object.defineProperty(exports, "mapGetters", {
+		enumerable: true,
+		get: function() {
+			return pinia.mapGetters;
+		}
+	});
+	Object.defineProperty(exports, "mapState", {
+		enumerable: true,
+		get: function() {
+			return pinia.mapState;
+		}
+	});
+	Object.defineProperty(exports, "mapStores", {
+		enumerable: true,
+		get: function() {
+			return pinia.mapStores;
+		}
+	});
+	Object.defineProperty(exports, "mapWritableState", {
+		enumerable: true,
+		get: function() {
+			return pinia.mapWritableState;
+		}
+	});
+	exports.maxLength = maxLength;
+	exports.minLength = minLength;
+	exports.name = name;
+	exports.numberRange = numberRange;
+	exports.pattern = pattern;
+	exports.required = required;
+	Object.defineProperty(exports, "setActivePinia", {
+		enumerable: true,
+		get: function() {
+			return pinia.setActivePinia;
+		}
+	});
+	Object.defineProperty(exports, "storeToRefs", {
+		enumerable: true,
+		get: function() {
+			return pinia.storeToRefs;
+		}
+	});
+	exports.useComputedStore = useComputedStore;
+	exports.useFormStore = useFormStore;
+	exports.useOnAction = useOnAction;
+	exports.useOptimistic = useOptimistic;
+	exports.usePersist = usePersist;
+	exports.usePersistedRef = usePersistedRef;
+	exports.usePersistedRefWithTTL = usePersistedRefWithTTL;
+	exports.usePersistedState = usePersistedState;
+	exports.useSharedState = useSharedState;
+	exports.useSimpleStore = useSimpleStore;
+	exports.useStore = useStore;
+	exports.useStoreDevtools = useStoreDevtools;
+	exports.useStoreSnapshot = useStoreSnapshot;
+	exports.useSubscribe = useSubscribe;
+	exports.useWatch = useWatch;
+	exports.version = version;
+});
+/*! End of @composy/store-vue | Powered by @composy/builder */
+//# sourceMappingURL=index.js.map