@meshmakers/octo-meshboard 3.5.520 → 3.5.530

package/fesm2022/meshmakers-octo-meshboard.mjs

@@ -4350,6 +4350,29 @@ class QueryExecutorService {
             };
         }));
     }
+    /**
+     * Column metadata of a persisted stream-data query for the widget config pickers.
+     * Runs the query with `first: 1` and its own window first; a query that cannot run
+     * without a window — an `Integral` column over a raw archive requires from/to
+     * (AB#7921) — fails or returns no columns, so it is run once more with `window`
+     * (the board's time window or a recent default). The error of the retry propagates.
+     */
+    async fetchStreamDataColumns(queryRtId, window) {
+        try {
+            const result = await firstValueFrom(this.executeStreamData(queryRtId, { first: 1 }));
+            if (result.columns.length > 0) {
+                return result.columns;
+            }
+        }
+        catch {
+            // Fall through to the windowed retry below.
+        }
+        const windowed = await firstValueFrom(this.executeStreamData(queryRtId, {
+            first: 1,
+            streamDataArgs: { from: window.from, to: window.to }
+        }));
+        return windowed.columns;
+    }
     /**
      * Resolution-aware series routing (AB#4290): asks the backend which archive/rollup to
      * query for a base archive family, time window and target point count — so a widget can
@@ -6422,14 +6445,20 @@ const SUPPORTED_ROW_TYPES$1 = [
 function sanitizeFieldName(fieldName) {
     return fieldName.replace(/\./g, '_');
 }
+/**
+ * Trailing aggregation function suffix the engine appends to a wire-form column:
+ * `_count`, `_sum`, `_avg`, `_min`, `_max`, and `_integral` for the stream-data
+ * Integral (energy over the query window, AB#7921).
+ */
+const AGGREGATION_FUNCTION_SUFFIX = /_(?:count|sum|avg|min|max|integral)$/i;
 /**
  * Strips a trailing aggregation function suffix from a path so the base path can
  * be compared independently of which aggregation produced it. The engine emits
- * cell paths like `meterreading_count` / `amountvalue_sum` for RT aggregation,
- * grouped aggregation, and stream-data variants.
+ * cell paths like `meterreading_count` / `amountvalue_sum` / `importpower_integral`
+ * for RT aggregation, grouped aggregation, and stream-data variants.
  */
 function stripAggregationFunctionSuffix(path) {
-    return path.replace(/_(?:count|sum|avg|min|max)$/i, '');
+    return path.replace(AGGREGATION_FUNCTION_SUFFIX, '');
 }
 /**
  * Canonical key form: drop dot and underscore separators and lowercase the rest.
@@ -6443,11 +6472,11 @@ function toCanonicalAttributeKey(s) {
 }
 /**
  * Detects whether a path ends with the engine's aggregation function suffix
- * (`_count`, `_sum`, `_avg`, `_min`, `_max`). Used to decide whether the loose
- * back-compat fallback in {@link matchesAttributePath} should fire.
+ * (`_count`, `_sum`, `_avg`, `_min`, `_max`, `_integral`). Used to decide whether the
+ * loose back-compat fallback in {@link matchesAttributePath} should fire.
  */
 function hasAggregationFunctionSuffix(path) {
-    return /_(?:count|sum|avg|min|max)$/i.test(path);
+    return AGGREGATION_FUNCTION_SUFFIX.test(path);
 }
 /**
  * Returns true when a cell's `attributePath` refers to the same source attribute
@@ -6701,10 +6730,10 @@ function processPieChartData(rows, categoryField, valueField) {
 /**
  * Applies an optional scale factor to a query value (KPI `valueMultiplier`).
  * Only numeric values are scaled — strings (e.g. enum labels or error
- * placeholders) pass through unchanged, as does everything when no multiplier
- * is configured. Use case: cumulated energy from uniformly sampled power
- * (Σ(kW samples) × sampleIntervalHours → kWh); the factor is window-independent
- * because SUM is linear in the sample count.
+ * placeholders) and `null` (no data) pass through unchanged, as does everything
+ * when no multiplier is configured. Use case: the unit factor of an energy KPI
+ * over a stream-data Integral column (value × hours): 1 for kW → kWh, 0.001 for
+ * W → kWh (AB#7921).
  */
 function applyValueMultiplier(value, multiplier) {
     if (typeof multiplier !== 'number' || typeof value !== 'number') {
@@ -7184,8 +7213,8 @@ class KpiWidgetComponent {
                     value = this.extractGroupedAggregationValue(result);
                     break;
             }
-            // Optional scale factor (e.g. Σ(kW samples) × sampleInterval → kWh).
-            // Applied to numeric values only; strings pass through unchanged.
+            // Optional unit factor (e.g. 1 for an Integral over kW → kWh, 0.001 for W → kWh).
+            // Applied to numeric values only; strings and null (no data) pass through unchanged.
             value = applyValueMultiplier(value, this.config.valueMultiplier);
             // Create a synthetic entity with the value
             const kpiEntity = {
@@ -7254,10 +7283,12 @@ class KpiWidgetComponent {
     /**
      * Extracts a cell value, preserving strings and converting numbers.
      * Returns the value as-is if it's a string, or parses it as a number.
+     * A null cell is "no data" (e.g. an Integral over an empty window, AB#7921) and
+     * stays null, so the KPI shows its empty state instead of a misleading 0.
      */
     extractCellValue(value) {
         if (value === null || value === undefined)
-            return 0;
+            return null;
         if (typeof value === 'number')
             return value;
         if (typeof value === 'string') {
@@ -8082,14 +8113,24 @@ class KpiConfigDialogComponent {
                 aggregationType: c.aggregationType ?? null
             }));
         }
-        // Stream-data: execute with a tiny page just to surface columns.
-        const sdResult = await firstValueFrom(this.queryExecutor.executeStreamData(rtId, { first: 1 }));
-        return sdResult.columns.map(c => ({
+        // Stream-data: execute with a tiny page just to surface columns. An Integral
+        // column needs from/to (AB#7921), so the executor retries with the board's
+        // window — or the last 24 hours when the board has no time filter.
+        const columns = await this.queryExecutor.fetchStreamDataColumns(rtId, this.columnProbeWindow());
+        return columns.map(c => ({
             attributePath: c.attributePath,
             attributeValueType: c.attributeValueType ?? '',
             aggregationType: c.aggregationType ?? null
         }));
     }
+    columnProbeWindow() {
+        const boardWindow = this.meshBoardStateService.resolveStreamDataTimeArgs();
+        if (boardWindow) {
+            return boardWindow;
+        }
+        const to = new Date();
+        return { from: new Date(to.getTime() - 24 * 60 * 60 * 1000), to };
+    }
     async onCategoryFieldChange(categoryField) {
         this.form.queryCategoryField = categoryField;
         this.form.queryCategoryValue = '';