@rhizomatics/signalk-esl-plugin 0.3.0

package/dist/config.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfig = defaultConfig;
+exports.resolveTemplatesDir = resolveTemplatesDir;
+exports.parseDevice = parseDevice;
+exports.resolveTemplatePath = resolveTemplatePath;
+exports.configSchema = configSchema;
+exports.configUiSchema = configUiSchema;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const resolveApiUrl_1 = require("./resolveApiUrl");
+/** The package's own bundled `templates/` directory (ships alongside `dist/`, see package.json's `files`) - templates here are always available, but a same-named template in the user's `templatesDir` takes priority. */
+const BUNDLED_TEMPLATES_DIR = (0, path_1.join)(__dirname, '..', 'templates');
+const SIGNALK_HOME_DIR = (0, path_1.join)((0, os_1.homedir)(), '.signalk');
+const DEFAULT_TEMPLATES_DIR = (0, path_1.join)(SIGNALK_HOME_DIR, 'esl', 'templates');
+function defaultConfig() {
+    return {
+        templatesDir: '',
+        scanOnStart: true,
+        scanDurationSeconds: 20,
+        paintConnectTimeoutSeconds: 30,
+        paintRetries: 3,
+        devices: [],
+    };
+}
+/**
+ * Resolves the user-facing `templatesDir` setting to an actual directory, mirroring
+ * signalk-parquet's `outputDirectory` convention: empty means the default location, a relative
+ * path is resolved against `~/.signalk` (where SignalK itself stores its config by default), and
+ * an absolute path is used as-is.
+ */
+function resolveTemplatesDir(templatesDir) {
+    const trimmed = templatesDir?.trim();
+    if (!trimmed) {
+        return DEFAULT_TEMPLATES_DIR;
+    }
+    return (0, path_1.isAbsolute)(trimmed) ? trimmed : (0, path_1.join)(SIGNALK_HOME_DIR, trimmed);
+}
+/**
+ * Enum for the combined "device" field, built from recently scanned devices - including ones a
+ * driver identified as its vendor but whose PID isn't in its metadata table yet (clearly labelled,
+ * so the user can at least see what was found and report the PID; repainting such a device still
+ * does nothing without a model override, since there's no width/height to render with) - plus, as a
+ * fallback, whatever's already saved so an existing selection doesn't vanish from the dropdown just
+ * because this particular run hasn't re-scanned it yet.
+ */
+function deviceOptions(discovered, current) {
+    const values = [];
+    const labels = [];
+    const seen = new Set();
+    for (const found of discovered) {
+        if (found.pid === undefined) {
+            continue;
+        }
+        const modelToken = [found.vendor, found.pid, found.hwVersion].filter((part) => part !== undefined).join(':');
+        const value = `${modelToken}@${found.address}`;
+        if (seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        values.push(value);
+        const label = found.metadata
+            ? `${found.vendor} ${found.metadata.label} (${found.address})`
+            : `${found.vendor} unrecognised PID 0x${found.pid.toString(16).padStart(4, '0')} (${found.address})`;
+        labels.push(label);
+    }
+    for (const device of current.devices) {
+        if (!seen.has(device.device)) {
+            seen.add(device.device);
+            values.push(device.device);
+            labels.push(`${device.device} (not seen in last scan)`);
+        }
+    }
+    return { values, labels };
+}
+function parseDevice(device) {
+    const [modelToken, address] = device.split('@');
+    const [vendor, pidStr, hwVersion] = (modelToken ?? '').split(':');
+    const pid = Number(pidStr);
+    return vendor && address && Number.isInteger(pid) ? { vendor, pid, hwVersion, address } : undefined;
+}
+function listSvgFiles(dir) {
+    try {
+        return (0, fs_1.readdirSync)(dir).filter((name) => name.endsWith('.svg'));
+    }
+    catch {
+        return [];
+    }
+}
+/** Local templates take priority over a same-named bundled one; both show up as options. */
+function templateNameOptions(templatesDir) {
+    const local = listSvgFiles(templatesDir);
+    const bundled = listSvgFiles(BUNDLED_TEMPLATES_DIR).filter((name) => !local.includes(name));
+    return [...local, ...bundled];
+}
+/** Resolves a template name to an actual file path - a local template overrides the bundled one of the same name. */
+function resolveTemplatePath(templatesDir, templateName) {
+    const localPath = (0, path_1.join)(templatesDir, templateName);
+    return (0, fs_1.existsSync)(localPath) ? localPath : (0, path_1.join)(BUNDLED_TEMPLATES_DIR, templateName);
+}
+/** JSON Schema forbids an empty `enum` array, so only attach one when there's at least one option - otherwise the whole config schema fails validation. */
+function withEnum(schema, values, names) {
+    return values.length > 0 ? { ...schema, enum: values, ...(names ? { enumNames: names } : {}) } : schema;
+}
+function configSchema(app, discovered = []) {
+    const defaults = defaultConfig();
+    const current = { ...defaults, ...app.readPluginOptions() };
+    const { values: deviceValues, labels: deviceLabels } = deviceOptions(discovered, current);
+    return {
+        type: 'object',
+        properties: {
+            templatesDir: {
+                type: 'string',
+                title: 'Templates directory',
+                description: `Relative path from ~/.signalk (e.g., "esl/templates" becomes ~/.signalk/esl/templates). ` +
+                    `Leave empty for default (${DEFAULT_TEMPLATES_DIR}). Absolute paths also supported. A template here ` +
+                    'with the same name as a bundled one takes priority.',
+                default: defaults.templatesDir,
+            },
+            scanOnStart: {
+                type: 'boolean',
+                title: 'Scan for devices on plugin start',
+                description: 'Runs a short BLE scan so discovered devices show up in a device\'s "Device" picker below.',
+                default: defaults.scanOnStart,
+            },
+            scanDurationSeconds: {
+                type: 'number',
+                title: 'Scan duration (seconds)',
+                description: 'How long the startup scan runs - increase if devices are missing from the "Device" picker below.',
+                minimum: 1,
+                default: defaults.scanDurationSeconds,
+            },
+            paintConnectTimeoutSeconds: {
+                type: 'number',
+                title: 'Paint connect timeout (seconds)',
+                description: 'How long to wait for a device to accept a BLE connection before giving up on a repaint attempt.',
+                minimum: 1,
+                default: defaults.paintConnectTimeoutSeconds,
+            },
+            paintRetries: {
+                type: 'number',
+                title: 'Paint retries',
+                description: 'How many times to attempt a repaint (including the first try) before giving up and reporting failure.',
+                minimum: 1,
+                default: defaults.paintRetries,
+            },
+            signalkApiUrl: {
+                type: 'string',
+                title: 'SignalK API base URL (leave blank to auto-detect)',
+                description: 'Used for plugin access to SignalK REST APIs not yet integrated for direct plugin access. Left blank, the plugin probes the likely options at startup (3000, 80, 443 ) - only set this manually to skip probing. Anonymous read access is required.',
+                enum: ['', ...resolveApiUrl_1.SIGNALK_API_URL_OPTIONS],
+            },
+            devices: {
+                type: 'array',
+                title: 'Devices',
+                items: {
+                    type: 'object',
+                    required: ['friendlyName', 'device', 'templateName', 'repaintTrigger'],
+                    properties: {
+                        friendlyName: { type: 'string', title: 'Friendly name' },
+                        device: withEnum({
+                            type: 'string',
+                            title: 'Device',
+                            description: 'Picked from devices found by a scan (plugin start, or `esl-cli scan`) - sets both the model and BLE address.',
+                        }, deviceValues, deviceLabels),
+                        templateName: withEnum({ type: 'string', title: 'Template' }, templateNameOptions(resolveTemplatesDir(current.templatesDir))),
+                        repaintTrigger: { type: 'string', title: 'Repaint trigger', enum: ['subscription', 'interval'] },
+                        triggerPath: { type: 'string', title: 'Trigger SignalK path (if repaint trigger is subscription)' },
+                        intervalHours: { type: 'number', title: 'Repaint every N hours (if repaint trigger is interval)', minimum: 1 },
+                        intervalMinute: { type: 'number', title: 'Minutes past the hour (if repaint trigger is interval)', minimum: 0, maximum: 59, default: 0 },
+                        aesKey: { type: 'string', title: 'BLE AES key (vendor-specific; leave blank to use a default key)' },
+                        forceRepaint: {
+                            type: 'boolean',
+                            title: 'Force repaint',
+                            description: 'Repaint even if the data is unchanged - clears itself automatically once that repaint completes',
+                            default: false,
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+function configUiSchema() {
+    return {
+        devices: {
+            items: {
+                repaintTrigger: { 'ui:widget': 'radio' },
+            },
+        },
+    };
+}

package/dist/devices/bleDiscovery.d.ts

@@ -0,0 +1,54 @@
+import { Adapter, Bluetooth, Device } from 'node-ble';
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Drop-in replacement for `node-ble`'s `createBluetooth` that fails fast and clearly when
+ * BLE isn't available at all, instead of letting `dbus-next` crash the whole process.
+ *
+ * `node-ble` connects to BlueZ over D-Bus, which only exists on Linux. On any other
+ * platform (e.g. a developer's Mac), the underlying `dbus-next` socket connection fails
+ * and emits an `'error'` event with no listener attached - Node treats that as an
+ * uncaught exception rather than a promise rejection, so no `try`/`catch` around
+ * `createBluetooth()` or its callers can see it; it takes the whole process down.
+ */
+export declare function createBluetooth(): {
+    bluetooth: Bluetooth;
+    destroy: () => void;
+};
+/** BLE manufacturer ID advertised by the device, if any - the key of its manufacturer data map. */
+export declare function getManufacturerId(device: Device): Promise<number | undefined>;
+export interface AdvertisedDevice {
+    address: string;
+    device: Device;
+    name?: string;
+    manufacturerId?: number;
+    manufacturerData?: Buffer;
+}
+/**
+ * Reads each nearby device's advertisement exactly once and hands it to `fn` - shared by
+ * `plugin.ts`'s startup scan and the CLI's `scan` command so that identifying which vendor (if
+ * any) a device belongs to costs one `getName`/`getManufacturerData` read per device total, not
+ * one per device per registered driver.
+ */
+export declare function forEachAdvertisedDevice(adapter: Adapter, fn: (advertised: AdvertisedDevice) => Promise<void>): Promise<void>;
+/**
+ * Retries `fn` up to `attempts` times (including the first try), returning on the first success -
+ * shared by the repaint scheduler and the CLI's `paint` command so one flaky BLE connection
+ * doesn't fail a whole repaint after a single bad attempt.
+ */
+export declare function withRetries<T>(attempts: number, fn: (attempt: number) => Promise<T>): Promise<T>;
+/**
+ * Opens exactly one BLE discovery window and one D-Bus/BlueZ session, then hands the adapter to
+ * `fn` - shared by `plugin.ts`'s startup scan and the CLI's `scan` command so scanning across
+ * multiple registered vendor drivers costs one discovery window total, not one window per driver.
+ */
+export declare function withDiscovery<T>(durationMs: number, fn: (adapter: Adapter) => Promise<T>): Promise<T>;
+/**
+ * `device.connect()` has no timeout of its own - BlueZ's underlying D-Bus `Connect` call can hang
+ * indefinitely for a device that's out of range or stuck mid-handshake, which would otherwise
+ * block a scan (or `paint()`) on that one device forever. Throws once `timeoutMs` elapses; if the
+ * connect does eventually resolve afterwards, disconnects in the background so a stray successful
+ * connection doesn't itself block the next attempt.
+ */
+export declare function connectWithTimeout(device: Device, timeoutMs: number): Promise<void>;
+/** Uses an already-known device if BlueZ has one cached, otherwise scans until it appears. */
+export declare function getOrDiscoverDevice(adapter: Adapter, address: string, timeoutMs: number): Promise<Device>;

package/dist/devices/bleDiscovery.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
+exports.createBluetooth = createBluetooth;
+exports.getManufacturerId = getManufacturerId;
+exports.forEachAdvertisedDevice = forEachAdvertisedDevice;
+exports.withRetries = withRetries;
+exports.withDiscovery = withDiscovery;
+exports.connectWithTimeout = connectWithTimeout;
+exports.getOrDiscoverDevice = getOrDiscoverDevice;
+const node_ble_1 = require("node-ble");
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Drop-in replacement for `node-ble`'s `createBluetooth` that fails fast and clearly when
+ * BLE isn't available at all, instead of letting `dbus-next` crash the whole process.
+ *
+ * `node-ble` connects to BlueZ over D-Bus, which only exists on Linux. On any other
+ * platform (e.g. a developer's Mac), the underlying `dbus-next` socket connection fails
+ * and emits an `'error'` event with no listener attached - Node treats that as an
+ * uncaught exception rather than a promise rejection, so no `try`/`catch` around
+ * `createBluetooth()` or its callers can see it; it takes the whole process down.
+ */
+function createBluetooth() {
+    if (process.platform !== 'linux') {
+        throw new Error(`BLE support requires Linux (BlueZ over D-Bus); "${process.platform}" is not supported - ` +
+            'run this on the target Linux host (e.g. the NanoPi), not on macOS/Windows.');
+    }
+    return (0, node_ble_1.createBluetooth)();
+}
+/** BLE manufacturer ID advertised by the device, if any - the key of its manufacturer data map. */
+async function getManufacturerId(device) {
+    const manufacturerData = await device.getManufacturerData().catch(() => undefined);
+    const [key] = Object.keys(manufacturerData ?? {});
+    return key === undefined ? undefined : Number(key);
+}
+/**
+ * Reads each nearby device's advertisement exactly once and hands it to `fn` - shared by
+ * `plugin.ts`'s startup scan and the CLI's `scan` command so that identifying which vendor (if
+ * any) a device belongs to costs one `getName`/`getManufacturerData` read per device total, not
+ * one per device per registered driver.
+ */
+async function forEachAdvertisedDevice(adapter, fn) {
+    for (const address of await adapter.devices()) {
+        // BlueZ can drop a device from its cache between `adapter.devices()` listing it and this
+        // lookup (e.g. it went out of range mid-scan) - skip it rather than aborting the whole scan.
+        const device = await adapter.getDevice(address).catch(() => undefined);
+        if (!device) {
+            continue;
+        }
+        const name = await device.getName().catch(() => undefined);
+        const manufacturerData = await device.getManufacturerData().catch(() => undefined);
+        const [key] = Object.keys(manufacturerData ?? {});
+        const manufacturerId = key === undefined ? undefined : Number(key);
+        await fn({ address, device, name, manufacturerId, manufacturerData: key === undefined ? undefined : manufacturerData[key] });
+    }
+}
+/**
+ * Retries `fn` up to `attempts` times (including the first try), returning on the first success -
+ * shared by the repaint scheduler and the CLI's `paint` command so one flaky BLE connection
+ * doesn't fail a whole repaint after a single bad attempt.
+ */
+async function withRetries(attempts, fn) {
+    let lastErr;
+    for (let attempt = 1; attempt <= Math.max(1, attempts); attempt++) {
+        try {
+            return await fn(attempt);
+        }
+        catch (err) {
+            lastErr = err;
+        }
+    }
+    throw lastErr;
+}
+/**
+ * Opens exactly one BLE discovery window and one D-Bus/BlueZ session, then hands the adapter to
+ * `fn` - shared by `plugin.ts`'s startup scan and the CLI's `scan` command so scanning across
+ * multiple registered vendor drivers costs one discovery window total, not one window per driver.
+ */
+async function withDiscovery(durationMs, fn) {
+    const { bluetooth, destroy } = createBluetooth();
+    try {
+        const adapter = await bluetooth.defaultAdapter();
+        const wasDiscovering = await adapter.isDiscovering();
+        if (!wasDiscovering) {
+            await adapter.startDiscovery();
+        }
+        await sleep(durationMs);
+        if (!wasDiscovering) {
+            await adapter.stopDiscovery();
+        }
+        return await fn(adapter);
+    }
+    finally {
+        destroy();
+    }
+}
+/**
+ * `device.connect()` has no timeout of its own - BlueZ's underlying D-Bus `Connect` call can hang
+ * indefinitely for a device that's out of range or stuck mid-handshake, which would otherwise
+ * block a scan (or `paint()`) on that one device forever. Throws once `timeoutMs` elapses; if the
+ * connect does eventually resolve afterwards, disconnects in the background so a stray successful
+ * connection doesn't itself block the next attempt.
+ */
+async function connectWithTimeout(device, timeoutMs) {
+    const connecting = device.connect();
+    let timedOut = false;
+    await Promise.race([connecting, sleep(timeoutMs).then(() => void (timedOut = true))]);
+    if (timedOut) {
+        connecting.then(() => device.disconnect()).catch(() => { });
+        throw new Error(`connecting to device timed out after ${timeoutMs}ms`);
+    }
+}
+/** Uses an already-known device if BlueZ has one cached, otherwise scans until it appears. */
+async function getOrDiscoverDevice(adapter, address, timeoutMs) {
+    try {
+        return await adapter.getDevice(address);
+    }
+    catch {
+        const wasDiscovering = await adapter.isDiscovering();
+        if (!wasDiscovering) {
+            await adapter.startDiscovery();
+        }
+        try {
+            return await adapter.waitDevice(address, timeoutMs);
+        }
+        finally {
+            if (!wasDiscovering) {
+                await adapter.stopDiscovery();
+            }
+        }
+    }
+}

package/dist/devices/registry.d.ts

@@ -0,0 +1,4 @@
+import { VendorDriver } from './types';
+export declare function registerDriver(driver: VendorDriver): void;
+export declare function getDriver(vendor: string): VendorDriver | undefined;
+export declare function allDrivers(): VendorDriver[];

package/dist/devices/registry.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDriver = registerDriver;
+exports.getDriver = getDriver;
+exports.allDrivers = allDrivers;
+const drivers = new Map();
+function registerDriver(driver) {
+    drivers.set(driver.vendor, driver);
+}
+function getDriver(vendor) {
+    return drivers.get(vendor);
+}
+function allDrivers() {
+    return [...drivers.values()];
+}

package/dist/devices/types.d.ts

@@ -0,0 +1,70 @@
+import { Device } from 'node-ble';
+import { Bitmap } from '../render/types';
+export type Colour = 'black' | 'white' | 'red' | 'yellow';
+/**
+ * Static facts about one device model, keyed by (vendor, pid) by the registry —
+ * PID alone is not assumed unique across vendors.
+ */
+export interface DeviceMetadata {
+    pid: number;
+    /**
+     * Disambiguates physical hardware that shares a PID (some vendors reuse PIDs across
+     * panel sizes) - the exact advertised value to match against; omit for the variant
+     * that should be treated as the default/fallback for that PID.
+     */
+    hwVersion?: string;
+    label: string;
+    width: number;
+    height: number;
+    voffset: number;
+    colours: Colour[];
+}
+export interface DiscoveredDevice {
+    address: string;
+    name?: string;
+    vendor: string;
+    pid?: number;
+    /**
+     * The advertised hardware-version disambiguator, captured independently of whether `metadata`
+     * lookup succeeded - lets `deviceOptions()` (`config.ts`) build a complete, parseable device token
+     * even for a PID a driver doesn't recognise yet, instead of losing it because it was only ever
+     * read off of `metadata.hwVersion`.
+     */
+    hwVersion?: string;
+    metadata?: DeviceMetadata;
+    rssi?: number;
+    /** BLE manufacturer ID (the key of the advertisement's manufacturer data), if advertised. */
+    manufacturerId?: number;
+    /** Battery level in millivolts, if the driver was able to read it during the scan. */
+    batteryMv?: number;
+}
+/** Manual model facts a user can supply for hardware that isn't yet in a driver's PID table. */
+export type DeviceModelOverride = Omit<DeviceMetadata, 'pid'>;
+/** Per-device settings the user supplies when registering a device, beyond what's in DeviceMetadata. */
+export interface VendorDeviceConfig {
+    address: string;
+    /** AES key for vendors that need it, entered by the user. If omitted, vendors that have one may fall back to a stock/manufacturer-default key instead of failing. */
+    aesKey?: string;
+    /** Forces the device model facts instead of looking up the advertised PID - for hardware not yet in the driver's table. */
+    modelOverride?: DeviceModelOverride;
+    /** How long to wait for the BLE connect step before giving up - if omitted, the driver picks its own default. */
+    connectTimeoutMs?: number;
+}
+export interface VendorDriver {
+    vendor: string;
+    /** Does this advertisement look like it came from one of this vendor's devices? */
+    matchesAdvertisement(name: string | undefined, manufacturerId: number | undefined): boolean;
+    /** hwVersion disambiguates PIDs a vendor reuses across panel sizes - see `DeviceMetadata.hwVersion`. */
+    metadataForPid(pid: number, hwVersion?: string): DeviceMetadata | undefined;
+    /** All device models this driver currently has confirmed metadata for. */
+    supportedDevices(): DeviceMetadata[];
+    /**
+     * Identifies one device the shared caller (see `bleDiscovery.ts`'s `forEachAdvertisedDevice`)
+     * has already matched to this vendor via `matchesAdvertisement` - only called for matches, so a
+     * device gets at most one vendor-specific connect/read regardless of how many drivers are
+     * registered, not one attempt per driver.
+     */
+    identifyDevice(device: Device, address: string, name: string | undefined, manufacturerId: number | undefined, manufacturerData: Buffer | undefined): Promise<DiscoveredDevice>;
+    /** Quantise the common bitmap to this device's palette/encoding and send it over BLE. */
+    paint(bitmap: Bitmap, config: VendorDeviceConfig): Promise<void>;
+}

package/dist/devices/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/devices/zhsunyco/encode.d.ts

@@ -0,0 +1,12 @@
+import { Bitmap } from '../../render/types';
+import { DeviceMetadata } from '../types';
+/**
+ * Quantises a common RGBA bitmap and packs it into the Wolink wire format: 2 bits per
+ * pixel, 4 pixels per byte, column-major, with both axes flipped (RAM is x/y-flipped
+ * relative to the displayed image). Mirrors `make_image`/`from_pillow` in the reference
+ * driver (examples/device_driver/zhunyco/wolink_ble.py).
+ *
+ * Rows above `voffset` (present on some panel sizes) are sent as black, matching the
+ * reference driver pasting the source image at a vertical offset onto a blank canvas.
+ */
+export declare function encodeBitmap(bitmap: Bitmap, metadata: DeviceMetadata): Buffer;

package/dist/devices/zhsunyco/encode.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBitmap = encodeBitmap;
+/** Mirrors the reference driver's `from_pillow` nearest-colour decision tree. */
+function nearestColour(r, g, b) {
+    if (r > 150 && g > 150 && b > 150)
+        return 1 /* WolinkColour.White */;
+    if (r > 150 && g > 100 && b < 80)
+        return 2 /* WolinkColour.Yellow */;
+    if (r > 150 && g < 80 && b < 80)
+        return 3 /* WolinkColour.Red */;
+    return 0 /* WolinkColour.Black */;
+}
+/**
+ * Quantises a common RGBA bitmap and packs it into the Wolink wire format: 2 bits per
+ * pixel, 4 pixels per byte, column-major, with both axes flipped (RAM is x/y-flipped
+ * relative to the displayed image). Mirrors `make_image`/`from_pillow` in the reference
+ * driver (examples/device_driver/zhunyco/wolink_ble.py).
+ *
+ * Rows above `voffset` (present on some panel sizes) are sent as black, matching the
+ * reference driver pasting the source image at a vertical offset onto a blank canvas.
+ */
+function encodeBitmap(bitmap, metadata) {
+    const { width, height, voffset } = metadata;
+    const contentHeight = height - voffset;
+    if (bitmap.width !== width || bitmap.height !== contentHeight) {
+        throw new Error(`zhsunyco paint: bitmap is ${bitmap.width}x${bitmap.height}, device "${metadata.label}" expects ${width}x${contentHeight}`);
+    }
+    const bytesPerColumn = height / 4;
+    const data = Buffer.alloc((width * height) / 4);
+    for (let x = 0; x < width; x++) {
+        const physX = width - 1 - x;
+        for (let y = 0; y < height; y++) {
+            const srcY = y - voffset;
+            const colour = srcY >= 0 && srcY < bitmap.height ? samplePixel(bitmap, x, srcY) : 0 /* WolinkColour.Black */;
+            const physY = height - 1 - y;
+            const byteIdx = physX * bytesPerColumn + Math.floor(physY / 4);
+            const bitShift = 6 - (physY % 4) * 2;
+            data[byteIdx] |= colour << bitShift;
+        }
+    }
+    return data;
+}
+function samplePixel(bitmap, x, y) {
+    const offset = (y * bitmap.width + x) * 4;
+    return nearestColour(bitmap.data[offset], bitmap.data[offset + 1], bitmap.data[offset + 2]);
+}

package/dist/devices/zhsunyco/index.d.ts

@@ -0,0 +1,11 @@
+import { Device } from 'node-ble';
+import { Bitmap } from '../../render/types';
+import { DeviceMetadata, DiscoveredDevice, VendorDeviceConfig, VendorDriver } from '../types';
+export declare class ZhsunycoDriver implements VendorDriver {
+    readonly vendor = "zhsunyco";
+    matchesAdvertisement(name: string | undefined, manufacturerId: number | undefined): boolean;
+    metadataForPid(pid: number, hwVersion?: string): DeviceMetadata | undefined;
+    supportedDevices(): DeviceMetadata[];
+    identifyDevice(device: Device, address: string, name: string | undefined, manufacturerId: number | undefined, manufacturerData: Buffer | undefined): Promise<DiscoveredDevice>;
+    paint(bitmap: Bitmap, config: VendorDeviceConfig): Promise<void>;
+}