@depup/jotai 2.18.0-depup.0

package/ts3.8/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/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;

package/ts3.8/vanilla/utils/atomWithDefault.d.ts

@@ -0,0 +1,11 @@
+import type { WritableAtom } from 'jotai/vanilla';
+import { RESET } from './constants';
+type Read<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['read'];
+type DefaultSetStateAction<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+export declare function atomWithDefault<Value>(getDefault: Read<Value, [
+    DefaultSetStateAction<Value>
+], void>): WritableAtom<Value, [
+    DefaultSetStateAction<Value>
+], void>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/atomWithLazy.d.ts

@@ -0,0 +1,3 @@
+import type { PrimitiveAtom } from 'jotai/vanilla';
+export declare function atomWithLazy<Value>(makeInitial: () => Value): PrimitiveAtom<Value>;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/atomWithObservable.d.ts

@@ -0,0 +1,37 @@
+import type { Atom, Getter, WritableAtom } from 'jotai/vanilla';
+type AnyError = unknown;
+type Subscription = {
+    unsubscribe: () => void;
+};
+type Observer<T> = {
+    next: (value: T) => void;
+    error: (error: AnyError) => void;
+    complete: () => void;
+};
+type ObservableLike<T> = {
+    subscribe(observer: Observer<T>): Subscription;
+} | {
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+} | {
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+    subscribe(next: (value: T) => void): Subscription;
+};
+type SubjectLike<T> = ObservableLike<T> & Observer<T>;
+type Options<Data> = {
+    initialValue?: Data | (() => Data);
+    unstable_timeout?: number;
+};
+type OptionsWithInitialValue<Data> = {
+    initialValue: Data | (() => Data);
+    unstable_timeout?: number;
+};
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => SubjectLike<Data>, options: OptionsWithInitialValue<Data>): WritableAtom<Data, [
+    Data
+], void>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => SubjectLike<Data>, options?: Options<Data>): WritableAtom<Data | Promise<Data>, [
+    Data
+], void>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => ObservableLike<Data>, options: OptionsWithInitialValue<Data>): Atom<Data>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => ObservableLike<Data>, options?: Options<Data>): Atom<Data | Promise<Data>>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/atomWithReducer.d.ts

@@ -0,0 +1,8 @@
+import type { WritableAtom } from 'jotai/vanilla';
+export declare function atomWithReducer<Value, Action>(initialValue: Value, reducer: (value: Value, action?: Action) => Value): WritableAtom<Value, [
+    Action?
+], void>;
+export declare function atomWithReducer<Value, Action>(initialValue: Value, reducer: (value: Value, action: Action) => Value): WritableAtom<Value, [
+    Action
+], void>;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/atomWithRefresh.d.ts

@@ -0,0 +1,10 @@
+import type { WritableAtom } from 'jotai/vanilla';
+type Read<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['read'];
+type Write<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['write'];
+export declare function atomWithRefresh<Value, Args extends unknown[], Result>(read: Read<Value, Args, Result>, write: Write<Value, Args, Result>): WritableAtom<Value, Args | [
+], Result | void>;
+export declare function atomWithRefresh<Value>(read: Read<Value, [
+], void>): WritableAtom<Value, [
+], void>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/atomWithReset.d.ts

@@ -0,0 +1,11 @@
+import type { WritableAtom } from 'jotai/vanilla';
+import { RESET } from './constants';
+type SetStateActionWithReset<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+type WithInitialValue<Value> = {
+    init: Value;
+};
+export declare function atomWithReset<Value>(initialValue: Value): WritableAtom<Value, [
+    SetStateActionWithReset<Value>
+], void> & WithInitialValue<Value>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/atomWithStorage.d.ts

