kotlin-react-legacy/react

Package-level declarations

Types

Children

external object Children

Online Documentation

ComponentClass

external interface ComponentClass<in P : Props> : ComponentType , RComponentClassStatics<Props, State, Context<*>?>

ForwardRefExoticComponent

sealed external interface ForwardRefExoticComponent<in P : PropsWithRef<*>> : ExoticComponent , HasDisplayName

HOC

external interface HOC<out P : Props, in R : Props>

PureComponent

abstract external class PureComponent(props: P = definedExternally) : Component<P, S>

RBuilder

interface RBuilder

RBuilderImpl

open class RBuilderImpl : RBuilder

RBuilderMultiple

open class RBuilderMultiple : RBuilderImpl

RBuilderSingle

open class RBuilderSingle : RBuilderImpl

RComponent

abstract class RComponent : Component<P, S>

RComponentClassStatics

external interface RComponentClassStatics?>

RElementBuilder

interface RElementBuilder<out P : Props> : RBuilder

RElementBuilderImpl

open class RElementBuilderImpl<out P : Props>(val attrs: P) : RBuilderImpl, RElementBuilder

Render

typealias Render = RBuilder.() -> Unit

RHandler

typealias RHandler = RElementBuilder.() -> Unit

RPureComponent

abstract class RPureComponent : PureComponent<P, S>

RStatics

open class RStatics, CTX : Context<*>?>(klazz: KClass<C>) : RComponentClassStatics<P, S, CTX>

Usage:

Properties

react

val KClass<out Component<P, *>>.react: ComponentClass

ref

var Props.ref: Ref<*>?

Functions

allOf

fun allOf(vararg hocs: HOC<P, P>): (component: ComponentClass) -> ComponentClass

buildElement

inline fun buildElement(handler: Render): ReactElement<*>

inline fun <T : RBuilder> buildElement(rBuilder: T, handler: T.() -> Unit): ReactElement<*>

buildElements

fun <T : RBuilder> buildElements(builder: T, handler: T.() -> Unit): ReactNode?

child

inline fun > RBuilder.child(noinline handler: RHandler)

cloneElement

external fun cloneElement(element: ReactElement, props: P? = definedExternally, vararg children: ReactNode?): ReactElement

inline fun cloneElement(element: ReactElement, vararg children: ReactNode?, props: P.() -> Unit): ReactElement

createElement

fun createElement(block: Render): ReactElement?

createRef

external fun <T : Any> createRef(): RefObject<T>

fallback

fun SuspenseProps.fallback(handler: Render)

fun fc(func: RBuilder.(props: P) -> Unit): FC

Get function component from func

fun fc(displayName: String, func: RBuilder.(props: P) -> Unit): FC

Get function component from func with displayName

forEachElement

fun Children.forEachElement(children: ReactNode?, handler: (ReactElement<*>) -> Unit)

forwardRef

fun <T : Any, P : PropsWithRef<T>> forwardRef(handler: RBuilder.(P, Ref<T>?) -> Unit): ForwardRefExoticComponent

invoke

operator fun HOC<P, R>.invoke(component: RBuilder.(P) -> Unit): ComponentClass<R>

operator fun HOC<P, R>.invoke(config: Any, component: RBuilder.(P) -> Unit): ComponentClass<R>

LegacyRefCallback

fun <T : Any> LegacyRefCallback(callback: (T?) -> Unit): RefCallback<T>

RBuilder

fun RBuilder(): RBuilder

RElementBuilder

fun RElementBuilder(attrs: P): RElementBuilder

setState

fun <S : State> Component<*, S>.setState(buildState: S.() -> Unit)

useContext

external fun <T> useContext(context: Context<T>): T

useLegacyRefCallback

fun <T : Any> useLegacyRefCallback(vararg dependencies: Any?, callback: (T?) -> Unit): RefCallback<T>