@types/react 16.9.47 → 16.9.51

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: Tue, 25 Aug 2020 06:10:10 GMT
+ * Last updated: Mon, 05 Oct 2020 18:02:24 GMT
  * Dependencies: [@types/csstype](https://npmjs.com/package/@types/csstype), [@types/prop-types](https://npmjs.com/package/@types/prop-types)
  * Global values: `React`
 

react/experimental.d.ts

@@ -163,4 +163,26 @@ declare module '.' {
      * @see https://reactjs.org/docs/concurrent-mode-reference.html#usetransition
      */
     export function unstable_useTransition(config?: SuspenseConfig | null): [TransitionStartFunction, boolean];
+
+    /**
+     * @private
+     */
+    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;
 }

react/index.d.ts

@@ -475,12 +475,12 @@ declare namespace React {
         // TODO (TypeScript 3.0): unknown
         context: any;
 
-        constructor(props: Readonly<P>);
+        constructor(props: Readonly<P> | P);
         /**
          * @deprecated
          * @see https://reactjs.org/docs/legacy-context.html
          */
-        constructor(props: P, context?: any);
+        constructor(props: P, context: any);
 
         // We MUST keep setState() as a unified signature because it allows proper checking of the method return type.
         // See: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18365#issuecomment-351013257
@@ -551,6 +551,16 @@ declare namespace React {
         displayName?: string;
     }
 
+    type VFC<P = {}> = VoidFunctionComponent<P>;
+
+    interface VoidFunctionComponent<P = {}> {
+        (props: P, context?: any): ReactElement<any, any> | null;
+        propTypes?: WeakValidationMap<P>;
+        contextTypes?: ValidationMap<any>;
+        defaultProps?: Partial<P>;
+        displayName?: string;
+    }
+
     interface ForwardRefRenderFunction<T, P = {}> {
         (props: PropsWithChildren<P>, ref: ((instance: T | null) => void) | MutableRefObject<T | null> | null): ReactElement | null;
         displayName?: string;
@@ -905,7 +915,7 @@ declare namespace React {
      * @see https://reactjs.org/docs/hooks-reference.html#usestate
      */
     function useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
-    // convenience overload when first argument is ommitted
+    // convenience overload when first argument is omitted
     /**
      * Returns a stateful value, and a function to update it.
      *
@@ -956,7 +966,7 @@ declare namespace React {
      * @see https://reactjs.org/docs/hooks-reference.html#usereducer
      */
     // overload where "I" may be a subset of ReducerState<R>; used to provide autocompletion.
-    // If "I" matches ReducerState<R> exactly then the last overload will allow initializer to be ommitted.
+    // If "I" matches ReducerState<R> exactly then the last overload will allow initializer to be omitted.
     // the last overload effectively behaves as if the identity function (x => x) is the initializer.
     function useReducer<R extends Reducer<any, any>, I>(
         reducer: R,
@@ -2025,14 +2035,18 @@ declare namespace React {
         allow?: string;
         allowFullScreen?: boolean;
         allowTransparency?: boolean;
+        /** @deprecated */
         frameBorder?: number | string;
         height?: number | string;
         loading?: "eager" | "lazy";
+        /** @deprecated */
         marginHeight?: number;
+        /** @deprecated */
         marginWidth?: number;
         name?: string;
         referrerPolicy?: string;
         sandbox?: string;
+        /** @deprecated */
         scrolling?: string;
         seamless?: boolean;
         src?: string;

react/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react",
-    "version": "16.9.47",
+    "version": "16.9.51",
     "description": "TypeScript definitions for React",
     "license": "MIT",
     "contributors": [
@@ -144,6 +144,6 @@
         "@types/prop-types": "*",
         "csstype": "^3.0.2"
     },
-    "typesPublisherContentHash": "2c49524c0b1ca37340f208781694ce9a70f1e26d475d06cf8b8c22325e206c7b",
-    "typeScriptVersion": "3.1"
+    "typesPublisherContentHash": "e6d1e8790b01a3fa2da65495350765d8a8d615619c5b759fee32719b160b6d2e",
+    "typeScriptVersion": "3.2"
 }