remos

Type aliases

Comparer

Comparer<T>: "strict" | "shallow" | ((a: T, b: T) => boolean)

Type parameters

T = any

ConcurrentMode

ConcurrentMode: (callback: Function, onCancel?: VoidFunction) => Function

Type declaration

- (callback: Function, onCancel?: VoidFunction): Function
- Parameters
  - callback: Function
  - Optional onCancel: VoidFunction
  Returns Function

FamilyModel

FamilyModel<TProps, TKey>: Model<TProps> & { $data: any; $family: any; $hydrate: any }

Type parameters

TProps: {} = {}
TKey = any

Injector

Injector: (api: ModelApi, props: any) => any

Type declaration

- (api: ModelApi, props: any): any
- Parameters
  - api: ModelApi
  - props: any
  Returns any

MemberModel

MemberModel<T, TKey>: Model<T> & { $key: any; $remove: any }

Type parameters

T: {} = {}
TKey = any

Model

Model<TProps>: { [ key in keyof TProps]: TProps[key] extends (...args: any[]) => any ? TProps[key] extends (...args: infer TArgs) => (model: Model) => infer TResult ? (...args: TArgs) => TResult : TProps[key] : TProps[key] } & ModelApi<TProps>

Type parameters

TProps: {} = AnyProps

ModelSlice

ModelSlice<TProps>: Readonly<TProps> & Notifier<TProps> & Watchable<TProps> & Slicable<TProps>

Type parameters

TProps

Observer

Observer: (args: ObserverArgs) => void

Type declaration

- (args: ObserverArgs): void
- Parameters
  - args: ObserverArgs
  Returns void

Wrapper

Wrapper: (next: Function, model: Model) => Function

Type declaration

- (next: Function, model: Model): Function
- Parameters
  - next: Function
  - model: Model
  Returns Function

Functions

abstract

abstract<TArgs, TResult>(name?: string): (...args: TArgs) => TResult

- Defined in packages/remos/lib/main.ts:1604
Type parameters
- TArgs: any[] = any[]
- TResult = void
Parameters
- Optional name: string
Returns (...args: TArgs) => TResult
- - (...args: TArgs): TResult
  - Parameters
    - Rest ...args: TArgs
    Returns TResult

as

as<T>(value: T): T

- Defined in packages/remos/lib/main.ts:1751
Type parameters
- T
Parameters
- value: T
Returns T

async

async<TData>(): AsyncModel<TData, any[]>
async<TData, TParams>(loader: (context: AsyncModelLoadContext, ...args: TParams) => Promise<TData>, ...initialParams: TParams): AsyncModel<TData, any[]>

- Defined in packages/remos/lib/main.ts:1950
Type parameters
- TData = any
Returns AsyncModel<TData, any[]>
- Defined in packages/remos/lib/main.ts:1950
Type parameters
- TData = any
- TParams: any[] = any[]
Parameters
- loader: (context: AsyncModelLoadContext, ...args: TParams) => Promise<TData>
  - - (context: AsyncModelLoadContext, ...args: TParams): Promise<TData>
    - Parameters
      - context: AsyncModelLoadContext
      - Rest ...args: TParams
      Returns Promise<TData>
- Rest ...initialParams: TParams
Returns AsyncModel<TData, any[]>

create

create<TProps>(props: TProps, key: keyof TProps, compareFn?: Comparer<TProps[keyof TProps]>): FamilyModel<TProps, TProps[keyof TProps]>
create<TProps, TBase>(base: TBase, builder: (base: { [ key in string | number | symbol]: TBase[key] extends Model<T> ? Base<T> : Base<TBase[key]> }) => TProps): Model<TProps>
create<TProps, TBase>(base: TBase, builder: (base: { [ key in string | number | symbol]: TBase[key] extends Model<T> ? Base<T> : Base<TBase[key]> }) => TProps, key: keyof TProps, compareFn?: Comparer<TProps[keyof TProps]>): FamilyModel<TProps, TProps[keyof TProps]>
create<TProps>(props: TProps): Model<TProps>

