@nextera.one/axis-server-sdk 2.3.20 → 2.3.22

package/dist/index.mjs

@@ -8689,8 +8689,9 @@ var init_sensor_registry = __esm({
   "src/engine/registry/sensor.registry.ts"() {
     init_axis_logger();
     SensorRegistry = class _SensorRegistry {
-      constructor(configService) {
+      constructor(configService, sensorConfigProvider) {
         this.configService = configService;
+        this.sensorConfigProvider = sensorConfigProvider;
         this.sensors = [];
         this.sensorsByName = /* @__PURE__ */ new Map();
         this.sensorsByType = /* @__PURE__ */ new Map();
@@ -8700,22 +8701,6 @@ var init_sensor_registry = __esm({
         if (!sensor.name) {
           throw new Error("AxisSensor must have a name");
         }
-        const enabledSensorsStr = this.configService?.get("ENABLED_SENSORS");
-        const disabledSensorsStr = this.configService?.get("DISABLED_SENSORS");
-        const enabledSensors = enabledSensorsStr ? enabledSensorsStr.split(",").map((s) => s.trim()) : null;
-        const disabledSensors = disabledSensorsStr ? disabledSensorsStr.split(",").map((s) => s.trim()) : [];
-        if (enabledSensors && !enabledSensors.includes(sensor.name)) {
-          this.logger.log(
-            `Skipping disabled sensor (not in ENABLED_SENSORS): ${sensor.name}`
-          );
-          return;
-        }
-        if (disabledSensors.includes(sensor.name)) {
-          this.logger.log(
-            `Skipping disabled sensor (in DISABLED_SENSORS): ${sensor.name}`
-          );
-          return;
-        }
         if (sensor.order === void 0) {
           throw new Error(`AxisSensor "${sensor.name}" must have an order field`);
         }
@@ -8739,18 +8724,21 @@ var init_sensor_registry = __esm({
         );
       }
       list() {
-        return [...this.sensors].sort(
+        return this.filterEnabledSensors(this.sensors).sort(
           (a, b) => (a.order ?? 999) - (b.order ?? 999)
         );
       }
       resolve(ref) {
         if (typeof ref === "string") {
-          return this.sensorsByName.get(ref);
+          const sensor2 = this.sensorsByName.get(ref);
+          return sensor2 && this.isSensorEnabled(sensor2) ? sensor2 : void 0;
         }
-        return this.sensorsByType.get(ref) ?? this.sensorsByName.get(ref.name);
+        const sensor = this.sensorsByType.get(ref) ?? this.sensorsByName.get(ref.name);
+        return sensor && this.isSensorEnabled(sensor) ? sensor : void 0;
       }
       getByName(name) {
-        return this.sensorsByName.get(name);
+        const sensor = this.sensorsByName.get(name);
+        return sensor && this.isSensorEnabled(sensor) ? sensor : void 0;
       }
       getPreDecodeSensors() {
         return this.list().filter(
@@ -8773,6 +8761,22 @@ var init_sensor_registry = __esm({
         this.sensorsByName.clear();
         this.sensorsByType.clear();
       }
+      getSensorConfig() {
+        const providerSnapshot = this.sensorConfigProvider?.getSensorConfig();
+        const source = this.getSensorsSource(providerSnapshot);
+        if (source !== "ENV" && providerSnapshot) {
+          return {
+            source,
+            enabledSensors: this.normalizeList(providerSnapshot.enabledSensors),
+            disabledSensors: this.normalizeList(providerSnapshot.disabledSensors)
+          };
+        }
+        return {
+          source,
+          enabledSensors: this.parseConfigList("ENABLED_SENSORS"),
+          disabledSensors: this.parseConfigList("DISABLED_SENSORS")
+        };
+      }
       isPreDecodeSensor(sensor) {
         const phase = typeof sensor.phase === "string" ? sensor.phase : sensor.phase?.phase;
         if (phase) return phase === "PRE_DECODE";
@@ -8792,6 +8796,48 @@ var init_sensor_registry = __esm({
           this.sensorsByName.set(sensorType.name, sensor);
         }
       }
+      filterEnabledSensors(sensors) {
+        return sensors.filter((sensor) => this.isSensorEnabled(sensor));
+      }
+      isSensorEnabled(sensor) {
+        const config = this.getSensorConfig();
+        const enabled = new Set(config.enabledSensors);
+        const disabled = new Set(config.disabledSensors);
+        const names = this.getSensorNames(sensor);
+        if (names.some((name) => disabled.has(name))) {
+          return false;
+        }
+        if (enabled.size > 0 && !names.some((name) => enabled.has(name))) {
+          return false;
+        }
+        return true;
+      }
+      getSensorNames(sensor) {
+        const names = [sensor.name];
+        const constructorName = sensor.constructor?.name;
+        if (constructorName && !names.includes(constructorName)) {
+          names.push(constructorName);
+        }
+        return names;
+      }
+      getSensorsSource(providerSnapshot) {
+        const raw = this.configService?.get("SENSORS_SOURCE") ?? providerSnapshot?.source ?? "ENV";
+        const normalized = String(raw || "ENV").trim().toUpperCase();
+        return normalized || "ENV";
+      }
+      parseConfigList(key) {
+        return this.normalizeList(this.configService?.get(key));
+      }
+      normalizeList(value) {
+        if (!value) return [];
+        if (Array.isArray(value)) {
+          return value.map((entry) => String(entry).trim()).filter(Boolean);
+        }
+        if (typeof value === "string") {
+          return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+        }
+        return [];
+      }
     };
   }
 });