@coaction/pinia 1.5.0 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @coaction/pinia
 
-![Node CI](https://github.com/unadlib/coaction/workflows/Node%20CI/badge.svg)
+![Node CI](https://github.com/coactionjs/coaction/workflows/Node%20CI/badge.svg)
 [![npm](https://img.shields.io/npm/v/@coaction/pinia.svg)](https://www.npmjs.com/package/@coaction/pinia)
 ![license](https://img.shields.io/npm/l/@coaction/pinia)
 
@@ -46,4 +46,4 @@ const useStore = create(() =>
 
 ## Documentation
 
-You can find the documentation [here](https://github.com/unadlib/coaction).
+You can find the documentation [here](https://github.com/coactionjs/coaction).

package/dist/index.d.mts

@@ -1,25 +1,13 @@
-import { StoreDefinition, StateTree, _GettersTree, DefineStoreOptions } from 'pinia';
-export * from 'pinia';
+import { DefineStoreOptions, StateTree, StoreDefinition, _GettersTree } from "pinia";
+export * from "pinia";
 
-type FunctionKeys<T> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
-}[keyof T];
-type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
-type ReadonlyKeys<T> = {
-    [K in keyof T]: Equal<{
-        [P in K]: T[P];
-    }, Readonly<{
-        [P in K]: T[P];
-    }>> extends true ? K : never;
-}[keyof T];
-type IStore<T extends object> = [
-    string,
-    Pick<T, Exclude<keyof T, ReadonlyKeys<T> | FunctionKeys<T>>>,
-    {
-        [K in ReadonlyKeys<T>]: (state: Pick<T, Exclude<keyof T, ReadonlyKeys<T> | FunctionKeys<T>>>) => T[K];
-    },
-    Pick<T, FunctionKeys<T>>
-];
+//#region \0rolldown/runtime.js
+//#endregion
+//#region packages/coaction-pinia/src/index.d.ts
+type FunctionKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? K : never }[keyof T];
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type ReadonlyKeys<T> = { [K in keyof T]: Equal<{ [P in K]: T[P] }, Readonly<{ [P in K]: T[P] }>> extends true ? K : never }[keyof T];
+type IStore<T extends object> = [string, Pick<T, Exclude<keyof T, ReadonlyKeys<T> | FunctionKeys<T>>>, { [K in ReadonlyKeys<T>]: (state: Pick<T, Exclude<keyof T, ReadonlyKeys<T> | FunctionKeys<T>>>) => T[K] }, Pick<T, FunctionKeys<T>>];
 /**
  * Bind a store to Pinia
  */
@@ -29,5 +17,8 @@ declare const bindPinia: <Id extends string, S extends StateTree = {}, G extends
  */
 declare const adapt: <T extends object>(store: StoreDefinition<IStore<T>[0], IStore<T>[1], IStore<T>[2], IStore<T>[3]>) => T;
 type PiniaStore<T extends object> = StoreDefinition<IStore<T>[0], IStore<T>[1], IStore<T>[2], IStore<T>[3]>;
-
-export { type IStore, type PiniaStore, adapt, bindPinia };
+declare namespace index_d_exports {
+  export { IStore, PiniaStore, adapt, bindPinia };
+}
+//#endregion
+export { IStore, PiniaStore, adapt, bindPinia };

package/dist/index.d.ts

@@ -1,25 +1,13 @@
-import { StoreDefinition, StateTree, _GettersTree, DefineStoreOptions } from 'pinia';
-export * from 'pinia';
+import { DefineStoreOptions, StateTree, StoreDefinition, _GettersTree } from "pinia";
+export * from "pinia";
 
-type FunctionKeys<T> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
-}[keyof T];
-type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
-type ReadonlyKeys<T> = {
-    [K in keyof T]: Equal<{
-        [P in K]: T[P];
-    }, Readonly<{
-        [P in K]: T[P];
-    }>> extends true ? K : never;
-}[keyof T];
-type IStore<T extends object> = [
-    string,
-    Pick<T, Exclude<keyof T, ReadonlyKeys<T> | FunctionKeys<T>>>,
-    {
-        [K in ReadonlyKeys<T>]: (state: Pick<T, Exclude<keyof T, ReadonlyKeys<T> | FunctionKeys<T>>>) => T[K];
-    },
-    Pick<T, FunctionKeys<T>>
-];
+//#region \0rolldown/runtime.js
+//#endregion
+//#region packages/coaction-pinia/src/index.d.ts
+type FunctionKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? K : never }[keyof T];
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type ReadonlyKeys<T> = { [K in keyof T]: Equal<{ [P in K]: T[P] }, Readonly<{ [P in K]: T[P] }>> extends true ? K : never }[keyof T];
+type IStore<T extends object> = [string, Pick<T, Exclude<keyof T, ReadonlyKeys<T> | FunctionKeys<T>>>, { [K in ReadonlyKeys<T>]: (state: Pick<T, Exclude<keyof T, ReadonlyKeys<T> | FunctionKeys<T>>>) => T[K] }, Pick<T, FunctionKeys<T>>];
 /**
  * Bind a store to Pinia
  */
@@ -29,5 +17,8 @@ declare const bindPinia: <Id extends string, S extends StateTree = {}, G extends
  */
 declare const adapt: <T extends object>(store: StoreDefinition<IStore<T>[0], IStore<T>[1], IStore<T>[2], IStore<T>[3]>) => T;
 type PiniaStore<T extends object> = StoreDefinition<IStore<T>[0], IStore<T>[1], IStore<T>[2], IStore<T>[3]>;
-
-export { type IStore, type PiniaStore, adapt, bindPinia };
+declare namespace index_d_exports {
+  export { IStore, PiniaStore, adapt, bindPinia };
+}
+//#endregion
+export { IStore, PiniaStore, adapt, bindPinia };

package/dist/index.js

@@ -1,130 +1,247 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#endregion
+let mutability = require("mutability");
+let coaction = require("coaction");
+let pinia = require("pinia");
+//#region packages/coaction-pinia/src/index.ts
+const instancesMap = /* @__PURE__ */ new WeakMap();
+const getOwnEnumerableKeys = (value) => Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+const isUnsafeKey = (key) => typeof key === "string" && (key === "__proto__" || key === "prototype" || key === "constructor");
+const isArrayIndexKey = (key) => {
+	if (typeof key !== "string") return false;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+const isObjectRecord = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const replaceMutableState = (rawState, mutableState, publicState, source) => {
+	const nextKeys = /* @__PURE__ */ new Set();
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (isUnsafeKey(key)) continue;
+		if (typeof source[key] === "function") continue;
+		nextKeys.add(key);
+	}
+	for (const key of getOwnEnumerableKeys(rawState)) {
+		if (isUnsafeKey(key)) {
+			delete rawState[key];
+			delete mutableState[key];
+			delete publicState[key];
+			continue;
+		}
+		if (typeof rawState[key] === "function") continue;
+		if (!nextKeys.has(key)) {
+			delete rawState[key];
+			delete mutableState[key];
+			delete publicState[key];
+		}
+	}
+	const rawSeen = /* @__PURE__ */ new WeakMap();
+	const mutableSeen = /* @__PURE__ */ new WeakMap();
+	const publicSeen = /* @__PURE__ */ new WeakMap();
+	rawSeen.set(source, rawState);
+	mutableSeen.set(source, mutableState);
+	publicSeen.set(source, publicState);
+	nextKeys.forEach((key) => {
+		rawState[key] = (0, coaction.sanitizeReplacementState)(source[key], rawSeen);
+		mutableState[key] = (0, coaction.sanitizeReplacementState)(source[key], mutableSeen);
+		publicState[key] = (0, coaction.sanitizeReplacementState)(source[key], publicSeen);
+	});
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  adapt: () => adapt,
-  bindPinia: () => bindPinia
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  adapt: () => adapt,
-  bindPinia: () => bindPinia
-});
-var import_mutability = require("mutability");
-var import_coaction = require("coaction");
-var import_pinia = require("pinia");
-__reExport(src_exports, require("pinia"));
-var instancesMap = /* @__PURE__ */ new WeakMap();
-var handleStore = (store, state, _, internal) => {
-  if (!internal.toMutableRaw) {
-    internal.toMutableRaw = (key) => instancesMap.get(key);
-    Object.assign(store, {
-      subscribe: (callback) => {
-        store._subscriptions.add(callback);
-        return () => store._subscriptions.delete(callback);
-      }
-    });
-    store._subscriptions = /* @__PURE__ */ new Set();
-    store._destroyers = /* @__PURE__ */ new Set();
-    const baseDestroy = store.destroy;
-    let destroyed = false;
-    store.destroy = () => {
-      if (destroyed) {
-        return;
-      }
-      destroyed = true;
-      baseDestroy();
-      store._subscriptions.clear();
-      store._subscriptions = void 0;
-      store._destroyers.forEach((destroy2) => destroy2());
-      store._destroyers = void 0;
-    };
-    store.apply = (state2 = store.getState(), patches) => {
-      if (!patches) {
-        if (state2 === store.getState()) return;
-        Object.assign(store.getState(), state2);
-        return;
-      }
-      (0, import_mutability.apply)(state2, patches);
-    };
-  }
-  const mutableStore = internal.toMutableRaw(state);
-  if (!mutableStore) {
-    throw new Error("Pinia store instance is not found");
-  }
-  const stopWatch = mutableStore.$subscribe((...args) => {
-    store._subscriptions.forEach((callback) => callback(...args));
-  });
-  const destroy = () => {
-    instancesMap.delete(state);
-    stopWatch();
-  };
-  store._destroyers.add(destroy);
+const toSnapshot = (value, visited = /* @__PURE__ */ new WeakMap()) => {
+	if (Array.isArray(value)) {
+		if (visited.has(value)) return visited.get(value);
+		const next = [];
+		next.length = value.length;
+		visited.set(value, next);
+		for (let index = 0; index < value.length; index += 1) if (Object.prototype.hasOwnProperty.call(value, index)) next[index] = toSnapshot(value[index], visited);
+		const source = value;
+		const target = next;
+		for (const key of getOwnEnumerableKeys(value)) {
+			if (isArrayIndexKey(key) || isUnsafeKey(key)) continue;
+			const child = source[key];
+			if (typeof child !== "function") target[key] = toSnapshot(child, visited);
+		}
+		return next;
+	}
+	if (typeof value === "object" && value !== null) {
+		if (!isObjectRecord(value)) return value;
+		if (visited.has(value)) return visited.get(value);
+		const next = {};
+		visited.set(value, next);
+		for (const key of getOwnEnumerableKeys(value)) {
+			if (isUnsafeKey(key)) continue;
+			const child = value[key];
+			if (typeof child !== "function") next[key] = toSnapshot(child, visited);
+		}
+		return next;
+	}
+	return value;
+};
+const snapshotPureState = (store) => toSnapshot(store.getPureState());
+const isEqualSnapshot = (left, right, visited = /* @__PURE__ */ new WeakMap()) => {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	const leftIsArray = Array.isArray(left);
+	const rightIsArray = Array.isArray(right);
+	if (leftIsArray || rightIsArray) {
+		if (!leftIsArray || !rightIsArray || left.length !== right.length) return false;
+	} else if (!isObjectRecord(left) || !isObjectRecord(right)) return false;
+	let seenTargets = visited.get(left);
+	if (!seenTargets) {
+		seenTargets = /* @__PURE__ */ new WeakSet();
+		visited.set(left, seenTargets);
+	} else if (seenTargets.has(right)) return true;
+	seenTargets.add(right);
+	const leftRecord = left;
+	const rightRecord = right;
+	const leftKeys = getOwnEnumerableKeys(left);
+	const rightKeys = getOwnEnumerableKeys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of leftKeys) {
+		if (!Object.prototype.hasOwnProperty.call(rightRecord, key)) return false;
+		if (!isEqualSnapshot(leftRecord[key], rightRecord[key], visited)) return false;
+	}
+	return true;
+};
+const handleStore = (store, state, _, internal) => {
+	const rawState = state;
+	let isApplyingCoactionState = false;
+	let lastSnapshot;
+	const restoreClientState = (snapshot) => {
+		const mutableStore = internal.toMutableRaw(rawState);
+		if (!mutableStore) return;
+		isApplyingCoactionState = true;
+		try {
+			replaceMutableState(internal.rootState ?? rawState, mutableStore, store.getState(), snapshot);
+		} finally {
+			lastSnapshot = snapshotPureState(store);
+			isApplyingCoactionState = false;
+		}
+	};
+	const syncSharedExternalChange = () => {
+		const currentSnapshot = snapshotPureState(store);
+		if (isApplyingCoactionState) {
+			lastSnapshot = currentSnapshot;
+			return "handled";
+		}
+		if (store.share === "client" && lastSnapshot) {
+			if (!isEqualSnapshot(currentSnapshot, lastSnapshot)) restoreClientState(lastSnapshot);
+			return "ignored";
+		}
+		if (store.share === "main" && lastSnapshot) {
+			const rootState = internal.rootState;
+			internal.rootState = lastSnapshot;
+			try {
+				(0, coaction.replaceExternalStoreState)(store, internal, currentSnapshot, { syncImmutable: false });
+			} finally {
+				internal.rootState = rootState;
+			}
+			lastSnapshot = currentSnapshot;
+			return "handled";
+		}
+		lastSnapshot = currentSnapshot;
+		return "external";
+	};
+	if (!internal.toMutableRaw) {
+		internal.toMutableRaw = (key) => instancesMap.get(key);
+		Object.assign(store, { subscribe: (callback) => {
+			store._subscriptions.add(callback);
+			return () => {
+				store._subscriptions?.delete(callback);
+			};
+		} });
+		store._subscriptions = /* @__PURE__ */ new Set();
+		store._destroyers = /* @__PURE__ */ new Set();
+		const baseDestroy = store.destroy;
+		let destroyed = false;
+		store.destroy = () => {
+			if (destroyed) return;
+			destroyed = true;
+			store._subscriptions?.clear();
+			store._subscriptions = void 0;
+			store._destroyers?.forEach((destroy) => destroy());
+			store._destroyers?.clear();
+			store._destroyers = void 0;
+			baseDestroy();
+		};
+		store.apply = (nextState = store.getState(), patches) => {
+			isApplyingCoactionState = true;
+			try {
+				if (!patches) {
+					if (nextState === store.getState()) return;
+					replaceMutableState(internal.rootState ?? rawState, internal.toMutableRaw(rawState), store.getState(), nextState);
+					return;
+				}
+				(0, mutability.apply)(nextState, patches);
+			} finally {
+				lastSnapshot = snapshotPureState(store);
+				isApplyingCoactionState = false;
+				internal.notifyStateChange?.();
+			}
+		};
+	}
+	const mutableStore = internal.toMutableRaw(state);
+	if (!mutableStore) throw new Error("Pinia store instance is not found");
+	let stopWatch;
+	const cancelReadySubscription = (0, coaction.onStoreReady)(store, () => {
+		replaceMutableState(internal.rootState ?? rawState, mutableStore, store.getState(), (0, coaction.sanitizeInitialStateValue)(snapshotPureState(store)));
+		lastSnapshot = snapshotPureState(store);
+		stopWatch = mutableStore.$subscribe((...args) => {
+			const change = syncSharedExternalChange();
+			if (change === "ignored") return;
+			if (change === "external") internal.notifyStateChange?.();
+			store._subscriptions.forEach((callback) => callback(...args));
+		});
+	});
+	const destroy = () => {
+		cancelReadySubscription();
+		instancesMap.delete(state);
+		stopWatch?.();
+	};
+	store._destroyers.add(destroy);
 };
-var bindPinia = (0, import_coaction.createBinder)({
-  handleStore,
-  handleState: ((options) => {
-    const descriptors = {};
-    options.getters = options.getters ?? {};
-    for (const key of Object.keys(options.getters)) {
-      const getter = options.getters[key];
-      if (typeof getter !== "function") {
-        continue;
-      }
-      descriptors[key] = {
-        get() {
-          return getter.call(this, this);
-        }
-      };
-    }
-    const rawState = Object.defineProperties(
-      {
-        ...options.state?.(),
-        ...options.actions
-      },
-      descriptors
-    );
-    const pinia = (0, import_pinia.createPinia)();
-    (0, import_pinia.setActivePinia)(pinia);
-    return {
-      copyState: options,
-      key: "actions",
-      bind: (state) => {
-        rawState.name = state.$id;
-        instancesMap.set(rawState, state);
-        return rawState;
-      }
-    };
-  })
+/**
+* Bind a store to Pinia
+*/
+const bindPinia = (0, coaction.createBinder)({
+	handleStore,
+	handleState: ((options) => {
+		const descriptors = {};
+		options.getters = options.getters ?? {};
+		options.actions = options.actions ?? {};
+		for (const key of Object.keys(options.getters)) {
+			const getter = options.getters[key];
+			if (typeof getter !== "function") continue;
+			descriptors[key] = { get() {
+				return getter.call(this, this);
+			} };
+		}
+		const rawState = Object.defineProperties({
+			...options.state?.(),
+			...options.actions
+		}, descriptors);
+		(0, pinia.setActivePinia)((0, pinia.createPinia)());
+		return {
+			copyState: options,
+			key: "actions",
+			bind: (state) => {
+				instancesMap.set(rawState, state);
+				return rawState;
+			}
+		};
+	})
 });
-var adapt = (store) => store;
-
-// index.ts
-__reExport(index_exports, src_exports, module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  adapt,
-  bindPinia
+/**
+* Adapt a store type to Pinia
+*/
+const adapt = (store) => store;
+//#endregion
+exports.adapt = adapt;
+exports.bindPinia = bindPinia;
+Object.keys(pinia).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return pinia[k];
+		}
+	});
 });

package/dist/index.mjs

@@ -1,127 +1,238 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  adapt: () => adapt,
-  bindPinia: () => bindPinia
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  adapt: () => adapt,
-  bindPinia: () => bindPinia
-});
-__reExport(src_exports, pinia_star);
 import { apply } from "mutability";
