@types/react-dom 15.5.16 → 15.5.18

react-dom v15.5/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for React (react-dom) (http://facebook.gi
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom/v15.
 
 ### Additional Details
- * Last updated: Wed, 15 Feb 2023 00:32:44 GMT
+ * Last updated: Wed, 27 Sep 2023 07:12:04 GMT
  * Dependencies: [@types/react](https://npmjs.com/package/@types/react)
  * Global values: `ReactDOM`, `ReactDOMServer`
 

react-dom v15.5/index.d.ts

@@ -10,10 +10,15 @@
 export as namespace ReactDOM;
 
 import {
-    ReactInstance, Component, ComponentState,
-    ReactElement, SFCElement, CElement,
-    DOMAttributes, DOMElement
-} from 'react';
+    CElement,
+    Component,
+    ComponentState,
+    DOMAttributes,
+    DOMElement,
+    ReactElement,
+    ReactInstance,
+    SFCElement,
+} from "react";
 
 export function findDOMNode<E extends Element>(instance: ReactInstance | null | undefined): E;
 export function findDOMNode(instance: ReactInstance): Element;
@@ -21,28 +26,28 @@ export function findDOMNode(instance: ReactInstance): Element;
 export function render<P extends DOMAttributes<T>, T extends Element>(
     element: DOMElement<P, T>,
     container: Element | null,
-    callback?: (element: T) => any
+    callback?: (element: T) => any,
 ): T;
 export function render<P>(
     element: SFCElement<P>,
     container: Element | null,
-    callback?: () => any
+    callback?: () => any,
 ): void;
 export function render<P, T extends Component<P, ComponentState>>(
     element: CElement<P, T>,
     container: Element | null,
-    callback?: (component: T) => any
+    callback?: (component: T) => any,
 ): T;
 export function render<P>(
     element: ReactElement<P>,
     container: Element | null,
-    callback?: (component?: Component<P, ComponentState> | Element) => any
+    callback?: (component?: Component<P, ComponentState> | Element) => any,
 ): Component<P, ComponentState> | Element | void;
 export function render<P>(
     parentComponent: Component<any>,
     element: SFCElement<P>,
     container: Element,
-    callback?: () => any
+    callback?: () => any,
 ): void;
 
 export function unmountComponentAtNode(container: Element): boolean;
@@ -56,14 +61,17 @@ export function unstable_renderSubtreeIntoContainer<P extends DOMAttributes<T>,
     parentComponent: Component<any>,
     element: DOMElement<P, T>,
     container: Element,
-    callback?: (element: T) => any): T;
+    callback?: (element: T) => any,
+): T;
 export function unstable_renderSubtreeIntoContainer<P, T extends Component<P, ComponentState>>(
     parentComponent: Component<any>,
     element: CElement<P, T>,
     container: Element,
-    callback?: (component: T) => any): T;
+    callback?: (component: T) => any,
+): T;
 export function unstable_renderSubtreeIntoContainer<P>(
     parentComponent: Component<any>,
     element: ReactElement<P>,
     container: Element,
-    callback?: (component?: Component<P, ComponentState> | Element) => any): Component<P, ComponentState> | Element | void;
+    callback?: (component?: Component<P, ComponentState> | Element) => any,
+): Component<P, ComponentState> | Element | void;

react-dom v15.5/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react-dom",
-    "version": "15.5.16",
+    "version": "15.5.18",
     "description": "TypeScript definitions for React (react-dom)",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom",
     "license": "MIT",
@@ -34,6 +34,6 @@
     "dependencies": {
         "@types/react": "^15"
     },
-    "typesPublisherContentHash": "78774703a954579fd100f896e1142c497f83ef85f89ae1c843ea4a0f369e5e7d",
-    "typeScriptVersion": "4.2"
+    "typesPublisherContentHash": "44eef8218ba9c80a7d8816a3803b21687ab73402979313457930cd65010f33a2",
+    "typeScriptVersion": "4.5"
 }

react-dom v15.5/server/index.d.ts

