reblok

Type aliases

Actions

Actions<T>: {}

Type parameters

Type declaration

[key: string]: Updater<T, any[]>

ArrayKey

ArrayKey: number

Comparer

Comparer<T>: (a: T, b: T) => boolean

Type parameters

Type declaration

- (a: T, b: T): boolean
- Parameters
  - a: T
  - b: T
  Returns boolean

ConcurrentMode

ConcurrentMode: (context: Record<string, any>, callback: VoidFunction) => ConcurrentController | void

Type declaration

- (context: Record<string, any>, callback: VoidFunction): ConcurrentController | void
- Parameters
  - context: Record<string, any>
  - callback: VoidFunction
  Returns ConcurrentController | void

Data

Data<TData>: TData extends Function ? never : TData | Promise<TData>

Type parameters

TData

DataGroup

DataGroup<TSource>: { [ key in keyof TSource]: TSource[key] extends Blok<infer T> ? T : never }

Type parameters

TSource

DehydratedData

DehydratedData: { data?: any; members?: [any, any][] }

Type declaration

Optional data?: any
Optional members?: [any, any][]

DehydratedDataCollection

DehydratedDataCollection: [any, DehydratedData][]

ExtraActions

ExtraActions<TActions>: { [ key in keyof TActions]: TActions[key] extends Updater<any, infer TParams> ? (...args: TParams) => void : never }

Type parameters

TActions

FieldPath

FieldPath<TFieldValues>: Path<TFieldValues>

Type parameters

TFieldValues: FieldValues

FieldPathValue

FieldPathValue<TFieldValues, TFieldPath>: PathValue<TFieldValues, TFieldPath>

Type parameters

TFieldValues: FieldValues
TFieldPath: FieldPath<TFieldValues>

FieldValues

FieldValues: Record<string, any>

HydrateBlok

HydrateBlok: (blok: Blok) => [boolean, any]

Type declaration

- (blok: Blok): [boolean, any]
- Parameters
  - blok: Blok
  Returns [boolean, any]

IsTuple

IsTuple<T>: number extends T["length"] ? false : true

Type parameters

T: ReadonlyArray<any>

Path

Path<T>: T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? { [ K in TupleKeys<T>]-?: PathImpl<K & string, T[K]> }[TupleKeys<T>] : PathImpl<ArrayKey, V> : { [ K in keyof T]-?: PathImpl<K & string, T[K]> }[keyof T]

Type parameters

PathImpl

PathImpl<K, V>: V extends Primitive ? `${K}` : `${K}` | `${K}.${Path<V>}`

Type parameters

K: string | number
V

PathValue

PathValue<T, P>: T extends any ? P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R> : never : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : never : never : never

Type parameters

T
P: Path<T>

Primitive

Selector

Selector<TSource, TData>: (data: TSource extends Blok<infer T> ? T : DataGroup<TSource>, prev: TData, context: UpdateContext<TData>) => Data<TData>

Type parameters

TSource
TData

Type declaration

- (data: TSource extends Blok<infer T> ? T : DataGroup<TSource>, prev: TData, context: UpdateContext<TData>): Data<TData>
- Parameters
  - data: TSource extends Blok<infer T> ? T : DataGroup<TSource>
  - prev: TData
  - context: UpdateContext<TData>
  Returns Data<TData>

TupleKeys

TupleKeys<T>: Exclude<keyof T, keyof any[]>

Type parameters

T: ReadonlyArray<any>

UpdateData

UpdateData<T>: Promise<T> | T | Updater<T>

Type parameters

Updater

Updater<TData, TParams>: (prev: TData, context: UpdateContext<TData>, ...args: TParams) => Data<TData>

Type parameters

TData
TParams: any[] = []

Type declaration

- (prev: TData, context: UpdateContext<TData>, ...args: TParams): Data<TData>
- Parameters
  - prev: TData
  - context: UpdateContext<TData>
  - Rest ...args: TParams
  Returns Data<TData>

Variables

Const blok

blok: Create = ...

Functions

batch

batch<T>(mutation: T): T

