@types/react 17.0.41 → 17.0.44

react/README.md → react v17.0/README.md

@@ -5,10 +5,10 @@
 This package contains type definitions for React (http://facebook.github.io/react/).
 
 # Details
-Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react.
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react/v17.
 
 ### Additional Details
- * Last updated: Sat, 19 Mar 2022 07:31:41 GMT
+ * Last updated: Thu, 07 Apr 2022 17:31:22 GMT
  * Dependencies: [@types/csstype](https://npmjs.com/package/@types/csstype), [@types/prop-types](https://npmjs.com/package/@types/prop-types), [@types/scheduler](https://npmjs.com/package/@types/scheduler)
  * Global values: `React`
 

react/global.d.ts → react v17.0/global.d.ts

@@ -40,6 +40,7 @@ interface HTMLButtonElement extends HTMLElement { }
 interface HTMLCanvasElement extends HTMLElement { }
 interface HTMLDataElement extends HTMLElement { }
 interface HTMLDataListElement extends HTMLElement { }
+interface HTMLDetailsElement extends HTMLElement { }
 interface HTMLDialogElement extends HTMLElement { }
 interface HTMLDivElement extends HTMLElement { }
 interface HTMLDListElement extends HTMLElement { }
@@ -60,10 +61,12 @@ interface HTMLLIElement extends HTMLElement { }
 interface HTMLLinkElement extends HTMLElement { }
 interface HTMLMapElement extends HTMLElement { }
 interface HTMLMetaElement extends HTMLElement { }
+interface HTMLMeterElement extends HTMLElement { }
 interface HTMLObjectElement extends HTMLElement { }
 interface HTMLOListElement extends HTMLElement { }
 interface HTMLOptGroupElement extends HTMLElement { }
 interface HTMLOptionElement extends HTMLElement { }
+interface HTMLOutputElement extends HTMLElement { }
 interface HTMLParagraphElement extends HTMLElement { }
 interface HTMLParamElement extends HTMLElement { }
 interface HTMLPreElement extends HTMLElement { }
@@ -83,6 +86,7 @@ interface HTMLTableRowElement extends HTMLElement { }
 interface HTMLTableSectionElement extends HTMLElement { }
 interface HTMLTemplateElement extends HTMLElement { }
 interface HTMLTextAreaElement extends HTMLElement { }
+interface HTMLTimeElement extends HTMLElement { }
 interface HTMLTitleElement extends HTMLElement { }
 interface HTMLTrackElement extends HTMLElement { }
 interface HTMLUListElement extends HTMLElement { }

react/index.d.ts → react v17.0/index.d.ts

@@ -29,14 +29,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
-// NOTE: Users of the upcoming React 18 release should add a reference
-// to 'react/next' in their project. See next.d.ts's top comment
-// for reference and documentation on how exactly to do it.
-
-// NOTE: Users of the `experimental` builds of React should add a reference
-// to 'react/experimental' in their project. See experimental.d.ts's top comment
-// for reference and documentation on how exactly to do it.
-
 /// <reference path="global.d.ts" />
 
 import * as CSS from 'csstype';
@@ -88,7 +80,8 @@ declare namespace React {
     interface RefObject<T> {
         readonly current: T | null;
     }
-    type RefCallback<T> = (instance: T | null) => void;
+    // Bivariance hack for consistent unsoundness with RefObject
+    type RefCallback<T> = { bivarianceHack(instance: T | null): void }["bivarianceHack"];
     type Ref<T> = RefCallback<T> | RefObject<T> | null;
     type LegacyRef<T> = string | Ref<T>;
     /**
@@ -2779,7 +2772,7 @@ declare namespace React {
         bdi: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
         bdo: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
         big: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
-        blockquote: DetailedHTMLFactory<BlockquoteHTMLAttributes<HTMLElement>, HTMLElement>;
+        blockquote: DetailedHTMLFactory<BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
         body: DetailedHTMLFactory<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
         br: DetailedHTMLFactory<HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
         button: DetailedHTMLFactory<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
@@ -2792,8 +2785,8 @@ declare namespace React {
         data: DetailedHTMLFactory<DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>;
         datalist: DetailedHTMLFactory<HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
         dd: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
-        del: DetailedHTMLFactory<DelHTMLAttributes<HTMLElement>, HTMLElement>;
-        details: DetailedHTMLFactory<DetailsHTMLAttributes<HTMLElement>, HTMLElement>;
+        del: DetailedHTMLFactory<DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
+        details: DetailedHTMLFactory<DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
         dfn: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
         dialog: DetailedHTMLFactory<DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
         div: DetailedHTMLFactory<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
@@ -2834,14 +2827,14 @@ declare namespace React {
         menu: DetailedHTMLFactory<MenuHTMLAttributes<HTMLElement>, HTMLElement>;
         menuitem: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
         meta: DetailedHTMLFactory<MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
-        meter: DetailedHTMLFactory<MeterHTMLAttributes<HTMLElement>, HTMLElement>;
+        meter: DetailedHTMLFactory<MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>;
         nav: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
         noscript: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
         object: DetailedHTMLFactory<ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>;
         ol: DetailedHTMLFactory<OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
         optgroup: DetailedHTMLFactory<OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
         option: DetailedHTMLFactory<OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>;
-        output: DetailedHTMLFactory<OutputHTMLAttributes<HTMLElement>, HTMLElement>;
+        output: DetailedHTMLFactory<OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
         p: DetailedHTMLFactory<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
         param: DetailedHTMLFactory<ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement>;
         picture: DetailedHTMLFactory<HTMLAttributes<HTMLElement>, HTMLElement>;
@@ -2873,7 +2866,7 @@ declare namespace React {
         tfoot: DetailedHTMLFactory<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
         th: DetailedHTMLFactory<ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
         thead: DetailedHTMLFactory<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
-        time: DetailedHTMLFactory<TimeHTMLAttributes<HTMLElement>, HTMLElement>;
+        time: DetailedHTMLFactory<TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
         title: DetailedHTMLFactory<HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
         tr: DetailedHTMLFactory<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
         track: DetailedHTMLFactory<TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;
@@ -3110,7 +3103,7 @@ declare global {
             bdi: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
             bdo: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
             big: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
-            blockquote: React.DetailedHTMLProps<React.BlockquoteHTMLAttributes<HTMLElement>, HTMLElement>;
+            blockquote: React.DetailedHTMLProps<React.BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
             body: React.DetailedHTMLProps<React.HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
             br: React.DetailedHTMLProps<React.HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
             button: React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>;
@@ -3123,8 +3116,8 @@ declare global {
             data: React.DetailedHTMLProps<React.DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>;
             datalist: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
             dd: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
-            del: React.DetailedHTMLProps<React.DelHTMLAttributes<HTMLElement>, HTMLElement>;
-            details: React.DetailedHTMLProps<React.DetailsHTMLAttributes<HTMLElement>, HTMLElement>;
+            del: React.DetailedHTMLProps<React.DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
+            details: React.DetailedHTMLProps<React.DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
             dfn: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
             dialog: React.DetailedHTMLProps<React.DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
             div: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
@@ -3165,7 +3158,7 @@ declare global {
             menu: React.DetailedHTMLProps<React.MenuHTMLAttributes<HTMLElement>, HTMLElement>;
             menuitem: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
             meta: React.DetailedHTMLProps<React.MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
-            meter: React.DetailedHTMLProps<React.MeterHTMLAttributes<HTMLElement>, HTMLElement>;
+            meter: React.DetailedHTMLProps<React.MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>;
             nav: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
             noindex: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
             noscript: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
@@ -3173,7 +3166,7 @@ declare global {
             ol: React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
             optgroup: React.DetailedHTMLProps<React.OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
             option: React.DetailedHTMLProps<React.OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>;
-            output: React.DetailedHTMLProps<React.OutputHTMLAttributes<HTMLElement>, HTMLElement>;
+            output: React.DetailedHTMLProps<React.OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
             p: React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
             param: React.DetailedHTMLProps<React.ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement>;
             picture: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
@@ -3205,7 +3198,7 @@ declare global {
             tfoot: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
             th: React.DetailedHTMLProps<React.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
             thead: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
-            time: React.DetailedHTMLProps<React.TimeHTMLAttributes<HTMLElement>, HTMLElement>;
+            time: React.DetailedHTMLProps<React.TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
             title: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
             tr: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
             track: React.DetailedHTMLProps<React.TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;

react/package.json → react v17.0/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react",
-    "version": "17.0.41",
+    "version": "17.0.44",
     "description": "TypeScript definitions for React",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react",
     "license": "MIT",
@@ -146,6 +146,6 @@
         "@types/scheduler": "*",
         "csstype": "^3.0.2"
     },
-    "typesPublisherContentHash": "3fe0b970275e3e20681098696740b1d560c44b5a38a62bcb14a909650b93e0b5",
+    "typesPublisherContentHash": "e2337761fa2e58147fa60cfb84ff8c8c71c26c6c9f87260f220e15cb430c5ca4",
     "typeScriptVersion": "3.9"
 }

react/experimental.d.ts

@@ -1,96 +0,0 @@
-/**
- * These are types for things that are present in the `experimental` builds of React but not yet
- * on a stable build.
- *
- * Once they are promoted to stable they can just be moved to the main index file.
- *
- * To load the types declared here in an actual project, there are three ways. The easiest one,
- * if your `tsconfig.json` already has a `"types"` array in the `"compilerOptions"` section,
- * is to add `"react/experimental"` to the `"types"` array.
- *
- * Alternatively, a specific import syntax can to be used from a typescript file.
- * This module does not exist in reality, which is why the {} is important:
- *
- * ```ts
- * import {} from 'react/experimental'
- * ```
- *
- * It is also possible to include it through a triple-slash reference:
- *
- * ```ts
- * /// <reference types="react/experimental" />
- * ```
- *
- * Either the import or the reference only needs to appear once, anywhere in the project.
- */
-
-// See https://github.com/facebook/react/blob/master/packages/react/src/React.js to see how the exports are declared,
-// and https://github.com/facebook/react/blob/master/packages/shared/ReactFeatureFlags.js to verify which APIs are
-// flagged experimental or not. Experimental APIs will be tagged with `__EXPERIMENTAL__`.
-//
-// For the inputs of types exported as simply a fiber tag, the `beginWork` function of ReactFiberBeginWork.js
-// is a good place to start looking for details; it generally calls prop validation functions or delegates
-// all tasks done as part of the render phase (the concurrent part of the React update cycle).
-//
-// Suspense-related handling can be found in ReactFiberThrow.js.
-
-import React = require('./next');
-
-export {};
-
-declare module '.' {
-    export type SuspenseListRevealOrder = 'forwards' | 'backwards' | 'together';
-    export type SuspenseListTailMode = 'collapsed' | 'hidden';
-
-    export interface SuspenseListCommonProps {
-        /**
-         * Note that SuspenseList require more than one child;
-         * it is a runtime warning to provide only a single child.
-         *
-         * It does, however, allow those children to be wrapped inside a single
-         * level of `<React.Fragment>`.
-         */
-        children: ReactElement | Iterable<ReactElement>;
-    }
-
-    interface DirectionalSuspenseListProps extends SuspenseListCommonProps {
-        /**
-         * Defines the order in which the `SuspenseList` children should be revealed.
-         */
-        revealOrder: 'forwards' | 'backwards';
-        /**
-         * Dictates how unloaded items in a SuspenseList is shown.
-         *
-         * - By default, `SuspenseList` will show all fallbacks in the list.
-         * - `collapsed` shows only the next fallback in the list.
-         * - `hidden` doesn’t show any unloaded items.
-         */
-        tail?: SuspenseListTailMode | undefined;
-    }
-
-    interface NonDirectionalSuspenseListProps extends SuspenseListCommonProps {
-        /**
-         * Defines the order in which the `SuspenseList` children should be revealed.
-         */
-        revealOrder?: Exclude<SuspenseListRevealOrder, DirectionalSuspenseListProps['revealOrder']> | undefined;
-        /**
-         * The tail property is invalid when not using the `forwards` or `backwards` reveal orders.
-         */
-        tail?: never | undefined;
-    }
-
-    export type SuspenseListProps = DirectionalSuspenseListProps | NonDirectionalSuspenseListProps;
-
-    /**
-     * `SuspenseList` helps coordinate many components that can suspend by orchestrating the order
-     * in which these components are revealed to the user.
-     *
-     * When multiple components need to fetch data, this data may arrive in an unpredictable order.
-     * However, if you wrap these items in a `SuspenseList`, React will not show an item in the list
-     * until previous items have been displayed (this behavior is adjustable).
-     *
-     * @see https://reactjs.org/docs/concurrent-mode-reference.html#suspenselist
-     * @see https://reactjs.org/docs/concurrent-mode-patterns.html#suspenselist
-     */
-    export const SuspenseList: ExoticComponent<SuspenseListProps>;
-}

react/next.d.ts

@@ -1,148 +0,0 @@
-/**
- * These are types for things that are present in the upcoming React 18 release.
- *
- * Once React 18 is released they can just be moved to the main index file.
- *
- * To load the types declared here in an actual project, there are three ways. The easiest one,
- * if your `tsconfig.json` already has a `"types"` array in the `"compilerOptions"` section,
- * is to add `"react/next"` to the `"types"` array.
- *
- * Alternatively, a specific import syntax can to be used from a typescript file.
- * This module does not exist in reality, which is why the {} is important:
- *
- * ```ts
- * import {} from 'react/next'
- * ```
- *
- * It is also possible to include it through a triple-slash reference:
- *
- * ```ts
- * /// <reference types="react/next" />
- * ```
- *
- * Either the import or the reference only needs to appear once, anywhere in the project.
- */
-
-// See https://github.com/facebook/react/blob/master/packages/react/src/React.js to see how the exports are declared,
-
-import React = require('.');
-
-export {};
-
-declare const UNDEFINED_VOID_ONLY: unique symbol;
-type VoidOrUndefinedOnly = void | { [UNDEFINED_VOID_ONLY]: never };
-
-declare module '.' {
-    export interface SuspenseProps {
-        /**
-         * The presence of this prop indicates that the content is computationally expensive to render.
-         * In other words, the tree is CPU bound and not I/O bound (e.g. due to fetching data).
-         * @see {@link https://github.com/facebook/react/pull/19936}
-         */
-        unstable_expectedLoadTime?: number | undefined;
-    }
-
-    // must be synchronous
-    export type TransitionFunction = () => VoidOrUndefinedOnly;
-    // strange definition to allow vscode to show documentation on the invocation
-    export interface TransitionStartFunction {
-        /**
-         * State updates caused inside the callback are allowed to be deferred.
-         *
-         * **If some state update causes a component to suspend, that state update should be wrapped in a transition.**
-         *
-         * @param callback A _synchronous_ function which causes state updates that can be deferred.
-         */
-        (callback: TransitionFunction): void;
-    }
-
-    /**
-     * Returns a deferred version of the value that may “lag behind” it for at most `timeoutMs`.
-     *
-     * This is commonly used to keep the interface responsive when you have something that renders immediately
-     * based on user input and something that needs to wait for a data fetch.
-     *
-     * A good example of this is a text input.
-     *
-     * @param value The value that is going to be deferred
-     *
-     * @see https://reactjs.org/docs/concurrent-mode-reference.html#usedeferredvalue
-     */
-    export function useDeferredValue<T>(value: T): T;
-
-    /**
-     * Allows components to avoid undesirable loading states by waiting for content to load
-     * before transitioning to the next screen. It also allows components to defer slower,
-     * data fetching updates until subsequent renders so that more crucial updates can be
-     * rendered immediately.
-     *
-     * The `useTransition` hook returns two values in an array.
-     *
-     * The first is a boolean, React’s way of informing us whether we’re waiting for the transition to finish.
-     * The second is a function that takes a callback. We can use it to tell React which state we want to defer.
-     *
-     * **If some state update causes a component to suspend, that state update should be wrapped in a transition.**
-     *
-     * @param config An optional object with `timeoutMs`
-     *
-     * @see https://reactjs.org/docs/concurrent-mode-reference.html#usetransition
-     */
-    export function useTransition(): [boolean, TransitionStartFunction];
-
-    /**
-     * Similar to `useTransition` but allows uses where hooks are not available.
-     *
-     * @param callback A _synchronous_ function which causes state updates that can be deferred.
-     */
-    export function startTransition(scope: TransitionFunction): void;
-
-    export function useId(): string;
-
-    /**
-     * this should be an internal type
-     */
-    interface MutableSource<T> {
-        _source: T;
-    }
-
-    export type MutableSourceSubscribe<T> = (source: T, callback: () => void) => () => void;
-
-    /**
-     * @param source A source could be anything as long as they can be subscribed to and have a "version".
-     * @param getVersion A function returns a value which will change whenever part of the source changes.
-     */
-    export function unstable_createMutableSource<T>(source: T, getVersion: () => any): MutableSource<T>;
-
-    /**
-     * useMutableSource() enables React components to safely and efficiently read from a mutable external source in Concurrent Mode.
-     * The API will detect mutations that occur during a render to avoid tearing
-     * and it will automatically schedule updates when the source is mutated.
-     * @param MutableSource
-     * @param getSnapshot
-     * @param subscribe
-     *
-     * @see https://github.com/reactjs/rfcs/blob/master/text/0147-use-mutable-source.md
-     */
-    export function unstable_useMutableSource<T, TResult extends unknown>(MutableSource: MutableSource<T>, getSnapshot: (source: T) => TResult, subscribe: MutableSourceSubscribe<T>): TResult;
-
-    /**
-     * @param effect Imperative function that can return a cleanup function
-     * @param deps If present, effect will only activate if the values in the list change.
-     *
-     * @see https://github.com/facebook/react/pull/21913
-     */
-     export function useInsertionEffect(effect: EffectCallback, deps?: DependencyList): void;
-
-    /**
-     * @param subscribe
-     * @param getSnapshot
-     *
-     * @see https://github.com/reactwg/react-18/discussions/86
-     */
-    // keep in sync with `useSyncExternalStore` from `use-sync-external-store`
-    export function useSyncExternalStore<Snapshot>(
-        subscribe: (onStoreChange: () => void) => () => void,
-        getSnapshot: () => Snapshot,
-        getServerSnapshot?: () => Snapshot,
-    ): Snapshot;
-}