@coaction/valtio 1.4.1 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @coaction/valtio
 
-![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/valtio.svg)](https://www.npmjs.com/package/@coaction/valtio)
 ![license](https://img.shields.io/npm/l/@coaction/valtio)
 
@@ -40,4 +40,4 @@ store.getState().increment();
 
 ## 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,8 +1,11 @@
-export * from 'valtio/vanilla';
-export { proxy } from 'valtio/vanilla';
+import { proxy } from "valtio/vanilla";
+export * from "valtio/vanilla";
 
+//#region \0rolldown/runtime.js
+//#endregion
+//#region packages/coaction-valtio/src/index.d.ts
 interface BindValtio {
-    <T extends object>(target: T): T;
+  <T extends object>(target: T): T;
 }
 /**
  * Bind a store to Valtio.
@@ -12,5 +15,8 @@ declare const bindValtio: BindValtio;
  * Adapt a Valtio store type to state type.
  */
 declare const adapt: <T extends object>(store: T) => T;
-
-export { adapt, bindValtio };
+declare namespace index_d_exports {
+  export { adapt, bindValtio, proxy };
+}
+//#endregion
+export { adapt, bindValtio, proxy };

package/dist/index.d.ts

@@ -1,8 +1,11 @@
-export * from 'valtio/vanilla';
-export { proxy } from 'valtio/vanilla';
+import { proxy } from "valtio/vanilla";
+export * from "valtio/vanilla";
 
+//#region \0rolldown/runtime.js
+//#endregion
+//#region packages/coaction-valtio/src/index.d.ts
 interface BindValtio {
-    <T extends object>(target: T): T;
+  <T extends object>(target: T): T;
 }
 /**
  * Bind a store to Valtio.
@@ -12,5 +15,8 @@ declare const bindValtio: BindValtio;
  * Adapt a Valtio store type to state type.
  */
 declare const adapt: <T extends object>(store: T) => T;
-
-export { adapt, bindValtio };
+declare namespace index_d_exports {
+  export { adapt, bindValtio, proxy };
+}
+//#endregion
+export { adapt, bindValtio, proxy };

package/dist/index.js

@@ -1,85 +1,227 @@
-"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 valtio_vanilla = require("valtio/vanilla");
+//#region packages/coaction-valtio/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,
-  bindValtio: () => bindValtio,
-  proxy: () => import_vanilla.proxy
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  adapt: () => adapt,
-  bindValtio: () => bindValtio,
-  proxy: () => import_vanilla.proxy
-});
-var import_mutability = require("mutability");
-var import_coaction = require("coaction");
-var import_vanilla = require("valtio/vanilla");
-__reExport(src_exports, require("valtio/vanilla"));
-var instancesMap = /* @__PURE__ */ new WeakMap();
-var handleStore = (store, rawState, state, internal) => {
-  if (!internal.toMutableRaw) {
-    internal.toMutableRaw = (key) => instancesMap.get(key);
-    const getMutableState = () => internal.toMutableRaw?.(rawState) ?? rawState;
-    Object.assign(store, {
-      subscribe: (listener) => (0, import_vanilla.subscribe)(getMutableState(), listener)
-    });
-    store.apply = (state2 = store.getState(), patches) => {
-      if (!patches) {
-        Object.assign(store.getState(), state2);
-        return;
-      }
-      (0, import_mutability.apply)(state2, patches);
-    };
-  }
+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, rawState, state, internal) => {
+	if (!internal.toMutableRaw) {
+		internal.toMutableRaw = (key) => instancesMap.get(key);
+		const getMutableState = () => internal.toMutableRaw?.(rawState) ?? rawState;
+		let isApplyingCoactionState = false;
+		let lastSnapshot;
+		const restoreClientState = (snapshot) => {
+			isApplyingCoactionState = true;
+			try {
+				replaceMutableState(internal.rootState ?? rawState, getMutableState(), 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";
+		};
+		store._destroyers = /* @__PURE__ */ new Set();
+		store._listeners = /* @__PURE__ */ new Set();
+		let unsubscribeExternal;
+		const cancelReadySubscription = (0, coaction.onStoreReady)(store, () => {
+			replaceMutableState(internal.rootState ?? rawState, getMutableState(), store.getState(), (0, coaction.sanitizeInitialStateValue)(snapshotPureState(store)));
+			lastSnapshot = snapshotPureState(store);
+			unsubscribeExternal = (0, valtio_vanilla.subscribe)(getMutableState(), () => {
+				const change = syncSharedExternalChange();
+				if (change === "ignored") return;
+				if (change === "external") internal.notifyStateChange?.();
+				store._listeners?.forEach((listener) => listener());
+			});
+		});
+		Object.assign(store, { subscribe: (listener) => {
+			store._listeners.add(listener);
+			return () => {
+				store._listeners?.delete(listener);
+			};
+		} });
+		const baseDestroy = store.destroy;
+		let destroyed = false;
+		store.destroy = () => {
+			if (destroyed) return;
+			destroyed = true;
+			cancelReadySubscription();
+			unsubscribeExternal?.();
+			unsubscribeExternal = void 0;
+			store._listeners?.clear();
+			store._listeners = void 0;
+			store._destroyers?.forEach((destroy) => destroy());
+			store._destroyers?.clear();
+			store._destroyers = void 0;
+			baseDestroy();
+		};
+		store.apply = (state = store.getState(), patches) => {
+			isApplyingCoactionState = true;
+			try {
+				if (!patches) {
+					replaceMutableState(internal.rootState ?? rawState, getMutableState(), store.getState(), state);
+					return;
+				}
+				(0, mutability.apply)(state, patches);
+			} finally {
+				lastSnapshot = snapshotPureState(store);
+				isApplyingCoactionState = false;
+				internal.notifyStateChange?.();
+			}
+		};
+	}
 };
-var bindValtio = (0, import_coaction.createBinder)({
-  handleStore,
-  handleState: (options) => {
-    const descriptors = Object.getOwnPropertyDescriptors(options);
-    const copyState = Object.defineProperties(
-      {},
-      descriptors
-    );
-    const rawState = Object.defineProperties({}, descriptors);
-    return {
-      copyState,
-      bind: (state) => {
-        instancesMap.set(rawState, state);
-        return rawState;
-      }
-    };
-  }
+/**
+* Bind a store to Valtio.
+*/
+const bindValtio = (0, coaction.createBinder)({
+	handleStore,
+	handleState: (options) => {
+		const descriptors = Object.getOwnPropertyDescriptors(options);
+		const copyState = Object.defineProperties({}, descriptors);
+		const rawState = Object.defineProperties({}, descriptors);
+		return {
+			copyState,
+			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,
-  bindValtio,
-  proxy
+/**
+* Adapt a Valtio store type to state type.
+*/
+const adapt = (store) => store;
+//#endregion
+exports.adapt = adapt;
+exports.bindValtio = bindValtio;
+exports.proxy = valtio_vanilla.proxy;
+Object.keys(valtio_vanilla).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return valtio_vanilla[k];
+		}
+	});
 });

package/dist/index.mjs

@@ -1,82 +1,217 @@
-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,
-  bindValtio: () => bindValtio,
-  proxy: () => proxy
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  adapt: () => adapt,
-  bindValtio: () => bindValtio,
-  proxy: () => proxy
-});
-__reExport(src_exports, vanilla_star);
 import { apply } from "mutability";
-import { createBinder } from "coaction";
+import { createBinder, onStoreReady, replaceExternalStoreState, sanitizeInitialStateValue, sanitizeReplacementState } from "coaction";
 import { proxy, subscribe } from "valtio/vanilla";
-import * as vanilla_star from "valtio/vanilla";
-var instancesMap = /* @__PURE__ */ new WeakMap();
-var handleStore = (store, rawState, state, internal) => {
-  if (!internal.toMutableRaw) {
-    internal.toMutableRaw = (key) => instancesMap.get(key);
-    const getMutableState = () => internal.toMutableRaw?.(rawState) ?? rawState;
-    Object.assign(store, {
-      subscribe: (listener) => subscribe(getMutableState(), listener)
-    });
-    store.apply = (state2 = store.getState(), patches) => {
-      if (!patches) {
-        Object.assign(store.getState(), state2);
-        return;
-      }
-      apply(state2, patches);
-    };
-  }
+export * from "valtio/vanilla";
+//#endregion
+//#region packages/coaction-valtio/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 bindValtio = createBinder({
-  handleStore,
-  handleState: (options) => {
-    const descriptors = Object.getOwnPropertyDescriptors(options);
-    const copyState = Object.defineProperties(
-      {},
-      descriptors
-    );
-    const rawState = Object.defineProperties({}, descriptors);
-    return {
-      copyState,
-      bind: (state) => {
-        instancesMap.set(rawState, state);
-        return rawState;
-      }
-    };
-  }
-});
-var adapt = (store) => store;
-
-// index.ts
-__reExport(index_exports, src_exports);
-export {
-  adapt,
-  bindValtio,
-  proxy
+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, rawState, state, internal) => {
+	if (!internal.toMutableRaw) {
+		internal.toMutableRaw = (key) => instancesMap.get(key);
+		const getMutableState = () => internal.toMutableRaw?.(rawState) ?? rawState;
+		let isApplyingCoactionState = false;
+		let lastSnapshot;
+		const restoreClientState = (snapshot) => {
+			isApplyingCoactionState = true;
+			try {
+				replaceMutableState(internal.rootState ?? rawState, getMutableState(), 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";
+		};
+		store._destroyers = /* @__PURE__ */ new Set();
+		store._listeners = /* @__PURE__ */ new Set();
+		let unsubscribeExternal;
+		const cancelReadySubscription = onStoreReady(store, () => {
+			replaceMutableState(internal.rootState ?? rawState, getMutableState(), store.getState(), sanitizeInitialStateValue(snapshotPureState(store)));
+			lastSnapshot = snapshotPureState(store);
+			unsubscribeExternal = subscribe(getMutableState(), () => {
+				const change = syncSharedExternalChange();
+				if (change === "ignored") return;
+				if (change === "external") internal.notifyStateChange?.();
+				store._listeners?.forEach((listener) => listener());
+			});
+		});
+		Object.assign(store, { subscribe: (listener) => {
+			store._listeners.add(listener);
+			return () => {
+				store._listeners?.delete(listener);
+			};
+		} });
+		const baseDestroy = store.destroy;
+		let destroyed = false;
+		store.destroy = () => {
+			if (destroyed) return;
+			destroyed = true;
+			cancelReadySubscription();
+			unsubscribeExternal?.();
+			unsubscribeExternal = void 0;
+			store._listeners?.clear();
+			store._listeners = void 0;
+			store._destroyers?.forEach((destroy) => destroy());
+			store._destroyers?.clear();
+			store._destroyers = void 0;
+			baseDestroy();
+		};
+		store.apply = (state = store.getState(), patches) => {
+			isApplyingCoactionState = true;
+			try {
+				if (!patches) {
+					replaceMutableState(internal.rootState ?? rawState, getMutableState(), store.getState(), state);
+					return;
+				}
+				apply(state, patches);
+			} finally {
+				lastSnapshot = snapshotPureState(store);
+				isApplyingCoactionState = false;
+				internal.notifyStateChange?.();
+			}
+		};
+	}
+};
+/**
+* Bind a store to Valtio.
+*/
+const bindValtio = createBinder({
+	handleStore,
+	handleState: (options) => {
+		const descriptors = Object.getOwnPropertyDescriptors(options);
+		const copyState = Object.defineProperties({}, descriptors);
+		const rawState = Object.defineProperties({}, descriptors);
+		return {
+			copyState,
+			bind: (state) => {
+				instancesMap.set(rawState, state);
+				return rawState;
+			}
+		};
+	}
+});
+/**
+* Adapt a Valtio store type to state type.
+*/
+const adapt = (store) => store;
+//#endregion
+export { adapt, bindValtio, proxy };

package/package.json

@@ -1,20 +1,31 @@
 {
   "name": "@coaction/valtio",
-  "version": "1.4.1",
+  "version": "2.0.0",
   "description": "A Coaction integration tool for Valtio",
   "keywords": [
-    "state",
     "coaction",
-    "valtio",
-    "proxy"
-  ],
-  "authors": [
-    "Michael Lin <unadlib@gmail.com> (https://github.com/unadlib)"
+    "proxy",
+    "state",
+    "valtio"
   ],
-  "homepage": "https://github.com/unadlib/coaction/tree/main/packages/coaction-valtio#readme",
+  "homepage": "https://github.com/coactionjs/coaction/tree/main/packages/coaction-valtio#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-valtio"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
   "main": "dist/index.js",
   "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -24,52 +35,29 @@
     },
     "./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-valtio"
-  },
-  "bugs": {
-    "url": "https://github.com/unadlib/coaction/issues"
-  },
-  "peerDependencies": {
-    "coaction": "^1.4.1",
-    "mutative": "^1.1.0",
-    "valtio": "^2.0.0"
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   },
-  "peerDependenciesMeta": {
-    "coaction": {
-      "optional": true
-    },
-    "mutative": {
-      "optional": true
-    },
-    "valtio": {
-      "optional": true
-    }
+  "dependencies": {
+    "mutability": "^1.2.1"
   },
   "devDependencies": {
     "mutative": "^1.3.0",
     "valtio": "^2.3.1",
-    "coaction": "1.4.1"
+    "coaction": "2.0.0"
   },
-  "dependencies": {
-    "mutability": "^1.2.1"
-  },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
+  "peerDependencies": {
+    "coaction": "^2.0.0",
+    "valtio": "^2.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"
   }
 }