@@ -0,0 +1,53 @@
+import type { WritableAtom } from 'jotai/vanilla';
+import { RESET } from './constants';
+type Unsubscribe = () => void;
+type Subscribe<Value> = (key: string, callback: (value: Value) => void, initialValue: Value) => Unsubscribe | undefined;
+type StringSubscribe = (key: string, callback: (value: string | null) => void) => Unsubscribe | undefined;
+type SetStateActionWithReset<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+export interface AsyncStorage<Value> {
+    getItem: (key: string, initialValue: Value) => PromiseLike<Value>;
+    setItem: (key: string, newValue: Value) => PromiseLike<void>;
+    removeItem: (key: string) => PromiseLike<void>;
+    subscribe?: Subscribe<Value>;
+}
+export interface SyncStorage<Value> {
+    getItem: (key: string, initialValue: Value) => Value;
+    setItem: (key: string, newValue: Value) => void;
+    removeItem: (key: string) => void;
+    subscribe?: Subscribe<Value>;
+}
+export interface AsyncStringStorage {
+    getItem: (key: string) => PromiseLike<string | null>;
+    setItem: (key: string, newValue: string) => PromiseLike<void>;
+    removeItem: (key: string) => PromiseLike<void>;
+    subscribe?: StringSubscribe;
+}
+export interface SyncStringStorage {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, newValue: string) => void;
+    removeItem: (key: string) => void;
+    subscribe?: StringSubscribe;
+}
+export declare function withStorageValidator<Value>(validator: (value: unknown) => value is Value): {
+    (storage: AsyncStorage<unknown>): AsyncStorage<Value>;
+    (storage: SyncStorage<unknown>): SyncStorage<Value>;
+};
+type JsonStorageOptions = {
+    reviver?: (key: string, value: unknown) => unknown;
+    replacer?: (key: string, value: unknown) => unknown;
+};
+export declare function createJSONStorage<Value>(): SyncStorage<Value>;
+export declare function createJSONStorage<Value>(getStringStorage: () => AsyncStringStorage, options?: JsonStorageOptions): AsyncStorage<Value>;
+export declare function createJSONStorage<Value>(getStringStorage: () => SyncStringStorage, options?: JsonStorageOptions): SyncStorage<Value>;
+export declare function atomWithStorage<Value>(key: string, initialValue: Value, storage: AsyncStorage<Value>, options?: {
+    getOnInit?: boolean;
+}): WritableAtom<Value | Promise<Value>, [
+    SetStateActionWithReset<Value | Promise<Value>>
+], Promise<void>>;
+export declare function atomWithStorage<Value>(key: string, initialValue: Value, storage?: SyncStorage<Value>, options?: {
+    getOnInit?: boolean;
+}): WritableAtom<Value, [
+    SetStateActionWithReset<Value>
+], void>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const RESET: unique symbol;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/freezeAtom.d.ts

@@ -0,0 +1,7 @@
+import type { Atom } from 'jotai/vanilla';
+export declare function freezeAtom<AtomType extends Atom<unknown>>(anAtom: AtomType): AtomType;
+/**
+ * @deprecated Define it on users end
+ */
+export declare function freezeAtomCreator<CreateAtom extends (...args: unknown[]) => Atom<unknown>>(createAtom: CreateAtom): CreateAtom;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/loadable.d.ts

@@ -0,0 +1,34 @@
+import type { Atom } from 'jotai/vanilla';
+export type Loadable<Value> = {
+    state: 'loading';
+} | {
+    state: 'hasError';
+    error: unknown;
+} | {
+    state: 'hasData';
+    data: Awaited<Value>;
+};
+/**
+ * @deprecated `loadable` is deprecated infavor of `unwrap`.
+ *
+ * Userland implementation of loadable:
+ * ```js
+ * function loadable(anAtom) {
+ *   const LOADING = { state: 'loading' }
+ *   const unwrappedAtom = unwrap(anAtom, () => LOADING)
+ *   return atom((get) => {
+ *     try {
+ *       const data = get(unwrappedAtom)
+ *       if (data === LOADING) {
+ *         return LOADING
+ *       }
+ *       return { state: 'hasData', data }
+ *     } catch (error) {
+ *       return { state: 'hasError', error }
+ *     }
+ *   })
+ * }
+ * ```
+ */
+export declare function loadable<Value>(anAtom: Atom<Value>): Atom<Loadable<Value>>;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/selectAtom.d.ts

@@ -0,0 +1,3 @@
+import type { Atom } from 'jotai/vanilla';
+export declare function selectAtom<Value, Slice>(anAtom: Atom<Value>, selector: (v: Value, prevSlice?: Slice) => Slice, equalityFn?: (a: Slice, b: Slice) => boolean): Atom<Slice>;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/splitAtom.d.ts

