@types/react-dom 16.9.2 → 16.9.6

react-dom/README.md

@@ -5,12 +5,12 @@
 This package contains type definitions for React (react-dom) (http://facebook.github.io/react/).
 
 # Details
-Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom.
 
-Additional Details
- * Last updated: Mon, 14 Oct 2019 20:17:00 GMT
- * Dependencies: @types/react
- * Global values: ReactDOM, ReactDOMNodeStream, ReactDOMServer
+### Additional Details
+ * Last updated: Tue, 31 Mar 2020 21:43:51 GMT
+ * Dependencies: [@types/react](https://npmjs.com/package/@types/react)
+ * Global values: `ReactDOM`, `ReactDOMNodeStream`, `ReactDOMServer`
 
 # Credits
-These definitions were written by Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>, MartynasZilinskas <https://github.com/MartynasZilinskas>, Josh Rutherford <https://github.com/theruther4d>, and Jessica Franco <https://github.com/Jessidhia>.
+These definitions were written by [Asana](https://asana.com), [AssureSign](http://www.assuresign.com), [Microsoft](https://microsoft.com), [MartynasZilinskas](https://github.com/MartynasZilinskas), [Josh Rutherford](https://github.com/theruther4d), and [Jessica Franco](https://github.com/Jessidhia).

react-dom/experimental.d.ts

@@ -0,0 +1,102 @@
+/**
+ * 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-dom/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-dom/experimental'
+ * ```
+ *
+ * It is also possible to include it through a triple-slash reference:
+ *
+ * ```ts
+ * /// <reference types="react-dom/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-dom/src/client/ReactDOM.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__`.
+
+import React = require('react');
+import ReactDOM = require('.');
+
+export {};
+
+declare module '.' {
+    // enableSuspenseServerRenderer feature
+    interface HydrationOptions {
+        onHydrated?(suspenseInstance: Comment): void;
+        onDeleted?(suspenseInstance: Comment): void;
+    }
+
+    // exposeConcurrentModeAPIs features
+
+    interface RootOptions {
+        hydrate?: boolean;
+        hydrationOptions?: HydrationOptions;
+    }
+
+    interface Root {
+        render(children: React.ReactChild | React.ReactNodeArray, callback?: () => void): void;
+        unmount(callback?: () => void): void;
+    }
+
+    /**
+     * Replaces `ReactDOM.render` when the `.render` method is called and enables Blocking Mode.
+     *
+     * Opting into Concurrent Mode introduces semantic changes to how React works.
+     * This means that you can’t use Concurrent Mode in just a few components.
+     * Because of this, some apps may not be able to migrate directly to Concurrent Mode.
+     * Blocking Mode only contains a small subset of Concurrent Mode features and is intended
+     * as an intermediary migration step for apps that are unable to migrate directly.
+     *
+     * @see https://reactjs.org/docs/concurrent-mode-adoption.html#migration-step-blocking-mode
+     * @see https://reactjs.org/docs/concurrent-mode-reference.html#createblockingroot
+     */
+    function createBlockingRoot(
+        container: Element | Document | DocumentFragment | Comment,
+        options?: RootOptions,
+    ): Root;
+
+    /**
+     * Replaces `ReactDOM.render` when the `.render` method is called and enables Concurrent Mode.
+     *
+     * @see https://reactjs.org/docs/concurrent-mode-reference.html#createroot
+     */
+    function createRoot(container: Element | Document | DocumentFragment | Comment, options?: RootOptions): Root;
+
+    function unstable_discreteUpdates<R>(callback: () => R): R;
+
+    function unstable_discreteUpdates<R, A1>(callback: (a1: A1) => R, a1: A1): R;
+
+    function unstable_discreteUpdates<R, A1, A2>(callback: (a1: A1, a2: A2) => R, a1: A1, a2: A2): R;
+
+    function unstable_discreteUpdates<R, A1, A2, A3>(
+        callback: (a1: A1, a2: A2, a3: A3) => R,
+        a1: A1,
+        a2: A2,
+        a3: A3,
+    ): R;
+
+    function unstable_flushDiscreteUpdates(): void;
+
+    function unstable_flushControlled(callback: () => void): void;
+
+    // enableSelectiveHydration feature
+
+    /**
+     * @see https://github.com/facebook/react/commit/3a2b5f148d450c69aab67f055fc441d294c23518
+     */
+    function unstable_scheduleHydration(target: Element | Document | DocumentFragment | Comment): void;
+}

react-dom/index.d.ts

@@ -9,6 +9,10 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
+// NOTE: Users of the `experimental` builds of React should add a reference
+// to 'react-dom/experimental' in their project. See experimental.d.ts's top comment
+// for reference and documentation on how exactly to do it.
+
 export as namespace ReactDOM;
 
 import {
@@ -18,7 +22,7 @@ import {
 } from 'react';
 
 export function findDOMNode(instance: ReactInstance | null | undefined): Element | null | Text;
-export function unmountComponentAtNode(container: Element): boolean;
+export function unmountComponentAtNode(container: Element | DocumentFragment): boolean;
 
 export function createPortal(children: ReactNode, container: Element, key?: null | string): ReactPortal;
 
@@ -52,73 +56,43 @@ export interface Renderer {
 
     <T extends Element>(
         element: DOMElement<DOMAttributes<T>, T>,
-        container: Element | null,
+        container: Element | DocumentFragment | null,
         callback?: () => void
     ): T;
 
     (
         element: Array<DOMElement<DOMAttributes<any>, any>>,
-        container: Element | null,
+        container: Element | DocumentFragment | null,
         callback?: () => void
     ): Element;
 
     (
         element: SFCElement<any> | Array<SFCElement<any>>,
-        container: Element | null,
+        container: Element | DocumentFragment | null,
         callback?: () => void
     ): void;
 
     <P, T extends Component<P, ComponentState>>(
         element: CElement<P, T>,
-        container: Element | null,
+        container: Element | DocumentFragment | null,
         callback?: () => void
     ): T;
 
     (
         element: Array<CElement<any, Component<any, ComponentState>>>,
-        container: Element | null,
+        container: Element | DocumentFragment | null,
         callback?: () => void
     ): Component<any, ComponentState>;
 
     <P>(
         element: ReactElement<P>,
-        container: Element | null,
+        container: Element | DocumentFragment | null,
         callback?: () => void
     ): Component<P, ComponentState> | Element | void;
 
     (
         element: ReactElement[],
-        container: Element | null,
+        container: Element | DocumentFragment | null,
         callback?: () => void
     ): Component<any, ComponentState> | Element | void;
 }
-
-export interface Work {
-  then(onCommit?: () => void): void;
-}
-
-export interface Batch {
-  commit(): void;
-  render(children: React.ReactNode): Work;
-  then(onComplete?: () => void): void;
-}
-
-export interface RootOptions {
-    hydrate?: boolean;
-}
-
-export interface SyncRoot {
-    render(children: React.ReactNode, callback?: () => void): Work;
-    unmount(callback?: () => void): void;
-}
-
-export function unstable_createSyncRoot(container: Element, options?: RootOptions): SyncRoot;
-
-export interface Root extends SyncRoot {
-  createBatch(): Batch;
-}
-
-export function unstable_createRoot(
-    container: Element,
-    options?: RootOptions
-): Root;

react-dom/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react-dom",
-    "version": "16.9.2",
+    "version": "16.9.6",
     "description": "TypeScript definitions for React (react-dom)",
     "license": "MIT",
     "contributors": [
@@ -33,7 +33,7 @@
         }
     ],
     "main": "",
-    "types": "index",
+    "types": "index.d.ts",
     "repository": {
         "type": "git",
         "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
@@ -43,6 +43,6 @@
     "dependencies": {
         "@types/react": "*"
     },
-    "typesPublisherContentHash": "897ba71f8211baa5df942d6e63bea8ce5f8ed8e500763b5cca5416b832fcb11c",
+    "typesPublisherContentHash": "6a13b83e378d549ddeae772447c4a211ba2d108e21786e64d706321289320543",
     "typeScriptVersion": "2.8"
 }

react-dom/server/index.d.ts

@@ -14,7 +14,7 @@ import { ReactElement } from 'react';
  * and send the markup down on the initial request for faster page loads and to allow search
  * engines to crawl your pages for SEO purposes.
  *
- * If you call `ReactDOM.render()` on a node that already has this server-rendered markup,
+ * If you call `ReactDOM.hydrate()` on a node that already has this server-rendered markup,
  * React will preserve it and only attach event handlers, allowing you
  * to have a very performant first-load experience.
  */

react-dom/test-utils/index.d.ts

@@ -287,7 +287,7 @@ export function createRenderer(): ShallowRenderer;
  * @see https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks
  */
 // the "void | undefined" is here to forbid any sneaky "Promise" returns.
-export function act(callback: () => void | undefined): DebugPromiseLike;
+export function act(callback: () => void | undefined): void;
 // the "void | undefined" is here to forbid any sneaky return values
 // tslint:disable-next-line: void-return
 export function act(callback: () => Promise<void | undefined>): Promise<undefined>;