- Defined in packages/remos/lib/main.ts:772
create a model with specified props

Type parameters
- TProps: {}
Parameters
- props: TProps
- key: keyof TProps
- Optional compareFn: Comparer<TProps[keyof TProps]>
Returns FamilyModel<TProps, TProps[keyof TProps]>
- Defined in packages/remos/lib/main.ts:772
create a model with specified props

Type parameters
- TProps: {}
- TBase: Record<string, {}>
Parameters
- base: TBase
- builder: (base: { [ key in string | number | symbol]: TBase[key] extends Model<T> ? Base<T> : Base<TBase[key]> }) => TProps
  - - (base: { [ key in string | number | symbol]: TBase[key] extends Model<T> ? Base<T> : Base<TBase[key]> }): TProps
    - Parameters
      - base: { [ key in string | number | symbol]: TBase[key] extends Model<T> ? Base<T> : Base<TBase[key]> }
      Returns TProps
Returns Model<TProps>
- Defined in packages/remos/lib/main.ts:772
create a model with specified props

Type parameters
- TProps: {}
- TBase: Record<string, {}>
Parameters
- base: TBase
- builder: (base: { [ key in string | number | symbol]: TBase[key] extends Model<T> ? Base<T> : Base<TBase[key]> }) => TProps
  - - (base: { [ key in string | number | symbol]: TBase[key] extends Model<T> ? Base<T> : Base<TBase[key]> }): TProps
    - Parameters
      - base: { [ key in string | number | symbol]: TBase[key] extends Model<T> ? Base<T> : Base<TBase[key]> }
      Returns TProps
- key: keyof TProps
- Optional compareFn: Comparer<TProps[keyof TProps]>
Returns FamilyModel<TProps, TProps[keyof TProps]>
- Defined in packages/remos/lib/main.ts:772
create a model with specified props

Type parameters
- TProps: {}
Parameters
- props: TProps
Returns Model<TProps>

createCancellable

createCancellable(onCancel?: VoidFunction): Cancellable

- Defined in packages/remos/lib/main.ts:1873
Parameters
- Optional onCancel: VoidFunction
Returns Cancellable

createEmitter

createEmitter(): Emitter

- Defined in packages/remos/lib/main.ts:624
Returns Emitter

debounce

debounce(ms?: number): ConcurrentMode

- Defined in packages/remos/lib/main.ts:1819
Parameters
- ms: number = 0
Returns ConcurrentMode

droppable

droppable(): ConcurrentMode

- Defined in packages/remos/lib/main.ts:1792
Returns ConcurrentMode

inject

inject(injectors: Injector | Injector[]): Injector[]

- Defined in packages/remos/lib/main.ts:1764
register injectors that will inject to the model at the creating phase

Parameters
- injectors: Injector | Injector[]
Returns Injector[]
previously registered injectors

isModel

isModel(value: any): value is Model<AnyProps>

- Defined in packages/remos/lib/main.ts:620
check the value is whether model or not

Parameters
- value: any
Returns value is Model<AnyProps>

of

of<TProps>(props: TProps): Model<TProps>

- Defined in packages/remos/lib/main.ts:1755
Type parameters
- TProps
Parameters
- props: TProps
Returns Model<TProps>

once

once(): ConcurrentMode

- Defined in packages/remos/lib/main.ts:1846
Returns ConcurrentMode

sequential

sequential(afterDone?: boolean): ConcurrentMode

- Defined in packages/remos/lib/main.ts:1770
Parameters
- afterDone: boolean = false
Returns ConcurrentMode

shallowCompare

shallowCompare(a: any, b: any): boolean

- Defined in packages/remos/lib/main.ts:569
Parameters
- a: any
- b: any
Returns boolean

state