-import { createBinder } from "coaction";
+import { createBinder, onStoreReady, replaceExternalStoreState, sanitizeInitialStateValue, sanitizeReplacementState } from "coaction";
 import { createPinia, setActivePinia } from "pinia";
-import * as pinia_star from "pinia";
-var instancesMap = /* @__PURE__ */ new WeakMap();
-var handleStore = (store, state, _, internal) => {
-  if (!internal.toMutableRaw) {
-    internal.toMutableRaw = (key) => instancesMap.get(key);
-    Object.assign(store, {
-      subscribe: (callback) => {
-        store._subscriptions.add(callback);
-        return () => store._subscriptions.delete(callback);
-      }
-    });
-    store._subscriptions = /* @__PURE__ */ new Set();
-    store._destroyers = /* @__PURE__ */ new Set();
-    const baseDestroy = store.destroy;
-    let destroyed = false;
-    store.destroy = () => {
-      if (destroyed) {
-        return;
-      }
-      destroyed = true;
-      baseDestroy();
-      store._subscriptions.clear();
-      store._subscriptions = void 0;
-      store._destroyers.forEach((destroy2) => destroy2());
-      store._destroyers = void 0;
-    };
-    store.apply = (state2 = store.getState(), patches) => {
-      if (!patches) {
-        if (state2 === store.getState()) return;
-        Object.assign(store.getState(), state2);
-        return;
-      }
-      apply(state2, patches);
-    };
-  }
-  const mutableStore = internal.toMutableRaw(state);
-  if (!mutableStore) {
-    throw new Error("Pinia store instance is not found");
-  }
-  const stopWatch = mutableStore.$subscribe((...args) => {
-    store._subscriptions.forEach((callback) => callback(...args));
-  });
-  const destroy = () => {
-    instancesMap.delete(state);
-    stopWatch();
-  };
-  store._destroyers.add(destroy);
+export * from "pinia";
+//#endregion
+//#region packages/coaction-pinia/src/index.ts
+const instancesMap = /* @__PURE__ */ new WeakMap();
+const getOwnEnumerableKeys = (value) => Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+const isUnsafeKey = (key) => typeof key === "string" && (key === "__proto__" || key === "prototype" || key === "constructor");
+const isArrayIndexKey = (key) => {
+	if (typeof key !== "string") return false;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
 };
-var bindPinia = createBinder({
-  handleStore,
-  handleState: ((options) => {
-    const descriptors = {};
-    options.getters = options.getters ?? {};
-    for (const key of Object.keys(options.getters)) {
-      const getter = options.getters[key];
-      if (typeof getter !== "function") {
-        continue;
-      }
-      descriptors[key] = {
-        get() {
-          return getter.call(this, this);
-        }
-      };
-    }
-    const rawState = Object.defineProperties(
-      {
-        ...options.state?.(),
-        ...options.actions
-      },
-      descriptors
-    );
-    const pinia = createPinia();
-    setActivePinia(pinia);
-    return {
-      copyState: options,
-      key: "actions",
-      bind: (state) => {
-        rawState.name = state.$id;
-        instancesMap.set(rawState, state);
-        return rawState;
-      }
-    };
-  })
-});
-var adapt = (store) => store;
-
-// index.ts
-__reExport(index_exports, src_exports);
-export {
-  adapt,
-  bindPinia
+const isObjectRecord = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const replaceMutableState = (rawState, mutableState, publicState, source) => {
+	const nextKeys = /* @__PURE__ */ new Set();
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (isUnsafeKey(key)) continue;
+		if (typeof source[key] === "function") continue;
+		nextKeys.add(key);
+	}
+	for (const key of getOwnEnumerableKeys(rawState)) {
+		if (isUnsafeKey(key)) {
+			delete rawState[key];
+			delete mutableState[key];
+			delete publicState[key];
+			continue;
+		}
+		if (typeof rawState[key] === "function") continue;
+		if (!nextKeys.has(key)) {
+			delete rawState[key];
+			delete mutableState[key];
+			delete publicState[key];
+		}
+	}
+	const rawSeen = /* @__PURE__ */ new WeakMap();
+	const mutableSeen = /* @__PURE__ */ new WeakMap();
+	const publicSeen = /* @__PURE__ */ new WeakMap();
+	rawSeen.set(source, rawState);
+	mutableSeen.set(source, mutableState);
+	publicSeen.set(source, publicState);
+	nextKeys.forEach((key) => {
+		rawState[key] = sanitizeReplacementState(source[key], rawSeen);
+		mutableState[key] = sanitizeReplacementState(source[key], mutableSeen);
+		publicState[key] = sanitizeReplacementState(source[key], publicSeen);
+	});
 };
+const toSnapshot = (value, visited = /* @__PURE__ */ new WeakMap()) => {
+	if (Array.isArray(value)) {
+		if (visited.has(value)) return visited.get(value);
+		const next = [];
+		next.length = value.length;
+		visited.set(value, next);
+		for (let index = 0; index < value.length; index += 1) if (Object.prototype.hasOwnProperty.call(value, index)) next[index] = toSnapshot(value[index], visited);
+		const source = value;
+		const target = next;
+		for (const key of getOwnEnumerableKeys(value)) {
+			if (isArrayIndexKey(key) || isUnsafeKey(key)) continue;
+			const child = source[key];
+			if (typeof child !== "function") target[key] = toSnapshot(child, visited);
+		}
+		return next;
+	}
+	if (typeof value === "object" && value !== null) {
+		if (!isObjectRecord(value)) return value;
+		if (visited.has(value)) return visited.get(value);
+		const next = {};
+		visited.set(value, next);
+		for (const key of getOwnEnumerableKeys(value)) {
+			if (isUnsafeKey(key)) continue;
+			const child = value[key];
+			if (typeof child !== "function") next[key] = toSnapshot(child, visited);
+		}
+		return next;
+	}
+	return value;
+};
+const snapshotPureState = (store) => toSnapshot(store.getPureState());
+const isEqualSnapshot = (left, right, visited = /* @__PURE__ */ new WeakMap()) => {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	const leftIsArray = Array.isArray(left);
+	const rightIsArray = Array.isArray(right);
+	if (leftIsArray || rightIsArray) {
+		if (!leftIsArray || !rightIsArray || left.length !== right.length) return false;
+	} else if (!isObjectRecord(left) || !isObjectRecord(right)) return false;
+	let seenTargets = visited.get(left);
+	if (!seenTargets) {
+		seenTargets = /* @__PURE__ */ new WeakSet();
+		visited.set(left, seenTargets);
+	} else if (seenTargets.has(right)) return true;
+	seenTargets.add(right);
+	const leftRecord = left;
+	const rightRecord = right;
+	const leftKeys = getOwnEnumerableKeys(left);
+	const rightKeys = getOwnEnumerableKeys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of leftKeys) {
+		if (!Object.prototype.hasOwnProperty.call(rightRecord, key)) return false;
+		if (!isEqualSnapshot(leftRecord[key], rightRecord[key], visited)) return false;
+	}
+	return true;
+};
+const handleStore = (store, state, _, internal) => {
+	const rawState = state;
+	let isApplyingCoactionState = false;
+	let lastSnapshot;
+	const restoreClientState = (snapshot) => {
+		const mutableStore = internal.toMutableRaw(rawState);
+		if (!mutableStore) return;
+		isApplyingCoactionState = true;
+		try {
+			replaceMutableState(internal.rootState ?? rawState, mutableStore, store.getState(), snapshot);
+		} finally {
+			lastSnapshot = snapshotPureState(store);
+			isApplyingCoactionState = false;
+		}
+	};
+	const syncSharedExternalChange = () => {
+		const currentSnapshot = snapshotPureState(store);
+		if (isApplyingCoactionState) {
+			lastSnapshot = currentSnapshot;
+			return "handled";
+		}
+		if (store.share === "client" && lastSnapshot) {
+			if (!isEqualSnapshot(currentSnapshot, lastSnapshot)) restoreClientState(lastSnapshot);
+			return "ignored";
+		}
+		if (store.share === "main" && lastSnapshot) {
+			const rootState = internal.rootState;
+			internal.rootState = lastSnapshot;
+			try {
+				replaceExternalStoreState(store, internal, currentSnapshot, { syncImmutable: false });
+			} finally {
+				internal.rootState = rootState;
+			}
+			lastSnapshot = currentSnapshot;
+			return "handled";
+		}
+		lastSnapshot = currentSnapshot;
+		return "external";
+	};
+	if (!internal.toMutableRaw) {
+		internal.toMutableRaw = (key) => instancesMap.get(key);
+		Object.assign(store, { subscribe: (callback) => {
+			store._subscriptions.add(callback);
+			return () => {
+				store._subscriptions?.delete(callback);
+			};
+		} });
+		store._subscriptions = /* @__PURE__ */ new Set();
+		store._destroyers = /* @__PURE__ */ new Set();
+		const baseDestroy = store.destroy;
+		let destroyed = false;
+		store.destroy = () => {
+			if (destroyed) return;
+			destroyed = true;
+			store._subscriptions?.clear();
+			store._subscriptions = void 0;
+			store._destroyers?.forEach((destroy) => destroy());
+			store._destroyers?.clear();
+			store._destroyers = void 0;
+			baseDestroy();
+		};
+		store.apply = (nextState = store.getState(), patches) => {
+			isApplyingCoactionState = true;
+			try {
+				if (!patches) {
+					if (nextState === store.getState()) return;
+					replaceMutableState(internal.rootState ?? rawState, internal.toMutableRaw(rawState), store.getState(), nextState);
+					return;
+				}
+				apply(nextState, patches);
+			} finally {
+				lastSnapshot = snapshotPureState(store);
+				isApplyingCoactionState = false;
+				internal.notifyStateChange?.();
+			}
+		};
+	}
+	const mutableStore = internal.toMutableRaw(state);
+	if (!mutableStore) throw new Error("Pinia store instance is not found");
+	let stopWatch;
+	const cancelReadySubscription = onStoreReady(store, () => {
+		replaceMutableState(internal.rootState ?? rawState, mutableStore, store.getState(), sanitizeInitialStateValue(snapshotPureState(store)));
+		lastSnapshot = snapshotPureState(store);
+		stopWatch = mutableStore.$subscribe((...args) => {
+			const change = syncSharedExternalChange();
+			if (change === "ignored") return;
+			if (change === "external") internal.notifyStateChange?.();
+			store._subscriptions.forEach((callback) => callback(...args));
+		});
+	});
+	const destroy = () => {
+		cancelReadySubscription();
+		instancesMap.delete(state);
+		stopWatch?.();
+	};
+	store._destroyers.add(destroy);
+};
+/**
+* Bind a store to Pinia
+*/
+const bindPinia = createBinder({
+	handleStore,
+	handleState: ((options) => {
+		const descriptors = {};
+		options.getters = options.getters ?? {};
+		options.actions = options.actions ?? {};
+		for (const key of Object.keys(options.getters)) {
+			const getter = options.getters[key];
+			if (typeof getter !== "function") continue;
+			descriptors[key] = { get() {
+				return getter.call(this, this);
+			} };
+		}
+		const rawState = Object.defineProperties({
+			...options.state?.(),
+			...options.actions
+		}, descriptors);
+		setActivePinia(createPinia());
+		return {
+			copyState: options,
+			key: "actions",
+			bind: (state) => {
+				instancesMap.set(rawState, state);
+				return rawState;
+			}
+		};
+	})
+});
+/**
+* Adapt a store type to Pinia
+*/
+const adapt = (store) => store;
+//#endregion
+export { adapt, bindPinia };

