@meshmakers/octo-meshboard 3.4.1130 → 3.4.1140

package/fesm2022/meshmakers-octo-meshboard.mjs

@@ -2535,17 +2535,26 @@ class MeshBoardStateService {
     /**
      * The IANA time zone to forward to the resolution-aware series query so calendar
      * rollups are selected in the board's zone (AB#4190). Maps the board mode:
-     * `'utc'` → `'UTC'`, an IANA id → itself, and `'local'` → `undefined` (the browser's
-     * own zone has no server-side meaning, so the resolver stays on UTC — the same
-     * basis its calendar rungs use by default). The result is consistent with the zone
-     * `resolveCurrentTimeRange()` used to compute the `{from, to}` window.
+     * `'utc'` → `'UTC'`, an IANA id → itself, and `'local'` → the browser's own IANA
+     * zone. The result is therefore always the same basis `resolveCurrentTimeRange()`
+     * used to compute the `{from, to}` window — in `'local'` mode that window is built
+     * from browser-local wall clocks, so naming that zone is what makes the two agree.
+     *
+     * `'local'` used to send nothing, which left the resolver on UTC. Under the default
+     * per-query comparison policy a calendar rung stored in another zone then has no
+     * determinate grain and drops out of the ladder, so the board silently fell back to
+     * a finer rung, reported signal `Ok`, and drew a window that was not the one asked
+     * for (AB#5157 review). `undefined` now only means the browser named no zone at all.
      */
     resolveStreamDataTimeZone() {
         const mode = this.timeZoneMode();
+        if (mode === 'utc') {
+            return 'UTC';
+        }
         if (mode === 'local') {
-            return undefined;
+            return Intl.DateTimeFormat().resolvedOptions().timeZone || undefined;
         }
-        return mode === 'utc' ? 'UTC' : mode;
+        return mode;
     }
     /**
      * Stores the source rtIds resolved from an entity selector's current
@@ -2945,6 +2954,7 @@ const ResolveSeriesQueryDocumentDto = gql `
       signal
       actualPoints
       diagnostic
+      finerRungAvailableFrom
     }
   }
 }
@@ -3158,7 +3168,8 @@ class QueryExecutorService {
             reducingFunction: decision.reducingFunction,
             signal: decision.signal,
             actualPoints: decision.actualPoints ?? null,
-            diagnostic: decision.diagnostic ?? null
+            diagnostic: decision.diagnostic ?? null,
+            finerRungAvailableFrom: decision.finerRungAvailableFrom ?? null
         };
     }
     /**
@@ -14626,6 +14637,9 @@ class LineChartWidgetComponent {
      * Resolution-aware hint (AB#4290): a short badge describing the archive-selection outcome —
      * `null` for a clean reduction (signal OK), a warning otherwise (fewer points delivered, or no
      * compatible rollup so the raw archive was returned unreduced). Mirrors the resolver's signal.
+     * `CoverageLimited` (AB#5157) is a distinct badge: a finer rung was skipped for holding no data
+     * over the window, which is a history gap rather than a density problem — so it is always shown,
+     * bypassing the {@link RESOLUTION_LIMIT_WARN_PX} suppression that mutes a merely coarse line.
      */
     resolutionHint = computed(() => {
         const s = this._resolutionSignal();
@@ -14633,6 +14647,20 @@ class LineChartWidgetComponent {
             return null;
         const diag = s.diagnostic ?? '';
         switch (s.signal) {
+            case SeriesResolutionSignalDto.CoverageLimitedDto: {
+                // Coverage, not density (AB#5157): the finer rung was skipped because it holds NO data
+                // over the window, so the pixel-density suppression must not apply — a dense-looking
+                // coarse line is still the wrong answer to "where is my history?". Always flagged.
+                const availableFrom = formatInstant(s.finerRungAvailableFrom, this.stateService.timeZoneMode(), {
+                    day: '2-digit', month: '2-digit', year: 'numeric'
+                });
+                return {
+                    text: '⚠ no history',
+                    title: availableFrom
+                        ? `History at this resolution is available from ${availableFrom}`
+                        : diag || 'A finer resolution exists but holds no data for this time range.'
+                };
+            }
             case SeriesResolutionSignalDto.ResolutionLimitedDto: {
                 const delivered = s.actualPoints ?? s.points;
                 const requested = this._resolutionTarget();
@@ -14667,7 +14695,20 @@ class LineChartWidgetComponent {
         const delivered = s.actualPoints ?? s.points;
         const requested = this._resolutionTarget();
         const ofReq = requested ? ` (the chart could show ~${requested})` : '';
+        const diag = s.diagnostic ?? '';
         switch (s.signal) {
+            case SeriesResolutionSignalDto.CoverageLimitedDto: {
+                const availableFrom = formatInstant(s.finerRungAvailableFrom, this.stateService.timeZoneMode(), {
+                    day: '2-digit', month: '2-digit', year: 'numeric'
+                });
+                const from = availableFrom
+                    ? ` That resolution only has history from ${availableFrom} onwards.`
+                    : '';
+                return `A finer resolution exists for this series, but it holds no data for the selected time range, `
+                    + `so the chart fell back to a coarser one (${delivered} point(s)${ofReq}).${from} `
+                    + `The values are correct — narrow the range to a covered period to see finer detail.`
+                    + (diag ? ` ${diag}` : '');
+            }
             case SeriesResolutionSignalDto.ResolutionLimitedDto:
                 return `This chart auto-selects the coarsest stored resolution that still fits the view. `
                     + `For this time range the finest matching rollup only provides ${delivered} point(s)${ofReq}, `
@@ -14925,28 +14966,23 @@ class LineChartWidgetComponent {
         if (!resolution) {
             return { rows: [], signal: null, requestedPoints: targetPoints };
         }
-        // Snap the query window to the resolver's effective-bucket grid. The downsampling engine only
-        // aggregates a stored point into a bin when the bin width equals the data grain AND the window
-        // start sits on that grid (from the epoch). An unaligned window — e.g. a relative "last N days"
-        // filter ending at the current wall-clock time (…:42:54) — otherwise makes every bin miss the
-        // hourly/interval data and yields an all-null (blank) chart. Aligning from + sizing to
-        // points × bucket makes each bin land exactly on a stored point.
-        let qFrom = from;
-        let qTo = to;
-        if (resolution.effectiveBucketMs > 0) {
-            const bucket = resolution.effectiveBucketMs;
-            const alignedFrom = Math.floor(from.getTime() / bucket) * bucket;
-            qFrom = new Date(alignedFrom);
-            qTo = new Date(alignedFrom + Math.max(1, resolution.points) * bucket);
-        }
+        // The requested window is passed through unchanged. The widget used to snap it to the
+        // resolver's effective-bucket grid, because the downsampling engine binned from whatever start
+        // it was handed and an unaligned window (a relative "last N days" filter ending at the current
+        // wall clock) made every bin miss the stored points. That alignment now happens where the grain
+        // is actually known — the engine snaps its own axis origin — and doing it here was wrong twice
+        // over for a calendar rung (AB#5157 review): `effectiveBucketMs` is an average, so anchoring it
+        // to the epoch landed the axis off the calendar boundaries and outside the requested window,
+        // and sizing the end as points × bucket cut the running period off. No client can compute this
+        // axis: neither the grain nor the rung's alignment is part of the query contract.
         // Group-aggregation mode (AB#4714): one downsampling call PER GROUP, each with the whole
         // group's rtIds, so the transient downsampling reduces over every member (per
         // requiredAggregation) into one aggregate line. Default mode: one call per source rtId, keeping
         // each source its own series. See loadGroupAggregatedRows / loadPerRtIdRows.
         const downsample = (rtIds, label) => this.queryExecutor.downsampleByArchive({
             archiveRtId: resolution.archiveRtId,
-            from: qFrom,
-            to: qTo,
+            from,
+            to,
             limit: Math.max(1, resolution.points),
             sourcePath,
             aggregation: resolution.reducingFunction,
@@ -15731,7 +15767,7 @@ class LineChartConfigDialogComponent {
               [(ngModel)]="selectedPersistentQuery"
               (querySelected)="onQuerySelected($event)"
               placeholder="Select a Query..."
-              hint="Select a query that returns time-series data with grouping.">
+              hint="Select a stream-data query on the archive you want to chart — a simple one is enough. The widget picks the rollup rung and downsamples itself; the fields below group the rows into series.">
             </mm-query-selector>
           </div>
 
@@ -15992,7 +16028,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImpor
               [(ngModel)]="selectedPersistentQuery"
               (querySelected)="onQuerySelected($event)"
               placeholder="Select a Query..."
-              hint="Select a query that returns time-series data with grouping.">
+              hint="Select a stream-data query on the archive you want to chart — a simple one is enough. The widget picks the rollup rung and downsamples itself; the fields below group the rows into series.">
             </mm-query-selector>
           </div>