From 9050d36d5763beabb1a642819dd24d61cccb3ffe Mon Sep 17 00:00:00 2001
From: Kitson Kelly <me@kitsonkelly.com>
Date: Tue, 17 Mar 2020 23:28:07 +1100
Subject: std: Provide types for React and ReactDOM (#4376)

Introduces `std/types` which is designed to provide types for common
libraries that are compatible with Deno.
---
 std/types/react/prop-types.d.ts | 123 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 std/types/react/prop-types.d.ts

(limited to 'std/types/react/prop-types.d.ts')

diff --git a/std/types/react/prop-types.d.ts b/std/types/react/prop-types.d.ts
new file mode 100644
index 000000000..0bb0e47e9
--- /dev/null
+++ b/std/types/react/prop-types.d.ts
@@ -0,0 +1,123 @@
+// These types are adapted from
+// https://github.com/DefinitelyTyped/DefinitelyTyped to work under Deno.
+//
+// Type definitions for prop-types 15.7
+// Project: https://github.com/reactjs/prop-types, https://facebook.github.io/react
+// Definitions by: DovydasNavickas <https://github.com/DovydasNavickas>
+//                 Ferdy Budhidharma <https://github.com/ferdaber>
+//                 Sebastian Silbermann <https://github.com/eps1lon>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+/* eslint-disable */
+export type ReactComponentLike =
+  | string
+  | ((props: any, context?: any) => any)
+  | (new (props: any, context?: any) => any);
+
+export interface ReactElementLike {
+  type: ReactComponentLike;
+  props: any;
+  key: string | number | null;
+}
+
+export interface ReactNodeArray extends Array<ReactNodeLike> {}
+
+export type ReactNodeLike =
+  | {}
+  | ReactElementLike
+  | ReactNodeArray
+  | string
+  | number
+  | boolean
+  | null
+  | undefined;
+
+export const nominalTypeHack: unique symbol;
+
+export type IsOptional<T> = undefined extends T ? true : false;
+
+export type RequiredKeys<V> = {
+  [K in keyof V]-?: Exclude<V[K], undefined> extends Validator<infer T>
+    ? IsOptional<T> extends true
+      ? never
+      : K
+    : never;
+}[keyof V];
+export type OptionalKeys<V> = Exclude<keyof V, RequiredKeys<V>>;
+export type InferPropsInner<V> = { [K in keyof V]-?: InferType<V[K]> };
+
+export interface Validator<T> {
+  (
+    props: { [key: string]: any },
+    propName: string,
+    componentName: string,
+    location: string,
+    propFullName: string
+  ): Error | null;
+  [nominalTypeHack]?: {
+    type: T;
+  };
+}
+
+export interface Requireable<T> extends Validator<T | undefined | null> {
+  isRequired: Validator<NonNullable<T>>;
+}
+
+export type ValidationMap<T> = { [K in keyof T]?: Validator<T[K]> };
+
+export type InferType<V> = V extends Validator<infer T> ? T : any;
+export type InferProps<V> = InferPropsInner<Pick<V, RequiredKeys<V>>> &
+  Partial<InferPropsInner<Pick<V, OptionalKeys<V>>>>;
+
+export const any: Requireable<any>;
+export const array: Requireable<any[]>;
+export const bool: Requireable<boolean>;
+export const func: Requireable<(...args: any[]) => any>;
+export const number: Requireable<number>;
+export const object: Requireable<object>;
+export const string: Requireable<string>;
+export const node: Requireable<ReactNodeLike>;
+export const element: Requireable<ReactElementLike>;
+export const symbol: Requireable<symbol>;
+export const elementType: Requireable<ReactComponentLike>;
+export function instanceOf<T>(
+  expectedClass: new (...args: any[]) => T
+): Requireable<T>;
+export function oneOf<T>(types: ReadonlyArray<T>): Requireable<T>;
+export function oneOfType<T extends Validator<any>>(
+  types: T[]
+): Requireable<NonNullable<InferType<T>>>;
+export function arrayOf<T>(type: Validator<T>): Requireable<T[]>;
+export function objectOf<T>(
+  type: Validator<T>
+): Requireable<{ [K in keyof any]: T }>;
+export function shape<P extends ValidationMap<any>>(
+  type: P
+): Requireable<InferProps<P>>;
+export function exact<P extends ValidationMap<any>>(
+  type: P
+): Requireable<Required<InferProps<P>>>;
+
+/**
+ * Assert that the values match with the type specs.
+ * Error messages are memorized and will only be shown once.
+ *
+ * @param typeSpecs Map of name to a ReactPropType
+ * @param values Runtime values that need to be type-checked
+ * @param location e.g. "prop", "context", "child context"
+ * @param componentName Name of the component for error messages
+ * @param getStack Returns the component stack
+ */
+export function checkPropTypes(
+  typeSpecs: any,
+  values: any,
+  location: string,
+  componentName: string,
+  getStack?: () => any
+): void;
+
+/**
+ * Only available if NODE_ENV=production
+ */
+export function resetWarningCache(): void;
-- 
cgit v1.2.3