@cyclone-ui/state 0.0.12 → 0.0.14

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 # Changelog for Cyclone UI - State
 
+## [0.0.13](https://github.com/storm-software/cyclone-ui/releases/tag/state%400.0.13) (10/11/2026)
+
+### Bug Fixes
+
+- **monorepo:** Update component descriptions and added design sync with Claude Design ([35ece709](https://github.com/storm-software/cyclone-ui/commit/35ece709))
+
+### Features
+
+- **field:** Added the `variant` property to both field and label components ([c1e0c13c](https://github.com/storm-software/cyclone-ui/commit/c1e0c13c))
+- **confetti-burst:** Added the Confetti Burst reusable animation ([b395a334](https://github.com/storm-software/cyclone-ui/commit/b395a334))
+- **like-button:** Added `LikeButton` and `Feedback` components ([9814aa5b](https://github.com/storm-software/cyclone-ui/commit/9814aa5b))
+
+### Updated Dependencies
+
+- Updated **helpers** to **v0.3.12**
+
+## [0.0.12](https://github.com/storm-software/cyclone-ui/releases/tag/state%400.0.12) (10/07/2026)
+
+### Bug Fixes
+
+- **themes:** Clean up typography tokens ([68aee6ad](https://github.com/storm-software/cyclone-ui/commit/68aee6ad))
+
+### Updated Dependencies
+
+- Updated **helpers** to **v0.3.11**
+
 ## [0.0.11](https://github.com/storm-software/cyclone-ui/releases/tag/state%400.0.11) (10/06/2026)
 
 ### Bug Fixes

package/README.md

@@ -27,7 +27,7 @@ This package is part of the <b>🌀 Cyclone UI</b> monorepo. The repository cont
 <!-- markdownlint-disable -->
 
 > [!IMPORTANT] 
-> This repository, and the apps, libraries, and tools contained within, is still in it's initial development phase. As a result, bugs and issues are expected with it's usage. When the main development phase completes, a proper release will be performed, the packages will be availible through NPM (and other distributions), and this message will be removed. However, in the meantime, please feel free to report any issues you may come across.
+> This repository, and the apps, libraries, and tools contained within, is still in it's initial development phase. As a result, bugs and issues are expected with it's usage. When the main development phase completes, a proper release will be performed, the packages will be available through NPM (and other distributions), and this message will be removed. However, in the meantime, please feel free to report any issues you may come across.
 
 <!-- markdownlint-restore -->
 <!-- prettier-ignore-end -->

package/dist/base/atoms/atom-with-broadcast.cjs

@@ -1 +1,45 @@
-const e=require("../utilities/is-atom.cjs"),t=require("./base-atom.cjs");let n=require("@stryke/type-checks/is-function");function r(r,i){let a=e.isAtom(i)?i:t.baseAtom(i),o=/* @__PURE__ */ new Set,s=typeof BroadcastChannel>`u`?void 0:new BroadcastChannel(r);s&&(s.onmessage=e=>{for(let t of o)t(e)});let c=t.baseAtom(e=>e(a),(e,t,r)=>{t(a,(0,n.isFunction)(r.value)?r.value(e(a)):r.value),!r.isEvent&&s&&s.postMessage(JSON.stringify(e(a)))});return c.onMount=e=>{let t=t=>{e({isEvent:!0,value:JSON.parse(t.data)})};return o.add(t),()=>{o.delete(t)}},t.baseAtom(e=>e(c),(e,t,n)=>{t(c,{isEvent:!1,value:n})})}exports.atomWithBroadcast=r;
+const require_is_atom = require("../utilities/is-atom.cjs");
+const require_base_atom = require("./base-atom.cjs");
+let _stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+
+//#region src/base/atoms/atom-with-broadcast.ts
+/**
+* Creates an atom that broadcasts its value to other tabs/windows using the BroadcastChannel API.
+*
+* @param key - The key to use for the BroadcastChannel
+* @param initialValueOrAtom - The initial value of the atom
+* @returns An atom that broadcasts its value to other tabs/windows using the BroadcastChannel API.
+*/
+function atomWithBroadcast(key, initialValueOrAtom) {
+	const valueAtom = require_is_atom.isAtom(initialValueOrAtom) ? initialValueOrAtom : require_base_atom.baseAtom(initialValueOrAtom);
+	const listeners = /* @__PURE__ */ new Set();
+	const channel = typeof BroadcastChannel === "undefined" ? void 0 : new BroadcastChannel(key);
+	if (channel) channel.onmessage = (message) => {
+		for (const listener of listeners) listener(message);
+	};
+	const broadcastAtom = require_base_atom.baseAtom((get) => get(valueAtom), (get, set, update) => {
+		set(valueAtom, (0, _stryke_type_checks_is_function.isFunction)(update.value) ? update.value(get(valueAtom)) : update.value);
+		if (!update.isEvent && channel) channel.postMessage(JSON.stringify(get(valueAtom)));
+	});
+	broadcastAtom.onMount = (setAtom) => {
+		const listener = (event) => {
+			setAtom({
+				isEvent: true,
+				value: JSON.parse(event.data)
+			});
+		};
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	};
+	return require_base_atom.baseAtom((get) => get(broadcastAtom), (_, set, update) => {
+		set(broadcastAtom, {
+			isEvent: false,
+			value: update
+		});
+	});
+}
+
+//#endregion
+exports.atomWithBroadcast = atomWithBroadcast;

package/dist/base/atoms/atom-with-broadcast.mjs

@@ -1,2 +1,46 @@
-import{isAtom as e}from"../utilities/is-atom.mjs";import{baseAtom as t}from"./base-atom.mjs";import{isFunction as n}from"@stryke/type-checks/is-function";function r(r,i){let a=e(i)?i:t(i),o=/* @__PURE__ */ new Set,s=typeof BroadcastChannel>`u`?void 0:new BroadcastChannel(r);s&&(s.onmessage=e=>{for(let t of o)t(e)});let c=t(e=>e(a),(e,t,r)=>{t(a,n(r.value)?r.value(e(a)):r.value),!r.isEvent&&s&&s.postMessage(JSON.stringify(e(a)))});return c.onMount=e=>{let t=t=>{e({isEvent:!0,value:JSON.parse(t.data)})};return o.add(t),()=>{o.delete(t)}},t(e=>e(c),(e,t,n)=>{t(c,{isEvent:!1,value:n})})}export{r as atomWithBroadcast};
+import { isAtom } from "../utilities/is-atom.mjs";
+import { baseAtom } from "./base-atom.mjs";
+import { isFunction } from "@stryke/type-checks/is-function";
+
+//#region src/base/atoms/atom-with-broadcast.ts
+/**
+* Creates an atom that broadcasts its value to other tabs/windows using the BroadcastChannel API.
+*
+* @param key - The key to use for the BroadcastChannel
+* @param initialValueOrAtom - The initial value of the atom
+* @returns An atom that broadcasts its value to other tabs/windows using the BroadcastChannel API.
+*/
+function atomWithBroadcast(key, initialValueOrAtom) {
+	const valueAtom = isAtom(initialValueOrAtom) ? initialValueOrAtom : baseAtom(initialValueOrAtom);
+	const listeners = /* @__PURE__ */ new Set();
+	const channel = typeof BroadcastChannel === "undefined" ? void 0 : new BroadcastChannel(key);
+	if (channel) channel.onmessage = (message) => {
+		for (const listener of listeners) listener(message);
+	};
+	const broadcastAtom = baseAtom((get) => get(valueAtom), (get, set, update) => {
+		set(valueAtom, isFunction(update.value) ? update.value(get(valueAtom)) : update.value);
+		if (!update.isEvent && channel) channel.postMessage(JSON.stringify(get(valueAtom)));
+	});
+	broadcastAtom.onMount = (setAtom) => {
+		const listener = (event) => {
+			setAtom({
+				isEvent: true,
+				value: JSON.parse(event.data)
+			});
+		};
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	};
+	return baseAtom((get) => get(broadcastAtom), (_, set, update) => {
+		set(broadcastAtom, {
+			isEvent: false,
+			value: update
+		});
+	});
+}
+
+//#endregion
+export { atomWithBroadcast };
 //# sourceMappingURL=atom-with-broadcast.mjs.map

package/dist/base/atoms/atom-with-broadcast.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"atom-with-broadcast.mjs","names":["atomWithBroadcast","valueAtom","isAtom","initialValueOrAtom","baseAtom","listeners","channel","key","listener","message","broadcastAtom","get","set","isFunction","update","setAtom","event"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-broadcast.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/atoms/atom-with-compare.cjs

@@ -1 +1,12 @@
-let e=require("jotai/utils");function t(t,n){return(0,e.atomWithReducer)(t,(e,t)=>n(e,t)?e:t)}exports.atomWithCompare=t;
+let jotai_utils = require("jotai/utils");
+
+//#region src/base/atoms/atom-with-compare.ts
+function atomWithCompare(initialValue, areEqual) {
+	return (0, jotai_utils.atomWithReducer)(initialValue, (prev, next) => {
+		if (areEqual(prev, next)) return prev;
+		return next;
+	});
+}
+
+//#endregion
+exports.atomWithCompare = atomWithCompare;

package/dist/base/atoms/atom-with-compare.mjs

@@ -1,2 +1,13 @@
-import{atomWithReducer as e}from"jotai/utils";function t(t,n){return e(t,(e,t)=>n(e,t)?e:t)}export{t as atomWithCompare};
+import { atomWithReducer } from "jotai/utils";
+
+//#region src/base/atoms/atom-with-compare.ts
+function atomWithCompare(initialValue, areEqual) {
+	return atomWithReducer(initialValue, (prev, next) => {
+		if (areEqual(prev, next)) return prev;
+		return next;
+	});
+}
+
+//#endregion
+export { atomWithCompare };
 //# sourceMappingURL=atom-with-compare.mjs.map

package/dist/base/atoms/atom-with-compare.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"atom-with-compare.mjs","names":["atomWithCompare","atomWithReducer","initialValue","areEqual","prev","next"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-compare.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/atoms/atom-with-debounce.cjs

@@ -1 +1,52 @@
-const e=require("../utilities/is-atom.cjs"),t=require("./base-atom.cjs"),n=require("./atom-with-wrapper.cjs");let r=require("@stryke/type-checks/is-function"),i=require("jotai/utils");function a(a,o=500,s=!1){let c=t.baseAtom(void 0),l=e.isAtom(a)?a:n.atomWithWrapper(a),u=t.baseAtom(null),d=t.baseAtom(e=>{let t=e(u);return t===null?e(l):t},(e,t,n)=>t(u,n)),f=t.baseAtom(!1),p=t.baseAtom(e=>e(u),(e,t,n)=>{clearTimeout(e(c));let a=e(d),m=n===i.RESET?e(u):(0,r.isFunction)(n)?n(a):n,h=()=>{t(d,m),t(f,!0)},g=()=>{t(p,m),t(f,!1)};if(h(),!s&&m===e(l)){g();return}let _=setTimeout(()=>{g()},o);t(c,_)});return{clearTimeoutAtom:t.baseAtom(null,(e,t)=>{clearTimeout(e(c)),t(f,!1)}),currentValueAtom:t.baseAtom(e=>e(d)),debouncedValueAtom:p,isDebouncingAtom:f}}exports.atomWithDebounce=a;
+const require_is_atom = require("../utilities/is-atom.cjs");
+const require_base_atom = require("./base-atom.cjs");
+const require_atom_with_wrapper = require("./atom-with-wrapper.cjs");
+let _stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+let jotai_utils = require("jotai/utils");
+
+//#region src/base/atoms/atom-with-debounce.ts
+function atomWithDebounce(initialValueOrAtom, debounceMs = 500, shouldDebounceOnReset = false) {
+	const prevTimeoutAtom = require_base_atom.baseAtom(void 0);
+	const initialValueAtom = require_is_atom.isAtom(initialValueOrAtom) ? initialValueOrAtom : require_atom_with_wrapper.atomWithWrapper(initialValueOrAtom);
+	const innerValueAtom = require_base_atom.baseAtom(null);
+	const _currentValueAtom = require_base_atom.baseAtom((get) => {
+		const innerValue = get(innerValueAtom);
+		if (innerValue === null) return get(initialValueAtom);
+		return innerValue;
+	}, (get, set, update) => set(innerValueAtom, update));
+	const isDebouncingAtom = require_base_atom.baseAtom(false);
+	const debouncedValueAtom = require_base_atom.baseAtom((get) => get(innerValueAtom), (get, set, update) => {
+		clearTimeout(get(prevTimeoutAtom));
+		const prevValue = get(_currentValueAtom);
+		const nextValue = update === jotai_utils.RESET ? get(innerValueAtom) : (0, _stryke_type_checks_is_function.isFunction)(update) ? update(prevValue) : update;
+		const onDebounceStart = () => {
+			set(_currentValueAtom, nextValue);
+			set(isDebouncingAtom, true);
+		};
+		const onDebounceEnd = () => {
+			set(debouncedValueAtom, nextValue);
+			set(isDebouncingAtom, false);
+		};
+		onDebounceStart();
+		if (!shouldDebounceOnReset && nextValue === get(initialValueAtom)) {
+			onDebounceEnd();
+			return;
+		}
+		const nextTimeoutId = setTimeout(() => {
+			onDebounceEnd();
+		}, debounceMs);
+		set(prevTimeoutAtom, nextTimeoutId);
+	});
+	return {
+		clearTimeoutAtom: require_base_atom.baseAtom(null, (get, set) => {
+			clearTimeout(get(prevTimeoutAtom));
+			set(isDebouncingAtom, false);
+		}),
+		currentValueAtom: require_base_atom.baseAtom((get) => get(_currentValueAtom)),
+		debouncedValueAtom,
+		isDebouncingAtom
+	};
+}
+
+//#endregion
+exports.atomWithDebounce = atomWithDebounce;

package/dist/base/atoms/atom-with-debounce.mjs

@@ -1,2 +1,53 @@
-import{isAtom as e}from"../utilities/is-atom.mjs";import{baseAtom as t}from"./base-atom.mjs";import{atomWithWrapper as n}from"./atom-with-wrapper.mjs";import{isFunction as r}from"@stryke/type-checks/is-function";import{RESET as i}from"jotai/utils";function a(a,o=500,s=!1){let c=t(void 0),l=e(a)?a:n(a),u=t(null),d=t(e=>{let t=e(u);return t===null?e(l):t},(e,t,n)=>t(u,n)),f=t(!1),p=t(e=>e(u),(e,t,n)=>{clearTimeout(e(c));let a=e(d),m=n===i?e(u):r(n)?n(a):n,h=()=>{t(d,m),t(f,!0)},g=()=>{t(p,m),t(f,!1)};if(h(),!s&&m===e(l)){g();return}let _=setTimeout(()=>{g()},o);t(c,_)});return{clearTimeoutAtom:t(null,(e,t)=>{clearTimeout(e(c)),t(f,!1)}),currentValueAtom:t(e=>e(d)),debouncedValueAtom:p,isDebouncingAtom:f}}export{a as atomWithDebounce};
+import { isAtom } from "../utilities/is-atom.mjs";
+import { baseAtom } from "./base-atom.mjs";
+import { atomWithWrapper } from "./atom-with-wrapper.mjs";
+import { isFunction } from "@stryke/type-checks/is-function";
+import { RESET } from "jotai/utils";
+
+//#region src/base/atoms/atom-with-debounce.ts
+function atomWithDebounce(initialValueOrAtom, debounceMs = 500, shouldDebounceOnReset = false) {
+	const prevTimeoutAtom = baseAtom(void 0);
+	const initialValueAtom = isAtom(initialValueOrAtom) ? initialValueOrAtom : atomWithWrapper(initialValueOrAtom);
+	const innerValueAtom = baseAtom(null);
+	const _currentValueAtom = baseAtom((get) => {
+		const innerValue = get(innerValueAtom);
+		if (innerValue === null) return get(initialValueAtom);
+		return innerValue;
+	}, (get, set, update) => set(innerValueAtom, update));
+	const isDebouncingAtom = baseAtom(false);
+	const debouncedValueAtom = baseAtom((get) => get(innerValueAtom), (get, set, update) => {
+		clearTimeout(get(prevTimeoutAtom));
+		const prevValue = get(_currentValueAtom);
+		const nextValue = update === RESET ? get(innerValueAtom) : isFunction(update) ? update(prevValue) : update;
+		const onDebounceStart = () => {
+			set(_currentValueAtom, nextValue);
+			set(isDebouncingAtom, true);
+		};
+		const onDebounceEnd = () => {
+			set(debouncedValueAtom, nextValue);
+			set(isDebouncingAtom, false);
+		};
+		onDebounceStart();
+		if (!shouldDebounceOnReset && nextValue === get(initialValueAtom)) {
+			onDebounceEnd();
+			return;
+		}
+		const nextTimeoutId = setTimeout(() => {
+			onDebounceEnd();
+		}, debounceMs);
+		set(prevTimeoutAtom, nextTimeoutId);
+	});
+	return {
+		clearTimeoutAtom: baseAtom(null, (get, set) => {
+			clearTimeout(get(prevTimeoutAtom));
+			set(isDebouncingAtom, false);
+		}),
+		currentValueAtom: baseAtom((get) => get(_currentValueAtom)),
+		debouncedValueAtom,
+		isDebouncingAtom
+	};
+}
+
+//#endregion
+export { atomWithDebounce };
 //# sourceMappingURL=atom-with-debounce.mjs.map

package/dist/base/atoms/atom-with-debounce.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"atom-with-debounce.mjs","names":["atomWithDebounce","prevTimeoutAtom","baseAtom","initialValueAtom","isAtom","initialValueOrAtom","atomWithWrapper","innerValueAtom","_currentValueAtom","innerValue","get","set","update","isDebouncingAtom","debouncedValueAtom","prevValue","nextValue","RESET","isFunction","onDebounceStart","onDebounceEnd","shouldDebounceOnReset","nextTimeoutId","debounceMs"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-debounce.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/atoms/atom-with-effect.cjs

@@ -1 +1,123 @@
-let e=require("jotai/vanilla"),t=require("@stryke/helpers/is-equal");function n(n){let r=(0,e.atom)(0),i=(0,e.atom)(()=>({inProgress:0,mounted:!1,promise:void 0,pendingError:void 0,cleanup:void 0,fromCleanup:!1,isRecursing:!1,isRefreshing:!1,get:(()=>{}),set:(()=>{})}),(e,t)=>{let n=e(i);return Object.assign(n,{mounted:!0,get:e,set:t}),t(r,e=>e+1),()=>{n.mounted=!1,l(n),u(n)}});i.onMount=e=>e();let a=(0,e.atom)(async e=>{e(r);let a=e(i);if(!a.mounted||a.isRecursing||a.inProgress&&!a.isRefreshing)return a.promise;u(a);let o=/* @__PURE__ */ new Map,s=t=>{let n=e(t);return o.set(t,n),n};s.peek=e=>a.get(e);let d=(...t)=>{try{return++a.inProgress,a.set(...t)}finally{Array.from(o.keys(),e),--a.inProgress}};d.recurse=(n,...r)=>{if(a.fromCleanup){if(process.env.NODE_ENV!==`production`)throw Error(`set.recurse is not allowed in cleanup`);return}try{return a.isRecursing=!0,a.set(n,...r)}finally{a.isRecursing=!1,Array.from(o).some(([n,r])=>!(0,t.isEqual)(e(n),r))&&c(a)}},++a.inProgress;function f(){try{if(a.isRefreshing=!1,!a.mounted)return;l(a),a.cleanup=n(s,d)}catch(e){a.pendingError=e,c(a)}finally{a.promise=void 0,--a.inProgress}}return a.isRefreshing?f():a.promise=Promise.resolve().then(f)});if(process.env.NODE_ENV!==`production`){function o(e,t){Object.defineProperty(e,"debugLabel",{get:()=>`${s.debugLabel??`effect`}:${t}`}),e.debugPrivate=!0}o(r,`refresh`),o(i,`ref`),o(a,`base`)}let s=(0,e.atom)(e=>void e(a));return s;function c(e){try{e.isRefreshing=!0,e.set(r,e=>e+1)}finally{e.isRefreshing=!1}}function l(e){if(e.cleanup)try{e.fromCleanup=!0,e.cleanup()}finally{e.fromCleanup=!1,e.cleanup=void 0}}function u(e){if(`e`in e){let t=e.pendingError;throw delete e.pendingError,t}}}exports.atomWithEffect=n;
+let jotai_vanilla = require("jotai/vanilla");
+let _stryke_helpers_is_equal = require("@stryke/helpers/is-equal");
+
+//#region src/base/atoms/atom-with-effect.ts
+function atomWithEffect(effect) {
+	const refreshAtom = (0, jotai_vanilla.atom)(0);
+	const refAtom = (0, jotai_vanilla.atom)(() => ({
+		inProgress: 0,
+		mounted: false,
+		promise: void 0,
+		pendingError: void 0,
+		cleanup: void 0,
+		fromCleanup: false,
+		isRecursing: false,
+		isRefreshing: false,
+		get: (() => {}),
+		set: (() => {})
+	}), (get, set) => {
+		const ref = get(refAtom);
+		Object.assign(ref, {
+			mounted: true,
+			get,
+			set
+		});
+		set(refreshAtom, (c) => c + 1);
+		return () => {
+			ref.mounted = false;
+			cleanup(ref);
+			throwPendingError(ref);
+		};
+	});
+	refAtom.onMount = (mount) => mount();
+	const baseAtom = (0, jotai_vanilla.atom)(async (get) => {
+		get(refreshAtom);
+		const ref = get(refAtom);
+		if (!ref.mounted || ref.isRecursing || ref.inProgress && !ref.isRefreshing) return ref.promise;
+		throwPendingError(ref);
+		const currDeps = /* @__PURE__ */ new Map();
+		const getter = (a) => {
+			const value = get(a);
+			currDeps.set(a, value);
+			return value;
+		};
+		getter.peek = (anAtom) => ref.get(anAtom);
+		const setter = (...args) => {
+			try {
+				++ref.inProgress;
+				return ref.set(...args);
+			} finally {
+				Array.from(currDeps.keys(), get);
+				--ref.inProgress;
+			}
+		};
+		setter.recurse = (anAtom, ...args) => {
+			if (ref.fromCleanup) {
+				if (process.env.NODE_ENV !== "production") throw new Error("set.recurse is not allowed in cleanup");
+				return;
+			}
+			try {
+				ref.isRecursing = true;
+				return ref.set(anAtom, ...args);
+			} finally {
+				ref.isRecursing = false;
+				if (Array.from(currDeps).some(([atom, value]) => !(0, _stryke_helpers_is_equal.isEqual)(get(atom), value))) refresh(ref);
+			}
+		};
+		++ref.inProgress;
+		function runEffect() {
+			try {
+				ref.isRefreshing = false;
+				if (!ref.mounted) return;
+				cleanup(ref);
+				ref.cleanup = effect(getter, setter);
+			} catch (error) {
+				ref.pendingError = error;
+				refresh(ref);
+			} finally {
+				ref.promise = void 0;
+				--ref.inProgress;
+			}
+		}
+		return ref.isRefreshing ? runEffect() : ref.promise = Promise.resolve().then(runEffect);
+	});
+	if (process.env.NODE_ENV !== "production") {
+		function setLabel(atom, label) {
+			Object.defineProperty(atom, "debugLabel", { get: () => `${effectAtom.debugLabel ?? "effect"}:${label}` });
+			atom.debugPrivate = true;
+		}
+		setLabel(refreshAtom, "refresh");
+		setLabel(refAtom, "ref");
+		setLabel(baseAtom, "base");
+	}
+	const effectAtom = (0, jotai_vanilla.atom)((get) => void get(baseAtom));
+	return effectAtom;
+	function refresh(ref) {
+		try {
+			ref.isRefreshing = true;
+			ref.set(refreshAtom, (c) => c + 1);
+		} finally {
+			ref.isRefreshing = false;
+		}
+	}
+	function cleanup(ref) {
+		if (!ref.cleanup) return;
+		try {
+			ref.fromCleanup = true;
+			ref.cleanup();
+		} finally {
+			ref.fromCleanup = false;
+			ref.cleanup = void 0;
+		}
+	}
+	function throwPendingError(ref) {
+		if ("e" in ref) {
+			const error = ref.pendingError;
+			delete ref.pendingError;
+			throw error;
+		}
+	}
+}
+
+//#endregion
+exports.atomWithEffect = atomWithEffect;

package/dist/base/atoms/atom-with-effect.mjs

@@ -1,2 +1,121 @@
-import{atom as e}from"jotai/vanilla";import{isEqual as t}from"@stryke/helpers/is-equal";function n(n){let r=e(0),i=e(()=>({inProgress:0,mounted:!1,promise:void 0,pendingError:void 0,cleanup:void 0,fromCleanup:!1,isRecursing:!1,isRefreshing:!1,get:(()=>{}),set:(()=>{})}),(e,t)=>{let n=e(i);return Object.assign(n,{mounted:!0,get:e,set:t}),t(r,e=>e+1),()=>{n.mounted=!1,s(n),c(n)}});i.onMount=e=>e();let a=e(async e=>{e(r);let a=e(i);if(!a.mounted||a.isRecursing||a.inProgress&&!a.isRefreshing)return a.promise;c(a);let l=/* @__PURE__ */ new Map,u=t=>{let n=e(t);return l.set(t,n),n};u.peek=e=>a.get(e);let d=(...t)=>{try{return++a.inProgress,a.set(...t)}finally{Array.from(l.keys(),e),--a.inProgress}};d.recurse=(n,...r)=>{if(!a.fromCleanup)try{return a.isRecursing=!0,a.set(n,...r)}finally{a.isRecursing=!1,Array.from(l).some(([n,r])=>!t(e(n),r))&&o(a)}},++a.inProgress;function f(){try{if(a.isRefreshing=!1,!a.mounted)return;s(a),a.cleanup=n(u,d)}catch(e){a.pendingError=e,o(a)}finally{a.promise=void 0,--a.inProgress}}return a.isRefreshing?f():a.promise=Promise.resolve().then(f)});return e(e=>void e(a));function o(e){try{e.isRefreshing=!0,e.set(r,e=>e+1)}finally{e.isRefreshing=!1}}function s(e){if(e.cleanup)try{e.fromCleanup=!0,e.cleanup()}finally{e.fromCleanup=!1,e.cleanup=void 0}}function c(e){if(`e`in e){let t=e.pendingError;throw delete e.pendingError,t}}}export{n as atomWithEffect};
+import { atom } from "jotai/vanilla";
+import { isEqual } from "@stryke/helpers/is-equal";
+
+//#region src/base/atoms/atom-with-effect.ts
+function atomWithEffect(effect) {
+	const refreshAtom = atom(0);
+	const refAtom = atom(() => ({
+		inProgress: 0,
+		mounted: false,
+		promise: void 0,
+		pendingError: void 0,
+		cleanup: void 0,
+		fromCleanup: false,
+		isRecursing: false,
+		isRefreshing: false,
+		get: (() => {}),
+		set: (() => {})
+	}), (get, set) => {
+		const ref = get(refAtom);
+		Object.assign(ref, {
+			mounted: true,
+			get,
+			set
+		});
+		set(refreshAtom, (c) => c + 1);
+		return () => {
+			ref.mounted = false;
+			cleanup(ref);
+			throwPendingError(ref);
+		};
+	});
+	refAtom.onMount = (mount) => mount();
+	const baseAtom = atom(async (get) => {
+		get(refreshAtom);
+		const ref = get(refAtom);
+		if (!ref.mounted || ref.isRecursing || ref.inProgress && !ref.isRefreshing) return ref.promise;
+		throwPendingError(ref);
+		const currDeps = /* @__PURE__ */ new Map();
+		const getter = (a) => {
+			const value = get(a);
+			currDeps.set(a, value);
+			return value;
+		};
+		getter.peek = (anAtom) => ref.get(anAtom);
+		const setter = (...args) => {
+			try {
+				++ref.inProgress;
+				return ref.set(...args);
+			} finally {
+				Array.from(currDeps.keys(), get);
+				--ref.inProgress;
+			}
+		};
+		setter.recurse = (anAtom, ...args) => {
+			if (ref.fromCleanup) throw new Error("set.recurse is not allowed in cleanup");
+			try {
+				ref.isRecursing = true;
+				return ref.set(anAtom, ...args);
+			} finally {
+				ref.isRecursing = false;
+				if (Array.from(currDeps).some(([atom, value]) => !isEqual(get(atom), value))) refresh(ref);
+			}
+		};
+		++ref.inProgress;
+		function runEffect() {
+			try {
+				ref.isRefreshing = false;
+				if (!ref.mounted) return;
+				cleanup(ref);
+				ref.cleanup = effect(getter, setter);
+			} catch (error) {
+				ref.pendingError = error;
+				refresh(ref);
+			} finally {
+				ref.promise = void 0;
+				--ref.inProgress;
+			}
+		}
+		return ref.isRefreshing ? runEffect() : ref.promise = Promise.resolve().then(runEffect);
+	});
+	{
+		function setLabel(atom, label) {
+			Object.defineProperty(atom, "debugLabel", { get: () => `${effectAtom.debugLabel ?? "effect"}:${label}` });
+			atom.debugPrivate = true;
+		}
+		setLabel(refreshAtom, "refresh");
+		setLabel(refAtom, "ref");
+		setLabel(baseAtom, "base");
+	}
+	const effectAtom = atom((get) => void get(baseAtom));
+	return effectAtom;
+	function refresh(ref) {
+		try {
+			ref.isRefreshing = true;
+			ref.set(refreshAtom, (c) => c + 1);
+		} finally {
+			ref.isRefreshing = false;
+		}
+	}
+	function cleanup(ref) {
+		if (!ref.cleanup) return;
+		try {
+			ref.fromCleanup = true;
+			ref.cleanup();
+		} finally {
+			ref.fromCleanup = false;
+			ref.cleanup = void 0;
+		}
+	}
+	function throwPendingError(ref) {
+		if ("e" in ref) {
+			const error = ref.pendingError;
+			delete ref.pendingError;
+			throw error;
+		}
+	}
+}
+
+//#endregion
+export { atomWithEffect };
 //# sourceMappingURL=atom-with-effect.mjs.map

package/dist/base/atoms/atom-with-effect.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"atom-with-effect.mjs","names":["atomWithEffect","refreshAtom","atom","refAtom","ref","get","set","c","cleanup","throwPendingError","mount","baseAtom","currDeps","getter","value","a","anAtom","setter","args","isEqual","refresh","runEffect","effect","error"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-effect.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/atoms/atom-with-listeners.cjs

@@ -1 +1,36 @@
-const e=require("../utilities/is-atom.cjs"),t=require("./base-atom.cjs");let n=require("jotai"),r=require("react");function i(i){let a=e.isAtom(i)?i:t.baseAtom(i),o=t.baseAtom([]);return[t.baseAtom(e=>e(a),(e,t,n)=>{let r=e(a);t(a,n);let i=e(a);for(let n of e(o))n(e,t,i,r)}),e=>{let t=(0,n.useSetAtom)(o);(0,r.useEffect)(()=>(t(t=>[...t,e]),()=>t(t=>{let n=t.indexOf(e);return[...t.slice(0,n),...t.slice(n+1)]})),[t,e])}]}exports.atomWithListeners=i;
+const require_is_atom = require("../utilities/is-atom.cjs");
+const require_base_atom = require("./base-atom.cjs");
+let jotai = require("jotai");
+let react = require("react");
+
+//#region src/base/atoms/atom-with-listeners.ts
+/**
+* Creates an atom that broadcasts its value to other tabs/windows using the BroadcastChannel API.
+*
+* @param initialValue - The initial value of the atom
+* @returns An atom that broadcasts its value to other tabs/windows using the BroadcastChannel API.
+*/
+function atomWithListeners(initialValue) {
+	const rootAtom = require_is_atom.isAtom(initialValue) ? initialValue : require_base_atom.baseAtom(initialValue);
+	const listenersAtom = require_base_atom.baseAtom([]);
+	const anAtom = require_base_atom.baseAtom((get) => get(rootAtom), (get, set, arg) => {
+		const prevVal = get(rootAtom);
+		set(rootAtom, arg);
+		const newVal = get(rootAtom);
+		for (const callback of get(listenersAtom)) callback(get, set, newVal, prevVal);
+	});
+	const useListener = (callback) => {
+		const setListeners = (0, jotai.useSetAtom)(listenersAtom);
+		(0, react.useEffect)(() => {
+			setListeners((prev) => [...prev, callback]);
+			return () => setListeners((prev) => {
+				const index = prev.indexOf(callback);
+				return [...prev.slice(0, index), ...prev.slice(index + 1)];
+			});
+		}, [setListeners, callback]);
+	};
+	return [anAtom, useListener];
+}
+
+//#endregion
+exports.atomWithListeners = atomWithListeners;

package/dist/base/atoms/atom-with-listeners.mjs

@@ -1,2 +1,37 @@
-import{isAtom as e}from"../utilities/is-atom.mjs";import{baseAtom as t}from"./base-atom.mjs";import{useSetAtom as n}from"jotai";import{useEffect as r}from"react";function i(i){let a=e(i)?i:t(i),o=t([]);return[t(e=>e(a),(e,t,n)=>{let r=e(a);t(a,n);let i=e(a);for(let n of e(o))n(e,t,i,r)}),e=>{let t=n(o);r(()=>(t(t=>[...t,e]),()=>t(t=>{let n=t.indexOf(e);return[...t.slice(0,n),...t.slice(n+1)]})),[t,e])}]}export{i as atomWithListeners};
+import { isAtom } from "../utilities/is-atom.mjs";
+import { baseAtom } from "./base-atom.mjs";
+import { useSetAtom } from "jotai";
+import { useEffect } from "react";
+
+//#region src/base/atoms/atom-with-listeners.ts
+/**
+* Creates an atom that broadcasts its value to other tabs/windows using the BroadcastChannel API.
+*
+* @param initialValue - The initial value of the atom
+* @returns An atom that broadcasts its value to other tabs/windows using the BroadcastChannel API.
+*/
+function atomWithListeners(initialValue) {
+	const rootAtom = isAtom(initialValue) ? initialValue : baseAtom(initialValue);
+	const listenersAtom = baseAtom([]);
+	const anAtom = baseAtom((get) => get(rootAtom), (get, set, arg) => {
+		const prevVal = get(rootAtom);
+		set(rootAtom, arg);
+		const newVal = get(rootAtom);
+		for (const callback of get(listenersAtom)) callback(get, set, newVal, prevVal);
+	});
+	const useListener = (callback) => {
+		const setListeners = useSetAtom(listenersAtom);
+		useEffect(() => {
+			setListeners((prev) => [...prev, callback]);
+			return () => setListeners((prev) => {
+				const index = prev.indexOf(callback);
+				return [...prev.slice(0, index), ...prev.slice(index + 1)];
+			});
+		}, [setListeners, callback]);
+	};
+	return [anAtom, useListener];
+}
+
+//#endregion
+export { atomWithListeners };
 //# sourceMappingURL=atom-with-listeners.mjs.map

package/dist/base/atoms/atom-with-listeners.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"atom-with-listeners.mjs","names":["atomWithListeners","rootAtom","isAtom","initialValue","baseAtom","listenersAtom","get","prevVal","set","arg","newVal","callback","setListeners","useSetAtom","useEffect","prev","index"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-listeners.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/atoms/atom-with-pending.cjs

@@ -1 +1,14 @@
-const e=require("./base-atom.cjs");let t=require("@stryke/helpers/noop");const n=new Promise(t.noop),r=()=>e.baseAtom(n);exports.atomWithPending=r;
+const require_base_atom = require("./base-atom.cjs");
+let _stryke_helpers_noop = require("@stryke/helpers/noop");
+
+//#region src/base/atoms/atom-with-pending.ts
+const pendingPromise = new Promise(_stryke_helpers_noop.noop);
+/**
+* Creates an atom that always returns a pending promise.
+*
+* @returns An atom that always returns a pending promise.
+*/
+const atomWithPending = () => require_base_atom.baseAtom(pendingPromise);
+
+//#endregion
+exports.atomWithPending = atomWithPending;