@depup/jotai 2.18.0-depup.0

package/system/vanilla/utils.production.js

@@ -0,0 +1 @@
+System.register(["jotai/vanilla"],(function(x){"use strict";var m;return{setters:[function(O){m=O.atom}],execute:(function(){x({atomFamily:$,atomWithDefault:X,atomWithLazy:lt,atomWithObservable:nt,atomWithReducer:D,atomWithRefresh:at,atomWithReset:P,atomWithStorage:tt,createJSONStorage:V,freezeAtom:T,freezeAtomCreator:q,loadable:ct,selectAtom:K,splitAtom:U,unstable_withStorageValidator:Y,unwrap:_});const O=x("RESET",Symbol(""));function P(t){const e=m(t,(s,u,c)=>{const a=typeof c=="function"?c(s(e)):c;u(e,a===O?t:a)});return e}function D(t,e){return m(t,function(s,u,c){u(this,e(s(this),c))})}function $(t,e){let s=null;const u=new Map,c=new Set,a=i=>{let n;if(e===void 0)n=u.get(i);else for(const[l,f]of u)if(e(l,i)){n=f;break}if(n!==void 0)if(s!=null&&s(n[1],i))a.remove(i);else return n[0];const r=t(i);return u.set(i,[r,Date.now()]),o("CREATE",i,r),r},o=(i,n,r)=>{for(const l of c)l({type:i,param:n,atom:r})};return a.unstable_listen=i=>(c.add(i),()=>{c.delete(i)}),a.getParams=()=>u.keys(),a.remove=i=>{if(e===void 0){if(!u.has(i))return;const[n]=u.get(i);u.delete(i),o("REMOVE",i,n)}else for(const[n,[r]]of u)if(e(n,i)){u.delete(n),o("REMOVE",n,r);break}},a.setShouldRemove=i=>{if(s=i,!!s)for(const[n,[r,l]]of u)s(l,n)&&(u.delete(n),o("REMOVE",n,r))},a}const I=(t,e,s)=>(e.has(s)?e:e.set(s,t())).get(s),C=new WeakMap,F=(t,e,s,u)=>{const c=I(()=>new WeakMap,C,e),a=I(()=>new WeakMap,c,s);return I(t,a,u)};function K(t,e,s=Object.is){return F(()=>{const u=Symbol(),c=([o,i])=>{if(i===u)return e(o);const n=e(o,i);return s(i,n)?i:n},a=m(o=>{const i=o(a),n=o(t);return c([n,i])});return a.init=u,a},t,e,s)}const A=new WeakSet,L=t=>{if(typeof t!="object"||t===null)return t;Object.freeze(t);const e=Object.getOwnPropertyNames(t);for(const s of e)L(t[s]);return t};function T(t){if(A.has(t))return t;A.add(t);const e=t.read;if(t.read=function(s,u){return L(e.call(this,s,u))},"write"in t){const s=t.write;t.write=function(u,c,...a){return s.call(this,u,(...o)=>(o[0]===t&&(o[1]=L(o[1])),c(...o)),...a)}}return t}function q(t){return((...e)=>T(t(...e)))}const j=(t,e,s)=>(e.has(s)?e:e.set(s,t())).get(s),B=new WeakMap,G=(t,e,s)=>{const u=j(()=>new WeakMap,B,e);return j(t,u,s)},H={},N=t=>!!t.write,Q=t=>typeof t=="function";function U(t,e){return G(()=>{const s=new WeakMap,u=(o,i)=>{let n=s.get(o);if(n)return n;const r=i&&s.get(i),l=[],f=[];return o.forEach((b,v)=>{const d=e?e(b):v;f[v]=d;const g=r&&r.atomList[r.keyList.indexOf(d)];if(g){l[v]=g;return}const W=w=>{const y=w(c),h=w(t),k=u(h,y==null?void 0:y.arr).keyList.indexOf(d);if(k<0||k>=h.length){const p=o[u(o).keyList.indexOf(d)];if(p)return p;throw new Error("splitAtom: index out of bounds for read")}return h[k]},E=(w,y,h)=>{const k=w(c),p=w(t),S=u(p,k==null?void 0:k.arr).keyList.indexOf(d);if(S<0||S>=p.length)throw new Error("splitAtom: index out of bounds for write");const J=Q(h)?h(p[S]):h;Object.is(p[S],J)||y(t,[...p.slice(0,S),J,...p.slice(S+1)])};l[v]=N(t)?m(W,E):m(W)}),r&&r.keyList.length===f.length&&r.keyList.every((b,v)=>b===f[v])?n=r:n={arr:o,atomList:l,keyList:f},s.set(o,n),n},c=m(o=>{const i=o(c),n=o(t);return u(n,i==null?void 0:i.arr)});c.init=void 0;const a=N(t)?m(o=>o(c).atomList,(o,i,n)=>{switch(n.type){case"remove":{const r=o(a).indexOf(n.atom);if(r>=0){const l=o(t);i(t,[...l.slice(0,r),...l.slice(r+1)])}break}case"insert":{const r=n.before?o(a).indexOf(n.before):o(a).length;if(r>=0){const l=o(t);i(t,[...l.slice(0,r),n.value,...l.slice(r)])}break}case"move":{const r=o(a).indexOf(n.atom),l=n.before?o(a).indexOf(n.before):o(a).length;if(r>=0&&l>=0){const f=o(t);r<l?i(t,[...f.slice(0,r),...f.slice(r+1,l),f[r],...f.slice(l)]):i(t,[...f.slice(0,l),f[r],...f.slice(l,r),...f.slice(r+1)])}break}}}):m(o=>o(c).atomList);return a},t,e||H)}function X(t){const e=Symbol(),s=m(e),u=m((c,a)=>{const o=c(s);return o!==e?o:t(c,a)},(c,a,o)=>{const i=typeof o=="function"?o(c(u)):o;a(s,i===O?e:i)});return u}const M=t=>typeof(t==null?void 0:t.then)=="function";function Y(t){return e=>({...e,getItem:(s,u)=>{const c=o=>t(o)?o:u,a=e.getItem(s,u);return M(a)?a.then(c):c(a)}})}function V(t=()=>{try{return window.localStorage}catch(s){return}},e){var s;let u,c;const a={getItem:(n,r)=>{var l,f;const b=d=>{if(d=d||"",u!==d){try{c=JSON.parse(d,e==null?void 0:e.reviver)}catch(g){return r}u=d}return c},v=(f=(l=t())==null?void 0:l.getItem(n))!=null?f:null;return M(v)?v.then(b):b(v)},setItem:(n,r)=>{var l;return(l=t())==null?void 0:l.setItem(n,JSON.stringify(r,e==null?void 0:e.replacer))},removeItem:n=>{var r;return(r=t())==null?void 0:r.removeItem(n)}},o=n=>(r,l,f)=>n(r,b=>{let v;try{v=JSON.parse(b||"")}catch(d){v=f}l(v)});let i;try{i=(s=t())==null?void 0:s.subscribe}catch(n){}return!i&&typeof window!="undefined"&&typeof window.addEventListener=="function"&&window.Storage&&(i=(n,r)=>{if(!(t()instanceof window.Storage))return()=>{};const l=f=>{f.storageArea===t()&&f.key===n&&r(f.newValue)};return window.addEventListener("storage",l),()=>{window.removeEventListener("storage",l)}}),i&&(a.subscribe=o(i)),a}const Z=V();function tt(t,e,s=Z,u){const c=u==null?void 0:u.getOnInit,a=m(c?s.getItem(t,e):e);return a.onMount=o=>{o(s.getItem(t,e));let i;return s.subscribe&&(i=s.subscribe(t,o,e)),i},m(o=>o(a),(o,i,n)=>{const r=typeof n=="function"?n(o(a)):n;return r===O?(i(a,e),s.removeItem(t)):M(r)?r.then(l=>(i(a,l),s.setItem(t,l))):(i(a,r),s.setItem(t,r))})}const et=t=>typeof(t==null?void 0:t.then)=="function";function nt(t,e){const s=c=>{if("e"in c)throw c.e;return c.d},u=m(c=>{var a;let o=t(c);const i=(a=o[Symbol.observable])==null?void 0:a.call(o);i&&(o=i);let n;const r=()=>new Promise(h=>{n=h}),l=e&&"initialValue"in e?{d:typeof e.initialValue=="function"?e.initialValue():e.initialValue}:r();let f,b;const v=h=>{b=h,n==null||n(h),f==null||f(h)};let d,g;const W=()=>!f,E=()=>{d&&(d.unsubscribe(),d=void 0)},w=()=>{d&&(clearTimeout(g),d.unsubscribe()),d=o.subscribe({next:h=>v({d:h}),error:h=>v({e:h}),complete:()=>{}}),W()&&e!=null&&e.unstable_timeout&&(g=setTimeout(E,e.unstable_timeout))};w();const y=m(b||l);return y.onMount=h=>(f=h,b&&h(b),d?clearTimeout(g):w(),()=>{f=void 0,e!=null&&e.unstable_timeout?g=setTimeout(E,e.unstable_timeout):E()}),[y,o,r,w,W]});return m(c=>{const[a]=c(u),o=c(a);return et(o)?o.then(s):s(o)},(c,a,o)=>{const[i,n,r,l,f]=c(u);if("next"in n)f()&&(a(i,r()),l()),n.next(o);else throw new Error("observable is not subject")})}const z=(t,e,s)=>(e.has(s)?e:e.set(s,t())).get(s),ot=new WeakMap,rt=(t,e,s)=>{const u=z(()=>new WeakMap,ot,e);return z(t,u,s)},it=t=>typeof(t==null?void 0:t.then)=="function",st=()=>{};function _(t,e=st){return rt(()=>{const s=new WeakMap,u=new WeakMap,c=m(0),a=m([]);a.INTERNAL_onInit=i=>{i.set(a,[()=>i.set(c,n=>n+1)])};const o=m(i=>{i(c);let n;try{n=i(o)}catch(l){}const r=i(t);if(!it(r))return{v:r};if(r!==(n==null?void 0:n.p)&&r.then(l=>{u.set(r,l);const[f]=i(a);f()},l=>{s.set(r,l);const[f]=i(a);f()}),s.has(r))throw s.get(r);return u.has(r)?{p:r,v:u.get(r)}:n&&"v"in n?{p:r,f:e(n.v),v:n.v}:{p:r,f:e()}});return o.init=void 0,m(i=>{const n=i(o);return"f"in n?n.f:n.v},(i,n,...r)=>n(t,...r))},t,e)}const R=new WeakMap,ut=(t,e)=>(R.has(e)?R:R.set(e,t())).get(e);function ct(t){return ut(()=>{const e={state:"loading"},s=_(t,()=>e);return m(u=>{try{const c=u(s);return c===e?e:{state:"hasData",data:c}}catch(c){return{state:"hasError",error:c}}})},t)}function at(t,e){const s=m(0);return m((u,c)=>(u(s),t(u,c)),(u,c,...a)=>{if(a.length===0)c(s,o=>o+1);else if(e)return e(u,c,...a)})}function lt(t){const e=m(void 0);return delete e.init,Object.defineProperty(e,"init",{get(){return t()}}),e}})}}));

