reactor library

Classes

AriaProps
AriaPropsInterface
Component<P extends Props, S extends State>
Dom
A class that provides namespacing for static DOM component factory methods, much like React.DOM in React JS.
DomProps
DomPropsInterface
JsBackedMap<K, V>
A view into a JavaScript object (jsObject) that conforms to the Dart Map interface. [...]
NoProps
Props
ReactChildrenPropInterface
ReactDOM
ReactElement
Reactor
REACTOR_SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
Seriously, NO. [...]
ReactorComponent
ReactPropsInterface
State
SyntheticClipboardEvent
SyntheticDataTransfer
SyntheticEvent
SyntheticFocusEvent
SyntheticFormEvent
SyntheticKeyboardEvent
SyntheticMouseEvent
SyntheticPointerEvent
SyntheticTouchEvent
SyntheticUIEvent
SyntheticWheelEvent
UbiquitousDomPropsInterface
UiMap
UiMapBase<K, V>
UiProps
Undefined
Skrew Dart, I'll have undefined if I want undefined!

Mixins

UbiquitousDomProps
UiComponentInterface
UiConsumerComponentInterface<T>
UiMapViewMixin<K, V>

Constants

undefined → const Undefined
Skrew Dart, I'll have undefined if I want undefined!
const Undefined()

Properties

useEffect ↔ void Function(void ())
Accepts a function that contains imperative, possibly effectful code. [...]
read / write

Functions

createContext<T>([T defaultValue, Function calculateChangedBits]) → Context<T>
createElement(dynamic component, dynamic props, dynamic children) ReactElement
Fragment([Map backingMap]) NoProps
A common pattern in React is for a component to return multiple elements. Fragments let you group a list of children without adding extra nodes to the DOM.
jsBackingMapOrJsCopy(Map map) → JsMap
Returns a JsMap version of map, which will be either: [...]
StrictMode([Map backingMap]) NoProps
StrictMode is a tool for highlighting potential problems in an application. Like Fragment, StrictMode does not render any visible UI. It activates additional checks and warnings for its descendants.
Suspense([Map backingMap]) → SuspenseProps
Suspense lets components “wait” for something before rendering. [...]
useCallback<T>(dynamic callback(), List dependencies) → dynamic Function()
Returns a memoized callback. [...]
useContext<T>(Context<T> contextType) → T
Accepts a context object (the value returned from createContext) and returns the current context value for that context. The current context value is determined by the value prop of the nearest Context.Provider above the calling component in the tree.
useDebugValue<T>(T value, [dynamic format(T value)]) → void
useDebugValue can be used to display a label for custom hooks in React DevTools.
useImperativeHandle<T, R extends T>(RefObject<T> ref, R init(), [List dependencies]) → void
useImperativeHandle customizes the instance value that is exposed to parent components when using ref. As always, imperative code using refs should be avoided in most cases. useImperativeHandle should be used with forwardRef.
useLayoutEffect(void init(), [List dependencies]) → void
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. [...]
useMemo<T>(T callback(), List dependencies) → T
Returns a memoized value. [...]
useReducer<TState>(Reducer<TState, dynamic> reducer, [TState initalState, TState init(TState initialState)]) → UseReducerObject<TState>
An alternative to useState. Returns the current state paired with a dispatch method. (If you’re familiar with Redux, you already know how this works.) [...]
useRef<T>([T initalValue]) → RefObject
useRef returns a mutable ref object whose .current property is initialized to the passed argument (initialValue). The returned object will persist for the full lifetime of the component.
useState<TState>(TState initalState) → UseStateObject<TState>
Returns a stateful value, and a function to update it. [...]

Typedefs

ClipboardEventCallback(SyntheticEvent event) → dynamic
DomEventCallback(SyntheticEvent event) → dynamic
Factory<TProps extends UiProps>([Map backingMap]) → TProps
FocusEventCallback(SyntheticEvent event) → dynamic
FormEventCallback(SyntheticEvent event) → dynamic
KeyboardEventCallback(SyntheticEvent event) → dynamic
MouseEventCallback(SyntheticMouseEvent event) → dynamic
PointerEventCallback(SyntheticEvent event) → dynamic
TouchEventCallback(SyntheticEvent event) → dynamic
UIEventCallback(SyntheticEvent event) → dynamic
WheelEventCallback(SyntheticEvent event) → dynamic