@coaction/pinia 1.5.0 → 2.1.0

package/README.md

@@ -1,40 +1,40 @@
 # @coaction/pinia
 
-![Node CI](https://github.com/unadlib/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)
+![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)
 
 A Coaction integration tool for Pinia
 
 ## Installation
 
-You can install it via npm, yarn or pnpm.
+Install it with pnpm:
 
 ```sh
-npm install coaction @coaction/pinia
+pnpm add coaction @coaction/pinia
 ```
 
 ## Usage
 
 ```js
 import { create } from 'coaction';
-import { bindPinia } from '@coaction/pinia';
+import { adapt, bindPinia } from '@coaction/pinia';
 import { defineStore } from 'pinia';
 
 const useStore = create(() =>
-  defineStore(
-    'test',
-    bindPinia({
-      state: () => ({ count: 0 }),
-      getters: {
-        double: (state) => state.count * 2
-      },
-      actions: {
-        increment(state) {
-          state.count += 1;
+  adapt(
+    defineStore(
+      'test',
+      bindPinia({
+        state: () => ({ count: 0 }),
+        getters: {
+          double: (state) => state.count * 2
+        },
+        actions: {
+          increment(state) {
+            state.count += 1;
+          }
         }
-      }
-    })
+      })
+    )
   )
 );
 ```
@@ -43,7 +43,13 @@ const useStore = create(() =>
 
 - `@coaction/pinia` only supports binding a whole Pinia store.
 - Coaction `Slices` mode is not supported in this adapter.
+- `bindPinia()` does not set Pinia's global active instance. Use `adapt()` for
+  Coaction-owned Pinia definitions, or provide your own active Pinia when using
+  raw Pinia store definitions directly.
+- Unknown root properties written directly to the Pinia store are ignored by
+  Coaction's fixed schema. They are not promoted into Coaction raw/public state,
+  and this adapter does not guarantee pruning them from the Pinia store.
 
 ## 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,159 @@
-"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 coaction = require("coaction");
+let pinia = require("pinia");
+//#region packages/coaction-pinia/src/index.ts
+const instancesMap = /* @__PURE__ */ new WeakMap();
+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 {
+			(0, coaction.replaceMutableAdapterState)(internal.rootState ?? rawState, mutableStore, store.getState(), snapshot);
+		} finally {
+			lastSnapshot = (0, coaction.snapshotMutableAdapterPureState)(store);
+			isApplyingCoactionState = false;
+		}
+	};
+	const syncSharedExternalChange = () => {
+		const currentSnapshot = (0, coaction.snapshotMutableAdapterPureState)(store);
+		if (isApplyingCoactionState) {
+			lastSnapshot = currentSnapshot;
+			return "handled";
+		}
+		if (store.share === "client" && lastSnapshot) {
+			if (!(0, coaction.isEqualMutableAdapterSnapshot)(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) => {
+			internal.assertAlive?.("subscribe");
+			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.getPureState(), patches) => {
+			internal.assertAlive?.("apply");
+			isApplyingCoactionState = true;
+			try {
+				if (!patches) {
+					if (nextState === store.getState()) return;
+					(0, coaction.replaceMutableAdapterState)(internal.rootState ?? rawState, internal.toMutableRaw(rawState), store.getState(), nextState);
+					return;
+				}
+				(0, coaction.applyMutableAdapterPatches)(nextState, patches, internal.rootState ?? rawState, internal.toMutableRaw(rawState), store.getState());
+			} finally {
+				lastSnapshot = (0, coaction.snapshotMutableAdapterPureState)(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, () => {
+		(0, coaction.replaceMutableAdapterState)(internal.rootState ?? rawState, mutableStore, store.getState(), (0, coaction.sanitizeInitialStateValue)((0, coaction.snapshotMutableAdapterPureState)(store)));
+		lastSnapshot = (0, coaction.snapshotMutableAdapterPureState)(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 __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"));
-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
+/**
+* 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);
+		return {
+			copyState: options,
+			key: "actions",
+			bind: (state) => {
+				instancesMap.set(rawState, state);
+				return rawState;
+			}
+		};
+	})
 });
-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);
+/**
+* Adapt a store type to Pinia
+*/
+const adapt = (store) => {
+	if (typeof store !== "function") return store;
+	const pinia$1 = (0, pinia.createPinia)();
+	const boundStore = ((...args) => {
+		const [piniaOverride, hot] = args;
+		return store(piniaOverride ?? pinia$1, hot);
+	});
+	Object.assign(boundStore, store);
+	return boundStore;
 };
-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;
-      }
-    };
-  })
-});
-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
+//#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,150 @@
-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 });
+import { applyMutableAdapterPatches, createBinder, isEqualMutableAdapterSnapshot, onStoreReady, replaceExternalStoreState, replaceMutableAdapterState, sanitizeInitialStateValue, snapshotMutableAdapterPureState } from "coaction";
+import { createPinia } from "pinia";
+export * from "pinia";
+//#endregion
+//#region packages/coaction-pinia/src/index.ts
+const instancesMap = /* @__PURE__ */ new WeakMap();
+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 {
+			replaceMutableAdapterState(internal.rootState ?? rawState, mutableStore, store.getState(), snapshot);
+		} finally {
+			lastSnapshot = snapshotMutableAdapterPureState(store);
+			isApplyingCoactionState = false;
+		}
+	};
+	const syncSharedExternalChange = () => {
+		const currentSnapshot = snapshotMutableAdapterPureState(store);
+		if (isApplyingCoactionState) {
+			lastSnapshot = currentSnapshot;
+			return "handled";
+		}
+		if (store.share === "client" && lastSnapshot) {
+			if (!isEqualMutableAdapterSnapshot(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) => {
+			internal.assertAlive?.("subscribe");
+			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.getPureState(), patches) => {
+			internal.assertAlive?.("apply");
+			isApplyingCoactionState = true;
+			try {
+				if (!patches) {
+					if (nextState === store.getState()) return;
+					replaceMutableAdapterState(internal.rootState ?? rawState, internal.toMutableRaw(rawState), store.getState(), nextState);
+					return;
+				}
+				applyMutableAdapterPatches(nextState, patches, internal.rootState ?? rawState, internal.toMutableRaw(rawState), store.getState());
+			} finally {
+				lastSnapshot = snapshotMutableAdapterPureState(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, () => {
+		replaceMutableAdapterState(internal.rootState ?? rawState, mutableStore, store.getState(), sanitizeInitialStateValue(snapshotMutableAdapterPureState(store)));
+		lastSnapshot = snapshotMutableAdapterPureState(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 __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 { 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);
-};
-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;
-      }
-    };
-  })
+/**
+* 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);
+		return {
+			copyState: options,
+			key: "actions",
+			bind: (state) => {
+				instancesMap.set(rawState, state);
+				return rawState;
+			}
+		};
+	})
 });
-var adapt = (store) => store;
-
-// index.ts
-__reExport(index_exports, src_exports);
-export {
-  adapt,
-  bindPinia
+/**
+* Adapt a store type to Pinia
+*/
+const adapt = (store) => {
+	if (typeof store !== "function") return store;
+	const pinia = createPinia();
+	const boundStore = ((...args) => {
+		const [piniaOverride, hot] = args;
+		return store(piniaOverride ?? pinia, hot);
+	});
+	Object.assign(boundStore, store);
+	return boundStore;
 };
+//#endregion
+export { adapt, bindPinia };

package/package.json

@@ -1,75 +1,68 @@
 {
   "name": "@coaction/pinia",
-  "version": "1.5.0",
+  "version": "2.1.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",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
       "default": "./dist/index.mjs"
     },
     "./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.1.0"
   },
-  "dependencies": {
-    "mutability": "^1.2.1"
-  },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
+  "peerDependencies": {
+    "coaction": ">=2.1.0 <3",
+    "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"
   }
 }