@@ -0,0 +1,21 @@
+import type { Atom, PrimitiveAtom, WritableAtom } from 'jotai/vanilla';
+type SplitAtomAction<Item> = {
+    type: 'remove';
+    atom: PrimitiveAtom<Item>;
+} | {
+    type: 'insert';
+    value: Item;
+    before?: PrimitiveAtom<Item>;
+} | {
+    type: 'move';
+    atom: PrimitiveAtom<Item>;
+    before?: PrimitiveAtom<Item>;
+};
+export declare function splitAtom<Item, Key>(arrAtom: WritableAtom<Item[], [
+    Item[]
+], void>, keyExtractor?: (item: Item) => Key): WritableAtom<PrimitiveAtom<Item>[], [
+    SplitAtomAction<Item>
+], void>;
+export declare function splitAtom<Item, Key>(arrAtom: Atom<Item[]>, keyExtractor?: (item: Item) => Key): Atom<Atom<Item>[]>;
+export {};
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla/utils/unwrap.d.ts

@@ -0,0 +1,6 @@
+import type { Atom, WritableAtom } from 'jotai/vanilla';
+export declare function unwrap<Value, Args extends unknown[], Result>(anAtom: WritableAtom<Value, Args, Result>): WritableAtom<Awaited<Value> | undefined, Args, Result>;
+export declare function unwrap<Value, Args extends unknown[], Result, PendingValue>(anAtom: WritableAtom<Value, Args, Result>, fallback: (prev?: Awaited<Value>) => PendingValue): WritableAtom<Awaited<Value> | PendingValue, Args, Result>;
+export declare function unwrap<Value>(anAtom: Atom<Value>): Atom<Awaited<Value> | undefined>;
+export declare function unwrap<Value, PendingValue>(anAtom: Atom<Value>, fallback: (prev?: Awaited<Value>) => PendingValue): Atom<Awaited<Value> | PendingValue>;
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

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

@@ -0,0 +1,15 @@
+export { RESET } from './utils/constants';
+export { atomWithReset } from './utils/atomWithReset';
+export { atomWithReducer } from './utils/atomWithReducer';
+export { atomFamily } from './utils/atomFamily';
+export { selectAtom } from './utils/selectAtom';
+export { freezeAtom, freezeAtomCreator } from './utils/freezeAtom';
+export { splitAtom } from './utils/splitAtom';
+export { atomWithDefault } from './utils/atomWithDefault';
+export { atomWithStorage, createJSONStorage, withStorageValidator as unstable_withStorageValidator, } from './utils/atomWithStorage';
+export { atomWithObservable } from './utils/atomWithObservable';
+export { loadable } from './utils/loadable';
+export { unwrap } from './utils/unwrap';
+export { atomWithRefresh } from './utils/atomWithRefresh';
+export { atomWithLazy } from './utils/atomWithLazy';
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/ts3.8/vanilla.d.ts

@@ -0,0 +1,5 @@
+export { atom } from './vanilla/atom';
+export type { Atom, WritableAtom, PrimitiveAtom } from './vanilla/atom';
+export { createStore, getDefaultStore, INTERNAL_overrideCreateStore, } from './vanilla/store';
+export type { Getter, Setter, ExtractAtomValue, ExtractAtomArgs, ExtractAtomResult, SetStateAction, } from './vanilla/typeUtils';
+declare type Awaited<T> = T extends Promise<infer V> ? V : T;

package/umd/babel/plugin-debug-label.development.js