package/system/vanilla.development.js

@@ -0,0 +1,75 @@
+System.register(['jotai/vanilla/internals'], (function (exports) {
+  'use strict';
+  var INTERNAL_buildStoreRev2;
+  return {
+    setters: [function (module) {
+      INTERNAL_buildStoreRev2 = module.INTERNAL_buildStoreRev2;
+    }],
+    execute: (function () {
+
+      exports({
+        INTERNAL_overrideCreateStore: INTERNAL_overrideCreateStore,
+        atom: atom,
+        createStore: createStore,
+        getDefaultStore: getDefaultStore
+      });
+
+      let keyCount = 0;
+      function atom(read, write) {
+        const key = `atom${++keyCount}`;
+        const config = {
+          toString() {
+            return this.debugLabel ? key + ":" + this.debugLabel : key;
+          }
+        };
+        if (typeof read === "function") {
+          config.read = read;
+        } else {
+          config.init = read;
+          config.read = defaultRead;
+          config.write = defaultWrite;
+        }
+        if (write) {
+          config.write = write;
+        }
+        return config;
+      }
+      function defaultRead(get) {
+        return get(this);
+      }
+      function defaultWrite(get, set, arg) {
+        return set(
+          this,
+          typeof arg === "function" ? arg(get(this)) : arg
+        );
+      }
+
+      let overriddenCreateStore;
+      function INTERNAL_overrideCreateStore(fn) {
+        overriddenCreateStore = fn(overriddenCreateStore);
+      }
+      function createStore() {
+        if (overriddenCreateStore) {
+          return overriddenCreateStore();
+        }
+        return INTERNAL_buildStoreRev2();
+      }
+      let defaultStore;
+      function getDefaultStore() {
+        if (!defaultStore) {
+          defaultStore = createStore();
+          {
+            globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
+            if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
+              console.warn(
+                "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
+              );
+            }
+          }
+        }
+        return defaultStore;
+      }
+
+    })
+  };
+}));

