coaction 3.0.0 → 3.1.0

package/dist/local.mjs

@@ -1,30 +1,41 @@
 import { apply, create, isDraft } from "mutative";
 import { computed, computed as computed$1, effect, effectScope, endBatch, endBatch as endBatch$1, isComputed, isEffect, isEffectScope, isSignal, signal, signal as signal$1, startBatch, startBatch as startBatch$1, trigger } from "alien-signals";
 //#region packages/core/src/lifecycle.ts
-const readyStores = /* @__PURE__ */ new WeakSet();
-const readyCallbacks = /* @__PURE__ */ new WeakMap();
+const storeReadyRuntimeSymbol = Symbol.for("coaction.lifecycle.ready");
+const getStoreReadyRuntime = (store, create = false) => {
+	const target = store;
+	const existing = target[storeReadyRuntimeSymbol];
+	if (existing || !create) return existing;
+	const runtime = {
+		callbacks: /* @__PURE__ */ new Set(),
+		ready: false
+	};
+	Object.defineProperty(target, storeReadyRuntimeSymbol, {
+		configurable: true,
+		enumerable: true,
+		value: runtime,
+		writable: true
+	});
+	return runtime;
+};
 const onStoreReady = (store, callback) => {
-	if (readyStores.has(store)) {
+	const runtime = getStoreReadyRuntime(store, true);
+	if (runtime.ready) {
 		callback();
 		return () => void 0;
 	}
-	let callbacks = readyCallbacks.get(store);
-	if (!callbacks) {
-		callbacks = /* @__PURE__ */ new Set();
-		readyCallbacks.set(store, callbacks);
-	}
-	callbacks.add(callback);
+	runtime.callbacks.add(callback);
 	return () => {
-		callbacks?.delete(callback);
+		runtime.callbacks.delete(callback);
 	};
 };
 const markStoreReady = (store) => {
-	readyStores.add(store);
-	const callbacks = readyCallbacks.get(store);
-	if (!callbacks) return;
-	readyCallbacks.delete(store);
+	const runtime = getStoreReadyRuntime(store, true);
+	if (runtime.ready) return;
+	runtime.ready = true;
+	const callbacks = [...runtime.callbacks];
+	runtime.callbacks.clear();
 	callbacks.forEach((callback) => callback());
-	callbacks.clear();
 };
 //#endregion
 //#region packages/core/src/applyMiddlewares.ts
@@ -77,15 +88,64 @@ const warnDroppedUnsafePatches = (unsafePatches, source) => {
 };
 const sanitizePatches = (patches, options = {}) => {
 	if (options.warnOnDropped) warnDroppedUnsafePatches(getUnsafePatchPaths(patches), options.source ?? "patches");
+	const seen = /* @__PURE__ */ new WeakMap();
 	return patches?.filter((patch) => !hasUnsafePatchPath(patch.path)).map((patch) => Object.prototype.hasOwnProperty.call(patch, "value") ? {
 		...patch,
-		value: sanitizeReplacementState(patch.value)
+		value: sanitizeReplacementState(patch.value, seen)
 	} : patch);
 };
 const sanitizeCheckedPatches = (patches, source) => {
 	assertSafePatches(patches, source);
 	return sanitizePatches(patches) ?? [];
 };
+const createRootReplacementPatches = (currentState, nextState) => {
+	const patches = [];
+	const inversePatches = [];
+	const nextKeys = new Set(getOwnEnumerableKeys(nextState));
+	for (const key of getOwnEnumerableKeys(currentState)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		if (nextKeys.has(key)) continue;
+		patches.push({
+			op: "remove",
+			path: [key]
+		});
+		inversePatches.push({
+			op: "add",
+			path: [key],
+			value: currentState[key]
+		});
+	}
+	for (const key of nextKeys) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		if (!Object.prototype.hasOwnProperty.call(currentState, key)) {
+			patches.push({
+				op: "add",
+				path: [key],
+				value: nextState[key]
+			});
+			inversePatches.push({
+				op: "remove",
+				path: [key]
+			});
+			continue;
+		}
+		if (Object.is(currentState[key], nextState[key])) continue;
+		patches.push({
+			op: "replace",
+			path: [key],
+			value: nextState[key]
+		});
+		inversePatches.push({
+			op: "replace",
+			path: [key],
+			value: currentState[key]
+		});
+	}
+	return {
+		patches,
+		inversePatches
+	};
+};
 const setOwnEnumerable = (target, key, value) => {
 	if (typeof key === "string" && isUnsafeKey(key)) return;
 	target[key] = value;
@@ -377,20 +437,92 @@ const getInitialState = (store, createState, internal) => {
 	}, {});
 };
 //#endregion