@@ -0,0 +1,58 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@babel/template')) :
+  typeof define === 'function' && define.amd ? define(['@babel/template'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.jotaiBabelPluginDebugLabel = factory(global._templateBuilder));
+})(this, (function (_templateBuilder) { 'use strict';
+
+  function isAtom(t, callee, customAtomNames) {
+    if (customAtomNames === void 0) {
+      customAtomNames = [];
+    }
+    var atomNames = [].concat(atomFunctionNames, customAtomNames);
+    if (t.isIdentifier(callee) && atomNames.includes(callee.name)) {
+      return true;
+    }
+    if (t.isMemberExpression(callee)) {
+      var property = callee.property;
+      if (t.isIdentifier(property) && atomNames.includes(property.name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  var atomFunctionNames = ['atom', 'atomFamily', 'atomWithDefault', 'atomWithObservable', 'atomWithReducer', 'atomWithReset', 'atomWithStorage', 'freezeAtom', 'loadable', 'selectAtom', 'splitAtom', 'unwrap', 'atomWithMachine', 'atomWithImmer', 'atomWithProxy', 'atomWithQuery', 'atomWithMutation', 'atomWithSubscription', 'atomWithStore', 'atomWithHash', 'atomWithLocation', 'focusAtom', 'atomWithValidate', 'validateAtoms', 'atomWithCache', 'atomWithRecoilValue'];
+
+  var templateBuilder = _templateBuilder.default || _templateBuilder;
+  function debugLabelPlugin(_ref, options) {
+    var t = _ref.types;
+    console.warn('[DEPRECATED] jotai/babel/plugin-debug-label is deprecated and will be removed in v3.\n' + 'Please use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel');
+    return {
+      visitor: {
+        ExportDefaultDeclaration: function ExportDefaultDeclaration(nodePath, state) {
+          var node = nodePath.node;
+          if (t.isCallExpression(node.declaration) && isAtom(t, node.declaration.callee, options == null ? void 0 : options.customAtomNames)) {
+            var filename = (state.filename || 'unknown').replace(/\.\w+$/, '');
+            var displayName = filename.split('/').pop();
+            if (displayName === 'index') {
+              displayName = filename.slice(0, -'/index'.length).split('/').pop() || 'unknown';
+            }
+            var buildExport = templateBuilder("\n          const %%atomIdentifier%% = %%atom%%;\n          export default %%atomIdentifier%%\n          ");
+            var ast = buildExport({
+              atomIdentifier: t.identifier(displayName),
+              atom: node.declaration
+            });
+            nodePath.replaceWithMultiple(ast);
+          }
+        },
+        VariableDeclarator: function VariableDeclarator(path) {
+          if (t.isIdentifier(path.node.id) && t.isCallExpression(path.node.init) && isAtom(t, path.node.init.callee, options == null ? void 0 : options.customAtomNames)) {
+            path.parentPath.insertAfter(t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(path.node.id.name), t.identifier('debugLabel')), t.stringLiteral(path.node.id.name))));
+          }
+        }
+      }
+    };
+  }
+
+  return debugLabelPlugin;
+
+}));

package/umd/babel/plugin-debug-label.production.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t(require("@babel/template")):"function"==typeof define&&define.amd?define(["@babel/template"],t):(e="undefined"!=typeof globalThis?globalThis:e||self).jotaiBabelPluginDebugLabel=t(e._templateBuilder)}(this,function(e){"use strict";function t(e,t,a){void 0===a&&(a=[]);var o=[].concat(i,a);if(e.isIdentifier(t)&&o.includes(t.name))return!0;if(e.isMemberExpression(t)){var n=t.property;if(e.isIdentifier(n)&&o.includes(n.name))return!0}return!1}var i=["atom","atomFamily","atomWithDefault","atomWithObservable","atomWithReducer","atomWithReset","atomWithStorage","freezeAtom","loadable","selectAtom","splitAtom","unwrap","atomWithMachine","atomWithImmer","atomWithProxy","atomWithQuery","atomWithMutation","atomWithSubscription","atomWithStore","atomWithHash","atomWithLocation","focusAtom","atomWithValidate","validateAtoms","atomWithCache","atomWithRecoilValue"],a=e.default||e;return function(e,i){var o=e.types;return console.warn("[DEPRECATED] jotai/babel/plugin-debug-label is deprecated and will be removed in v3.\nPlease use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel"),{visitor:{ExportDefaultDeclaration:function(e,n){var r=e.node;if(o.isCallExpression(r.declaration)&&t(o,r.declaration.callee,null==i?void 0:i.customAtomNames)){var l=(n.filename||"unknown").replace(/\.\w+$/,""),s=l.split("/").pop();"index"===s&&(s=l.slice(0,-6).split("/").pop()||"unknown");var m=a("\n          const %%atomIdentifier%% = %%atom%%;\n          export default %%atomIdentifier%%\n          ")({atomIdentifier:o.identifier(s),atom:r.declaration});e.replaceWithMultiple(m)}},VariableDeclarator:function(e){o.isIdentifier(e.node.id)&&o.isCallExpression(e.node.init)&&t(o,e.node.init.callee,null==i?void 0:i.customAtomNames)&&e.parentPath.insertAfter(o.expressionStatement(o.assignmentExpression("=",o.memberExpression(o.identifier(e.node.id.name),o.identifier("debugLabel")),o.stringLiteral(e.node.id.name))))}}}}});

package/umd/babel/plugin-react-refresh.development.js

