Skip to main content

mvc

Index

Classes

Functions

Type Aliases

Type Aliases

BaseControllerContext

BaseControllerContext: { params?: unknown; scope: Scope }

Base context for a controller

Type declaration

  • optionalparams?: unknown
  • scope: Scope

BaseService

BaseService: Record<string, any> | (...args: any[]) => any

Base service type which is implemented by controllers

BaseViewModel

BaseViewModel: Record<string, unknown> & { props?: Record<string, Atom<unknown>>; state?: Record<string, Atom<unknown>> }

Controller

Controller<TService>: TService & { destroy: () => void }

Effects and business logic controller.

Implementation of the controller must provide destroy() method. It should be used for closing subscriptions and disposing resources.

@example
type LoggerController = Controller<{
  log: (message: string) => void;
}>;

Type parameters

ControllerClassDeclaration

ControllerClassDeclaration<TContext>: TContext extends ControllerParamsContext<infer TParams> ? { new ControllerClassDeclaration(params: TParams): BaseController<TContext>; new ControllerClassDeclaration(providers: readonly ExtensionParamsProvider[]): BaseController<TContext> } : { new ControllerClassDeclaration(): BaseController<TContext>; new ControllerClassDeclaration(providers: readonly ExtensionParamsProvider[]): BaseController<TContext> }

Base class declaration for controllers

Type parameters

ControllerContext

ControllerContext<TContext>: TContext & { create: any }

Type parameters

ControllerDeclaration

ControllerDeclaration<TContext, TService>: TContext extends ControllerParamsContext<infer TParams> ? { new ControllerDeclaration(params: TParams): Controller<TService>; new ControllerDeclaration(providers: readonly ExtensionParamsProvider[]): Controller<TService> } : { new ControllerDeclaration(): Controller<TService>; new ControllerDeclaration(providers: readonly ExtensionParamsProvider[]): Controller<TService> }

Base declaration for a controller

Type parameters

ControllerFactory

ControllerFactory<TContext, TService>: (context: ControllerContext<TContext>) => PartialController<TService> | undefined | void

Factory function for a controller

Type parameters

Type declaration

    • (context: ControllerContext<TContext>): PartialController<TService> | undefined | void

    • Parameters

      Returns PartialController<TService> | undefined | void

ControllerParams

ControllerParams: Record<string, unknown>

Parameters for a controller

ControllerParamsContext

ControllerParamsContext<TParams>: BaseControllerContext & { params: TParams }

Context with parameters for a controller

Type parameters

ExtensionFn

ExtensionFn<TSourceContext, TContextExtension>: (sourceContext: TSourceContext, extensionParams?: ExtensionParams) => TSourceContext & TContextExtension

Extension function for a controller

It extends a controller context with additional data

@returns

The extended context

Type parameters

Type declaration

    • (sourceContext: TSourceContext, extensionParams?: ExtensionParams): TSourceContext & TContextExtension

    • Parameters

      • sourceContext: TSourceContext

        The source context

      • optionalextensionParams: ExtensionParams

        Additional parameters for the extension

      Returns TSourceContext & TContextExtension

ExtensionParams

ExtensionParams: Record<string, any>

Parameters for an extension

ExtensionParamsProvider

ExtensionParamsProvider: (params: ExtensionParams) => ExtensionParams

Provider for arbitrary extension parameters

It extends extension parameters with additional data and returns them. An extension can use this data during creation of a controller context.

Type declaration

InferViewPropsFromControllerContext

InferViewPropsFromControllerContext<TContext, ElseType>: TContext extends ViewControllerContext<infer InferredProps> ? InferredProps : ElseType

Utility type to infer the view props from the controller context

Type parameters

ViewBinding

ViewBinding<TProps>: { onMount: Signal<void>; onUnmount: Signal<void>; onUpdate: Signal<Partial<TProps>>; props: ViewPropAtoms<TProps>; status: Atom<ViewStatus> }

ViewBinding is the binding between the controller and the view

Type parameters

Type declaration

  • readonlyonMount: Signal<void>

    Signals that the view has been mounted

  • readonlyonUnmount: Signal<void>

    Signals that the view has been unmounted.

  • readonlyonUpdate: Signal<Partial<TProps>>

    Signals that the view has been updated.

    Partial

    <TProps>
    is the properties that were updated.

  • readonlyprops: ViewPropAtoms<TProps>

    View's props

  • readonlystatus: Atom<ViewStatus>

ViewControllerContext

ViewControllerContext<TProps>: BaseControllerContext & { view: ViewBinding<TProps> }

ViewControllerContext is the context with the view binding that is provided to the controller

Type parameters

ViewModel

ViewModel<T>: T

Type parameters

ViewModelClassDeclaration

ViewModelClassDeclaration<TViewModel, TContext>: { __viewModelType?: TViewModel }

Type parameters

Type declaration

    • new (): BaseViewController<TViewModel, TContext>
    • new (providers: readonly ExtensionParamsProvider[]): BaseViewController<TViewModel, TContext>

    • Returns BaseViewController<TViewModel, TContext>

    • Parameters

      Returns BaseViewController<TViewModel, TContext>

  • optionalreadonly__viewModelType?: TViewModel

ViewModelDeclaration

ViewModelDeclaration<TViewModel, TContext>: { new ViewModelDeclaration(): Controller<TViewModel>; new ViewModelDeclaration(providers: readonly ExtensionParamsProvider[]): Controller<TViewModel> }

Type parameters

Type declaration

ViewModelFactory

ViewModelFactory<TContext, TViewModel>: (context: ControllerContext<TContext>) => Omit<TViewModel, props>

Type parameters

Type declaration

ViewPropAtoms

ViewPropAtoms<TProps>: TProps extends Record<string, never> ? Record<string, never> : Readonly<{ [ K in keyof TProps ]: Atom<TProps[K]> }>

ViewPropAtoms are the atoms wit View's props that are provided to the controller by the ViewBinding

Type parameters

ViewProps

ViewProps: Record<string, unknown>

ViewProps are the properties that are provided to the view

ViewProxy

ViewProxy<TProps>: ViewBinding<TProps> & { destroy: () => void; mount: () => void; unmount: () => void; update: (props?: Partial<TProps>) => void }

ViewProxy implements the binding between the controller and the view.

It can be used to represent a view inside unit tests for the controller.

Type parameters

ViewStatus

ViewStatus: unmounted | mounted | destroyed