signalk-charts-provider-simple 2.5.0 → 2.6.0

package/README.md

@@ -5,6 +5,7 @@ A lightweight Signal K server plugin for managing local nautical charts, written
 ## Features
 
 - **Local Chart Management**: MBTiles (raster and vector), with folder organization and enable/disable toggles
+- **Folder Groups**: Enable/disable whole chart folders at once (OpenCPN-style groups, including nested folders); clients like Freeboard-SK see the change live via `resources.charts` deltas
 - **Download Manager**: Built-in download queue with progress tracking and ZIP extraction
 - **Chart Catalog**: Browse and download charts from [chartcatalogs.github.io](https://chartcatalogs.github.io/) with automatic update notifications
 - **NOAA Charts**: Draw a coverage region on a map from NOAA band-4 chart footprints; the plugin bundles the overlapping band-3/4/5 ENCs and converts them into a single vector MBTiles named after your chart set

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAuHxD,OAAO,KAAK,EACV,aAAa,EAEb,iBAAiB,EAIjB,QAAQ,EAET,MAAM,YAAY,CAAC;AAwBpB,QAAA,MAAM,iBAAiB,GAAI,KAAK,iBAAiB,KAAG,MAg7HnD,CAAC;AA4GF,eAAO,MAAM,oBAAoB,GAC/B,KAAK,QAAQ,EACb,UAAU,aAAa,EACvB,GAAG,MAAM,EACT,GAAG,MAAM,EACT,GAAG,MAAM,KACR,IAiDF,CAAC;AAEF,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,MAAM,EAAE,MAAM,qBAAqB,CAAC;AA8HxD,OAAO,KAAK,EACV,aAAa,EAEb,iBAAiB,EAIjB,QAAQ,EAET,MAAM,YAAY,CAAC;AAwBpB,QAAA,MAAM,iBAAiB,GAAI,KAAK,iBAAiB,KAAG,MAujInD,CAAC;AA4GF,eAAO,MAAM,oBAAoB,GAC/B,KAAK,QAAQ,EACb,UAAU,aAAa,EACvB,GAAG,MAAM,EACT,GAAG,MAAM,EACT,GAAG,MAAM,KACR,IAiDF,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/dist/index.js

@@ -9,6 +9,7 @@ import { findCharts, findRepairableCharts } from './charts-loader.js';
 import { checkForUpdates, classifyUrl, fetchCatalog, fetchCatalogRegistry, getCachedCatalog, getCatalogRegistry, getCatalogsWithInstalledCharts, getConvertingCharts, getConvertingCount, getInstalledCatalogCharts, getRegistryStatus, initCatalogManager, pruneStaleInstalls, removeInstall, removeInstallByFilename, renameInstallFilename, rollbackInstall, setConvertingState, setInstallFilename, trackInstall } from './utils/catalog-manager.js';
 import { cleanCatalogTitle } from './utils/catalog-title.js';
 import { initChartState, isChartEnabled, setChartEnabled } from './utils/chart-state.js';
+import { initFolderState, isFolderEnabled, isFolderPathEnabled, setFolderEnabled, removeFolderState } from './utils/folder-state.js';
 import { getCpuBudget, setCpuBudget } from './utils/concurrency.js';
 import { PLUGIN_OWNER_ID } from './utils/container-jobs.js';
 import { getContainerManager, waitForContainerManager } from './utils/container-manager.js';
@@ -147,6 +148,11 @@ const pluginConstructor = (app) => {
                 clearInterval(catalogUpdateInterval);
                 catalogUpdateInterval = null;
             }
+            // Release sqlite handles: on Windows an open handle keeps the
+            // .mbtiles file locked, and Signal K restarts the plugin on every
+            // config save, which would otherwise leak the whole map each time.
+            closeProviderHandles(Object.values(chartProviders));
+            chartProviders = {};
             app.setPluginStatus('stopped');
         },
         registerWithRouter: (router) => {
@@ -265,6 +271,7 @@ const pluginConstructor = (app) => {
             console.log(`[charts-provider] chartPath resolved to ${chartPath} (marker write failed)`);
         }
         initChartState(pluginDataDir);
+        initFolderState(pluginDataDir);
         const dataDir = pluginDataDir;
         initCatalogManager(dataDir, app.debug.bind(app));
         initNoaaEncFootprints(dataDir, app.debug.bind(app));
@@ -442,6 +449,43 @@ const pluginConstructor = (app) => {
         // a stale snapshot would delete them as "invalid".
         void cleanupChartDirectory(chartPath);
     };
+    // A chart is served only when its own flag AND every ancestor folder's
+    // flag are enabled; folder state is a separate layer that never rewrites
+    // per-chart state.
+    const isChartVisible = (chartPath, filePath) => {
+        const relativePath = path.relative(chartPath, filePath);
+        return isChartEnabled(relativePath) && isFolderPathEnabled(path.dirname(relativePath));
+    };
+    // findCharts opens a sqlite handle for every chart it finds; any provider
+    // that doesn't make it into (or drops out of) `chartProviders` must be
+    // closed explicitly or the handle leaks — and on Windows keeps the
+    // .mbtiles file locked. Safe to call on live objects being replaced:
+    // tile serving is synchronous from map lookup to handle use, so no
+    // in-flight request can hold a closed handle across an await.
+    const closeProviderHandles = (providers) => {
+        for (const provider of providers) {
+            try {
+                provider._mbtilesHandle?.close();
+            }
+            catch {
+                // Already closed — nothing to release.
+            }
+        }
+    };
+    const partitionVisibleCharts = (chartPath, charts) => {
+        const visible = {};
+        const dropped = [];
+        for (const [identifier, chart] of Object.entries(charts)) {
+            if (isChartVisible(chartPath, chart._filePath || '')) {
+                visible[identifier] = chart;
+            }
+            else {
+                dropped.push(chart);
+            }
+        }
+        closeProviderHandles(dropped);
+        return visible;
+    };
     // Load enabled charts into `chartProviders` and prune stale install
     // records. Display-critical: must run (and resolve) before the resource
     // provider is registered so `listResources` has charts to return. Returns
@@ -449,10 +493,7 @@ const pluginConstructor = (app) => {
     const loadChartProviders = async (chartPath) => {
         try {
             const charts = await findCharts(chartPath);
-            const enabledCharts = Object.fromEntries(Object.entries(charts).filter(([, chart]) => {
-                const relativePath = path.relative(chartPath, chart._filePath || '');
-                return isChartEnabled(relativePath);
-            }));
+            const enabledCharts = partitionVisibleCharts(chartPath, charts);
             app.debug(`Chart provider: Found ${Object.keys(charts).length} charts (${Object.keys(enabledCharts).length} enabled) from ${chartPath}.`);
             chartProviders = enabledCharts;
             pruneStaleInstalls(Object.keys(charts));
@@ -615,6 +656,12 @@ const pluginConstructor = (app) => {
     const ChartToggleBody = Type.Object({
         enabled: Type.Boolean()
     });
+    // folderPath travels in the body (not a URL param): nested folders contain
+    // '/' and Express 5 rejects encoded %2F in path segments.
+    const FolderToggleBody = Type.Object({
+        folderPath: Type.String({ minLength: 1 }),
+        enabled: Type.Boolean()
+    });
     const MoveChartBody = Type.Object({
         chartPath: Type.String({ minLength: 1 }),
         targetFolder: Type.String({ minLength: 1 })
@@ -915,13 +962,22 @@ const pluginConstructor = (app) => {
                     return {
                         ...chart,
                         enabled: isChartEnabled(chart.relativePath),
+                        folderEnabled: isFolderPathEnabled(chart.folder),
                         downloading: downloadingFiles.has(chart.name),
                         converting
                     };
                 });
+                const folderStates = Object.fromEntries(folders.map((folder) => [
+                    folder,
+                    {
+                        enabled: isFolderEnabled(folder),
+                        effectiveEnabled: isFolderPathEnabled(folder)
+                    }
+                ]));
                 res.json({
                     charts: chartsWithState,
                     folders: folders,
+                    folderStates,
                     basePath: chartPath
                 });
             }
@@ -1051,6 +1107,7 @@ const pluginConstructor = (app) => {
                     return;
                 }
                 await fs.promises.rmdir(fullPath);
+                removeFolderState(folderPathParam);
                 res.status(200).json({ success: true, message: 'Folder deleted successfully' });
             }
             catch (error) {
@@ -1058,6 +1115,64 @@ const pluginConstructor = (app) => {
                 res.status(500).send('Error deleting folder');
             }
         });
+        router.post('/folders/toggle', async (req, res) => {
+            const body = parseBody(FolderToggleBody, req, res);
+            if (!body) {
+                return;
+            }
+            const { folderPath, enabled } = body;
+            try {
+                const basePath = props.chartPath || defaultChartsPath;
+                const fullPath = path.join(basePath, folderPath);
+                if (!isWithinBase(fullPath, basePath)) {
+                    res.status(403).send('Access denied: Invalid path');
+                    return;
+                }
+                if (path.normalize(fullPath) === path.normalize(basePath)) {
+                    res.status(400).send('Cannot toggle the root folder');
+                    return;
+                }
+                if (!fs.existsSync(fullPath)) {
+                    res.status(404).send('Folder not found');
+                    return;
+                }
+                if (!fs.statSync(fullPath).isDirectory()) {
+                    res.status(400).send('Not a folder');
+                    return;
+                }
+                // Diff providers before/after the refresh: a folder toggle can affect
+                // many charts (including nested folders), while charts that are
+                // individually disabled stay absent on both sides and emit no delta.
+                const before = chartProviders;
+                setFolderEnabled(folderPath, enabled);
+                await refreshChartProviders();
+                let chartsAffected = 0;
+                for (const id of Object.keys(before)) {
+                    if (!chartProviders[id]) {
+                        emitChartDelta(id, null);
+                        chartsAffected++;
+                    }
+                }
+                for (const id of Object.keys(chartProviders)) {
+                    if (!before[id]) {
+                        emitChartDelta(id, sanitizeProvider(chartProviders[id], 2));
+                        chartsAffected++;
+                    }
+                }
+                app.debug(`Folder ${folderPath} set to ${enabled ? 'enabled' : 'disabled'} (${chartsAffected} chart delta(s))`);
+                res.status(200).json({
+                    success: true,
+                    message: `Folder ${enabled ? 'enabled' : 'disabled'}`,
+                    folderPath,
+                    enabled,
+                    chartsAffected
+                });
+            }
+            catch (error) {
+                console.error('Error toggling folder state:', error);
+                res.status(500).send('Error toggling folder state');
+            }
+        });
         router.post('/charts/:chartPath/toggle', async (req, res) => {
             const chartPathParam = decodeURIComponent(req.params.chartPath);
             const body = parseBody(ChartToggleBody, req, res);
@@ -1141,6 +1256,12 @@ const pluginConstructor = (app) => {
                     const chartData = sanitizeProvider(chartProviders[chartId], 2);
                     emitChartDelta(chartId, chartData);
                 }
+                else {
+                    // The move can hide the chart from serving (target folder disabled)
+                    // — retract it so v2 clients don't keep a stale entry whose tiles
+                    // now 404.
+                    emitChartDelta(chartId, null);
+                }
                 res.status(200).json({ success: true, message: 'Chart moved successfully' });
             }
             catch (error) {
@@ -3300,10 +3421,11 @@ const pluginConstructor = (app) => {
         try {
             const chartPath = props.chartPath || defaultChartsPath;
             const charts = await findCharts(chartPath);
-            chartProviders = Object.fromEntries(Object.entries(charts).filter(([, chart]) => {
-                const relativePath = path.relative(chartPath, chart._filePath || '');
-                return isChartEnabled(relativePath);
-            }));
+            // Close the handles of the map being replaced — findCharts reopened
+            // every chart, so the old provider objects would otherwise leak.
+            const previous = chartProviders;
+            chartProviders = partitionVisibleCharts(chartPath, charts);
+            closeProviderHandles(Object.values(previous));
             app.debug(`Chart providers refreshed: ${Object.keys(chartProviders).length} enabled charts`);
         }
         catch (error) {