@typed/hooks

A self-organizing event-based hooks implementation built using @typed/effects to decouple managing state from any framework in a way that you can still test.

Through hooking into the event's exposed by our environment type HooksManagerEnv, one can build many unique reactive abstractions. For example @typed/render uses this system to provide a self-patching render tree and @typed/html which does quite the same with our own custom virtual-dom that's effect-aware.

Index

Namespaces

InitialState

Enumerations

HookEnvironmentEventType

Interfaces

Type aliases

Variables

TimerChannel

Type aliases

ChannelEnv

ChannelEnv<A>: A extends Channel<infer R, any> ? R : never

Type parameters

ChannelManager

ChannelManager<A>: { useChannelState: <E, B, C>(options: UseChannelStateOptions<E, B, C>, node: A) => ChannelEffects<E, UseChannelState<E, B, C>> }

Type parameters

A: object

Type declaration

Readonly useChannelState: <E, B, C>(options: UseChannelStateOptions<E, B, C>, node: A) => ChannelEffects<E, UseChannelState<E, B, C>>
- - <E, B, C>(options: UseChannelStateOptions<E, B, C>, node: A): ChannelEffects<E, UseChannelState<E, B, C>>
 - Type parameters
 - E
 - B
 - C
 Parameters
 - options: UseChannelStateOptions<E, B, C>
 - node: A
 Returns ChannelEffects<E, UseChannelState<E, B, C>>

ChannelValue

ChannelValue<A>: A extends Channel<any, infer R> ? R : never

Type parameters

HookEnvironmentEvent

HookEnvironmentEvent: Tuple<Created, { created: HookEnvironment; parent: HookEnvironment }> | Tuple<Updated, { hookEnvironment: HookEnvironment; updated: boolean }> | Tuple<Removed, HookEnvironment>

Ref

Ref<A>: { current: Maybe<A> }

Type parameters

Type declaration

current: Maybe<A>

RemoteDataActions

RemoteDataActions<A, B>: { clear: () => PureEffect<RemoteData<A, B>>; failure: (value: A, refreshing: boolean) => PureEffect<RemoteData<A, B>>; loading: () => PureEffect<RemoteData<A, B>>; set: (remoteData: RemoteData<A, B>) => PureEffect<RemoteData<A, B>>; success: (value: B, refreshing: boolean) => PureEffect<RemoteData<A, B>>; update: (updateFn: Arity1<RemoteData<A, B>, RemoteData<A, B>>) => PureEffect<RemoteData<A, B>> }

Type parameters

Type declaration

Readonly clear: () => PureEffect<RemoteData<A, B>>
- - (): PureEffect<RemoteData<A, B>>
 - Returns PureEffect<RemoteData<A, B>>
Readonly failure: (value: A, refreshing: boolean) => PureEffect<RemoteData<A, B>>
- - (value: A, refreshing: boolean): PureEffect<RemoteData<A, B>>
 - Parameters
 - value: A
 - refreshing: boolean
 Returns PureEffect<RemoteData<A, B>>
Readonly loading: () => PureEffect<RemoteData<A, B>>
- - (): PureEffect<RemoteData<A, B>>
 - Returns PureEffect<RemoteData<A, B>>
Readonly set: (remoteData: RemoteData<A, B>) => PureEffect<RemoteData<A, B>>
- - (remoteData: RemoteData<A, B>): PureEffect<RemoteData<A, B>>
 - Parameters
 - remoteData: RemoteData<A, B>
 Returns PureEffect<RemoteData<A, B>>
Readonly success: (value: B, refreshing: boolean) => PureEffect<RemoteData<A, B>>
- - (value: B, refreshing: boolean): PureEffect<RemoteData<A, B>>
 - Parameters
 - value: B
 - refreshing: boolean
 Returns PureEffect<RemoteData<A, B>>