package/system/vanilla.production.js

@@ -0,0 +1 @@
+System.register(["jotai/vanilla/internals"],(function(f){"use strict";var a;return{setters:[function(i){a=i.INTERNAL_buildStoreRev2}],execute:(function(){f({INTERNAL_overrideCreateStore:N,atom:l,createStore:c,getDefaultStore:d});let i=0;function l(t,o){const r=`atom${++i}`,e={toString(){return r}};return typeof t=="function"?e.read=t:(e.init=t,e.read=s,e.write=S),o&&(e.write=o),e}function s(t){return t(this)}function S(t,o,r){return o(this,typeof r=="function"?r(t(this)):r)}let n;function N(t){n=t(n)}function c(){return n?n():a()}let u;function d(){return u||(u=c()),u}})}}));

package/ts3.8/babel/plugin-debug-label.d.ts

@@ -0,0 +1,6 @@
+import babel from '@babel/core';
+import type { PluginObj } from '@babel/core';
+import type { PluginOptions } from './utils';
+/** @deprecated Use `jotai-babel/plugin-debug-label` instead. */
+export default function debugLabelPlugin({ types: t }: typeof babel, options?: PluginOptions): PluginObj;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/babel/plugin-react-refresh.d.ts

@@ -0,0 +1,6 @@
+import babel from '@babel/core';
+import type { PluginObj } from '@babel/core';
+import type { PluginOptions } from './utils';
+/** @deprecated Use `jotai-babel/plugin-react-refresh` instead. */
+export default function reactRefreshPlugin({ types: t }: typeof babel, options?: PluginOptions): PluginObj;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/babel/preset.d.ts

@@ -0,0 +1,7 @@
+import babel from '@babel/core';
+import type { PluginOptions } from './utils';
+/** @deprecated Use `jotai-babel/preset` instead. */
+export default function jotaiPreset(_: typeof babel, options?: PluginOptions): {
+    plugins: babel.PluginItem[];
+};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/babel/utils.d.ts

