Copied types from DefinitelyTyped into this repository

package.json

@@ -3,6 +3,7 @@
   "version": "0.0.0-semantically-released",
   "description": "Simple and complete DOM testing utilities that encourage good testing practices.",
   "main": "dist/index.js",
+  "types": "types/index.d.ts",
   "module": "dist/@testing-library/dom.esm.js",
   "umd:main": "dist/@testing-library/dom.umd.js",
   "source": "src/index.js",
@@ -32,11 +33,11 @@
     "validate": "kcd-scripts validate"
   },
   "files": [
-    "dist"
+    "dist",
+    "types"
   ],
   "dependencies": {
     "@babel/runtime": "^7.9.2",
-    "@types/testing-library__dom": "^7.0.0",
     "aria-query": "^4.0.2",
     "dom-accessibility-api": "^0.4.2",
     "pretty-format": "^25.1.0"

types/config.d.ts

@@ -0,0 +1,12 @@
+export interface Config {
+    testIdAttribute: string;
+    asyncWrapper(cb: (...args: any[]) => any): Promise<any>;
+    asyncUtilTimeout: number;
+    defaultHidden: boolean;
+}
+
+export interface ConfigFn {
+    (existingConfig: Config): Partial<Config>;
+}
+
+export function configure(configDelta: Partial<Config> | ConfigFn): void;

types/events.d.ts

@@ -0,0 +1,95 @@
+export type EventType =
+    | 'copy'
+    | 'cut'
+    | 'paste'
+    | 'compositionEnd'
+    | 'compositionStart'
+    | 'compositionUpdate'
+    | 'keyDown'
+    | 'keyPress'
+    | 'keyUp'
+    | 'focus'
+    | 'blur'
+    | 'focusIn'
+    | 'focusOut'
+    | 'change'
+    | 'input'
+    | 'invalid'
+    | 'submit'
+    | 'reset'
+    | 'click'
+    | 'contextMenu'
+    | 'dblClick'
+    | 'drag'
+    | 'dragEnd'
+    | 'dragEnter'
+    | 'dragExit'
+    | 'dragLeave'
+    | 'dragOver'
+    | 'dragStart'
+    | 'drop'
+    | 'mouseDown'
+    | 'mouseEnter'
+    | 'mouseLeave'
+    | 'mouseMove'
+    | 'mouseOut'
+    | 'mouseOver'
+    | 'mouseUp'
+    | 'popState'
+    | 'select'
+    | 'touchCancel'
+    | 'touchEnd'
+    | 'touchMove'
+    | 'touchStart'
+    | 'scroll'
+    | 'wheel'
+    | 'abort'
+    | 'canPlay'
+    | 'canPlayThrough'
+    | 'durationChange'
+    | 'emptied'
+    | 'encrypted'
+    | 'ended'
+    | 'loadedData'
+    | 'loadedMetadata'
+    | 'loadStart'
+    | 'pause'
+    | 'play'
+    | 'playing'
+    | 'progress'
+    | 'rateChange'
+    | 'seeked'
+    | 'seeking'
+    | 'stalled'
+    | 'suspend'
+    | 'timeUpdate'
+    | 'volumeChange'
+    | 'waiting'
+    | 'load'
+    | 'error'
+    | 'animationStart'
+    | 'animationEnd'
+    | 'animationIteration'
+    | 'transitionEnd'
+    | 'doubleClick'
+    | 'pointerOver'
+    | 'pointerEnter'
+    | 'pointerDown'
+    | 'pointerMove'
+    | 'pointerUp'
+    | 'pointerCancel'
+    | 'pointerOut'
+    | 'pointerLeave'
+    | 'gotPointerCapture'
+    | 'lostPointerCapture';
+
+export type FireFunction = (element: Document | Element | Window | Node, event: Event) => boolean;
+export type FireObject = {
+    [K in EventType]: (element: Document | Element | Window | Node, options?: {}) => boolean;
+};
+export type CreateObject = {
+    [K in EventType]: (element: Document | Element | Window | Node, options?: {}) => Event;
+};
+
+export const createEvent: CreateObject;
+export const fireEvent: FireFunction & FireObject;

types/get-node-text.d.ts

@@ -0,0 +1 @@
+export function getNodeText(node: HTMLElement): string;

types/get-queries-for-element.d.ts

@@ -0,0 +1,30 @@
+import { Matcher } from './matches';
+import * as queries from './queries';
+
+export type BoundFunction<T> = T extends (
+    attribute: string,
+    element: HTMLElement,
+    text: infer P,
+    options: infer Q,
+) => infer R
+    ? (text: P, options?: Q) => R
+    : T extends (a1: any, text: infer P, options: infer Q, waitForElementOptions: infer W) => infer R
+    ? (text: P, options?: Q, waitForElementOptions?: W) => R
+    : T extends (a1: any, text: infer P, options: infer Q) => infer R
+    ? (text: P, options?: Q) => R
+    : never;
+export type BoundFunctions<T> = { [P in keyof T]: BoundFunction<T[P]> };
+
+export type Query = (
+    container: HTMLElement,
+    ...args: any[]
+) => Error | Promise<HTMLElement[]> | Promise<HTMLElement> | HTMLElement[] | HTMLElement | null;
+
+export interface Queries {
+    [T: string]: Query;
+}
+
+export function getQueriesForElement<T extends Queries = typeof queries>(
+    element: HTMLElement,
+    queriesToBind?: T,
+): BoundFunctions<T>;

types/index.d.ts

@@ -0,0 +1,34 @@
+// Type definitions for @testing-library/dom 7.0
+// Project: https://github.com/testing-library/dom-testing-library
+// Definitions by: Alex Krolick <https://github.com/alexkrolick>
+//                 Kent C Dodds <https://github.com/kentcdodds>
+//                 Sebastian Silbermann <https://github.com/eps1lon>
+//                 Weyert de Boer <https://github.com/weyert>
+//                 Ronald Rey <https://github.com/reyronald>
+//                 Justin Hall <https://github.com/wKovacs64>
+//                 Wesley Tsai <https://github.com/wezleytsai>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 3.1
+
+import { getQueriesForElement } from './get-queries-for-element';
+import * as queries from './queries';
+import * as queryHelpers from './query-helpers';
+
+declare const within: typeof getQueriesForElement;
+export { queries, queryHelpers, within };
+
+export * from './queries';
+export * from './query-helpers';
+export * from './screen';
+export * from './wait';
+export * from './wait-for';
+export * from './wait-for-dom-change';
+export * from './wait-for-element';
+export * from './wait-for-element-to-be-removed';
+export * from './matches';
+export * from './get-node-text';
+export * from './events';
+export * from './get-queries-for-element';
+export * from './pretty-dom';
+export * from './role-helpers';
+export * from './config';

types/matches.d.ts

@@ -0,0 +1,29 @@
+export type MatcherFunction = (content: string, element: HTMLElement) => boolean;
+export type Matcher = string | RegExp | MatcherFunction;
+
+export type NormalizerFn = (text: string) => string;
+
+export interface MatcherOptions {
+    exact?: boolean;
+    /** Use normalizer with getDefaultNormalizer instead */
+    trim?: boolean;
+    /** Use normalizer with getDefaultNormalizer instead */
+    collapseWhitespace?: boolean;
+    normalizer?: NormalizerFn;
+}
+
+export type Match = (
+    textToMatch: string,
+    node: HTMLElement | null,
+    matcher: Matcher,
+    options?: MatcherOptions,
+) => boolean;
+
+export interface DefaultNormalizerOptions {
+    trim?: boolean;
+    collapseWhitespace?: boolean;
+}
+
+export function getDefaultNormalizer(options?: DefaultNormalizerOptions): NormalizerFn;
+
+// N.B. Don't expose fuzzyMatches + matches here: they're not public API

types/pretty-dom.d.ts

@@ -0,0 +1,4 @@
+import { OptionsReceived } from 'pretty-format';
+
+export function prettyDOM(dom?: Element | HTMLDocument, maxLength?: number, options?: OptionsReceived): string | false;
+export function logDOM(dom?: Element | HTMLDocument, maxLength?: number, options?: OptionsReceived): void;

types/queries.d.ts

@@ -0,0 +1,135 @@
+import { Matcher, MatcherOptions } from './matches';
+import { SelectorMatcherOptions } from './query-helpers';
+import { WaitForElementOptions } from './wait-for-element';
+
+export type QueryByBoundAttribute = (
+    container: HTMLElement,
+    id: Matcher,
+    options?: MatcherOptions,
+) => HTMLElement | null;
+
+export type AllByBoundAttribute = (container: HTMLElement, id: Matcher, options?: MatcherOptions) => HTMLElement[];
+
+export type FindAllByBoundAttribute = (
+    container: HTMLElement,
+    id: Matcher,
+    options?: MatcherOptions,
+    waitForElementOptions?: WaitForElementOptions,
+) => Promise<HTMLElement[]>;
+
+export type GetByBoundAttribute = (container: HTMLElement, id: Matcher, options?: MatcherOptions) => HTMLElement;
+
+export type FindByBoundAttribute = (
+    container: HTMLElement,
+    id: Matcher,
+    options?: MatcherOptions,
+    waitForElementOptions?: WaitForElementOptions,
+) => Promise<HTMLElement>;
+
+export type QueryByText = (container: HTMLElement, id: Matcher, options?: SelectorMatcherOptions) => HTMLElement | null;
+
+export type AllByText = (container: HTMLElement, id: Matcher, options?: SelectorMatcherOptions) => HTMLElement[];
+
+export type FindAllByText = (
+    container: HTMLElement,
+    id: Matcher,
+    options?: SelectorMatcherOptions,
+    waitForElementOptions?: WaitForElementOptions,
+) => Promise<HTMLElement[]>;
+
+export type GetByText = (container: HTMLElement, id: Matcher, options?: SelectorMatcherOptions) => HTMLElement;
+
+export type FindByText = (
+    container: HTMLElement,
+    id: Matcher,
+    options?: SelectorMatcherOptions,
+    waitForElementOptions?: WaitForElementOptions,
+) => Promise<HTMLElement>;
+
+export interface ByRoleOptions extends MatcherOptions {
+    /**
+     * If true includes elements in the query set that are usually excluded from
+     * the accessibility tree. `role="none"` or `role="presentation"` are included
+     * in either case.
+     * @default false
+     */
+    hidden?: boolean;
+    /**
+     * Includes every role used in the `role` attribute
+     * For example *ByRole('progressbar', {queryFallbacks: true})` will find <div role="meter progresbar">`.
+     */
+    queryFallbacks?: boolean;
+    /**
+     * Only considers  elements with the specified accessible name.
+     */
+    name?: string | RegExp | ((accessibleName: string, element: Element) => boolean);
+}
+
+export type AllByRole = (container: HTMLElement, role: Matcher, options?: ByRoleOptions) => HTMLElement[];
+
+export type GetByRole = (container: HTMLElement, role: Matcher, options?: ByRoleOptions) => HTMLElement;
+
+export type QueryByRole = (container: HTMLElement, role: Matcher, options?: ByRoleOptions) => HTMLElement | null;
+
+export type FindByRole = (
+    container: HTMLElement,
+    role: Matcher,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForElementOptions,
+) => Promise<HTMLElement>;
+
+export type FindAllByRole = (
+    container: HTMLElement,
+    role: Matcher,
+    options?: ByRoleOptions,
+    waitForElementOptions?: WaitForElementOptions,
+) => Promise<HTMLElement[]>;
+
+export const getByLabelText: GetByText;
+export const getAllByLabelText: AllByText;
+export const queryByLabelText: QueryByText;
+export const queryAllByLabelText: AllByText;
+export const findByLabelText: FindByText;
+export const findAllByLabelText: FindAllByText;
+export const getByPlaceholderText: GetByBoundAttribute;
+export const getAllByPlaceholderText: AllByBoundAttribute;
+export const queryByPlaceholderText: QueryByBoundAttribute;
+export const queryAllByPlaceholderText: AllByBoundAttribute;
+export const findByPlaceholderText: FindByBoundAttribute;
+export const findAllByPlaceholderText: FindAllByBoundAttribute;
+export const getByText: GetByText;
+export const getAllByText: AllByText;
+export const queryByText: QueryByText;
+export const queryAllByText: AllByText;
+export const findByText: FindByText;
+export const findAllByText: FindAllByText;
+export const getByAltText: GetByBoundAttribute;
+export const getAllByAltText: AllByBoundAttribute;
+export const queryByAltText: QueryByBoundAttribute;
+export const queryAllByAltText: AllByBoundAttribute;
+export const findByAltText: FindByBoundAttribute;
+export const findAllByAltText: FindAllByBoundAttribute;
+export const getByTitle: GetByBoundAttribute;
+export const getAllByTitle: AllByBoundAttribute;
+export const queryByTitle: QueryByBoundAttribute;
+export const queryAllByTitle: AllByBoundAttribute;
+export const findByTitle: FindByBoundAttribute;
+export const findAllByTitle: FindAllByBoundAttribute;
+export const getByDisplayValue: GetByBoundAttribute;
+export const getAllByDisplayValue: AllByBoundAttribute;
+export const queryByDisplayValue: QueryByBoundAttribute;
+export const queryAllByDisplayValue: AllByBoundAttribute;
+export const findByDisplayValue: FindByBoundAttribute;
+export const findAllByDisplayValue: FindAllByBoundAttribute;
+export const getByRole: GetByRole;
+export const getAllByRole: AllByRole;
+export const queryByRole: QueryByRole;
+export const queryAllByRole: AllByRole;
+export const findByRole: FindByRole;
+export const findAllByRole: FindAllByRole;
+export const getByTestId: GetByBoundAttribute;
+export const getAllByTestId: AllByBoundAttribute;
+export const queryByTestId: QueryByBoundAttribute;
+export const queryAllByTestId: AllByBoundAttribute;
+export const findByTestId: FindByBoundAttribute;
+export const findAllByTestId: FindAllByBoundAttribute;