@types/react-dom 17.0.0 → 17.0.4

react-dom/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for React (react-dom) (https://reactjs.or
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom.
 
 ### Additional Details
- * Last updated: Fri, 20 Nov 2020 22:01:05 GMT
+ * Last updated: Mon, 10 May 2021 22:31:25 GMT
  * Dependencies: [@types/react](https://npmjs.com/package/@types/react)
  * Global values: `ReactDOM`, `ReactDOMNodeStream`, `ReactDOMServer`
 

react-dom/experimental.d.ts

@@ -52,23 +52,6 @@ declare module '.' {
         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 unstable_createBlockingRoot(
-        container: Element | Document | DocumentFragment | Comment,
-        options?: RootOptions,
-    ): Root;
-
     /**
      * Replaces `ReactDOM.render` when the `.render` method is called and enables Concurrent Mode.
      *

react-dom/index.d.ts

@@ -30,6 +30,9 @@ export const version: string;
 export const render: Renderer;
 export const hydrate: Renderer;
 
+export function flushSync<R>(fn: () => R): R;
+export function flushSync<A, R>(fn: (a: A) => R, a: A): R;
+
 export function unstable_batchedUpdates<A, B>(callback: (a: A, b: B) => any, a: A, b: B): void;
 export function unstable_batchedUpdates<A>(callback: (a: A) => any, a: A): void;
 export function unstable_batchedUpdates(callback: () => any): void;

react-dom/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react-dom",
-    "version": "17.0.0",
+    "version": "17.0.4",
     "description": "TypeScript definitions for React (react-dom)",
     "license": "MIT",
     "contributors": [
@@ -43,6 +43,6 @@
     "dependencies": {
         "@types/react": "*"
     },
-    "typesPublisherContentHash": "b1d11668457222630c5b11e04c338f3cbcee00f6e40f98e5fef66d0bfe1414cf",
-    "typeScriptVersion": "3.3"
+    "typesPublisherContentHash": "f6ef2f5cdf9e3adf7cc9fe9efc08259a2712408862af5d62dbfe1ac1dad2162d",
+    "typeScriptVersion": "3.5"
 }

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

@@ -7,6 +7,8 @@ import {
 
 import * as ReactTestUtils from ".";
 
+export {};
+
 export interface OptionalEventProperties {
     bubbles?: boolean;
     cancelable?: boolean;
@@ -288,12 +290,14 @@ export function createRenderer(): ShallowRenderer;
  */
 // NOTES
 // - the order of these signatures matters - typescript will check the signatures in source order.
-//   If the `() => void` signature is first, it'll erroneously match a Promise returning function for users with
+//   If the `() => VoidOrUndefinedOnly` signature is first, it'll erroneously match a Promise returning function for users with
 //   `strictNullChecks: false`.
-// - the "void | undefined" types are there to forbid any non-void return values for users with `strictNullChecks: true`
+// - VoidOrUndefinedOnly is there to forbid any non-void return values for users with `strictNullChecks: true`
+declare const UNDEFINED_VOID_ONLY: unique symbol;
 // tslint:disable-next-line: void-return
-export function act(callback: () => Promise<void | undefined>): Promise<undefined>;
-export function act(callback: () => void | undefined): void;
+type VoidOrUndefinedOnly = void | { [UNDEFINED_VOID_ONLY]: never };
+export function act(callback: () => Promise<void>): Promise<undefined>;
+export function act(callback: () => VoidOrUndefinedOnly): void;
 
 // Intentionally doesn't extend PromiseLike<never>.
 // Ideally this should be as hard to accidentally use as possible.