@types/react 16.9.24 → 16.9.25

react/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for React (http://facebook.github.io/reac
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react.
 
 ### Additional Details
- * Last updated: Thu, 27 Feb 2020 18:24:44 GMT
+ * Last updated: Fri, 20 Mar 2020 17:59:38 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

@@ -82,17 +82,53 @@ declare namespace React {
         | ((props: P) => ReactElement | null)
         | (new (props: P) => Component<P, any>);
 
-    type Key = string | number;
-
     interface RefObject<T> {
         readonly current: T | null;
     }
     type RefCallback<T> = { bivarianceHack(instance: T | null): void }["bivarianceHack"];
     type Ref<T> = RefCallback<T> | RefObject<T> | null;
     type LegacyRef<T> = string | Ref<T>;
+    /**
+     * Gets the instance type for a React element. The instance will be different for various component types:
+     *
+     * - React class components will be the class instance. So if you had `class Foo extends React.Component<{}> {}`
+     *   and used `React.ElementRef<typeof Foo>` then the type would be the instance of `Foo`.
+     * - React stateless functional components do not have a backing instance and so `React.ElementRef<typeof Bar>`
+     *   (when `Bar` is `function Bar() {}`) will give you the `undefined` type.
+     * - JSX intrinsics like `div` will give you their DOM instance. For `React.ElementRef<'div'>` that would be
+     *   `HTMLDivElement`. For `React.ElementRef<'input'>` that would be `HTMLInputElement`.
+     * - React stateless functional components that forward a `ref` will give you the `ElementRef` of the forwarded
+     *   to component.
+     *
+     * `C` must be the type _of_ a React component so you need to use typeof as in React.ElementRef<typeof MyComponent>.
+     *
+     * @todo In Flow, this works a little different with forwarded refs and the `AbstractComponent` that
+     *       `React.forwardRef()` returns.
+     */
+    type ElementRef<
+        C extends
+            | ForwardRefExoticComponent<any>
+            | { new (props: any): Component<any> }
+            | ((props: any, context?: any) => ReactElement | null)
+            | keyof JSX.IntrinsicElements
+    > = C extends ForwardRefExoticComponent<infer FP>
+        ? FP extends RefAttributes<infer FC>
+            ? FC
+            : never
+        : C extends { new (props: any): Component<any> }
+        ? InstanceType<C>
+        : C extends ((props: any, context?: any) => ReactElement | null)
+        ? undefined
+        : C extends keyof JSX.IntrinsicElements
+        ? JSX.IntrinsicElements[C] extends DOMAttributes<infer E>
+            ? E
+            : never
+        : never;
 
     type ComponentState = any;
 
+    type Key = string | number;
+
     /**
      * @internal You shouldn't need to use this type since you never see these attributes
      * inside your component or have to validate them.

react/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react",
-    "version": "16.9.24",
+    "version": "16.9.25",
     "description": "TypeScript definitions for React",
     "license": "MIT",
     "contributors": [
@@ -129,6 +129,6 @@
         "@types/prop-types": "*",
         "csstype": "^2.2.0"
     },
-    "typesPublisherContentHash": "17bd982329cdc89889c2c46e57a42af4f9372394f7b143680480005a2965bdf1",
+    "typesPublisherContentHash": "9734b6f2aa660752af997a294f88d260a7d58fdcb17c125c76f79f3d8f9d9555",
     "typeScriptVersion": "2.8"
 }