coaction 2.0.0 → 3.0.0

package/dist/adapter.mjs

@@ -0,0 +1,548 @@
+import { apply, create } from "mutative";
+import { setActiveSub } from "alien-signals";
+import * as alienSignalsSystem from "alien-signals/system";
+//#region packages/core/src/global.ts
+const getGlobal = () => {
+	let _global;
+	if (typeof window !== "undefined") _global = window;
+	else if (typeof global !== "undefined") _global = global;
+	else if (typeof self !== "undefined") _global = self;
+	else _global = {};
+	return _global;
+};
+getGlobal().SharedWorkerGlobalScope || globalThis.WorkerGlobalScope;
+const bindSymbol = Symbol("bind");
+//#endregion
+//#region packages/core/src/binder.ts
+const createExternalStoreAdapter = ({ handleState, handleStore }) => ((state) => {
+	const { copyState, key, bind } = handleState(state);
+	const value = typeof key !== "undefined" ? copyState[key] : copyState;
+	Object.defineProperty(value, bindSymbol, {
+		configurable: true,
+		enumerable: typeof key !== "undefined",
+		value: {
+			handleStore,
+			bind
+		}
+	});
+	return copyState;
+});
+/**
+* Build an adapter helper for bridging an external store implementation into
+* Coaction.
+*
+* @remarks
+* Import this compatibility helper from `coaction/adapter`.
+*
+* Official bindings use this to integrate stores such as Redux, Jotai, Pinia,
+* Zustand, MobX, and Valtio. Binder-backed integrations are whole-store
+* adapters; they are not compatible with Coaction slices mode.
+*/
+function createBinder({ handleState, handleStore }) {
+	return createExternalStoreAdapter({
+		handleState,
+		handleStore
+	});
+}
+/**
+* Define a whole-store adapter for integrating an external state runtime with
+* Coaction.
+*
+* @remarks
+* Import this helper from `coaction/adapter`. `createBinder()` remains as a
+* compatibility alias for existing official and community integrations.
+*/
+function defineExternalStoreAdapter(options) {
+	return createExternalStoreAdapter(options);
+}
+//#endregion
+//#region packages/core/src/utils.ts
+const isUnsafeKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
+const isUnsafePathSegment = (segment) => typeof segment === "string" && isUnsafeKey(segment);
+var UnsafePatchPathError = class extends Error {
+	name = "UnsafePatchPathError";
+};
+var StateSchemaError = class extends Error {
+	name = "StateSchemaError";
+};
+const isStateSchemaError = (error) => error instanceof StateSchemaError || error instanceof Error && error.name === "StateSchemaError";
+const hasUnsafePatchPath = (path) => {
+	return (Array.isArray(path) ? path : typeof path === "string" ? path.split("/").filter(Boolean).map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~")) : []).some(isUnsafePathSegment);
+};
+const formatPatchPath = (path) => Array.isArray(path) ? path.map((segment) => String(segment)).join(".") : String(path);
+const getUnsafePatchPaths = (patches) => patches?.filter((patch) => hasUnsafePatchPath(patch.path)) ?? [];
+const assertSafePatches = (patches, source = "patches") => {
+	const unsafePatches = getUnsafePatchPaths(patches);
+	if (!unsafePatches.length) return;
+	const paths = unsafePatches.map((patch) => `'${formatPatchPath(patch.path)}'`).join(", ");
+	throw new UnsafePatchPathError(`Unsafe patch path${unsafePatches.length > 1 ? "s" : ""} ${paths} cannot be applied from ${source}.`);
+};
+const warnDroppedUnsafePatches = (unsafePatches, source) => {
+	if (process.env.NODE_ENV !== "development" || !unsafePatches.length) return;
+	const paths = unsafePatches.map((patch) => `'${formatPatchPath(patch.path)}'`).join(", ");
+	console.warn(`Coaction dropped unsafe patch path${unsafePatches.length > 1 ? "s" : ""} ${paths} from ${source}.`);
+};
+const sanitizePatches = (patches, options = {}) => {
+	if (options.warnOnDropped) warnDroppedUnsafePatches(getUnsafePatchPaths(patches), options.source ?? "patches");
+	return patches?.filter((patch) => !hasUnsafePatchPath(patch.path)).map((patch) => Object.prototype.hasOwnProperty.call(patch, "value") ? {
+		...patch,
+		value: sanitizeReplacementState(patch.value)
+	} : 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 createRootStateFromPatches = (currentState, patches) => {
+	const nextState = sanitizeReplacementState(currentState);
+	const seen = /* @__PURE__ */ new WeakMap();
+	for (const patch of patches) {
+		if (!Array.isArray(patch.path) || patch.path.length !== 1 || ![
+			"add",
+			"remove",
+			"replace"
+		].includes(patch.op)) return;
+		const key = patch.path[0];
+		if (patch.op === "remove") {
+			delete nextState[key];
+			continue;
+		}
+		nextState[key] = sanitizeReplacementState(patch.value, seen);
+	}
+	return nextState;
+};
+const applyRootReplacementWithPatches = (store, nextState, options = {}) => {
+	const { patches, inversePatches } = createRootReplacementPatches(store.getPureState(), nextState);
+	const finalPatches = store.patch ? store.patch({
+		patches,
+		inversePatches
+	}) : {
+		patches,
+		inversePatches
+	};
+	const safePatches = sanitizeCheckedPatches(finalPatches.patches, "store.patch()");
+	const safeInversePatches = sanitizeCheckedPatches(finalPatches.inversePatches, "store.patch() inverse patches");
+	if (safePatches.length) {
+		const applyExactReplacement = options.applyExactReplacement;
+		const exactReplacementState = applyExactReplacement ? createRootStateFromPatches(store.getPureState(), safePatches) : void 0;
+		if (applyExactReplacement && exactReplacementState) applyExactReplacement(exactReplacementState);
+		else store.apply(store.getPureState(), safePatches);
+	}
+	return [
+		store.getPureState(),
+		safePatches,
+		safeInversePatches
+	];
+};
+const setOwnEnumerable = (target, key, value) => {
+	if (typeof key === "string" && isUnsafeKey(key)) return;
+	target[key] = value;
+};
+const getOwnEnumerableKeys = (source) => {
+	if (typeof source !== "object" || source === null) return [];
+	return Reflect.ownKeys(source).filter((key) => Object.prototype.propertyIsEnumerable.call(source, key));
+};
+const isArrayIndexKey$1 = (key) => {
+	if (typeof key !== "string") return false;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
+};
+const replaceOwnEnumerable = (target, source) => {
+	const seen = /* @__PURE__ */ new WeakMap();
+	seen.set(source, target);
+	const nextKeys = /* @__PURE__ */ new Set();
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		if (typeof source[key] === "function") continue;
+		nextKeys.add(key);
+	}
+	for (const key of getOwnEnumerableKeys(target)) if (!nextKeys.has(key)) delete target[key];
+	nextKeys.forEach((key) => {
+		setOwnEnumerable(target, key, sanitizeReplacementState(source[key], seen));
+	});
+};
+const sanitizeReplacementState = (source, seen = /* @__PURE__ */ new WeakMap()) => {
+	if (typeof source !== "object" || source === null) return source;
+	const cached = seen.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const target = [];
+		target.length = source.length;
+		seen.set(source, target);
+		for (let index = 0; index < source.length; index += 1) if (Object.prototype.hasOwnProperty.call(source, index)) target[index] = sanitizeReplacementState(source[index], seen);
+		for (const key of getOwnEnumerableKeys(source)) {
+			if (isArrayIndexKey$1(key) || typeof key === "string" && isUnsafeKey(key)) continue;
+			const value = source[key];
+			if (typeof value === "function") continue;
+			setOwnEnumerable(target, key, sanitizeReplacementState(value, seen));
+		}
+		return target;
+	}
+	const prototype = Object.getPrototypeOf(source);
+	if (prototype !== Object.prototype && prototype !== null) return source;
+	const target = Object.create(prototype);
+	seen.set(source, target);
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		const value = source[key];
+		if (typeof value === "function") continue;
+		setOwnEnumerable(target, key, sanitizeReplacementState(value, seen));
+	}
+	return target;
+};
+const sanitizeInitialStateValue = (source, seen = /* @__PURE__ */ new WeakMap()) => {
+	if (typeof source !== "object" || source === null) return source;
+	const cached = seen.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const target = [];
+		target.length = source.length;
+		seen.set(source, target);
+		for (let index = 0; index < source.length; index += 1) if (Object.prototype.hasOwnProperty.call(source, index)) target[index] = sanitizeInitialStateValue(source[index], seen);
+		for (const key of getOwnEnumerableKeys(source)) {
+			if (isArrayIndexKey$1(key) || typeof key === "string" && isUnsafeKey(key)) continue;
+			setOwnEnumerable(target, key, sanitizeInitialStateValue(source[key], seen));
+		}
+		return target;
+	}
+	const prototype = Object.getPrototypeOf(source);
+	if (prototype !== Object.prototype && prototype !== null) return source;
+	const target = Object.create(prototype);
+	seen.set(source, target);
+	for (const key of getOwnEnumerableKeys(source)) {
+		if (typeof key === "string" && isUnsafeKey(key)) continue;
+		setOwnEnumerable(target, key, sanitizeInitialStateValue(source[key], seen));
+	}
+	return target;
+};
+//#endregion
+//#region packages/core/src/externalMutableAdapterUtils.ts
+const getMutableAdapterOwnEnumerableKeys = (value) => Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+const isMutableAdapterUnsafeKey = (key) => typeof key === "string" && isUnsafeKey(key);
+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;
+};
+const isObjectRecord = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const assertCanSetMutableAdapterPublicStateKey = (publicState, key) => {
+	if (Object.prototype.hasOwnProperty.call(publicState, key)) return;
+	if (Object.isExtensible(publicState)) return;
+	throw new StateSchemaError(`Unknown state key '${String(key)}' cannot be added after store initialization. Coaction state schema is fixed.`);
+};
+const ensureMutableAdapterRawDescriptor = (rawState, mutableState, publicState, key) => {
+	if (rawState === mutableState) return;
+	const rawDescriptor = Object.getOwnPropertyDescriptor(rawState, key);
+	if (rawDescriptor?.get && rawDescriptor.set) return;
+	const publicDescriptor = Object.getOwnPropertyDescriptor(publicState, key);
+	if (!publicDescriptor || rawDescriptor?.configurable === false) return;
+	Object.defineProperty(rawState, key, {
+		get: () => mutableState[key],
+		set: (value) => {
+			mutableState[key] = value;
+		},
+		configurable: true,
+		enumerable: publicDescriptor.enumerable
+	});
+};
+const replaceMutableAdapterState = (rawState, mutableState, publicState, source) => {
+	const nextKeys = /* @__PURE__ */ new Set();
+	for (const key of getMutableAdapterOwnEnumerableKeys(source)) {
+		if (isMutableAdapterUnsafeKey(key)) continue;
+		if (typeof source[key] === "function") continue;
+		nextKeys.add(key);
+	}
+	nextKeys.forEach((key) => {
+		assertCanSetMutableAdapterPublicStateKey(publicState, key);
+	});
+	for (const key of getMutableAdapterOwnEnumerableKeys(rawState)) {
+		if (isMutableAdapterUnsafeKey(key)) {
+			delete rawState[key];
+			delete mutableState[key];
+			continue;
+		}
+		if (typeof rawState[key] === "function") continue;
+		if (!nextKeys.has(key)) {
+			delete rawState[key];
+			delete mutableState[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) => {
+		ensureMutableAdapterRawDescriptor(rawState, mutableState, publicState, key);
+		rawState[key] = sanitizeReplacementState(source[key], rawSeen);
+		mutableState[key] = sanitizeReplacementState(source[key], mutableSeen);
+		publicState[key] = sanitizeReplacementState(source[key], publicSeen);
+	});
+};
+const applyMutableAdapterPatches = (baseState, patches, rawState, mutableState, publicState, validateState) => {
+	assertSafePatches(patches, "mutable adapter apply()");
+	const nextState = apply(toMutableAdapterSnapshot(baseState === publicState ? rawState : baseState), patches);
+	validateState?.(nextState);
+	replaceMutableAdapterState(rawState, mutableState, publicState, nextState);
+};
+const toMutableAdapterSnapshot = (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] = toMutableAdapterSnapshot(value[index], visited);
+		const source = value;
+		const target = next;
+		for (const key of getMutableAdapterOwnEnumerableKeys(value)) {
+			if (isArrayIndexKey(key) || isMutableAdapterUnsafeKey(key)) continue;
+			const child = source[key];
+			if (typeof child !== "function") target[key] = toMutableAdapterSnapshot(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 getMutableAdapterOwnEnumerableKeys(value)) {
+			if (isMutableAdapterUnsafeKey(key)) continue;
+			const child = value[key];
+			if (typeof child !== "function") next[key] = toMutableAdapterSnapshot(child, visited);
+		}
+		return next;
+	}
+	return value;
+};
+const snapshotMutableAdapterPureState = (store) => toMutableAdapterSnapshot(store.getPureState());
+const isEqualMutableAdapterSnapshot = (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 = getMutableAdapterOwnEnumerableKeys(left);
+	const rightKeys = getMutableAdapterOwnEnumerableKeys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of leftKeys) {
+		if (!Object.prototype.hasOwnProperty.call(rightRecord, key)) return false;
+		if (!isEqualMutableAdapterSnapshot(leftRecord[key], rightRecord[key], visited)) return false;
+	}
+	return true;
+};
+//#endregion
+//#region packages/core/src/reactiveTracker.ts
+const ReactiveFlags = alienSignalsSystem.ReactiveFlags;
+const unwatch = (node) => {
+	if (!(node.flags & ReactiveFlags.Mutable)) {
+		node.depsTail = void 0;
+		node.flags = 0;
+		purgeDeps(node);
+		const sub = node.subs;
+		if (sub !== void 0) unlink(sub);
+		return;
+	}
+	if (node.depsTail !== void 0) {
+		node.depsTail = void 0;
+		node.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
+		purgeDeps(node);
+	}
+};
+const unlink = (link, sub = link.sub) => {
+	const dep = link.dep;
+	const prevDep = link.prevDep;
+	const nextDep = link.nextDep;
+	const nextSub = link.nextSub;
+	const prevSub = link.prevSub;
+	if (nextDep !== void 0) nextDep.prevDep = prevDep;
+	else sub.depsTail = prevDep;
+	if (prevDep !== void 0) prevDep.nextDep = nextDep;
+	else sub.deps = nextDep;
+	if (nextSub !== void 0) nextSub.prevSub = prevSub;
+	else dep.subsTail = prevSub;
+	if (prevSub !== void 0) prevSub.nextSub = nextSub;
+	else if ((dep.subs = nextSub) === void 0) unwatch(dep);
+	return nextDep;
+};
+const purgeDeps = (sub) => {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink(dep, sub);
+};
+/**
+* Create a low-level signal dependency tracker for framework adapters.
+*
+* @remarks
+* Adapter and framework authors import this helper from `coaction/adapter`.
+*/
+const createReactiveTracker = () => {
+	let version = 0;
+	let disposed = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const node = {
+		deps: void 0,
+		depsTail: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		flags: ReactiveFlags.Watching,
+		fn: () => {
+			if (disposed) return;
+			version += 1;
+			listeners.forEach((listener) => listener());
+		}
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		listeners.clear();
+		node.depsTail = void 0;
+		purgeDeps(node);
+		node.flags = 0;
+	};
+	return {
+		getSnapshot: () => version,
+		subscribe(listener) {
+			if (disposed) return () => void 0;
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		track(fn) {
+			if (disposed) return fn();
+			node.depsTail = void 0;
+			node.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
+			const prevSub = setActiveSub(node);
+			try {
+				return fn();
+			} finally {
+				setActiveSub(prevSub);
+				node.flags &= ~ReactiveFlags.RecursedCheck;
+				purgeDeps(node);
+			}
+		},
+		dispose
+	};
+};
+//#endregion
+//#region packages/core/src/lifecycle.ts
+const readyStores = /* @__PURE__ */ new WeakSet();
+const readyCallbacks = /* @__PURE__ */ new WeakMap();
+const onStoreReady = (store, callback) => {
+	if (readyStores.has(store)) {
+		callback();
+		return () => void 0;
+	}
+	let callbacks = readyCallbacks.get(store);
+	if (!callbacks) {
+		callbacks = /* @__PURE__ */ new Set();
+		readyCallbacks.set(store, callbacks);
+	}
+	callbacks.add(callback);
+	return () => {
+		callbacks?.delete(callback);
+	};
+};
+//#endregion
+//#region packages/core/src/replaceExternalStoreState.ts
+const replaceExternalStoreState = (store, internal, source, { syncImmutable = true } = {}) => {
+	internal.validateReplacementSource?.(source);
+	const [nextState, patches, inversePatches] = create(internal.rootState, (draft) => {
+		replaceOwnEnumerable(draft, source);
+	}, { enablePatches: true });
+	internal.validateState?.(nextState);
+	const safePatches = sanitizeCheckedPatches((store.patch ? store.patch({
+		patches,
+		inversePatches
+	}) : {
+		patches,
+		inversePatches
+	}).patches, "store.patch()");
+	if (!safePatches.length) return;
+	const updateImmutable = internal.updateImmutable;
+	if (!syncImmutable) internal.updateImmutable = void 0;
+	try {
+		store.apply(internal.rootState, safePatches);
+	} finally {
+		internal.updateImmutable = updateImmutable;
+	}
+	internal.emitPatches?.(safePatches);
+};
+//#endregion
+//#region packages/core/src/wrapStore.ts
+/**
+* Convert a store object into Coaction's callable store shape.
+*
+* @remarks
+* Framework bindings use this to attach selector-aware readers while
+* preserving the underlying store API on the returned function object. Most
+* applications should use a public `create` entry instead of calling
+* `wrapStore()` directly. Framework authors import this helper from
+* `coaction/local` or `coaction/adapter`.
+*/
+const wrapStore = (store, getState = () => store.getState()) => {
+	const { name, ..._store } = store;
+	return Object.assign({ [name]: (...args) => getState(...args) }[name], _store);
+};
+//#endregion
+export { StateSchemaError, applyMutableAdapterPatches, applyRootReplacementWithPatches, createBinder, createReactiveTracker, createRootReplacementPatches, defineExternalStoreAdapter, getMutableAdapterOwnEnumerableKeys, isEqualMutableAdapterSnapshot, isMutableAdapterUnsafeKey, isStateSchemaError, onStoreReady, replaceExternalStoreState, replaceMutableAdapterState, replaceOwnEnumerable, sanitizeInitialStateValue, sanitizeReplacementState, snapshotMutableAdapterPureState, toMutableAdapterSnapshot, wrapStore };