@cyclone-ui/state 0.0.12 → 0.0.14

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

@@ -1,2 +1,15 @@
-import{baseAtom as e}from"./base-atom.mjs";import{noop as t}from"@stryke/helpers/noop";const n=new Promise(t),r=()=>e(n);export{r as atomWithPending};
+import { baseAtom } from "./base-atom.mjs";
+import { noop } from "@stryke/helpers/noop";
+
+//#region src/base/atoms/atom-with-pending.ts
+const pendingPromise = new Promise(noop);
+/**
+* Creates an atom that always returns a pending promise.
+*
+* @returns An atom that always returns a pending promise.
+*/
+const atomWithPending = () => baseAtom(pendingPromise);
+
+//#endregion
+export { atomWithPending };
 //# sourceMappingURL=atom-with-pending.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"atom-with-pending.mjs","names":["pendingPromise","noop","atomWithPending","baseAtom"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-pending.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/atoms/atom-with-refresh-and-default.cjs

@@ -1 +1,19 @@
-const e=require("./base-atom.cjs"),t=(t,n)=>{let r=e.baseAtom(null);return e.baseAtom(e=>{let i=e(r);return i&&i.refresh===e(t)?i.value:n(e)},(e,n,i)=>{n(r,{refresh:e(t),value:i})})};exports.atomWithRefreshAndDefault=t;
+const require_base_atom = require("./base-atom.cjs");
+
+//#region src/base/atoms/atom-with-refresh-and-default.ts
+const atomWithRefreshAndDefault = (refreshAtom, getDefault) => {
+	const overwrittenAtom = require_base_atom.baseAtom(null);
+	return require_base_atom.baseAtom((get) => {
+		const lastState = get(overwrittenAtom);
+		if (lastState && lastState.refresh === get(refreshAtom)) return lastState.value;
+		return getDefault(get);
+	}, (get, set, update) => {
+		set(overwrittenAtom, {
+			refresh: get(refreshAtom),
+			value: update
+		});
+	});
+};
+
+//#endregion
+exports.atomWithRefreshAndDefault = atomWithRefreshAndDefault;

package/dist/base/atoms/atom-with-refresh-and-default.mjs

@@ -1,2 +1,20 @@
-import{baseAtom as e}from"./base-atom.mjs";const t=(t,n)=>{let r=e(null);return e(e=>{let i=e(r);return i&&i.refresh===e(t)?i.value:n(e)},(e,n,i)=>{n(r,{refresh:e(t),value:i})})};export{t as atomWithRefreshAndDefault};
+import { baseAtom } from "./base-atom.mjs";
+
+//#region src/base/atoms/atom-with-refresh-and-default.ts
+const atomWithRefreshAndDefault = (refreshAtom, getDefault) => {
+	const overwrittenAtom = baseAtom(null);
+	return baseAtom((get) => {
+		const lastState = get(overwrittenAtom);
+		if (lastState && lastState.refresh === get(refreshAtom)) return lastState.value;
+		return getDefault(get);
+	}, (get, set, update) => {
+		set(overwrittenAtom, {
+			refresh: get(refreshAtom),
+			value: update
+		});
+	});
+};
+
+//#endregion
+export { atomWithRefreshAndDefault };
 //# sourceMappingURL=atom-with-refresh-and-default.mjs.map