package/package.json

@@ -1,19 +1,30 @@
 {
   "name": "@coaction/pinia",
-  "version": "1.5.0",
+  "version": "2.0.0",
   "description": "A Coaction integration tool for Pinia",
   "keywords": [
-    "state",
     "coaction",
-    "pinia"
+    "pinia",
+    "state"
   ],
-  "authors": [
-    "Michael Lin <unadlib@gmail.com> (https://github.com/unadlib)"
-  ],
-  "homepage": "https://github.com/unadlib/coaction/tree/main/packages/coaction-pinia#readme",
+  "homepage": "https://github.com/coactionjs/coaction/tree/main/packages/coaction-pinia#readme",
+  "bugs": {
+    "url": "https://github.com/coactionjs/coaction/issues"
+  },
   "license": "MIT",
+  "author": "unadlib",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/coactionjs/coaction.git",
+    "directory": "packages/coaction-pinia"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
   "main": "dist/index.js",
   "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -23,53 +34,30 @@
     },
     "./package.json": "./package.json"
   },
-  "types": "dist/index.d.ts",
-  "sideEffects": false,
-  "files": [
-    "dist"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/unadlib/coaction.git",
-    "directory": "packages/coaction-pinia"
-  },
-  "bugs": {
-    "url": "https://github.com/unadlib/coaction/issues"
-  },
-  "peerDependencies": {
-    "coaction": "^1.5.0",
-    "mutative": "^1.1.0",
-    "pinia": "^2.0 || ^3.0.0"
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   },
-  "peerDependenciesMeta": {
-    "coaction": {
-      "optional": true
-    },
-    "mutative": {
-      "optional": true
-    },
-    "pinia": {
-      "optional": true
-    }
+  "dependencies": {
+    "mutability": "^1.2.1"
   },
   "devDependencies": {
     "data-transport": "^5.0.3",
     "mutative": "^1.3.0",
     "pinia": "^3.0.4",
-    "coaction": "1.5.0"
+    "coaction": "2.0.0"
   },
-  "dependencies": {
-    "mutability": "^1.2.1"
-  },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
+  "peerDependencies": {
+    "coaction": "^2.0.0",
+    "pinia": "^2.0 || ^3.0.0"
   },
-  "author": "unadlib",
+  "authors": [
+    "Michael Lin <unadlib@gmail.com> (https://github.com/unadlib)"
+  ],
   "scripts": {
     "clean": "rm -rf dist",
     "test": "vitest run test",
-    "build": "tsup index.ts --format cjs,esm --dts --clean --out-dir dist",
-    "dev": "tsup index.ts --format cjs,esm --dts --watch --out-dir dist"
+    "build": "node ../../scripts/build-package.mjs",
+    "dev": "node ../../scripts/build-package.mjs --watch"
   }
 }