@rhizomatics/signalk-einklabel-plugin 0.6.4 → 0.7.0

package/dist/plugin.js

@@ -21,16 +21,16 @@ async function runStartupScan(app, discovered, durationSeconds) {
                 }
                 const found = await driver.identifyDevice(device, address, name, manufacturerId, manufacturerData).catch((err) => {
                     scanError = `${driver.vendor} scan failed: ${err.message}`;
-                    app.debug(`${scanError}\n${err.stack ?? ''}`);
+                    app.debug(`${scanError}\n${err.stack ?? ""}`);
                     return undefined;
                 });
                 if (!found) {
                     return;
                 }
                 discovered.push(found);
-                const pid = found.pid !== undefined ? `0x${found.pid.toString(16).padStart(4, '0')}` : 'unknown';
-                const hwid = found.hwVersion ?? 'unknown';
-                app.debug(`discovered ${driver.vendor} device "${found.name ?? ''}" [${found.address}] pid=${pid} hwid=${hwid}`);
+                const pid = found.pid !== undefined ? `0x${found.pid.toString(16).padStart(4, "0")}` : "unknown";
+                const hwid = found.hwVersion ?? "unknown";
+                app.debug(`discovered ${driver.vendor} device "${found.name ?? ""}" [${found.address}] pid=${pid} hwid=${hwid}`);
             });
         });
     }
@@ -39,17 +39,17 @@ async function runStartupScan(app, discovered, durationSeconds) {
         // D-Bus connection) skips every line below, leaving the admin UI stuck on "Scanning..."
         // forever even though `discovered` may already hold devices found before the failure.
         scanError = `scan failed: ${err.message}`;
-        app.debug(`${scanError}\n${err.stack ?? ''}`);
+        app.debug(`${scanError}\n${err.stack ?? ""}`);
     }
     // Surfaces the real cause in the admin UI (instead of only the debug log) - a scan that
     // ends in well under its configured duration is almost always this, not "no devices nearby".
-    app.setPluginError(scanError ?? '');
+    app.setPluginError(scanError ?? "");
     const elapsedSeconds = ((Date.now() - startedAt) / 1000).toFixed(1);
     if (discovered.length === 0) {
         app.setPluginStatus(`Scan complete - no ESL devices found nearby after ${elapsedSeconds} seconds.`);
         return;
     }
