@types/react-dom 17.0.15 → 18.0.2

react-dom v17.0/README.md → react-dom/README.md

@@ -5,12 +5,12 @@
 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/v17.
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom.
 
 ### Additional Details
- * Last updated: Thu, 07 Apr 2022 17:31:23 GMT
+ * Last updated: Thu, 21 Apr 2022 18:01:42 GMT
  * Dependencies: [@types/react](https://npmjs.com/package/@types/react)
- * Global values: `ReactDOM`, `ReactDOMNodeStream`, `ReactDOMServer`
+ * Global values: `ReactDOM`, `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), [Jessica Franco](https://github.com/Jessidhia), and [Sebastian Silbermann](https://github.com/eps1lon).

react-dom/client.d.ts

@@ -0,0 +1,40 @@
+/**
+ * WARNING: This entrypoint is only available starting with `react-dom@18.0.0-rc.1`
+ */
+
+// See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
+
+import React = require('react');
+export interface HydrationOptions {
+    /**
+     * Prefix for `useId`.
+     */
+    identifierPrefix?: string;
+    onRecoverableError?: (error: unknown) => void;
+}
+
+export interface RootOptions {
+    /**
+     * Prefix for `useId`.
+     */
+    identifierPrefix?: string;
+    onRecoverableError?: (error: unknown) => void;
+}
+
+export interface Root {
+    render(children: React.ReactChild | Iterable<React.ReactNode>): void;
+    unmount(): void;
+}
+
+/**
+ * Replaces `ReactDOM.render` when the `.render` method is called and enables Concurrent Mode.
+ *
+ * @see https://reactjs.org/docs/concurrent-mode-reference.html#createroot
+ */
+export function createRoot(container: Element | DocumentFragment, options?: RootOptions): Root;
+
+export function hydrateRoot(
+    container: Element | Document,
+    initialChildren: React.ReactChild | Iterable<React.ReactNode>,
+    options?: HydrationOptions,
+): Root;

react-dom/experimental.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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/main/packages/react-dom/index.experimental.js to see how the exports are declared,
+// but confirm with published source code (e.g. https://unpkg.com/react-dom@experimental) that these exports end up in the published code
+
+import React = require('react');
+import ReactDOM = require('./next');
+
+export {};
+
+declare module '.' {}

react-dom v17.0/index.d.ts → react-dom/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for React (react-dom) 17.0
+// Type definitions for React (react-dom) 18.0
 // Project: https://reactjs.org
 // Definitions by: Asana <https://asana.com>
 //                 AssureSign <http://www.assuresign.com>
@@ -10,6 +10,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 {

react-dom/next.d.ts

@@ -0,0 +1,34 @@
+/**
+ * These are types for things that are present in the upcoming React 18 release.
+ *
+ * Once React 18 is released 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/next"` 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/next'
+ * ```
+ *
+ * It is also possible to include it through a triple-slash reference:
+ *
+ * ```ts
+ * /// <reference types="react-dom/next" />
+ * ```
+ *
+ * Either the import or the reference only needs to appear once, anywhere in the project.
+ */
+
+// See https://github.com/facebook/react/blob/main/packages/react-dom/index.js to see how the exports are declared,
+// but confirm with published source code (e.g. https://unpkg.com/react-dom@next) that these exports end up in the published code
+
+import React = require('react');
+import ReactDOM = require('.');
+
+export {};
+
+declare module '.' {}

react-dom v17.0/package.json → react-dom/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react-dom",
-    "version": "17.0.15",
+    "version": "18.0.2",
     "description": "TypeScript definitions for React (react-dom)",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom",
     "license": "MIT",
@@ -47,8 +47,36 @@
     },
     "scripts": {},
     "dependencies": {
-        "@types/react": "^17"
+        "@types/react": "*"
     },
-    "typesPublisherContentHash": "2ba4656eb0610592a703a57ffab398587d12daf639cd9f7abf43c67440cef43b",
-    "typeScriptVersion": "3.9"
+    "typesPublisherContentHash": "72a20209680e5c96e111d54d943c23ee84ae698daf720273739b5f72b1f276a1",
+    "typeScriptVersion": "3.9",
+    "exports": {
+        ".": {
+            "types": {
+                "default": "./index.d.ts"
+            }
+        },
+        "./client": {
+            "types": {
+                "default": "./client.d.ts"
+            }
+        },
+        "./next": {
+            "types": {
+                "default": "./next.d.ts"
+            }
+        },
+        "./server": {
+            "types": {
+                "default": "./server.d.ts"
+            }
+        },
+        "./experimental": {
+            "types": {
+                "default": "./experimental.d.ts"
+            }
+        },
+        "./package.json": "./package.json"
+    }
 }

react-dom/server.d.ts

@@ -0,0 +1,119 @@
+// forward declarations
+declare global {
+    namespace NodeJS {
+        // tslint:disable-next-line:no-empty-interface
+        interface ReadableStream {}
+
+        // tslint:disable-next-line:no-empty-interface
+        interface WritableStream {}
+    }
+
+    /**
+     * Stub for https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+     */
+    // tslint:disable-next-line:no-empty-interface
+    interface AbortSignal {}
+
+    /**
+     * Stub for https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
+     */
+    // tslint:disable-next-line:no-empty-interface
+    interface ReadableStream {}
+}
+
+import { ReactElement, ReactNode } from 'react';
+
+export interface RenderToPipeableStreamOptions {
+    identifierPrefix?: string;
+    namespaceURI?: string;
+    nonce?: string;
+    bootstrapScriptContent?: string;
+    bootstrapScripts?: string[];
+    bootstrapModules?: string[];
+    progressiveChunkSize?: number;
+    onShellReady?: () => void;
+    onShellError?: (error: unknown) => void;
+    onAllReady?: () => void;
+    onError?: (error: unknown) => void;
+}
+
+export interface PipeableStream {
+    abort(): void;
+    pipe<Writable extends NodeJS.WritableStream>(destination: Writable): Writable;
+}
+
+/**
+ * Only available in the environments with [Node.js Streams](https://nodejs.dev/learn/nodejs-streams).
+ *
+ * @see [API](https://reactjs.org/docs/react-dom-server.html#rendertopipeablestream)
+ *
+ * @param children
+ * @param options
+ */
+export function renderToPipeableStream(children: ReactNode, options?: RenderToPipeableStreamOptions): PipeableStream;
+
+/**
+ * Render a React element to its initial HTML. This should only be used on the server.
+ * React will return an HTML string. You can use this method to generate HTML on the server
+ * 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.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.
+ */
+export function renderToString(element: ReactElement): string;
+
+/**
+ * Render a React element to its initial HTML. Returns a Readable stream that outputs
+ * an HTML string. The HTML output by this stream is exactly equal to what
+ * `ReactDOMServer.renderToString()` would return.
+ *
+ * @deprecated
+ */
+export function renderToNodeStream(element: ReactElement): NodeJS.ReadableStream;
+
+/**
+ * Similar to `renderToString`, except this doesn't create extra DOM attributes
+ * such as `data-reactid`, that React uses internally. This is useful if you want
+ * to use React as a simple static page generator, as stripping away the extra
+ * attributes can save lots of bytes.
+ */
+export function renderToStaticMarkup(element: ReactElement): string;
+
+/**
+ * Similar to `renderToNodeStream`, except this doesn't create extra DOM attributes
+ * such as `data-reactid`, that React uses internally. The HTML output by this stream
+ * is exactly equal to what `ReactDOMServer.renderToStaticMarkup()` would return.
+ */
+export function renderToStaticNodeStream(element: ReactElement): NodeJS.ReadableStream;
+
+export interface RenderToReadableStreamOptions {
+    identifierPrefix?: string;
+    namespaceURI?: string;
+    nonce?: string;
+    bootstrapScriptContent?: string;
+    bootstrapScripts?: string[];
+    bootstrapModules?: string[];
+    progressiveChunkSize?: number;
+    signal?: AbortSignal;
+    onError?: (error: unknown) => void;
+}
+
+export interface ReactDOMServerReadableStream extends ReadableStream {
+    allReady: Promise<void>;
+}
+
+/**
+ * Only available in the environments with [Web Streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) (this includes browsers, Deno, and some modern edge runtimes).
+ *
+ * @see [API](https://reactjs.org/docs/react-dom-server.html#rendertoreadablestream)
+ */
+export function renderToReadableStream(
+    children: ReactNode,
+    options?: RenderToReadableStreamOptions,
+): Promise<ReactDOMServerReadableStream>;
+
+export const version: string;
+
+export as namespace ReactDOMServer;

react-dom v17.0/node-stream/index.d.ts

@@ -1,18 +0,0 @@
-import { ReactElement } from 'react';
-
-/**
- * Render a ReactElement to its initial HTML. This should only be used on the
- * server.
- * See https://facebook.github.io/react/docs/react-dom-stream.html#rendertostream
- */
-export function renderToStream(element: ReactElement): any;
-
-/**
- * Similar to renderToStream, except this doesn't create extra DOM attributes
- * such as data-react-id that React uses internally.
- * See https://facebook.github.io/react/docs/react-dom-stream.html#rendertostaticstream
- */
-export function renderToStaticStream(element: ReactElement): any;
-export const version: string;
-
-export as namespace ReactDOMNodeStream;

react-dom v17.0/server.d.ts

@@ -1,47 +0,0 @@
-// forward declarations
-declare global {
-    namespace NodeJS {
-        // tslint:disable-next-line:no-empty-interface
-        interface ReadableStream {}
-    }
-}
-
-import { ReactElement } from 'react';
-
-/**
- * Render a React element to its initial HTML. This should only be used on the server.
- * React will return an HTML string. You can use this method to generate HTML on the server
- * 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.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.
- */
-export function renderToString(element: ReactElement): string;
-
-/**
- * Render a React element to its initial HTML. Returns a Readable stream that outputs
- * an HTML string. The HTML output by this stream is exactly equal to what
- * `ReactDOMServer.renderToString()` would return.
- */
-export function renderToNodeStream(element: ReactElement): NodeJS.ReadableStream;
-
-/**
- * Similar to `renderToString`, except this doesn't create extra DOM attributes
- * such as `data-reactid`, that React uses internally. This is useful if you want
- * to use React as a simple static page generator, as stripping away the extra
- * attributes can save lots of bytes.
- */
-export function renderToStaticMarkup(element: ReactElement): string;
-
-/**
- * Similar to `renderToNodeStream`, except this doesn't create extra DOM attributes
- * such as `data-reactid`, that React uses internally. The HTML output by this stream
- * is exactly equal to what `ReactDOMServer.renderToStaticMarkup()` would return.
- */
-export function renderToStaticNodeStream(element: ReactElement): NodeJS.ReadableStream;
-
-export const version: string;
-
-export as namespace ReactDOMServer;