@mtcute/dispatcher 0.1.1 → 0.2.0

package/cjs/dispatcher.js

@@ -13,11 +13,13 @@ const index_js_1 = require("./state/index.js");
  */
 class Dispatcher {
     constructor(client, params) {
-        this._groups = {};
+        this._groups = new Map();
         this._groupsOrder = [];
         this._children = [];
         this.dispatchRawUpdate = this.dispatchRawUpdate.bind(this);
         this.dispatchUpdate = this.dispatchUpdate.bind(this);
+        this._onClientBeforeConnect = this._onClientBeforeConnect.bind(this);
+        this._onClientBeforeClose = this._onClientBeforeClose.bind(this);
         // eslint-disable-next-line prefer-const
         let { storage, key, sceneName } = params ?? {};
         if (client) {
@@ -72,34 +74,75 @@ class Dispatcher {
     get sceneName() {
         return this._scene;
     }
+    _onClientBeforeConnect() {
+        (async () => {
+            if (!this._parent &&
+                this._storage &&
+                this._storage !== this._client.storage) {
+                // this is a root dispatcher with custom storage
+                await this._storage.load?.();
+            }
+            if (this._parent && this._customStorage) {
+                // this is a child dispatcher with custom storage
+                await this._customStorage.load?.();
+            }
+            for (const child of this._children) {
+                child._onClientBeforeConnect();
+            }
+            if (this._scenes) {
+                for (const scene of this._scenes.values()) {
+                    scene._onClientBeforeConnect();
+                }
+            }
+        })().catch((err) => this._client._emitError(err));
+    }
+    _onClientBeforeClose() {
+        (async () => {
+            if (!this._parent &&
+                this._storage &&
+                this._storage !== this._client.storage) {
+                // this is a root dispatcher with custom storage
+                await this._storage.save?.();
+                await this._storage.destroy?.();
+            }
+            if (this._parent && this._customStorage) {
+                // this is a child dispatcher with custom storage
+                await this._customStorage.save?.();
+                await this._customStorage.destroy?.();
+            }
+            for (const child of this._children) {
+                child._onClientBeforeClose();
+            }
+            if (this._scenes) {
+                for (const scene of this._scenes.values()) {
+                    scene._onClientBeforeClose();
+                }
+            }
+        })().catch((err) => this._client._emitError(err));
+    }
     /**
      * Bind the dispatcher to the client.
      * Called by the constructor automatically if
      * `client` was passed.
      *
-     * Under the hood, this replaces client's `dispatchUpdate`
-     * function, meaning you can't bind two different
-     * dispatchers to the same client at the same time.
-     * Instead, use {@link extend}, {@link addChild}
-     * or {@link addScene} on the existing, already bound dispatcher.
-     *
      * Dispatcher also uses bound client to throw errors
      */
     bindToClient(client) {
         client.on('update', this.dispatchUpdate);
         client.on('raw_update', this.dispatchRawUpdate);
+        client.on('before_connect', this._onClientBeforeConnect);
+        client.on('before_close', this._onClientBeforeClose);
         this._client = client;
     }
     /**
      * Unbind a dispatcher from the client.
-     *
-     * This will replace client's dispatchUpdate with a no-op.
-     * If this dispatcher is not bound, nothing will happen.
      */
     unbind() {
         if (this._client) {
             this._client.off('update', this.dispatchUpdate);
             this._client.off('raw_update', this.dispatchRawUpdate);
+            this._client.off('before_connect', this._onClientBeforeConnect);
+            this._client.off('before_close', this._onClientBeforeClose);
             this._client = undefined;
         }
     }
@@ -137,9 +180,9 @@ class Dispatcher {
             return false;
         let handled = false;
         outer: for (const grp of this._groupsOrder) {
-            const group = this._groups[grp];
-            if ('raw' in group) {
-                const handlers = group.raw;
+            const group = this._groups.get(grp);
+            if (group.has('raw')) {
+                const handlers = group.get('raw');
                 for (const h of handlers) {
                     let result;
                     if (!h.check || (await h.check(this._client, update, peers))) {
@@ -231,11 +274,11 @@ class Dispatcher {
                 }
             }
             else {
-                if (!this._scenes || !(parsedScene in this._scenes)) {
+                if (!this._scenes || !this._scenes.has(parsedScene)) {
                     // not registered scene
                     return false;
                 }
-                return this._scenes[parsedScene]._dispatchUpdateNowImpl(update, parsedState, parsedScene, true);
+                return this._scenes.get(parsedScene)._dispatchUpdateNowImpl(update, parsedState, parsedScene, true);
             }
         }
         if (parsedState === undefined) {
@@ -274,10 +317,10 @@ class Dispatcher {
         }
         if (shouldDispatch) {
             outer: for (const grp of this._groupsOrder) {
-                const group = this._groups[grp];
-                if (update.name in group) {
+                const group = this._groups.get(grp);
+                if (group.has(update.name)) {
                     // raw is not handled here, so we can safely assume this
-                    const handlers = group[update.name];
+                    const handlers = group.get(update.name);
                     try {
                         for (const h of handlers) {
                             let result;
@@ -305,7 +348,7 @@ class Dispatcher {
                                     if (!scene) {
                                         throw new client_1.MtArgumentError('Cannot use ToScene without entering a scene');
                                     }
-                                    return this._scenes[scene]._dispatchUpdateNowImpl(update, undefined, scene, true);
+                                    return this._scenes.get(scene)._dispatchUpdateNowImpl(update, undefined, scene, true);
                                 }
                             }
                             break;
@@ -340,47 +383,49 @@ class Dispatcher {
      * @param group  Handler group index
      */
     addUpdateHandler(handler, group = 0) {
-        if (!(group in this._groups)) {
-            this._groups[group] = {};
+        if (!this._groups.has(group)) {
+            this._groups.set(group, new Map());
             this._groupsOrder.push(group);
             this._groupsOrder.sort((a, b) => a - b);
         }
-        if (!(handler.name in this._groups[group])) {
-            this._groups[group][handler.name] = [];
+        if (!this._groups.get(group).has(handler.name)) {
+            this._groups.get(group).set(handler.name, []);
         }
-        this._groups[group][handler.name].push(handler);
+        this._groups.get(group).get(handler.name).push(handler);
     }
     /**
      * Remove an update handler (or handlers) from a given
      * handler group.
      *
      * @param handler  Update handler to remove, its name or `'all'` to remove all
-     * @param group  Handler group index (-1 to affect all groups)
+     * @param group  Handler group index (null to affect all groups)
      */
     removeUpdateHandler(handler, group = 0) {
-        if (group !== -1 && !(group in this._groups)) {
+        if (group !== null && !this._groups.has(group)) {
             return;
         }
         if (typeof handler === 'string') {
             if (handler === 'all') {
-                if (group === -1) {
-                    this._groups = {};
+                if (group === null) {
+                    this._groups = new Map();
                 }
                 else {
-                    delete this._groups[group];
+                    this._groups.delete(group);
                 }
             }
-            else {
-                delete this._groups[group][handler];
+            else if (group !== null) {
+                this._groups.get(group).delete(handler);
             }
             return;
         }
-        if (!(handler.name in this._groups[group])) {
+        if (group === null)
+            return;
+        if (!this._groups.get(group).has(handler.name)) {
             return;
         }
-        const idx = this._groups[group][handler.name].indexOf(handler);
+        const idx = this._groups.get(group).get(handler.name).indexOf(handler);
         if (idx > -1) {
-            this._groups[group][handler.name].splice(idx, 1);
+            this._groups.get(group).get(handler.name).splice(idx, 1);
         }
     }
     /**
@@ -473,6 +518,8 @@ class Dispatcher {
         child._client = this._client;
         child._storage = this._storage;
         child._stateKeyDelegate = this._stateKeyDelegate;
+        child._customStorage ?? (child._customStorage = this._customStorage);
+        child._customStateKeyDelegate ?? (child._customStateKeyDelegate = this._customStateKeyDelegate);
     }
     /**
      * Add a child dispatcher.
@@ -497,16 +544,16 @@ class Dispatcher {
     }
     addScene(scene, scoped = true) {
         if (!this._scenes)
-            this._scenes = {};
+            this._scenes = new Map();
         if (!scene._scene) {
             throw new client_1.MtArgumentError('Non-scene dispatcher passed to addScene. Use `Dispatcher.scene()` to create one.');
         }
-        if (scene._scene in this._scenes) {
+        if (this._scenes.has(scene._scene)) {
             throw new client_1.MtArgumentError(`Scene with name ${scene._scene} is already registered!`);
         }
         this._prepareChild(scene);
         scene._sceneScoped = scoped;
-        this._scenes[scene._scene] = scene;
+        this._scenes.set(scene._scene, scene);
     }
     /**
      * Remove a child dispatcher.
@@ -548,21 +595,22 @@ class Dispatcher {
             throw new client_1.MtArgumentError('Provided dispatcher has custom storage and cannot be extended from.');
         }
         other._groupsOrder.forEach((group) => {
-            if (!(group in this._groups)) {
-                this._groups[group] = other._groups[group];
+            if (!this._groups.has(group)) {
+                this._groups.set(group, other._groups.get(group));
                 this._groupsOrder.push(group);
             }
             else {
-                const otherGrp = other._groups[group];
-                const selfGrp = this._groups[group];
-                Object.keys(otherGrp).forEach((typ) => {
-                    if (!(typ in selfGrp)) {
-                        selfGrp[typ] = otherGrp[typ];
+                const otherGrp = other._groups.get(group);
+                const selfGrp = this._groups.get(group);
+                for (const typ of otherGrp.keys()) {
+                    if (!selfGrp.has(typ)) {
+                        selfGrp.set(typ, otherGrp.get(typ));
                     }
                     else {
-                        selfGrp[typ].push(...otherGrp[typ]);
+                        // selfGrp[typ].push(...otherGrp[typ])
+                        selfGrp.get(typ).push(...otherGrp.get(typ));
                     }
-                });
+                }
             }
         });
         other._children.forEach((it) => {
@@ -572,16 +620,16 @@ class Dispatcher {
         if (other._scenes) {
             const otherScenes = other._scenes;
             if (!this._scenes)
-                this._scenes = {};
+                this._scenes = new Map();
             const myScenes = this._scenes;
-            Object.keys(otherScenes).forEach((key) => {
-                otherScenes[key]._unparent();
-                if (key in myScenes) {
+            for (const key of otherScenes.keys()) {
+                otherScenes.get(key)._unparent();
+                if (myScenes.has(key)) {
                     // will be overwritten
-                    delete myScenes[key];
+                    myScenes.delete(key);
                 }
-                this.addScene(myScenes[key], myScenes[key]._sceneScoped);
-            });
+                this.addScene(otherScenes.get(key), otherScenes.get(key)._sceneScoped);
+            }
         }
         this._groupsOrder.sort((a, b) => a - b);
     }
@@ -600,13 +648,14 @@ class Dispatcher {
     clone(children = false) {
         const dp = new Dispatcher();
         // copy handlers.
-        Object.keys(this._groups).forEach((key) => {
+        for (const key of this._groups.keys()) {
             const idx = key;
-            dp._groups[idx] = {};
-            Object.keys(this._groups[idx]).forEach((type) => {
-                dp._groups[idx][type] = [...this._groups[idx][type]];
-            });
-        });
+            dp._groups.set(idx, new Map());
+            for (const type of this._groups.get(idx).keys()) {
+                // dp._groups.get(idx)!.set(type, [...this._groups.get(idx)!].get(type)!])
+                dp._groups.get(idx).set(type, [...this._groups.get(idx).get(type)]);
+            }
+        }
         dp._groupsOrder = [...this._groupsOrder];
         dp._errorHandler = this._errorHandler;
         dp._customStateKeyDelegate = this._customStateKeyDelegate;
@@ -617,10 +666,10 @@ class Dispatcher {
                 dp.addChild(child);
             });
             if (this._scenes) {
-                Object.keys(this._scenes).forEach((key) => {
-                    const scene = this._scenes[key].clone(true);
-                    dp.addScene(scene, this._scenes[key]._sceneScoped);
-                });
+                for (const key of this._scenes.keys()) {
+                    const scene = this._scenes.get(key).clone(true);
+                    dp.addScene(scene, this._scenes.get(key)._sceneScoped);
+                }
             }
         }
         return dp;