@types/react 16.14.0 → 16.14.4

react/README.md → react v16.14/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/v16.
 
 ### Additional Details
- * Last updated: Fri, 20 Nov 2020 13:41:08 GMT
+ * Last updated: Fri, 12 Feb 2021 18:02:48 GMT
  * Dependencies: [@types/csstype](https://npmjs.com/package/@types/csstype), [@types/prop-types](https://npmjs.com/package/@types/prop-types)
  * Global values: `React`
 

react/index.d.ts → react v16.14/index.d.ts

@@ -61,6 +61,10 @@ interface SchedulerInteraction {
     timestamp: number;
 }
 
+declare const UNDEFINED_VOID_ONLY: unique symbol;
+// Destructors are only allowed to return void.
+type Destructor = () => void | { [UNDEFINED_VOID_ONLY]: never };
+
 // tslint:disable-next-line:export-just-namespace
 export = React;
 export as namespace React;
@@ -82,7 +86,7 @@ declare namespace React {
     type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
 
     type JSXElementConstructor<P> =
-        | ((props: P) => ReactElement | null)
+        | ((props: P) => ReactElement<any, any> | null)
         | (new (props: P) => Component<P, any>);
 
     interface RefObject<T> {
@@ -176,6 +180,7 @@ declare namespace React {
     }
 
     // ReactHTML for ReactHTMLElement
+    // tslint:disable-next-line:no-empty-interface
     interface ReactHTMLElement<T extends HTMLElement> extends DetailedReactHTMLElement<AllHTMLAttributes<T>, T> { }
 
     interface DetailedReactHTMLElement<P extends HTMLAttributes<T>, T extends HTMLElement> extends DOMElement<P, T> {
@@ -214,6 +219,7 @@ declare namespace React {
     type DOMFactory<P extends DOMAttributes<T>, T extends Element> =
         (props?: ClassAttributes<T> & P | null, ...children: ReactNode[]) => DOMElement<P, T>;
 
+    // tslint:disable-next-line:no-empty-interface
     interface HTMLFactory<T extends HTMLElement> extends DetailedHTMLFactory<AllHTMLAttributes<T>, T> {}
 
     interface DetailedHTMLFactory<P extends HTMLAttributes<T>, T extends HTMLElement> extends DOMFactory<P, T> {
@@ -429,6 +435,7 @@ declare namespace React {
     type ReactInstance = Component<any> | Element;
 
     // Base component for plain JS classes
+    // tslint:disable-next-line:no-empty-interface
     interface Component<P = {}, S = {}, SS = any> extends ComponentLifecycle<P, S, SS> { }
     class Component<P, S> {
         // tslint won't let me format the sample code in a way that vscode likes it :(
@@ -558,10 +565,8 @@ declare namespace React {
         displayName?: string;
     }
 
-    type ForwardedRef<T> = ((instance: T | null) => void) | MutableRefObject<T | null> | null;
-
     interface ForwardRefRenderFunction<T, P = {}> {
-        (props: PropsWithChildren<P>, ref: ForwardedRef<T>): ReactElement | null;
+        (props: PropsWithChildren<P>, ref: ((instance: T | null) => void) | MutableRefObject<T | null> | null): ReactElement | null;
         displayName?: string;
         // explicit rejected with `never` required due to
         // https://github.com/microsoft/TypeScript/issues/36826
@@ -891,8 +896,7 @@ declare namespace React {
     type DependencyList = ReadonlyArray<any>;
 
     // NOTE: callbacks are _only_ allowed to return either void, or a destructor.
-    // The destructor is itself only allowed to return void.
-    type EffectCallback = () => (void | (() => void | undefined));
+    type EffectCallback = () => (void | Destructor);
 
     interface MutableRefObject<T> {
         current: T;
@@ -1195,6 +1199,7 @@ declare namespace React {
         target: EventTarget & T;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface FormEvent<T = Element> extends SyntheticEvent<T> {
     }
 
@@ -1942,6 +1947,7 @@ declare namespace React {
         referrerPolicy?: HTMLAttributeReferrerPolicy;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface AudioHTMLAttributes<T> extends MediaHTMLAttributes<T> {}
 
     interface AreaHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -2966,6 +2972,7 @@ type ReactManagedAttributes<C, P> = C extends { propTypes: infer T; defaultProps
 
 declare global {
     namespace JSX {
+        // tslint:disable-next-line:no-empty-interface
         interface Element extends React.ReactElement<any, any> { }
         interface ElementClass extends React.Component<any> {
             render(): React.ReactNode;
@@ -2981,7 +2988,9 @@ declare global {
                 : ReactManagedAttributes<T, P>
             : ReactManagedAttributes<C, P>;
 
+        // tslint:disable-next-line:no-empty-interface
         interface IntrinsicAttributes extends React.Attributes { }
+        // tslint:disable-next-line:no-empty-interface
         interface IntrinsicClassAttributes<T> extends React.ClassAttributes<T> { }
 
         interface IntrinsicElements {

react/package.json → react v16.14/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react",
-    "version": "16.14.0",
+    "version": "16.14.4",
     "description": "TypeScript definitions for React",
     "license": "MIT",
     "contributors": [
@@ -144,6 +144,6 @@
         "@types/prop-types": "*",
         "csstype": "^3.0.2"
     },
-    "typesPublisherContentHash": "eadbd9474e09134894b99ffaba3a199ff7206e48438f729d368c3a01d8fd5512",
-    "typeScriptVersion": "3.3"
+    "typesPublisherContentHash": "fe61a2fd3f98961570899034e6de539579e385542cdc7142518fca624f5965bb",
+    "typeScriptVersion": "3.4"
 }

react/experimental.d.ts

@@ -1,189 +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('.');
-
-export {};
-
-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;
-    }
-
-    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;
-    }
-
-    interface NonDirectionalSuspenseListProps extends SuspenseListCommonProps {
-        /**
-         * Defines the order in which the `SuspenseList` children should be revealed.
-         */
-        revealOrder?: Exclude<SuspenseListRevealOrder, DirectionalSuspenseListProps['revealOrder']>;
-        /**
-         * The tail property is invalid when not using the `forwards` or `backwards` reveal orders.
-         */
-        tail?: never;
-    }
-
-    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 unstable_SuspenseList: ExoticComponent<SuspenseListProps>;
-
-    export interface SuspenseConfig {
-        busyDelayMs?: number;
-        busyMinDurationMs?: number;
-    }
-
-    // undocumented, considered for removal
-    export function unstable_withSuspenseConfig(
-        scope: () => void | undefined,
-        config: SuspenseConfig | null | undefined,
-    ): void;
-
-    // must be synchronous
-    export type TransitionFunction = () => void | undefined;
-    // 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 unstable_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 function that takes a callback. We can use it to tell React which state we want to defer.
-     * The seconda boolean. It’s React’s way of informing us whether we’re waiting for the transition to finish.
-     *
-     * **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 unstable_useTransition(config?: SuspenseConfig | null): [TransitionStartFunction, boolean];
-
-    const opaqueIdentifierBranding: unique symbol;
-    /**
-     * WARNING: Don't use this as a `string`.
-     *
-     * This is an opaque type that is not supposed to type-check structurally.
-     * It is only valid if returned from React methods and passed to React e.g. `<button aria-labelledby={opaqueIdentifier} />`
-     */
-    // We can't create a type that would be rejected for string concatenation or `.toString()` calls.
-    // So in order to not have to add `string | OpaqueIdentifier` to every react-dom host prop we intersect it with `string`.
-    type OpaqueIdentifier = string & {
-        readonly [opaqueIdentifierBranding]: unknown;
-        // While this would cause `const stringified: string = opaqueIdentifier.toString()` to not type-check it also adds completions while typing.
-        // It would also still allow string concatenation.
-        // Unsure which is better. Not type-checking or not suggesting.
-        // toString(): void;
-    };
-
-    export function unstable_useOpaqueIdentifier(): OpaqueIdentifier;
-
-    /**
-     * 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 unstable_startTransition(scope: TransitionFunction): void;
-}