@meshmakers/octo-meshboard 3.4.910 → 3.4.930

package/README.md

@@ -72,10 +72,10 @@ To set a Well-Known Name for a MeshBoard:
 
 The Well-Known Name should be lowercase with hyphens, similar to URL slugs.
 
-### URL Sync on Board Switch (`meshBoardSyncUrl`)
+### URL Sync (`meshBoardSyncUrl`)
 
-After a post-init board switch (e.g. via the manager dialog), the view syncs the
-loaded board's rtId into the URL:
+After the initial load and after every post-init board switch (e.g. via the
+manager dialog), the view syncs the loaded board's rtId into the URL:
 
 - If the active route has an `:rtId` param, the last URL segment is replaced —
   always enabled, no configuration needed.

package/fesm2022/meshmakers-octo-meshboard.mjs

@@ -468,6 +468,8 @@ const GetEntitiesByCkTypeDocumentDto = gql `
         rtId
         ckTypeId
         rtWellKnownName
+        rtDisplayName
+        rtDisplayDescription
         rtCreationDateTime
         rtChangedDateTime
         attributes(resolveEnumValuesToNames: true) {
@@ -2910,6 +2912,14 @@ const GetStreamDataQueryArchiveDocumentDto = gql `
       }
     }
   }
+  runtime {
+    systemSimpleSdQuery(rtId: $rtId) {
+      items {
+        rtId
+        rtIds
+      }
+    }
+  }
 }
     `;
 class GetStreamDataQueryArchiveDtoGQL extends i1.Query {
@@ -3158,7 +3168,11 @@ class QueryExecutorService {
      * Resolution-aware routing (AB#4290): reads a persisted stream-data query's base archive rtId
      * and target CK type WITHOUT executing the query (the `rows` sub-connection is not selected), so
      * a widget can feed the archive to {@link resolveSeriesQuery} and use the CK type to resolve
-     * per-series labels. Returns null when the query is missing or has no archive.
+     * per-series labels. Also reads the query's persisted RtIds pin
+     * (`System/StreamDataQuery.RtIds`) from the runtime entity — the transient downsampling path
+     * bypasses the persisted query execution, so widgets must re-apply the pin themselves
+     * (AB#4818). `rtIds` is null when the query has no pin (or is not a SimpleSdQuery).
+     * Returns null when the query is missing or has no archive.
      */
     async fetchQueryArchive(queryRtId) {
         const result = await firstValueFrom(this.queryArchiveGql.fetch({ variables: { rtId: queryRtId }, fetchPolicy: 'cache-first' }));
@@ -3166,7 +3180,12 @@ class QueryExecutorService {
         if (item?.archiveRtId == null) {
             return null;
         }
-        return { archiveRtId: String(item.archiveRtId), ckTypeId: item.associatedCkTypeId != null ? String(item.associatedCkTypeId) : null };
+        const pinned = result.data?.runtime?.systemSimpleSdQuery?.items?.[0]?.rtIds;
+        return {
+            archiveRtId: String(item.archiveRtId),
+            ckTypeId: item.associatedCkTypeId != null ? String(item.associatedCkTypeId) : null,
+            rtIds: pinned && pinned.length > 0 ? pinned.map(String) : null
+        };
     }
     /**
      * Resolution-aware routing (AB#4290): runs the AB#4233 downsampling query against an explicit
@@ -4652,7 +4671,9 @@ class EntityCardConfigDialogComponent {
                     rtId: entity.rtId,
                     ckTypeId: entity.ckTypeId,
                     rtWellKnownName: entity.rtWellKnownName ?? undefined,
-                    displayName: entity.rtWellKnownName || entity.rtId
+                    rtDisplayName: entity.rtDisplayName,
+                    rtDisplayDescription: entity.rtDisplayDescription ?? undefined,
+                    displayName: entity.rtDisplayName
                 };
             }
         }
@@ -6181,7 +6202,9 @@ class KpiConfigDialogComponent {
                     rtId: entity.rtId,
                     ckTypeId: entity.ckTypeId,
                     rtWellKnownName: entity.rtWellKnownName ?? undefined,
-                    displayName: entity.rtWellKnownName || entity.rtId
+                    rtDisplayName: entity.rtDisplayName,
+                    rtDisplayDescription: entity.rtDisplayDescription ?? undefined,
+                    displayName: entity.rtDisplayName
                 };
             }
         }
@@ -7545,13 +7568,26 @@ const ISO_DATE_TIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]
 function isIsoDateTime(value) {
     return typeof value === 'string' && ISO_DATE_TIME_RE.test(value);
 }
-/** Parses a value into a valid `Date`, or returns `null` when it is not a usable instant. */
+/**
+ * ISO-8601 date-time WITHOUT a zone designator (no `Z`, no offset). The wire
+ * serializes UTC instants in this naive form (e.g. `2026-08-16T10:50:00`), but
+ * `new Date(...)` parses such strings as browser-LOCAL time — shifting every
+ * timestamp by the UTC offset before the board's timezone mode is even applied
+ * (AB#4818). {@link toInstant} pins these to UTC instead.
+ */
+const ISO_NAIVE_DATE_TIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?$/;
+/**
+ * Parses a value into a valid `Date`, or returns `null` when it is not a usable
+ * instant. A naive ISO date-time string (no `Z`/offset) is treated as UTC — the
+ * wire's serialization of an instant — never as browser-local time (AB#4818).
+ */
 function toInstant(value) {
     if (value instanceof Date) {
         return isNaN(value.getTime()) ? null : value;
     }
     if (typeof value === 'string' || typeof value === 'number') {
-        const date = new Date(value);
+        const normalized = typeof value === 'string' && ISO_NAIVE_DATE_TIME_RE.test(value) ? `${value}Z` : value;
+        const date = new Date(normalized);
         return isNaN(date.getTime()) ? null : date;
     }
     return null;
@@ -10959,7 +10995,9 @@ class GaugeConfigDialogComponent {
                     rtId: entity.rtId,
                     ckTypeId: entity.ckTypeId,
                     rtWellKnownName: entity.rtWellKnownName ?? undefined,
-                    displayName: entity.rtWellKnownName || entity.rtId
+                    rtDisplayName: entity.rtDisplayName,
+                    rtDisplayDescription: entity.rtDisplayDescription ?? undefined,
+                    displayName: entity.rtDisplayName
                 };
             }
         }
@@ -14866,6 +14904,11 @@ class LineChartWidgetComponent {
         if (!info) {
             throw new Error('Resolution-aware line chart: base archive not found for the selected query.');
         }
+        // Source scope (AB#4818): an active entity-selector binding overrides; otherwise the persisted
+        // query's RtIds pin applies — the transient downsampling bypasses the persisted query execution,
+        // so without re-applying the pin a pinned widget would silently aggregate every entity captured
+        // by the archive.
+        const scopeRtIds = sourceRtIds && sourceRtIds.length > 0 ? sourceRtIds : (info.rtIds ?? undefined);
         // The Y-axis value field is the column being reduced, so it doubles as the resolver's
         // source path (matched case-insensitively against the rollup's aggregation spec).
         const sourcePath = this.config.valueField;
@@ -14877,7 +14920,7 @@ class LineChartWidgetComponent {
             targetPoints,
             requiredAggregation: aggregation,
             sourcePath,
-            rtIds: sourceRtIds && sourceRtIds.length > 0 ? sourceRtIds : undefined,
+            rtIds: scopeRtIds,
             // Resolve calendar rollups in the board's zone so civil-day buckets match the
             // window (computed on the same zone by resolveCurrentTimeRange) — AB#4190.
             timeZone: this.stateService.resolveStreamDataTimeZone()
@@ -14914,8 +14957,8 @@ class LineChartWidgetComponent {
             fieldFilter
         }).then(seriesRows => seriesRows.map(r => this.reshapeResolutionRow(r, label)));
         const rows = ds.aggregateSeriesByGroup && info.ckTypeId
-            ? await this.loadGroupAggregatedRows(info.ckTypeId, sourceRtIds, downsample)
-            : await this.loadPerRtIdRows(info.ckTypeId, sourceRtIds, downsample);
+            ? await this.loadGroupAggregatedRows(info.ckTypeId, scopeRtIds, downsample)
+            : await this.loadPerRtIdRows(info.ckTypeId, scopeRtIds, downsample);
         return { rows, signal: resolution, requestedPoints: targetPoints };
     }
     /**
@@ -15044,9 +15087,11 @@ class LineChartWidgetComponent {
                 }
             }
             if (categoryValue && seriesGroupValue) {
-                // Parse date for sorting
+                // Parse date for sorting. toInstant treats a naive wire timestamp (no zone designator)
+                // as UTC — a bare `new Date(...)` would reinterpret it as browser-local time and shift
+                // the axis by the UTC offset (AB#4818).
                 if (!allCategories.has(categoryValue)) {
-                    allCategories.set(categoryValue, new Date(categoryValue));
+                    allCategories.set(categoryValue, toInstant(categoryValue) ?? new Date(NaN));
                 }
                 allSeriesGroups.add(seriesGroupValue);
                 if (!dataMap.has(categoryValue)) {
@@ -16649,13 +16694,11 @@ class HeatmapWidgetComponent {
                 return values.length;
         }
     }
+    /** Delegates to {@link toInstant} so naive wire timestamps are pinned to UTC (AB#4818). */
     parseDate(value) {
         if (!value)
             return null;
-        if (value instanceof Date)
-            return value;
-        const date = new Date(String(value));
-        return isNaN(date.getTime()) ? null : date;
+        return toInstant(value);
     }
     convertFiltersToDto(filters) {
         const variables = this.stateService.getVariables();
@@ -30865,6 +30908,120 @@ function buildUrlWithRtId(input) {
     }
     return null;
 }
+/**
+ * Returns the URL to navigate to after the *initial* board load, or `null`
+ * when the URL must not be rewritten.
+ *
+ * The constructor effect skips URL sync during the initial load (it would race
+ * with the transient board `loadInitialMeshBoard` puts up first), so the view
+ * syncs once after loading settles. Nothing to do when no board loaded or the
+ * URL already carried the rtId; otherwise the `buildUrlWithRtId` rules apply.
+ */
+function buildInitialUrlWithRtId(input) {
+    const { loadedRtId, rtIdFromRoute, ...rest } = input;
+    if (!loadedRtId || rtIdFromRoute) {
+        return null;
+    }
+    return buildUrlWithRtId({ ...rest, rtId: loadedRtId });
+}
+
+/**
+ * Pure helpers for representing the active time-filter selection in the URL.
+ *
+ * The URL is written from two sides — the board-switch rtId sync and the
+ * time-range picker — and two concurrent Router navigations supersede each
+ * other (the later one wins, computed from the pre-navigation route, silently
+ * dropping the rtId path change). Both writers therefore serialize the tf_*
+ * params through these helpers onto one target URL string and navigate once.
+ */
+/** All tf_* query params; params not used by the selection type are null (= removed). */
+function timeFilterQueryParams(selection) {
+    const params = {
+        tf_type: selection.type,
+        tf_year: null,
+        tf_quarter: null,
+        tf_month: null,
+        tf_day: null,
+        tf_hf: null,
+        tf_ht: null,
+        tf_rv: null,
+        tf_ru: null,
+        tf_from: null,
+        tf_to: null
+    };
+    switch (selection.type) {
+        case 'year':
+            if (selection.year != null)
+                params['tf_year'] = selection.year.toString();
+            break;
+        case 'quarter':
+            if (selection.year != null)
+                params['tf_year'] = selection.year.toString();
+            if (selection.quarter != null)
+                params['tf_quarter'] = selection.quarter.toString();
+            break;
+        case 'month':
+            if (selection.year != null)
+                params['tf_year'] = selection.year.toString();
+            if (selection.month != null)
+                params['tf_month'] = selection.month.toString();
+            break;
+        case 'day':
+            if (selection.year != null)
+                params['tf_year'] = selection.year.toString();
+            if (selection.month != null)
+                params['tf_month'] = selection.month.toString();
+            if (selection.day != null)
+                params['tf_day'] = selection.day.toString();
+            if (selection.hourFrom != null)
+                params['tf_hf'] = selection.hourFrom.toString();
+            if (selection.hourTo != null)
+                params['tf_ht'] = selection.hourTo.toString();
+            break;
+        case 'relative':
+            if (selection.relativeValue != null)
+                params['tf_rv'] = selection.relativeValue.toString();
+            if (selection.relativeUnit)
+                params['tf_ru'] = selection.relativeUnit;
+            break;
+        case 'custom':
+            if (selection.customFrom)
+                params['tf_from'] = selection.customFrom;
+            if (selection.customTo)
+                params['tf_to'] = selection.customTo;
+            break;
+    }
+    return params;
+}
+/**
+ * Returns `url` with the given query params merged in: string values are set,
+ * null values are removed, params not mentioned are preserved.
+ */
+function applyQueryParams(url, params) {
+    const [pathPart, queryPart] = url.split('?');
+    const search = new URLSearchParams(queryPart ?? '');
+    for (const [key, value] of Object.entries(params)) {
+        if (value === null) {
+            search.delete(key);
+        }
+        else {
+            search.set(key, value);
+        }
+    }
+    const query = search.toString();
+    return query ? `${pathPart}?${query}` : pathPart;
+}
+/**
+ * Returns `url` with its tf_* query params replaced by the given selection's.
+ * Non-tf params (es_*, …) are preserved. `selection` null/undefined returns
+ * the url unchanged.
+ */
+function applyTimeFilterParams(url, selection) {
+    if (!selection) {
+        return url;
+    }
+    return applyQueryParams(url, timeFilterQueryParams(selection));
+}
 
 /**
  * Component for editing MeshBoard variables.
@@ -32211,9 +32368,14 @@ class MeshBoardViewComponent {
             if (currentRtId && currentRtId !== this.lastNavigatedRtId) {
                 this.lastNavigatedRtId = currentRtId;
                 if (this.initialLoadComplete) {
-                    // Only update URL and time filter for post-init board switches (e.g. manager dialog)
-                    this.updateUrlWithRtId(currentRtId);
+                    // Only update URL and time filter for post-init board switches (e.g.
+                    // manager dialog). Time filter first: updateUrlWithRtId serializes
+                    // the then-active selection into the SAME navigation as the rtId
+                    // path change — a second concurrent navigation (e.g. the picker's
+                    // writeTimeFilterToUrl) would supersede the path change and drop the
+                    // rtId from the URL.
                     this.initializeTimeFilterVariables();
+                    this.updateUrlWithRtId(currentRtId);
                 }
             }
         });
@@ -32265,9 +32427,16 @@ class MeshBoardViewComponent {
             syncUrlOptIn: this.route.snapshot.data['meshBoardSyncUrl'] === true
         });
         if (targetUrl !== null) {
-            this.router.navigateByUrl(targetUrl, { replaceUrl: true });
+            // One navigation for path + tf_* params: a separate time-filter
+            // navigation would supersede this one and drop the rtId path change.
+            this.router.navigateByUrl(applyTimeFilterParams(targetUrl, this.activeTimeFilterSelection()), { replaceUrl: true });
         }
     }
+    /** The active time-filter selection to mirror into the URL, or null when the filter is off. */
+    activeTimeFilterSelection() {
+        const config = this.stateService.getTimeFilterConfig();
+        return config?.enabled ? config.selection ?? null : null;
+    }
     async ngOnInit() {
         // Track the component's own width for the compact layout tiers. The callback
         // fires outside the Angular zone; re-enter it so the signal update schedules
@@ -32323,6 +32492,21 @@ class MeshBoardViewComponent {
             await this.initializeEntitySelectors();
             // Mark initial load as complete so the effect can handle subsequent board switches
             this.initialLoadComplete = true;
+            // The constructor effect skipped the URL sync during the initial load
+            // (and already consumed the rtId via lastNavigatedRtId), so sync once
+            // here, after loading settled — the transient board from
+            // loadInitialMeshBoard never reaches the URL. Stays a no-op without
+            // meshBoardSyncUrl/:rtId (AB#4457) and preserves the query params.
+            const initialUrl = buildInitialUrlWithRtId({
+                currentUrl: this.router.url,
+                loadedRtId: this.stateService.persistedMeshBoardId(),
+                rtIdFromRoute,
+                hasRtIdParam: this.route.snapshot.paramMap.has('rtId'),
+                syncUrlOptIn: this.route.snapshot.data['meshBoardSyncUrl'] === true
+            });
+            if (initialUrl !== null) {
+                this.router.navigateByUrl(applyTimeFilterParams(initialUrl, this.activeTimeFilterSelection()), { replaceUrl: true });
+            }
             // Update breadcrumb with MeshBoard name
             this.updateBreadcrumb();
             // Wire visibility-aware auto-refresh. The config-watching effect already
@@ -32760,69 +32944,17 @@ class MeshBoardViewComponent {
      * Only writes params relevant to the current type, clears all others.
      */
     writeTimeFilterToUrl(selection) {
-        // Start with all params cleared
-        const cleanParams = {
-            tf_type: selection.type,
-            tf_year: null,
-            tf_quarter: null,
-            tf_month: null,
-            tf_day: null,
-            tf_hf: null,
-            tf_ht: null,
-            tf_rv: null,
-            tf_ru: null,
-            tf_from: null,
-            tf_to: null
-        };
-        // Set only the params relevant to the current type
-        switch (selection.type) {
-            case 'year':
-                if (selection.year != null)
-                    cleanParams['tf_year'] = selection.year.toString();
-                break;
-            case 'quarter':
-                if (selection.year != null)
-                    cleanParams['tf_year'] = selection.year.toString();
-                if (selection.quarter != null)
-                    cleanParams['tf_quarter'] = selection.quarter.toString();
-                break;
-            case 'month':
-                if (selection.year != null)
-                    cleanParams['tf_year'] = selection.year.toString();
-                if (selection.month != null)
-                    cleanParams['tf_month'] = selection.month.toString();
-                break;
-            case 'day':
-                if (selection.year != null)
-                    cleanParams['tf_year'] = selection.year.toString();
-                if (selection.month != null)
-                    cleanParams['tf_month'] = selection.month.toString();
-                if (selection.day != null)
-                    cleanParams['tf_day'] = selection.day.toString();
-                if (selection.hourFrom != null)
-                    cleanParams['tf_hf'] = selection.hourFrom.toString();
-                if (selection.hourTo != null)
-                    cleanParams['tf_ht'] = selection.hourTo.toString();
-                break;
-            case 'relative':
-                if (selection.relativeValue != null)
-                    cleanParams['tf_rv'] = selection.relativeValue.toString();
-                if (selection.relativeUnit)
-                    cleanParams['tf_ru'] = selection.relativeUnit;
-                break;
-            case 'custom':
-                if (selection.customFrom)
-                    cleanParams['tf_from'] = selection.customFrom;
-                if (selection.customTo)
-                    cleanParams['tf_to'] = selection.customTo;
-                break;
+        // Serialize onto the current URL string instead of router.navigate([],
+        // {relativeTo}): the relative form is computed from the pre-navigation
+        // route and, when it supersedes an in-flight rtId navigation, restores the
+        // stale path (old/no board rtId) into the URL.
+        const targetUrl = applyTimeFilterParams(this.router.url, selection);
+        if (targetUrl === this.router.url) {
+            // No-op writes must not navigate: the router would still cancel an
+            // in-flight rtId navigation before skipping the identical URL.
+            return;
         }
-        this.router.navigate([], {
-            relativeTo: this.route,
-            queryParams: cleanParams,
-            queryParamsHandling: 'merge',
-            replaceUrl: true
-        });
+        this.router.navigateByUrl(targetUrl, { replaceUrl: true });
     }
     /**
      * Reads the time filter selection from URL query parameters.
@@ -32851,17 +32983,33 @@ class MeshBoardViewComponent {
      * Compares two TimeRangeSelection objects for equality.
      */
     isSelectionEqual(a, b) {
-        return (a.type === b.type &&
-            a.year === b.year &&
-            a.quarter === b.quarter &&
-            a.month === b.month &&
-            a.day === b.day &&
-            a.hourFrom === b.hourFrom &&
-            a.hourTo === b.hourTo &&
-            a.relativeValue === b.relativeValue &&
-            a.relativeUnit === b.relativeUnit &&
-            a.customFrom === b.customFrom &&
-            a.customTo === b.customTo);
+        // Compare only the fields the selection type actually uses: the picker
+        // pre-fills the unused fields with current-date defaults (e.g. year/month
+        // on a relative selection) while stored selections omit them. A
+        // field-by-field comparison then reports equal selections as changed and
+        // triggers a spurious URL write that supersedes (and thereby drops) the
+        // board-switch rtId navigation.
+        if (a.type !== b.type) {
+            return false;
+        }
+        const eq = (x, y) => (x ?? null) === (y ?? null);
+        switch (a.type) {
+            case 'year':
+                return eq(a.year, b.year);
+            case 'quarter':
+                return eq(a.year, b.year) && eq(a.quarter, b.quarter);
+            case 'month':
+                return eq(a.year, b.year) && eq(a.month, b.month);
+            case 'day':
+                return eq(a.year, b.year) && eq(a.month, b.month) && eq(a.day, b.day) &&
+                    eq(a.hourFrom, b.hourFrom) && eq(a.hourTo, b.hourTo);
+            case 'relative':
+                return eq(a.relativeValue, b.relativeValue) && eq(a.relativeUnit, b.relativeUnit);
+            case 'custom':
+                return eq(a.customFrom, b.customFrom) && eq(a.customTo, b.customTo);
+            default:
+                return false;
+        }
     }
     /**
      * Duplicates a widget with all its settings.
@@ -33298,12 +33446,13 @@ class MeshBoardViewComponent {
         for (const selector of selectors) {
             params[`es_${selector.id}`] = selector.selectedRtId ?? null;
         }
-        this.router.navigate([], {
-            relativeTo: this.route,
-            queryParams: params,
-            queryParamsHandling: 'merge',
-            replaceUrl: true
-        });
+        // Same single-URL serialization as writeTimeFilterToUrl: no relative
+        // navigation off a possibly stale route, and no no-op navigation that
+        // would cancel an in-flight rtId navigation.
+        const targetUrl = applyQueryParams(this.router.url, params);
+        if (targetUrl !== this.router.url) {
+            this.router.navigateByUrl(targetUrl, { replaceUrl: true });
+        }
     }
     /**
      * Reads entity selector selections from URL query parameters.