@iobroker/db-base 7.2.3-alpha.8-20260709-8d8c9c5ed → 7.2.3

package/build/cjs/index.d.ts

@@ -1,4 +1,4 @@
-export { InMemoryFileDB, type ConnectionOptions, type DbStatus, type DbOptions, type FileDbSettings, type MetaObject, } from './lib/inMemFileDB.js';
+export { InMemoryFileDB } 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 index_exports = {};
-__export(index_exports, {
+var esm_exports = {};
+__export(esm_exports, {
   InMemoryFileDB: () => import_inMemFileDB.InMemoryFileDB,
   RedisHandler: () => import_redisHandler.RedisHandler,
   tools: () => import_js_controller_common_db.tools
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(esm_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 {\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;",
+  "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;",
   "names": []
 }

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

@@ -1,120 +1,66 @@
 /**
  *      States DB in memory - Server
  *
- *      Copyright 2013-2026 bluefox <dogafox@gmail.com>
+ *      Copyright 2013-2024 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[];
-    /** 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 */
+    options: Record<string, any>;
     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<TObject> = (id: string, obj: TObject) => void;
-/** Status information about the database */
+type ChangeFunction = (id: string, state: any) => void;
 export interface DbStatus {
-    /** Type of the database backend (e.g. file, jsonl, redis) */
-    type: 'file' | 'redis' | 'jsonl';
-    /** Whether this process runs the database server */
+    type: string;
     server: boolean;
 }
-/** Options describing where the database stores its files */
+interface BackupOptions {
+    /** deactivates backup if true */
+    disabled: boolean;
+    /** minimum number of files */
+    files: number;
+    hours: number;
+    /** minutes */
+    period: number;
+    path: string;
+}
 export interface DbOptions {
-    /** Name of the directory used for backups */
     backupDirName: string;
-    /** Name of the database file */
     fileName: string;
 }
-/** 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 */
+interface FileDbSettings {
+    fileDB: DbOptions;
+    jsonlDB: DbOptions;
+    backup: BackupOptions;
+    change?: ChangeFunction;
+    connected: (nameOfServer: string) => void;
+    logger: InternalLogger;
     connection: ConnectionOptions;
     /** unused */
     auth?: null;
-    /** 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;
+    secure: boolean;
+    /** as required by createServer TODO: if createServer is typed, add type */
+    certificates: any;
+    port: number;
+    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[]>;
@@ -123,25 +69,19 @@ interface SubscriptionClient {
  * The parent of the class structure, which provides basic JSON storage
  * and general subscription and publish functionality
  */
-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;
+export declare class InMemoryFileDB {
+    private settings;
+    private readonly change;
+    protected dataset: Record<string, any>;
+    private readonly namespace;
     private lastSave;
-    protected stateTimer: NodeJS.Timeout | null;
+    private stateTimer;
     private callbackSubscriptionClient;
-    protected readonly dataDir: string;
+    private readonly dataDir;
     private readonly datasetName;
-    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
-     */
+    private log;
+    private readonly backupDir;
+    constructor(settings: FileDbSettings);
     open(): Promise<void>;
     /**
      * Loads a dataset file
@@ -149,55 +89,20 @@ export declare class InMemoryFileDB<TObject, THandler extends SubscriptionClient
      * @param datasetName Filename of the file to load
      * @returns obj read data, normally as object
      */
-    loadDatasetFile(datasetName: string): Promise<Record<string, TObject>>;
+    loadDatasetFile(datasetName: string): Promise<Record<string, any>>;
     /**
      * 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, TObject>>;
-    /**
-     * Normalize the backup settings and create the backup directory
-     */
+    loadDataset(datasetName: string): Promise<Record<string, any>>;
     initBackupDir(): 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
-     */
+    handleSubscribe(client: SubscriptionClient, type: string, pattern: string | string[], cb?: () => void): void;
+    handleSubscribe(client: SubscriptionClient, type: string, pattern: string | string[], options: any, cb?: () => void): void;
     handleUnsubscribe(client: SubscriptionClient, type: string, pattern: string | string[], cb?: () => void): void | Promise<void>;
-    /**
-     * 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
-     */
+    publishToClients(_client: SubscriptionClient, _type: string, _id: string, _obj: any): number;
     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
@@ -215,25 +120,9 @@ export declare class InMemoryFileDB<TObject, THandler extends SubscriptionClient
      * @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;
-    /**
-     * 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.
-     */
+    getClients(): Record<string, any>;
+    publishAll(type: string, id: string, obj: any): number;
     destroy(): Promise<void>;
 }
 export {};

package/build/cjs/lib/inMemFileDB.js

@@ -5,7 +5,6 @@ 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 });
@@ -37,27 +36,24 @@ 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 = null;
-  stateTimer = null;
-  callbackSubscriptionClient = {};
+  lastSave;
+  stateTimer;
+  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
@@ -70,36 +66,29 @@ 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 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;
+    const fileName = this.settings.jsonlDB ? this.settings.jsonlDB.fileName : this.settings.fileDB.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.backupDir = backup.path || import_node_path.default.join(this.dataDir, fileDbOptions.backupDirName);
+    this.stateTimer = null;
+    this.backupDir = this.settings.backup.path || import_node_path.default.join(this.dataDir, this.settings.fileDB.backupDirName);
     this.log = import_js_controller_common_db.tools.getLogger(this.settings.logger);
-    if (!backup.disabled) {
+    if (!this.settings.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");
-        backup.disabled = true;
+        this.settings.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);
   }
@@ -162,75 +151,58 @@ class InMemoryFileDB {
     }
     return ret;
   }
-  /**
-   * Normalize the backup settings and create the backup directory
-   */
   initBackupDir() {
-    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;
+    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;
     }
     const maxTimeoutMinutes = Math.floor((2 ** 31 - 1) / 6e4);
-    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;
+    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;
     }
-    backup.period *= 6e4;
-    backup.files = backup.files === void 0 ? 24 : parseInt(String(backup.files));
-    if (isNaN(backup.files)) {
-      backup.files = 24;
+    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.hours = backup.hours === void 0 ? 48 : parseInt(String(backup.hours));
-    if (isNaN(backup.hours)) {
-      backup.hours = 48;
+    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;
     }
+    import_fs_extra.default.ensureDirSync(this.backupDir);
   }
-  /**
-   * 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] ||= [];
+  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] || [];
     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)) });
+        s.push({ pattern: pattern2, regex: new RegExp(import_js_controller_common_db.tools.pattern2RegEx(pattern2)), options });
       });
     } else {
       if (!s.find((sub) => sub.pattern === pattern)) {
-        s.push({ pattern, regex: new RegExp(import_js_controller_common_db.tools.pattern2RegEx(pattern)) });
+        s.push({ pattern, regex: new RegExp(import_js_controller_common_db.tools.pattern2RegEx(pattern)), options });
       }
     }
+    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 = /* @__PURE__ */ __name((p) => {
+      const removeEntry = (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);
@@ -241,28 +213,15 @@ 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 ?? 48) * 36e5;
+    const limit = Date.now() - this.settings.backup.hours * 36e5;
     files = files.filter((f) => f.endsWith(`${baseFilename}.gz`));
-    while (files.length > (this.settings.backup?.files ?? 24)) {
+    while (files.length > this.settings.backup.files) {
       const file = files.shift();
       if (!file) {
         continue;
@@ -277,11 +236,6 @@ 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()}-`;
@@ -313,7 +267,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 {
@@ -378,10 +332,9 @@ class InMemoryFileDB {
    */
   saveBackup(jsonString) {
     const now = Date.now();
-    const fileName = this.settings.fileDB?.fileName;
-    if (fileName && this.settings.backup?.period && (!this.lastSave || now - this.lastSave > this.settings.backup.period)) {
+    if (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)}_${fileName}.gz`);
+      const backFileName = import_node_path.default.join(this.backupDir, `${this.getTimeStr(now)}_${this.settings.fileDB.fileName}.gz`);
       try {
         if (!import_fs_extra.default.existsSync(backFileName)) {
           const output = import_fs_extra.default.createWriteStream(backFileName);
@@ -392,32 +345,19 @@ class InMemoryFileDB {
           compress.pipe(output);
           compress.write(jsonString);
           compress.end();
-          this.deleteOldBackupFiles(fileName);
+          this.deleteOldBackupFiles(this.settings.fileDB.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`);
@@ -440,9 +380,7 @@ class InMemoryFileDB {
     }
     return publishCount;
   }
-  /**
-   * Destructor of the class. Called when shutting down to persist state and clear timers.
-   */
+  // Destructor of the class. Called by shutting down.
   async destroy() {
     if (this.stateTimer) {
       clearTimeout(this.stateTimer);