@@ -0,0 +1,6 @@
+import { types } from '@babel/core';
+export interface PluginOptions {
+    customAtomNames?: string[];
+}
+export declare function isAtom(t: typeof types, callee: babel.types.Expression | babel.types.V8IntrinsicIdentifier, customAtomNames?: PluginOptions['customAtomNames']): boolean;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/benchmarks/simple-read.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/benchmarks/simple-write.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/benchmarks/subscribe-write.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/babel/plugin-debug-label.d.ts

@@ -0,0 +1,6 @@
+import babel from '@babel/core';
+import type { PluginObj } from '@babel/core';
+import type { PluginOptions } from './utils';
+/** @deprecated Use `jotai-babel/plugin-debug-label` instead. */
+export default function debugLabelPlugin({ types: t }: typeof babel, options?: PluginOptions): PluginObj;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/babel/plugin-react-refresh.d.ts

@@ -0,0 +1,6 @@
+import babel from '@babel/core';
+import type { PluginObj } from '@babel/core';
+import type { PluginOptions } from './utils';
+/** @deprecated Use `jotai-babel/plugin-react-refresh` instead. */
+export default function reactRefreshPlugin({ types: t }: typeof babel, options?: PluginOptions): PluginObj;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/babel/preset.d.ts

@@ -0,0 +1,7 @@
+import babel from '@babel/core';
+import type { PluginOptions } from './utils';
+/** @deprecated Use `jotai-babel/preset` instead. */
+export default function jotaiPreset(_: typeof babel, options?: PluginOptions): {
+    plugins: babel.PluginItem[];
+};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/babel/utils.d.ts

@@ -0,0 +1,6 @@
+import { types } from '@babel/core';
+export interface PluginOptions {
+    customAtomNames?: string[];
+}
+export declare function isAtom(t: typeof types, callee: babel.types.Expression | babel.types.V8IntrinsicIdentifier, customAtomNames?: PluginOptions['customAtomNames']): boolean;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from 'jotai/vanilla';
+export * from 'jotai/react';
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/Provider.d.ts

@@ -0,0 +1,17 @@
+import type { FunctionComponent, ReactElement, ReactNode } from 'react';
+import { createStore } from 'jotai/vanilla';
+type Store = ReturnType<typeof createStore>;
+type Options = {
+    store?: Store;
+};
+export declare function useStore(options?: Options): Store;
+export declare function Provider({ children, store, }: {
+    children?: ReactNode;
+    store?: Store;
+}): ReactElement<{
+    value: Store | undefined;
+}, FunctionComponent<{
+    value: Store;
+}>>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/useAtom.d.ts

@@ -0,0 +1,28 @@
+import type { Atom, ExtractAtomArgs, ExtractAtomResult, ExtractAtomValue, PrimitiveAtom, SetStateAction, WritableAtom } from 'jotai/vanilla';
+import { useAtomValue } from './useAtomValue';
+type SetAtom<Args extends unknown[], Result> = (...args: Args) => Result;
+type Options = Parameters<typeof useAtomValue>[1];
+export declare function useAtom<Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, options?: Options): [
+    Awaited<Value>,
+    SetAtom<Args, Result>
+];
+export declare function useAtom<Value>(atom: PrimitiveAtom<Value>, options?: Options): [
+    Awaited<Value>,
+    SetAtom<[
+        SetStateAction<Value>
+    ], void>
+];
+export declare function useAtom<Value>(atom: Atom<Value>, options?: Options): [
+    Awaited<Value>,
+    never
+];
+export declare function useAtom<AtomType extends WritableAtom<unknown, never[], unknown>>(atom: AtomType, options?: Options): [
+    Awaited<ExtractAtomValue<AtomType>>,
+    SetAtom<ExtractAtomArgs<AtomType>, ExtractAtomResult<AtomType>>
+];
+export declare function useAtom<AtomType extends Atom<unknown>>(atom: AtomType, options?: Options): [
+    Awaited<ExtractAtomValue<AtomType>>,
+    never
+];
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/useAtomValue.d.ts

@@ -0,0 +1,10 @@
+import type { Atom, ExtractAtomValue } from 'jotai/vanilla';
+import { useStore } from './Provider';
+type Options = Parameters<typeof useStore>[0] & {
+    delay?: number;
+    unstable_promiseStatus?: boolean;
+};
+export declare function useAtomValue<Value>(atom: Atom<Value>, options?: Options): Awaited<Value>;
+export declare function useAtomValue<AtomType extends Atom<unknown>>(atom: AtomType, options?: Options): Awaited<ExtractAtomValue<AtomType>>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/useSetAtom.d.ts

@@ -0,0 +1,8 @@
+import type { ExtractAtomArgs, ExtractAtomResult, WritableAtom } from 'jotai/vanilla';
+import { useStore } from './Provider';
+type SetAtom<Args extends unknown[], Result> = (...args: Args) => Result;
+type Options = Parameters<typeof useStore>[0];
+export declare function useSetAtom<Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, options?: Options): SetAtom<Args, Result>;
+export declare function useSetAtom<AtomType extends WritableAtom<unknown, never[], unknown>>(atom: AtomType, options?: Options): SetAtom<ExtractAtomArgs<AtomType>, ExtractAtomResult<AtomType>>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/utils/useAtomCallback.d.ts