Readonly update: (updateFn: Arity1<RemoteData<A, B>, RemoteData<A, B>>) => PureEffect<RemoteData<A, B>>
- - (updateFn: Arity1<RemoteData<A, B>, RemoteData<A, B>>): PureEffect<RemoteData<A, B>>
 - Parameters
 - updateFn: Arity1<RemoteData<A, B>, RemoteData<A, B>>
 Returns PureEffect<RemoteData<A, B>>

UseChannelState

UseChannelState<E, A, B>: keyof [IO<ChannelEffects<E, B>>, (updateFn: Arity1<A, A>) => ChannelEffects<E, B>]

Type parameters

UseChannelStateOptions

UseChannelStateOptions<E, A, B>: { channel: Channel<E, A>; initialState?: InitialState<E, A>; selector?: Arity1<A, B> }

Type parameters

Type declaration

Readonly channel: Channel<E, A>
Optional Readonly initialState?: InitialState<E, A>
Optional Readonly selector?: Arity1<A, B>

UseHttp

UseHttp<A>: keyof [() => PureEffect<RD.RemoteData<Error, A>>, () => PureEffect<Fiber<RD.RemoteData<Error, A>>>, () => PureEffect<RD.RemoteData<Error, A>>]

Type parameters

UseHttpOptions

UseHttpOptions<A, B>: HttpOptions & { fetchType?: "prefer-current" | "prefer-last"; type: Type<A, B> }

Type parameters

UseLenses

UseLenses<A, R>: {}

Type parameters

A
R: Record<string, Lens<A, any>>

Type declaration

UseRef

UseRef<A>: keyof [Ref<A>, Arity1<A | undefined | void | null, void>]

Type parameters

UseState

UseState<A>: keyof [IO<PureEffect<A>>, (updateFn: Arity1<A, A>) => PureEffect<A>]

Type parameters

Variables

Const TimerChannel

TimerChannel: Channel<TimerEnv, Timer> = createChannel<TimerEnv, Timer>(function* () {const { timer } = yield* get<TimerEnv>()return timer})

Functions

createChannel

createChannel<E, A>(defaultValue: () => Effects<E, A>): Channel<E, A>

- Defined in packages/hooks/source/createChannel.ts:4
Type parameters
- E
- A
Parameters
- defaultValue: () => Effects<E, A>
 - - (): Effects<E, A>
 - Returns Effects<E, A>
Returns Channel<E, A>

createChannelManager

createChannelManager<A>(setUpdated: (node: A, updated: boolean) => PureEffect<void>, getAllDescendants: (providers: WeakSet<A>, consumers: WeakMap<A, any>, node: A) => Generator<A, void, any>, getParent: (node: A) => A | undefined): ChannelManager<A>

- Defined in packages/hooks/source/createChannelManager.ts:16
Type parameters
- A: object
Parameters
- setUpdated: (node: A, updated: boolean) => PureEffect<void>
 - - (node: A, updated: boolean): PureEffect<void>
 - Parameters
 - node: A
 - updated: boolean
 Returns PureEffect<void>
- getAllDescendants: (providers: WeakSet<A>, consumers: WeakMap<A, any>, node: A) => Generator<A, void, any>
 - - (providers: WeakSet<A>, consumers: WeakMap<A, any>, node: A): Generator<A, void, any>
 - Parameters
 - providers: WeakSet<A>
 - consumers: WeakMap<A, any>
 - node: A
 Returns Generator<A, void, any>
- getParent: (node: A) => A | undefined
 - - (node: A): A | undefined
 - Parameters
 - node: A
 Returns A | undefined
Returns ChannelManager<A>

createHookEnvironment

createHookEnvironment(manager: HooksManager): HookEnvironment

- Defined in packages/hooks/source/createHookEnvironment.ts:20
Parameters
- manager: HooksManager
Returns HookEnvironment

createHooksManager

createHooksManager(uuidEnv: UuidEnv): HooksManager

- Defined in packages/hooks/source/createHooksManager.ts:20
Parameters
- uuidEnv: UuidEnv
Returns HooksManager

