npm package diff

Package: @types/react

Versions: 18.2.73 - 18.3.8

File: react/canary.d.ts

Index: react/canary.d.ts
===================================================================
--- react/canary.d.ts
+++ react/canary.d.ts
@@ -29,34 +29,13 @@
 
 declare const UNDEFINED_VOID_ONLY: unique symbol;
 type VoidOrUndefinedOnly = void | { [UNDEFINED_VOID_ONLY]: never };
 
+type NativeToggleEvent = ToggleEvent;
+
 declare module "." {
-    interface ThenableImpl<T> {
-        then(onFulfill: (value: T) => unknown, onReject: (error: unknown) => unknown): void | PromiseLike<unknown>;
-    }
-    interface UntrackedThenable<T> extends ThenableImpl<T> {
-        status?: void;
-    }
+    export type Usable<T> = PromiseLike<T> | Context<T>;
 
-    export interface PendingThenable<T> extends ThenableImpl<T> {
-        status: "pending";
-    }
-
-    export interface FulfilledThenable<T> extends ThenableImpl<T> {
-        status: "fulfilled";
-        value: T;
-    }
-
-    export interface RejectedThenable<T> extends ThenableImpl<T> {
-        status: "rejected";
-        reason: unknown;
-    }
-
-    export type Thenable<T> = UntrackedThenable<T> | PendingThenable<T> | FulfilledThenable<T> | RejectedThenable<T>;
-
-    export type Usable<T> = Thenable<T> | Context<T>;
-
     export function use<T>(usable: Usable<T>): T;
 
     interface ServerContextJSONArray extends ReadonlyArray<ServerContextJSONValue> {}
     export type ServerContextJSONValue =
@@ -101,8 +80,15 @@
          */
         (callback: () => Promise<VoidOrUndefinedOnly>): void;
     }
 
+    /**
+     * Similar to `useTransition` but allows uses where hooks are not available.
+     *
+     * @param callback An _asynchronous_ function which causes state updates that can be deferred.
+     */
+    export function startTransition(scope: () => Promise<VoidOrUndefinedOnly>): void;
+
     export function useOptimistic<State>(
         passthrough: State,
     ): [State, (action: State | ((pendingState: State) => State)) => void];
     export function useOptimistic<State, Action>(
@@ -123,5 +109,58 @@
         action: (state: Awaited<State>, payload: Payload) => State | Promise<State>,
         initialState: Awaited<State>,
         permalink?: string,
     ): [state: Awaited<State>, dispatch: (payload: Payload) => void, isPending: boolean];
+
+    interface DOMAttributes<T> {
+        // Transition Events
+        onTransitionCancel?: TransitionEventHandler<T> | undefined;
+        onTransitionCancelCapture?: TransitionEventHandler<T> | undefined;
+        onTransitionRun?: TransitionEventHandler<T> | undefined;
+        onTransitionRunCapture?: TransitionEventHandler<T> | undefined;
+        onTransitionStart?: TransitionEventHandler<T> | undefined;
+        onTransitionStartCapture?: TransitionEventHandler<T> | undefined;
+    }
+
+    type ToggleEventHandler<T = Element> = EventHandler<ToggleEvent<T>>;
+
+    interface HTMLAttributes<T> {
+        popover?: "" | "auto" | "manual" | undefined;
+        popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+        popoverTarget?: string | undefined;
+        onToggle?: ToggleEventHandler<T> | undefined;
+        onBeforeToggle?: ToggleEventHandler<T> | undefined;
+    }
+
+    interface ToggleEvent<T = Element> extends SyntheticEvent<T, NativeToggleEvent> {
+        oldState: "closed" | "open";
+        newState: "closed" | "open";
+    }
+
+    interface LinkHTMLAttributes<T> {
+        precedence?: string | undefined;
+    }
+
+    interface StyleHTMLAttributes<T> {
+        href?: string | undefined;
+        precedence?: string | undefined;
+    }
+
+    /**
+     * @internal Use `Awaited<ReactNode>` instead
+     */
+    // Helper type to enable `Awaited<ReactNode>`.
+    // Must be a copy of the non-thenables of `ReactNode`.
+    type AwaitedReactNode =
+        | ReactElement
+        | string
+        | number
+        | Iterable<AwaitedReactNode>
+        | ReactPortal
+        | boolean
+        | null
+        | undefined;
+    interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES {
+        promises: Promise<AwaitedReactNode>;
+        bigints: bigint;
+    }
 }