+//#region packages/core/src/storeCommit.ts
+const storeCommitRuntimeSymbol = Symbol.for("coaction.storeCommit.runtime");
+const getStoreCommitRuntime = (store, create = false) => {
+	const target = store;
+	const existing = target[storeCommitRuntimeSymbol];
+	if (existing || !create) return existing;
+	const runtime = {
+		disposed: false,
+		listeners: /* @__PURE__ */ new Set(),
+		prepareListeners: /* @__PURE__ */ new Set()
+	};
+	Object.defineProperty(target, storeCommitRuntimeSymbol, {
+		configurable: true,
+		enumerable: true,
+		value: runtime,
+		writable: true
+	});
+	return runtime;
+};
+/** @internal */
+const hasStoreCommitListeners = (store) => Boolean(getStoreCommitRuntime(store)?.listeners.size);
+/** @internal */
+const publishStoreCommit = (store, commit) => {
+	const runtime = getStoreCommitRuntime(store);
+	if (!runtime || runtime.disposed || !runtime.listeners.size) return;
+	for (const listener of [...runtime.listeners]) listener(commit);
+};
+/** @internal */
+const prepareStoreCommit = (store, commit) => {
+	const runtime = getStoreCommitRuntime(store);
+	if (!runtime || runtime.disposed || !runtime.prepareListeners.size) return false;
+	let replace = false;
+	for (const listener of runtime.prepareListeners) replace = listener(commit) === true || replace;
+	return replace;
+};
+/** @internal */
+const getStoreCommitSource = (store, fallback) => getStoreCommitRuntime(store)?.source ?? fallback;
+/** @internal */
+const runWithStoreCommitSource = (store, source, callback) => {
+	const runtime = getStoreCommitRuntime(store, true);
+	const previousSource = runtime.source;
+	runtime.source = source;
+	try {
+		return callback();
+	} finally {
+		runtime.source = previousSource;
+	}
+};
+/** @internal */
+const registerStorePatchReplayer = (store, replay) => {
+	const runtime = getStoreCommitRuntime(store, true);
+	runtime.replay = replay;
+};
+/** @internal */
+const disposeStoreCommitRuntime = (store) => {
+	const runtime = getStoreCommitRuntime(store);
+	if (!runtime) return;
+	runtime.disposed = true;
+	runtime.listeners.clear();
+	runtime.prepareListeners.clear();
+	runtime.source = void 0;
+	runtime.replay = void 0;
+};
+//#endregion
 //#region packages/core/src/handleDraft.ts
 const handleDraft = (store, internal) => {
 	internal.rootState = internal.backupState;
 	const [, patches, inversePatches] = internal.finalizeDraft();
-	const safePatches = sanitizeCheckedPatches((store.patch ? store.patch({
+	const finalPatches = store.patch ? store.patch({
 		patches,
 		inversePatches
 	}) : {
 		patches,
 		inversePatches
-	}).patches, "store.patch()");
+	};
+	const safePatches = sanitizeCheckedPatches(finalPatches.patches, "store.patch()");
+	const safeInversePatches = sanitizeCheckedPatches(finalPatches.inversePatches, "store.patch() inverse patches");
 	if (safePatches.length) {
 		store.apply(internal.rootState, safePatches);
 		internal.emitPatches?.(safePatches);
+		publishStoreCommit(store, {
+			state: internal.rootState,
+			patches: safePatches,
+			inversePatches: safeInversePatches,
+			source: "mutableAction"
+		});
 	}
 };
 //#endregion
@@ -437,7 +569,7 @@ const createLocalAction = ({ fn, internal, key, options, store, sliceKey }) => {
 				throw error;
 			}
 		};
