@depup/jotai 2.18.0-depup.0

package/esm/vanilla.d.mts

@@ -0,0 +1,4 @@
+export { atom } from './vanilla/atom.mjs';
+export type { Atom, WritableAtom, PrimitiveAtom } from './vanilla/atom.mjs';
+export { createStore, getDefaultStore, INTERNAL_overrideCreateStore, } from './vanilla/store.mjs';
+export type { Getter, Setter, ExtractAtomValue, ExtractAtomArgs, ExtractAtomResult, SetStateAction, } from './vanilla/typeUtils.mjs';

package/esm/vanilla.mjs

@@ -0,0 +1,59 @@
+import { INTERNAL_buildStoreRev2 } from 'jotai/vanilla/internals';
+
+let keyCount = 0;
+function atom(read, write) {
+  const key = `atom${++keyCount}`;
+  const config = {
+    toString() {
+      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && 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();
+    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
+      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;
+}
+
+export { INTERNAL_overrideCreateStore, atom, createStore, getDefaultStore };

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from 'jotai/vanilla';
+export * from 'jotai/react';

package/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var vanilla = require('jotai/vanilla');
+var react = require('jotai/react');
+
+
+
+Object.keys(vanilla).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return vanilla[k]; }
+	});
+});
+Object.keys(react).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return react[k]; }
+	});
+});

package/package.json

@@ -0,0 +1,125 @@
+{
+  "name": "@depup/jotai",
+  "description": "[DepUp] 👻 Primitive and flexible state management for React",
+  "private": false,
+  "type": "commonjs",
+  "version": "2.18.0-depup.0",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "typesVersions": {
+    ">=4.8": {
+      "esm/*": [
+        "esm/*"
+      ],
+      "*": [
+        "*"
+      ]
+    },
+    ">=3.8": {
+      "esm/*": [
+        "ts3.8/*"
+      ],
+      "*": [
+        "ts3.8/*"
+      ]
+    },
+    "*": {
+      "esm/*": [
+        "ts_version_3.8_and_above_is_required.d.ts"
+      ],
+      "*": [
+        "ts_version_3.8_and_above_is_required.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "react-native": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "import": {
+        "types": "./esm/index.d.mts",
+        "default": "./esm/index.mjs"
+      },
+      "default": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      }
+    },
+    "./*": {
+      "react-native": {
+        "types": "./*.d.ts",
+        "default": "./*.js"
+      },
+      "import": {
+        "types": "./esm/*.d.mts",
+        "default": "./esm/*.mjs"
+      },
+      "default": {
+        "types": "./*.d.ts",
+        "default": "./*.js"
+      }
+    }
+  },
+  "files": [
+    "**"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=12.20.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pmndrs/jotai.git"
+  },
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "jotai",
+    "react",
+    "state",
+    "manager",
+    "management",
+    "recoil",
+    "store"
+  ],
+  "author": "Daishi Kato",
+  "contributors": [],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pmndrs/jotai/issues"
+  },
+  "homepage": "https://github.com/pmndrs/jotai",
+  "packageManager": "pnpm@10.18.3",
+  "peerDependencies": {
+    "@babel/core": ">=7.0.0",
+    "@babel/template": ">=7.0.0",
+    "@types/react": ">=17.0.0",
+    "react": ">=17.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@babel/core": {
+      "optional": true
+    },
+    "@babel/template": {
+      "optional": true
+    },
+    "@types/react": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "depup": {
+    "changes": {},
+    "depsUpdated": 0,
+    "originalPackage": "jotai",
+    "originalVersion": "2.18.0",
+    "processedAt": "2026-03-09T03:53:57.128Z",
+    "smokeTest": "failed"
+  }
+}

package/react/Provider.d.ts

@@ -0,0 +1,16 @@
+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 {};

package/react/useAtom.d.ts

@@ -0,0 +1,13 @@
+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 {};

package/react/useAtomValue.d.ts

@@ -0,0 +1,9 @@
+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 {};

package/react/useSetAtom.d.ts

@@ -0,0 +1,7 @@
+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 {};

package/react/utils/useAtomCallback.d.ts

@@ -0,0 +1,5 @@
+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 {};

package/react/utils/useHydrateAtoms.d.ts

@@ -0,0 +1,14 @@
+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 {};

package/react/utils/useReducerAtom.d.ts

@@ -0,0 +1,14 @@
+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 {};

package/react/utils/useResetAtom.d.ts

@@ -0,0 +1,6 @@
+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 {};