createHooksManagerEnv

createHooksManagerEnv(uuidEnv: UuidEnv): HooksManagerEnv

- Defined in packages/hooks/source/createHooksManagerEnv.ts:8
Parameters
- uuidEnv: UuidEnv
Returns HooksManagerEnv

createTestHookEnvironment

createTestHookEnvironment(uuidEnv: UuidEnv): { timer: VirtualTimer } & HooksManagerEnv & HookEnv

- Defined in packages/hooks/source/createTestHookEnvironment.ts:7
Parameters
- uuidEnv: UuidEnv
Returns { timer: VirtualTimer } & HooksManagerEnv & HookEnv

createTreeManager

createTreeManager<A>(): TreeManager<A>

- Defined in packages/hooks/source/createTreeManager.ts:4
Type parameters
- A: object
Returns TreeManager<A>

createUpdateManager

createUpdateManager<A>(getAllDescendants: (a: A) => Generator<A, any, any>): { hasBeenUpdated: (node: A) => boolean; setUpdated: (node: A, hasBeenUpdated: boolean) => PureEffect<void> }

- Defined in packages/hooks/source/createUpdateManager.ts:4
Type parameters
- A: object
Parameters
- getAllDescendants: (a: A) => Generator<A, any, any>
 - - (a: A): Generator<A, any, any>
 - Parameters
 - a: A
 Returns Generator<A, any, any>
Returns { hasBeenUpdated: (node: A) => boolean; setUpdated: (node: A, hasBeenUpdated: boolean) => PureEffect<void> }
- Readonly hasBeenUpdated: (node: A) => boolean
 - - (node: A): boolean
 - Parameters
 - node: A
 Returns boolean
- Readonly setUpdated: (node: A, hasBeenUpdated: boolean) => PureEffect<void>
 - - (node: A, hasBeenUpdated: boolean): PureEffect<void>
 - Parameters
 - node: A
 - hasBeenUpdated: boolean
 Returns PureEffect<void>

didRefChange

didRefChange<A>(ref: Ref<A>, setRef: (value: A | null | void | undefined) => void, value: A, firstRun: boolean): boolean

- Defined in packages/hooks/source/didRefChange.ts:5
Type parameters
- A
Parameters
- ref: Ref<A>
- setRef: (value: A | null | void | undefined) => void
 - - (value: A | null | void | undefined): void
 - Parameters
 - value: A | null | void | undefined
 Returns void
- value: A
- firstRun: boolean
Returns boolean

Const getEnvironmentByKey

getEnvironmentByKey(key: object): ChannelEffects<HookEnv, HookEnvironment>

- Defined in packages/hooks/source/getEnvironmentByKey.ts:4
Parameters
- key: object
Returns ChannelEffects<HookEnv, HookEnvironment>

getHookEnv

getHookEnv(): HookEffects<unknown, HookEnvironment>

- Defined in packages/hooks/source/getHookEnv.ts:4
Returns HookEffects<unknown, HookEnvironment>

provideChannel

provideChannel<E, A>(channel: Channel<E, A>, initialState?: InitialState<E, A>): ChannelEffects<HookEnv & E, UseChannelState<E, A>>

- Defined in packages/hooks/source/useChannel.ts:39
Used to provided the values of a Channel to itself and all consumers lower in the tree, if any.

Type parameters
- E
- A
Parameters
- channel: Channel<E, A>
- Default value initialState: InitialState<E, A> = channel.defaultValue
Returns ChannelEffects<HookEnv & E, UseChannelState<E, A>>

runWithHooks

runWithHooks<A, B>(effect: HookEffects<A, B>, hookEnvironment: HookEnvironment): Effects<A, B>

- Defined in packages/hooks/source/runWithHooks.ts:5
Type parameters
- A
- B
Parameters
- effect: HookEffects<A, B>
- hookEnvironment: HookEnvironment
Returns Effects<A, B>

