@mtcute/dispatcher 0.1.0

package/esm/propagation.js

@@ -0,0 +1,23 @@
+/**
+ * Propagation action.
+ *
+ * `Stop`: Stop the propagation of the event through any handler groups
+ * in the current dispatcher. Does not prevent child dispatchers from
+ * being executed.
+ *
+ * `StopChildren`: Stop the propagation of the event through any handler groups
+ * in the current dispatcher, and any of its children. If current dispatcher
+ * is a child, does not prevent from propagating to its siblings.
+ *
+ * `Continue`: Continue propagating the event inside the same handler group.
+ *
+ * `ToScene`: Used after using `state.enter()` to dispatch the update to the scene
+ */
+export var PropagationAction;
+(function (PropagationAction) {
+    PropagationAction["Stop"] = "stop";
+    PropagationAction["StopChildren"] = "stop-children";
+    PropagationAction["Continue"] = "continue";
+    PropagationAction["ToScene"] = "scene";
+})(PropagationAction = PropagationAction || (PropagationAction = {}));
+//# sourceMappingURL=propagation.js.map

package/esm/propagation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"propagation.js","sourceRoot":"","sources":["../../src/propagation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IACzB,kCAAa,CAAA;IACb,mDAA8B,CAAA;IAC9B,0CAAqB,CAAA;IACrB,sCAAiB,CAAA;AACrB,CAAC,EALW,iBAAiB,GAAjB,iBAAiB,KAAjB,iBAAiB,QAK5B","sourcesContent":["/**\n * Propagation action.\n *\n * `Stop`: Stop the propagation of the event through any handler groups\n * in the current dispatcher. Does not prevent child dispatchers from\n * being executed.\n *\n * `StopChildren`: Stop the propagation of the event through any handler groups\n * in the current dispatcher, and any of its children. If current dispatcher\n * is a child, does not prevent from propagating to its siblings.\n *\n * `Continue`: Continue propagating the event inside the same handler group.\n *\n * `ToScene`: Used after using `state.enter()` to dispatch the update to the scene\n */\nexport enum PropagationAction {\n    Stop = 'stop',\n    StopChildren = 'stop-children',\n    Continue = 'continue',\n    ToScene = 'scene',\n}\n"]}

package/esm/state/index.d.ts

@@ -0,0 +1,3 @@
+export * from './key.js';
+export * from './storage.js';
+export * from './update-state.js';

package/esm/state/index.js

@@ -0,0 +1,4 @@
+export * from './key.js';
+export * from './storage.js';
+export * from './update-state.js';
+//# sourceMappingURL=index.js.map

package/esm/state/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/state/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA","sourcesContent":["export * from './key.js'\nexport * from './storage.js'\nexport * from './update-state.js'\n"]}

package/esm/state/key.d.ts

@@ -0,0 +1,23 @@
+import { Chat, MaybeAsync, User } from '@mtcute/client';
+import { CallbackQueryContext, MessageContext } from '../context/index.js';
+/**
+ * Function that determines how the state key is derived.
+ *
+ * The key is additionally prefixed with current scene, if any.
+ *
+ * @param msg  Message or callback from which to derive the key
+ * @param scene  Current scene UID, or `null` if none
+ */
+export type StateKeyDelegate = (upd: MessageContext | CallbackQueryContext | User | Chat) => MaybeAsync<string | null>;
+/**
+ * Default state key delegate.
+ *
+ * Derives key as follows:
+ *  - If private chat, `msg.chat.id`
+ *  - If group chat, `msg.chat.id + '_' + msg.sender.id`
+ *  - If channel, `msg.chat.id`
+ *  - If non-inline callback query:
+ *    - If in private chat (i.e. `upd.chatType === 'user'`), `upd.user.id`
+ *    - If in group/channel/supergroup (i.e. `upd.chatType !== 'user'`), `upd.chatId + '_' + upd.user.id`
+ */
+export declare const defaultStateKeyDelegate: StateKeyDelegate;

package/esm/state/key.js

@@ -0,0 +1,41 @@
+import { assertNever } from '@mtcute/client';
+/**
+ * Default state key delegate.
+ *
+ * Derives key as follows:
+ *  - If private chat, `msg.chat.id`
+ *  - If group chat, `msg.chat.id + '_' + msg.sender.id`
+ *  - If channel, `msg.chat.id`
+ *  - If non-inline callback query:
+ *    - If in private chat (i.e. `upd.chatType === 'user'`), `upd.user.id`
+ *    - If in group/channel/supergroup (i.e. `upd.chatType !== 'user'`), `upd.chatId + '_' + upd.user.id`
+ */
+export const defaultStateKeyDelegate = (upd) => {
+    if ('type' in upd) {
+        // User | Chat
+        return String(upd.id);
+    }
+    if (upd._name === 'new_message') {
+        switch (upd.chat.chatType) {
+            case 'private':
+            case 'bot':
+            case 'channel':
+                return String(upd.chat.id);
+            case 'group':
+            case 'supergroup':
+            case 'gigagroup':
+                return `${upd.chat.id}_${upd.sender.id}`;
+            default:
+                assertNever(upd.chat.chatType);
+        }
+    }
+    if (upd._name === 'callback_query') {
+        if (upd.isInline)
+            return null;
+        if (upd.chatType === 'user')
+            return `${upd.user.id}`;
+        return `${upd.chatId}_${upd.user.id}`;
+    }
+    return null;
+};
+//# sourceMappingURL=key.js.map

