@rhizomatics/signalk-einklabel-plugin 0.9.0-beta1 → 0.9.0-beta2

package/dist/config.d.ts

@@ -94,19 +94,18 @@ export interface PluginConfig {
  */
 export declare const BUNDLED_TEMPLATES_DIR: string;
 export declare function defaultConfig(): PluginConfig;
+export declare function readCurrentConfig(app: ServerAPI): Partial<PluginConfig>;
 /**
- * `app.readPluginOptions()`/`savePluginOptions()` aren't actually symmetric despite what their doc
- * comments imply: signalk-server's `readPluginOptions()` returns the *whole* on-disk file
- * (`{ configuration, enabled, enableDebug, enableLogging }`), not just the `configuration` object
- * `savePluginOptions()` writes into - see signalk-server's `interfaces/plugins.ts`
- * (`appCopy.readPluginOptions = () => getPluginOptions(plugin.id)` vs.
- * `appCopy.savePluginOptions = (configuration, cb) => savePluginOptions(id, { ...getPluginOptions(id), configuration }, cb)`).
- * Spreading that return value straight back into a save call therefore nests the whole file one level
- * deeper inside its own `configuration` key every time (see `support/signalk-einklabel-plugin.json` and
- * `clearForceRepaint` in `./repaintScheduler.ts`). Unwrapping any such nesting and keeping only recognised
- * fields here means every save collapses back down instead of growing, self-healing an already-corrupted file.
+ * Actively rewrites the on-disk file once it's nested (see `readCurrentConfig`'s doc comment) -
+ * `readCurrentConfig` alone only self-heals in memory for callers that go through it, but the admin
+ * UI's own config-editing form round-trips whatever raw JSON it was handed verbatim, including a
+ * stray nested `configuration` key it never touches (no schema field maps to it) - so left alone,
+ * every future save from the UI keeps re-persisting that dead weight forever (see
+ * `support/signalk-einklabel-plugin.json`). Called once at plugin start, which - unlike
+ * `clearForceRepaint` - isn't gated on any device having `forceRepaint` set, so a nested file gets
+ * flattened even if nothing ever triggers that path.
  */
-export declare function readCurrentConfig(app: ServerAPI): Partial<PluginConfig>;
+export declare function healNestedConfig(app: ServerAPI): void;
 /**
  * Resolves the user-facing `templatesDir` setting to an actual directory, mirroring
  * signalk-parquet's `outputDirectory` convention: empty means the default location, a relative

package/dist/config.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUNDLED_TEMPLATES_DIR = exports.ALL_DEVICES = void 0;
 exports.defaultConfig = defaultConfig;
 exports.readCurrentConfig = readCurrentConfig;
+exports.healNestedConfig = healNestedConfig;
 exports.resolveTemplatesDir = resolveTemplatesDir;
 exports.parseDevice = parseDevice;
 exports.resolveTemplatePath = resolveTemplatePath;
@@ -65,14 +66,21 @@ const PLUGIN_CONFIG_KEYS = [
  * `clearForceRepaint` in `./repaintScheduler.ts`). Unwrapping any such nesting and keeping only recognised
  * fields here means every save collapses back down instead of growing, self-healing an already-corrupted file.
  */
-function readCurrentConfig(app) {
-    let raw = app.readPluginOptions();
+function unwrapNestedConfiguration(raw) {
+    let levels = 0;
     while (raw &&
         typeof raw === "object" &&
         "configuration" in raw &&
         typeof raw.configuration === "object") {
         raw = raw.configuration;
+        levels++;
     }
+    // One level is the normal, expected shape signalk-server itself stores on disk (see the doc
+    // comment above) - only a *second* nested `configuration` key onwards is the corruption this
+    // guards against.
+    return { unwrapped: raw, wasNested: levels > 1 };
+}
+function pickKnownKeys(raw) {
     const result = {};
     if (raw && typeof raw === "object") {
         for (const key of PLUGIN_CONFIG_KEYS) {
@@ -83,6 +91,31 @@ function readCurrentConfig(app) {
     }
     return result;
 }
+function readCurrentConfig(app) {
+    const { unwrapped } = unwrapNestedConfiguration(app.readPluginOptions());
+    return pickKnownKeys(unwrapped);
+}
+/**
+ * Actively rewrites the on-disk file once it's nested (see `readCurrentConfig`'s doc comment) -
+ * `readCurrentConfig` alone only self-heals in memory for callers that go through it, but the admin
+ * UI's own config-editing form round-trips whatever raw JSON it was handed verbatim, including a
+ * stray nested `configuration` key it never touches (no schema field maps to it) - so left alone,
+ * every future save from the UI keeps re-persisting that dead weight forever (see
+ * `support/signalk-einklabel-plugin.json`). Called once at plugin start, which - unlike
+ * `clearForceRepaint` - isn't gated on any device having `forceRepaint` set, so a nested file gets
+ * flattened even if nothing ever triggers that path.
+ */
+function healNestedConfig(app) {
+    const { unwrapped, wasNested } = unwrapNestedConfiguration(app.readPluginOptions());
+    if (!wasNested)
+        return;
+    app.savePluginOptions(pickKnownKeys(unwrapped), (err) => {
+        if (err)
+            app.debug(`failed to clean up legacy nested plugin config: ${err.message}`);
+        else
+            app.debug("cleaned up a legacy nested plugin config file on disk");
+    });
+}
 /**
  * Resolves the user-facing `templatesDir` setting to an actual directory, mirroring
  * signalk-parquet's `outputDirectory` convention: empty means the default location, a relative

package/dist/plugin.js

@@ -49,6 +49,7 @@ function createPlugin(app) {
                 ...config,
             };
             app.debug(`starting with ${pluginConfig.devices.length} configured device(s)`);
+            (0, config_1.healNestedConfig)(app);
             if (pluginConfig.scanOnStart) {
                 void runStartupScan(app, pluginConfig.scanDurationSeconds);
             }

package/dist/repaintScheduler.js

@@ -234,11 +234,22 @@ async function considerRepaint(app, config, device, target, state, getApiUrl) {
     });
     const rawContext = await assembleRawContext(app, apiUrl, bindings);
     const templateHash = hashTemplate(templateMtimeMs);
+    // Hashed from `rawContext`, not `renderContext` below - `meta.repainted` (and the rest of `meta`)
+    // is only added after this point, deliberately, so a template merely *displaying* the repaint
+    // timestamp doesn't perpetually invalidate its own dedup and force a repaint every check. A full
+    // paint flashes the whole panel several times, and there's no confirmed partial-refresh path on
+    // these devices - so a bound value simply being unchanged is worth trusting over any staleness in
+    // a displayed clock.
     const dataHash = hashData(rawContext);
     const stateKey = stateKeyFor(device.friendlyName, address);
     const previous = state[stateKey];
     const templateChanged = previous?.templateHash !== templateHash;
     const dataChanged = previous?.dataHash !== dataHash;
+    // The devices are battery-constrained, so a repaint is skipped whenever neither the template nor
+    // the bound data has changed since the last successful paint - regardless of what triggered this
+    // check (interval or subscription) or whether it's a regular scheduled tick vs. the deferred
+    // startup catch-up (see `startupCheckTimer`). `forceRepaint` is the explicit, one-shot override
+    // for "repaint anyway".
     if (!templateChanged && !dataChanged && !device.forceRepaint) {
         app.debug(`${label}: data unchanged, skipping repaint`);
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhizomatics/signalk-einklabel-plugin",
-  "version": "0.9.0-beta1",
+  "version": "0.9.0-beta2",
   "description": "Display SignalK data on eInk Electronic Shelf Labels",
   "keywords": [
     "ble",