node-red-contrib-homekit-bridged 2.0.0-dev.0 → 2.0.0-dev.10

package/build/lib/Storage.js

@@ -1,100 +1,162 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Storage = void 0;
-const logger_1 = require("@nrchkb/logger");
-const node_persist_1 = __importDefault(require("node-persist"));
-const path_1 = __importDefault(require("path"));
-const uuid_1 = require("uuid");
-const NRCHKBError_1 = __importDefault(require("./NRCHKBError"));
-const StorageType_1 = require("./types/storage/StorageType");
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Storage_exports = {};
+__export(Storage_exports, {
+  Storage: () => Storage
+});
+module.exports = __toCommonJS(Storage_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_logger = require("@nrchkb/logger");
+var import_node_persist = __toESM(require("node-persist"));
+var import_uuid = require("uuid");
+var import_NRCHKBError = __toESM(require("./NRCHKBError"));
+var import_StorageType = require("./types/storage/StorageType");
 class Storage {
-    static storagePath() {
-        if (!Storage.storageInitialized) {
-            throw new NRCHKBError_1.default('Storage path was not initialized!');
-        }
-        return Storage.customStoragePath;
-    }
-    static init(...storagePathSegments) {
-        Storage.customStoragePath = path_1.default.resolve(...storagePathSegments);
-        Storage.storageInitialized = true;
-        Storage.log.trace('Initializing');
-        return node_persist_1.default.init({ dir: Storage.storagePath() });
-    }
-    static save(type, key, value) {
-        const itemName = key ? `${type}-${key}` : type;
-        Storage.log.trace(`Saving ${itemName}:${value}`);
-        return node_persist_1.default.set(itemName, value);
-    }
-    static saveCallback(eventCallback, ttl = 10000) {
-        const callbackID = (0, uuid_1.v4)();
-        Storage.memoryStorage[callbackID] = eventCallback;
-        setTimeout(() => {
-            if (callbackID in Storage.memoryStorage) {
-                Storage.log.debug(`Callback ${callbackID} timeout`);
-                eventCallback.callback();
-                delete Storage.memoryStorage[callbackID];
-            }
-        }, ttl);
-        return callbackID;
-    }
-    static saveCustomCharacteristics(value) {
-        return Storage.save(StorageType_1.StorageType.CUSTOM_CHARACTERISTICS, undefined, value);
-    }
-    static saveService(key, value) {
-        return Storage.save(StorageType_1.StorageType.SERVICE, key, value);
+  static {
+    this.storageInitialized = false;
+  }
+  static {
+    this.memoryStorage = /* @__PURE__ */ new Map();
+  }
+  static {
+    this.MAX_CALLBACKS = 1e3;
+  }
+  static {
+    this.log = (0, import_logger.logger)("NRCHKB", "Storage");
+  }
+  static storagePath() {
+    if (!Storage.storageInitialized) {
+      throw new import_NRCHKBError.default("Storage path was not initialized!");
     }
-    static saveAccessory(key, value) {
-        return Storage.save(StorageType_1.StorageType.ACCESSORY, key, value);
-    }
-    static saveHost(key, serializedHost) {
-        return Storage.save(StorageType_1.StorageType.HOST, key, serializedHost);
-    }
-    static load(type, key) {
-        const itemName = key ? `${type}-${key}` : type;
-        Storage.log.trace(`Loading ${itemName}`);
-        return node_persist_1.default.get(itemName);
-    }
-    static loadCallback(key) {
-        if (key in Storage.memoryStorage) {
-            Storage.log.trace(`Returning callback ${key}`);
-            const value = Storage.memoryStorage[key];
-            delete Storage.memoryStorage[key];
-            return value;
+    return Storage.customStoragePath;
+  }
+  static init(...storagePathSegments) {
+    Storage.customStoragePath = import_node_path.default.resolve(...storagePathSegments);
+    Storage.storageInitialized = true;
+    Storage.log.trace("Initializing");
+    return import_node_persist.default.init({ dir: Storage.storagePath() });
+  }
+  static save(type, key, value) {
+    const itemName = key ? `${type}-${key}` : type;
+    Storage.log.trace(`Saving ${itemName}:${value}`);
+    return import_node_persist.default.set(itemName, value);
+  }
+  static saveCallback(eventCallback, ttl = 1e4) {
+    const callbackID = (0, import_uuid.v4)();
+    const currentSize = Storage.memoryStorage.size;
+    if (currentSize >= Storage.MAX_CALLBACKS) {
+      Storage.log.debug(
+        `Callback storage at maximum capacity (${currentSize}/${Storage.MAX_CALLBACKS}). Dropping oldest callbacks.`
+      );
+      const keysToDelete = Math.ceil(Storage.MAX_CALLBACKS * 0.1);
+      const iterator = Storage.memoryStorage.keys();
+      for (let index = 0; index < keysToDelete; index += 1) {
+        const oldestKey = iterator.next();
+        if (oldestKey.done) {
+          break;
         }
-        return undefined;
-    }
-    static loadCustomCharacteristics() {
-        return Storage.load(StorageType_1.StorageType.CUSTOM_CHARACTERISTICS);
-    }
-    static loadService(key) {
-        return new Promise((resolve, reject) => {
-            Storage.load(StorageType_1.StorageType.SERVICE, key).then((value) => {
-                if (value === undefined) {
-                    reject('Service data not exists');
-                }
-                else if ('primaryService' in value) {
-                    resolve(value);
-                }
-                else {
-                    reject('Service data corrupted');
-                }
-            });
-        });
+        const entry = Storage.memoryStorage.get(oldestKey.value);
+        if (entry) {
+          clearTimeout(entry.timeoutHandle);
+        }
+        Storage.memoryStorage.delete(oldestKey.value);
+      }
     }
-    static loadAccessory(key) {
-        return Storage.load(StorageType_1.StorageType.ACCESSORY, key);
+    const timeoutHandle = setTimeout(() => {
+      const entry = Storage.memoryStorage.get(callbackID);
+      if (entry) {
+        Storage.log.debug(`Callback ${callbackID} timeout`);
+        Storage.memoryStorage.delete(callbackID);
+        entry.eventCallback.callback();
+      }
+    }, ttl);
+    Storage.memoryStorage.set(callbackID, {
+      eventCallback,
+      timeoutHandle
+    });
+    return callbackID;
+  }
+  static saveCustomCharacteristics(value) {
+    return Storage.save(
+      import_StorageType.StorageType.CUSTOM_CHARACTERISTICS,
+      void 0,
+      value
+    );
+  }
+  static saveService(key, value) {
+    return Storage.save(import_StorageType.StorageType.SERVICE, key, value);
+  }
+  static saveAccessory(key, value) {
+    return Storage.save(import_StorageType.StorageType.ACCESSORY, key, value);
+  }
+  static saveHost(key, serializedHost) {
+    return Storage.save(import_StorageType.StorageType.HOST, key, serializedHost);
+  }
+  static load(type, key) {
+    const itemName = key ? `${type}-${key}` : type;
+    Storage.log.trace(`Loading ${itemName}`);
+    return import_node_persist.default.get(itemName);
+  }
+  static loadCallback(key) {
+    const entry = Storage.memoryStorage.get(key);
+    if (entry) {
+      Storage.log.trace(`Returning callback ${key}`);
+      clearTimeout(entry.timeoutHandle);
+      Storage.memoryStorage.delete(key);
+      return entry.eventCallback;
     }
-    static loadHost(key) {
-        return Storage.load(StorageType_1.StorageType.HOST, key);
+    return void 0;
+  }
+  static loadCustomCharacteristics() {
+    return Storage.load(import_StorageType.StorageType.CUSTOM_CHARACTERISTICS);
+  }
+  static async loadService(key) {
+    const value = await Storage.load(import_StorageType.StorageType.SERVICE, key);
+    if (value === void 0) {
+      throw "Service data not exists";
     }
-    static uuid4Validate(uuid) {
-        return (0, uuid_1.validate)(uuid) && (0, uuid_1.version)(uuid) === 4;
+    if (typeof value === "object" && value !== null && "primaryService" in value) {
+      return value;
     }
+    throw "Service data corrupted";
+  }
+  static loadAccessory(key) {
+    return Storage.load(import_StorageType.StorageType.ACCESSORY, key);
+  }
+  static loadHost(key) {
+    return Storage.load(import_StorageType.StorageType.HOST, key);
+  }
+  static uuid4Validate(uuid) {
+    return (0, import_uuid.validate)(uuid) && (0, import_uuid.version)(uuid) === 4;
+  }
 }
-exports.Storage = Storage;
-Storage.storageInitialized = false;
-Storage.memoryStorage = {};
-Storage.log = (0, logger_1.logger)('NRCHKB', 'Storage');
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Storage
+});