-    const summary = discovered.map((device) => `${device.name ?? device.vendor} [${device.address}]`).join(', ');
+    const summary = discovered.map((device) => `${device.name ?? device.vendor} [${device.address}]`).join(", ");
     app.setPluginStatus(`Scan complete - found ${discovered.length} device(s) in ${elapsedSeconds}s: ${summary} - pick one from a device's "Device" field below`);
 }
 function createPlugin(app) {
@@ -63,13 +63,16 @@ function createPlugin(app) {
     let scanInProgress;
     let scanStartedAt;
     const plugin = {
-        id: 'signalk-einklabel-plugin',
-        name: 'eInk ESL (Electronic Shelf Label)',
-        description: 'Renders selected SignalK data to BLE eInk Electronic Shelf Labels',
+        id: "signalk-einklabel-plugin",
+        name: "eInk ESL (Electronic Shelf Label)",
+        description: "Renders selected SignalK data to BLE eInk Electronic Shelf Labels",
         schema: () => (0, config_1.configSchema)(app, lastDiscovered),
         uiSchema: () => (0, config_1.configUiSchema)(),
         start(config) {
-            const pluginConfig = { ...(0, config_1.defaultConfig)(), ...config };
+            const pluginConfig = {
+                ...(0, config_1.defaultConfig)(),
+                ...config,
+            };
             app.debug(`starting with ${pluginConfig.devices.length} configured device(s)`);
             if (pluginConfig.scanOnStart) {
                 if (scanInProgress) {
@@ -82,7 +85,7 @@ function createPlugin(app) {
                     scanStartedAt = Date.now();
                     const scan = runStartupScan(app, lastDiscovered, pluginConfig.scanDurationSeconds).catch((err) => app.debug(`startup scan failed: ${err.message}`));
                     scanInProgress = scan;
-                    scan.finally(() => {
+                    void scan.finally(() => {
                         scanInProgress = undefined;
                         scanStartedAt = undefined;
                     });
@@ -93,7 +96,7 @@ function createPlugin(app) {
         stop() {
             scheduler?.stop();
             scheduler = undefined;
-            app.debug('stopped');
+            app.debug("stopped");
         },
     };
     return plugin;

package/dist/pluginVersion.d.ts

@@ -4,3 +4,12 @@
  * `cli/liveContext.ts`), e.g. to show a build/version marker on a label for support purposes.
  */
 export declare const PLUGIN_VERSION: string;
+/**
+ * The installed plugin's own package name, with any npm scope (`@rhizomatics/`) stripped - prefixed
+ * onto `console.error` lines from code shared with the CLI (rendering/device-driver modules with no
+ * `ServerAPI` to call `app.debug` on). SignalK server's own `app.debug` calls are auto-namespaced
+ * with the plugin id (unscoped, e.g. `signalk-einklabel-plugin`) by the `debug` module underneath
+ * it, so without this prefix those `console.error` lines would show up in the server log
+ * unidentified next to ones that are - matching the unscoped form keeps the two consistent.
+ */
+export declare const PLUGIN_NAME: string;

package/dist/pluginVersion.js

@@ -1,11 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLUGIN_VERSION = void 0;
+exports.PLUGIN_NAME = exports.PLUGIN_VERSION = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, "..", "package.json"), "utf-8"));
 /**
  * The installed plugin's own version, read from `package.json` once at module load - exposed to
  * templates as `source=einklabel,path=plugin_version` (see `meta` in repaintScheduler.ts and
  * `cli/liveContext.ts`), e.g. to show a build/version marker on a label for support purposes.
  */
-exports.PLUGIN_VERSION = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '..', 'package.json'), 'utf-8')).version;
+exports.PLUGIN_VERSION = packageJson.version;
+/**
+ * The installed plugin's own package name, with any npm scope (`@rhizomatics/`) stripped - prefixed
+ * onto `console.error` lines from code shared with the CLI (rendering/device-driver modules with no
+ * `ServerAPI` to call `app.debug` on). SignalK server's own `app.debug` calls are auto-namespaced
+ * with the plugin id (unscoped, e.g. `signalk-einklabel-plugin`) by the `debug` module underneath
+ * it, so without this prefix those `console.error` lines would show up in the server log
+ * unidentified next to ones that are - matching the unscoped form keeps the two consistent.
+ */
+exports.PLUGIN_NAME = packageJson.name.replace(/^@[^/]+\//, "");

package/dist/render/assets.d.ts

@@ -6,10 +6,18 @@
  */
 export declare function normalizeAssetKey(value: unknown): string | undefined;
 /**
- * Resolves an `assets=` binding to an actual `.svg` file, looked up as `<key>.svg` inside `assetsDir`
- * resolved relative to the template's own directory (mirroring how a bundled template's relative asset
- * references keep working whether the template itself is the bundled copy or a user override elsewhere) -
- * `undefined` if no matching file exists, which callers treat as "no image" rather than an error, since an
- * unmapped value (e.g. a phase name the asset set doesn't cover) is an expected, not exceptional, case.
+ * Resolves an `assets=` binding to an actual `.svg` file, looked up as `<key>.svg` inside whichever
+ * `assets/<assetsName>` directory `selectAssetsDir` picks. `undefined` if that directory has no
+ * matching file, which callers treat as "no image" rather than an error, since an unmapped value
+ * (e.g. a phase name the asset set doesn't cover) is an expected, not exceptional, case.
  */
-export declare function resolveAssetPath(templatePath: string, assetsDir: string, key: string): string | undefined;
+export declare function resolveAssetPath(templatesDir: string, bundledTemplatesDir: string, assetsName: string, key: string): string | undefined;
+/**
+ * Diagnoses why an `assets=` directory itself might be at fault, for a caller to log when
+ * `resolveAssetPath` comes back empty - a wrong/misconfigured `assets=` name (typo, nothing bundled or
+ * user-supplied under that name) looks identical to "this value just has no icon" from
+ * `resolveAssetPath` alone, and the two need very different fixes. Checks the same directory
+ * `resolveAssetPath` would have read from; `undefined` when that directory is fine (exists, is a
+ * directory, is readable) - the miss is then just this value's.
+ */
+export declare function describeAssetsDirProblem(templatesDir: string, bundledTemplatesDir: string, assetsName: string): string | undefined;

package/dist/render/assets.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeAssetKey = normalizeAssetKey;
 exports.resolveAssetPath = resolveAssetPath;
+exports.describeAssetsDirProblem = describeAssetsDirProblem;
 const fs_1 = require("fs");
 const path_1 = require("path");
 /**
@@ -11,23 +12,77 @@ const path_1 = require("path");
  * a file (non-string, empty, or all-punctuation), which callers treat as "no image".
  */
 function normalizeAssetKey(value) {
-    if (typeof value !== 'string')
+    if (typeof value !== "string")
         return undefined;
     const normalized = value
         .trim()
         .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '_')
-        .replace(/^_+|_+$/g, '');
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
     return normalized || undefined;
 }
 /**
- * Resolves an `assets=` binding to an actual `.svg` file, looked up as `<key>.svg` inside `assetsDir`
- * resolved relative to the template's own directory (mirroring how a bundled template's relative asset
- * references keep working whether the template itself is the bundled copy or a user override elsewhere) -
- * `undefined` if no matching file exists, which callers treat as "no image" rather than an error, since an
- * unmapped value (e.g. a phase name the asset set doesn't cover) is an expected, not exceptional, case.
+ * Picks which `assets/<assetsName>` directory an `assets=` binding should read from - the user's own
+ * `templatesDir/assets/<assetsName>` if it exists as a directory at all, otherwise
+ * `bundledTemplatesDir/assets/<assetsName>` (see `BUNDLED_TEMPLATES_DIR` in `../config.ts`). This is a
+ * whole-directory choice, not a per-file merge: a user who provides their own `assets/lunar_phases`
+ * directory (even a partial one, missing some phases) gets exactly that directory and nothing from the
+ * bundled set, so it's always clear which files are in play - see the module's "overrides only work at
+ * directory level" design note. This choice is independent of which template file (bundled or a user
+ * override) ended up being rendered, so a user can override just a template, just its resources, or
+ * both, in any combination.
  */
-function resolveAssetPath(templatePath, assetsDir, key) {
-    const candidate = (0, path_1.join)((0, path_1.dirname)(templatePath), assetsDir, `${key}.svg`);
+function selectAssetsDir(templatesDir, bundledTemplatesDir, assetsName) {
+    const userDir = (0, path_1.join)(templatesDir, "assets", assetsName);
+    try {
+        if ((0, fs_1.statSync)(userDir).isDirectory())
+            return userDir;
+    }
+    catch {
+        // doesn't exist (or isn't readable) - fall through to the bundled directory
+    }
+    return (0, path_1.join)(bundledTemplatesDir, "assets", assetsName);
+}
+/**
+ * Resolves an `assets=` binding to an actual `.svg` file, looked up as `<key>.svg` inside whichever
+ * `assets/<assetsName>` directory `selectAssetsDir` picks. `undefined` if that directory has no
+ * matching file, which callers treat as "no image" rather than an error, since an unmapped value
+ * (e.g. a phase name the asset set doesn't cover) is an expected, not exceptional, case.
+ */
+function resolveAssetPath(templatesDir, bundledTemplatesDir, assetsName, key) {
+    const candidate = (0, path_1.join)(selectAssetsDir(templatesDir, bundledTemplatesDir, assetsName), `${key}.svg`);
     return (0, fs_1.existsSync)(candidate) ? candidate : undefined;
 }
+/** `undefined` when `dir` is a readable directory - otherwise a human-readable reason it isn't. */
+function describeDir(dir) {
+    if (!(0, fs_1.existsSync)(dir))
+        return `"${dir}" does not exist`;
+    let stats;
+    try {
+        stats = (0, fs_1.statSync)(dir);
+    }
+    catch (err) {
+        return `"${dir}" could not be read: ${err.message}`;
+    }
+    if (!stats.isDirectory())
+        return `"${dir}" is not a directory`;
+    try {
+        (0, fs_1.accessSync)(dir, fs_1.constants.R_OK);
+    }
+    catch (err) {
+        return `"${dir}" is not readable: ${err.message}`;
+    }
+    return undefined;
+}
+/**
+ * Diagnoses why an `assets=` directory itself might be at fault, for a caller to log when
+ * `resolveAssetPath` comes back empty - a wrong/misconfigured `assets=` name (typo, nothing bundled or
+ * user-supplied under that name) looks identical to "this value just has no icon" from
+ * `resolveAssetPath` alone, and the two need very different fixes. Checks the same directory
+ * `resolveAssetPath` would have read from; `undefined` when that directory is fine (exists, is a
+ * directory, is readable) - the miss is then just this value's.
+ */
+function describeAssetsDirProblem(templatesDir, bundledTemplatesDir, assetsName) {
+    const problem = describeDir(selectAssetsDir(templatesDir, bundledTemplatesDir, assetsName));
+    return problem && `assets directory ${problem}`;
+}

package/dist/render/binding.d.ts

@@ -1,4 +1,4 @@
-import { TemplateContext } from './types';
+import { TemplateContext } from "./types";
 declare const SOURCES: readonly ["signalk", "resources", "einklabel"];
 type Source = (typeof SOURCES)[number];
 /**
@@ -17,7 +17,14 @@ export interface Binding {
     /** Explicit unit-preferences category (e.g. `depth`, `speed`, `temperature`) for a numeric value with no path metadata of its own, e.g. a `source=resources` value - see `../unitCategories.ts`. */
     category?: string;
     round?: number;
-    /** Only meaningful on an `<image>` element's binding (see `SvgRenderer`) - a directory, resolved relative to the template file, of `<value>.svg` files to pick from by the resolved value (see `../assets.ts`'s `normalizeAssetKey`). */
+    /**
+     * Only meaningful on an `<image>` element's binding (see `SvgRenderer`) - names an `assets/<name>`
+     * directory (e.g. `assets=lunar_phases` for `templates/assets/lunar_phases/`) of `<value>.svg` files
+     * to pick from by the resolved value (see `../assets.ts`'s `normalizeAssetKey`/`resolveAssetPath`).
+     * Looked up under the user's configured templates directory first, then the plugin's own bundled
+     * `templates/` directory - never relative to the specific template file itself, so overriding a
+     * template doesn't also require duplicating its bundled asset sets.
+     */
     assets?: string;
 }
 /**

package/dist/render/binding.js

@@ -6,8 +6,8 @@ exports.resolveBinding = resolveBinding;
 exports.renderBinding = renderBinding;
 const xmldom_1 = require("@xmldom/xmldom");
 const formatters_1 = require("./formatters");
-const SOURCES = ['signalk', 'resources', 'einklabel'];
-const KNOWN_KEYS = new Set(['source', 'context', 'resource', 'path', 'format', 'category', 'round', 'assets']);
+const SOURCES = ["signalk", "resources", "einklabel"];
+const KNOWN_KEYS = new Set(["source", "context", "resource", "path", "format", "category", "round", "assets"]);
 /**
  * Parses a `<desc>` element's text content into a `Binding`, e.g.
  * `source=resources,resource=tides,path=extremes[0].level,category=depth,round=2` or, using the
@@ -19,15 +19,15 @@ const KNOWN_KEYS = new Set(['source', 'context', 'resource', 'path', 'format', '
  */
 function parseBinding(desc) {
     const trimmedDesc = desc.trim();
-    if (trimmedDesc && !trimmedDesc.includes('=')) {
-        return { source: 'signalk', context: 'self', path: trimmedDesc };
+    if (trimmedDesc && !trimmedDesc.includes("=")) {
+        return { source: "signalk", context: "self", path: trimmedDesc };
     }
     const fields = {};
-    for (const pair of desc.split(',')) {
+    for (const pair of desc.split(",")) {
         const trimmed = pair.trim();
         if (!trimmed)
             continue;
-        const eq = trimmed.indexOf('=');
+        const eq = trimmed.indexOf("=");
         if (eq < 0) {
             throw new Error(`invalid binding "${desc}" - expected "key=value" pairs, got "${trimmed}"`);
         }
@@ -37,12 +37,12 @@ function parseBinding(desc) {
         }
         fields[key] = trimmed.slice(eq + 1).trim();
     }
-    const source = (fields.source ?? 'signalk');
+    const source = (fields.source ?? "signalk");
     if (!SOURCES.includes(source)) {
         throw new Error(`invalid binding "${desc}" - unknown source "${source}"`);
     }
-    const context = fields.context ?? 'self';
-    if (source === 'resources' && !fields.resource) {
+    const context = fields.context ?? "self";
+    if (source === "resources" && !fields.resource) {
         throw new Error(`invalid binding "${desc}" - source=resources requires a "resource" key`);
     }
     if (!fields.path) {
@@ -67,12 +67,12 @@ function parseBinding(desc) {
  * way as a `<text>` binding.
  */
 function findBindings(svgSource) {
-    const doc = new xmldom_1.DOMParser().parseFromString(svgSource, 'image/svg+xml');
+    const doc = new xmldom_1.DOMParser().parseFromString(svgSource, "image/svg+xml");
     const bindings = [];
-    for (const tagName of ['text', 'image']) {
+    for (const tagName of ["text", "image"]) {
         const elements = doc.getElementsByTagName(tagName);
         for (let i = 0; i < elements.length; i++) {
-            const desc = elements.item(i)?.getElementsByTagName('desc').item(0);
+            const desc = elements.item(i)?.getElementsByTagName("desc").item(0);
             if (desc?.textContent) {
                 bindings.push(parseBinding(desc.textContent));
             }
@@ -83,12 +83,12 @@ function findBindings(svgSource) {
 /** Supports both `a.[0].b` and `a[0].b` array index notation, matching `setAtPath` in repaintScheduler.ts. */
 function getAtPath(obj, path) {
     const segments = path
-        .replace(/\[(\d+)\]/g, '.$1')
-        .split('.')
+        .replace(/\[(\d+)\]/g, ".$1")
+        .split(".")
         .filter((segment) => segment.length > 0);
     let node = obj;
     for (const segment of segments) {
-        if (node === null || typeof node !== 'object')
+        if (node === null || typeof node !== "object")
             return undefined;
         node = node[segment];
     }
@@ -96,7 +96,7 @@ function getAtPath(obj, path) {
 }
 /** Resolves a parsed `Binding` against the render context assembled by `assembleRawContext`. */
 function resolveBinding(binding, context) {
-    if (binding.source === 'signalk') {
+    if (binding.source === "signalk") {
         const signalk = context.signalk;
         const vessel = signalk?.[binding.context];
         if (vessel === undefined) {
@@ -104,7 +104,7 @@ function resolveBinding(binding, context) {
         }
         return getAtPath(vessel, binding.path);
     }
-    if (binding.source === 'einklabel') {
+    if (binding.source === "einklabel") {
         const meta = context.meta;
         if (meta === undefined) {
             throw new Error('binding references source "einklabel" but no "meta" is present in the render context');
@@ -127,7 +127,7 @@ function resolveBinding(binding, context) {
  * rather than an error).
  */
 function resolveDisplayUnits(binding, context) {
-    if (binding.source !== 'signalk')
+    if (binding.source !== "signalk")
         return undefined;
     const pathMeta = context.pathMeta;
     return pathMeta?.[binding.context]?.[binding.path]?.displayUnits;
@@ -161,20 +161,20 @@ function resolveCategoryDisplayUnits(binding, context) {
  */
 function renderBinding(binding, context) {
     const value = resolveBinding(binding, context);
-    if (binding.format && binding.format !== 'raw')
+    if (binding.format && binding.format !== "raw")
         return (0, formatters_1.applyFormat)(binding.format, value, context, binding.round);
-    if (typeof value === 'number') {
+    if (typeof value === "number") {
         if (binding.category)
             return (0, formatters_1.formatDisplayUnits)(value, resolveCategoryDisplayUnits(binding, context), binding.round);
-        const displayUnits = binding.format === 'raw' ? undefined : resolveDisplayUnits(binding, context);
+        const displayUnits = binding.format === "raw" ? undefined : resolveDisplayUnits(binding, context);
         if (displayUnits)
             return (0, formatters_1.formatDisplayUnits)(value, displayUnits, binding.round);
         if (binding.round !== undefined)
             return value.toFixed(binding.round);
     }
     if (value === null || value === undefined)
-        return '';
-    if (typeof value === 'object')
+        return "";
+    if (typeof value === "object")
         return JSON.stringify(value);
     return String(value);
 }

package/dist/render/fonts.js

@@ -24,9 +24,9 @@ exports.GENERIC_FONT_FAMILY_MAP = exports.DEFAULT_FONT_PATHS = void 0;
  */
 exports.DEFAULT_FONT_PATHS = [
     // first font is the default
-    require.resolve('@fontsource/roboto/files/roboto-latin-400-normal.woff2'),
-    require.resolve('@fontsource/roboto-mono/files/roboto-mono-latin-400-normal.woff2'),
-    require.resolve('@fontsource/roboto-serif/files/roboto-serif-latin-400-normal.woff2'),
+    require.resolve("@fontsource/roboto/files/roboto-latin-400-normal.woff2"),
+    require.resolve("@fontsource/roboto-mono/files/roboto-mono-latin-400-normal.woff2"),
+    require.resolve("@fontsource/roboto-serif/files/roboto-serif-latin-400-normal.woff2"),
 ];
 /**
  * Maps each CSS generic font-family keyword to the literal embedded name (nameID1) of the
@@ -36,7 +36,7 @@ exports.DEFAULT_FONT_PATHS = [
  * - see project memory. Keep these in sync with DEFAULT_FONT_PATHS if a bucket's font ever changes.
  */
 exports.GENERIC_FONT_FAMILY_MAP = {
-    'sans-serif': 'Roboto',
-    monospace: 'Roboto Mono',
-    serif: 'Roboto Serif 20pt',
+    "sans-serif": "Roboto",
+    monospace: "Roboto Mono",
+    serif: "Roboto Serif 20pt",
 };

package/dist/render/formatters.d.ts

@@ -1,4 +1,4 @@
-import { TemplateContext } from './types';
+import { TemplateContext } from "./types";
 /**
  * Matches `displayUnits` on a path's own metadata (`app.getMetadata(path).displayUnits` in the live
  * plugin, the `.../meta` tree over HTTP in the CLI) - SignalK's per-path unit-preference info, fully

package/dist/render/formatters.js

@@ -8,7 +8,7 @@ const mathjs_1 = require("mathjs");
 /** Converts a base-SI value (always what SignalK paths deliver) to its metadata's preferred display unit and formats it with the unit's symbol, e.g. 3.42 -> "11.2ft". */
 function formatDisplayUnits(value, displayUnits, round) {
     const converted = displayUnits.formula ? Number((0, mathjs_1.evaluate)(displayUnits.formula, { value })) : value;
-    const decimals = round ?? (displayUnits.displayFormat?.includes('.') ? displayUnits.displayFormat.split('.')[1].length : 0);
+    const decimals = round ?? (displayUnits.displayFormat?.includes(".") ? displayUnits.displayFormat.split(".")[1].length : 0);
     const symbol = displayUnits.symbol ?? displayUnits.targetUnit;
     return `${converted.toFixed(decimals)}${symbol}`;
 }
@@ -37,10 +37,13 @@ function selfTimezone(context) {
  * binding (see `considerRepaint`).
  */
 function resolveLocalZoneAbbreviation(context) {
-    const part = new Intl.DateTimeFormat(undefined, { timeZone: selfTimezone(context), timeZoneName: 'short' })
+    const part = new Intl.DateTimeFormat(undefined, {
+        timeZone: selfTimezone(context),
+        timeZoneName: "short",
+    })
         .formatToParts(new Date())
-        .find((p) => p.type === 'timeZoneName');
-    return part?.value ?? '';
+        .find((p) => p.type === "timeZoneName");
+    return part?.value ?? "";
 }
 /**
  * A `resources`-sourced timestamp can arrive as either an ISO string (always true over HTTP, since
@@ -51,9 +54,9 @@ function resolveLocalZoneAbbreviation(context) {
  */
 function parseTimestamp(value) {
     if (value instanceof Date)
-        return luxon_1.DateTime.fromJSDate(value, { zone: 'utc' });
-    if (typeof value === 'string')
-        return luxon_1.DateTime.fromISO(value, { zone: 'utc' });
+        return luxon_1.DateTime.fromJSDate(value, { zone: "utc" });
+    if (typeof value === "string")
+        return luxon_1.DateTime.fromISO(value, { zone: "utc" });
     return undefined;
 }
 /**
@@ -63,51 +66,51 @@ function parseTimestamp(value) {
  */
 function formatLocalTime(value, context) {
     const dt = parseTimestamp(value)?.setZone(selfTimezone(context));
-    return dt?.isValid ? dt.toFormat('HH:mm') : '';
+    return dt?.isValid ? dt.toFormat("HH:mm") : "";
 }
 /** e.g. "27 Jun" - day of month (no leading zero) and abbreviated month name, in the local vessel's timezone. */
 function formatDayMonth(value, context) {
     const dt = parseTimestamp(value)?.setZone(selfTimezone(context));
-    return dt?.isValid ? dt.toFormat('d MMM') : '';
+    return dt?.isValid ? dt.toFormat("d MMM") : "";
 }
 /** e.g. "21 Jun 26 18:05" - day of month (no leading zero), abbreviated month, 2-digit year, and 24h time, in the local vessel's timezone. */
 function formatLocalDatetimeShort(value, context) {
     const dt = parseTimestamp(value)?.setZone(selfTimezone(context));
-    return dt?.isValid ? dt.toFormat('d MMM yy HH:mm') : '';
+    return dt?.isValid ? dt.toFormat("d MMM yy HH:mm") : "";
 }
 /**
  * IANA region names are ambiguous about DST (e.g. "Europe/London" is UTC+00:00 in winter, UTC+01:00
  * in summer); show the numeric offset actually in effect.
  */
 function formatUtcOffset(value) {
-    if (typeof value !== 'string' || !value)
-        return '';
+    if (typeof value !== "string" || !value)
+        return "";
     const dt = luxon_1.DateTime.now().setZone(value);
-    return dt.isValid ? `UTC${dt.toFormat('ZZ')}` : '';
+    return dt.isValid ? `UTC${dt.toFormat("ZZ")}` : "";
 }
 function formatPosition(value, round) {
     const position = value;
-    if (typeof position?.latitude !== 'number' || typeof position?.longitude !== 'number')
-        return '';
+    if (typeof position?.latitude !== "number" || typeof position?.longitude !== "number")
+        return "";
     const decimals = round ?? 4;
     const lat = Math.abs(position.latitude).toFixed(decimals);
     const lon = Math.abs(position.longitude).toFixed(decimals);
-    const latHemisphere = position.latitude >= 0 ? 'N' : 'S';
-    const lonHemisphere = position.longitude >= 0 ? 'E' : 'W';
+    const latHemisphere = position.latitude >= 0 ? "N" : "S";
+    const lonHemisphere = position.longitude >= 0 ? "E" : "W";
     return `${lat}°${latHemisphere} ${lon}°${lonHemisphere}`;
 }
 /** Applies a named `format=` formatter to a resolved binding value. */
 function applyFormat(name, value, context, round) {
     switch (name) {
-        case 'local_time':
+        case "local_time":
             return formatLocalTime(value, context);
-        case 'day_mon':
+        case "day_mon":
             return formatDayMonth(value, context);
-        case 'local_datetime_short':
+        case "local_datetime_short":
             return formatLocalDatetimeShort(value, context);
-        case 'utc_offset':
+        case "utc_offset":
             return formatUtcOffset(value);
-        case 'position':
+        case "position":
             return formatPosition(value, round);
         default:
             throw new Error(`unknown format "${name}"`);

package/dist/render/png.d.ts

@@ -1,3 +1,3 @@
-import { Bitmap } from './types';
+import { Bitmap } from "./types";
 /** Encodes a common Bitmap as PNG bytes, for previewing templates without a physical device. */
 export declare function bitmapToPng(bitmap: Bitmap): Buffer;

package/dist/render/svgRenderer.d.ts

@@ -1,4 +1,4 @@
-import { Bitmap, Renderer, TemplateContext } from './types';
+import { Bitmap, Renderer, TemplateContext } from "./types";
 /**
  * Renders an SVG+binding template to a common RGBA bitmap.
  *
@@ -17,12 +17,13 @@ import { Bitmap, Renderer, TemplateContext } from './types';
  * whole tree and rendered blank.
  *
  * Non-textual inclusion: an `<image>` element with a `<desc>` child works the same way, except the
- * resolved value picks one of a directory of `.svg` files (an `assets=` key, required, names that
- * directory - see `./assets.ts`) rather than substituting text, and the element is dropped entirely
- * (rather than showing an error placeholder) whenever the value is unavailable or doesn't map to a
- * file - e.g. a device without the `derived-data` plugin installed simply shows no moon-phase icon.
- * The matched file's contents are inlined as a `data:image/svg+xml;base64,...` URI so no filesystem
- * access happens at resvg-wasm's render step.
+ * resolved value picks one of a directory of `.svg` files (an `assets=` key, required, names an
+ * `assets/<name>` directory looked up under `templatesDir` first and `BUNDLED_TEMPLATES_DIR` otherwise
+ * - see `resolveAssetPath` in `./assets.ts`) rather than substituting text, and the element is dropped
+ * entirely (rather than showing an error placeholder) whenever the value is unavailable or doesn't map
+ * to a file - e.g. a device without the `derived-data` plugin installed simply shows no moon-phase
+ * icon. The matched file's contents are inlined as a `data:image/svg+xml;base64,...` URI so no
+ * filesystem access happens at resvg-wasm's render step.
  *
  * resvg-wasm cannot see the host's installed fonts (`loadSystemFonts`/`fontFiles`
  * are silently no-ops under plain Node) - it only renders text if given font
@@ -36,5 +37,5 @@ export declare class SvgRenderer implements Renderer {
     private fontBuffers?;
     constructor(fontPaths?: string[]);
     private loadFontBuffers;
-    render(svgTemplatePath: string, context: TemplateContext, width: number, height: number): Promise<Bitmap>;
+    render(svgTemplatePath: string, context: TemplateContext, width: number, height: number, templatesDir?: string, bundledTemplatesDir?: string): Promise<Bitmap>;
 }