state<T>(defaultValue?: T, notifyChange?: boolean): State<T>

- Defined in packages/remos/lib/main.ts:2042
Type parameters
- T
Parameters
- Optional defaultValue: T
- Optional notifyChange: boolean
Returns State<T>

strictCompare

strictCompare(a: any, b: any): boolean

- Defined in packages/remos/lib/main.ts:565
Parameters
- a: any
- b: any
Returns boolean

sync

sync<TData>(model: Task<TData>, defaultValue?: TData): TData
sync<TData>(models: Task<TData>[], defaultValue?: TData[]): TData[]
sync<TData>(models: Set<Task<TData>>, defaultValue?: TData[]): TData[]
sync<TData>(models: Map<any, Task<TData>>, defaultValue?: TData[]): TData[]
sync<TData, TResult>(model: Task<TData>, selector: (data: TData) => TResult, defaultValue?: TResult): TResult
sync<TData, TResult>(models: Task<TData>[], selector: (data: TData[]) => TResult, defaultValue?: TResult): TResult
sync<TData, TResult>(models: Set<Task<TData>>, selector: (data: TData[]) => TResult, defaultValue?: TResult): TResult
sync<TData, TResult>(models: Map<any, Task<TData>>, selector: (data: TData[]) => TResult, defaultValue?: TResult): TResult

- Defined in packages/remos/lib/main.ts:1888
Type parameters
- TData
Parameters
- model: Task<TData>
- Optional defaultValue: TData
Returns TData
- Defined in packages/remos/lib/main.ts:1888
Type parameters
- TData
Parameters
- models: Task<TData>[]
- Optional defaultValue: TData[]
Returns TData[]
- Defined in packages/remos/lib/main.ts:1888
Type parameters
- TData
Parameters
- models: Set<Task<TData>>
- Optional defaultValue: TData[]
Returns TData[]
- Defined in packages/remos/lib/main.ts:1888
Type parameters
- TData
Parameters
- models: Map<any, Task<TData>>
- Optional defaultValue: TData[]
Returns TData[]
- Defined in packages/remos/lib/main.ts:1888
Type parameters
- TData
- TResult
Parameters
- model: Task<TData>
- selector: (data: TData) => TResult
  - - (data: TData): TResult
    - Parameters
      - data: TData
      Returns TResult
- Optional defaultValue: TResult
Returns TResult
- Defined in packages/remos/lib/main.ts:1888
Type parameters
- TData
- TResult
Parameters
- models: Task<TData>[]
- selector: (data: TData[]) => TResult
  - - (data: TData[]): TResult
    - Parameters
      - data: TData[]
      Returns TResult
- Optional defaultValue: TResult
Returns TResult
- Defined in packages/remos/lib/main.ts:1888
Type parameters
- TData
- TResult
Parameters
- models: Set<Task<TData>>
- selector: (data: TData[]) => TResult
  - - (data: TData[]): TResult
    - Parameters
      - data: TData[]
      Returns TResult
- Optional defaultValue: TResult
Returns TResult
- Defined in packages/remos/lib/main.ts:1888
Type parameters
- TData
- TResult
Parameters
- models: Map<any, Task<TData>>
- selector: (data: TData[]) => TResult
  - - (data: TData[]): TResult
    - Parameters
      - data: TData[]
      Returns TResult
- Optional defaultValue: TResult
Returns TResult

throttle

throttle(ms: number): ConcurrentMode

- Defined in packages/remos/lib/main.ts:1858
Parameters
- ms: number
Returns ConcurrentMode

useModel

