Secondary

trait Secondary[Ctx, CtxFn[_], _Step <: SubsequentStep[Ctx, CtxFn]] extends Primary[Ctx, _Step]

Linear Supertypes

Primary[Ctx, _Step], AnyRef, Any

Known Subclasses

SecondaryWithRender, Subsequent, Subsequent, Subsequent

Ordering

Alphabetic
By Inheritance

Inherited

Secondary
Primary
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Type Members

final type Step = _Step
Definition Classes
Primary

Abstract Value Members

abstract def next[H](f: (Ctx) => H)(implicit step: Step): Primary._Step.Next[H]
Attributes
protected
Definition Classes
Primary
abstract def self(f: (Ctx) => Any)(implicit step: Step): Primary._Step.Self
Attributes
protected
Definition Classes
Primary

Concrete Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0
Definition Classes
Any
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
final def custom[I, O](hook: CustomHook[I, O])(implicit step: Step, a: Arg[Ctx, I], d: DynamicNextStep[O]): OneOf[Primary._Step.Self, Primary._Step.Next[O]]
Use a custom hook
Use a custom hook
Definition Classes
Primary
final def customBy[O](hook: CtxFn[CustomHook[Unit, O]])(implicit step: Step, d: DynamicNextStep[O]): OneOf[_Step.Self, _Step.Next[O]]
Use a custom hook
final def customBy[O](hook: (Ctx) => CustomHook[Unit, O])(implicit step: Step, d: DynamicNextStep[O]): OneOf[Primary._Step.Self, Primary._Step.Next[O]]
Use a custom hook
Use a custom hook
Definition Classes
Primary
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
final def localLazyVal[A](a: => A)(implicit step: Step): Primary._Step.Next[() => A]
Create a new local lazy val on each render.
Create a new local lazy val on each render.
Definition Classes
Primary
final def localLazyValBy[A](f: CtxFn[A])(implicit step: Step): _Step.Next[() => A]
Create a new local lazy val on each render.
final def localLazyValBy[A](f: (Ctx) => A)(implicit step: Step): Primary._Step.Next[() => A]
Create a new local lazy val on each render.
Create a new local lazy val on each render.
Definition Classes
Primary
final def localVal[A](a: => A)(implicit step: Step): Primary._Step.Next[A]
Create a new local val on each render.
Create a new local val on each render.
Definition Classes
Primary
final def localValBy[A](f: CtxFn[A])(implicit step: Step): _Step.Next[A]
Create a new local val on each render.
final def localValBy[A](f: (Ctx) => A)(implicit step: Step): Primary._Step.Next[A]
Create a new local val on each render.
Create a new local val on each render.
Definition Classes
Primary
final def localVar[A](a: => A)(implicit step: Step): Primary._Step.Next[Var[A]]
Create a new local var on each render.
Create a new local var on each render.
Definition Classes
Primary
final def localVarBy[A](f: CtxFn[A])(implicit step: Step): _Step.Next[Var[A]]
Create a new local var on each render.
final def localVarBy[A](f: (Ctx) => A)(implicit step: Step): Primary._Step.Next[Var[A]]
Create a new local var on each render.
Create a new local var on each render.
Definition Classes
Primary
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
final def unchecked[A](f: => A)(implicit step: Step, d: DynamicNextStep[A]): OneOf[Primary._Step.Self, Primary._Step.Next[A]]
Provides you with a means to do whatever you want without the static guarantees that the normal DSL provides.
Provides you with a means to do whatever you want without the static guarantees that the normal DSL provides. It's up to you to ensure you don't vioalte React's hook rules.
Definition Classes
Primary
final def uncheckedBy[A](f: CtxFn[A])(implicit step: Step, d: DynamicNextStep[A]): OneOf[_Step.Self, _Step.Next[A]]
Provides you with a means to do whatever you want without the static guarantees that the normal DSL provides.
Provides you with a means to do whatever you want without the static guarantees that the normal DSL provides. It's up to you to ensure you don't vioalte React's hook rules.
final def uncheckedBy[A](f: (Ctx) => A)(implicit step: Step, d: DynamicNextStep[A]): OneOf[Primary._Step.Self, Primary._Step.Next[A]]
Provides you with a means to do whatever you want without the static guarantees that the normal DSL provides.
Provides you with a means to do whatever you want without the static guarantees that the normal DSL provides. It's up to you to ensure you don't vioalte React's hook rules.
Definition Classes
Primary
final def useCallback[A](callback: A)(implicit a: UseCallbackArg[A], step: Step): Primary._Step.Next[Reusable[A]]
Returns a memoized callback.
Returns a memoized callback.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usecallback
final def useCallbackBy[A](callback: CtxFn[A])(implicit a: UseCallbackArg[A], step: Step): _Step.Next[Reusable[A]]
Returns a memoized callback.
Returns a memoized callback.
See also
https://reactjs.org/docs/hooks-reference.html#usecallback
final def useCallbackBy[A](callback: (Ctx) => A)(implicit a: UseCallbackArg[A], step: Step): Primary._Step.Next[Reusable[A]]
Returns a memoized callback.
Returns a memoized callback.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usecallback
final def useCallbackWithDeps[D, A](deps: => D)(callback: (D) => A)(implicit a: UseCallbackArg[A], r: Reusability[D], step: Step): Primary._Step.Next[Reusable[A]]
Returns a memoized callback.
Returns a memoized callback.
Pass an inline callback and dependencies. useCallback will return a memoized version of the callback that only changes if one of the dependencies has changed. This is useful when passing callbacks to optimized child components that rely on reference equality to prevent unnecessary renders.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usecallback
final def useCallbackWithDepsBy[D, A](deps: CtxFn[D])(callback: CtxFn[(D) => A])(implicit a: UseCallbackArg[A], r: Reusability[D], step: Step): _Step.Next[Reusable[A]]
Returns a memoized callback.
Returns a memoized callback.
Pass an inline callback and dependencies. useCallback will return a memoized version of the callback that only changes if one of the dependencies has changed. This is useful when passing callbacks to optimized child components that rely on reference equality to prevent unnecessary renders.
See also
https://reactjs.org/docs/hooks-reference.html#usecallback
final def useCallbackWithDepsBy[D, A](deps: (Ctx) => D)(callback: (Ctx) => (D) => A)(implicit a: UseCallbackArg[A], r: Reusability[D], step: Step): Primary._Step.Next[Reusable[A]]
Returns a memoized callback.
Returns a memoized callback.
Pass an inline callback and dependencies. useCallback will return a memoized version of the callback that only changes if one of the dependencies has changed. This is useful when passing callbacks to optimized child components that rely on reference equality to prevent unnecessary renders.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usecallback
final def useContext[A](ctx: Context[A])(implicit step: Step): Primary._Step.Next[A]
Accepts a context object and returns the current context value for that context.
Accepts a context object and returns the current context value for that context. The current context value is determined by the value prop of the nearest <MyContext.Provider> above the calling component in the tree.
When the nearest <MyContext.Provider> above the component updates, this Hook will trigger a rerender with the latest context value passed to that MyContext provider. Even if an ancestor uses React.memo or shouldComponentUpdate, a rerender will still happen starting at the component itself using useContext.
A component calling useContext will always re-render when the context value changes. If re-rendering the component is expensive, you can optimize it by using memoization.
useContext(MyContext) only lets you read the context and subscribe to its changes. You still need a <MyContext.Provider> above in the tree to provide the value for this context.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usecontext
final def useContextBy[A](f: CtxFn[Context[A]])(implicit step: Step): _Step.Next[A]
Accepts a context object and returns the current context value for that context.
Accepts a context object and returns the current context value for that context. The current context value is determined by the value prop of the nearest <MyContext.Provider> above the calling component in the tree.
When the nearest <MyContext.Provider> above the component updates, this Hook will trigger a rerender with the latest context value passed to that MyContext provider. Even if an ancestor uses React.memo or shouldComponentUpdate, a rerender will still happen starting at the component itself using useContext.
A component calling useContext will always re-render when the context value changes. If re-rendering the component is expensive, you can optimize it by using memoization.
useContext(MyContext) only lets you read the context and subscribe to its changes. You still need a <MyContext.Provider> above in the tree to provide the value for this context.
See also
https://reactjs.org/docs/hooks-reference.html#usecontext
final def useContextBy[A](f: (Ctx) => Context[A])(implicit step: Step): Primary._Step.Next[A]
Accepts a context object and returns the current context value for that context.
Accepts a context object and returns the current context value for that context. The current context value is determined by the value prop of the nearest <MyContext.Provider> above the calling component in the tree.
When the nearest <MyContext.Provider> above the component updates, this Hook will trigger a rerender with the latest context value passed to that MyContext provider. Even if an ancestor uses React.memo or shouldComponentUpdate, a rerender will still happen starting at the component itself using useContext.
A component calling useContext will always re-render when the context value changes. If re-rendering the component is expensive, you can optimize it by using memoization.
useContext(MyContext) only lets you read the context and subscribe to its changes. You still need a <MyContext.Provider> above in the tree to provide the value for this context.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usecontext
final def useDebugValue(desc: => Any)(implicit step: Step): Primary._Step.Self
Used to display a label for custom hooks in React DevTools.
Used to display a label for custom hooks in React DevTools.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usedebugvalue
final def useDebugValueBy(f: CtxFn[Any])(implicit step: Step): _Step.Self
Used to display a label for custom hooks in React DevTools.
Used to display a label for custom hooks in React DevTools.
See also
https://reactjs.org/docs/hooks-reference.html#usedebugvalue
final def useDebugValueBy(desc: (Ctx) => Any)(implicit step: Step): Primary._Step.Self
Used to display a label for custom hooks in React DevTools.
Used to display a label for custom hooks in React DevTools.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usedebugvalue
final def useDeferredValue[A](value: CtxFn[A])(implicit step: Step): _Step.Next[A]
Lets you defer updating a part of the UI.
Lets you defer updating a part of the UI.
Annotations
@inline()
See also
https://react.dev/reference/react/useDeferredValue
final def useDeferredValue[A](value: (Ctx) => A)(implicit step: Step): Primary._Step.Next[A]
Lets you defer updating a part of the UI.
Lets you defer updating a part of the UI.
Definition Classes
Primary
See also
https://react.dev/reference/react/useDeferredValue
final def useEffect[A](effect: A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
By default, effects run after every completed render. If you'd only like to execute the effect when your component is mounted, then use useEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useEffectWithDeps.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useEffectBy[A](effect: CtxFn[A])(implicit a: UseEffectArg[A], step: Step): _Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
By default, effects run after every completed render. If you'd only like to execute the effect when your component is mounted, then use useEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useEffectWithDeps.
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useEffectBy[A](effect: (Ctx) => A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
By default, effects run after every completed render. If you'd only like to execute the effect when your component is mounted, then use useEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useEffectWithDeps.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useEffectOnMount[A](effect: A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
This will only execute the effect when your component is mounted.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useEffectOnMountBy[A](effect: CtxFn[A])(implicit a: UseEffectArg[A], step: Step): _Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
This will only execute the effect when your component is mounted.
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useEffectOnMountBy[A](effect: (Ctx) => A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
This will only execute the effect when your component is mounted.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useEffectWithDeps[D, A](deps: => D)(effect: (D) => A)(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): Primary._Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
This will only execute the effect when values in the first argument change.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useEffectWithDepsBy[D, A](deps: CtxFn[D])(effect: CtxFn[(D) => A])(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): _Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
This will only execute the effect when values in the first argument change.
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useEffectWithDepsBy[D, A](deps: (Ctx) => D)(effect: (Ctx) => (D) => A)(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): Primary._Step.Self
The callback passed to useEffect will run after the render is committed to the screen.
The callback passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.
This will only execute the effect when values in the first argument change.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useeffect
final def useForceUpdate(implicit step: Step): Primary._Step.Next[Reusable[Sync[Unit]]]
Provides a Callback that when invoked forces a re-render of your component.
Provides a Callback that when invoked forces a re-render of your component.
Definition Classes
Primary
final def useId(implicit step: Step): Primary._Step.Next[String]
Generates unique IDs that can be passed to accessibility attributes.
Generates unique IDs that can be passed to accessibility attributes.
Definition Classes
Primary
See also
https://react.dev/reference/react/useId
final def useInsertionEffect[A](effect: A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
If you'd only like to execute the effect when your component is mounted, then use useInsertionEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useInsertionEffectWithDeps.
Definition Classes
Primary
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useInsertionEffectBy[A](effect: CtxFn[A])(implicit a: UseEffectArg[A], step: Step): _Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
If you'd only like to execute the effect when your component is mounted, then use useInsertionEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useInsertionEffectWithDeps.
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useInsertionEffectBy[A](effect: (Ctx) => A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
If you'd only like to execute the effect when your component is mounted, then use useInsertionEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useInsertionEffectWithDeps.
Definition Classes
Primary
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useInsertionEffectOnMount[A](effect: A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when your component is mounted.
Definition Classes
Primary
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useInsertionEffectOnMountBy[A](effect: CtxFn[A])(implicit a: UseEffectArg[A], step: Step): _Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when your component is mounted.
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useInsertionEffectOnMountBy[A](effect: (Ctx) => A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when your component is mounted.
Definition Classes
Primary
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useInsertionEffectWithDeps[D, A](deps: => D)(effect: (D) => A)(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when values in the first argument change.
Definition Classes
Primary
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useInsertionEffectWithDepsBy[D, A](deps: CtxFn[D])(effect: CtxFn[(D) => A])(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): _Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when values in the first argument change.
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useInsertionEffectWithDepsBy[D, A](deps: (Ctx) => D)(effect: (Ctx) => (D) => A)(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations, but before any layout Effects fire. Use this to insert styles before any Effects fire that may need to read layout. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when values in the first argument change.
Definition Classes
Primary
See also
https://react.dev/reference/react/useInsertionEffect#useInsertionEffect
final def useLayoutEffect[A](effect: A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
If you'd only like to execute the effect when your component is mounted, then use useLayoutEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useLayoutEffectWithDeps.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useLayoutEffectBy[A](effect: CtxFn[A])(implicit a: UseEffectArg[A], step: Step): _Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
If you'd only like to execute the effect when your component is mounted, then use useLayoutEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useLayoutEffectWithDeps.
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useLayoutEffectBy[A](effect: (Ctx) => A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
If you'd only like to execute the effect when your component is mounted, then use useLayoutEffectOnMount. If you'd only like to execute the effect when certain values have changed, then use useLayoutEffectWithDeps.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useLayoutEffectOnMount[A](effect: A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when your component is mounted.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useLayoutEffectOnMountBy[A](effect: CtxFn[A])(implicit a: UseEffectArg[A], step: Step): _Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when your component is mounted.
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useLayoutEffectOnMountBy[A](effect: (Ctx) => A)(implicit a: UseEffectArg[A], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when your component is mounted.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useLayoutEffectWithDeps[D, A](deps: => D)(effect: (D) => A)(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when values in the first argument change.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useLayoutEffectWithDepsBy[D, A](deps: CtxFn[D])(effect: CtxFn[(D) => A])(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): _Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when values in the first argument change.
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useLayoutEffectWithDepsBy[D, A](deps: (Ctx) => D)(effect: (Ctx) => (D) => A)(implicit a: UseEffectArg[A], r: Reusability[D], step: Step): Primary._Step.Self
The signature is identical to useEffect, but it fires synchronously after all DOM mutations.
The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside useLayoutEffect will be flushed synchronously, before the browser has a chance to paint.
Prefer the standard useEffect when possible to avoid blocking visual updates.
This will only execute the effect when values in the first argument change.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#useLayoutEffect
final def useMemo[D, A](deps: => D)(create: (D) => A)(implicit r: Reusability[D], step: Step): Primary._Step.Next[Reusable[A]]
Returns a memoized value.
Returns a memoized value.
Pass a “create” function and any dependencies. useMemo will only recompute the memoized value when one of the dependencies has changed. This optimization helps to avoid expensive calculations on every render.
Remember that the function passed to useMemo runs during rendering. Don’t do anything there that you wouldn’t normally do while rendering. For example, side effects belong in useEffect, not useMemo.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usememo
final def useMemoBy[D, A](deps: CtxFn[D])(create: CtxFn[(D) => A])(implicit r: Reusability[D], step: Step): _Step.Next[Reusable[A]]
Returns a memoized value.
Returns a memoized value.
Pass a “create” function and any dependencies. useMemo will only recompute the memoized value when one of the dependencies has changed. This optimization helps to avoid expensive calculations on every render.
Remember that the function passed to useMemo runs during rendering. Don’t do anything there that you wouldn’t normally do while rendering. For example, side effects belong in useEffect, not useMemo.
See also
https://reactjs.org/docs/hooks-reference.html#usememo
final def useMemoBy[D, A](deps: (Ctx) => D)(create: (Ctx) => (D) => A)(implicit r: Reusability[D], step: Step): Primary._Step.Next[Reusable[A]]
Returns a memoized value.
Returns a memoized value.
Pass a “create” function and any dependencies. useMemo will only recompute the memoized value when one of the dependencies has changed. This optimization helps to avoid expensive calculations on every render.
Remember that the function passed to useMemo runs during rendering. Don’t do anything there that you wouldn’t normally do while rendering. For example, side effects belong in useEffect, not useMemo.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usememo
final def useReducer[S, A](reducer: (S, A) => S, initialState: => S)(implicit step: Step): Primary._Step.Next[UseReducer[S, A]]
An alternative to useState.
An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method. (If you’re familiar with Redux, you already know how this works.)
useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values or when the next state depends on the previous one. useReducer also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usereducer
final def useReducerBy[S, A](reducer: CtxFn[(S, A) => S], initialState: CtxFn[S])(implicit step: Step): _Step.Next[UseReducer[S, A]]
An alternative to useState.
An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method. (If you’re familiar with Redux, you already know how this works.)
useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values or when the next state depends on the previous one. useReducer also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.
See also
https://reactjs.org/docs/hooks-reference.html#usereducer
final def useReducerBy[S, A](reducer: (Ctx) => (S, A) => S, initialState: (Ctx) => S)(implicit step: Step): Primary._Step.Next[UseReducer[S, A]]
An alternative to useState.
An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method. (If you’re familiar with Redux, you already know how this works.)
useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values or when the next state depends on the previous one. useReducer also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.
Definition Classes
Primary
See also
https://reactjs.org/docs/hooks-reference.html#usereducer
final def useRef[A](initialValue: => A)(implicit step: Step): Primary._Step.Next[UseRef[A]]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useRefBy[A](f: CtxFn[A])(implicit step: Step): _Step.Next[UseRef[A]]
Create a mutable ref that will persist for the full lifetime of the component.
final def useRefBy[A](initialValue: (Ctx) => A)(implicit step: Step): Primary._Step.Next[UseRef[A]]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useRefToAnyVdom(implicit step: Step): Primary._Step.Next[ToAnyVdom]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useRefToJsComponent[F[_], A[_], P1, S1, CT1[-p, +u] <: CtorType[p, u], R <: RawMounted[P0, S0], P0 <: Object, S0 <: Object, CT0[-p, +u] <: CtorType[p, u]](a: WithJsComponentArg[F, A, P1, S1, CT1, R, P0, S0])(implicit step: Step): Primary._Step.Next[WithJsComponent[F, A, P1, S1, CT1, R, P0, S0]]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useRefToJsComponent[P <: Object, S <: Object](implicit step: Step): Primary._Step.Next[ToJsComponent[P, S, RawMounted[P, S]]]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useRefToJsComponentWithMountedFacade[P <: Object, S <: Object, F <: Object](implicit step: Step): Primary._Step.Next[ToJsComponent[P, S, RawMounted[P, S] with F]]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useRefToScalaComponent[P, S, B, CT[-p, +u] <: CtorType[p, u]](c: Component[P, S, B, CT])(implicit step: Step): Primary._Step.Next[WithScalaComponent[P, S, B, CT]]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useRefToScalaComponent[P, S, B](implicit step: Step): Primary._Step.Next[ToScalaComponent[P, S, B]]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useRefToVdom[N <: TopNode](implicit arg0: ClassTag[N], step: Step): Primary._Step.Next[ToVdom[N]]
Create a mutable ref that will persist for the full lifetime of the component.
Create a mutable ref that will persist for the full lifetime of the component.
Definition Classes
Primary
final def useState[S](initialState: => S)(implicit step: Step): Primary._Step.Next[UseState[S]]
Returns a stateful value, and a function to update it.
Returns a stateful value, and a function to update it.
During the initial render, the returned state is the same as the value passed as the first argument (initialState).
During subsequent re-renders, the first value returned by useState will always be the most recent state after applying updates.
Definition Classes
Primary
final def useStateBy[S](initialState: CtxFn[S])(implicit step: Step): _Step.Next[UseState[S]]
Returns a stateful value, and a function to update it.
Returns a stateful value, and a function to update it.
During the initial render, the returned state is the same as the value passed as the first argument (initialState).
During subsequent re-renders, the first value returned by useState will always be the most recent state after applying updates.
final def useStateBy[S](initialState: (Ctx) => S)(implicit step: Step): Primary._Step.Next[UseState[S]]
Returns a stateful value, and a function to update it.
Returns a stateful value, and a function to update it.
During the initial render, the returned state is the same as the value passed as the first argument (initialState).
During subsequent re-renders, the first value returned by useState will always be the most recent state after applying updates.
Definition Classes
Primary
final def useStateWithReuse[S](initialState: => S)(implicit arg0: ClassTag[S], arg1: Reusability[S], step: Step): Primary._Step.Next[UseStateWithReuse[S]]
Returns a stateful value, and a function to update it.
Returns a stateful value, and a function to update it.
During the initial render, the returned state is the same as the value passed as the first argument (initialState).
During subsequent re-renders, the first value returned by useState will always be the most recent state after applying updates.
Definition Classes
Primary
final def useStateWithReuseBy[S](initialState: CtxFn[S])(implicit arg0: ClassTag[S], arg1: Reusability[S], step: Step): _Step.Next[UseStateWithReuse[S]]
Returns a stateful value, and a function to update it.
Returns a stateful value, and a function to update it.
During the initial render, the returned state is the same as the value passed as the first argument (initialState).
During subsequent re-renders, the first value returned by useState will always be the most recent state after applying updates.
final def useStateWithReuseBy[S](initialState: (Ctx) => S)(implicit arg0: ClassTag[S], arg1: Reusability[S], step: Step): Primary._Step.Next[UseStateWithReuse[S]]
Returns a stateful value, and a function to update it.
Returns a stateful value, and a function to update it.
During the initial render, the returned state is the same as the value passed as the first argument (initialState).
During subsequent re-renders, the first value returned by useState will always be the most recent state after applying updates.
Definition Classes
Primary
final def useSyncExternalStore[F[_], A](subscribe: (F[Unit]) => F[F[Unit]], getSnapshot: F[A], getServerSnapshot: UndefOr[F[A]])(implicit F: Sync[F], step: Step): Primary._Step.Next[A]
Lets you subscribe to an external store.
Lets you subscribe to an external store.
Definition Classes
Primary
See also
https://react.dev/reference/react/useSyncExternalStore
final def useSyncExternalStore[F[_], A](subscribe: (F[Unit]) => F[F[Unit]], getSnapshot: F[A])(implicit F: Sync[F], step: Step): Primary._Step.Next[A]
Lets you subscribe to an external store.
Lets you subscribe to an external store.
Definition Classes
Primary
Annotations
@inline()
See also
https://react.dev/reference/react/useSyncExternalStore
final def useSyncExternalStoreBy[F[_], A](subscribe: CtxFn[(F[Unit]) => F[F[Unit]]], getSnapshot: CtxFn[F[A]], getServerSnapshot: UndefOr[CtxFn[F[A]]])(implicit F: Sync[F], step: Step): _Step.Next[A]
Lets you subscribe to an external store.
Lets you subscribe to an external store.
See also
https://react.dev/reference/react/useSyncExternalStore
final def useSyncExternalStoreBy[F[_], A](subscribe: CtxFn[(F[Unit]) => F[F[Unit]]], getSnapshot: CtxFn[F[A]])(implicit F: Sync[F], step: Step): _Step.Next[A]
Lets you subscribe to an external store.
Lets you subscribe to an external store.
Annotations
@inline()
See also
https://react.dev/reference/react/useSyncExternalStore
final def useSyncExternalStoreBy[F[_], A](subscribe: (Ctx) => (F[Unit]) => F[F[Unit]], getSnapshot: (Ctx) => F[A], getServerSnapshot: UndefOr[(Ctx) => F[A]])(implicit F: Sync[F], step: Step): Primary._Step.Next[A]
Lets you subscribe to an external store.
Lets you subscribe to an external store.
Definition Classes
Primary
See also
https://react.dev/reference/react/useSyncExternalStore
final def useSyncExternalStoreBy[F[_], A](subscribe: (Ctx) => (F[Unit]) => F[F[Unit]], getSnapshot: (Ctx) => F[A])(implicit F: Sync[F], step: Step): Primary._Step.Next[A]
Lets you subscribe to an external store.
Lets you subscribe to an external store.
Definition Classes
Primary
Annotations
@inline()
See also
https://react.dev/reference/react/useSyncExternalStore
final def useTransition(implicit step: Step): Primary._Step.Next[UseTransition]
Allows components to avoid undesirable loading states by waiting for content to load before transitioning to the next screen.
Allows components to avoid undesirable loading states by waiting for content to load before transitioning to the next screen. It also allows components to defer slower, data fetching updates until subsequent renders so that more crucial updates can be rendered immediately.
**If some state update causes a component to suspend, that state update should be wrapped in a transition.**
Definition Classes
Primary
See also
https://react.dev/reference/react/useTransition
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()

Packages

Secondary

trait Secondary[Ctx, CtxFn[_], _Step <: SubsequentStep[Ctx, CtxFn]] extends Primary[Ctx, _Step]

Type Members

Abstract Value Members

Concrete Value Members

Inherited from Primary[Ctx, _Step]

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Secondary

trait Secondary[Ctx, CtxFn[_], _Step <: SubsequentStep[Ctx, CtxFn]] extends Primary[Ctx, _Step]

Type Members

Abstract Value Members

Concrete Value Members

Inherited from Primary[Ctx, _Step]

Inherited from AnyRef

Inherited from Any

Ungrouped

Secondary