Class UpdateState<State>

State of the current update.

Template: SceneName

Possible scene names

Type Parameters

  • State extends object

    Type that represents the state

Constructors

constructor

Accessors

scene

Methods

delete enter exit get merge rateLimit resetRateLimit set throttle

Constructors

constructor

  • new UpdateState<State extends object>(
        storage: StateService,
        key: string,
        scene: null | string,
        scoped?: boolean,
        customStorage?: StateService,
        customKey?: string,
    ): UpdateState<State>

  • Type Parameters

    • State extends object

    Parameters

    • storage: StateService
    • key: string
    • scene: null | string
    • Optionalscoped: boolean
    • OptionalcustomStorage: StateService
    • OptionalcustomKey: string

    Returns UpdateState<State>

Accessors

scene

  • get scene(): null | string

  • Name of the current scene

    Returns null | string

Methods

delete

  • delete(): Promise<void>

  • Delete the state from the storage

    Returns Promise<void>

enter

  • enter<SceneState extends object, Scene extends Dispatcher<SceneState>>(
        scene: Scene,
        params?: { reset?: boolean; ttl?: number; with?: SceneState },
    ): Promise<void>

  • Enter some scene

    Type Parameters

    Parameters

    • scene: Scene
    • Optionalparams: { reset?: boolean; ttl?: number; with?: SceneState }
      • Optionalreset?: boolean

        If currently in a scoped scene, whether to reset the state

        Default

        true
      • Optionalttl?: number

        TTL for the scene (in seconds)

      • Optionalwith?: SceneState

        Initial state for the scene

        Note that this will only work if the scene uses the same key delegate as this state.

    Returns Promise<void>

exit

  • exit(reset?: boolean): Promise<void>

  • Exit from current scene to the root

    Parameters

    • reset: boolean = true

      Whether to reset scene state (only applicable in case this is a scoped scene)

    Returns Promise<void>

get

  • get(fallback: State | () => State, force?: boolean): Promise<State>

  • Retrieve the state from the storage, falling back to default if not found

    Parameters

    • fallback: State | () => State

      Default state value

    • Optionalforce: boolean

      Whether to ignore cached state (def. false)

    Returns Promise<State>

  • get(fallback?: State | () => State, force?: boolean): Promise<null | State>

  • Retrieve the state from the storage, falling back to default if not found

    Parameters

    • Optionalfallback: State | () => State

      Default state value

    • Optionalforce: boolean

      Whether to ignore cached state (def. false)

    Returns Promise<null | State>

  • get(force?: boolean): Promise<null | State>

  • Retrieve the state from the storage

    Parameters

    • Optionalforce: boolean

      Whether to ignore cached state (def. false)

    Returns Promise<null | State>

merge

  • merge(
        state: Partial<State>,
        params?: {
            fallback?: State | () => State;
            forceLoad?: boolean;
            ttl?: number;
        },
    ): Promise<State>

  • Merge the given object to the current state.

    Note: If the storage currently has no state, then fallback must be provided.

    Basically a shorthand to calling .get(), modifying and then calling .set()

    Parameters

    • state: Partial<State>

      State to be merged

    • params: { fallback?: State | () => State; forceLoad?: boolean; ttl?: number } = {}

    Returns Promise<State>

rateLimit

  • rateLimit(key: string, limit: number, window: number): Promise<[number, number]>

  • Rate limit some handler.

    When the rate limit exceeds, RateLimitError is thrown.

    This is a simple rate-limiting solution that uses the same key as the state. If you need something more sophisticated and/or customizable, you'll have to implement your own rate-limiter.

    Note: key is used to prefix the local key derived using the given key delegate.

    Parameters

    • key: string

      Key of the rate limit

    • limit: number

      Maximum number of requests in window

    • window: number

      Window size in seconds

    Returns Promise<[number, number]>

    Tuple containing the number of remaining and unix time in ms when the user can try again

resetRateLimit

  • resetRateLimit(key: string): Promise<void>

  • Reset the rate limit

    Parameters

    • key: string

      Key of the rate limit

    Returns Promise<void>

set

  • set(state: State, ttl?: number): Promise<void>

  • Set new state to the storage

    Parameters

    • state: State

      New state

    • Optionalttl: number

      TTL for the new state (in seconds)

    Returns Promise<void>

throttle

  • throttle(key: string, limit: number, window: number): Promise<[number, number]>

  • Throttle some handler.

    When the rate limit exceeds, this function waits for it to reset.

    This is a simple wrapper over rateLimit, and follows the same logic.

    Note: key is used to prefix the local key derived using the given key delegate.

    Parameters

    • key: string

      Key of the rate limit

    • limit: number

      Maximum number of requests in window

    • window: number

      Window size in seconds

    Returns Promise<[number, number]>

    Tuple containing the number of remaining and unix time in ms when the user can try again

Settings

Member Visibility

On This Page

Constructors
Accessors
Methods