@@ -0,0 +1,6 @@
+import { useSetAtom } from 'jotai/react';
+import type { Getter, Setter } from 'jotai/vanilla';
+type Options = Parameters<typeof useSetAtom>[1];
+export declare function useAtomCallback<Result, Args extends unknown[]>(callback: (get: Getter, set: Setter, ...arg: Args) => Result, options?: Options): (...args: Args) => Result;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/utils/useHydrateAtoms.d.ts

@@ -0,0 +1,27 @@
+import { useStore } from 'jotai/react';
+import type { WritableAtom } from 'jotai/vanilla';
+type Options = Parameters<typeof useStore>[0] & {
+    dangerouslyForceHydrate?: boolean;
+};
+type AnyWritableAtom = WritableAtom<any, any[], any>;
+type InferAtomTuples<T> = {
+    [K in keyof T]: T[K] extends readonly [
+        infer A,
+        ...infer Rest
+    ] ? A extends WritableAtom<unknown, infer Args, unknown> ? Rest extends Args ? readonly [
+        A,
+        ...Rest
+    ] : never : T[K] : never;
+};
+export type INTERNAL_InferAtomTuples<T> = InferAtomTuples<T>;
+export declare function useHydrateAtoms<T extends (readonly [
+    AnyWritableAtom,
+    ...unknown[]
+])[]>(values: InferAtomTuples<T>, options?: Options): void;
+export declare function useHydrateAtoms<T extends Map<AnyWritableAtom, unknown>>(values: T, options?: Options): void;
+export declare function useHydrateAtoms<T extends Iterable<readonly [
+    AnyWritableAtom,
+    ...unknown[]
+]>>(values: InferAtomTuples<T>, options?: Options): void;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/utils/useReducerAtom.d.ts

@@ -0,0 +1,21 @@
+import { useAtom } from 'jotai/react';
+import type { PrimitiveAtom } from 'jotai/vanilla';
+type Options = Parameters<typeof useAtom>[1];
+/**
+ * @deprecated please use a recipe instead
+ * https://github.com/pmndrs/jotai/pull/2467
+ */
+export declare function useReducerAtom<Value, Action>(anAtom: PrimitiveAtom<Value>, reducer: (v: Value, a?: Action) => Value, options?: Options): [
+    Value,
+    (action?: Action) => void
+];
+/**
+ * @deprecated please use a recipe instead
+ * https://github.com/pmndrs/jotai/pull/2467
+ */
+export declare function useReducerAtom<Value, Action>(anAtom: PrimitiveAtom<Value>, reducer: (v: Value, a: Action) => Value, options?: Options): [
+    Value,
+    (action: Action) => void
+];
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/utils/useResetAtom.d.ts

@@ -0,0 +1,9 @@
+import { useSetAtom } from 'jotai/react';
+import { RESET } from 'jotai/vanilla/utils';
+import type { WritableAtom } from 'jotai/vanilla';
+type Options = Parameters<typeof useSetAtom>[1];
+export declare function useResetAtom<T>(anAtom: WritableAtom<unknown, [
+    typeof RESET
+], T>, options?: Options): () => T;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react/utils.d.ts

@@ -0,0 +1,5 @@
+export { useResetAtom } from './utils/useResetAtom';
+export { useReducerAtom } from './utils/useReducerAtom';
+export { useAtomCallback } from './utils/useAtomCallback';
+export { useHydrateAtoms } from './utils/useHydrateAtoms';
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/react.d.ts

@@ -0,0 +1,5 @@
+export { Provider, useStore } from './react/Provider';
+export { useAtomValue } from './react/useAtomValue';
+export { useSetAtom } from './react/useSetAtom';
+export { useAtom } from './react/useAtom';
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/utils.d.ts

@@ -0,0 +1,3 @@
+export * from 'jotai/vanilla/utils';
+export * from 'jotai/react/utils';
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/vanilla/atom.d.ts