- Defined in packages/reblok/lib/main.ts:35
perform mutation of multiple bloks, when the mutation done, all change notifications are triggered

Type parameters
- T: Function
Parameters
- mutation: T
Returns T

by

by<TItem, TResult>(selector: (item: TItem) => TResult, desc?: boolean): (a: TItem, b: TItem) => 0 | 1 | -1

- Defined in packages/reblok/lib/main.ts:1002
Type parameters
- TItem
- TResult
Parameters
- selector: (item: TItem) => TResult
  - - (item: TItem): TResult
    - Parameters
      - item: TItem
      Returns TResult
- desc: boolean = false
Returns (a: TItem, b: TItem) => 0 | 1 | -1
- - (a: TItem, b: TItem): 0 | 1 | -1
  - Parameters
    - a: TItem
    - b: TItem
    Returns 0 | 1 | -1

create

create<TData, TProps, TActions>(initialData: UpdateData<TData>, options?: BlokOptions<TData, TProps, TActions>): Blok<TData> & TProps & ExtraActions<TActions>

- Defined in packages/reblok/lib/main.ts:238
Type parameters
- TData
- TProps
- TActions: Actions<TData>
Parameters
- initialData: UpdateData<TData>
- Optional options: BlokOptions<TData, TProps, TActions>
Returns Blok<TData> & TProps & ExtraActions<TActions>

createEmitter

createEmitter(): Emitter

- Defined in packages/reblok/lib/main.ts:54
Returns Emitter

debounce

debounce(ms: number): ConcurrentMode

- Defined in packages/reblok/lib/main.ts:138
delay updating in X milliseconds

Parameters
- ms: number
Returns ConcurrentMode

droppable

droppable(): ConcurrentMode

- Defined in packages/reblok/lib/main.ts:145
Returns ConcurrentMode

exclude

exclude<TItem>(predicate: (item: TItem, index: number) => boolean): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:1030
Type parameters
- TItem
Parameters
- predicate: (item: TItem, index: number) => boolean
  - - (item: TItem, index: number): boolean
    - Parameters
      - item: TItem
      - index: number
      Returns boolean
Returns Updater<TItem[]>

family

family<TBlok, TKey>(factory: (key: TKey) => TBlok, options?: FamilyOptions<TKey>): Family<TBlok, TKey>

- Defined in packages/reblok/lib/main.ts:640
Type parameters
- TBlok: Blok<any, TBlok>
- TKey
Parameters
- factory: (key: TKey) => TBlok
  - - (key: TKey): TBlok
    - Parameters
      - key: TKey
      Returns TBlok
- Optional options: FamilyOptions<TKey>
Returns Family<TBlok, TKey>

filter

filter<TItem>(predicate: (item: TItem, index: number) => boolean): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:941
Type parameters
- TItem
Parameters
- predicate: (item: TItem, index: number) => boolean
  - - (item: TItem, index: number): boolean
    - Parameters
      - item: TItem
      - index: number
      Returns boolean
Returns Updater<TItem[]>

from

from<TData, TSource, TProps, TActions>(source: any, selector: Selector<TSource, TData>, options?: LinkedBlokOptions<TData, TProps, TActions>): Blok<TData> & TProps & ExtraActions<TActions>

- Defined in packages/reblok/lib/main.ts:685
Type parameters
- TData
- TSource
- TProps
- TActions: Actions<TData>
Parameters
- source: any
- selector: Selector<TSource, TData>
- Optional options: LinkedBlokOptions<TData, TProps, TActions>
Returns Blok<TData> & TProps & ExtraActions<TActions>

hydrate

hydrate(collection?: DehydratedDataCollection): Hydration

- Defined in packages/reblok/lib/main.ts:776
hydrate adds a previously dehydrated state into a cache. If the bloks included in dehydration already exist in the cache, hydrate does not overwrite them.

Parameters
- Optional collection: DehydratedDataCollection
Returns Hydration

include

include<TItem>(predicate: (item: TItem, index: number) => boolean): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:1028
Type parameters
- TItem
Parameters
- predicate: (item: TItem, index: number) => boolean
  - - (item: TItem, index: number): boolean
    - Parameters
      - item: TItem
      - index: number
      Returns boolean
