@types/react 16.7.6 → 16.7.10

react/README.md

@@ -8,9 +8,9 @@ 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: Wed, 14 Nov 2018 06:52:17 GMT
+ * Last updated: Fri, 30 Nov 2018 06:26:44 GMT
  * Dependencies: csstype, prop-types
  * Global values: React
 
 # Credits
-These definitions were written by Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>, John Reilly <https://github.com/johnnyreilly>, Benoit Benezech <https://github.com/bbenezech>, Patricio Zavolinsky <https://github.com/pzavolinsky>, Digiguru <https://github.com/digiguru>, Eric Anderson <https://github.com/ericanderson>, Albert Kurniawan <https://github.com/morcerf>, Tanguy Krotoff <https://github.com/tkrotoff>, Dovydas Navickas <https://github.com/DovydasNavickas>, Stéphane Goetz <https://github.com/onigoetz>, Josh Rutherford <https://github.com/theruther4d>, Guilherme Hübner <https://github.com/guilhermehubner>, Ferdy Budhidharma <https://github.com/ferdaber>, Johann Rakotoharisoa <https://github.com/jrakotoharisoa>, Olivier Pascal <https://github.com/pascaloliv>, Martin Hochel <https://github.com/hotell>, Frank Li <https://github.com/franklixuefei>, Jessica Franco <https://github.com/Kovensky>.
+These definitions were written by Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>, John Reilly <https://github.com/johnnyreilly>, Benoit Benezech <https://github.com/bbenezech>, Patricio Zavolinsky <https://github.com/pzavolinsky>, Digiguru <https://github.com/digiguru>, Eric Anderson <https://github.com/ericanderson>, Tanguy Krotoff <https://github.com/tkrotoff>, Dovydas Navickas <https://github.com/DovydasNavickas>, Stéphane Goetz <https://github.com/onigoetz>, Josh Rutherford <https://github.com/theruther4d>, Guilherme Hübner <https://github.com/guilhermehubner>, Ferdy Budhidharma <https://github.com/ferdaber>, Johann Rakotoharisoa <https://github.com/jrakotoharisoa>, Olivier Pascal <https://github.com/pascaloliv>, Martin Hochel <https://github.com/hotell>, Frank Li <https://github.com/franklixuefei>, Jessica Franco <https://github.com/Kovensky>.

react/index.d.ts

@@ -8,7 +8,6 @@
 //                 Patricio Zavolinsky <https://github.com/pzavolinsky>
 //                 Digiguru <https://github.com/digiguru>
 //                 Eric Anderson <https://github.com/ericanderson>
-//                 Albert Kurniawan <https://github.com/morcerf>
 //                 Tanguy Krotoff <https://github.com/tkrotoff>
 //                 Dovydas Navickas <https://github.com/DovydasNavickas>
 //                 Stéphane Goetz <https://github.com/onigoetz>