@@ -0,0 +1,48 @@
+import type { Store } from './store';
+type Getter = <Value>(atom: Atom<Value>) => Value;
+type Setter = <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type SetAtom<Args extends unknown[], Result> = <A extends Args>(...args: A) => Result;
+/**
+ * setSelf is for internal use only and subject to change without notice.
+ */
+type Read<Value, SetSelf = never> = (get: Getter, options: {
+    readonly signal: AbortSignal;
+    readonly setSelf: SetSelf;
+}) => Value;
+type Write<Args extends unknown[], Result> = (get: Getter, set: Setter, ...args: Args) => Result;
+type WithInitialValue<Value> = {
+    init: Value;
+};
+type OnUnmount = () => void;
+type OnMount<Args extends unknown[], Result> = <S extends SetAtom<Args, Result>>(setAtom: S) => OnUnmount | void;
+export interface Atom<Value> {
+    toString: () => string;
+    read: Read<Value>;
+    debugLabel?: string;
+    /**
+     * To ONLY be used by Jotai libraries to mark atoms as private. Subject to change.
+     * @private
+     */
+    debugPrivate?: boolean;
+    /**
+     * Fires after atom is referenced by the store for the first time
+     * This is an internal API and subject to change without notice.
+     */
+    INTERNAL_onInit?: (store: Store) => void;
+}
+export interface WritableAtom<Value, Args extends unknown[], Result> extends Atom<Value> {
+    read: Read<Value, SetAtom<Args, unknown>>;
+    write: Write<Args, Result>;
+    onMount?: OnMount<Args, Result>;
+}
+type SetStateAction<Value> = Value | ((prev: Value) => Value);
+export type PrimitiveAtom<Value> = WritableAtom<Value, [
+    SetStateAction<Value>
+], void>;
+export declare function atom<Value, Args extends unknown[], Result>(read: Read<Value, SetAtom<Args, unknown>>, write: Write<Args, Result>): WritableAtom<Value, Args, Result>;
+export declare function atom<Value>(read: Read<Value>): Atom<Value>;
+export declare function atom<Value, Args extends unknown[], Result>(initialValue: Value, write: Write<Args, Result>): WritableAtom<Value, Args, Result> & WithInitialValue<Value>;
+export declare function atom<Value>(): PrimitiveAtom<Value | undefined> & WithInitialValue<Value | undefined>;
+export declare function atom<Value>(initialValue: Value): PrimitiveAtom<Value> & WithInitialValue<Value>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/vanilla/internals.d.ts

