@saber2pr/react/lib/core/react/React.d.ts

react in Typescript.

import { createRenderer } from "../react-reconciler/ReactFiberReconciler";
import { Children as ReactChildren } from "./ReactChildren";
import * as ReactElementType from "../shared/ReactElementType";
import * as ReactContext from "./ReactContext";
import * as ReactStack from "../shared/testStackSize";
import * as ReactMemo from "./memo";
declare namespace React {
    const useCallBack: <T extends Function>(callback: T, deps?: readonly any[]) => T;
    const useMemo: <T>(memoFunc: () => T, deps?: readonly any[]) => T;
    const useReducer: <S, A>(initReducer: (state: S, action: A) => S, initialState: S, initAction?: A) => [S, (action: A) => void];
    const useRef: <T>(value?: T) => ReactElementType.MutableRefObject<T>;
    const useState: <T>(initialState: T) => [T, (state: T) => void];
    const useEffect: (create: import("../shared/ReactTypes").Effect, deps?: readonly any[]) => void;
    const useImperativeHandle: <T, R extends T>(ref: ReactElementType.RefObject<T>, creator: () => R, deps?: readonly any[]) => void;
    const createElement: (tag: any, props: object, ...children: any[]) => import("../shared/ReactTypes").Fiber;
    const Children: typeof ReactChildren;
    const Fragment: symbol;
    const forwardRef: <T extends Object, P extends Object = {}>(FC: ReactElementType.RefForwardingComponent<T, P>) => ({ ref, ...props }: {
        ref: ReactElementType.MutableRefObject<T>;
    } & P) => ReactElementType.ReactElement;
    const lazy: <T extends Object>(lazyComponent: ReactElementType.LazyComponent<T>) => (props: T) => JSX.Element;
    const Suspense: ({ fallback, children }: {
        fallback: JSX.Element;
        children?: JSX.Element;
    }) => JSX.Element;
    const memo: typeof ReactMemo.memo;
    const createContext: typeof ReactContext.createContext;
    const Stack: typeof ReactStack;
}
declare type Override<T, K extends keyof T, V> = {
    [P in keyof T]: P extends K ? V : T[P];
};
declare namespace React {
    export type MutableRefObject<T> = ReactElementType.MutableRefObject<T>;
    export type Props<T> = ReactElementType.Props<T>;
    type ExAttributes<T> = {
        dangerouslySetInnerHTML?: {
            __html: string;
        };
    } & Props<T>;
    export type HTMLAttributes<T extends HTMLElement> = Override<T, "style", CSSProperties> & ExAttributes<T>;
    export type IntrinsicAttributes<T extends HTMLElement> = Partial<HTMLAttributes<T>>;
    export type CSSProperties = Partial<CSSStyleDeclaration>;
    export type FC<T extends Object> = ReactElementType.FC<T>;
    export type ComponentType<T> = FC<T>;
    export type ReactElement = ReactElementType.ReactElement;
    export type RefForwardingComponent<T, P> = ReactElementType.RefForwardingComponent<T, P>;
    export type Consumer<T> = ReactElementType.Consumer<T>;
    export type Provider<T> = ReactElementType.Provider<T>;
    export type ReactContext<T> = ReactElementType.ReactContext<T>;
    export {};
}
declare global {
    namespace JSX {
        type IntrinsicElements = {
            [K in keyof HTMLElementTagNameMap]: React.IntrinsicAttributes<HTMLElementTagNameMap[K]>;
        };
        interface Element extends React.ReactElement {
        }
        interface ElementChildrenAttribute {
            children: {};
        }
        export import RefAttributes = React.MutableRefObject;
    }
}
declare const useCallBack: <T extends Function>(callback: T, deps?: readonly any[]) => T;
declare const useMemo: <T>(memoFunc: () => T, deps?: readonly any[]) => T;
declare const useReducer: <S, A>(initReducer: (state: S, action: A) => S, initialState: S, initAction?: A) => [S, (action: A) => void];
declare const useRef: <T>(value?: T) => ReactElementType.MutableRefObject<T>;
declare const useState: <T>(initialState: T) => [T, (state: T) => void];
declare const useEffect: (create: import("../shared/ReactTypes").Effect, deps?: readonly any[]) => void;
declare const useImperativeHandle: <T, R extends T>(ref: ReactElementType.RefObject<T>, creator: () => R, deps?: readonly any[]) => void;
declare type CSSProperties = React.CSSProperties;
declare type Props<T extends HTMLElement> = React.Props<T>;
declare const Fragment: symbol;
declare const forwardRef: <T extends Object, P extends Object = {}>(FC: ReactElementType.RefForwardingComponent<T, P>) => ({ ref, ...props }: {
    ref: ReactElementType.MutableRefObject<T>;
} & P) => ReactElementType.ReactElement;
declare const lazy: <T extends Object>(lazyComponent: ReactElementType.LazyComponent<T>) => (props: T) => JSX.Element;
declare const Suspense: ({ fallback, children }: {
    fallback: JSX.Element;
    children?: JSX.Element;
}) => JSX.Element;
declare const memo: typeof ReactMemo.memo;
declare const createContext: typeof ReactContext.createContext;
declare const Stack: typeof ReactStack;
export default React;
export { React, useCallBack, useMemo, useReducer, useRef, useState, useEffect, useImperativeHandle, createRenderer, CSSProperties, Props, Fragment, forwardRef, lazy, Suspense, memo, createContext, Stack };