@mxtommy/kip 4.6.0 → 4.7.0-beta.3

package/CHANGELOG.md

@@ -1,8 +1,8 @@
 # v4.6.0
 ## Improvements
-* Built-in Time-Series storage and History-API provider now use the native node:sqlite feature, eliminating all binary and external dependencies.
+* Built-in Time-Series storage and History-API provider now use the native node:sqlite feature, eliminating binary and external dependencies.
   * Requires Node.js 22.5.0 or newer. If you use an older Node.js version, you must select an alternative History-API provider.
-  * **IMPORTANT:** Before upgrading Node.js, always confirm your Signal K server version supports the required Node.js version. See the [Signal K installation documentation](https://demo.signalk.org/documentation/Installation.html).
+  * **IMPORTANT:** Before upgrading Node.js, always confirm your Signal K server and OS supports the required Node.js version. See the [Signal K installation documentation](https://demo.signalk.org/documentation/Installation.html).
 ## Fixes
 * Extending v4.5.x features to VenusOS (32bit OS) - Error: Failed to start: Error loading duckdb native binding: unsupported arch 'arm' for platform 'linux'. Fixes #979
 * Uninstallation does not remove all files. Fixes #981

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxtommy/kip",
-  "version": "4.6.0",
+  "version": "4.7.0-beta.3",
   "description": "An advanced and versatile marine instrumentation package to display Signal K data.",
   "license": "MIT",
   "author": {
@@ -76,10 +76,10 @@
     "@angular/platform-browser": "21.2.1",
     "@angular/platform-browser-dynamic": "21.2.1",
     "@angular/router": "21.2.1",
-    "@angular-devkit/build-angular": "^21.1.4",
+    "@angular-devkit/build-angular": "^21.2.1",
     "@angular-devkit/schematics-cli": "^20.1.6",
-    "@angular/build": "^21.1.4",
-    "@angular/cli": "^21.1.4",
+    "@angular/build": "^21.2.1",
+    "@angular/cli": "^21.2.1",
     "@angular/compiler-cli": "21.2.1",
     "@angular/language-service": "21.2.1",
     "@types/canvas-gauges": "^2.1.8",
@@ -89,7 +89,7 @@
     "@types/js-quantities": "^1.6.6",
     "@types/lodash-es": "^4.17.9",
     "@types/node": "^24.1.0",
-    "angular-eslint": "21.2.0",
+    "angular-eslint": "21.3.0",
     "codelyzer": "^6.0.0",
     "eslint": "^9.29.0",
     "jasmine-core": "~4.0.1",

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

@@ -37,6 +37,14 @@ const server_api_1 = require("@signalk/server-api");
 const openapi = __importStar(require("./openApi.json"));
 const history_series_service_1 = require("./history-series.service");
 const sqlite_history_storage_service_1 = require("./sqlite-history-storage.service");
+async function defaultGetSqliteModule() {
+    try {
+        return await Promise.resolve().then(() => __importStar(require('node:sqlite')));
+    }
+    catch {
+        return null;
+    }
+}
 const start = (server) => {
     const mutableOpenApi = JSON.parse(JSON.stringify(openapi.default ?? openapi));
     const API_PATHS = {
@@ -79,15 +87,14 @@ 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;
     const SQLITE_INIT_WAIT_TIMEOUT_MS = 5000;
     const MIN_NODE_SQLITE_VERSION = '22.5.0';
     let streamUnsubscribes = [];
-    let historyApiRegistry = null;
     let historyApiProviderRegistered = false;
     let runtimeSqliteUnavailableMessage = null;
     function logRuntimeDependencyVersions() {
@@ -95,16 +102,12 @@ const start = (server) => {
         const sqliteAvailability = modeConfig && modeConfig.nodeSqliteAvailable ? 'available' : 'unavailable';
         server.debug(`[KIP][RUNTIME] ${nodeIdentity} node:sqlite=${sqliteAvailability}`);
     }
-    async function getSqliteModule() {
-        try {
-            return await Promise.resolve().then(() => __importStar(require('node:sqlite')));
-        }
-        catch {
-            return null;
-        }
-    }
     async function detectSqliteRuntime() {
-        const sqliteModule = await getSqliteModule();
+        const exportedStart = start;
+        const resolveSqliteModule = typeof exportedStart.getSqliteModule === 'function'
+            ? exportedStart.getSqliteModule
+            : defaultGetSqliteModule;
+        const sqliteModule = await resolveSqliteModule();
         if (!sqliteModule) {
             runtimeSqliteUnavailableMessage = `node:sqlite requires Node ${MIN_NODE_SQLITE_VERSION}+`;
             return false;
@@ -145,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}`;
@@ -470,7 +564,17 @@ const start = (server) => {
             server.debug('[KIP][HISTORY_PROVIDER] registration skipped reason=config-disabled');
             return;
         }
-        const host = server;
+        const serverWithHistoryApi = server;
+        const registerHistoryApiProvider = typeof serverWithHistoryApi.registerHistoryApiProvider === 'function'
+            ? serverWithHistoryApi.registerHistoryApiProvider.bind(serverWithHistoryApi)
+            : (typeof serverWithHistoryApi.history?.registerHistoryApiProvider === 'function'
+                ? serverWithHistoryApi.history.registerHistoryApiProvider.bind(serverWithHistoryApi.history)
+                : null);
+        // guard when running in SK variants that do not support History API registration
+        if (!registerHistoryApiProvider) {
+            server.debug('[KIP][HISTORY_PROVIDER] registration skipped reason=api-unavailable');
+            return;
+        }
         const apiProvider = {
             getValues: async (query) => {
                 const resolved = await resolveHistoryValues(buildHistoryQueryFromValuesRequest(query));
@@ -485,26 +589,9 @@ const start = (server) => {
             getPaths: (query) => resolveHistoryPaths(buildHistoryQueryFromRangeRequest(query)),
             getContexts: (query) => resolveHistoryContexts(buildHistoryQueryFromRangeRequest(query))
         };
-        const registry = host.history && typeof host.history.registerHistoryApiProvider === 'function'
-            ? host.history
-            : (typeof host.registerHistoryApiProvider === 'function'
-                ? {
-                    registerHistoryApiProvider: host.registerHistoryApiProvider.bind(host),
-                    unregisterHistoryApiProvider: typeof host.unregisterHistoryApiProvider === 'function'
-                        ? host.unregisterHistoryApiProvider.bind(host)
-                        : undefined
-                }
-                : null);
-        if (registry && typeof registry.registerHistoryApiProvider === 'function') {
-            registry.registerHistoryApiProvider(apiProvider);
-            historyApiProviderRegistered = true;
-            if (typeof registry.unregisterHistoryApiProvider === 'function') {
-                historyApiRegistry = { unregisterHistoryApiProvider: registry.unregisterHistoryApiProvider.bind(registry) };
-            }
-            server.debug('[KIP][HISTORY_PROVIDER] registration success provider=kip');
-            return;
-        }
-        server.debug('[KIP][HISTORY_PROVIDER] registration skipped reason=api-unavailable');
+        registerHistoryApiProvider(apiProvider);
+        historyApiProviderRegistered = true;
+        server.debug('[KIP][HISTORY_PROVIDER] registration success provider=kip');
     }
     function rebuildSeriesCaptureSubscriptions() {
         stopSeriesCapture();
@@ -603,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');
@@ -742,16 +826,16 @@ const start = (server) => {
                 .catch(() => undefined)
                 .then(() => storageService.close(storageLifecycleToken))
                 .catch(() => undefined);
-            if (historyApiRegistry) {
-                try {
-                    historyApiRegistry.unregisterHistoryApiProvider();
-                    server.debug('[KIP][HISTORY_PROVIDER] unregister success provider=kip');
-                }
-                catch (error) {
-                    server.error(`[HISTORY PROVIDER] unregister failed: ${String(error.message || error)}`);
-                }
-                historyApiRegistry = null;
+            const serverWithHistoryApi = server;
+            const unregisterHistoryApiProvider = typeof serverWithHistoryApi.unregisterHistoryApiProvider === 'function'
+                ? serverWithHistoryApi.unregisterHistoryApiProvider.bind(serverWithHistoryApi)
+                : (typeof serverWithHistoryApi.history?.unregisterHistoryApiProvider === 'function'
+                    ? serverWithHistoryApi.history.unregisterHistoryApiProvider.bind(serverWithHistoryApi.history)
+                    : null);
+            if (unregisterHistoryApiProvider) {
+                unregisterHistoryApiProvider();
             }
+            historyApiProviderRegistered = false;
             sqliteInitializationPromise = null;
             const msg = 'Stopped.';
             server.setPluginStatus(msg);
@@ -1057,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();
@@ -1093,4 +1191,6 @@ const start = (server) => {
     };
     return plugin;
 };
+const startWithHooks = start;
+startWithHooks.getSqliteModule = defaultGetSqliteModule;
 module.exports = start;