@iobroker/db-base 7.2.3 → 8.0.0-alpha.2-20260923-99da17fcc

package/build/cjs/index.d.ts

@@ -1,4 +1,4 @@
-export { InMemoryFileDB } from './lib/inMemFileDB.js';
+export { InMemoryFileDB, type ConnectionOptions, type DbStatus, type DbOptions, type FileDbSettings, type MetaObject, } from './lib/inMemFileDB.js';
 export { RedisHandler } from './lib/redisHandler.js';
 export { tools } from '@iobroker/js-controller-common-db';
 //# sourceMappingURL=index.d.ts.map

package/build/cjs/index.js

@@ -16,13 +16,13 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var esm_exports = {};
-__export(esm_exports, {
+var index_exports = {};
+__export(index_exports, {
   InMemoryFileDB: () => import_inMemFileDB.InMemoryFileDB,
   RedisHandler: () => import_redisHandler.RedisHandler,
   tools: () => import_js_controller_common_db.tools
 });
-module.exports = __toCommonJS(esm_exports);
+module.exports = __toCommonJS(index_exports);
 var import_inMemFileDB = require("./lib/inMemFileDB.js");
 var import_redisHandler = require("./lib/redisHandler.js");
 var import_js_controller_common_db = require("@iobroker/js-controller-common-db");

package/build/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["export { InMemoryFileDB } from './lib/inMemFileDB.js';\nexport { RedisHandler } from './lib/redisHandler.js';\nexport { tools } from '@iobroker/js-controller-common-db';\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;;;;;;;AAAA,yBAA+B;AAC/B,0BAA6B;AAC7B,qCAAsB;",
+  "sourcesContent": ["export {\n    InMemoryFileDB,\n    type ConnectionOptions,\n    type DbStatus,\n    type DbOptions,\n    type FileDbSettings,\n    type MetaObject,\n} from './lib/inMemFileDB.js';\nexport { RedisHandler } from './lib/redisHandler.js';\nexport { tools } from '@iobroker/js-controller-common-db';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;;;;;;;AAAA,yBAOO;AACP,0BAA6B;AAC7B,qCAAsB;",
   "names": []
 }

package/build/cjs/lib/inMemFileDB.d.ts

@@ -1,66 +1,120 @@
 /**
  *      States DB in memory - Server
  *
- *      Copyright 2013-2024 bluefox <dogafox@gmail.com>
+ *      Copyright 2013-2026 bluefox <dogafox@gmail.com>
  *
  *      MIT License
  *
  */
 import type { InternalLogger } from '@iobroker/js-controller-common-db/tools';
+interface BackupOptions {
+    /** deactivates backup if true */
+    disabled: boolean;
+    /** minimum number of files */
+    files: number;
+    hours: number;
+    /** minutes */
+    period: number;
+    path: string;
+}
+export type MetaObject = Record<string, string>;
+export type FileSize = number;
+/** Options describing how to connect to the database server */
 export interface ConnectionOptions {
+    /** Password for authentication, if required */
     pass?: string;
+    /** Name of the sentinel master to connect to */
     sentinelName?: string;
     /** array on sentinel */
     host: string | string[];
     /** array on sentinel */
     port: number | number[];
-    options: Record<string, any>;
+    /** Additional connection options passed to the database driver */
+    options: ioBroker.ObjectsDatabaseOptions['options'];
+    /** Options forwarded to the JSONL database backend */
+    jsonlOptions?: ioBroker.ObjectsDatabaseOptions['jsonlOptions'];
+    /** Redis key prefix used by the in-memory server */
+    redisNamespace?: string;
+    /** Enable more verbose connection logging */
     enhancedLogging?: boolean;
+    /** Disable the in-memory file cache and always read files from disk */
+    noFileCache?: boolean;
+    /** Whether the connection should be secured via TLS */
+    secure?: boolean;
+    /** Backup configuration */
     backup?: BackupOptions;
     /** relative path to the data dir */
     dataDir?: string;
+    /** Interval in milliseconds in which the in-memory states are persisted to disk */
+    writeFileInterval?: number;
 }
-type ChangeFunction = (id: string, state: any) => void;
+type ChangeFunction<TObject> = (id: string, obj: TObject) => void;
+/** Status information about the database */
 export interface DbStatus {
-    type: string;
+    /** Type of the database backend (e.g. file, jsonl, redis) */
+    type: 'file' | 'redis' | 'jsonl';
+    /** Whether this process runs the database server */
     server: boolean;
 }
-interface BackupOptions {
-    /** deactivates backup if true */
-    disabled: boolean;
-    /** minimum number of files */
-    files: number;
-    hours: number;
-    /** minutes */
-    period: number;
-    path: string;
-}
+/** Options describing where the database stores its files */
 export interface DbOptions {
+    /** Name of the directory used for backups */
     backupDirName: string;
+    /** Name of the database file */
     fileName: string;
 }
-interface FileDbSettings {
-    fileDB: DbOptions;
-    jsonlDB: DbOptions;
-    backup: BackupOptions;
-    change?: ChangeFunction;
-    connected: (nameOfServer: string) => void;
-    logger: InternalLogger;
+/** Settings accepted by the in-memory database classes and their subclasses */
+export interface FileDbSettings<TObject> {
+    /** File DB storage options (filled in by the subclass constructor before `super()`) */
+    fileDB?: DbOptions;
+    /** JSONL DB storage options (only set by the JSONL backend; only the file name is used) */
+    jsonlDB?: Pick<DbOptions, 'fileName'>;
+    /** Backup options (derived from `connection.backup` by the base constructor) */
+    backup?: BackupOptions;
+    /** Callback invoked when a value in the database changes */
+    change?: ChangeFunction<TObject>;
+    /** Callback invoked once the database server is ready */
+    connected: (nameOfServer?: string) => void;
+    /** Logger instance (or logger configuration) used for all database logging */
+    logger?: InternalLogger;
+    /** Options describing how to connect to the database server */
     connection: ConnectionOptions;
     /** unused */
     auth?: null;
-    secure: boolean;
-    /** as required by createServer TODO: if createServer is typed, add type */
-    certificates: any;
-    port: number;
-    host: string;
+    /** Whether the server connection should be secured via TLS */
+    secure?: boolean;
+    /** Port the in-memory server listens on */
+    port?: number;
+    /** Host the in-memory server binds to */
+    host?: string;
     /** logging namespace */
     namespace?: string;
+    /** Host name used as a fallback for the logging namespace */
+    hostname?: string;
+    /** Default ACL applied to newly created objects */
+    defaultNewAcl?: {
+        object: number;
+        state: number;
+        file: number;
+        owner: ioBroker.ObjectIDs.User;
+        ownerGroup: ioBroker.ObjectIDs.Group;
+    };
+    /** Redis key prefix used by the in-memory server (defaults to "io") */
+    redisNamespace?: string;
+    /** Namespace used for the message box */
+    namespaceMsg?: string;
+    /** Namespace used for log messages */
+    namespaceLog?: string;
+    /** Namespace used for sessions */
+    namespaceSession?: string;
+    /** Namespace used for meta information */
+    metaNamespace?: string;
+    /** Redis key prefix used for object meta information (defaults to "meta") */
+    namespaceMeta?: string;
 }
 interface Subscription {
     pattern: string;
     regex: RegExp;
-    options: any;
 }
 interface SubscriptionClient {
     _subscribe?: Record<string, Subscription[]>;
@@ -69,19 +123,25 @@ interface SubscriptionClient {
  * The parent of the class structure, which provides basic JSON storage
  * and general subscription and publish functionality
  */
-export declare class InMemoryFileDB {
-    private settings;
-    private readonly change;
-    protected dataset: Record<string, any>;
-    private readonly namespace;
+export declare class InMemoryFileDB<TObject, THandler extends SubscriptionClient = SubscriptionClient> {
+    protected settings: FileDbSettings<TObject>;
+    protected change: ChangeFunction<TObject> | undefined;
+    protected dataset: Record<string, TObject | MetaObject>;
+    protected namespace: string;
     private lastSave;
-    private stateTimer;
+    protected stateTimer: NodeJS.Timeout | null;
     private callbackSubscriptionClient;
-    private readonly dataDir;
+    protected readonly dataDir: string;
     private readonly datasetName;
-    private log;
-    private readonly backupDir;
-    constructor(settings: FileDbSettings);
+    protected log: InternalLogger;
+    protected readonly backupDir: string;
+    /**
+     * @param settings Settings for the database, the connection and backups
+     */
+    constructor(settings: FileDbSettings<TObject>);
+    /**
+     * Open the database by loading the dataset from disk
+     */
     open(): Promise<void>;
     /**
      * Loads a dataset file
@@ -89,20 +149,55 @@ export declare class InMemoryFileDB {
      * @param datasetName Filename of the file to load
      * @returns obj read data, normally as object
      */
-    loadDatasetFile(datasetName: string): Promise<Record<string, any>>;
+    loadDatasetFile(datasetName: string): Promise<Record<string, TObject>>;
     /**
      * Loads the dataset including pot. Fallback handling
      *
      * @param datasetName Filename of the file to load
      * @returns obj dataset read as object
      */
-    loadDataset(datasetName: string): Promise<Record<string, any>>;
+    loadDataset(datasetName: string): Promise<Record<string, TObject>>;
+    /**
+     * Normalize the backup settings and create the backup directory
+     */
     initBackupDir(): void;
-    handleSubscribe(client: SubscriptionClient, type: string, pattern: string | string[], cb?: () => void): void;
-    handleSubscribe(client: SubscriptionClient, type: string, pattern: string | string[], options: any, cb?: () => void): void;
+    /**
+     * Subscribe a client to changes matching the given pattern
+     *
+     * @param client The client to register the subscription for
+     * @param type The subscription type (e.g. objects or states)
+     * @param pattern One or more patterns to subscribe to
+     */
+    handleSubscribe(client: SubscriptionClient, type: string, pattern: string | string[]): void;
+    /**
+     * Remove a client's subscription for the given pattern
+     *
+     * @param client The client whose subscription should be removed
+     * @param type The subscription type (e.g. objects or states)
+     * @param pattern One or more patterns to unsubscribe from
+     * @param cb Called once the subscription has been removed
+     */
     handleUnsubscribe(client: SubscriptionClient, type: string, pattern: string | string[], cb?: () => void): void | Promise<void>;
-    publishToClients(_client: SubscriptionClient, _type: string, _id: string, _obj: any): number;
+    /**
+     * Publish a change to a single client. Must be implemented by a subclass that handles client communication.
+     *
+     * @param _client The client to publish to
+     * @param _type The change type (e.g. objects or states)
+     * @param _id The ID of the changed object or state
+     * @param _obj The new value of the object or state
+     */
+    publishToClients(_client: SubscriptionClient, _type: string, _id: string, _obj: TObject | string | null | FileSize | MetaObject): number;
+    /**
+     * Delete outdated backup files according to the configured retention settings
+     *
+     * @param baseFilename Base file name of the backups that should be pruned
+     */
     deleteOldBackupFiles(baseFilename: string): void;
+    /**
+     * Format a timestamp into a "YYYY-MM-DD_HH-MM-SS" string used for backup file names
+     *
+     * @param date Timestamp in milliseconds
+     */
     getTimeStr(date: number): string;
     /**
      * Handle saving the dataset incl. backups
@@ -120,9 +215,25 @@ export declare class InMemoryFileDB {
      * @param jsonString JSON string of the complete dataset to also be stored into a compressed backup file
      */
     saveBackup(jsonString: string): void;
+    /**
+     * Get the current status of the database
+     */
     getStatus(): DbStatus;
-    getClients(): Record<string, any>;
-    publishAll(type: string, id: string, obj: any): number;
+    /**
+     * Get the currently connected clients. Subclasses override this to return the real clients.
+     */
+    getClients(): Record<string, THandler>;
+    /**
+     * Publish a change to all connected clients and local subscribers
+     *
+     * @param type The change type (e.g. objects or states)
+     * @param id The ID of the changed object or state
+     * @param obj The new value of the object or state
+     */
+    publishAll(type: string, id: string, obj: TObject | string | null | FileSize | MetaObject): number;
+    /**
+     * Destructor of the class. Called when shutting down to persist state and clear timers.
+     */
     destroy(): Promise<void>;
 }
 export {};

package/build/cjs/lib/inMemFileDB.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -36,24 +37,27 @@ var import_node_path = __toESM(require("node:path"), 1);
 var import_js_controller_common_db = require("@iobroker/js-controller-common-db");
 var import_node_zlib = require("node:zlib");
 class InMemoryFileDB {
+  static {
+    __name(this, "InMemoryFileDB");
+  }
   settings;
   change;
-  dataset;
+  dataset = {};
   namespace;
-  lastSave;
-  stateTimer;
-  callbackSubscriptionClient;
+  lastSave = null;
+  stateTimer = null;
+  callbackSubscriptionClient = {};
   dataDir;
   datasetName;
   log;
   backupDir;
+  /**
+   * @param settings Settings for the database, the connection and backups
+   */
   constructor(settings) {
-    this.settings = settings || {};
+    this.settings = settings;
     this.change = this.settings.change;
-    this.dataset = {};
     this.namespace = this.settings.namespace || "";
-    this.lastSave = null;
-    this.callbackSubscriptionClient = {};
     this.settings.backup = this.settings.connection.backup || {
       disabled: false,
       // deactivates
@@ -66,29 +70,36 @@ class InMemoryFileDB {
       path: ""
       // use default path
     };
+    const backup = this.settings.backup;
     this.dataDir = this.settings.connection.dataDir || import_js_controller_common_db.tools.getDefaultDataDir();
     if (!import_node_path.default.isAbsolute(this.dataDir)) {
       this.dataDir = import_node_path.default.normalize(import_node_path.default.join(import_js_controller_common_db.tools.getControllerDir(), this.dataDir));
     }
     this.dataDir = this.dataDir.replace(/\\/g, "/");
-    const fileName = this.settings.jsonlDB ? this.settings.jsonlDB.fileName : this.settings.fileDB.fileName;
+    const fileDbOptions = this.settings.fileDB;
+    if (!fileDbOptions) {
+      throw new Error(`${this.namespace} No fileDB storage options were provided`);
+    }
+    const fileName = this.settings.jsonlDB ? this.settings.jsonlDB.fileName : fileDbOptions.fileName;
     this.datasetName = import_node_path.default.join(this.dataDir, fileName);
     const parts = import_node_path.default.dirname(this.datasetName);
     import_fs_extra.default.ensureDirSync(parts);
-    this.stateTimer = null;
-    this.backupDir = this.settings.backup.path || import_node_path.default.join(this.dataDir, this.settings.fileDB.backupDirName);
+    this.backupDir = backup.path || import_node_path.default.join(this.dataDir, fileDbOptions.backupDirName);
     this.log = import_js_controller_common_db.tools.getLogger(this.settings.logger);
-    if (!this.settings.backup.disabled) {
+    if (!backup.disabled) {
       try {
         this.initBackupDir();
       } catch (e) {
         this.log.error(`Database backups are disabled, because backup directory could not be initialized: ${e.message}`);
         this.log.error("This leads to an increased risk of data loss, please check that the configured backup directory is available and restart the controller");
-        this.settings.backup.disabled = true;
+        backup.disabled = true;
       }
     }
     this.log.debug(`${this.namespace} Data File: ${this.datasetName}`);
   }
+  /**
+   * Open the database by loading the dataset from disk
+   */
   async open() {
     this.dataset = await this.loadDataset(this.datasetName);
   }
@@ -151,58 +162,75 @@ class InMemoryFileDB {
     }
     return ret;
   }
+  /**
+   * Normalize the backup settings and create the backup directory
+   */
   initBackupDir() {
-    this.settings.backup.period = this.settings.backup.period === void 0 ? 120 : parseInt(String(this.settings.backup.period));
-    if (isNaN(this.settings.backup.period)) {
-      this.settings.backup.period = 120;
+    import_fs_extra.default.ensureDirSync(this.backupDir);
+    const backup = this.settings.backup;
+    if (!backup) {
+      return;
+    }
+    backup.period = backup.period === void 0 ? 120 : parseInt(String(backup.period));
+    if (isNaN(backup.period)) {
+      backup.period = 120;
     }
     const maxTimeoutMinutes = Math.floor((2 ** 31 - 1) / 6e4);
-    if (this.settings.backup.period > maxTimeoutMinutes) {
-      this.log.warn(`${this.namespace} Configured backup period ${this.settings.backup.period} is larger than the supported maximum of ${maxTimeoutMinutes} minutes. Defaulting to 120 minutes.`);
-      this.settings.backup.period = 120;
+    if (backup.period > maxTimeoutMinutes) {
+      this.log.warn(`${this.namespace} Configured backup period ${backup.period} is larger than the supported maximum of ${maxTimeoutMinutes} minutes. Defaulting to 120 minutes.`);
+      backup.period = 120;
     }
-    this.settings.backup.period *= 6e4;
-    this.settings.backup.files = this.settings.backup.files === void 0 ? 24 : parseInt(String(this.settings.backup.files));
-    if (isNaN(this.settings.backup.files)) {
-      this.settings.backup.files = 24;
+    backup.period *= 6e4;
+    backup.files = backup.files === void 0 ? 24 : parseInt(String(backup.files));
+    if (isNaN(backup.files)) {
+      backup.files = 24;
     }
-    this.settings.backup.hours = this.settings.backup.hours === void 0 ? 48 : parseInt(String(this.settings.backup.hours));
-    if (isNaN(this.settings.backup.hours)) {
-      this.settings.backup.hours = 48;
+    backup.hours = backup.hours === void 0 ? 48 : parseInt(String(backup.hours));
+    if (isNaN(backup.hours)) {
+      backup.hours = 48;
     }
-    import_fs_extra.default.ensureDirSync(this.backupDir);
   }
-  handleSubscribe(client, type, pattern, options, cb) {
-    if (typeof options === "function") {
-      cb = options;
-      options = void 0;
-    }
-    client._subscribe = client._subscribe || {};
-    client._subscribe[type] = client._subscribe[type] || [];
+  /**
+   * Subscribe a client to changes matching the given pattern
+   *
+   * @param client The client to register the subscription for
+   * @param type The subscription type (e.g. objects or states)
+   * @param pattern One or more patterns to subscribe to
+   */
+  handleSubscribe(client, type, pattern) {
+    client._subscribe ||= {};
+    client._subscribe[type] ||= [];
     const s = client._subscribe[type];
     if (pattern instanceof Array) {
       pattern.forEach((pattern2) => {
         if (s.find((sub) => sub.pattern === pattern2)) {
           return;
         }
-        s.push({ pattern: pattern2, regex: new RegExp(import_js_controller_common_db.tools.pattern2RegEx(pattern2)), options });
+        s.push({ pattern: pattern2, regex: new RegExp(import_js_controller_common_db.tools.pattern2RegEx(pattern2)) });
       });
     } else {
       if (!s.find((sub) => sub.pattern === pattern)) {
-        s.push({ pattern, regex: new RegExp(import_js_controller_common_db.tools.pattern2RegEx(pattern)), options });
+        s.push({ pattern, regex: new RegExp(import_js_controller_common_db.tools.pattern2RegEx(pattern)) });
       }
     }
-    typeof cb === "function" && cb();
   }
+  /**
+   * Remove a client's subscription for the given pattern
+   *
+   * @param client The client whose subscription should be removed
+   * @param type The subscription type (e.g. objects or states)
+   * @param pattern One or more patterns to unsubscribe from
+   * @param cb Called once the subscription has been removed
+   */
   handleUnsubscribe(client, type, pattern, cb) {
     const s = client?._subscribe?.[type];
     if (s) {
-      const removeEntry = (p) => {
+      const removeEntry = /* @__PURE__ */ __name((p) => {
         const index = s.findIndex((sub) => sub.pattern === p);
         if (index > -1) {
           s.splice(index, 1);
         }
-      };
+      }, "removeEntry");
       if (pattern instanceof Array) {
         pattern.forEach((p) => {
           removeEntry(p);
@@ -213,15 +241,28 @@ class InMemoryFileDB {
     }
     return import_js_controller_common_db.tools.maybeCallback(cb);
   }
+  /**
+   * Publish a change to a single client. Must be implemented by a subclass that handles client communication.
+   *
+   * @param _client The client to publish to
+   * @param _type The change type (e.g. objects or states)
+   * @param _id The ID of the changed object or state
+   * @param _obj The new value of the object or state
+   */
   publishToClients(_client, _type, _id, _obj) {
     throw new Error("no communication handling implemented");
   }
+  /**
+   * Delete outdated backup files according to the configured retention settings
+   *
+   * @param baseFilename Base file name of the backups that should be pruned
+   */
   deleteOldBackupFiles(baseFilename) {
     let files = import_fs_extra.default.readdirSync(this.backupDir);
     files.sort();
-    const limit = Date.now() - this.settings.backup.hours * 36e5;
+    const limit = Date.now() - (this.settings.backup?.hours ?? 48) * 36e5;
     files = files.filter((f) => f.endsWith(`${baseFilename}.gz`));
-    while (files.length > this.settings.backup.files) {
+    while (files.length > (this.settings.backup?.files ?? 24)) {
       const file = files.shift();
       if (!file) {
         continue;
@@ -236,6 +277,11 @@ class InMemoryFileDB {
       }
     }
   }
+  /**
+   * Format a timestamp into a "YYYY-MM-DD_HH-MM-SS" string used for backup file names
+   *
+   * @param date Timestamp in milliseconds
+   */
   getTimeStr(date) {
     const dateObj = new Date(date);
     let text = `${dateObj.getFullYear().toString()}-`;
@@ -267,7 +313,7 @@ class InMemoryFileDB {
   async saveState() {
     try {
       const jsonString = await this.saveDataset();
-      if (!this.settings.backup.disabled && jsonString) {
+      if (!this.settings.backup?.disabled && jsonString) {
         this.saveBackup(jsonString);
       }
     } finally {
@@ -332,9 +378,10 @@ class InMemoryFileDB {
    */
   saveBackup(jsonString) {
     const now = Date.now();
-    if (this.settings.backup.period && (!this.lastSave || now - this.lastSave > this.settings.backup.period)) {
+    const fileName = this.settings.fileDB?.fileName;
+    if (fileName && this.settings.backup?.period && (!this.lastSave || now - this.lastSave > this.settings.backup.period)) {
       this.lastSave = now;
-      const backFileName = import_node_path.default.join(this.backupDir, `${this.getTimeStr(now)}_${this.settings.fileDB.fileName}.gz`);
+      const backFileName = import_node_path.default.join(this.backupDir, `${this.getTimeStr(now)}_${fileName}.gz`);
       try {
         if (!import_fs_extra.default.existsSync(backFileName)) {
           const output = import_fs_extra.default.createWriteStream(backFileName);
@@ -345,19 +392,32 @@ class InMemoryFileDB {
           compress.pipe(output);
           compress.write(jsonString);
           compress.end();
-          this.deleteOldBackupFiles(this.settings.fileDB.fileName);
+          this.deleteOldBackupFiles(fileName);
         }
       } catch (e) {
         this.log.error(`${this.namespace} Cannot save backup ${backFileName}: ${e.message}`);
       }
     }
   }
+  /**
+   * Get the current status of the database
+   */
   getStatus() {
     return { type: "file", server: true };
   }
+  /**
+   * Get the currently connected clients. Subclasses override this to return the real clients.
+   */
   getClients() {
     return {};
   }
+  /**
+   * Publish a change to all connected clients and local subscribers
+   *
+   * @param type The change type (e.g. objects or states)
+   * @param id The ID of the changed object or state
+   * @param obj The new value of the object or state
+   */
   publishAll(type, id, obj) {
     if (id === void 0) {
       this.log.error(`${this.namespace} Can not publish empty ID`);
@@ -380,7 +440,9 @@ class InMemoryFileDB {
     }
     return publishCount;
   }
-  // Destructor of the class. Called by shutting down.
+  /**
+   * Destructor of the class. Called when shutting down to persist state and clear timers.
+   */
   async destroy() {
     if (this.stateTimer) {
       clearTimeout(this.stateTimer);