@types/react-dom 16.9.11 → 17.0.0

react-dom v16.9/README.md → react-dom/README.md

@@ -5,10 +5,10 @@
 This package contains type definitions for React (react-dom) (https://reactjs.org).
 
 # Details
-Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom/v16.
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom.
 
 ### Additional Details
- * Last updated: Fri, 12 Feb 2021 18:02:48 GMT
+ * Last updated: Fri, 20 Nov 2020 22:01:05 GMT
  * Dependencies: [@types/react](https://npmjs.com/package/@types/react)
  * Global values: `ReactDOM`, `ReactDOMNodeStream`, `ReactDOMServer`
 

react-dom/experimental.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 unstable_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 unstable_createRoot(container: Element | Document | DocumentFragment | Comment, options?: RootOptions): Root;
+
+    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 v16.9/index.d.ts → react-dom/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for React (react-dom) 16.9
+// Type definitions for React (react-dom) 17.0
 // Project: https://reactjs.org
 // Definitions by: Asana <https://asana.com>
 //                 AssureSign <http://www.assuresign.com>

react-dom v16.9/package.json → react-dom/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react-dom",
-    "version": "16.9.11",
+    "version": "17.0.0",
     "description": "TypeScript definitions for React (react-dom)",
     "license": "MIT",
     "contributors": [
@@ -41,8 +41,8 @@
     },
     "scripts": {},
     "dependencies": {
-        "@types/react": "^16"
+        "@types/react": "*"
     },
-    "typesPublisherContentHash": "550ed1e4b6475591e135170a4c9ac8e70c518caca3a624a72c549b32c25a5ef3",
-    "typeScriptVersion": "3.4"
+    "typesPublisherContentHash": "b1d11668457222630c5b11e04c338f3cbcee00f6e40f98e5fef66d0bfe1414cf",
+    "typeScriptVersion": "3.3"
 }

react-dom v16.9/test-utils/index.d.ts → react-dom/test-utils/index.d.ts

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