@@ -50,7 +49,11 @@ declare namespace React {
     // React Elements
     // ----------------------------------------------------------------------
 
-    type ReactType<P = any> = string | ComponentType<P>;
+    type ReactType<P = any> =
+        {
+            [K in keyof JSX.IntrinsicElements]: P extends JSX.IntrinsicElements[K] ? K : never
+        }[keyof JSX.IntrinsicElements] |
+        ComponentType<P>;
     type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
 
     type Key = string | number;
@@ -418,6 +421,34 @@ declare namespace React {
         refs: {
             [key: string]: ReactInstance
         };
+
+        // Static properties copied from ComponentClass interface.
+        /**
+         * The validity of the type of `propTypes` cannot be checked
+         * automatically at the definition of a component class because the
+         * required type depends on `P`.  We recommend checking it using
+         * `asPropTypes` from the `react-typescript-helpers` package.  If you
+         * don't do that, then the type will still be checked by
+         * JSX.LibraryManagedAttributes every time the component is used,
+         * assuming you use TypeScript 3.0 or newer.
+         */
+        // Note: `propTypes` and `defaultProps` need to be `any` so that a
+        // component class that does not redeclare them is assignable to
+        // `ComponentClass<P>`.
+        static propTypes?: any;
+        static contextTypes?: ValidationMap<any>;
+        static childContextTypes?: ValidationMap<any>;
+        /**
+         * The validity of the type of `defaultProps` cannot be checked
+         * automatically at the definition of a component class because the
+         * required type depends on `P`.  We recommend checking it using
+         * `asDefaultProps` from the `react-typescript-helpers` package.  If you
+         * don't do that, then the type will still be checked by
+         * JSX.LibraryManagedAttributes every time the component is used,
+         * assuming you use TypeScript 3.0 or newer.
+         */
+        static defaultProps?: any;
+        static displayName?: string;
     }
 
     class PureComponent<P = {}, S = {}, SS = any> extends Component<P, S, SS> { }
@@ -492,8 +523,7 @@ declare namespace React {
      */
     type ClassType<P, T extends Component<P, ComponentState>, C extends ComponentClass<P>> =
         C &
-        (new (props: P, context?: any) => T) &
-        (new (props: P, context?: any) => { props: P });
+        (new (props: P, context?: any) => T);
 
     //
     // Component Specs and Lifecycle
@@ -714,17 +744,17 @@ declare namespace React {
      * NOTE: prefer ComponentPropsWithRef, if the ref is forwarded,
      * or ComponentPropsWithoutRef when refs are not supported.
      */
-    type ComponentProps<T extends keyof JSX.IntrinsicElements | ComponentType<any>> =
+    type ComponentProps<T extends ReactType> =
         T extends ComponentType<infer P>
             ? P
             : T extends keyof JSX.IntrinsicElements
                 ? JSX.IntrinsicElements[T]
                 : {};
-    type ComponentPropsWithRef<T extends keyof JSX.IntrinsicElements | ComponentType<any>> =
+    type ComponentPropsWithRef<T extends ReactType> =
         T extends ComponentClass<infer P>
             ? PropsWithoutRef<P> & RefAttributes<InstanceType<T>>
             : PropsWithRef<ComponentProps<T>>;
-    type ComponentPropsWithoutRef<T extends keyof JSX.IntrinsicElements | ComponentType<any>> =
+    type ComponentPropsWithoutRef<T extends ReactType> =
         PropsWithoutRef<ComponentProps<T>>;
 
     // will show `Memo(${Component.displayName || Component.name})` in devtools by default,
@@ -2634,30 +2664,76 @@ declare namespace React {
          */
         componentStack: string;
     }
-}
 
-// Declared props take priority over inferred props
-// If declared props have indexed properties, ignore inferred props entirely as keyof gets widened
-type MergePropTypes<P, T> = P & Pick<T, Exclude<keyof T, keyof P>>;
-
-// Any prop that has a default prop becomes optional, but its type is unchanged
-// Undeclared default props are augmented into the resulting allowable attributes
-// If declared props have indexed properties, ignore default props entirely as keyof gets widened
-// Wrap in an outer-level conditional type to allow distribution over props that are unions
-type Defaultize<P, D> = P extends any
-    ? string extends keyof P ? P :
-        & Pick<P, Exclude<keyof P, keyof D>>
-        & Partial<Pick<P, Extract<keyof P, keyof D>>>
-        & Partial<Pick<D, Exclude<keyof D, keyof P>>>
-    : never;
-
-type ReactManagedAttributes<C, P> = C extends { propTypes: infer T; defaultProps: infer D; }
-    ? Defaultize<MergePropTypes<P, PropTypes.InferProps<T>>, D>
-    : C extends { propTypes: infer T; }
-        ? MergePropTypes<P, PropTypes.InferProps<T>>
-        : C extends { defaultProps: infer D; }
-            ? Defaultize<P, D>
-            : P;
+    const Invalid_propTypes: unique symbol;
+    /**
+     * Dummy interface that is intersected into the props type of a component on
+     * use to generate an error if the component's `propTypes` static property
+     * is invalid.  In most cases, you can get more information about the
+     * problem with the `propTypes` by trying to assign the component to a
+     * variable of type `React.ComponentType<P>` where `P` is the appropriate
+     * props type.  You can bypass the type checking of `propTypes` by defining
+     * a static property named `bypassPropTypesTypecheck`.
+     */
+    interface Invalid_propTypes<P, T> {
+        [Invalid_propTypes]: never;
+    }
+
+    const Invalid_defaultProps: unique symbol;
+    /**
+     * Dummy interface that is intersected into the props type of a component on
+     * use to generate an error if the component's `defaultProps` static
+     * property is invalid.  In most cases, you can get more information about
+     * the problem with the `defaultProps` by trying to assign the component to
+     * a variable of type `React.ComponentType<P>` where `P` is the appropriate
+     * props type.  You can bypass the type checking of `defaultProps` by
+     * defining a static property named `bypassDefaultPropsTypecheck`.
+     */
+    interface Invalid_defaultProps<P, D> {
+        [Invalid_defaultProps]: never;
+    }
+
+    // For a component class, the P passed to JSX.LibraryManagedAttributes is
+    // based on the `props` property and includes `children` regardless of
+    // whether the original props type (the `P` type argument to
+    // React.Component) does.  However, it's common for component classes not
+    // to list `children` in the `propTypes` if the original props type did not
+    // include `children`.  We accommodate that here by making the validator for
+    // `children` optional.
+    type ValidationMapWithOptionalChildren<P> =
+        ValidationMap<Pick<P, Exclude<keyof P, "children">>> &
+        Partial<ValidationMap<Pick<P, Extract<keyof P, "children">>>>;
+
+    // Explicitly check for excess properties in CheckPropTypes and
+    // CheckDefaultProps because by the time we get to
+    // JSX.LibraryManagedAttributes, we have lost the opportunity to do an
+    // excess properties check on the original object literal.
+
+    type CheckPropTypes<P, T> =
+        // This condition attempts to single out `T = any`, which needs to bypass the rest of the check
+        // because `keyof T` would come out as not extending `keyof P`.
+        T extends typeof Invalid_propTypes ? {} :
+        [keyof T, T] extends [keyof P, ValidationMapWithOptionalChildren<P>] ? {} : Invalid_propTypes<P, T>;
+
+    type CheckDefaultProps<P, D> =
+        D extends typeof Invalid_defaultProps ? {} :
+        [keyof D, D] extends [keyof P, Partial<P>] ? {} : Invalid_defaultProps<P, D>;
+
+    // Any prop that has a default prop becomes optional, but its type is unchanged
+    // If declared props have indexed properties, ignore default props entirely as keyof gets widened
+    // Wrap in an outer-level conditional type to allow distribution over props that are unions
+    type Defaultize<P, D> = P extends any
+        ? string extends keyof P ? P :
+            & Pick<P, Exclude<keyof P, keyof D>>
+            & Partial<Pick<P, Extract<keyof P, keyof D>>>
+        : never;
+
+    type ReactManagedAttributes<C, P> =
+        (C extends { propTypes: infer T; }
+            ? (C extends { bypassPropTypesTypecheck: {}; } ? {} : CheckPropTypes<P, T>) : {}) &
+        (C extends { defaultProps: infer D; }
+            ? (C extends { bypassDefaultPropsTypecheck: {}; } ? {} : CheckDefaultProps<P, D>) & Defaultize<P, D> : P);
+}
 
 declare global {
     namespace JSX {
@@ -2673,9 +2749,9 @@ declare global {
         // let's assume it's reasonable to do a single React.lazy() around a single React.memo() / vice-versa
         type LibraryManagedAttributes<C, P> = C extends React.MemoExoticComponent<infer T> | React.LazyExoticComponent<infer T>
             ? T extends React.MemoExoticComponent<infer U> | React.LazyExoticComponent<infer U>
-                ? ReactManagedAttributes<U, P>
-                : ReactManagedAttributes<T, P>
-            : ReactManagedAttributes<C, P>;
+                ? React.ReactManagedAttributes<U, P>
+                : React.ReactManagedAttributes<T, P>
+            : React.ReactManagedAttributes<C, P>;
 
         // tslint:disable-next-line:no-empty-interface
         interface IntrinsicAttributes extends React.Attributes { }

react/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react",
-    "version": "16.7.6",
+    "version": "16.7.10",
     "description": "TypeScript definitions for React",
     "license": "MIT",
     "contributors": [
@@ -41,11 +41,6 @@
             "url": "https://github.com/ericanderson",
             "githubUsername": "ericanderson"
         },
-        {
-            "name": "Albert Kurniawan",
-            "url": "https://github.com/morcerf",
-            "githubUsername": "morcerf"
-        },
         {
             "name": "Tanguy Krotoff",
             "url": "https://github.com/tkrotoff",
@@ -113,6 +108,6 @@
         "csstype": "^2.2.0",
         "@types/prop-types": "*"
     },
-    "typesPublisherContentHash": "60d15e04bc5ffc563f4870c9af6a03836db85f8603e47389ec327081eb2a4994",
+    "typesPublisherContentHash": "46c581d5016bb66b4b04968847bb233a19a992c0434d4cf5f5212c12c5d5f1be",
     "typeScriptVersion": "2.8"
 }