useModel<TProps>(creator: (create: Create) => TProps, options?: UseModelOptions<TProps>): Model<TProps>
useModel<TProps>(creator: (create: Create) => TProps, update?: (prev: TProps) => Partial<TProps>): Model<TProps>
useModel<T, TProps>(listenable: T, options?: Omit<UseModelOptions<TProps>, "update">): T
useModel(listenable: Listenable[], options?: Omit<UseModelOptions<any>, "update">): void
useModel<T, TResult>(listenable: T, selector: T extends Listenable ? (props: T) => TResult : T extends Record<string, any> ? (allProps: { [ key in string | number | symbol]: T[key] }) => TResult : never, compareFn?: Comparer<any>): TResult
useModel<TProps>(props: TProps): Model<TProps>
useModel<TProps>(props: TProps, update: (prev: TProps) => Partial<TProps>): Model<TProps>

- Defined in packages/remos/lib/main.ts:1612
Type parameters
- TProps: {}
Parameters
- creator: (create: Create) => TProps
  - - (create: Create): TProps
    - Parameters
      - create: Create
      Returns TProps
- Optional options: UseModelOptions<TProps>
Returns Model<TProps>
- Defined in packages/remos/lib/main.ts:1612
Type parameters
- TProps: {}
Parameters
- creator: (create: Create) => TProps
  - - (create: Create): TProps
    - Parameters
      - create: Create
      Returns TProps
- Optional update: (prev: TProps) => Partial<TProps>
  - - (prev: TProps): Partial<TProps>
    - Parameters
      - prev: TProps
      Returns Partial<TProps>
Returns Model<TProps>
- Defined in packages/remos/lib/main.ts:1612
Type parameters
- T: Listenable
- TProps
Parameters
- listenable: T
- Optional options: Omit<UseModelOptions<TProps>, "update">
Returns T
- Defined in packages/remos/lib/main.ts:1612
Parameters
- listenable: Listenable[]
- Optional options: Omit<UseModelOptions<any>, "update">
Returns void
- Defined in packages/remos/lib/main.ts:1612
Type parameters
- T
- TResult
Parameters
- listenable: T
- selector: T extends Listenable ? (props: T) => TResult : T extends Record<string, any> ? (allProps: { [ key in string | number | symbol]: T[key] }) => TResult : never
- Optional compareFn: Comparer<any>
Returns TResult
- Defined in packages/remos/lib/main.ts:1612
Type parameters
- TProps: {}
Parameters
- props: TProps
Returns Model<TProps>
- Defined in packages/remos/lib/main.ts:1612
Type parameters
- TProps: {}
Parameters
- props: TProps
- update: (prev: TProps) => Partial<TProps>
  - - (prev: TProps): Partial<TProps>
    - Parameters
      - prev: TProps
      Returns Partial<TProps>
Returns Model<TProps>

Index

Interfaces

Type aliases

Functions

Type aliases

Comparer

Type parameters

T = any

ConcurrentMode

Type declaration

Parameters

callback: Function

Optional onCancel: VoidFunction

Returns Function

FamilyModel

Type parameters

TProps: {} = {}

TKey = any

Injector

Type declaration

Parameters

api: ModelApi

props: any

Returns any

MemberModel

Type parameters

T: {} = {}

TKey = any

Model

Type parameters

TProps: {} = AnyProps

ModelSlice

Type parameters

TProps

Observer

Type declaration

Parameters

args: ObserverArgs

Returns void

Wrapper

Type declaration

Parameters

next: Function

model: Model

Returns Function

Functions

abstract

Type parameters

TArgs: any[] = any[]

TResult = void

Parameters

Optional name: string

Returns (...args: TArgs) => TResult

Parameters

Rest ...args: TArgs

Returns TResult

as

Type parameters

T

Parameters

value: T

Returns T

async

Type parameters

TData = any

Returns AsyncModel<TData, any[]>

Type parameters

TData = any

TParams: any[] = any[]

Parameters

loader: (context: AsyncModelLoadContext, ...args: TParams) => Promise<TData>

Parameters

context: AsyncModelLoadContext

Rest ...args: TParams

Returns Promise<TData>

Rest ...initialParams: TParams

Returns AsyncModel<TData, any[]>

create

Type parameters

TProps: {}