@@ -0,0 +1,165 @@
+import type { Atom, WritableAtom } from './atom';
+type AnyValue = unknown;
+type AnyError = unknown;
+type AnyAtom = Atom<AnyValue>;
+type AnyWritableAtom = WritableAtom<AnyValue, unknown[], unknown>;
+type OnUnmount = () => void;
+type EpochNumber = number;
+/**
+ * Mutable atom state,
+ * tracked for both mounted and unmounted atoms in a store.
+ *
+ * This should be garbage collectable.
+ * We can mutate it during atom read. (except for fields with TODO)
+ */
+type AtomState<Value = AnyValue> = {
+    /**
+     * Map of atoms that the atom depends on.
+     * The map value is the epoch number of the dependency.
+     */
+    readonly d: Map<AnyAtom, EpochNumber>;
+    /**
+     * Set of atoms with pending promise that depend on the atom.
+     *
+     * This may cause memory leaks, but it's for the capability to continue promises
+     * TODO(daishi): revisit how to handle this
+     */
+    readonly p: Set<AnyAtom>;
+    /** The epoch number of the atom. */
+    n: EpochNumber;
+    /** Atom value */
+    v?: Value;
+    /** Atom error */
+    e?: AnyError;
+};
+/**
+ * State tracked for mounted atoms. An atom is considered "mounted" if it has a
+ * subscriber, or is a transitive dependency of another atom that has a
+ * subscriber.
+ * The mounted state of an atom is freed once it is no longer mounted.
+ */
+type Mounted = {
+    /** Set of listeners to notify when the atom value changes. */
+    readonly l: Set<() => void>;
+    /** Set of mounted atoms that the atom depends on. */
+    readonly d: Set<AnyAtom>;
+    /** Set of mounted atoms that depends on the atom. */
+    readonly t: Set<AnyAtom>;
+    /** Function to run when the atom is unmounted. */
+    u?: () => void;
+};
+type WeakMapLike<K extends object, V> = {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+};
+type SetLike<T> = {
+    readonly size: number;
+    add(value: T): void;
+    has(value: T): boolean;
+    delete(value: T): boolean;
+    clear(): void;
+    forEach(callback: (value: T) => void): void;
+    [Symbol.iterator](): IterableIterator<T>;
+};
+type AtomStateMap = WeakMapLike<AnyAtom, AtomState>;
+type MountedMap = WeakMapLike<AnyAtom, Mounted>;
+type InvalidatedAtoms = WeakMapLike<AnyAtom, EpochNumber>;
+type ChangedAtoms = SetLike<AnyAtom>;
+type Callbacks = SetLike<() => void>;
+type AtomRead = <Value>(store: Store, atom: Atom<Value>, ...params: Parameters<Atom<Value>['read']>) => Value;
+type AtomWrite = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, ...params: Parameters<WritableAtom<Value, Args, Result>['write']>) => Result;
+type AtomOnInit = <Value>(store: Store, atom: Atom<Value>) => void;
+type AtomOnMount = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, setAtom: (...args: Args) => Result) => OnUnmount | void;
+type EnsureAtomState = <Value>(store: Store, atom: Atom<Value>) => AtomState<Value>;
+type FlushCallbacks = (store: Store) => void;
+type RecomputeInvalidatedAtoms = (store: Store) => void;
+type ReadAtomState = <Value>(store: Store, atom: Atom<Value>) => AtomState<Value>;
+type InvalidateDependents = (store: Store, atom: AnyAtom) => void;
+type WriteAtomState = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type MountDependencies = (store: Store, atom: AnyAtom) => void;
+type MountAtom = <Value>(store: Store, atom: Atom<Value>) => Mounted;
+type UnmountAtom = <Value>(store: Store, atom: Atom<Value>) => Mounted | undefined;
+type SetAtomStateValueOrPromise = <Value>(store: Store, atom: Atom<Value>, valueOrPromise: Value) => void;
+type StoreGet = <Value>(store: Store, atom: Atom<Value>) => Value;
+type StoreSet = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type StoreSub = (store: Store, atom: AnyAtom, listener: () => void) => () => void;
+type EnhanceBuildingBlocks = (buildingBlocks: Readonly<BuildingBlocks>) => Readonly<BuildingBlocks>;
+type AbortHandlersMap = WeakMapLike<PromiseLike<unknown>, Set<() => void>>;
+type RegisterAbortHandler = <T>(store: Store, promise: PromiseLike<T>, abortHandler: () => void) => void;
+type AbortPromise = <T>(store: Store, promise: PromiseLike<T>) => void;
+type Store = {
+    get: <Value>(atom: Atom<Value>) => Value;
+    set: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+    sub: (atom: AnyAtom, listener: () => void) => () => void;
+};
+type BuildingBlocks = [
+    /*atomStateMap*/ AtomStateMap,
+    /*mountedMap*/ MountedMap,
+    /*invalidatedAtoms*/ InvalidatedAtoms,
+    /*changedAtoms*/ ChangedAtoms,
+    /*mountCallbacks*/ Callbacks,
+    /*unmountCallbacks*/ Callbacks,
+    /*storeHooks*/ StoreHooks,
+    /*atomRead*/ AtomRead,
+    /*atomWrite*/ AtomWrite,
+    /*atomOnInit*/ AtomOnInit,
+    /*atomOnMount*/ AtomOnMount,
+    /*ensureAtomState*/ EnsureAtomState,
+    /*flushCallbacks*/ FlushCallbacks,
+    /*recomputeInvalidatedAtoms*/ RecomputeInvalidatedAtoms,
+    /*readAtomState*/ ReadAtomState,
+    /*invalidateDependents*/ InvalidateDependents,
+    /*writeAtomState*/ WriteAtomState,
+    /*mountDependencies*/ MountDependencies,
+    /*mountAtom*/ MountAtom,
+    /*unmountAtom*/ UnmountAtom,
+    /*setAtomStateValueOrPromise*/ SetAtomStateValueOrPromise,
+    /*storeGet*/ StoreGet,
+    /*storeSet*/ StoreSet,
+    /*storeSub*/ StoreSub,
+    /*enhanceBuildingBlocks*/ EnhanceBuildingBlocks | undefined,
+    /*abortHandlersMap*/ AbortHandlersMap,
+    /*registerAbortHandler*/ RegisterAbortHandler,
+    /*abortPromise*/ AbortPromise
+];
+export type { AtomState as INTERNAL_AtomState, Mounted as INTERNAL_Mounted, AtomStateMap as INTERNAL_AtomStateMap, MountedMap as INTERNAL_MountedMap, InvalidatedAtoms as INTERNAL_InvalidatedAtoms, ChangedAtoms as INTERNAL_ChangedAtoms, Callbacks as INTERNAL_Callbacks, AtomRead as INTERNAL_AtomRead, AtomWrite as INTERNAL_AtomWrite, AtomOnInit as INTERNAL_AtomOnInit, AtomOnMount as INTERNAL_AtomOnMount, EnsureAtomState as INTERNAL_EnsureAtomState, FlushCallbacks as INTERNAL_FlushCallbacks, RecomputeInvalidatedAtoms as INTERNAL_RecomputeInvalidatedAtoms, ReadAtomState as INTERNAL_ReadAtomState, InvalidateDependents as INTERNAL_InvalidateDependents, WriteAtomState as INTERNAL_WriteAtomState, MountDependencies as INTERNAL_MountDependencies, MountAtom as INTERNAL_MountAtom, UnmountAtom as INTERNAL_UnmountAtom, Store as INTERNAL_Store, BuildingBlocks as INTERNAL_BuildingBlocks, StoreHooks as INTERNAL_StoreHooks, };
+declare function hasInitialValue<T extends Atom<AnyValue>>(atom: T): atom is T & (T extends Atom<infer Value> ? {
+    init: Value;
+} : never);
+declare function isActuallyWritableAtom(atom: AnyAtom): atom is AnyWritableAtom;
+declare function isAtomStateInitialized<Value>(atomState: AtomState<Value>): boolean;
+declare function returnAtomValue<Value>(atomState: AtomState<Value>): Value;
+declare function isPromiseLike(p: unknown): p is PromiseLike<unknown>;
+declare function addPendingPromiseToDependency(atom: AnyAtom, promise: PromiseLike<AnyValue>, dependencyAtomState: AtomState): void;
+declare function getMountedOrPendingDependents(atom: AnyAtom, atomState: AtomState, mountedMap: MountedMap): Iterable<AnyAtom>;
+type StoreHook = {
+    (): void;
+    add(callback: () => void): () => void;
+};
+type StoreHookForAtoms = {
+    (atom: AnyAtom): void;
+    add(atom: AnyAtom, callback: () => void): () => void;
+    add(atom: undefined, callback: (atom: AnyAtom) => void): () => void;
+};
+/** StoreHooks are an experimental API. */
+type StoreHooks = {
+    /** Listener to notify when the atom state is created. */
+    readonly i?: StoreHookForAtoms;
+    /** Listener to notify when the atom is read. */
+    readonly r?: StoreHookForAtoms;
+    /** Listener to notify when the atom value is changed. */
+    readonly c?: StoreHookForAtoms;
+    /** Listener to notify when the atom is mounted. */
+    readonly m?: StoreHookForAtoms;
+    /** Listener to notify when the atom is unmounted. */
+    readonly u?: StoreHookForAtoms;
+    /** Listener to notify when callbacks are being flushed. */
+    readonly f?: StoreHook;
+};
+declare function initializeStoreHooks(storeHooks: StoreHooks): Required<StoreHooks>;
+declare function getBuildingBlocks(store: Store): Readonly<BuildingBlocks>;
+declare function buildStore(...buildArgs: Partial<BuildingBlocks>): Store;
+export { buildStore as INTERNAL_buildStoreRev2, getBuildingBlocks as INTERNAL_getBuildingBlocksRev2, initializeStoreHooks as INTERNAL_initializeStoreHooksRev2, hasInitialValue as INTERNAL_hasInitialValue, isActuallyWritableAtom as INTERNAL_isActuallyWritableAtom, isAtomStateInitialized as INTERNAL_isAtomStateInitialized, returnAtomValue as INTERNAL_returnAtomValue, isPromiseLike as INTERNAL_isPromiseLike, addPendingPromiseToDependency as INTERNAL_addPendingPromiseToDependency, getMountedOrPendingDependents as INTERNAL_getMountedOrPendingDependents, };
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/vanilla/store.d.ts