useCallback

useCallback<A, B>(fn: Arity1<A, B>, deps: ReadonlyArray<any>): HookEffects<unknown, Arity1<A, B>>

- Defined in packages/hooks/source/useCallback.ts:5
Type parameters
- A
- B
Parameters
- fn: Arity1<A, B>
- deps: ReadonlyArray<any>
Returns HookEffects<unknown, Arity1<A, B>>

useChannel

useChannel<E, A>(channel: Channel<E, A>): ChannelEffects<HookEnv & E, UseChannelState<E, A>>

- Defined in packages/hooks/source/useChannel.ts:29
Used to consume and update the Channels value by a provider higher up in the tree or in the case of no parents the provided environment.

Type parameters
- E
- A
Parameters
- channel: Channel<E, A>
Returns ChannelEffects<HookEnv & E, UseChannelState<E, A>>

useChannelState

useChannelState<E, A, B>(options: UseChannelStateOptions<E, A, B>): ChannelEffects<HookEnv & E, UseChannelState<E, A, B>>

- Defined in packages/hooks/source/useChannel.ts:13
Type parameters
- E
- A
- B
Parameters
- options: UseChannelStateOptions<E, A, B>
Returns ChannelEffects<HookEnv & E, UseChannelState<E, A, B>>

Const useChannelValue

useChannelValue<E, A>(channel: Channel<E, A>): ChannelEffects<HookEnv & E, A>

- Defined in packages/hooks/source/useChannel.ts:59
Type parameters
- E
- A
Parameters
- channel: Channel<E, A>
Returns ChannelEffects<HookEnv & E, A>

useDepChange

useDepChange<A>(dep: A, firstRun?: boolean): HookEffects<unknown, boolean>

- Defined in packages/hooks/source/useDepChange.ts:5
Type parameters
- A
Parameters
- dep: A
- Default value firstRun: boolean = true
Returns HookEffects<unknown, boolean>

useEffect

useEffect<A>(fn: Fn<A, Disposable>, deps: A): ChannelEffects<HookEnv & TimerEnv, Disposable>

- Defined in packages/hooks/source/useEffect.ts:12
Type parameters
- A: keyof any[]
Parameters
- fn: Fn<A, Disposable>
- deps: A
Returns ChannelEffects<HookEnv & TimerEnv, Disposable>

useEffectBy

useEffectBy<A, B, E, C>(values: ReadonlyArray<A>, identify: (a: A) => B, fn: (a: A, index: number, key: B) => HookEffects<E, C>): ChannelEffects<HookEnv & TimerEnv & E, ReadonlyArray<C>>

- Defined in packages/hooks/source/useEffectBy.ts:9
Type parameters
- A
- B: object
- E
- C
Parameters
- values: ReadonlyArray<A>
- identify: (a: A) => B
 - - (a: A): B
 - Parameters
 - a: A
 Returns B
- fn: (a: A, index: number, key: B) => HookEffects<E, C>
 - - (a: A, index: number, key: B): HookEffects<E, C>
 - Parameters
 - a: A
 - index: number
 - key: B
 Returns HookEffects<E, C>
Returns ChannelEffects<HookEnv & TimerEnv & E, ReadonlyArray<C>>

useEffectOnce

useEffectOnce(fn: IO<Disposable>): ChannelEffects<HookEnv & TimerEnv, Disposable>

- Defined in packages/hooks/source/useEffect.ts:32
Parameters
- fn: IO<Disposable>
Returns ChannelEffects<HookEnv & TimerEnv, Disposable>

useJsonRequest

useJsonRequest<A, B>(url: string, options: UseHttpOptions<A, B>): HookEffects<HttpEnv & FiberFailure & Fork & Kill, UseHttp>

- Defined in packages/hooks/source/useJsonRequest.ts:40
Type parameters
- A
- B
Parameters
- url: string
- options: UseHttpOptions<A, B>
Returns HookEffects<HttpEnv & FiberFailure & Fork & Kill, UseHttp>