@@ -1,4 +1,4 @@
-import { ReactElement } from 'react';
+import { ReactElement } from "react";
 
 /**
  * Render a React element to its initial HTML. This should only be used on the server.

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

@@ -1,9 +1,17 @@
 import {
-    AbstractView, Component, ComponentClass,
-    ReactElement, ReactInstance, ClassType,
-    DOMElement, SFCElement, CElement,
-    ReactHTMLElement, DOMAttributes, SFC
-} from 'react';
+    AbstractView,
+    CElement,
+    ClassType,
+    Component,
+    ComponentClass,
+    DOMAttributes,
+    DOMElement,
+    ReactElement,
+    ReactHTMLElement,
+    ReactInstance,
+    SFC,
+    SFCElement,
+} from "react";
 
 import * as ReactTestUtils from ".";
 
@@ -22,7 +30,21 @@ export interface OptionalEventProperties {
     type?: string | undefined;
 }
 
-export type ModifierKey = "Alt" | "AltGraph" | "CapsLock" | "Control" | "Fn" | "FnLock" | "Hyper" | "Meta" | "NumLock" | "ScrollLock" | "Shift" | "Super" | "Symbol" | "SymbolLock";
+export type ModifierKey =
+    | "Alt"
+    | "AltGraph"
+    | "CapsLock"
+    | "Control"
+    | "Fn"
+    | "FnLock"
+    | "Hyper"
+    | "Meta"
+    | "NumLock"
+    | "ScrollLock"
+    | "Shift"
+    | "Super"
+    | "Symbol"
+    | "SymbolLock";
 
 export interface SyntheticEventData extends OptionalEventProperties {
     altKey?: boolean | undefined;
@@ -61,7 +83,7 @@ export interface SyntheticEventData extends OptionalEventProperties {
 export type EventSimulator = (element: Element | Component<any>, eventData?: SyntheticEventData) => void;
 
 export interface MockedComponentClass {
-    new (): any;
+    new(): any;
 }
 
 export interface ShallowRenderer {
@@ -86,16 +108,19 @@ export namespace Simulate {
     const animationIteration: EventSimulator;
     const animationStart: EventSimulator;
     const blur: EventSimulator;
+    const cancel: EventSimulator;
     const canPlay: EventSimulator;
     const canPlayThrough: EventSimulator;
     const change: EventSimulator;
     const click: EventSimulator;
+    const close: EventSimulator;
     const compositionEnd: EventSimulator;
     const compositionStart: EventSimulator;
     const compositionUpdate: EventSimulator;
     const contextMenu: EventSimulator;
     const copy: EventSimulator;
     const cut: EventSimulator;
+    const auxClick: EventSimulator;
     const doubleClick: EventSimulator;
     const drag: EventSimulator;
     const dragEnd: EventSimulator;
@@ -132,11 +157,24 @@ export namespace Simulate {
     const play: EventSimulator;
     const playing: EventSimulator;
     const progress: EventSimulator;
+    const pointerCancel: EventSimulator;
+    const pointerDown: EventSimulator;
+    const pointerUp: EventSimulator;
+    const pointerMove: EventSimulator;
+    const pointerOut: EventSimulator;
+    const pointerOver: EventSimulator;
+    const pointerEnter: EventSimulator;
+    const pointerLeave: EventSimulator;
+    const gotPointerCapture: EventSimulator;
+    const lostPointerCapture: EventSimulator;
     const rateChange: EventSimulator;
+    const reset: EventSimulator;
     const scroll: EventSimulator;
+    const toggle: EventSimulator;
     const seeked: EventSimulator;
     const seeking: EventSimulator;
     const select: EventSimulator;
+    const beforeInput: EventSimulator;
     const stalled: EventSimulator;
     const submit: EventSimulator;
     const suspend: EventSimulator;
@@ -155,17 +193,21 @@ export namespace Simulate {
  * Render a React element into a detached DOM node in the document. __This function requires a DOM__.
  */
 export function renderIntoDocument<T extends Element>(
-    element: DOMElement<any, T>): T;
+    element: DOMElement<any, T>,
+): T;
 export function renderIntoDocument(
-    element: SFCElement<any>): void;
+    element: SFCElement<any>,
+): void;
 // If we replace `P` with `any` in this overload, then some tests fail because
 // calls to `renderIntoDocument` choose the last overload on the
 // subtype-relation pass and get an undesirably broad return type.  Using `P`
 // allows this overload to match on the subtype-relation pass.
 export function renderIntoDocument<P, T extends Component<P>>(
-    element: CElement<P, T>): T;
+    element: CElement<P, T>,
+): T;
 export function renderIntoDocument<P>(
-    element: ReactElement<P>): Component<P> | Element | void;
+    element: ReactElement<P>,
+): Component<P> | Element | void;
 
 /**
  * Pass a mocked component module to this method to augment it with useful methods that allow it to
@@ -173,7 +215,9 @@ export function renderIntoDocument<P>(
  * a simple `<div>` (or other tag if `mockTagName` is provided) containing any provided children.
  */
 export function mockComponent(
-    mocked: MockedComponentClass, mockTagName?: string): typeof ReactTestUtils;
+    mocked: MockedComponentClass,
+    mockTagName?: string,
+): typeof ReactTestUtils;
 
 /**
  * Returns `true` if `element` is any React element.
@@ -184,22 +228,30 @@ export function isElement(element: any): boolean;
  * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
  */
 export function isElementOfType<T extends HTMLElement>(
-    element: ReactElement, type: string): element is ReactHTMLElement<T>;
+    element: ReactElement,
+    type: string,
+): element is ReactHTMLElement<T>;
 /**
  * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
  */
 export function isElementOfType<P extends DOMAttributes<{}>, T extends Element>(
-    element: ReactElement, type: string): element is DOMElement<P, T>;
+    element: ReactElement,
+    type: string,
+): element is DOMElement<P, T>;
 /**
  * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
  */
 export function isElementOfType<P>(
-    element: ReactElement, type: SFC<P>): element is SFCElement<P>;
+    element: ReactElement,
+    type: SFC<P>,
+): element is SFCElement<P>;
 /**
  * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
  */
 export function isElementOfType<P, T extends Component<P>, C extends ComponentClass<P>>(
-    element: ReactElement, type: ClassType<P, T, C>): element is CElement<P, T>;
+    element: ReactElement,
+    type: ClassType<P, T, C>,
+): element is CElement<P, T>;
 
 /**
  * Returns `true` if `instance` is a DOM component (such as a `<div>` or `<span>`).
@@ -213,7 +265,9 @@ export function isCompositeComponent(instance: ReactInstance): instance is Compo
  * Returns `true` if `instance` is a component whose type is of a React `componentClass`.
  */
 export function isCompositeComponentWithType<T extends Component<any>, C extends ComponentClass<any>>(
-    instance: ReactInstance, type: ClassType<any, T, C>): boolean;
+    instance: ReactInstance,
+    type: ClassType<any, T, C>,
+): boolean;
 
 /**
  * Traverse all components in `tree` and accumulate all components where
@@ -222,7 +276,8 @@ export function isCompositeComponentWithType<T extends Component<any>, C extends
  */
 export function findAllInRenderedTree(
     root: Component<any>,
-    fn: (i: ReactInstance) => boolean): ReactInstance[];
+    fn: (i: ReactInstance) => boolean,
+): ReactInstance[];
 
 /**
  * Finds all DOM elements of components in the rendered tree that are
@@ -230,7 +285,8 @@ export function findAllInRenderedTree(
  */
 export function scryRenderedDOMComponentsWithClass(
     root: Component<any>,
-    className: string): Element[];
+    className: string,
+): Element[];
 /**
  * Like `scryRenderedDOMComponentsWithClass()` but expects there to be one result,
  * and returns that one result, or throws exception if there is any other
@@ -238,7 +294,8 @@ export function scryRenderedDOMComponentsWithClass(
  */
 export function findRenderedDOMComponentWithClass(
     root: Component<any>,
-    className: string): Element;
+    className: string,
+): Element;
 
 /**
  * Finds all DOM elements of components in the rendered tree that are
@@ -246,7 +303,8 @@ export function findRenderedDOMComponentWithClass(
  */
 export function scryRenderedDOMComponentsWithTag(
     root: Component<any>,
-    tagName: string): Element[];
+    tagName: string,
+): Element[];
 /**
  * Like `scryRenderedDOMComponentsWithTag()` but expects there to be one result,
  * and returns that one result, or throws exception if there is any other
@@ -254,14 +312,16 @@ export function scryRenderedDOMComponentsWithTag(
  */
 export function findRenderedDOMComponentWithTag(
     root: Component<any>,
-    tagName: string): Element;
+    tagName: string,
+): Element;
 
 /**
  * Finds all instances of components with type equal to `componentClass`.
  */
 export function scryRenderedComponentsWithType<T extends Component, C extends ComponentClass>(
     root: Component<any>,
-    type: ClassType<any, T, C>): T[];
+    type: ClassType<any, T, C>,
+): T[];
 
 /**
  * Same as `scryRenderedComponentsWithType()` but expects there to be one result
@@ -270,7 +330,8 @@ export function scryRenderedComponentsWithType<T extends Component, C extends Co
  */
 export function findRenderedComponentWithType<T extends Component, C extends ComponentClass>(
     root: Component<any>,
-    type: ClassType<any, T, C>): T;
+    type: ClassType<any, T, C>,
+): T;
 
 /**
  * Call this in your tests to create a shallow renderer.