@mxtommy/kip 4.7.0-beta.2 → 4.7.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxtommy/kip",
-  "version": "4.7.0-beta.2",
+  "version": "4.7.0-beta.3",
   "description": "An advanced and versatile marine instrumentation package to display Signal K data.",
   "license": "MIT",
   "author": {

package/plugin/history-series.service.js

@@ -6,11 +6,14 @@ exports.HistorySeriesService = void 0;
  */
 class HistorySeriesService {
     nowProvider;
+    selfContext;
     seriesById = new Map();
+    enabledSeriesKeysByPath = new Map();
     lastAcceptedTimestampBySeriesKey = new Map();
     sampleSink = null;
-    constructor(nowProvider = () => Date.now()) {
+    constructor(nowProvider = () => Date.now(), selfContext = null) {
         this.nowProvider = nowProvider;
+        this.selfContext = selfContext;
     }
     /**
      * Returns all configured series sorted by `seriesId`.
@@ -56,6 +59,7 @@ class HistorySeriesService {
         const normalized = this.normalizeSeries(input);
         const key = normalized.seriesId;
         this.seriesById.set(key, normalized);
+        this.rebuildEnabledPathIndex();
         return normalized;
     }
     /**
@@ -90,6 +94,7 @@ class HistorySeriesService {
             this.seriesById.delete(key);
             this.lastAcceptedTimestampBySeriesKey.delete(key);
         });
+        this.rebuildEnabledPathIndex();
         return true;
     }
     /**
@@ -103,7 +108,7 @@ class HistorySeriesService {
      * console.log(result.created, result.deleted);
      */
     reconcileSeries(desiredSeries) {
-        const now = Date.now();
+        const now = this.nowProvider();
         const desiredById = new Map();
         desiredSeries.forEach(entry => {
             const normalized = this.normalizeSeries(entry);
@@ -122,7 +127,7 @@ class HistorySeriesService {
                 created += 1;
                 return;
             }
-            if (JSON.stringify(existing) !== JSON.stringify(desired)) {
+            if (!this.areSeriesEquivalent(existing, desired)) {
                 this.seriesById.set(seriesKey, desiredWithReconcile);
                 updated += 1;
             }
@@ -138,6 +143,7 @@ class HistorySeriesService {
                 deleted += 1;
             }
         });
+        this.rebuildEnabledPathIndex();
         return {
             created,
             updated,
@@ -157,12 +163,10 @@ class HistorySeriesService {
      * service.recordSample('abc', 12.4, Date.now());
      */
     recordSample(seriesId, value, timestamp) {
-        const seriesEntry = Array.from(this.seriesById.entries())
-            .find(([, series]) => series.seriesId === seriesId);
-        if (!seriesEntry) {
+        if (!this.seriesById.has(seriesId)) {
             return false;
         }
-        return this.recordSampleByKey(seriesEntry[0], value, timestamp);
+        return this.recordSampleByKey(seriesId, value, timestamp);
     }
     recordSampleByKey(seriesKey, value, timestamp) {
         const series = this.seriesById.get(seriesKey);
@@ -213,8 +217,13 @@ class HistorySeriesService {
         }
         let recorded = 0;
         leafSamples.forEach(leaf => {
-            this.seriesById.forEach((series, seriesKey) => {
-                if (series.path !== leaf.path || series.enabled === false) {
+            const seriesKeys = this.enabledSeriesKeysByPath.get(leaf.path);
+            if (!seriesKeys || seriesKeys.length === 0) {
+                return;
+            }
+            seriesKeys.forEach(seriesKey => {
+                const series = this.seriesById.get(seriesKey);
+                if (!series) {
                     return;
                 }
                 const seriesContext = series.context ?? 'vessels.self';
@@ -293,6 +302,68 @@ class HistorySeriesService {
         });
         return Array.from(contexts).sort();
     }
+    rebuildEnabledPathIndex() {
+        this.enabledSeriesKeysByPath.clear();
+        this.seriesById.forEach((series, seriesKey) => {
+            if (series.enabled === false) {
+                return;
+            }
+            const keys = this.enabledSeriesKeysByPath.get(series.path) ?? [];
+            keys.push(seriesKey);
+            this.enabledSeriesKeysByPath.set(series.path, keys);
+        });
+    }
+    areSeriesEquivalent(left, right) {
+        const leftComparable = this.toComparableSeries(left);
+        const rightComparable = this.toComparableSeries(right);
+        return leftComparable.seriesId === rightComparable.seriesId
+            && leftComparable.datasetUuid === rightComparable.datasetUuid
+            && leftComparable.ownerWidgetUuid === rightComparable.ownerWidgetUuid
+            && leftComparable.ownerWidgetSelector === rightComparable.ownerWidgetSelector
+            && leftComparable.path === rightComparable.path
+            && leftComparable.expansionMode === rightComparable.expansionMode
+            && this.areStringArraysEquivalent(leftComparable.allowedBatteryIds, rightComparable.allowedBatteryIds)
+            && leftComparable.source === rightComparable.source
+            && leftComparable.context === rightComparable.context
+            && leftComparable.timeScale === rightComparable.timeScale
+            && leftComparable.period === rightComparable.period
+            && leftComparable.retentionDurationMs === rightComparable.retentionDurationMs
+            && leftComparable.sampleTime === rightComparable.sampleTime
+            && leftComparable.enabled === rightComparable.enabled
+            && this.areStringArraysEquivalent(leftComparable.methods, rightComparable.methods);
+    }
+    toComparableSeries(series) {
+        const { reconcileTs, ...comparable } = series;
+        void reconcileTs;
+        return {
+            ...comparable,
+            allowedBatteryIds: this.normalizeComparableStringArray(comparable.allowedBatteryIds),
+            methods: this.normalizeComparableStringArray(comparable.methods)
+        };
+    }
+    areStringArraysEquivalent(left, right) {
+        const normalizedLeft = this.normalizeComparableStringArray(left) ?? [];
+        const normalizedRight = this.normalizeComparableStringArray(right) ?? [];
+        if (normalizedLeft.length !== normalizedRight.length) {
+            return false;
+        }
+        return normalizedLeft.every((value, index) => value === normalizedRight[index]);
+    }
+    normalizeComparableStringArray(values) {
+        if (!Array.isArray(values) || values.length === 0) {
+            return undefined;
+        }
+        return [...values]
+            .filter((value) => typeof value === 'string')
+            .sort((left, right) => left.localeCompare(right));
+    }
+    isChartWidget(ownerWidgetSelector, ownerWidgetUuid) {
+        if (ownerWidgetSelector === 'widget-data-chart' || ownerWidgetSelector === 'widget-windtrends-chart') {
+            return true;
+        }
+        return ownerWidgetUuid?.startsWith('widget-windtrends-chart') === true
+            || ownerWidgetUuid?.startsWith('widget-data-chart') === true;
+    }
     normalizeSeries(input) {
         const seriesId = (input.seriesId || input.datasetUuid || '').trim();
         if (!seriesId) {
@@ -310,8 +381,8 @@ class HistorySeriesService {
         if (!path) {
             throw new Error('path is required');
         }
-        // Determine if this is a chart type widget
-        const isDataWidget = ownerWidgetUuid?.startsWith('widget-windtrends-chart') || ownerWidgetUuid?.startsWith('widget-data-chart');
+        const ownerWidgetSelector = typeof input.ownerWidgetSelector === 'string' ? input.ownerWidgetSelector.trim() : undefined;
+        const isDataWidget = this.isChartWidget(ownerWidgetSelector, ownerWidgetUuid);
         const retentionMs = this.resolveRetentionMs(input);
         let sampleTime;
         if (isDataWidget) {
@@ -329,6 +400,7 @@ class HistorySeriesService {
             seriesId,
             datasetUuid,
             ownerWidgetUuid,
+            ownerWidgetSelector,
             path,
             source: input.source ?? 'default',
             context: input.context ?? 'vessels.self',
@@ -408,11 +480,17 @@ class HistorySeriesService {
         if (seriesContext === sampleContext) {
             return true;
         }
-        if (seriesContext === 'vessels.self') {
-            return sampleContext === 'vessels.self' || sampleContext.startsWith('vessels.');
+        if (this.isSelfContext(seriesContext) && this.isSelfContext(sampleContext)) {
+            return true;
         }
         return false;
     }
+    isSelfContext(context) {
+        if (context === 'vessels.self') {
+            return true;
+        }
+        return !!this.selfContext && context === this.selfContext;
+    }
     isSourceMatch(seriesSource, sampleSource) {
         if (seriesSource === '*' || seriesSource === 'any') {
             return true;

package/plugin/index.js

@@ -87,8 +87,8 @@ const start = (server) => {
             }
         }
     };
-    const historySeries = new history_series_service_1.HistorySeriesService(() => Date.now());
-    const storageService = new sqlite_history_storage_service_1.SqliteHistoryStorageService();
+    const historySeries = new history_series_service_1.HistorySeriesService(() => Date.now(), typeof server.selfId === 'string' && server.selfId.trim().length > 0 ? `vessels.${server.selfId.trim()}` : null);
+    const storageService = new sqlite_history_storage_service_1.SqliteHistoryStorageService(server.getDataDirPath());
     let retentionSweepTimer = null;
     let storageFlushTimer = null;
     let sqliteInitializationPromise = null;
@@ -148,6 +148,97 @@ const start = (server) => {
             nodeSqliteAvailable: nodeSqliteAvailable !== false
         };
     }
+    function slugify(value) {
+        return value
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    function resolveBmsBatteryIdsFromSelfPath() {
+        const batteriesPath = server.getSelfPath('electrical.batteries');
+        const readCandidate = (node) => {
+            if (!node || typeof node !== 'object' || Array.isArray(node)) {
+                return null;
+            }
+            const root = node;
+            if (Object.prototype.hasOwnProperty.call(root, 'value')) {
+                const value = root.value;
+                if (value && typeof value === 'object' && !Array.isArray(value)) {
+                    return value;
+                }
+                return null;
+            }
+            return root;
+        };
+        const candidates = readCandidate(batteriesPath);
+        if (!candidates) {
+            return [];
+        }
+        return Object.keys(candidates)
+            .filter(id => /^[a-z0-9_-]+$/i.test(id))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    function getExistingConcreteBmsSeries(templateSeries, existingSeries) {
+        return existingSeries
+            .filter(series => series.ownerWidgetUuid === templateSeries.ownerWidgetUuid)
+            .filter(series => series.expansionMode == null)
+            .filter(series => series.seriesId !== templateSeries.seriesId)
+            .map(series => ({ ...series }));
+    }
+    function mergeSeriesDefinitions(series) {
+        const mergedById = new Map();
+        series.forEach(item => {
+            mergedById.set(item.seriesId, item);
+        });
+        return Array.from(mergedById.values());
+    }
+    function expandTemplateSeriesDefinitions(payload, existingSeries = []) {
+        const bmsMetrics = ['capacity.stateOfCharge', 'current'];
+        const expandedById = new Map();
+        const discoveredBatteryIds = resolveBmsBatteryIdsFromSelfPath();
+        payload.forEach(series => {
+            const isBmsTemplate = series.expansionMode === 'bms-battery-tree' && series.ownerWidgetSelector === 'widget-bms';
+            if (!isBmsTemplate) {
+                expandedById.set(series.seriesId, series);
+                return;
+            }
+            if (discoveredBatteryIds.length === 0) {
+                getExistingConcreteBmsSeries(series, existingSeries).forEach(existing => {
+                    expandedById.set(existing.seriesId, existing);
+                });
+                return;
+            }
+            const allowedBatteryIds = Array.isArray(series.allowedBatteryIds)
+                ? series.allowedBatteryIds
+                    .filter((id) => typeof id === 'string')
+                    .map(id => id.trim())
+                    .filter(id => id.length > 0)
+                : [];
+            const allowedSet = allowedBatteryIds.length > 0 ? new Set(allowedBatteryIds) : null;
+            const batteryIds = discoveredBatteryIds.filter(id => !allowedSet || allowedSet.has(id));
+            if (batteryIds.length === 0) {
+                return;
+            }
+            const source = series.source ?? 'default';
+            const sourceKey = slugify(source || 'default') || 'default';
+            batteryIds.forEach(batteryId => {
+                bmsMetrics.forEach(metric => {
+                    const path = `self.electrical.batteries.${batteryId}.${metric}`;
+                    const seriesId = `${series.ownerWidgetUuid}:bms:${batteryId}:${metric}:${sourceKey}`;
+                    expandedById.set(seriesId, {
+                        ...series,
+                        seriesId,
+                        datasetUuid: `${series.ownerWidgetUuid}:bms:${batteryId}:${metric}:${sourceKey}`,
+                        path,
+                        retentionDurationMs: Number.isFinite(series.retentionDurationMs) ? series.retentionDurationMs : 24 * 60 * 60 * 1000,
+                        expansionMode: null,
+                        allowedBatteryIds: null
+                    });
+                });
+            });
+        });
+        return Array.from(expandedById.values());
+    }
     function getDisplaySelfPath(displayId, suffix) {
         const tail = suffix ? `.${suffix}` : '';
         const want = `displays.${displayId}${tail}`;
@@ -599,9 +690,6 @@ const start = (server) => {
             if (!modeConfig.nodeSqliteAvailable) {
                 server.error(`[KIP][RUNTIME] node:sqlite unavailable. ${runtimeSqliteUnavailableMessage}`);
             }
-            const serverWithApp = server;
-            const dataDirPath = serverWithApp.app?.getDataDirPath?.();
-            storageService.setDataDirPath(typeof dataDirPath === 'string' ? dataDirPath : null);
             storageService.setRuntimeAvailability(modeConfig.nodeSqliteAvailable, runtimeSqliteUnavailableMessage ?? undefined);
             logRuntimeDependencyVersions();
             logOperationalMode('start-configured');
@@ -1053,14 +1141,28 @@ const start = (server) => {
                     if (!Array.isArray(payload)) {
                         return sendFail(res, 400, 'Body must be an array of series definitions');
                     }
-                    const simulated = new history_series_service_1.HistorySeriesService(() => Date.now());
-                    historySeries.listSeries().forEach(series => {
+                    const simulated = new history_series_service_1.HistorySeriesService(() => Date.now(), typeof server.selfId === 'string' && server.selfId.trim().length > 0 ? `vessels.${server.selfId.trim()}` : null);
+                    const currentSeries = mergeSeriesDefinitions([
+                        ...(await storageService.getSeriesDefinitions()),
+                        ...historySeries.listSeries()
+                    ]);
+                    currentSeries.forEach(series => {
                         simulated.upsertSeries(series);
                     });
                     const scopedPayload = payload.map(series => ({
                         ...series
                     }));
-                    const result = simulated.reconcileSeries(scopedPayload);
+                    const isBatteryDiscoveryUnavailable = resolveBmsBatteryIdsFromSelfPath().length === 0;
+                    const preservedBmsSeries = isBatteryDiscoveryUnavailable
+                        ? scopedPayload
+                            .filter(series => series.expansionMode === 'bms-battery-tree' && series.ownerWidgetSelector === 'widget-bms')
+                            .flatMap(series => currentSeries.filter(current => current.ownerWidgetUuid === series.ownerWidgetUuid && current.expansionMode == null && current.seriesId !== series.seriesId))
+                        : [];
+                    const expandedPayload = mergeSeriesDefinitions([
+                        ...expandTemplateSeriesDefinitions(scopedPayload, currentSeries),
+                        ...preservedBmsSeries
+                    ]);
+                    const result = simulated.reconcileSeries(expandedPayload);
                     const nextSeries = simulated.listSeries();
                     await storageService.replaceSeriesDefinitions(nextSeries);
                     const seriesOutsideScope = historySeries.listSeries();