useLens

useLens<A, B>(__namedParameters: [() => A, (updateFn: Arity1<A, A>) => PureEffect<A>], lens: Lens<A, B>): HookEffects<unknown, UseState>

- Defined in packages/hooks/source/useLens.ts:18
Type parameters
- A
- B
Parameters
- __namedParameters: [() => A, (updateFn: Arity1<A, A>) => PureEffect<A>]
- lens: Lens<A, B>
Returns HookEffects<unknown, UseState>

useLenses

useLenses<A, R>(state: UseState<A>, lenses: R): HookEffects<HooksManagerEnv & TimerEnv, UseLenses<A, R>>

- Defined in packages/hooks/source/useLens.ts:54
Type parameters
- A
- R: Record<string, Lens<A, any>>
Parameters
- state: UseState<A>
- lenses: R
Returns HookEffects<HooksManagerEnv & TimerEnv, UseLenses<A, R>>

useMapChannel

useMapChannel<E, A, B>(fn: Arity1<A, B>, channel: Channel<E, A>): ChannelEffects<HookEnv & E, B>

- Defined in packages/hooks/source/useChannel.ts:50
Used to consume and map over the values in a channel. Will only be marked as updated if the return value of the selector has changed.

Type parameters
- E
- A
- B
Parameters
- fn: Arity1<A, B>
- channel: Channel<E, A>
Returns ChannelEffects<HookEnv & E, B>

useMatches

useMatches<A, B>(value: A, matches: ReadonlyArray<Match<A, B>>): HookEffects<unknown, Maybe>

- Defined in packages/hooks/source/useMatches.ts:7
Type parameters
- A
- B
Parameters
- value: A
- matches: ReadonlyArray<Match<A, B>>
Returns HookEffects<unknown, Maybe>

useMemo

useMemo<E, A, B>(fn: Fn<A, B>, deps: A): HookEffects<E, B>

- Defined in packages/hooks/source/useMemo.ts:7
Type parameters
- E
- A: keyof any[]
- B
Parameters
- fn: Fn<A, B>
- deps: A
Returns HookEffects<E, B>

useMemoEffect

useMemoEffect<E, A, B>(fn: Fn<A, Effects<E, B>>, deps: A): HookEffects<E, B>

- Defined in packages/hooks/source/useMemo.ts:18
Type parameters
- E
- A: keyof any[]
- B
Parameters
- fn: Fn<A, Effects<E, B>>
- deps: A
Returns HookEffects<E, B>

useReduceChannel

useReduceChannel<E, A, B>(reducer: Arity2<A, B, A>, channel: Channel<E, A>): ChannelEffects<HookEnv & E, keyof [IO<ChannelEffects<E, A>>, Arity1<B, ChannelEffects<E, A>>]>

- Defined in packages/hooks/source/useChannel.ts:62
Type parameters
- E
- A
- B
Parameters
- reducer: Arity2<A, B, A>
- channel: Channel<E, A>
Returns ChannelEffects<HookEnv & E, keyof [IO<ChannelEffects<E, A>>, Arity1<B, ChannelEffects<E, A>>]>

useReducer

useReducer<E, A, B>(reducer: Arity2<A, B, A>, seed: InitialState<E, A>): HookEffects<E, keyof [IO<PureEffect<A>>, Arity1<B, PureEffect<A>>]>

- Defined in packages/hooks/source/useReducer.ts:7
Type parameters
- E
- A
- B
Parameters
- reducer: Arity2<A, B, A>
- seed: InitialState<E, A>
Returns HookEffects<E, keyof [IO<PureEffect<A>>, Arity1<B, PureEffect<A>>]>

useRef

useRef<E, A>(initialState?: InitialState<E, A>): HookEffects<E, UseRef<A>>