@@ -0,0 +1,6 @@
+import type { INTERNAL_Store } from 'jotai/vanilla/internals';
+export type Store = INTERNAL_Store;
+export declare function INTERNAL_overrideCreateStore(fn: (prev: typeof createStore | undefined) => typeof createStore): void;
+export declare function createStore(): Store;
+export declare function getDefaultStore(): Store;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/vanilla/typeUtils.d.ts

@@ -0,0 +1,8 @@
+import type { Atom, PrimitiveAtom, WritableAtom } from './atom';
+export type Getter = Parameters<Atom<unknown>['read']>[0];
+export type Setter = Parameters<WritableAtom<unknown, unknown[], unknown>['write']>[1];
+export type ExtractAtomValue<AtomType> = AtomType extends Atom<infer Value> ? Value : never;
+export type ExtractAtomArgs<AtomType> = AtomType extends WritableAtom<unknown, infer Args, infer _Result> ? Args : never;
+export type ExtractAtomResult<AtomType> = AtomType extends WritableAtom<unknown, infer _Args, infer Result> ? Result : never;
+export type SetStateAction<Value> = ExtractAtomArgs<PrimitiveAtom<Value>>[0];
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/esm/vanilla/utils/atomFamily.d.ts

@@ -0,0 +1,56 @@
+import type { Atom } from 'jotai/vanilla';
+/**
+ * in milliseconds
+ */
+type CreatedAt = number;
+type ShouldRemove<Param> = (createdAt: CreatedAt, param: Param) => boolean;
+type Cleanup = () => void;
+type Callback<Param, AtomType> = (event: {
+    type: 'CREATE' | 'REMOVE';
+    param: Param;
+    atom: AtomType;
+}) => void;
+/**
+ * @deprecated atomFamily is deprecated and will be removed in v3.
+ * Please use the `jotai-family` package instead: https://github.com/jotaijs/jotai-family
+ *
+ * Install: `npm install jotai-family`
+ *
+ * Migration:
+ * ```ts
+ * // Before
+ * import { atomFamily } from 'jotai/utils'
+ *
+ * // After
+ * import { atomFamily } from 'jotai-family'
+ * ```
+ */
+export interface AtomFamily<Param, AtomType> {
+    (param: Param): AtomType;
+    getParams(): Iterable<Param>;
+    remove(param: Param): void;
+    setShouldRemove(shouldRemove: ShouldRemove<Param> | null): void;
+    /**
+     * fires when an atom is created or removed
+     * This API is for advanced use cases, and can change without notice.
+     */
+    unstable_listen(callback: Callback<Param, AtomType>): Cleanup;
+}
+/**
+ * @deprecated atomFamily is deprecated and will be removed in v3.
+ * Please use the `jotai-family` package instead: https://github.com/jotaijs/jotai-family
+ *
+ * Install: `npm install jotai-family`
+ *
+ * Migration:
+ * ```ts
+ * // Before
+ * import { atomFamily } from 'jotai/utils'
+ *
+ * // After
+ * import { atomFamily } from 'jotai-family'
+ * ```
+ */
+export declare function atomFamily<Param, AtomType extends Atom<unknown>>(initializeAtom: (param: Param) => AtomType, areEqual?: (a: Param, b: Param) => boolean): AtomFamily<Param, AtomType>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;