@iobroker/js-controller-adapter 7.2.3 → 8.0.0-alpha.2-20260923-99da17fcc

package/build/cjs/lib/adapter/log.js

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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 });
@@ -22,6 +23,9 @@ __export(log_exports, {
 });
 module.exports = __toCommonJS(log_exports);
 class Log {
+  static {
+    __name(this, "Log");
+  }
   namespaceLog;
   level;
   // TODO: this should be a winston.Logger, but the exported types will mess up because of https://github.com/microsoft/rushstack/issues/2220
@@ -41,18 +45,43 @@ class Log {
     this.error = this.error.bind(this);
     this.warn = this.warn.bind(this);
   }
+  /**
+   * Log a message at the silly level, prefixed with the adapter namespace
+   *
+   * @param msg the message to log
+   */
   silly(msg) {
     this.logger.silly(`${this.namespaceLog} ${msg}`);
   }
+  /**
+   * Log a message at the debug level, prefixed with the adapter namespace
+   *
+   * @param msg the message to log
+   */
   debug(msg) {
     this.logger.debug(`${this.namespaceLog} ${msg}`);
   }
+  /**
+   * Log a message at the info level, prefixed with the adapter namespace
+   *
+   * @param msg the message to log
+   */
   info(msg) {
     this.logger.info(`${this.namespaceLog} ${msg}`);
   }
+  /**
+   * Log a message at the error level, prefixed with the adapter namespace
+   *
+   * @param msg the message to log
+   */
   error(msg) {
     this.logger.error(`${this.namespaceLog} ${msg}`);
   }
+  /**
+   * Log a message at the warn level, prefixed with the adapter namespace
+   *
+   * @param msg the message to log
+   */
   warn(msg) {
     this.logger.warn(`${this.namespaceLog} ${msg}`);
   }

package/build/cjs/lib/adapter/log.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/lib/adapter/log.ts"],
-  "sourcesContent": ["type LogFunction = (msg: string) => void;\n\n/**\n * Log class for adapter.js\n *\n * It prefixes every message with the given namespace\n */\nexport class Log implements ioBroker.Logger {\n    private readonly namespaceLog: string;\n    readonly level: ioBroker.LogLevel;\n    // TODO: this should be a winston.Logger, but the exported types will mess up because of https://github.com/microsoft/rushstack/issues/2220\n    private readonly logger: {\n        silly: LogFunction;\n        debug: LogFunction;\n        info: LogFunction;\n        warn: LogFunction;\n        error: LogFunction;\n    };\n\n    /**\n     * @param namespaceLog Logging namespace to prefix\n     * @param level The log level\n     * @param logger logger instance\n     */\n    constructor(namespaceLog: string, level: ioBroker.LogLevel, logger: any) {\n        this.namespaceLog = namespaceLog;\n        this.level = level;\n        // We have to bind the `this` context here, or it is possible that `this` is\n        // undefined when passing around the logger methods. This happens e.g. when doing this:\n        //   const log = new Log(...);\n        //   const test = log.info;\n        //   test();\n        this.logger = logger;\n        this.silly = this.silly.bind(this);\n        this.debug = this.debug.bind(this);\n        this.info = this.info.bind(this);\n        this.error = this.error.bind(this);\n        this.warn = this.warn.bind(this);\n    }\n\n    silly(msg: string): void {\n        this.logger.silly(`${this.namespaceLog} ${msg}`);\n    }\n\n    debug(msg: string): void {\n        this.logger.debug(`${this.namespaceLog} ${msg}`);\n    }\n\n    info(msg: string): void {\n        this.logger.info(`${this.namespaceLog} ${msg}`);\n    }\n\n    error(msg: string): void {\n        this.logger.error(`${this.namespaceLog} ${msg}`);\n    }\n\n    warn(msg: string): void {\n        this.logger.warn(`${this.namespaceLog} ${msg}`);\n    }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAEA;;;;;AAKM,MAAO,IAAG;EACK;EACR;;EAEQ;;;;;;EAajB,YAAY,cAAsB,OAA0B,QAAW;AACnE,SAAK,eAAe;AACpB,SAAK,QAAQ;AAMb,SAAK,SAAS;AACd,SAAK,QAAQ,KAAK,MAAM,KAAK,IAAI;AACjC,SAAK,QAAQ,KAAK,MAAM,KAAK,IAAI;AACjC,SAAK,OAAO,KAAK,KAAK,KAAK,IAAI;AAC/B,SAAK,QAAQ,KAAK,MAAM,KAAK,IAAI;AACjC,SAAK,OAAO,KAAK,KAAK,KAAK,IAAI;EACnC;EAEA,MAAM,KAAW;AACb,SAAK,OAAO,MAAM,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EACnD;EAEA,MAAM,KAAW;AACb,SAAK,OAAO,MAAM,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EACnD;EAEA,KAAK,KAAW;AACZ,SAAK,OAAO,KAAK,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EAClD;EAEA,MAAM,KAAW;AACb,SAAK,OAAO,MAAM,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EACnD;EAEA,KAAK,KAAW;AACZ,SAAK,OAAO,KAAK,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EAClD;;",
+  "sourcesContent": ["type LogFunction = (msg: string) => void;\n\n/**\n * Log class for adapter.js\n *\n * It prefixes every message with the given namespace\n */\nexport class Log implements ioBroker.Logger {\n    private readonly namespaceLog: string;\n    readonly level: ioBroker.LogLevel;\n    // TODO: this should be a winston.Logger, but the exported types will mess up because of https://github.com/microsoft/rushstack/issues/2220\n    private readonly logger: {\n        silly: LogFunction;\n        debug: LogFunction;\n        info: LogFunction;\n        warn: LogFunction;\n        error: LogFunction;\n    };\n\n    /**\n     * @param namespaceLog Logging namespace to prefix\n     * @param level The log level\n     * @param logger logger instance\n     */\n    constructor(namespaceLog: string, level: ioBroker.LogLevel, logger: any) {\n        this.namespaceLog = namespaceLog;\n        this.level = level;\n        // We have to bind the `this` context here, or it is possible that `this` is\n        // undefined when passing around the logger methods. This happens e.g. when doing this:\n        //   const log = new Log(...);\n        //   const test = log.info;\n        //   test();\n        this.logger = logger;\n        this.silly = this.silly.bind(this);\n        this.debug = this.debug.bind(this);\n        this.info = this.info.bind(this);\n        this.error = this.error.bind(this);\n        this.warn = this.warn.bind(this);\n    }\n\n    /**\n     * Log a message at the silly level, prefixed with the adapter namespace\n     *\n     * @param msg the message to log\n     */\n    silly(msg: string): void {\n        this.logger.silly(`${this.namespaceLog} ${msg}`);\n    }\n\n    /**\n     * Log a message at the debug level, prefixed with the adapter namespace\n     *\n     * @param msg the message to log\n     */\n    debug(msg: string): void {\n        this.logger.debug(`${this.namespaceLog} ${msg}`);\n    }\n\n    /**\n     * Log a message at the info level, prefixed with the adapter namespace\n     *\n     * @param msg the message to log\n     */\n    info(msg: string): void {\n        this.logger.info(`${this.namespaceLog} ${msg}`);\n    }\n\n    /**\n     * Log a message at the error level, prefixed with the adapter namespace\n     *\n     * @param msg the message to log\n     */\n    error(msg: string): void {\n        this.logger.error(`${this.namespaceLog} ${msg}`);\n    }\n\n    /**\n     * Log a message at the warn level, prefixed with the adapter namespace\n     *\n     * @param msg the message to log\n     */\n    warn(msg: string): void {\n        this.logger.warn(`${this.namespaceLog} ${msg}`);\n    }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAEA;;;;;AAKM,MAAO,IAAG;EALhB,OAKgB;;;EACK;EACR;;EAEQ;;;;;;EAajB,YAAY,cAAsB,OAA0B,QAAW;AACnE,SAAK,eAAe;AACpB,SAAK,QAAQ;AAMb,SAAK,SAAS;AACd,SAAK,QAAQ,KAAK,MAAM,KAAK,IAAI;AACjC,SAAK,QAAQ,KAAK,MAAM,KAAK,IAAI;AACjC,SAAK,OAAO,KAAK,KAAK,KAAK,IAAI;AAC/B,SAAK,QAAQ,KAAK,MAAM,KAAK,IAAI;AACjC,SAAK,OAAO,KAAK,KAAK,KAAK,IAAI;EACnC;;;;;;EAOA,MAAM,KAAW;AACb,SAAK,OAAO,MAAM,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EACnD;;;;;;EAOA,MAAM,KAAW;AACb,SAAK,OAAO,MAAM,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EACnD;;;;;;EAOA,KAAK,KAAW;AACZ,SAAK,OAAO,KAAK,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EAClD;;;;;;EAOA,MAAM,KAAW;AACb,SAAK,OAAO,MAAM,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EACnD;;;;;;EAOA,KAAK,KAAW;AACZ,SAAK,OAAO,KAAK,GAAG,KAAK,YAAY,IAAI,GAAG,EAAE;EAClD;;",
   "names": []
 }

package/build/cjs/lib/adapter/managers/AdapterContextBase.d.ts

@@ -0,0 +1,49 @@
+import type { Client as StatesInRedisClient } from '@iobroker/db-states-redis';
+import type { Client as ObjectsInRedisClient } from '@iobroker/db-objects-redis';
+import type { AdapterContext } from '../../../lib/adapter/context.js';
+/**
+ * Base class for adapter managers that read from the shared {@link AdapterContext}.
+ *
+ * Holds the context in a private `#ctx` field so subclasses cannot bypass the connection-checked
+ * getters and reach the raw (possibly null) DB clients directly. Access to `states`/`objects` goes
+ * through the throwing getters, which raise `ERROR_DB_CLOSED` when the respective database is not
+ * connected; the other getters pass ctx values through unchanged.
+ *
+ * Getters are `protected` because `#` privates are not visible to subclasses.
+ */
+export declare abstract class AdapterContextBase {
+    #private;
+    /**
+     * @param ctx Shared adapter context providing live runtime state
+     */
+    constructor(ctx: AdapterContext);
+    /**
+     * The connected states DB client.
+     *
+     * @throws {Error} `ERROR_DB_CLOSED` when the states database is not connected.
+     */
+    protected get states(): StatesInRedisClient;
+    /**
+     * The connected objects DB client.
+     *
+     * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected.
+     */
+    protected get objects(): ObjectsInRedisClient;
+    /** Current adapter common config */
+    protected get common(): ioBroker.InstanceCommon | undefined;
+    /** Current adapter instance config (native) */
+    protected get config(): ioBroker.AdapterConfig;
+    /** Current host name (may be undefined before init) */
+    protected get host(): string | undefined;
+    /** Current adapter namespace, e.g. `"adapter.0"` */
+    protected get namespace(): `${string}.${number}`;
+    /** Current namespace string used in log messages */
+    protected get namespaceLog(): string;
+    /** Logger instance */
+    protected get logger(): AdapterContext['logger'];
+    /** Controller for UI messaging */
+    protected get uiMessagingController(): AdapterContext['uiMessagingController'];
+    /** Increment the adapter's outbound-write counter. */
+    protected countOutput(): void;
+}
+//# sourceMappingURL=AdapterContextBase.d.ts.map

package/build/cjs/lib/adapter/managers/AdapterContextBase.js

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AdapterContextBase_exports = {};
+__export(AdapterContextBase_exports, {
+  AdapterContextBase: () => AdapterContextBase
+});
+module.exports = __toCommonJS(AdapterContextBase_exports);
+var import_js_controller_common = require("@iobroker/js-controller-common");
+class AdapterContextBase {
+  static {
+    __name(this, "AdapterContextBase");
+  }
+  #ctx;
+  /**
+   * @param ctx Shared adapter context providing live runtime state
+   */
+  constructor(ctx) {
+    this.#ctx = ctx;
+  }
+  /**
+   * The connected states DB client.
+   *
+   * @throws {Error} `ERROR_DB_CLOSED` when the states database is not connected.
+   */
+  get states() {
+    const states = this.#ctx.states;
+    if (!states) {
+      throw new Error(import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
+    }
+    return states;
+  }
+  /**
+   * The connected objects DB client.
+   *
+   * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected.
+   */
+  get objects() {
+    const objects = this.#ctx.objects;
+    if (!objects) {
+      throw new Error(import_js_controller_common.tools.ERRORS.ERROR_DB_CLOSED);
+    }
+    return objects;
+  }
+  /** Current adapter common config */
+  get common() {
+    return this.#ctx.common;
+  }
+  /** Current adapter instance config (native) */
+  get config() {
+    return this.#ctx.config;
+  }
+  /** Current host name (may be undefined before init) */
+  get host() {
+    return this.#ctx.host;
+  }
+  /** Current adapter namespace, e.g. `"adapter.0"` */
+  get namespace() {
+    return this.#ctx.namespace;
+  }
+  /** Current namespace string used in log messages */
+  get namespaceLog() {
+    return this.#ctx.namespaceLog;
+  }
+  /** Logger instance */
+  get logger() {
+    return this.#ctx.logger;
+  }
+  /** Controller for UI messaging */
+  get uiMessagingController() {
+    return this.#ctx.uiMessagingController;
+  }
+  /** Increment the adapter's outbound-write counter. */
+  countOutput() {
+    this.#ctx.countOutput();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdapterContextBase
+});
+//# sourceMappingURL=AdapterContextBase.js.map

package/build/cjs/lib/adapter/managers/AdapterContextBase.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/adapter/managers/AdapterContextBase.ts"],
+  "sourcesContent": ["import type { Client as StatesInRedisClient } from '@iobroker/db-states-redis';\nimport type { Client as ObjectsInRedisClient } from '@iobroker/db-objects-redis';\nimport type { AdapterContext } from '@/lib/adapter/context.js';\nimport { tools } from '@iobroker/js-controller-common';\n\n/**\n * Base class for adapter managers that read from the shared {@link AdapterContext}.\n *\n * Holds the context in a private `#ctx` field so subclasses cannot bypass the connection-checked\n * getters and reach the raw (possibly null) DB clients directly. Access to `states`/`objects` goes\n * through the throwing getters, which raise `ERROR_DB_CLOSED` when the respective database is not\n * connected; the other getters pass ctx values through unchanged.\n *\n * Getters are `protected` because `#` privates are not visible to subclasses.\n */\nexport abstract class AdapterContextBase {\n    readonly #ctx: AdapterContext;\n\n    /**\n     * @param ctx Shared adapter context providing live runtime state\n     */\n    constructor(ctx: AdapterContext) {\n        this.#ctx = ctx;\n    }\n\n    /**\n     * The connected states DB client.\n     *\n     * @throws {Error} `ERROR_DB_CLOSED` when the states database is not connected.\n     */\n    protected get states(): StatesInRedisClient {\n        const states = this.#ctx.states;\n        if (!states) {\n            throw new Error(tools.ERRORS.ERROR_DB_CLOSED);\n        }\n        return states;\n    }\n\n    /**\n     * The connected objects DB client.\n     *\n     * @throws {Error} `ERROR_DB_CLOSED` when the objects database is not connected.\n     */\n    protected get objects(): ObjectsInRedisClient {\n        const objects = this.#ctx.objects;\n        if (!objects) {\n            throw new Error(tools.ERRORS.ERROR_DB_CLOSED);\n        }\n        return objects;\n    }\n\n    /** Current adapter common config */\n    protected get common(): ioBroker.InstanceCommon | undefined {\n        return this.#ctx.common;\n    }\n\n    /** Current adapter instance config (native) */\n    protected get config(): ioBroker.AdapterConfig {\n        return this.#ctx.config;\n    }\n\n    /** Current host name (may be undefined before init) */\n    protected get host(): string | undefined {\n        return this.#ctx.host;\n    }\n\n    /** Current adapter namespace, e.g. `\"adapter.0\"` */\n    protected get namespace(): `${string}.${number}` {\n        return this.#ctx.namespace;\n    }\n\n    /** Current namespace string used in log messages */\n    protected get namespaceLog(): string {\n        return this.#ctx.namespaceLog;\n    }\n\n    /** Logger instance */\n    protected get logger(): AdapterContext['logger'] {\n        return this.#ctx.logger;\n    }\n\n    /** Controller for UI messaging */\n    protected get uiMessagingController(): AdapterContext['uiMessagingController'] {\n        return this.#ctx.uiMessagingController;\n    }\n\n    /** Increment the adapter's outbound-write counter. */\n    protected countOutput(): void {\n        this.#ctx.countOutput();\n    }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAGA;;;;;AAAA,kCAAsB;AAYhB,MAAgB,mBAAkB;EAZxC,OAYwC;;;EAC3B;;;;EAKT,YAAY,KAAmB;AAC3B,SAAK,OAAO;EAChB;;;;;;EAOA,IAAc,SAAM;AAChB,UAAM,SAAS,KAAK,KAAK;AACzB,QAAI,CAAC,QAAQ;AACT,YAAM,IAAI,MAAM,kCAAM,OAAO,eAAe;IAChD;AACA,WAAO;EACX;;;;;;EAOA,IAAc,UAAO;AACjB,UAAM,UAAU,KAAK,KAAK;AAC1B,QAAI,CAAC,SAAS;AACV,YAAM,IAAI,MAAM,kCAAM,OAAO,eAAe;IAChD;AACA,WAAO;EACX;;EAGA,IAAc,SAAM;AAChB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,SAAM;AAChB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,OAAI;AACd,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,YAAS;AACnB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,eAAY;AACtB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,SAAM;AAChB,WAAO,KAAK,KAAK;EACrB;;EAGA,IAAc,wBAAqB;AAC/B,WAAO,KAAK,KAAK;EACrB;;EAGU,cAAW;AACjB,SAAK,KAAK,YAAW;EACzB;;",
+  "names": []
+}

package/build/cjs/lib/adapter/managers/AliasManager.d.ts

@@ -0,0 +1,103 @@
+import type { AliasTargetEntry } from '../../_Types.js';
+import type { ValidateIdOptions } from '../../../lib/adapter/validator.js';
+import type { AdapterContext } from '../../../lib/adapter/context.js';
+import { AdapterContextBase } from '../../../lib/adapter/managers/AdapterContextBase.js';
+/** Validates a (possibly foreign) id; throws on invalid. Bound to the adapter's Validator. */
+export type ValidateId = (id: string, isForeignId: boolean, options?: ValidateIdOptions | null) => void;
+/**
+ * Owns the alias subscription cache and its bookkeeping: which real (source) states feed which
+ * `alias.*` targets, the alias subscription patterns, and the single `alias.*` object subscription.
+ * The source-state change fan-out ({@link resolveSourceChange}) is synchronous by contract so the
+ * state-change handler cannot interleave a cache mutation mid-fan-out.
+ */
+export declare class AliasManager extends AdapterContextBase {
+    #private;
+    /**
+     * @param ctx Shared adapter context providing live runtime state
+     * @param validateId Bound id validator from the adapter's Validator instance
+     */
+    constructor(ctx: AdapterContext, validateId: ValidateId);
+    /**
+     * Whether the given source (real) state id currently feeds any alias.
+     *
+     * @param id the real source state id
+     */
+    hasSource(id: string): boolean;
+    /** Number of tracked source states. */
+    get size(): number;
+    /**
+     * Whether the given subscription pattern is tracked.
+     *
+     * @param pattern the subscription pattern
+     */
+    hasPattern(pattern: string): boolean;
+    /**
+     * Track a subscription pattern.
+     *
+     * @param pattern the subscription pattern
+     */
+    addPattern(pattern: string): void;
+    /**
+     * Stop tracking a subscription pattern.
+     *
+     * @param pattern the subscription pattern
+     */
+    deletePattern(pattern: string): void;
+    /**
+     * Whether `id` falls into any tracked alias pattern (wildcards via pattern2RegEx).
+     *
+     * @param id the id to test against the tracked patterns
+     */
+    matchesAnyPattern(id: string): boolean;
+    /**
+     * Reacts to a change of an `alias.*` object: re-points, updates, or removes the target across the
+     * tracked sources, and picks up a newly-appeared alias that falls into a tracked pattern.
+     * Live-iterates the cache while awaiting add/remove — the loop lives here, with the map, to
+     * preserve the original mutation-during-iteration semantics exactly.
+     *
+     * @param id the changed alias object id
+     * @param obj the new object (null/undefined if deleted)
+     */
+    handleAliasObjectChange(id: string, obj: ioBroker.Object | null | undefined): Promise<void>;
+    /**
+     * Removes every target subscribed under the given pattern, live-iterating the cache so a removal
+     * mutating the map mid-loop keeps the original semantics. Awaits each removal.
+     *
+     * @param pattern the subscription pattern being unsubscribed
+     */
+    removeTargetsForPattern(pattern: string): Promise<void>;
+    /**
+     * Synchronously computes the fan-out of a source (real) state change to its alias targets.
+     * Returns one `{ targetId, state }` per unique target. MUST NOT await — the caller relies on the
+     * cache not mutating between read and emit.
+     *
+     * @param sourceId the changed real state id
+     * @param state the new state value (or null on deletion)
+     */
+    resolveSourceChange(sourceId: string, state: ioBroker.State | null | undefined): Array<{
+        targetId: string;
+        state: ioBroker.State | null;
+    }>;
+    /** Subscribe the `alias.*` object range once (idempotent). */
+    ensureAliasObjectSubscription(): void;
+    /** Drop the `alias.*` object subscription when no aliases remain. */
+    maybeDropAliasObjectSubscription(): void;
+    /**
+     * Register an alias target for its source state, subscribing the source state (and reading its
+     * metadata once). Preserves the create-before-await ordering and the post-await existence
+     * re-check that guard a concurrent removal.
+     *
+     * @param aliasObj the `alias.*` object being subscribed
+     * @param pattern the subscription pattern that pulled it in
+     */
+    addAliasSubscribe(aliasObj: ioBroker.AnyObject, pattern: string): Promise<void>;
+    /**
+     * Remove one alias target from its source; when the source has no targets left, delete the entry
+     * and unsubscribe the source state.
+     *
+     * @param sourceId the real source state id
+     * @param aliasObjOrIdx the target entry or its index in the targets array
+     */
+    removeAliasSubscribe(sourceId: string, aliasObjOrIdx: number | AliasTargetEntry): Promise<void>;
+}
+//# sourceMappingURL=AliasManager.d.ts.map

package/build/cjs/lib/adapter/managers/AliasManager.js

@@ -0,0 +1,293 @@
+"use strict";
+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 __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 });
+};
+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 AliasManager_exports = {};
+__export(AliasManager_exports, {
+  AliasManager: () => AliasManager
+});
+module.exports = __toCommonJS(AliasManager_exports);
+var import_js_controller_common = require("@iobroker/js-controller-common");
+var import_deep_clone = __toESM(require("deep-clone"), 1);
+var import_AdapterContextBase = require("../../../lib/adapter/managers/AdapterContextBase.js");
+var import_constants = require("../../../lib/adapter/constants.js");
+class AliasManager extends import_AdapterContextBase.AdapterContextBase {
+  static {
+    __name(this, "AliasManager");
+  }
+  #aliases = /* @__PURE__ */ new Map();
+  #aliasPatterns = /* @__PURE__ */ new Set();
+  #aliasObjectsSubscribed = false;
+  #validateId;
+  /**
+   * @param ctx Shared adapter context providing live runtime state
+   * @param validateId Bound id validator from the adapter's Validator instance
+   */
+  constructor(ctx, validateId) {
+    super(ctx);
+    this.#validateId = validateId;
+  }
+  /**
+   * Whether the given source (real) state id currently feeds any alias.
+   *
+   * @param id the real source state id
+   */
+  hasSource(id) {
+    return this.#aliases.has(id);
+  }
+  /** Number of tracked source states. */
+  get size() {
+    return this.#aliases.size;
+  }
+  /**
+   * Whether the given subscription pattern is tracked.
+   *
+   * @param pattern the subscription pattern
+   */
+  hasPattern(pattern) {
+    return this.#aliasPatterns.has(pattern);
+  }
+  /**
+   * Track a subscription pattern.
+   *
+   * @param pattern the subscription pattern
+   */
+  addPattern(pattern) {
+    this.#aliasPatterns.add(pattern);
+  }
+  /**
+   * Stop tracking a subscription pattern.
+   *
+   * @param pattern the subscription pattern
+   */
+  deletePattern(pattern) {
+    this.#aliasPatterns.delete(pattern);
+  }
+  /**
+   * Whether `id` falls into any tracked alias pattern (wildcards via pattern2RegEx).
+   *
+   * @param id the id to test against the tracked patterns
+   */
+  matchesAnyPattern(id) {
+    for (const aliasPattern of this.#aliasPatterns) {
+      const testPattern = aliasPattern.slice(-1) === "*" ? new RegExp(import_js_controller_common.tools.pattern2RegEx(aliasPattern)) : aliasPattern;
+      if (typeof testPattern === "string" && aliasPattern === id || testPattern instanceof RegExp && testPattern.test(id)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Reacts to a change of an `alias.*` object: re-points, updates, or removes the target across the
+   * tracked sources, and picks up a newly-appeared alias that falls into a tracked pattern.
+   * Live-iterates the cache while awaiting add/remove — the loop lives here, with the map, to
+   * preserve the original mutation-during-iteration semantics exactly.
+   *
+   * @param id the changed alias object id
+   * @param obj the new object (null/undefined if deleted)
+   */
+  async handleAliasObjectChange(id, obj) {
+    let isNewAlias = true;
+    for (const [sourceId, alias] of this.#aliases) {
+      const targetAlias = alias.targets.find((entry) => entry.id === id);
+      if (targetAlias) {
+        isNewAlias = false;
+        if (obj?.common?.alias?.id) {
+          const newSourceId = typeof obj.common.alias.id.read === "string" ? obj.common.alias.id.read : obj.common.alias.id;
+          if (newSourceId !== sourceId) {
+            await this.removeAliasSubscribe(sourceId, targetAlias);
+            try {
+              await this.addAliasSubscribe(obj, targetAlias.pattern);
+            } catch (e) {
+              this.logger.error(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);
+            }
+          } else {
+            targetAlias.min = obj.common.min;
+            targetAlias.max = obj.common.max;
+            targetAlias.type = obj.common.type;
+            targetAlias.alias = (0, import_deep_clone.default)(obj.common.alias);
+          }
+        } else {
+          await this.removeAliasSubscribe(sourceId, targetAlias);
+        }
+      }
+    }
+    if (isNewAlias && obj && this.matchesAnyPattern(id)) {
+      try {
+        await this.addAliasSubscribe(obj, id);
+      } catch (e) {
+        this.logger.warn(`${this.namespaceLog} Could not add alias subscription: ${e.message}`);
+      }
+    }
+  }
+  /**
+   * Removes every target subscribed under the given pattern, live-iterating the cache so a removal
+   * mutating the map mid-loop keeps the original semantics. Awaits each removal.
+   *
+   * @param pattern the subscription pattern being unsubscribed
+   */
+  async removeTargetsForPattern(pattern) {
+    const promises = new Array();
+    for (const [sourceId, alias] of this.#aliases) {
+      for (let i = alias.targets.length - 1; i >= 0; i--) {
+        if (alias.targets[i].pattern === pattern) {
+          promises.push(this.removeAliasSubscribe(sourceId, i));
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  /**
+   * Synchronously computes the fan-out of a source (real) state change to its alias targets.
+   * Returns one `{ targetId, state }` per unique target. MUST NOT await — the caller relies on the
+   * cache not mutating between read and emit.
+   *
+   * @param sourceId the changed real state id
+   * @param state the new state value (or null on deletion)
+   */
+  resolveSourceChange(sourceId, state) {
+    const out = new Array();
+    const alias = this.#aliases.get(sourceId);
+    if (!alias) {
+      return out;
+    }
+    const uniqueTargets = /* @__PURE__ */ new Set();
+    for (const target of alias.targets) {
+      const targetId = target.id;
+      if (uniqueTargets.has(targetId)) {
+        continue;
+      }
+      uniqueTargets.add(targetId);
+      const aState = state ? import_js_controller_common.tools.formatAliasValue({
+        sourceCommon: alias.source,
+        targetCommon: target,
+        state: (0, import_deep_clone.default)(state),
+        logger: this.logger,
+        logNamespace: this.namespaceLog,
+        sourceId,
+        targetId
+      }) : null;
+      if (aState || !state) {
+        out.push({ targetId, state: aState });
+      }
+    }
+    return out;
+  }
+  /** Subscribe the `alias.*` object range once (idempotent). */
+  ensureAliasObjectSubscription() {
+    if (!this.#aliasObjectsSubscribed) {
+      this.#aliasObjectsSubscribed = true;
+      this.objects.subscribe(`${import_constants.ALIAS_STARTS_WITH}*`);
+    }
+  }
+  /** Drop the `alias.*` object subscription when no aliases remain. */
+  maybeDropAliasObjectSubscription() {
+    if (!this.#aliases.size && this.#aliasObjectsSubscribed) {
+      this.#aliasObjectsSubscribed = false;
+      this.objects.unsubscribe(`${import_constants.ALIAS_STARTS_WITH}*`);
+    }
+  }
+  /**
+   * Register an alias target for its source state, subscribing the source state (and reading its
+   * metadata once). Preserves the create-before-await ordering and the post-await existence
+   * re-check that guard a concurrent removal.
+   *
+   * @param aliasObj the `alias.*` object being subscribed
+   * @param pattern the subscription pattern that pulled it in
+   */
+  async addAliasSubscribe(aliasObj, pattern) {
+    if (aliasObj.type !== "state") {
+      return;
+    }
+    if (!aliasObj.common?.alias?.id) {
+      this.logger.warn(`${this.namespaceLog} Alias ${aliasObj._id} has no target 5`);
+      throw new Error(`Alias ${aliasObj._id} has no target`);
+    }
+    const sourceId = import_js_controller_common.tools.isObject(aliasObj.common.alias.id) ? aliasObj.common.alias.id.read : aliasObj.common.alias.id;
+    try {
+      this.#validateId(sourceId, true, null);
+    } catch (e) {
+      throw new Error(`Error validating alias id of ${aliasObj._id}: ${e.message}`);
+    }
+    const targetEntry = {
+      alias: (0, import_deep_clone.default)(aliasObj.common.alias),
+      id: aliasObj._id,
+      pattern,
+      type: aliasObj.common.type,
+      max: aliasObj.common.max,
+      min: aliasObj.common.min,
+      unit: aliasObj.common.unit
+    };
+    let aliasDetails;
+    if (!this.#aliases.has(sourceId)) {
+      aliasDetails = { targets: [] };
+      this.#aliases.set(sourceId, aliasDetails);
+    } else {
+      aliasDetails = this.#aliases.get(sourceId);
+    }
+    if (!aliasDetails.source) {
+      await this.states.subscribe(sourceId);
+      const sourceObj = await this.objects.getObject(sourceId, { user: import_constants.SYSTEM_ADMIN_USER });
+      if (sourceObj?.common && this.#aliases.has(sourceObj._id)) {
+        aliasDetails.source = {
+          min: sourceObj.common.min,
+          max: sourceObj.common.max,
+          type: sourceObj.common.type,
+          unit: sourceObj.common.unit
+        };
+      }
+    }
+    aliasDetails.targets.push(targetEntry);
+  }
+  /**
+   * Remove one alias target from its source; when the source has no targets left, delete the entry
+   * and unsubscribe the source state.
+   *
+   * @param sourceId the real source state id
+   * @param aliasObjOrIdx the target entry or its index in the targets array
+   */
+  async removeAliasSubscribe(sourceId, aliasObjOrIdx) {
+    if (!this.#aliases.has(sourceId)) {
+      return;
+    }
+    const alias = this.#aliases.get(sourceId);
+    const pos = typeof aliasObjOrIdx === "number" ? aliasObjOrIdx : alias.targets.indexOf(aliasObjOrIdx);
+    if (pos !== -1) {
+      alias.targets.splice(pos, 1);
+      if (!alias.targets.length) {
+        this.#aliases.delete(sourceId);
+        await this.states.unsubscribe(sourceId);
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AliasManager
+});
+//# sourceMappingURL=AliasManager.js.map