@@ -0,0 +1,76 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@babel/template')) :
+  typeof define === 'function' && define.amd ? define(['@babel/template'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.jotaiBabelPluginReactRefresh = factory(global._templateBuilder));
+})(this, (function (_templateBuilder) { 'use strict';
+
+  function isAtom(t, callee, customAtomNames) {
+    if (customAtomNames === void 0) {
+      customAtomNames = [];
+    }
+    var atomNames = [].concat(atomFunctionNames, customAtomNames);
+    if (t.isIdentifier(callee) && atomNames.includes(callee.name)) {
+      return true;
+    }
+    if (t.isMemberExpression(callee)) {
+      var property = callee.property;
+      if (t.isIdentifier(property) && atomNames.includes(property.name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  var atomFunctionNames = ['atom', 'atomFamily', 'atomWithDefault', 'atomWithObservable', 'atomWithReducer', 'atomWithReset', 'atomWithStorage', 'freezeAtom', 'loadable', 'selectAtom', 'splitAtom', 'unwrap', 'atomWithMachine', 'atomWithImmer', 'atomWithProxy', 'atomWithQuery', 'atomWithMutation', 'atomWithSubscription', 'atomWithStore', 'atomWithHash', 'atomWithLocation', 'focusAtom', 'atomWithValidate', 'validateAtoms', 'atomWithCache', 'atomWithRecoilValue'];
+
+  var templateBuilder = _templateBuilder.default || _templateBuilder;
+  function reactRefreshPlugin(_ref, options) {
+    var t = _ref.types;
+    console.warn('[DEPRECATED] jotai/babel/plugin-react-refresh is deprecated and will be removed in v3.\n' + 'Please use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel');
+    return {
+      pre: function pre(_ref2) {
+        var opts = _ref2.opts;
+        if (!opts.filename) {
+          throw new Error('Filename must be available');
+        }
+      },
+      visitor: {
+        Program: {
+          exit: function exit(path) {
+            var jotaiAtomCache = templateBuilder("\n          globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {\n            cache: new Map(),\n            get(name, inst) { \n              if (this.cache.has(name)) {\n                return this.cache.get(name)\n              }\n              this.cache.set(name, inst)\n              return inst\n            },\n          }")();
+            path.unshiftContainer('body', jotaiAtomCache);
+          }
+        },
+        ExportDefaultDeclaration: function ExportDefaultDeclaration(nodePath, state) {
+          var node = nodePath.node;
+          if (t.isCallExpression(node.declaration) && isAtom(t, node.declaration.callee, options == null ? void 0 : options.customAtomNames)) {
+            var filename = state.filename || 'unknown';
+            var atomKey = filename + "/defaultExport";
+            var buildExport = templateBuilder("export default globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)");
+            var ast = buildExport({
+              atomKey: t.stringLiteral(atomKey),
+              atom: node.declaration
+            });
+            nodePath.replaceWith(ast);
+          }
+        },
+        VariableDeclarator: function VariableDeclarator(nodePath, state) {
+          var _nodePath$parentPath$, _nodePath$parentPath$2;
+          if (t.isIdentifier(nodePath.node.id) && t.isCallExpression(nodePath.node.init) && isAtom(t, nodePath.node.init.callee, options == null ? void 0 : options.customAtomNames) && ((_nodePath$parentPath$ = nodePath.parentPath.parentPath) != null && _nodePath$parentPath$.isProgram() || (_nodePath$parentPath$2 = nodePath.parentPath.parentPath) != null && _nodePath$parentPath$2.isExportNamedDeclaration())) {
+            var filename = state.filename || 'unknown';
+            var atomKey = filename + "/" + nodePath.node.id.name;
+            var buildAtomDeclaration = templateBuilder("const %%atomIdentifier%% = globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)");
+            var ast = buildAtomDeclaration({
+              atomIdentifier: t.identifier(nodePath.node.id.name),
+              atomKey: t.stringLiteral(atomKey),
+              atom: nodePath.node.init
+            });
+            nodePath.parentPath.replaceWith(ast);
+          }
+        }
+      }
+    };
+  }
+
+  return reactRefreshPlugin;
+
+}));

package/umd/babel/plugin-react-refresh.production.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t(require("@babel/template")):"function"==typeof define&&define.amd?define(["@babel/template"],t):(e="undefined"!=typeof globalThis?globalThis:e||self).jotaiBabelPluginReactRefresh=t(e._templateBuilder)}(this,function(e){"use strict";function t(e,t,i){void 0===i&&(i=[]);var o=[].concat(a,i);if(e.isIdentifier(t)&&o.includes(t.name))return!0;if(e.isMemberExpression(t)){var n=t.property;if(e.isIdentifier(n)&&o.includes(n.name))return!0}return!1}var a=["atom","atomFamily","atomWithDefault","atomWithObservable","atomWithReducer","atomWithReset","atomWithStorage","freezeAtom","loadable","selectAtom","splitAtom","unwrap","atomWithMachine","atomWithImmer","atomWithProxy","atomWithQuery","atomWithMutation","atomWithSubscription","atomWithStore","atomWithHash","atomWithLocation","focusAtom","atomWithValidate","validateAtoms","atomWithCache","atomWithRecoilValue"],i=e.default||e;return function(e,a){var o=e.types;return console.warn("[DEPRECATED] jotai/babel/plugin-react-refresh is deprecated and will be removed in v3.\nPlease use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel"),{pre:function(e){if(!e.opts.filename)throw new Error("Filename must be available")},visitor:{Program:{exit:function(e){var t=i("\n          globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {\n            cache: new Map(),\n            get(name, inst) { \n              if (this.cache.has(name)) {\n                return this.cache.get(name)\n              }\n              this.cache.set(name, inst)\n              return inst\n            },\n          }")();e.unshiftContainer("body",t)}},ExportDefaultDeclaration:function(e,n){var r=e.node;if(o.isCallExpression(r.declaration)&&t(o,r.declaration.callee,null==a?void 0:a.customAtomNames)){var l=(n.filename||"unknown")+"/defaultExport",m=i("export default globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)")({atomKey:o.stringLiteral(l),atom:r.declaration});e.replaceWith(m)}},VariableDeclarator:function(e,n){var r,l;if(o.isIdentifier(e.node.id)&&o.isCallExpression(e.node.init)&&t(o,e.node.init.callee,null==a?void 0:a.customAtomNames)&&(null!=(r=e.parentPath.parentPath)&&r.isProgram()||null!=(l=e.parentPath.parentPath)&&l.isExportNamedDeclaration())){var m=(n.filename||"unknown")+"/"+e.node.id.name,s=i("const %%atomIdentifier%% = globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)")({atomIdentifier:o.identifier(e.node.id.name),atomKey:o.stringLiteral(m),atom:e.node.init});e.parentPath.replaceWith(s)}}}}}});

package/umd/babel/preset.development.js

@@ -0,0 +1,114 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@babel/template')) :
+  typeof define === 'function' && define.amd ? define(['@babel/template'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.jotaiBabelPreset = factory(global._templateBuilder));
+})(this, (function (_templateBuilder) { 'use strict';
+
+  function isAtom(t, callee, customAtomNames) {
+    if (customAtomNames === void 0) {
+      customAtomNames = [];
+    }
+    var atomNames = [].concat(atomFunctionNames, customAtomNames);
+    if (t.isIdentifier(callee) && atomNames.includes(callee.name)) {
+      return true;
+    }
+    if (t.isMemberExpression(callee)) {
+      var property = callee.property;
+      if (t.isIdentifier(property) && atomNames.includes(property.name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  var atomFunctionNames = ['atom', 'atomFamily', 'atomWithDefault', 'atomWithObservable', 'atomWithReducer', 'atomWithReset', 'atomWithStorage', 'freezeAtom', 'loadable', 'selectAtom', 'splitAtom', 'unwrap', 'atomWithMachine', 'atomWithImmer', 'atomWithProxy', 'atomWithQuery', 'atomWithMutation', 'atomWithSubscription', 'atomWithStore', 'atomWithHash', 'atomWithLocation', 'focusAtom', 'atomWithValidate', 'validateAtoms', 'atomWithCache', 'atomWithRecoilValue'];
+
+  var templateBuilder$1 = _templateBuilder.default || _templateBuilder;
+  function debugLabelPlugin(_ref, options) {
+    var t = _ref.types;
+    console.warn('[DEPRECATED] jotai/babel/plugin-debug-label is deprecated and will be removed in v3.\n' + 'Please use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel');
+    return {
+      visitor: {
+        ExportDefaultDeclaration: function ExportDefaultDeclaration(nodePath, state) {
+          var node = nodePath.node;
+          if (t.isCallExpression(node.declaration) && isAtom(t, node.declaration.callee, options == null ? void 0 : options.customAtomNames)) {
+            var filename = (state.filename || 'unknown').replace(/\.\w+$/, '');
+            var displayName = filename.split('/').pop();
+            if (displayName === 'index') {
+              displayName = filename.slice(0, -'/index'.length).split('/').pop() || 'unknown';
+            }
+            var buildExport = templateBuilder$1("\n          const %%atomIdentifier%% = %%atom%%;\n          export default %%atomIdentifier%%\n          ");
+            var ast = buildExport({
+              atomIdentifier: t.identifier(displayName),
+              atom: node.declaration
+            });
+            nodePath.replaceWithMultiple(ast);
+          }
+        },
+        VariableDeclarator: function VariableDeclarator(path) {
+          if (t.isIdentifier(path.node.id) && t.isCallExpression(path.node.init) && isAtom(t, path.node.init.callee, options == null ? void 0 : options.customAtomNames)) {
+            path.parentPath.insertAfter(t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(path.node.id.name), t.identifier('debugLabel')), t.stringLiteral(path.node.id.name))));
+          }
+        }
+      }
+    };
+  }
+
+  var templateBuilder = _templateBuilder.default || _templateBuilder;
+  function reactRefreshPlugin(_ref, options) {
+    var t = _ref.types;
+    console.warn('[DEPRECATED] jotai/babel/plugin-react-refresh is deprecated and will be removed in v3.\n' + 'Please use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel');
+    return {
+      pre: function pre(_ref2) {
+        var opts = _ref2.opts;
+        if (!opts.filename) {
+          throw new Error('Filename must be available');
+        }
+      },
+      visitor: {
+        Program: {
+          exit: function exit(path) {
+            var jotaiAtomCache = templateBuilder("\n          globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {\n            cache: new Map(),\n            get(name, inst) { \n              if (this.cache.has(name)) {\n                return this.cache.get(name)\n              }\n              this.cache.set(name, inst)\n              return inst\n            },\n          }")();
+            path.unshiftContainer('body', jotaiAtomCache);
+          }
+        },
+        ExportDefaultDeclaration: function ExportDefaultDeclaration(nodePath, state) {
+          var node = nodePath.node;
+          if (t.isCallExpression(node.declaration) && isAtom(t, node.declaration.callee, options == null ? void 0 : options.customAtomNames)) {
+            var filename = state.filename || 'unknown';
+            var atomKey = filename + "/defaultExport";
+            var buildExport = templateBuilder("export default globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)");
+            var ast = buildExport({
+              atomKey: t.stringLiteral(atomKey),
+              atom: node.declaration
+            });
+            nodePath.replaceWith(ast);
+          }
+        },
+        VariableDeclarator: function VariableDeclarator(nodePath, state) {
+          var _nodePath$parentPath$, _nodePath$parentPath$2;
+          if (t.isIdentifier(nodePath.node.id) && t.isCallExpression(nodePath.node.init) && isAtom(t, nodePath.node.init.callee, options == null ? void 0 : options.customAtomNames) && ((_nodePath$parentPath$ = nodePath.parentPath.parentPath) != null && _nodePath$parentPath$.isProgram() || (_nodePath$parentPath$2 = nodePath.parentPath.parentPath) != null && _nodePath$parentPath$2.isExportNamedDeclaration())) {
+            var filename = state.filename || 'unknown';
+            var atomKey = filename + "/" + nodePath.node.id.name;
+            var buildAtomDeclaration = templateBuilder("const %%atomIdentifier%% = globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)");
+            var ast = buildAtomDeclaration({
+              atomIdentifier: t.identifier(nodePath.node.id.name),
+              atomKey: t.stringLiteral(atomKey),
+              atom: nodePath.node.init
+            });
+            nodePath.parentPath.replaceWith(ast);
+          }
+        }
+      }
+    };
+  }
+
+  function jotaiPreset(_, options) {
+    console.warn('[DEPRECATED] jotai/babel/preset is deprecated and will be removed in v3.\n' + 'Please use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel');
+    return {
+      plugins: [[debugLabelPlugin, options], [reactRefreshPlugin, options]]
+    };
+  }
+
+  return jotaiPreset;
+
+}));

package/umd/babel/preset.production.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t(require("@babel/template")):"function"==typeof define&&define.amd?define(["@babel/template"],t):(e="undefined"!=typeof globalThis?globalThis:e||self).jotaiBabelPreset=t(e._templateBuilder)}(this,function(e){"use strict";function t(e,t,i){void 0===i&&(i=[]);var n=[].concat(a,i);if(e.isIdentifier(t)&&n.includes(t.name))return!0;if(e.isMemberExpression(t)){var o=t.property;if(e.isIdentifier(o)&&n.includes(o.name))return!0}return!1}var a=["atom","atomFamily","atomWithDefault","atomWithObservable","atomWithReducer","atomWithReset","atomWithStorage","freezeAtom","loadable","selectAtom","splitAtom","unwrap","atomWithMachine","atomWithImmer","atomWithProxy","atomWithQuery","atomWithMutation","atomWithSubscription","atomWithStore","atomWithHash","atomWithLocation","focusAtom","atomWithValidate","validateAtoms","atomWithCache","atomWithRecoilValue"],i=e.default||e;function n(e,a){var n=e.types;return console.warn("[DEPRECATED] jotai/babel/plugin-debug-label is deprecated and will be removed in v3.\nPlease use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel"),{visitor:{ExportDefaultDeclaration:function(e,o){var r=e.node;if(n.isCallExpression(r.declaration)&&t(n,r.declaration.callee,null==a?void 0:a.customAtomNames)){var l=(o.filename||"unknown").replace(/\.\w+$/,""),s=l.split("/").pop();"index"===s&&(s=l.slice(0,-6).split("/").pop()||"unknown");var m=i("\n          const %%atomIdentifier%% = %%atom%%;\n          export default %%atomIdentifier%%\n          ")({atomIdentifier:n.identifier(s),atom:r.declaration});e.replaceWithMultiple(m)}},VariableDeclarator:function(e){n.isIdentifier(e.node.id)&&n.isCallExpression(e.node.init)&&t(n,e.node.init.callee,null==a?void 0:a.customAtomNames)&&e.parentPath.insertAfter(n.expressionStatement(n.assignmentExpression("=",n.memberExpression(n.identifier(e.node.id.name),n.identifier("debugLabel")),n.stringLiteral(e.node.id.name))))}}}}var o=e.default||e;function r(e,a){var i=e.types;return console.warn("[DEPRECATED] jotai/babel/plugin-react-refresh is deprecated and will be removed in v3.\nPlease use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel"),{pre:function(e){if(!e.opts.filename)throw new Error("Filename must be available")},visitor:{Program:{exit:function(e){var t=o("\n          globalThis.jotaiAtomCache = globalThis.jotaiAtomCache || {\n            cache: new Map(),\n            get(name, inst) { \n              if (this.cache.has(name)) {\n                return this.cache.get(name)\n              }\n              this.cache.set(name, inst)\n              return inst\n            },\n          }")();e.unshiftContainer("body",t)}},ExportDefaultDeclaration:function(e,n){var r=e.node;if(i.isCallExpression(r.declaration)&&t(i,r.declaration.callee,null==a?void 0:a.customAtomNames)){var l=(n.filename||"unknown")+"/defaultExport",s=o("export default globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)")({atomKey:i.stringLiteral(l),atom:r.declaration});e.replaceWith(s)}},VariableDeclarator:function(e,n){var r,l;if(i.isIdentifier(e.node.id)&&i.isCallExpression(e.node.init)&&t(i,e.node.init.callee,null==a?void 0:a.customAtomNames)&&(null!=(r=e.parentPath.parentPath)&&r.isProgram()||null!=(l=e.parentPath.parentPath)&&l.isExportNamedDeclaration())){var s=(n.filename||"unknown")+"/"+e.node.id.name,m=o("const %%atomIdentifier%% = globalThis.jotaiAtomCache.get(%%atomKey%%, %%atom%%)")({atomIdentifier:i.identifier(e.node.id.name),atomKey:i.stringLiteral(s),atom:e.node.init});e.parentPath.replaceWith(m)}}}}}return function(e,t){return console.warn("[DEPRECATED] jotai/babel/preset is deprecated and will be removed in v3.\nPlease use the `jotai-babel` package instead: https://github.com/jotaijs/jotai-babel"),{plugins:[[n,t],[r,t]]}}});

package/umd/index.development.js

@@ -0,0 +1,20 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jotai/vanilla'), require('jotai/react')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'jotai/vanilla', 'jotai/react'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jotai = {}, global.jotaiVanilla, global.jotaiReact));
+})(this, (function (exports, vanilla, react) { 'use strict';
+
+	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/umd/index.production.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("jotai/vanilla"),require("jotai/react")):"function"==typeof define&&define.amd?define(["exports","jotai/vanilla","jotai/react"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).jotai={},e.jotaiVanilla,e.jotaiReact)}(this,function(e,t,o){"use strict";Object.keys(t).forEach(function(o){"default"===o||Object.prototype.hasOwnProperty.call(e,o)||Object.defineProperty(e,o,{enumerable:!0,get:function(){return t[o]}})}),Object.keys(o).forEach(function(t){"default"===t||Object.prototype.hasOwnProperty.call(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:function(){return o[t]}})})});