-		const enablePatches = store.transport ?? options.enablePatches;
+		const enablePatches = Boolean(store.transport ?? options.enablePatches) || hasStoreCommitListeners(store);
 		return traceAction(() => {
 			if (internal.mutableInstance && !internal.isBatching && enablePatches) {
 				let result;
@@ -745,8 +877,10 @@ const getRawState = (store, internal, initialState, options, createClientAction)
 //#region packages/core/src/handleState.ts
 const handleState = (store, internal, options) => {
 	let defaultResultValidated = false;
+	let pendingCommitSource;
 	const defaultUpdater = (next) => {
 		defaultResultValidated = false;
+		let producedState;
 		const merge = (_next = next) => {
 			if (_next !== next) internal.validateState?.(_next);
 			assertKnownStateShape(_next, internal.rootState, internal.stateSchema, store.isSliceStore);
@@ -760,7 +894,7 @@ const handleState = (store, internal, options) => {
 			}
 			if (typeof returnValue === "object" && returnValue !== null) merge(returnValue);
 		} : merge;
-		if (!(store.transport ?? options.enablePatches) && internal.mutableInstance) {
+		if (!(Boolean(store.transport ?? options.enablePatches) || hasStoreCommitListeners(store)) && internal.mutableInstance) {
 			if (internal.actMutable) {
 				internal.actMutable(() => {
 					fn.apply(null);
@@ -782,6 +916,7 @@ const handleState = (store, internal, options) => {
 			}, { enablePatches: true });
 			assertKnownStateShape(result[0], internal.backupState, internal.stateSchema, store.isSliceStore, { requireSliceRoots: true });
 			internal.validateState?.(internal.getTransportState?.() ?? result[0]);
+			producedState = result[0];
 			patches = result[1];
 			inversePatches = result[2];
 		} finally {
@@ -798,6 +933,18 @@ const handleState = (store, internal, options) => {
 		if (!patch) internal.validatePatches?.(finalPatches.patches);
 		const safePatches = sanitizeCheckedPatches(finalPatches.patches, "store.patch()");
 		const safeInversePatches = sanitizeCheckedPatches(finalPatches.inversePatches, "store.patch() inverse patches");
+		if (producedState && safePatches.some((patch) => typeof patch.value === "object" && patch.value !== null) && prepareStoreCommit(store, {
+			state: producedState,
+			patches: safePatches,
+			inversePatches: safeInversePatches,
+			source: "setState"
+		})) {
+			runWithStoreCommitSource(store, "setState", () => {
+				store.apply(producedState);
+			});
+			defaultResultValidated = true;
+			return [];
+		}
 		if (safePatches.length) {
 			defaultResultValidated = internal.applyValidatedPatches?.(internal.rootState, safePatches, !patch) ?? false;
 			if (!internal.applyValidatedPatches) store.apply(internal.rootState, safePatches);
@@ -809,6 +956,8 @@ const handleState = (store, internal, options) => {
 		];
 	};
 	const setState = (next, updater = defaultUpdater) => {
+		const commitSource = pendingCommitSource ?? "setState";
+		pendingCommitSource = void 0;
 		internal.assertAlive?.("setState");
 		internal.assertMutationAllowed?.("setState");
 		if (store.share === "client") throw new Error(`setState() cannot be called in the client store. To update the state, please trigger a store method with setState() instead.`);
@@ -819,7 +968,7 @@ const handleState = (store, internal, options) => {
 			assertKnownStateShape(next, internal.rootState, internal.stateSchema, store.isSliceStore);
 		}
 		internal.isBatching = true;
-		if (!store.share && !options.enablePatches && !internal.mutableInstance && updater === defaultUpdater) try {
+		if (!store.share && !options.enablePatches && !hasStoreCommitListeners(store) && !internal.mutableInstance && updater === defaultUpdater) try {
 			if (typeof next === "function") try {
 				internal.backupState = internal.rootState;
 				const snapshotCache = internal.computedSnapshotCache;
@@ -900,13 +1049,60 @@ const handleState = (store, internal, options) => {
 				sanitizeCheckedPatches(result[2], "setState updater inverse result")
 			];
 		}
-		if (result?.[1]) internal.emitPatches?.(result[1]);
+		if (result?.length === 3) {
+			const [, patches, inversePatches] = result;
+			internal.emitPatches?.(patches);
+			if (patches.length || inversePatches.length) publishStoreCommit(store, {
+				state: internal.rootState,
+				patches,
+				inversePatches,
+				source: commitSource
+			});
+		}
 		return result;
 	};
+	const replayPatches = ({ patches, inversePatches }, replaySetState = setState) => {
+		const previousSource = pendingCommitSource;
+		pendingCommitSource = "replay";
+		try {
+			replaySetState(internal.rootState, () => {
+				const inputPatches = patches.map((patch) => ({
+					...patch,
+					path: Array.isArray(patch.path) ? [...patch.path] : patch.path
+				}));
+				const inputInversePatches = inversePatches.map((patch) => ({
+					...patch,
+					path: Array.isArray(patch.path) ? [...patch.path] : patch.path
+				}));
+				const finalPatches = store.patch ? store.patch({
+					patches: inputPatches,
+					inversePatches: inputInversePatches
+				}) : {
+					patches: inputPatches,
+					inversePatches: inputInversePatches
+				};
+				const safePatches = sanitizeCheckedPatches(finalPatches.patches, "store.patch()");
+				const safeInversePatches = sanitizeCheckedPatches(finalPatches.inversePatches, "store.patch() inverse patches");
+				if (safePatches.length) {
+					internal.applyValidatedPatches?.(internal.rootState, safePatches, false);
+					if (!internal.applyValidatedPatches) store.apply(internal.rootState, safePatches);
+				}
+				return [
+					internal.rootState,
+					safePatches,
+					safeInversePatches
+				];
+			});
+			return internal.rootState;
+		} finally {
+			pendingCommitSource = previousSource;
+		}
+	};
 	const getState = (deps, selector) => deps && selector ? new Computed(deps, selector) : internal.module;
 	return {
 		setState,
-		getState
+		getState,
+		replayPatches
 	};
 };
 //#endregion
@@ -949,7 +1145,7 @@ const createStore = (createState, options, runtime = {}) => {
 		namespaceMap.set(name, true);
 	}
 	try {
-		const { setState, getState } = handleState(store, internal, options);
+		const { setState, getState, replayPatches } = handleState(store, internal, options);
 		const subscribe = (listener) => {
 			internal.assertAlive?.("subscribe");
 			internal.listeners.add(listener);
@@ -971,6 +1167,7 @@ const createStore = (createState, options, runtime = {}) => {
 				firstError ??= error;
 			}
 			internal.listeners.clear();
+			disposeStoreCommitRuntime(store);
 			try {
 				store.transport?.dispose();
 			} catch (error) {
@@ -999,7 +1196,23 @@ const createStore = (createState, options, runtime = {}) => {
 			if (internal.updateImmutable) internal.updateImmutable(internal.rootState);
 			else internal.listeners.forEach((listener) => listener());
 		};
-		const apply$1 = (state = internal.rootState, patches) => applyState(state, patches);
+		const apply$1 = (state = internal.rootState, patches) => {
+			const observeReplacement = patches === void 0 && hasStoreCommitListeners(store);
+			const previousState = internal.rootState;
+			applyState(state, patches);
+			if (!observeReplacement) return;
+			const replacement = createRootReplacementPatches(previousState, internal.rootState);
+			const safePatches = sanitizeCheckedPatches(replacement.patches, "store.apply() replacement");
+			const safeInversePatches = sanitizeCheckedPatches(replacement.inversePatches, "store.apply() replacement inverse patches");
+			if (!safePatches.length && !safeInversePatches.length) return;
+			internal.emitPatches?.(safePatches);
+			publishStoreCommit(store, {
+				state: internal.rootState,
+				patches: safePatches,
+				inversePatches: safeInversePatches,
+				source: getStoreCommitSource(store, "external")
+			});
+		};
 		internal.applyValidatedPatches = (state, patches, skipFinalValidation) => {
 			if (store.apply !== apply$1) {
 				store.apply(state, patches);
@@ -1041,6 +1254,7 @@ const createStore = (createState, options, runtime = {}) => {
 		});
 		const middlewareStore = applyMiddlewares(store, options.middlewares ?? []);
 		if (middlewareStore !== store) Object.assign(store, middlewareStore);
+		registerStorePatchReplayer(store, replayPatches);
 		internal.assertAlive?.("store initialization");
 		if (validatePatches && store.patch) {
 			const patch = store.patch.bind(store);