Returns Updater<TItem[]>

map

map<TItem>(mapper: (item: TItem, index: number) => TItem): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:975
Type parameters
- TItem
Parameters
- mapper: (item: TItem, index: number) => TItem
  - - (item: TItem, index: number): TItem
    - Parameters
      - item: TItem
      - index: number
      Returns TItem
Returns Updater<TItem[]>

order

order<TItem>(...by: ((a: TItem, b: TItem) => number)[]): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:1015
Type parameters
- TItem
Parameters
- Rest ...by: ((a: TItem, b: TItem) => number)[]
Returns Updater<TItem[]>

pop

pop<TItem>(): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:920
Type parameters
- TItem
Returns Updater<TItem[]>

push

push<TItem>(...items: TItem[]): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:913
Type parameters
- TItem
Parameters
- Rest ...items: TItem[]
Returns Updater<TItem[]>

reverse

reverse<TItem>(): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:961
Type parameters
- TItem
Returns Updater<TItem[]>

shallow

shallow(a: any, b: any): any

- Defined in packages/reblok/lib/main.ts:99
Parameters
- a: any
- b: any
Returns any

shift

shift<TItem>(): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:927
Type parameters
- TItem
Returns Updater<TItem[]>

slice

slice<TItem>(start?: number, end?: number): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:968
Type parameters
- TItem
Parameters
- Optional start: number
- Optional end: number
Returns Updater<TItem[]>

sort

sort<TItem>(compare?: (a: TItem, b: TItem) => number): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:952
Type parameters
- TItem
Parameters
- Optional compare: (a: TItem, b: TItem) => number
  - - (a: TItem, b: TItem): number
    - Parameters
      - a: TItem
      - b: TItem
      Returns number
Returns Updater<TItem[]>

splice

splice<TItem>(index: number, remove: number, ...items: TItem[]): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:1036
Type parameters
- TItem
Parameters
- index: number
- remove: number
- Rest ...items: TItem[]
Returns Updater<TItem[]>

swap

swap<TItem>(from: number, to: number): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:992
Type parameters
- TItem
Parameters
- from: number
- to: number
Returns Updater<TItem[]>

throttle

throttle(ms: number): ConcurrentMode

- Defined in packages/reblok/lib/main.ts:165
limit one updating in X milliseconds

Parameters
- ms: number
Returns ConcurrentMode

unshift

unshift<TItem>(...items: TItem[]): Updater<TItem[]>

- Defined in packages/reblok/lib/main.ts:934
Type parameters
- TItem
Parameters
- Rest ...items: TItem[]
Returns Updater<TItem[]>

Index

Interfaces

Type aliases

Variables

Functions

Type aliases

Actions

Type parameters

T

Type declaration

[key: string]: Updater<T, any[]>

ArrayKey

Comparer

Type parameters

T

Type declaration

Parameters

a: T

b: T

Returns boolean

ConcurrentMode

Type declaration

Parameters

context: Record<string, any>

callback: VoidFunction

Returns ConcurrentController | void

Data

Type parameters

TData

DataGroup

Type parameters

TSource

DehydratedData

Type declaration

Optional data?: any

Optional members?: [any, any][]

DehydratedDataCollection

ExtraActions

Type parameters

TActions

FieldPath

Type parameters

TFieldValues: FieldValues

FieldPathValue

Type parameters

TFieldValues: FieldValues

TFieldPath: FieldPath<TFieldValues>

FieldValues

HydrateBlok

Type declaration

Parameters

blok: Blok

Returns [boolean, any]

IsTuple

Type parameters

T: ReadonlyArray<any>

Path

Type parameters

T

PathImpl

Type parameters

K: string | number

V

PathValue

Type parameters

T

P: Path<T>

Primitive

Selector

Type parameters

TSource

TData

Type declaration

Parameters

data: TSource extends Blok<infer T> ? T : DataGroup<TSource>

prev: TData

context: UpdateContext<TData>

Returns Data<TData>

TupleKeys

Type parameters