package/react/utils.d.ts

@@ -0,0 +1,4 @@
+export { useResetAtom } from './utils/useResetAtom';
+export { useReducerAtom } from './utils/useReducerAtom';
+export { useAtomCallback } from './utils/useAtomCallback';
+export { useHydrateAtoms } from './utils/useHydrateAtoms';

package/react/utils.js

@@ -0,0 +1,100 @@
+'use client';
+'use strict';
+
+var react$1 = require('react');
+var react = require('jotai/react');
+var utils = require('jotai/vanilla/utils');
+var vanilla = require('jotai/vanilla');
+
+function useResetAtom(anAtom, options) {
+  var setAtom = react.useSetAtom(anAtom, options);
+  var resetAtom = react$1.useCallback(function () {
+    return setAtom(utils.RESET);
+  }, [setAtom]);
+  return resetAtom;
+}
+
+function useReducerAtom(anAtom, reducer, options) {
+  if (process.env.NODE_ENV !== 'production') {
+    console.warn('[DEPRECATED] useReducerAtom is deprecated and will be removed in the future. Please create your own version using the recipe. https://github.com/pmndrs/jotai/pull/2467');
+  }
+  var _useAtom = react.useAtom(anAtom, options),
+    state = _useAtom[0],
+    setState = _useAtom[1];
+  var dispatch = react$1.useCallback(function (action) {
+    setState(function (prev) {
+      return reducer(prev, action);
+    });
+  }, [setState, reducer]);
+  return [state, dispatch];
+}
+
+function useAtomCallback(callback, options) {
+  var anAtom = react$1.useMemo(function () {
+    return vanilla.atom(null, function (get, set) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      return callback.apply(void 0, [get, set].concat(args));
+    });
+  }, [callback]);
+  return react.useSetAtom(anAtom, options);
+}
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+    t && (r = t);
+    var o = 0;
+    return function () {
+      return o >= r.length ? {
+        done: true
+      } : {
+        done: false,
+        value: r[o++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+var hydratedMap = new WeakMap();
+function useHydrateAtoms(values, options) {
+  var store = react.useStore(options);
+  var hydratedSet = getHydratedSet(store);
+  for (var _iterator = _createForOfIteratorHelperLoose(values), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+      atom = _step$value[0],
+      args = _arrayLikeToArray(_step$value).slice(1);
+    if (!hydratedSet.has(atom) || options != null && options.dangerouslyForceHydrate) {
+      hydratedSet.add(atom);
+      store.set.apply(store, [atom].concat(args));
+    }
+  }
+}
+var getHydratedSet = function getHydratedSet(store) {
+  var hydratedSet = hydratedMap.get(store);
+  if (!hydratedSet) {
+    hydratedSet = new WeakSet();
+    hydratedMap.set(store, hydratedSet);
+  }
+  return hydratedSet;
+};
+
+exports.useAtomCallback = useAtomCallback;
+exports.useHydrateAtoms = useHydrateAtoms;
+exports.useReducerAtom = useReducerAtom;
+exports.useResetAtom = useResetAtom;

package/react.d.ts

@@ -0,0 +1,4 @@
+export { Provider, useStore } from './react/Provider';
+export { useAtomValue } from './react/useAtomValue';
+export { useSetAtom } from './react/useSetAtom';
+export { useAtom } from './react/useAtom';

package/react.js

@@ -0,0 +1,182 @@
+'use client';
+'use strict';
+
+var React = require('react');
+var vanilla = require('jotai/vanilla');
+var internals = require('jotai/vanilla/internals');
+
+var StoreContext = React.createContext(undefined);
+function useStore(options) {
+  var store = React.useContext(StoreContext);
+  return (options == null ? void 0 : options.store) || store || vanilla.getDefaultStore();
+}
+function Provider(_ref) {
+  var children = _ref.children,
+    store = _ref.store;
+  var storeRef = React.useRef(null);
+  if (store) {
+    return React.createElement(StoreContext.Provider, {
+      value: store
+    }, children);
+  }
+  if (storeRef.current === null) {
+    storeRef.current = vanilla.createStore();
+  }
+  return React.createElement(StoreContext.Provider, {
+    value: storeRef.current
+  }, children);
+}
+
+var isPromiseLike = function isPromiseLike(x) {
+  return typeof (x == null ? void 0 : x.then) === 'function';
+};
+var attachPromiseStatus = function attachPromiseStatus(promise) {
+  if (!promise.status) {
+    promise.status = 'pending';
+    promise.then(function (v) {
+      promise.status = 'fulfilled';
+      promise.value = v;
+    }, function (e) {
+      promise.status = 'rejected';
+      promise.reason = e;
+    });
+  }
+};
+var use = React.use || function (promise) {
+  if (promise.status === 'pending') {
+    throw promise;
+  } else if (promise.status === 'fulfilled') {
+    return promise.value;
+  } else if (promise.status === 'rejected') {
+    throw promise.reason;
+  } else {
+    attachPromiseStatus(promise);
+    throw promise;
+  }
+};
+var continuablePromiseMap = new WeakMap();
+var createContinuablePromise = function createContinuablePromise(store, promise, getValue) {
+  var buildingBlocks = internals.INTERNAL_getBuildingBlocksRev2(store);
+  var registerAbortHandler = buildingBlocks[26];
+  var continuablePromise = continuablePromiseMap.get(promise);
+  if (!continuablePromise) {
+    continuablePromise = new Promise(function (resolve, reject) {
+      var curr = promise;
+      var onFulfilled = function onFulfilled(me) {
+        return function (v) {
+          if (curr === me) {
+            resolve(v);
+          }
+        };
+      };
+      var onRejected = function onRejected(me) {
+        return function (e) {
+          if (curr === me) {
+            reject(e);
+          }
+        };
+      };
+      var _onAbort = function onAbort() {
+        try {
+          var nextValue = getValue();
+          if (isPromiseLike(nextValue)) {
+            continuablePromiseMap.set(nextValue, continuablePromise);
+            curr = nextValue;
+            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
+            registerAbortHandler(store, nextValue, _onAbort);
+          } else {
+            resolve(nextValue);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      };
+      promise.then(onFulfilled(promise), onRejected(promise));
+      registerAbortHandler(store, promise, _onAbort);
+    });
+    continuablePromiseMap.set(promise, continuablePromise);
+  }
+  return continuablePromise;
+};
+function useAtomValue(atom, options) {
+  var _ref = options || {},
+    delay = _ref.delay,
+    _ref$unstable_promise = _ref.unstable_promiseStatus,
+    promiseStatus = _ref$unstable_promise === void 0 ? !React.use : _ref$unstable_promise;
+  var store = useStore(options);
+  var _useReducer = React.useReducer(function (prev) {
+      var nextValue = store.get(atom);
+      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
+        return prev;
+      }
+      return [nextValue, store, atom];
+    }, undefined, function () {
+      return [store.get(atom), store, atom];
+    }),
+    _useReducer$ = _useReducer[0],
+    valueFromReducer = _useReducer$[0],
+    storeFromReducer = _useReducer$[1],
+    atomFromReducer = _useReducer$[2],
+    rerender = _useReducer[1];
+  var value = valueFromReducer;
+  if (storeFromReducer !== store || atomFromReducer !== atom) {
+    rerender();
+    value = store.get(atom);
+  }
+  React.useEffect(function () {
+    var unsub = store.sub(atom, function () {
+      if (promiseStatus) {
+        try {
+          var _value = store.get(atom);
+          if (isPromiseLike(_value)) {
+            attachPromiseStatus(createContinuablePromise(store, _value, function () {
+              return store.get(atom);
+            }));
+          }
+        } catch (_unused) {}
+      }
+      if (typeof delay === 'number') {
+        setTimeout(rerender, delay);
+        return;
+      }
+      rerender();
+    });
+    rerender();
+    return unsub;
+  }, [store, atom, delay, promiseStatus]);
+  React.useDebugValue(value);
+  if (isPromiseLike(value)) {
+    var promise = createContinuablePromise(store, value, function () {
+      return store.get(atom);
+    });
+    if (promiseStatus) {
+      attachPromiseStatus(promise);
+    }
+    return use(promise);
+  }
+  return value;
+}
+
+function useSetAtom(atom, options) {
+  var store = useStore(options);
+  var setAtom = React.useCallback(function () {
+    if (process.env.NODE_ENV !== 'production' && !('write' in atom)) {
+      throw new Error('not writable atom');
+    }
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return store.set.apply(store, [atom].concat(args));
+  }, [store, atom]);
+  return setAtom;
+}
+
+function useAtom(atom, options) {
+  return [useAtomValue(atom, options), useSetAtom(atom, options)];
+}
+
+exports.Provider = Provider;
+exports.useAtom = useAtom;
+exports.useAtomValue = useAtomValue;
+exports.useSetAtom = useSetAtom;
+exports.useStore = useStore;