@depup/jotai 2.19.1-depup.0 → 2.20.2-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/jotai
 
 | Field | Value |
 |-------|-------|
-| Original | [jotai](https://www.npmjs.com/package/jotai) @ 2.19.1 |
-| Processed | 2026-04-07 |
+| Original | [jotai](https://www.npmjs.com/package/jotai) @ 2.20.2 |
+| Processed | 2026-07-21 |
 | Smoke test | failed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-04-07T16:33:27.833Z",
+  "timestamp": "2026-07-21T17:26:23.906Z",
   "totalUpdated": 0
 }

package/esm/react.mjs

@@ -1,7 +1,7 @@
 'use client';
 import React, { createContext, useContext, useRef, createElement, useReducer, useEffect, useDebugValue, useCallback } from 'react';
 import { getDefaultStore, createStore } from 'jotai/vanilla';
-import { INTERNAL_getBuildingBlocksRev2 } from 'jotai/vanilla/internals';
+import { INTERNAL_getBuildingBlocksRev3 } from 'jotai/vanilla/internals';
 
 const StoreContext = createContext(
   void 0
@@ -63,7 +63,7 @@ const use = React.use || // A shim for older React versions
 });
 const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
 const createContinuablePromise = (store, promise, getValue) => {
-  const buildingBlocks = INTERNAL_getBuildingBlocksRev2(store);
+  const buildingBlocks = INTERNAL_getBuildingBlocksRev3(store);
   const registerAbortHandler = buildingBlocks[26];
   let continuablePromise = continuablePromiseMap.get(promise);
   if (!continuablePromise) {
@@ -86,7 +86,7 @@ const createContinuablePromise = (store, promise, getValue) => {
             continuablePromiseMap.set(nextValue, continuablePromise);
             curr = nextValue;
             nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
-            registerAbortHandler(store, nextValue, onAbort);
+            registerAbortHandler(buildingBlocks, store, nextValue, onAbort);
           } else {
             resolve(nextValue);
           }
@@ -95,7 +95,7 @@ const createContinuablePromise = (store, promise, getValue) => {
         }
       };
       promise.then(onFulfilled(promise), onRejected(promise));
-      registerAbortHandler(store, promise, onAbort);
+      registerAbortHandler(buildingBlocks, store, promise, onAbort);
     });
     continuablePromiseMap.set(promise, continuablePromise);
   }

package/esm/vanilla/internals.d.mts

@@ -1,10 +1,12 @@
-import { type Atom, type WritableAtom } from './atom.mjs';
+import type { Atom, WritableAtom } from './atom.mjs';
 type AnyValue = unknown;
 type AnyError = unknown;
 type AnyAtom = Atom<AnyValue>;
-type AnyWritableAtom = WritableAtom<AnyValue, unknown[], unknown>;
-type WritableAtomWithOnMount<Value, Args extends unknown[], Result> = Omit<WritableAtom<Value, Args, Result>, 'onMount'> & {
-    onMount: NonNullable<WritableAtom<Value, Args, Result>['onMount']>;
+type WithOnMount<Args extends unknown[], Result> = {
+    onMount: NonNullable<WritableAtom<AnyValue, Args, Result>['onMount']>;
+};
+type WithOnInit = {
+    INTERNAL_onInit: NonNullable<Atom<AnyValue>['INTERNAL_onInit']>;
 };
 type OnUnmount = () => void;
 type EpochNumber = number;
@@ -73,27 +75,27 @@ 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: WritableAtomWithOnMount<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 AtomRead = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>, ...params: Parameters<Atom<Value>['read']>) => Value;
+type AtomWrite = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, ...params: Parameters<WritableAtom<Value, Args, Result>['write']>) => Result;
+type AtomOnInit = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value> & WithOnInit) => void;
+type AtomOnMount = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result> & WithOnMount<Args, Result>, setAtom: (...args: Args) => Result) => OnUnmount | void;
+type EnsureAtomState = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => AtomState<Value>;
+type FlushCallbacks = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => void;
+type RecomputeInvalidatedAtoms = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => void;
+type ReadAtomState = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => AtomState<Value>;
+type InvalidateDependents = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom) => void;
+type WriteAtomState = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, args: Args) => Result;
+type MountDependencies = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom) => void;
+type MountAtom = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Mounted;
+type UnmountAtom = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Mounted | undefined;
+type SetAtomStateValueOrPromise = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>, valueOrPromise: Value) => void;
+type StoreGet = <Value>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: Atom<Value>) => Value;
+type StoreSet = <Value, Args extends unknown[], Result>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type StoreSub = (buildingBlocks: Readonly<BuildingBlocks>, store: Store, atom: AnyAtom, listener: () => void) => () => void;
+type EnhanceBuildingBlocks = (buildingBlocks: Readonly<BuildingBlocks>, store: Store) => 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 RegisterAbortHandler = <T>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, promise: PromiseLike<T>, abortHandler: () => void) => void;
+type AbortPromise = <T>(buildingBlocks: Readonly<BuildingBlocks>, store: Store, promise: PromiseLike<T>) => void;
 type StoreEpochHolder = [n: EpochNumber];
 type Store = {
     get: <Value>(atom: Atom<Value>) => Value;
@@ -132,13 +134,15 @@ type BuildingBlocks = [
     storeEpochHolder: StoreEpochHolder
 ];
 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> ? {
+declare function hasInitialValue<T extends AnyAtom>(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;
+type ActuallyWritableAtom<T extends AnyAtom> = T extends WritableAtom<infer V, infer A, infer R> ? T & WritableAtom<V, A, R> : T extends Atom<infer V> ? T & WritableAtom<V, unknown[], unknown> : never;
+declare function isActuallyWritableAtom<T extends AnyAtom>(atom: T): atom is ActuallyWritableAtom<T>;
+declare function isAtomStateInitialized(atomState: AtomState<AnyValue>): boolean;
 declare function returnAtomValue<Value>(atomState: AtomState<Value>): Value;
 declare function isPromiseLike(p: unknown): p is PromiseLike<unknown>;
+declare function shouldThrowSynchronously(error: unknown): boolean;
 declare function addPendingPromiseToDependency(atom: AnyAtom, promise: PromiseLike<AnyValue>, dependencyAtomState: AtomState): void;
 declare function getMountedOrPendingDependents(atom: AnyAtom, atomState: AtomState, mountedMap: MountedMap): Iterable<AnyAtom>;
 type StoreHook = {
@@ -167,5 +171,5 @@ type StoreHooks = {
 };
 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 function buildStore(...partialBuildingBlocks: Partial<BuildingBlocks>): Store;
+export { buildStore as INTERNAL_buildStoreRev3, getBuildingBlocks as INTERNAL_getBuildingBlocksRev3, initializeStoreHooks as INTERNAL_initializeStoreHooksRev3, hasInitialValue as INTERNAL_hasInitialValue, isActuallyWritableAtom as INTERNAL_isActuallyWritableAtom, isAtomStateInitialized as INTERNAL_isAtomStateInitialized, returnAtomValue as INTERNAL_returnAtomValue, isPromiseLike as INTERNAL_isPromiseLike, shouldThrowSynchronously as INTERNAL_shouldThrowSynchronously, addPendingPromiseToDependency as INTERNAL_addPendingPromiseToDependency, getMountedOrPendingDependents as INTERNAL_getMountedOrPendingDependents, };