package/esm/state/key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","sourceRoot":"","sources":["../../../src/state/key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA0B,MAAM,gBAAgB,CAAA;AAcpE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAqB,CAAC,GAAG,EAAiB,EAAE;IAC5E,IAAI,MAAM,IAAI,GAAG,EAAE;QACf,cAAc;QACd,OAAO,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;KACxB;IAED,IAAI,GAAG,CAAC,KAAK,KAAK,aAAa,EAAE;QAC7B,QAAQ,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE;YACvB,KAAK,SAAS,CAAC;YACf,KAAK,KAAK,CAAC;YACX,KAAK,SAAS;gBACV,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;YAC9B,KAAK,OAAO,CAAC;YACb,KAAK,YAAY,CAAC;YAClB,KAAK,WAAW;gBACZ,OAAO,GAAG,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,CAAA;YAC5C;gBACI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;SACrC;KACJ;IAED,IAAI,GAAG,CAAC,KAAK,KAAK,gBAAgB,EAAE;QAChC,IAAI,GAAG,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAA;QAC7B,IAAI,GAAG,CAAC,QAAQ,KAAK,MAAM;YAAE,OAAO,GAAG,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,CAAA;QAEpD,OAAO,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,CAAA;KACxC;IAED,OAAO,IAAI,CAAA;AACf,CAAC,CAAA","sourcesContent":["import { assertNever, Chat, MaybeAsync, User } from '@mtcute/client'\n\nimport { CallbackQueryContext, MessageContext } from '../context/index.js'\n\n/**\n * Function that determines how the state key is derived.\n *\n * The key is additionally prefixed with current scene, if any.\n *\n * @param msg  Message or callback from which to derive the key\n * @param scene  Current scene UID, or `null` if none\n */\nexport type StateKeyDelegate = (upd: MessageContext | CallbackQueryContext | User | Chat) => MaybeAsync<string | null>\n\n/**\n * Default state key delegate.\n *\n * Derives key as follows:\n *  - If private chat, `msg.chat.id`\n *  - If group chat, `msg.chat.id + '_' + msg.sender.id`\n *  - If channel, `msg.chat.id`\n *  - If non-inline callback query:\n *    - If in private chat (i.e. `upd.chatType === 'user'`), `upd.user.id`\n *    - If in group/channel/supergroup (i.e. `upd.chatType !== 'user'`), `upd.chatId + '_' + upd.user.id`\n */\nexport const defaultStateKeyDelegate: StateKeyDelegate = (upd): string | null => {\n    if ('type' in upd) {\n        // User | Chat\n        return String(upd.id)\n    }\n\n    if (upd._name === 'new_message') {\n        switch (upd.chat.chatType) {\n            case 'private':\n            case 'bot':\n            case 'channel':\n                return String(upd.chat.id)\n            case 'group':\n            case 'supergroup':\n            case 'gigagroup':\n                return `${upd.chat.id}_${upd.sender.id}`\n            default:\n                assertNever(upd.chat.chatType)\n        }\n    }\n\n    if (upd._name === 'callback_query') {\n        if (upd.isInline) return null\n        if (upd.chatType === 'user') return `${upd.user.id}`\n\n        return `${upd.chatId}_${upd.user.id}`\n    }\n\n    return null\n}\n"]}

package/esm/state/storage.d.ts

@@ -0,0 +1,75 @@
+import { MaybeAsync } from '@mtcute/client';
+/**
+ * Interface for FSM storage for the dispatcher.
+ *
+ * All of the officially supported storages already implement
+ * this interface, so you can just re-use it.
+ *
+ * Current scene is a special case of a `string` state,
+ * Most of the time you can just store it the same way
+ * as normal state, prefixing with something like `$current_state_`
+ * (scene name can't start with `$`).
+ * Alternatively, you can store them as simple strings
+ */
+export interface IStateStorage {
+    /**
+     * Retrieve state from the storage
+     *
+     * @param key  Key of the state, as defined by {@link StateKeyDelegate}
+     */
+    getState(key: string): MaybeAsync<unknown>;
+    /**
+     * Save state to the storage
+     *
+     * @param key  Key of the state, as defined by {@link StateKeyDelegate}
+     * @param state  Object representing the state
+     * @param ttl  TTL for the state, in seconds
+     */
+    setState(key: string, state: unknown, ttl?: number): MaybeAsync<void>;
+    /**
+     * Delete state from the storage
+     *
+     * @param key  Key of the state, as defined by {@link StateKeyDelegate}
+     */
+    deleteState(key: string): MaybeAsync<void>;
+    /**
+     * Retrieve the current scene UID from the storage
+     *
+     * @param key  Key of the state, as defined by {@link StateKeyDelegate}
+     */
+    getCurrentScene(key: string): MaybeAsync<string | null>;
+    /**
+     * Change current scene's UID from the storage
+     *
+     * @param key  Key of the state, as defined by {@link StateKeyDelegate}
+     * @param scene  New scene
+     * @param ttl  TTL for the scene, in seconds
+     */
+    setCurrentScene(key: string, scene: string, ttl?: number): MaybeAsync<void>;
+    /**
+     * Delete current scene from the storage, effectively "exiting" to root.
+     *
+     * @param key  Key of the state, as defined by {@link StateKeyDelegate}
+     */
+    deleteCurrentScene(key: string): MaybeAsync<void>;
+    /**
+     * Get information about a rate limit.
+     *
+     * It is recommended that you use sliding window or leaky bucket
+     * to implement rate limiting ([learn more](https://konghq.com/blog/how-to-design-a-scalable-rate-limiting-algorithm/)),
+     *
+     * @param key  Key of the rate limit
+     * @param limit  Maximum number of requests in `window`
+     * @param window  Window size in seconds
+     * @returns  Tuple containing the number of remaining and
+     *   unix time in ms when the user can try again
+     */
+    getRateLimit(key: string, limit: number, window: number): MaybeAsync<[number, number]>;
+    /**
+     * Reset a rate limit.
+     *
+     * @param key  Key of the rate limit
+     */
+    resetRateLimit(key: string): MaybeAsync<void>;
+}
+export declare function isCompatibleStorage(storage: unknown): storage is IStateStorage;

package/esm/state/storage.js

@@ -0,0 +1,13 @@
+export function isCompatibleStorage(storage) {
+    return (typeof storage === 'object' &&
+        storage !== null &&
+        'getState' in storage &&
+        'setState' in storage &&
+        'deleteState' in storage &&
+        'getCurrentScene' in storage &&
+        'setCurrentScene' in storage &&
+        'deleteCurrentScene' in storage &&
+        'getRateLimit' in storage &&
+        'resetRateLimit' in storage);
+}
+//# sourceMappingURL=storage.js.map

package/esm/state/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../src/state/storage.ts"],"names":[],"mappings":"AAmFA,MAAM,UAAU,mBAAmB,CAAC,OAAgB;IAChD,OAAO,CACH,OAAO,OAAO,KAAK,QAAQ;QAC3B,OAAO,KAAK,IAAI;QAChB,UAAU,IAAI,OAAO;QACrB,UAAU,IAAI,OAAO;QACrB,aAAa,IAAI,OAAO;QACxB,iBAAiB,IAAI,OAAO;QAC5B,iBAAiB,IAAI,OAAO;QAC5B,oBAAoB,IAAI,OAAO;QAC/B,cAAc,IAAI,OAAO;QACzB,gBAAgB,IAAI,OAAO,CAC9B,CAAA;AACL,CAAC","sourcesContent":["import { MaybeAsync } from '@mtcute/client'\n\n/**\n * Interface for FSM storage for the dispatcher.\n *\n * All of the officially supported storages already implement\n * this interface, so you can just re-use it.\n *\n * Current scene is a special case of a `string` state,\n * Most of the time you can just store it the same way\n * as normal state, prefixing with something like `$current_state_`\n * (scene name can't start with `$`).\n * Alternatively, you can store them as simple strings\n */\nexport interface IStateStorage {\n    /**\n     * Retrieve state from the storage\n     *\n     * @param key  Key of the state, as defined by {@link StateKeyDelegate}\n     */\n    getState(key: string): MaybeAsync<unknown>\n\n    /**\n     * Save state to the storage\n     *\n     * @param key  Key of the state, as defined by {@link StateKeyDelegate}\n     * @param state  Object representing the state\n     * @param ttl  TTL for the state, in seconds\n     */\n    setState(key: string, state: unknown, ttl?: number): MaybeAsync<void>\n\n    /**\n     * Delete state from the storage\n     *\n     * @param key  Key of the state, as defined by {@link StateKeyDelegate}\n     */\n    deleteState(key: string): MaybeAsync<void>\n\n    /**\n     * Retrieve the current scene UID from the storage\n     *\n     * @param key  Key of the state, as defined by {@link StateKeyDelegate}\n     */\n    getCurrentScene(key: string): MaybeAsync<string | null>\n\n    /**\n     * Change current scene's UID from the storage\n     *\n     * @param key  Key of the state, as defined by {@link StateKeyDelegate}\n     * @param scene  New scene\n     * @param ttl  TTL for the scene, in seconds\n     */\n    setCurrentScene(key: string, scene: string, ttl?: number): MaybeAsync<void>\n\n    /**\n     * Delete current scene from the storage, effectively \"exiting\" to root.\n     *\n     * @param key  Key of the state, as defined by {@link StateKeyDelegate}\n     */\n    deleteCurrentScene(key: string): MaybeAsync<void>\n\n    /**\n     * Get information about a rate limit.\n     *\n     * It is recommended that you use sliding window or leaky bucket\n     * to implement rate limiting ([learn more](https://konghq.com/blog/how-to-design-a-scalable-rate-limiting-algorithm/)),\n     *\n     * @param key  Key of the rate limit\n     * @param limit  Maximum number of requests in `window`\n     * @param window  Window size in seconds\n     * @returns  Tuple containing the number of remaining and\n     *   unix time in ms when the user can try again\n     */\n    getRateLimit(key: string, limit: number, window: number): MaybeAsync<[number, number]>\n\n    /**\n     * Reset a rate limit.\n     *\n     * @param key  Key of the rate limit\n     */\n    resetRateLimit(key: string): MaybeAsync<void>\n}\n\nexport function isCompatibleStorage(storage: unknown): storage is IStateStorage {\n    return (\n        typeof storage === 'object' &&\n        storage !== null &&\n        'getState' in storage &&\n        'setState' in storage &&\n        'deleteState' in storage &&\n        'getCurrentScene' in storage &&\n        'setCurrentScene' in storage &&\n        'deleteCurrentScene' in storage &&\n        'getRateLimit' in storage &&\n        'resetRateLimit' in storage\n    )\n}\n"]}

package/esm/state/update-state.d.ts

@@ -0,0 +1,151 @@
+import { MtcuteError } from '@mtcute/client';
+import type { Dispatcher } from '../dispatcher.js';
+import { IStateStorage } from './storage.js';
+/**
+ * Error thrown by `.rateLimit()`
+ */
+export declare class RateLimitError extends MtcuteError {
+    readonly reset: number;
+    constructor(reset: number);
+}
+/**
+ * State of the current update.
+ *
+ * @template State  Type that represents the state
+ * @template SceneName  Possible scene names
+ */
+export declare class UpdateState<State extends object> {
+    private _key;
+    private _localKey;
+    private _storage;
+    private _scene;
+    private _scoped?;
+    private _cached?;
+    private _localStorage;
+    private _localKeyBase;
+    constructor(storage: IStateStorage, key: string, scene: string | null, scoped?: boolean, customStorage?: IStateStorage, customKey?: string);
+    /** Name of the current scene */
+    get scene(): string | null;
+    private _updateLocalKey;
+    /**
+     * Retrieve the state from the storage, falling back to default
+     * if not found
+     *
+     * @param fallback  Default state value
+     * @param force  Whether to ignore cached state (def. `false`)
+     */
+    get(fallback: State | (() => State), force?: boolean): Promise<State>;
+    /**
+     * Retrieve the state from the storage, falling back to default
+     * if not found
+     *
+     * @param fallback  Default state value
+     * @param force  Whether to ignore cached state (def. `false`)
+     */
+    get(fallback?: State | (() => State), force?: boolean): Promise<State | null>;
+    /**
+     * Retrieve the state from the storage
+     *
+     * @param force  Whether to ignore cached state (def. `false`)
+     */
+    get(force?: boolean): Promise<State | null>;
+    /**
+     * Set new state to the storage
+     *
+     * @param state  New state
+     * @param ttl  TTL for the new state (in seconds)
+     */
+    set(state: State, ttl?: number): Promise<void>;
+    /**
+     * 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()`
+     *
+     * @param state  State to be merged
+     * @param fallback  Default state
+     * @param ttl  TTL for the new state (in seconds)
+     * @param forceLoad  Whether to force load the old state from storage
+     */
+    merge(state: Partial<State>, params?: {
+        fallback?: State | (() => State);
+        ttl?: number;
+        forceLoad?: boolean;
+    }): Promise<State>;
+    /**
+     * Delete the state from the storage
+     */
+    delete(): Promise<void>;
+    /**
+     * Enter some scene
+     */
+    enter<SceneState extends object, Scene extends Dispatcher<SceneState>>(scene: Scene, params?: {
+        /**
+         * Initial state for the scene
+         *
+         * Note that this will only work if the scene uses the same key delegate as this state.
+         */
+        with?: SceneState;
+        /** TTL for the scene (in seconds) */
+        ttl?: number;
+        /**
+         * If currently in a scoped scene, whether to reset the state
+         *
+         * @default  true
+         */
+        reset?: boolean;
+    }): Promise<void>;
+    /**
+     * Exit from current scene to the root
+     *
+     * @param reset
+     *     Whether to reset scene state (only applicable in case this is a scoped scene)
+     */
+    exit(reset?: boolean): Promise<void>;
+    /**
+     * Rate limit some handler.
+     *
+     * When the rate limit exceeds, {@link 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.
+     *
+     * @param key  Key of the rate limit
+     * @param limit  Maximum number of requests in `window`
+     * @param window  Window size in seconds
+     * @returns  Tuple containing the number of remaining and
+     *   unix time in ms when the user can try again
+     */
+    rateLimit(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 {@link rateLimit}, and follows the same logic.
+     *
+     * > **Note**: `key` is used to prefix the local key
+     * > derived using the given key delegate.
+     *
+     * @param key  Key of the rate limit
+     * @param limit  Maximum number of requests in `window`
+     * @param window  Window size in seconds
+     * @returns  Tuple containing the number of remaining and
+     *   unix time in ms when the user can try again
+     */
+    throttle(key: string, limit: number, window: number): Promise<[number, number]>;
+    /**
+     * Reset the rate limit
+     *
+     * @param key  Key of the rate limit
+     */
+    resetRateLimit(key: string): Promise<void>;
+}

package/esm/state/update-state.js

@@ -0,0 +1,206 @@
+/* eslint-disable dot-notation */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { MtArgumentError, MtcuteError } from '@mtcute/client';
+import { sleep } from '@mtcute/client/utils.js';
+/**
+ * Error thrown by `.rateLimit()`
+ */
+export class RateLimitError extends MtcuteError {
+    constructor(reset) {
+        super('You are being rate limited.');
+        this.reset = reset;
+    }
+}
+/**
+ * State of the current update.
+ *
+ * @template State  Type that represents the state
+ * @template SceneName  Possible scene names
+ */
+export class UpdateState {
+    constructor(storage, key, scene, scoped, customStorage, customKey) {
+        this._storage = storage;
+        this._key = key;
+        this._scene = scene;
+        this._scoped = scoped;
+        this._localStorage = customStorage ?? storage;
+        this._localKeyBase = customKey ?? key;
+        this._updateLocalKey();
+    }
+    /** Name of the current scene */
+    get scene() {
+        return this._scene;
+    }
+    _updateLocalKey() {
+        if (!this._scoped)
+            this._localKey = this._localKeyBase;
+        else {
+            this._localKey = this._scene ? this._scene + '_' + this._localKeyBase : this._localKeyBase;
+        }
+    }
+    async get(fallback, force) {
+        if (typeof fallback === 'boolean') {
+            force = fallback;
+            fallback = undefined;
+        }
+        if (!force && this._cached !== undefined) {
+            if (!this._cached && fallback) {
+                return typeof fallback === 'function' ? fallback() : fallback;
+            }
+            return this._cached;
+        }
+        let res = (await this._localStorage.getState(this._localKey));
+        if (!res && fallback) {
+            res = typeof fallback === 'function' ? fallback() : fallback;
+        }
+        this._cached = res;
+        return res;
+    }
+    /**
+     * Set new state to the storage
+     *
+     * @param state  New state
+     * @param ttl  TTL for the new state (in seconds)
+     */
+    async set(state, ttl) {
+        this._cached = state;
+        await this._localStorage.setState(this._localKey, state, ttl);
+    }
+    /**
+     * 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()`
+     *
+     * @param state  State to be merged
+     * @param fallback  Default state
+     * @param ttl  TTL for the new state (in seconds)
+     * @param forceLoad  Whether to force load the old state from storage
+     */
+    async merge(state, params = {}) {
+        const { fallback, ttl, forceLoad } = params;
+        const old = await this.get(forceLoad);
+        if (!old) {
+            if (!fallback) {
+                throw new MtArgumentError('Cannot use merge on empty state without fallback.');
+            }
+            const fallback_ = typeof fallback === 'function' ? fallback() : fallback;
+            await this.set({ ...fallback_, ...state }, ttl);
+        }
+        else {
+            await this.set({ ...old, ...state }, ttl);
+        }
+        // _cached is set by .set()
+        return this._cached;
+    }
+    /**
+     * Delete the state from the storage
+     */
+    async delete() {
+        this._cached = null;
+        await this._localStorage.deleteState(this._localKey);
+    }
+    /**
+     * Enter some scene
+     */
+    async enter(scene, params) {
+        const { with: with_, ttl, reset = true } = params ?? {};
+        if (reset && this._scoped)
+            await this.delete();
+        if (!scene['_scene']) {
+            throw new MtArgumentError('Cannot enter a non-scene Dispatcher');
+        }
+        if (!scene['_parent']) {
+            throw new MtArgumentError('This scene has not been registered');
+        }
+        this._scene = scene['_scene'];
+        this._scoped = scene['_sceneScoped'];
+        this._updateLocalKey();
+        await this._storage.setCurrentScene(this._key, this._scene, ttl);
+        if (with_) {
+            if (scene['_customStateKeyDelegate']) {
+                throw new MtArgumentError('Cannot use `with` parameter when the scene uses a custom state key delegate');
+            }
+            await scene.getState(this._key).set(with_, ttl);
+        }
+    }
+    /**
+     * Exit from current scene to the root
+     *
+     * @param reset
+     *     Whether to reset scene state (only applicable in case this is a scoped scene)
+     */
+    async exit(reset = true) {
+        if (reset && this._scoped)
+            await this.delete();
+        this._scene = null;
+        this._updateLocalKey();
+        await this._storage.deleteCurrentScene(this._key);
+    }
+    /**
+     * Rate limit some handler.
+     *
+     * When the rate limit exceeds, {@link 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.
+     *
+     * @param key  Key of the rate limit
+     * @param limit  Maximum number of requests in `window`
+     * @param window  Window size in seconds
+     * @returns  Tuple containing the number of remaining and
+     *   unix time in ms when the user can try again
+     */
+    async rateLimit(key, limit, window) {
+        const [remaining, reset] = await this._localStorage.getRateLimit(`${key}:${this._localKey}`, limit, window);
+        if (!remaining) {
+            throw new RateLimitError(reset);
+        }
+        return [remaining - 1, reset];
+    }
+    /**
+     * Throttle some handler.
+     *
+     * When the rate limit exceeds, this function waits for it to reset.
+     *
+     * This is a simple wrapper over {@link rateLimit}, and follows the same logic.
+     *
+     * > **Note**: `key` is used to prefix the local key
+     * > derived using the given key delegate.
+     *
+     * @param key  Key of the rate limit
+     * @param limit  Maximum number of requests in `window`
+     * @param window  Window size in seconds
+     * @returns  Tuple containing the number of remaining and
+     *   unix time in ms when the user can try again
+     */
+    async throttle(key, limit, window) {
+        try {
+            return await this.rateLimit(key, limit, window);
+        }
+        catch (e) {
+            if (e instanceof RateLimitError) {
+                await sleep(e.reset - Date.now());
+                return this.throttle(key, limit, window);
+            }
+            throw e;
+        }
+    }
+    /**
+     * Reset the rate limit
+     *
+     * @param key  Key of the rate limit
+     */
+    async resetRateLimit(key) {
+        await this._localStorage.resetRateLimit(`${key}:${this._localKey}`);
+    }
+}
+//# sourceMappingURL=update-state.js.map

package/esm/state/update-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-state.js","sourceRoot":"","sources":["../../../src/state/update-state.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable dot-notation */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MtArgumentError, MtcuteError } from '@mtcute/client'\nimport { sleep } from '@mtcute/client/utils.js'\n\nimport type { Dispatcher } from '../dispatcher.js'\nimport { IStateStorage } from './storage.js'\n\n/**\n * Error thrown by `.rateLimit()`\n */\nexport class RateLimitError extends MtcuteError {\n    constructor(readonly reset: number) {\n        super('You are being rate limited.')\n    }\n}\n\n/**\n * State of the current update.\n *\n * @template State  Type that represents the state\n * @template SceneName  Possible scene names\n */\nexport class UpdateState<State extends object> {\n    private _key: string\n    private _localKey!: string\n\n    private _storage: IStateStorage\n\n    private _scene: string | null\n    private _scoped?: boolean\n    private _cached?: State | null\n\n    private _localStorage: IStateStorage\n    private _localKeyBase: string\n\n    constructor(\n        storage: IStateStorage,\n        key: string,\n        scene: string | null,\n        scoped?: boolean,\n        customStorage?: IStateStorage,\n        customKey?: string,\n    ) {\n        this._storage = storage\n        this._key = key\n        this._scene = scene\n        this._scoped = scoped\n\n        this._localStorage = customStorage ?? storage\n        this._localKeyBase = customKey ?? key\n\n        this._updateLocalKey()\n    }\n\n    /** Name of the current scene */\n    get scene(): string | null {\n        return this._scene\n    }\n\n    private _updateLocalKey(): void {\n        if (!this._scoped) this._localKey = this._localKeyBase\n        else {\n            this._localKey = this._scene ? this._scene + '_' + this._localKeyBase : this._localKeyBase\n        }\n    }\n\n    /**\n     * Retrieve the state from the storage, falling back to default\n     * if not found\n     *\n     * @param fallback  Default state value\n     * @param force  Whether to ignore cached state (def. `false`)\n     */\n    async get(fallback: State | (() => State), force?: boolean): Promise<State>\n\n    /**\n     * Retrieve the state from the storage, falling back to default\n     * if not found\n     *\n     * @param fallback  Default state value\n     * @param force  Whether to ignore cached state (def. `false`)\n     */\n    async get(fallback?: State | (() => State), force?: boolean): Promise<State | null>\n    /**\n     * Retrieve the state from the storage\n     *\n     * @param force  Whether to ignore cached state (def. `false`)\n     */\n    async get(force?: boolean): Promise<State | null>\n    async get(fallback?: State | (() => State) | boolean, force?: boolean): Promise<State | null> {\n        if (typeof fallback === 'boolean') {\n            force = fallback\n            fallback = undefined\n        }\n\n        if (!force && this._cached !== undefined) {\n            if (!this._cached && fallback) {\n                return typeof fallback === 'function' ? fallback() : fallback\n            }\n\n            return this._cached\n        }\n\n        let res = (await this._localStorage.getState(this._localKey)) as State | null\n\n        if (!res && fallback) {\n            res = typeof fallback === 'function' ? fallback() : fallback\n        }\n        this._cached = res\n\n        return res\n    }\n\n    /**\n     * Set new state to the storage\n     *\n     * @param state  New state\n     * @param ttl  TTL for the new state (in seconds)\n     */\n    async set(state: State, ttl?: number): Promise<void> {\n        this._cached = state\n        await this._localStorage.setState(this._localKey, state, ttl)\n    }\n\n    /**\n     * Merge the given object to the current state.\n     *\n     * > **Note**: If the storage currently has no state,\n     * > then `fallback` must be provided.\n     *\n     * Basically a shorthand to calling `.get()`,\n     * modifying and then calling `.set()`\n     *\n     * @param state  State to be merged\n     * @param fallback  Default state\n     * @param ttl  TTL for the new state (in seconds)\n     * @param forceLoad  Whether to force load the old state from storage\n     */\n    async merge(\n        state: Partial<State>,\n        params: {\n            fallback?: State | (() => State)\n            ttl?: number\n            forceLoad?: boolean\n        } = {},\n    ): Promise<State> {\n        const { fallback, ttl, forceLoad } = params\n\n        const old = await this.get(forceLoad)\n\n        if (!old) {\n            if (!fallback) {\n                throw new MtArgumentError('Cannot use merge on empty state without fallback.')\n            }\n\n            const fallback_ = typeof fallback === 'function' ? fallback() : fallback\n\n            await this.set({ ...fallback_, ...state }, ttl)\n        } else {\n            await this.set({ ...old, ...state }, ttl)\n        }\n\n        // _cached is set by .set()\n\n        return this._cached!\n    }\n\n    /**\n     * Delete the state from the storage\n     */\n    async delete(): Promise<void> {\n        this._cached = null\n        await this._localStorage.deleteState(this._localKey)\n    }\n\n    /**\n     * Enter some scene\n     */\n    async enter<SceneState extends object, Scene extends Dispatcher<SceneState>>(\n        scene: Scene,\n        params?: {\n            /**\n             * Initial state for the scene\n             *\n             * Note that this will only work if the scene uses the same key delegate as this state.\n             */\n            with?: SceneState\n\n            /** TTL for the scene (in seconds) */\n            ttl?: number\n\n            /**\n             * If currently in a scoped scene, whether to reset the state\n             *\n             * @default  true\n             */\n            reset?: boolean\n        },\n    ): Promise<void> {\n        const { with: with_, ttl, reset = true } = params ?? {}\n\n        if (reset && this._scoped) await this.delete()\n\n        if (!scene['_scene']) {\n            throw new MtArgumentError('Cannot enter a non-scene Dispatcher')\n        }\n\n        if (!scene['_parent']) {\n            throw new MtArgumentError('This scene has not been registered')\n        }\n\n        this._scene = scene['_scene']\n        this._scoped = scene['_sceneScoped']\n        this._updateLocalKey()\n\n        await this._storage.setCurrentScene(this._key, this._scene, ttl)\n\n        if (with_) {\n            if (scene['_customStateKeyDelegate']) {\n                throw new MtArgumentError('Cannot use `with` parameter when the scene uses a custom state key delegate')\n            }\n\n            await scene.getState(this._key).set(with_, ttl)\n        }\n    }\n\n    /**\n     * Exit from current scene to the root\n     *\n     * @param reset\n     *     Whether to reset scene state (only applicable in case this is a scoped scene)\n     */\n    async exit(reset = true): Promise<void> {\n        if (reset && this._scoped) await this.delete()\n        this._scene = null\n        this._updateLocalKey()\n        await this._storage.deleteCurrentScene(this._key)\n    }\n\n    /**\n     * Rate limit some handler.\n     *\n     * When the rate limit exceeds, {@link RateLimitError} is thrown.\n     *\n     * This is a simple rate-limiting solution that uses\n     * the same key as the state. If you need something more\n     * sophisticated and/or customizable, you'll have to implement\n     * your own rate-limiter.\n     *\n     * > **Note**: `key` is used to prefix the local key\n     * > derived using the given key delegate.\n     *\n     * @param key  Key of the rate limit\n     * @param limit  Maximum number of requests in `window`\n     * @param window  Window size in seconds\n     * @returns  Tuple containing the number of remaining and\n     *   unix time in ms when the user can try again\n     */\n    async rateLimit(key: string, limit: number, window: number): Promise<[number, number]> {\n        const [remaining, reset] = await this._localStorage.getRateLimit(`${key}:${this._localKey}`, limit, window)\n\n        if (!remaining) {\n            throw new RateLimitError(reset)\n        }\n\n        return [remaining - 1, reset]\n    }\n\n    /**\n     * Throttle some handler.\n     *\n     * When the rate limit exceeds, this function waits for it to reset.\n     *\n     * This is a simple wrapper over {@link rateLimit}, and follows the same logic.\n     *\n     * > **Note**: `key` is used to prefix the local key\n     * > derived using the given key delegate.\n     *\n     * @param key  Key of the rate limit\n     * @param limit  Maximum number of requests in `window`\n     * @param window  Window size in seconds\n     * @returns  Tuple containing the number of remaining and\n     *   unix time in ms when the user can try again\n     */\n    async throttle(key: string, limit: number, window: number): Promise<[number, number]> {\n        try {\n            return await this.rateLimit(key, limit, window)\n        } catch (e: unknown) {\n            if (e instanceof RateLimitError) {\n                await sleep(e.reset - Date.now())\n\n                return this.throttle(key, limit, window)\n            }\n\n            throw e\n        }\n    }\n\n    /**\n     * Reset the rate limit\n     *\n     * @param key  Key of the rate limit\n     */\n    async resetRateLimit(key: string): Promise<void> {\n        await this._localStorage.resetRateLimit(`${key}:${this._localKey}`)\n    }\n}\n"]}

package/esm/wizard.d.ts

@@ -0,0 +1,60 @@
+import { MaybeAsync } from '@mtcute/client';
+import { MessageContext } from './context/message.js';
+import { Dispatcher } from './dispatcher.js';
+import { filters } from './filters/index.js';
+import { UpdateState } from './state/update-state.js';
+/**
+ * Action for the wizard scene.
+ *
+ * `Next`: Continue to the next registered step
+ * (or exit, if this is the last step)
+ *
+ * `Stay`: Stay on the same step
+ *
+ * `Exit`: Exit from the wizard scene
+ *
+ * You can also return a `number` to jump to that step
+ */
+export declare enum WizardSceneAction {
+    Next = "next",
+    Stay = "stay",
+    Exit = "exit"
+}
+interface WizardInternalState {
+    $step?: number;
+}
+/**
+ * Wizard is a special type of Dispatcher
+ * that can be used to simplify implementing
+ * step-by-step scenes.
+ */
+export declare class WizardScene<State extends object> extends Dispatcher<State & WizardInternalState> {
+    private _steps;
+    private _defaultState;
+    setDefaultState(defaultState: State): void;
+    /**
+     * Get the total number of registered steps
+     */
+    get totalSteps(): number;
+    /**
+     * Go to the Nth step
+     */
+    goToStep(state: UpdateState<WizardInternalState>, step: number): Promise<void>;
+    /**
+     * Skip N steps
+     */
+    skip(state: UpdateState<WizardInternalState>, count?: number): Promise<void>;
+    /**
+     * Filter that will only pass if the current step is `step`
+     */
+    static onNthStep(step: number): filters.UpdateFilter<any, {}, WizardInternalState>;
+    /**
+     * Filter that will only pass if the current step is the one after last one added
+     */
+    onCurrentStep(): filters.UpdateFilter<any, {}, WizardInternalState>;
+    /**
+     * Add a step to the wizard
+     */
+    addStep(handler: (msg: MessageContext, state: UpdateState<State & WizardInternalState>) => MaybeAsync<WizardSceneAction | number>): void;
+}
+export {};