package/dist/base/atoms/atom-with-refresh-and-default.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"atom-with-refresh-and-default.mjs","names":["atomWithRefreshAndDefault","overwrittenAtom","baseAtom","lastState","get","refreshAtom","getDefault","set","update"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-refresh-and-default.mjs","names":[],"sources":[],"mappings":""}

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

@@ -1 +1,13 @@
-const e=require("./base-atom.cjs");function t(t){let n=e.baseAtom(0);return e.baseAtom(e=>(e(n),t(e)),(e,t)=>t(n,e=>e+1))}exports.atomWithRefresh=t;
+const require_base_atom = require("./base-atom.cjs");
+
+//#region src/base/atoms/atom-with-refresh.ts
+function atomWithRefresh(fn) {
+	const refreshCounter = require_base_atom.baseAtom(0);
+	return require_base_atom.baseAtom((get) => {
+		get(refreshCounter);
+		return fn(get);
+	}, (_, set) => set(refreshCounter, (i) => i + 1));
+}
+
+//#endregion
+exports.atomWithRefresh = atomWithRefresh;

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

@@ -1,2 +1,14 @@
-import{baseAtom as e}from"./base-atom.mjs";function t(t){let n=e(0);return e(e=>(e(n),t(e)),(e,t)=>t(n,e=>e+1))}export{t as atomWithRefresh};
+import { baseAtom } from "./base-atom.mjs";
+
+//#region src/base/atoms/atom-with-refresh.ts
+function atomWithRefresh(fn) {
+	const refreshCounter = baseAtom(0);
+	return baseAtom((get) => {
+		get(refreshCounter);
+		return fn(get);
+	}, (_, set) => set(refreshCounter, (i) => i + 1));
+}
+
+//#endregion
+export { atomWithRefresh };
 //# sourceMappingURL=atom-with-refresh.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"atom-with-refresh.mjs","names":["atomWithRefresh","refreshCounter","baseAtom","get","fn","set","i"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-refresh.mjs","names":[],"sources":[],"mappings":""}

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

@@ -1 +1,13 @@
-const e=require("./base-atom.cjs");function t(t){let n=e.baseAtom(t,(e,t,r)=>{let i=r??!e(n);t(n,i)});return n}exports.atomWithToggle=t;
+const require_base_atom = require("./base-atom.cjs");
+
+//#region src/base/atoms/atom-with-toggle.ts
+function atomWithToggle(initialValue) {
+	const anAtom = require_base_atom.baseAtom(initialValue, (get, set, nextValue) => {
+		const update = nextValue ?? !get(anAtom);
+		set(anAtom, update);
+	});
+	return anAtom;
+}
+
+//#endregion
+exports.atomWithToggle = atomWithToggle;

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

@@ -1,2 +1,14 @@
-import{baseAtom as e}from"./base-atom.mjs";function t(t){let n=e(t,(e,t,r)=>{let i=r??!e(n);t(n,i)});return n}export{t as atomWithToggle};
+import { baseAtom } from "./base-atom.mjs";
+
+//#region src/base/atoms/atom-with-toggle.ts
+function atomWithToggle(initialValue) {
+	const anAtom = baseAtom(initialValue, (get, set, nextValue) => {
+		const update = nextValue ?? !get(anAtom);
+		set(anAtom, update);
+	});
+	return anAtom;
+}
+
+//#endregion
+export { atomWithToggle };
 //# sourceMappingURL=atom-with-toggle.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"atom-with-toggle.mjs","names":["atomWithToggle","anAtom","baseAtom","initialValue","update","nextValue","get","set"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-toggle.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/atoms/atom-with-web-storage.cjs

@@ -1 +1,48 @@
-const e=require("../utilities/is-atom.cjs"),t=require("./base-atom.cjs"),n=require("./atom-with-broadcast.cjs"),r=require("./atom-with-debounce.cjs"),i=require("./atom-with-effect.cjs"),a=require("../utilities/create-web-storage.cjs");let o=require("@stryke/type-checks/is-function"),s=require("jotai/utils");const c=()=>a.createWebStorage(()=>localStorage);function l(a,l,u=c(),d){let f=d?.debounceMs??500,p=d?.getOnInit??!0,m=e.isAtom(l)?l:t.baseAtom(l),h=r.atomWithDebounce((0,s.atomWithStorage)(a,e.isAtom(l)?void 0:l,u,{getOnInit:p}),f),g=r.atomWithDebounce(n.atomWithBroadcast(a,e.isAtom(l)?void 0:l),f),_=t.baseAtom(e=>e(m),(e,t,n)=>{let r=(0,o.isFunction)(n)?n(e(m)):n;t(m,r),t(h.debouncedValueAtom,r),t(g.debouncedValueAtom,r)}),v=i.atomWithEffect((e,t)=>{let n=e(g.debouncedValueAtom);n!==e(_)&&t(_,n)});return t.baseAtom(e=>(e(v),e(_)),(e,t,n)=>{t(_,n)})}exports.atomWithWebStorage=l,exports.getWebStorage=c;
+const require_is_atom = require("../utilities/is-atom.cjs");
+const require_base_atom = require("./base-atom.cjs");
+const require_atom_with_broadcast = require("./atom-with-broadcast.cjs");
+const require_atom_with_debounce = require("./atom-with-debounce.cjs");
+const require_atom_with_effect = require("./atom-with-effect.cjs");
+const require_create_web_storage = require("../utilities/create-web-storage.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-web-storage.ts
+const getWebStorage = () => require_create_web_storage.createWebStorage(() => localStorage);
+/**
+* Creates an atom that persists its state in external storage and sends a broadcast message to other tabs/windows when the state changes.
+*
+* @param key - The key to use for the storage
+* @param initialValue - The initial value of the atom
+* @param webStorage - The storage to use
+* @returns An atom that persists its state in external storage and sends a broadcast message to other tabs/windows when the state changes.
+*/
+function atomWithWebStorage(key, initialValueOrAtom, webStorage = getWebStorage(), options) {
+	const debounceMs = options?.debounceMs ?? 500;
+	const getOnInit = options?.getOnInit ?? true;
+	const valueAtom = require_is_atom.isAtom(initialValueOrAtom) ? initialValueOrAtom : require_base_atom.baseAtom(initialValueOrAtom);
+	const debouncedStorageAtom = require_atom_with_debounce.atomWithDebounce((0, jotai_utils.atomWithStorage)(key, require_is_atom.isAtom(initialValueOrAtom) ? void 0 : initialValueOrAtom, webStorage, { getOnInit }), debounceMs);
+	const debouncedBroadcastAtom = require_atom_with_debounce.atomWithDebounce(require_atom_with_broadcast.atomWithBroadcast(key, require_is_atom.isAtom(initialValueOrAtom) ? void 0 : initialValueOrAtom), debounceMs);
+	const wrapperAtom = require_base_atom.baseAtom((get) => {
+		return get(valueAtom);
+	}, (get, set, update) => {
+		const nextValue = (0, _stryke_type_checks_is_function.isFunction)(update) ? update(get(valueAtom)) : update;
+		set(valueAtom, nextValue);
+		set(debouncedStorageAtom.debouncedValueAtom, nextValue);
+		set(debouncedBroadcastAtom.debouncedValueAtom, nextValue);
+	});
+	const effectAtom = require_atom_with_effect.atomWithEffect((get, set) => {
+		const next = get(debouncedBroadcastAtom.debouncedValueAtom);
+		if (next !== get(wrapperAtom)) set(wrapperAtom, next);
+	});
+	return require_base_atom.baseAtom((get) => {
+		get(effectAtom);
+		return get(wrapperAtom);
+	}, (get, set, update) => {
+		set(wrapperAtom, update);
+	});
+}
+
+//#endregion
+exports.atomWithWebStorage = atomWithWebStorage;
+exports.getWebStorage = getWebStorage;

package/dist/base/atoms/atom-with-web-storage.mjs

@@ -1,2 +1,48 @@
-import{isAtom as e}from"../utilities/is-atom.mjs";import{baseAtom as t}from"./base-atom.mjs";import{atomWithBroadcast as n}from"./atom-with-broadcast.mjs";import{atomWithDebounce as r}from"./atom-with-debounce.mjs";import{atomWithEffect as i}from"./atom-with-effect.mjs";import{createWebStorage as a}from"../utilities/create-web-storage.mjs";import{isFunction as o}from"@stryke/type-checks/is-function";import{atomWithStorage as s}from"jotai/utils";const c=()=>a(()=>localStorage);function l(a,l,u=c(),d){let f=d?.debounceMs??500,p=d?.getOnInit??!0,m=e(l)?l:t(l),h=r(s(a,e(l)?void 0:l,u,{getOnInit:p}),f),g=r(n(a,e(l)?void 0:l),f),_=t(e=>e(m),(e,t,n)=>{let r=o(n)?n(e(m)):n;t(m,r),t(h.debouncedValueAtom,r),t(g.debouncedValueAtom,r)}),v=i((e,t)=>{let n=e(g.debouncedValueAtom);n!==e(_)&&t(_,n)});return t(e=>(e(v),e(_)),(e,t,n)=>{t(_,n)})}export{l as atomWithWebStorage,c as getWebStorage};
+import { isAtom } from "../utilities/is-atom.mjs";
+import { baseAtom } from "./base-atom.mjs";
+import { atomWithBroadcast } from "./atom-with-broadcast.mjs";
+import { atomWithDebounce } from "./atom-with-debounce.mjs";
+import { atomWithEffect } from "./atom-with-effect.mjs";
+import { createWebStorage } from "../utilities/create-web-storage.mjs";
+import { isFunction } from "@stryke/type-checks/is-function";
+import { atomWithStorage } from "jotai/utils";
+
+//#region src/base/atoms/atom-with-web-storage.ts
+const getWebStorage = () => createWebStorage(() => localStorage);
+/**
+* Creates an atom that persists its state in external storage and sends a broadcast message to other tabs/windows when the state changes.
+*
+* @param key - The key to use for the storage
+* @param initialValue - The initial value of the atom
+* @param webStorage - The storage to use
+* @returns An atom that persists its state in external storage and sends a broadcast message to other tabs/windows when the state changes.
+*/
+function atomWithWebStorage(key, initialValueOrAtom, webStorage = getWebStorage(), options) {
+	const debounceMs = options?.debounceMs ?? 500;
+	const getOnInit = options?.getOnInit ?? true;
+	const valueAtom = isAtom(initialValueOrAtom) ? initialValueOrAtom : baseAtom(initialValueOrAtom);
+	const debouncedStorageAtom = atomWithDebounce(atomWithStorage(key, isAtom(initialValueOrAtom) ? void 0 : initialValueOrAtom, webStorage, { getOnInit }), debounceMs);
+	const debouncedBroadcastAtom = atomWithDebounce(atomWithBroadcast(key, isAtom(initialValueOrAtom) ? void 0 : initialValueOrAtom), debounceMs);
+	const wrapperAtom = baseAtom((get) => {
+		return get(valueAtom);
+	}, (get, set, update) => {
+		const nextValue = isFunction(update) ? update(get(valueAtom)) : update;
+		set(valueAtom, nextValue);
+		set(debouncedStorageAtom.debouncedValueAtom, nextValue);
+		set(debouncedBroadcastAtom.debouncedValueAtom, nextValue);
+	});
+	const effectAtom = atomWithEffect((get, set) => {
+		const next = get(debouncedBroadcastAtom.debouncedValueAtom);
+		if (next !== get(wrapperAtom)) set(wrapperAtom, next);
+	});
+	return baseAtom((get) => {
+		get(effectAtom);
+		return get(wrapperAtom);
+	}, (get, set, update) => {
+		set(wrapperAtom, update);
+	});
+}
+
+//#endregion
+export { atomWithWebStorage, getWebStorage };
 //# sourceMappingURL=atom-with-web-storage.mjs.map

package/dist/base/atoms/atom-with-web-storage.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"atom-with-web-storage.mjs","names":["getWebStorage","createWebStorage","atomWithWebStorage","debounceMs","options","getOnInit","valueAtom","isAtom","initialValueOrAtom","baseAtom","debouncedStorageAtom","atomWithDebounce","atomWithStorage","key","webStorage","debouncedBroadcastAtom","atomWithBroadcast","wrapperAtom","get","nextValue","isFunction","update","set","effectAtom","atomWithEffect","next"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-web-storage.mjs","names":[],"sources":[],"mappings":""}

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

@@ -1 +1,25 @@
-const e=require("./base-atom.cjs");let t=require("@stryke/type-checks/is-function");const n=e=>(0,t.isFunction)(e)?{__fn:e}:e,r=e=>e&&typeof e==`object`&&`__fn`in e?e.__fn:e,i=t=>{let i=e.baseAtom(n(t));return e.baseAtom(e=>r(e(i)),(e,t,r)=>t(i,n(r)))};exports.atomWithWrapper=i;
+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-wrapper.ts
+const wrapFn = (fnOrValue) => (0, _stryke_type_checks_is_function.isFunction)(fnOrValue) ? { __fn: fnOrValue } : fnOrValue;
+const unwrapFn = (wrappedFnOrValue) => wrappedFnOrValue && typeof wrappedFnOrValue === "object" && "__fn" in wrappedFnOrValue ? wrappedFnOrValue.__fn : wrappedFnOrValue;
+/**
+* Create an atom with a wrapper that allows functions as values.
+*
+* @remarks
+* Jotai atoms don't allow functions as values by default. This function is a
+* drop-in replacement for `atom` that wraps functions in an object while
+* leaving non-functions unchanged. The wrapper object should be completely
+* invisible to consumers of the atom.
+*
+* @param initialValue - The initial value of the atom
+* @returns An atom with a wrapper that allows functions as values.
+*/
+const atomWithWrapper = (initialValue) => {
+	const rootAtom = require_base_atom.baseAtom(wrapFn(initialValue));
+	return require_base_atom.baseAtom((get) => unwrapFn(get(rootAtom)), (_get, set, value) => set(rootAtom, wrapFn(value)));
+};
+
+//#endregion
+exports.atomWithWrapper = atomWithWrapper;

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

@@ -1,2 +1,26 @@
-import{baseAtom as e}from"./base-atom.mjs";import{isFunction as t}from"@stryke/type-checks/is-function";const n=e=>t(e)?{__fn:e}:e,r=e=>e&&typeof e==`object`&&`__fn`in e?e.__fn:e,i=t=>{let i=e(n(t));return e(e=>r(e(i)),(e,t,r)=>t(i,n(r)))};export{i as atomWithWrapper};
+import { baseAtom } from "./base-atom.mjs";
+import { isFunction } from "@stryke/type-checks/is-function";
+
+//#region src/base/atoms/atom-with-wrapper.ts
+const wrapFn = (fnOrValue) => isFunction(fnOrValue) ? { __fn: fnOrValue } : fnOrValue;
+const unwrapFn = (wrappedFnOrValue) => wrappedFnOrValue && typeof wrappedFnOrValue === "object" && "__fn" in wrappedFnOrValue ? wrappedFnOrValue.__fn : wrappedFnOrValue;
+/**
+* Create an atom with a wrapper that allows functions as values.
+*
+* @remarks
+* Jotai atoms don't allow functions as values by default. This function is a
+* drop-in replacement for `atom` that wraps functions in an object while
+* leaving non-functions unchanged. The wrapper object should be completely
+* invisible to consumers of the atom.
+*
+* @param initialValue - The initial value of the atom
+* @returns An atom with a wrapper that allows functions as values.
+*/
+const atomWithWrapper = (initialValue) => {
+	const rootAtom = baseAtom(wrapFn(initialValue));
+	return baseAtom((get) => unwrapFn(get(rootAtom)), (_get, set, value) => set(rootAtom, wrapFn(value)));
+};
+
+//#endregion
+export { atomWithWrapper };
 //# sourceMappingURL=atom-with-wrapper.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"atom-with-wrapper.mjs","names":["wrapFn","isFunction","fnOrValue","unwrapFn","wrappedFnOrValue","atomWithWrapper","rootAtom","baseAtom","initialValue","get","set","value"],"sources":[],"mappings":""}
+{"version":3,"file":"atom-with-wrapper.mjs","names":[],"sources":[],"mappings":""}

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

@@ -1 +1,25 @@
-const e=require("../utilities/set-atom-debug.cjs");let t=require("jotai/vanilla");function n(n,r){let i=(0,t.atom)(n,r);return i.setDebugLabel=t=>{e.setAtomDebugLabel(i,t)},i}exports.baseAtom=n;
+const require_set_atom_debug = require("../utilities/set-atom-debug.cjs");
+let jotai_vanilla = require("jotai/vanilla");
+
+//#region src/base/atoms/base-atom.ts
+/**
+* Create a "base" atom that can be used to create derived atoms.
+* The base atom is a writable atom that can be used to create derived atoms.
+*
+* @remarks
+* This function serves as a wrapper around the `atom` function from the Jotai library that adds debugging helpers.
+*
+* @param readOrInitialValue - The initial value of the atom or a read function
+* @param write - The write function for the atom
+* @returns The base atom
+*/
+function baseAtom(readOrInitialValue, write) {
+	const result = (0, jotai_vanilla.atom)(readOrInitialValue, write);
+	result.setDebugLabel = (label) => {
+		require_set_atom_debug.setAtomDebugLabel(result, label);
+	};
+	return result;
+}
+
+//#endregion
+exports.baseAtom = baseAtom;

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

@@ -1,2 +1,26 @@
-import{setAtomDebugLabel as e}from"../utilities/set-atom-debug.mjs";import{atom as t}from"jotai/vanilla";function n(n,r){let i=t(n,r);return i.setDebugLabel=t=>{e(i,t)},i}export{n as baseAtom};
+import { setAtomDebugLabel } from "../utilities/set-atom-debug.mjs";
+import { atom } from "jotai/vanilla";
+
+//#region src/base/atoms/base-atom.ts
+/**
+* Create a "base" atom that can be used to create derived atoms.
+* The base atom is a writable atom that can be used to create derived atoms.
+*
+* @remarks
+* This function serves as a wrapper around the `atom` function from the Jotai library that adds debugging helpers.
+*
+* @param readOrInitialValue - The initial value of the atom or a read function
+* @param write - The write function for the atom
+* @returns The base atom
+*/
+function baseAtom(readOrInitialValue, write) {
+	const result = atom(readOrInitialValue, write);
+	result.setDebugLabel = (label) => {
+		setAtomDebugLabel(result, label);
+	};
+	return result;
+}
+
+//#endregion
+export { baseAtom };
 //# sourceMappingURL=base-atom.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"base-atom.mjs","names":["jotaiAtom","baseAtom","result","atom","readOrInitialValue","write","setAtomDebugLabel","label"],"sources":[],"mappings":""}
+{"version":3,"file":"base-atom.mjs","names":["jotaiAtom"],"sources":[],"mappings":""}

package/dist/base/atoms/index.cjs

@@ -1 +1,24 @@
-const e=require("./atom-with-broadcast.cjs"),t=require("./atom-with-compare.cjs"),n=require("./atom-with-wrapper.cjs"),r=require("./atom-with-debounce.cjs"),i=require("./atom-with-effect.cjs"),a=require("./atom-with-listeners.cjs"),o=require("./atom-with-pending.cjs"),s=require("./atom-with-refresh.cjs"),c=require("./atom-with-refresh-and-default.cjs"),l=require("./atom-with-toggle.cjs"),u=require("./atom-with-web-storage.cjs");exports.atomWithBroadcast=e.atomWithBroadcast,exports.atomWithCompare=t.atomWithCompare,exports.atomWithDebounce=r.atomWithDebounce,exports.atomWithEffect=i.atomWithEffect,exports.atomWithListeners=a.atomWithListeners,exports.atomWithPending=o.atomWithPending,exports.atomWithRefresh=s.atomWithRefresh,exports.atomWithRefreshAndDefault=c.atomWithRefreshAndDefault,exports.atomWithToggle=l.atomWithToggle,exports.atomWithWebStorage=u.atomWithWebStorage,exports.atomWithWrapper=n.atomWithWrapper,exports.getWebStorage=u.getWebStorage;
+const require_atom_with_broadcast = require("./atom-with-broadcast.cjs");
+const require_atom_with_compare = require("./atom-with-compare.cjs");
+const require_atom_with_wrapper = require("./atom-with-wrapper.cjs");
+const require_atom_with_debounce = require("./atom-with-debounce.cjs");
+const require_atom_with_effect = require("./atom-with-effect.cjs");
+const require_atom_with_listeners = require("./atom-with-listeners.cjs");
+const require_atom_with_pending = require("./atom-with-pending.cjs");
+const require_atom_with_refresh = require("./atom-with-refresh.cjs");
+const require_atom_with_refresh_and_default = require("./atom-with-refresh-and-default.cjs");
+const require_atom_with_toggle = require("./atom-with-toggle.cjs");
+const require_atom_with_web_storage = require("./atom-with-web-storage.cjs");
+
+exports.atomWithBroadcast = require_atom_with_broadcast.atomWithBroadcast;
+exports.atomWithCompare = require_atom_with_compare.atomWithCompare;
+exports.atomWithDebounce = require_atom_with_debounce.atomWithDebounce;
+exports.atomWithEffect = require_atom_with_effect.atomWithEffect;
+exports.atomWithListeners = require_atom_with_listeners.atomWithListeners;
+exports.atomWithPending = require_atom_with_pending.atomWithPending;
+exports.atomWithRefresh = require_atom_with_refresh.atomWithRefresh;
+exports.atomWithRefreshAndDefault = require_atom_with_refresh_and_default.atomWithRefreshAndDefault;
+exports.atomWithToggle = require_atom_with_toggle.atomWithToggle;
+exports.atomWithWebStorage = require_atom_with_web_storage.atomWithWebStorage;
+exports.atomWithWrapper = require_atom_with_wrapper.atomWithWrapper;
+exports.getWebStorage = require_atom_with_web_storage.getWebStorage;

package/dist/base/atoms/index.mjs

@@ -1 +1,13 @@
-import{atomWithBroadcast as e}from"./atom-with-broadcast.mjs";import{atomWithCompare as t}from"./atom-with-compare.mjs";import{atomWithWrapper as n}from"./atom-with-wrapper.mjs";import{atomWithDebounce as r}from"./atom-with-debounce.mjs";import{atomWithEffect as i}from"./atom-with-effect.mjs";import{atomWithListeners as a}from"./atom-with-listeners.mjs";import{atomWithPending as o}from"./atom-with-pending.mjs";import{atomWithRefresh as s}from"./atom-with-refresh.mjs";import{atomWithRefreshAndDefault as c}from"./atom-with-refresh-and-default.mjs";import{atomWithToggle as l}from"./atom-with-toggle.mjs";import{atomWithWebStorage as u,getWebStorage as d}from"./atom-with-web-storage.mjs";export{e as atomWithBroadcast,t as atomWithCompare,r as atomWithDebounce,i as atomWithEffect,a as atomWithListeners,o as atomWithPending,s as atomWithRefresh,c as atomWithRefreshAndDefault,l as atomWithToggle,u as atomWithWebStorage,n as atomWithWrapper,d as getWebStorage};
+import { atomWithBroadcast } from "./atom-with-broadcast.mjs";
+import { atomWithCompare } from "./atom-with-compare.mjs";
+import { atomWithWrapper } from "./atom-with-wrapper.mjs";
+import { atomWithDebounce } from "./atom-with-debounce.mjs";
+import { atomWithEffect } from "./atom-with-effect.mjs";
+import { atomWithListeners } from "./atom-with-listeners.mjs";
+import { atomWithPending } from "./atom-with-pending.mjs";
+import { atomWithRefresh } from "./atom-with-refresh.mjs";
+import { atomWithRefreshAndDefault } from "./atom-with-refresh-and-default.mjs";
+import { atomWithToggle } from "./atom-with-toggle.mjs";
+import { atomWithWebStorage, getWebStorage } from "./atom-with-web-storage.mjs";
+
+export { atomWithBroadcast, atomWithCompare, atomWithDebounce, atomWithEffect, atomWithListeners, atomWithPending, atomWithRefresh, atomWithRefreshAndDefault, atomWithToggle, atomWithWebStorage, atomWithWrapper, getWebStorage };

package/dist/base/hooks/index.cjs

@@ -1 +1,9 @@
-const e=require("./use-atom-effect.cjs"),t=require("./use-hydrate-molecule.cjs"),n=require("./use-prepare-atoms.cjs"),r=require("./use-sync-molecule.cjs");exports.useAtomEffect=e.useAtomEffect,exports.useHydrateMolecule=t.useHydrateMolecule,exports.usePrepareAtoms=n.usePrepareAtoms,exports.useSyncMolecule=r.useSyncMolecule;
+const require_use_atom_effect = require("./use-atom-effect.cjs");
+const require_use_hydrate_molecule = require("./use-hydrate-molecule.cjs");
+const require_use_prepare_atoms = require("./use-prepare-atoms.cjs");
+const require_use_sync_molecule = require("./use-sync-molecule.cjs");
+
+exports.useAtomEffect = require_use_atom_effect.useAtomEffect;
+exports.useHydrateMolecule = require_use_hydrate_molecule.useHydrateMolecule;
+exports.usePrepareAtoms = require_use_prepare_atoms.usePrepareAtoms;
+exports.useSyncMolecule = require_use_sync_molecule.useSyncMolecule;

package/dist/base/hooks/index.mjs

@@ -1 +1,6 @@
-import{useAtomEffect as e}from"./use-atom-effect.mjs";import{useHydrateMolecule as t}from"./use-hydrate-molecule.mjs";import{usePrepareAtoms as n}from"./use-prepare-atoms.mjs";import{useSyncMolecule as r}from"./use-sync-molecule.mjs";export{e as useAtomEffect,t as useHydrateMolecule,n as usePrepareAtoms,r as useSyncMolecule};
+import { useAtomEffect } from "./use-atom-effect.mjs";
+import { useHydrateMolecule } from "./use-hydrate-molecule.mjs";
+import { usePrepareAtoms } from "./use-prepare-atoms.mjs";
+import { useSyncMolecule } from "./use-sync-molecule.mjs";
+
+export { useAtomEffect, useHydrateMolecule, usePrepareAtoms, useSyncMolecule };

package/dist/base/hooks/use-atom-effect.cjs

@@ -1 +1,17 @@
-const e=require("../atoms/atom-with-effect.cjs");let t=require("jotai/utils"),n=require("@stryke/hooks/use-memo-stable"),r=require("jotai/react");function i(i,a=[]){(0,r.useAtomValue)((0,t.loadable)((0,n.useMemoStable)(()=>e.atomWithEffect(i),a)))}exports.useAtomEffect=i;
+const require_atom_with_effect = require("../atoms/atom-with-effect.cjs");
+let jotai_utils = require("jotai/utils");
+let _stryke_hooks_use_memo_stable = require("@stryke/hooks/use-memo-stable");
+let jotai_react = require("jotai/react");
+
+//#region src/base/hooks/use-atom-effect.ts
+/**
+* A hook that runs a side effect when the component mounts.
+*
+* @param effectFn - The side effect function.
+*/
+function useAtomEffect(effectFn, deps = []) {
+	(0, jotai_react.useAtomValue)((0, jotai_utils.loadable)((0, _stryke_hooks_use_memo_stable.useMemoStable)(() => require_atom_with_effect.atomWithEffect(effectFn), deps)));
+}
+
+//#endregion
+exports.useAtomEffect = useAtomEffect;

package/dist/base/hooks/use-atom-effect.mjs

@@ -1,2 +1,18 @@
-import{atomWithEffect as e}from"../atoms/atom-with-effect.mjs";import{loadable as t}from"jotai/utils";import{useMemoStable as n}from"@stryke/hooks/use-memo-stable";import{useAtomValue as r}from"jotai/react";function i(i,a=[]){r(t(n(()=>e(i),a)))}export{i as useAtomEffect};
+import { atomWithEffect } from "../atoms/atom-with-effect.mjs";
+import { loadable } from "jotai/utils";
+import { useMemoStable } from "@stryke/hooks/use-memo-stable";
+import { useAtomValue } from "jotai/react";
+
+//#region src/base/hooks/use-atom-effect.ts
+/**
+* A hook that runs a side effect when the component mounts.
+*
+* @param effectFn - The side effect function.
+*/
+function useAtomEffect(effectFn, deps = []) {
+	useAtomValue(loadable(useMemoStable(() => atomWithEffect(effectFn), deps)));
+}
+
+//#endregion
+export { useAtomEffect };
 //# sourceMappingURL=use-atom-effect.mjs.map

package/dist/base/hooks/use-atom-effect.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-atom-effect.mjs","names":["useAtomEffect","useAtomValue","loadable","useMemoStable","atomWithEffect","effectFn","deps"],"sources":[],"mappings":""}
+{"version":3,"file":"use-atom-effect.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/hooks/use-hydrate-molecule.cjs

@@ -1 +1,17 @@
-let e=require("jotai/utils");const t=(t,n,r)=>{let i=[];for(let e of Object.keys(t)){let r=n[e];r!==void 0&&i.push([t[e],r])}(0,e.useHydrateAtoms)(i,{store:r})};exports.useHydrateMolecule=t;
+let jotai_utils = require("jotai/utils");
+
+//#region src/base/hooks/use-hydrate-molecule.ts
+/**
+* Hydrate atoms with initial values for SSR.
+*/
+const useHydrateMolecule = (atoms, initialValues, store) => {
+	const values = [];
+	for (const key of Object.keys(atoms)) {
+		const initialValue = initialValues[key];
+		if (initialValue !== void 0) values.push([atoms[key], initialValue]);
+	}
+	(0, jotai_utils.useHydrateAtoms)(values, { store });
+};
+
+//#endregion
+exports.useHydrateMolecule = useHydrateMolecule;

package/dist/base/hooks/use-hydrate-molecule.mjs

@@ -1,2 +1,18 @@
-import{useHydrateAtoms as e}from"jotai/utils";const t=(t,n,r)=>{let i=[];for(let e of Object.keys(t)){let r=n[e];r!==void 0&&i.push([t[e],r])}e(i,{store:r})};export{t as useHydrateMolecule};
+import { useHydrateAtoms } from "jotai/utils";
+
+//#region src/base/hooks/use-hydrate-molecule.ts
+/**
+* Hydrate atoms with initial values for SSR.
+*/
+const useHydrateMolecule = (atoms, initialValues, store) => {
+	const values = [];
+	for (const key of Object.keys(atoms)) {
+		const initialValue = initialValues[key];
+		if (initialValue !== void 0) values.push([atoms[key], initialValue]);
+	}
+	useHydrateAtoms(values, { store });
+};
+
+//#endregion
+export { useHydrateMolecule };
 //# sourceMappingURL=use-hydrate-molecule.mjs.map

package/dist/base/hooks/use-hydrate-molecule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-hydrate-molecule.mjs","names":["useHydrateMolecule","values","key","atoms","initialValue","initialValues","useHydrateAtoms"],"sources":[],"mappings":""}
+{"version":3,"file":"use-hydrate-molecule.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/hooks/use-prepare-atoms.cjs

@@ -1 +1,20 @@
-let e=require("jotai/vanilla"),t=require("react"),n=require("jotai/react");function r(e,n=(e,t)=>e===t){let[r,i]=(0,t.useState)(e),a=e.length!==r.length||e.some((e,t)=>!n(e,r[t]));return a&&i(e),a?e:r}function i(i,a){let o=r(i);(0,n.useAtomValue)((0,t.useMemo)(()=>(0,e.atom)(e=>{o.map(t=>e(t))}),[o]),a)}exports.usePrepareAtoms=i;
+let jotai_vanilla = require("jotai/vanilla");
+let react = require("react");
+let jotai_react = require("jotai/react");
+
+//#region src/base/hooks/use-prepare-atoms.ts
+function useMemoList(list, compareFn = (a, b) => a === b) {
+	const [state, setState] = (0, react.useState)(list);
+	const listChanged = list.length !== state.length || list.some((arg, index) => !compareFn(arg, state[index]));
+	if (listChanged) setState(list);
+	return listChanged ? list : state;
+}
+function usePrepareAtoms(atoms, options) {
+	const stableAtoms = useMemoList(atoms);
+	(0, jotai_react.useAtomValue)((0, react.useMemo)(() => (0, jotai_vanilla.atom)((get) => {
+		stableAtoms.map((stableAtom) => get(stableAtom));
+	}), [stableAtoms]), options);
+}
+
+//#endregion
+exports.usePrepareAtoms = usePrepareAtoms;

package/dist/base/hooks/use-prepare-atoms.mjs

@@ -1,2 +1,21 @@
-import{atom as e}from"jotai/vanilla";import{useMemo as t,useState as n}from"react";import{useAtomValue as r}from"jotai/react";function i(e,t=(e,t)=>e===t){let[r,i]=n(e),a=e.length!==r.length||e.some((e,n)=>!t(e,r[n]));return a&&i(e),a?e:r}function a(n,a){let o=i(n);r(t(()=>e(e=>{o.map(t=>e(t))}),[o]),a)}export{a as usePrepareAtoms};
+import { atom } from "jotai/vanilla";
+import { useMemo, useState } from "react";
+import { useAtomValue } from "jotai/react";
+
+//#region src/base/hooks/use-prepare-atoms.ts
+function useMemoList(list, compareFn = (a, b) => a === b) {
+	const [state, setState] = useState(list);
+	const listChanged = list.length !== state.length || list.some((arg, index) => !compareFn(arg, state[index]));
+	if (listChanged) setState(list);
+	return listChanged ? list : state;
+}
+function usePrepareAtoms(atoms, options) {
+	const stableAtoms = useMemoList(atoms);
+	useAtomValue(useMemo(() => atom((get) => {
+		stableAtoms.map((stableAtom) => get(stableAtom));
+	}), [stableAtoms]), options);
+}
+
+//#endregion
+export { usePrepareAtoms };
 //# sourceMappingURL=use-prepare-atoms.mjs.map

package/dist/base/hooks/use-prepare-atoms.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-prepare-atoms.mjs","names":["useMemoList","a","b","state","setState","useState","list","listChanged","compareFn","arg","index","usePrepareAtoms","stableAtoms","atoms","useAtomValue","useMemo","atom","get","stableAtom","options"],"sources":[],"mappings":""}
+{"version":3,"file":"use-prepare-atoms.mjs","names":[],"sources":[],"mappings":""}

package/dist/base/hooks/use-sync-molecule.cjs

@@ -1 +1,37 @@
-const e=require("../utilities/is-atom.cjs");let t=require("@stryke/helpers/is-equal"),n=require("jotai"),r=require("react");const i=e=>{let n=(0,r.useRef)(e);return(0,t.isEqual)(n.current,e)||(n.current=e),n.current},a=(t,a,o)=>{for(let s of Object.keys(t)){let c=a[s];e.isAtom(c)&&(c=(0,n.useAtomValue)(c)),c=i(c);let l=(0,n.useSetAtom)(t[s],{store:o});(0,r.useEffect)(()=>{c!==void 0&&l(c)},[l,c])}};exports.useSyncMolecule=a;
+const require_is_atom = require("../utilities/is-atom.cjs");
+let _stryke_helpers_is_equal = require("@stryke/helpers/is-equal");
+let jotai = require("jotai");
+let react = require("react");
+
+//#region src/base/hooks/use-sync-molecule.ts
+/**
+* Keep the previous reference while `value` is deeply equal to it, so callers
+* passing a fresh object literal each render do not re-trigger effects.
+*/
+const useDeepStable = (value) => {
+	const ref = (0, react.useRef)(value);
+	if (!(0, _stryke_helpers_is_equal.isEqual)(ref.current, value)) ref.current = value;
+	return ref.current;
+};
+/**
+* Update atoms with new values on changes.
+*
+* @remarks
+* Values are compared deeply, so a provider that re-renders with equivalent
+* `initialState` does not write to its atoms again. Without this, two
+* providers sharing a molecule scope overwrite each other on every render.
+*/
+const useSyncMolecule = (atoms, values, store) => {
+	for (const key of Object.keys(atoms)) {
+		let value = values[key];
+		if (require_is_atom.isAtom(value)) value = (0, jotai.useAtomValue)(value);
+		value = useDeepStable(value);
+		const setAtom = (0, jotai.useSetAtom)(atoms[key], { store });
+		(0, react.useEffect)(() => {
+			if (value !== void 0) setAtom(value);
+		}, [setAtom, value]);
+	}
+};
+
+//#endregion
+exports.useSyncMolecule = useSyncMolecule;