- Defined in packages/hooks/source/useRef.ts:4
Type parameters
- E
- A
Parameters
- Optional initialState: InitialState<E, A>
Returns HookEffects<E, UseRef<A>>

useRemoteData

useRemoteData<E, A, B>(initial?: InitialState<E, RemoteData<A, B>>): HookEffects<E, keyof [IO<PureEffect<RemoteData<A, B>>>, RemoteDataActions<A, B>]>

- Defined in packages/hooks/source/useRemoteData.ts:27
Type parameters
- E
- A
- B
Parameters
- Default value initial: InitialState<E, RemoteData<A, B>> = InitialState.of(NoData) as InitialState<E,RemoteData<A, B>>
Returns HookEffects<E, keyof [IO<PureEffect<RemoteData<A, B>>>, RemoteDataActions<A, B>]>

useRouter

useRouter<A, B>(routes: ReadonlyArray<Route<any, A>>, scope?: Path): HookEffects<HistoryEnv, Maybe<A>>

- Defined in packages/hooks/source/useRouter.ts:9
Type parameters
- A
- B
Parameters
- routes: ReadonlyArray<Route<any, A>>
- Optional scope: Path
Returns HookEffects<HistoryEnv, Maybe<A>>

useState

useState<E, A>(initialState: InitialState<E, A>): HookEffects<E, UseState<A>>

- Defined in packages/hooks/source/useState.ts:4
Type parameters
- E
- A
Parameters
- initialState: InitialState<E, A>
Returns HookEffects<E, UseState<A>>

useTimer

useTimer(): ChannelEffects<HookEnv & TimerEnv, Timer>

- Defined in packages/hooks/source/useTimer.ts:7
Returns ChannelEffects<HookEnv & TimerEnv, Timer>

@typed/hooks

Index

Namespaces

Enumerations

Interfaces

Type aliases

Variables

Functions

Type aliases

ChannelEnv

Type parameters

A

ChannelManager

Type parameters

A: object

Type declaration

Readonly useChannelState: <E, B, C>(options: UseChannelStateOptions<E, B, C>, node: A) => ChannelEffects<E, UseChannelState<E, B, C>>

Type parameters

E

B

C

Parameters

options: UseChannelStateOptions<E, B, C>

node: A

Returns ChannelEffects<E, UseChannelState<E, B, C>>

ChannelValue

Type parameters

A

HookEnvironmentEvent

Ref

Type parameters

A

Type declaration

current: Maybe<A>

RemoteDataActions

Type parameters

A

B

Type declaration

Readonly clear: () => PureEffect<RemoteData<A, B>>

Returns PureEffect<RemoteData<A, B>>

Readonly failure: (value: A, refreshing: boolean) => PureEffect<RemoteData<A, B>>

Parameters

value: A

refreshing: boolean

Returns PureEffect<RemoteData<A, B>>

Readonly loading: () => PureEffect<RemoteData<A, B>>

Returns PureEffect<RemoteData<A, B>>

Readonly set: (remoteData: RemoteData<A, B>) => PureEffect<RemoteData<A, B>>

Parameters

remoteData: RemoteData<A, B>

Returns PureEffect<RemoteData<A, B>>

Readonly success: (value: B, refreshing: boolean) => PureEffect<RemoteData<A, B>>

Parameters

value: B

refreshing: boolean

Returns PureEffect<RemoteData<A, B>>

Readonly update: (updateFn: Arity1<RemoteData<A, B>, RemoteData<A, B>>) => PureEffect<RemoteData<A, B>>

Parameters

updateFn: Arity1<RemoteData<A, B>, RemoteData<A, B>>

Returns PureEffect<RemoteData<A, B>>

UseChannelState

Type parameters

E

A

B

UseChannelStateOptions

Type parameters

E

A

B

Type declaration

Readonly channel: Channel<E, A>

Optional Readonly initialState?: InitialState<E, A>

Optional Readonly selector?: Arity1<A, B>

UseHttp

Type parameters

A

UseHttpOptions

Type parameters