@synapticon/motion-master-client 2.3.0-beta.0 → 6.0.0-alpha.23

package/dist/generated/http-client.js

@@ -0,0 +1,171 @@
+/* eslint-disable */
+/* tslint:disable */
+// @ts-nocheck
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+export var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["JsonApi"] = "application/vnd.api+json";
+    ContentType["FormData"] = "multipart/form-data";
+    ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+    ContentType["Text"] = "text/plain";
+})(ContentType || (ContentType = {}));
+export class HttpClient {
+    baseUrl = "https://local.motion-master.synapticon.com:61447";
+    securityData = null;
+    securityWorker;
+    abortControllers = new Map();
+    customFetch = (...fetchParams) => fetch(...fetchParams);
+    baseApiParams = {
+        credentials: "same-origin",
+        headers: {},
+        redirect: "follow",
+        referrerPolicy: "no-referrer",
+    };
+    constructor(apiConfig = {}) {
+        Object.assign(this, apiConfig);
+    }
+    setSecurityData = (data) => {
+        this.securityData = data;
+    };
+    encodeQueryParam(key, value) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
+    }
+    addQueryParam(query, key) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+    addArrayQueryParam(query, key) {
+        const value = query[key];
+        return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+    }
+    toQueryString(rawQuery) {
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
+        return keys
+            .map((key) => Array.isArray(query[key])
+            ? this.addArrayQueryParam(query, key)
+            : this.addQueryParam(query, key))
+            .join("&");
+    }
+    addQueryParams(rawQuery) {
+        const queryString = this.toQueryString(rawQuery);
+        return queryString ? `?${queryString}` : "";
+    }
+    contentFormatters = {
+        [ContentType.Json]: (input) => input !== null && (typeof input === "object" || typeof input === "string")
+            ? JSON.stringify(input)
+            : input,
+        [ContentType.JsonApi]: (input) => input !== null && (typeof input === "object" || typeof input === "string")
+            ? JSON.stringify(input)
+            : input,
+        [ContentType.Text]: (input) => input !== null && typeof input !== "string"
+            ? JSON.stringify(input)
+            : input,
+        [ContentType.FormData]: (input) => {
+            if (input instanceof FormData) {
+                return input;
+            }
+            return Object.keys(input || {}).reduce((formData, key) => {
+                const property = input[key];
+                formData.append(key, property instanceof Blob
+                    ? property
+                    : typeof property === "object" && property !== null
+                        ? JSON.stringify(property)
+                        : `${property}`);
+                return formData;
+            }, new FormData());
+        },
+        [ContentType.UrlEncoded]: (input) => this.toQueryString(input),
+    };
+    mergeRequestParams(params1, params2) {
+        return {
+            ...this.baseApiParams,
+            ...params1,
+            ...(params2 || {}),
+            headers: {
+                ...(this.baseApiParams.headers || {}),
+                ...(params1.headers || {}),
+                ...((params2 && params2.headers) || {}),
+            },
+        };
+    }
+    createAbortSignal = (cancelToken) => {
+        if (this.abortControllers.has(cancelToken)) {
+            const abortController = this.abortControllers.get(cancelToken);
+            if (abortController) {
+                return abortController.signal;
+            }
+            return void 0;
+        }
+        const abortController = new AbortController();
+        this.abortControllers.set(cancelToken, abortController);
+        return abortController.signal;
+    };
+    abortRequest = (cancelToken) => {
+        const abortController = this.abortControllers.get(cancelToken);
+        if (abortController) {
+            abortController.abort();
+            this.abortControllers.delete(cancelToken);
+        }
+    };
+    request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+        const secureParams = ((typeof secure === "boolean" ? secure : this.baseApiParams.secure) &&
+            this.securityWorker &&
+            (await this.securityWorker(this.securityData))) ||
+            {};
+        const requestParams = this.mergeRequestParams(params, secureParams);
+        const queryString = query && this.toQueryString(query);
+        const payloadFormatter = this.contentFormatters[type || ContentType.Json];
+        const responseFormat = format || requestParams.format;
+        return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
+            ...requestParams,
+            headers: {
+                ...(requestParams.headers || {}),
+                ...(type && type !== ContentType.FormData
+                    ? { "Content-Type": type }
+                    : {}),
+            },
+            signal: (cancelToken
+                ? this.createAbortSignal(cancelToken)
+                : requestParams.signal) || null,
+            body: typeof body === "undefined" || body === null
+                ? null
+                : payloadFormatter(body),
+        }).then(async (response) => {
+            const r = response;
+            r.data = null;
+            r.error = null;
+            const responseToParse = responseFormat ? response.clone() : response;
+            const data = !responseFormat
+                ? r
+                : await responseToParse[responseFormat]()
+                    .then((data) => {
+                    if (r.ok) {
+                        r.data = data;
+                    }
+                    else {
+                        r.error = data;
+                    }
+                    return r;
+                })
+                    .catch((e) => {
+                    r.error = e;
+                    return r;
+                });
+            if (cancelToken) {
+                this.abortControllers.delete(cancelToken);
+            }
+            if (!response.ok)
+                throw data;
+            return data;
+        });
+    };
+}

package/dist/hex.d.ts

@@ -0,0 +1,2 @@
+export declare function formatHex(value: number, width?: number, prefix?: boolean): string;
+export declare function parseHexBytes(input: string): number[] | null;

package/dist/hex.js

@@ -0,0 +1,20 @@
+// Format a number as an uppercase hex string, zero-padded to `width` digits. With `prefix`
+// (the default) it carries the conventional "0x"; pass false for bare digits — e.g. a subindex
+// rendered after a colon ("0x6040:00"). The display inverse of parseHexBytes.
+export function formatHex(value, width = 4, prefix = true) {
+    return `${prefix ? '0x' : ''}${value.toString(16).toUpperCase().padStart(width, '0')}`;
+}
+// Parse a string of hex bytes ("0A FF", "0x0AFF", "0a,ff") into a byte array.
+// Returns null when the input is empty or not a valid even-length hex string.
+export function parseHexBytes(input) {
+    const cleaned = input.replace(/0x/gi, '').replace(/[\s,]+/g, '');
+    if (cleaned.length === 0 || cleaned.length % 2 !== 0)
+        return null;
+    if (!/^[0-9a-fA-F]+$/.test(cleaned))
+        return null;
+    const bytes = [];
+    for (let i = 0; i < cleaned.length; i += 2) {
+        bytes.push(parseInt(cleaned.slice(i, i + 2), 16));
+    }
+    return bytes;
+}

package/dist/index.d.ts

@@ -1,7 +1,10 @@
-export { MotionMasterClientWebSocketConnection } from './motion-master-client-web-socket-connection';
-export { MotionMasterClient } from './motion-master-client';
-export { IMotionMasterNotificationSubscribeData } from './motion-master-notification-subscribe-data';
-export { MotionMasterNotificationWebSocketConnection } from './motion-master-notification-web-socket-connection';
-export { MotionMasterNotification } from './motion-master-notification';
-export * from './util';
-//# sourceMappingURL=index.d.ts.map
+export * from './generated/http-client.js';
+export * from './generated/data-contracts.js';
+export * from './generated/Api.js';
+export * from './constants.js';
+export * from './web-socket-connection.js';
+export * from './client.js';
+export * from './hex.js';
+export * from './sdo.js';
+export * from './somanet.js';
+export * from './mmpd.js';

package/dist/index.js

@@ -1,22 +1,16 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var motion_master_client_web_socket_connection_1 = require("./motion-master-client-web-socket-connection");
-Object.defineProperty(exports, "MotionMasterClientWebSocketConnection", { enumerable: true, get: function () { return motion_master_client_web_socket_connection_1.MotionMasterClientWebSocketConnection; } });
-var motion_master_client_1 = require("./motion-master-client");
-Object.defineProperty(exports, "MotionMasterClient", { enumerable: true, get: function () { return motion_master_client_1.MotionMasterClient; } });
-var motion_master_notification_web_socket_connection_1 = require("./motion-master-notification-web-socket-connection");
-Object.defineProperty(exports, "MotionMasterNotificationWebSocketConnection", { enumerable: true, get: function () { return motion_master_notification_web_socket_connection_1.MotionMasterNotificationWebSocketConnection; } });
-var motion_master_notification_1 = require("./motion-master-notification");
-Object.defineProperty(exports, "MotionMasterNotification", { enumerable: true, get: function () { return motion_master_notification_1.MotionMasterNotification; } });
-__exportStar(require("./util"), exports);
-//# sourceMappingURL=index.js.map
+// Public entry point for @synapticon/motion-master-client.
+//
+// `src/generated/` is the swagger-typescript-api output — regenerate with `pnpm generate`, never
+// hand-edit. Everything else here is the hand-written SDK layer (facade + WebSocket connection).
+export * from './generated/http-client.js';
+export * from './generated/data-contracts.js';
+export * from './generated/Api.js';
+export * from './constants.js';
+export * from './web-socket-connection.js';
+export * from './client.js';
+// Pure, framework-agnostic helpers (no DOM/React): hex formatting, CoE SDO value
+// encode/decode, and SOMANET file-list parsing.
+export * from './hex.js';
+export * from './sdo.js';
+export * from './somanet.js';
+export * from './mmpd.js';

package/dist/mmpd.d.ts

@@ -0,0 +1,54 @@
+export interface MmpdPdoEntry {
+    index: number;
+    subindex: number;
+    isOutput: boolean;
+    dataType: number;
+    bitLength: number;
+    bitOffset: number;
+    name: string;
+}
+export interface MmpdDevice {
+    slavePosition: number;
+    vendorId: number;
+    productCode: number;
+    revisionNumber: number;
+    serialNumber: number;
+    name: string;
+    entries: MmpdPdoEntry[];
+}
+export interface MmpdHeader {
+    formatVersion: number;
+    flags: number;
+    cyclePeriodUs: number;
+    startSequence: bigint;
+    rowCount: number;
+    inputBytes: number;
+    outputBytes: number;
+    devices: MmpdDevice[];
+}
+export interface MmpdRow {
+    sequence: bigint;
+    timestampNs: bigint;
+    inputs: Uint8Array;
+    outputs: Uint8Array;
+}
+export declare class MmpdFile {
+    readonly header: MmpdHeader;
+    private readonly u8;
+    private readonly dv;
+    private readonly rowsStart;
+    constructor(header: MmpdHeader, u8: Uint8Array, dv: DataView, rowsStart: number);
+    get rowCount(): number;
+    get rowStride(): number;
+    rowAt(i: number): MmpdRow;
+    timestampsUs(): Float64Array;
+    decodeSeries(entry: MmpdPdoEntry): (number | null)[];
+}
+export declare function parseMmpd(data: ArrayBuffer | Uint8Array): MmpdFile;
+export declare function fetchProcessDataDump(baseUrl: string, options?: {
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<MmpdFile>;
+export declare function extractBits(src: Uint8Array, bitOffset: number, bitLength: number): Uint8Array;
+export declare function decodeMmpdValue(dataType: number, bytes: Uint8Array): number | bigint | string | null;
+export declare function isPlottableDataType(dataType: number): boolean;

package/dist/mmpd.js

@@ -0,0 +1,323 @@
+// Parser for the `.mmpd` process-data recorder dump (see libs/node/process_data_dump.{h,cc}). The
+// format embeds the process image as a header so a run decodes fully offline — no running Motion
+// Master and no live bus. All multi-byte integers are little-endian.
+//
+// Layout:
+//   Prefix (40 bytes): magic 'MMPD', u16 formatVersion, u16 flags, u32 cyclePeriodUs,
+//     u64 startSequence, u64 rowCount, u32 inputBytes, u32 outputBytes, u32 deviceCount.
+//   Device table (deviceCount): u16 slavePosition, u32 vendorId/productCode/revisionNumber/
+//     serialNumber, str name, u32 entryCount, then per entry: u16 index, u8 subindex,
+//     u8 direction (1=output/RxPDO, 0=input/TxPDO), u16 dataType, u16 bitLength, u32 bitOffset,
+//     str name. (str = u16 byte length + UTF-8 bytes.)
+//   Rows (rowCount, fixed stride 16 + inputBytes + outputBytes): u64 sequence, u64 timestampNs,
+//     inputs[inputBytes], outputs[outputBytes].
+const MAGIC = 0x4450_4d4d; // 'MMPD' as a little-endian u32 ('M','M','P','D')
+const SUPPORTED_FORMAT_VERSION = 1;
+const utf8 = new TextDecoder();
+// Cursor over a DataView for sequential little-endian reads while parsing the header.
+class Cursor {
+    dv;
+    u8;
+    offset;
+    constructor(dv, u8, offset = 0) {
+        this.dv = dv;
+        this.u8 = u8;
+        this.offset = offset;
+    }
+    u8val() {
+        return this.dv.getUint8(this.offset++);
+    }
+    u16() {
+        const v = this.dv.getUint16(this.offset, true);
+        this.offset += 2;
+        return v;
+    }
+    u32() {
+        const v = this.dv.getUint32(this.offset, true);
+        this.offset += 4;
+        return v;
+    }
+    u64() {
+        const v = this.dv.getBigUint64(this.offset, true);
+        this.offset += 8;
+        return v;
+    }
+    str() {
+        const len = this.u16();
+        const s = utf8.decode(this.u8.subarray(this.offset, this.offset + len));
+        this.offset += len;
+        return s;
+    }
+}
+/// A parsed `.mmpd` dump. The header is read eagerly; row values are decoded on demand so a
+/// large file (a deep recorder ring) is not fully materialised up front.
+export class MmpdFile {
+    header;
+    u8;
+    dv;
+    rowsStart;
+    constructor(header, u8, dv, 
+    /// Byte offset of the first row within the buffer.
+    rowsStart) {
+        this.header = header;
+        this.u8 = u8;
+        this.dv = dv;
+        this.rowsStart = rowsStart;
+    }
+    get rowCount() {
+        return this.header.rowCount;
+    }
+    /// Per-row byte stride: u64 sequence + u64 timestampNs + inputs + outputs.
+    get rowStride() {
+        return 16 + this.header.inputBytes + this.header.outputBytes;
+    }
+    /// The raw record at row `i` (views into the source buffer; do not retain past the buffer's life).
+    rowAt(i) {
+        const base = this.rowsStart + i * this.rowStride;
+        const inputsAt = base + 16;
+        const outputsAt = inputsAt + this.header.inputBytes;
+        return {
+            sequence: this.dv.getBigUint64(base, true),
+            timestampNs: this.dv.getBigUint64(base + 8, true),
+            inputs: this.u8.subarray(inputsAt, outputsAt),
+            outputs: this.u8.subarray(outputsAt, outputsAt + this.header.outputBytes),
+        };
+    }
+    /// Epoch microseconds for every row (JS-exact in a Number until ~year 2255, matching the live
+    /// monitoring protocol). Sub-microsecond nanoseconds are dropped.
+    timestampsUs() {
+        const out = new Float64Array(this.header.rowCount);
+        for (let i = 0; i < out.length; i++) {
+            out[i] = Number(this.dv.getBigUint64(this.rowsStart + i * this.rowStride + 8, true) / 1000n);
+        }
+        return out;
+    }
+    /// Decodes one entry's value for every row. Numeric types yield numbers (64-bit ints are coerced
+    /// to Number, lossy beyond 2^53); strings, undecodable (dataType 0), and unsupported types yield
+    /// null — so the result is always plottable.
+    decodeSeries(entry) {
+        const out = new Array(this.header.rowCount);
+        const reader = numericReader(entry.dataType);
+        const byteAligned = entry.bitOffset % 8 === 0 && entry.bitLength % 8 === 0;
+        const regionStart = entry.isOutput ? 16 + this.header.inputBytes : 16;
+        if (reader && byteAligned) {
+            // Fast path: read straight from the buffer with no per-row allocation.
+            const valueOffset = regionStart + (entry.bitOffset >> 3);
+            for (let i = 0; i < out.length; i++) {
+                const v = reader(this.dv, this.rowsStart + i * this.rowStride + valueOffset);
+                out[i] = typeof v === 'bigint' ? Number(v) : v;
+            }
+            return out;
+        }
+        // Slow path: sub-byte fields and strings — extract the bits, then decode.
+        for (let i = 0; i < out.length; i++) {
+            const row = this.rowAt(i);
+            const bytes = extractBits(entry.isOutput ? row.outputs : row.inputs, entry.bitOffset, entry.bitLength);
+            const v = decodeMmpdValue(entry.dataType, bytes);
+            out[i] = typeof v === 'number' ? v : typeof v === 'bigint' ? Number(v) : null;
+        }
+        return out;
+    }
+}
+/// Parses a `.mmpd` dump. Throws on a bad magic or an unsupported format version. A file whose row
+/// region is shorter than `rowCount` implies (truncated transfer) is clamped to the rows present.
+export function parseMmpd(data) {
+    const u8 = data instanceof Uint8Array ? data : new Uint8Array(data);
+    const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+    if (u8.byteLength < 40 || dv.getUint32(0, true) !== MAGIC) {
+        throw new Error('Not a .mmpd file (bad magic)');
+    }
+    const formatVersion = dv.getUint16(4, true);
+    if (formatVersion !== SUPPORTED_FORMAT_VERSION) {
+        throw new Error(`Unsupported .mmpd format version ${formatVersion} (expected ${SUPPORTED_FORMAT_VERSION})`);
+    }
+    const header = {
+        formatVersion,
+        flags: dv.getUint16(6, true),
+        cyclePeriodUs: dv.getUint32(8, true),
+        startSequence: dv.getBigUint64(12, true),
+        rowCount: Number(dv.getBigUint64(20, true)),
+        inputBytes: dv.getUint32(28, true),
+        outputBytes: dv.getUint32(32, true),
+        devices: [],
+    };
+    const deviceCount = dv.getUint32(36, true);
+    const cursor = new Cursor(dv, u8, 40);
+    for (let d = 0; d < deviceCount; d++) {
+        const device = {
+            slavePosition: cursor.u16(),
+            vendorId: cursor.u32(),
+            productCode: cursor.u32(),
+            revisionNumber: cursor.u32(),
+            serialNumber: cursor.u32(),
+            name: cursor.str(),
+            entries: [],
+        };
+        const entryCount = cursor.u32();
+        for (let e = 0; e < entryCount; e++) {
+            device.entries.push({
+                index: cursor.u16(),
+                subindex: cursor.u8val(),
+                isOutput: cursor.u8val() === 1,
+                dataType: cursor.u16(),
+                bitLength: cursor.u16(),
+                bitOffset: cursor.u32(),
+                name: cursor.str(),
+            });
+        }
+        header.devices.push(device);
+    }
+    const rowsStart = cursor.offset;
+    const rowStride = 16 + header.inputBytes + header.outputBytes;
+    const available = Math.floor((u8.byteLength - rowsStart) / rowStride);
+    if (available < header.rowCount) {
+        header.rowCount = Math.max(0, available);
+    }
+    return new MmpdFile(header, u8, dv, rowsStart);
+}
+// A byte-aligned reader for the fixed-width numeric types, or null for variable/sub-byte/string
+// types that need the bit-extraction path.
+function numericReader(dataType) {
+    switch (dataType) {
+        case 1 /* DataType.BOOLEAN */:
+        case 5 /* DataType.UNSIGNED8 */:
+        case 30 /* DataType.BYTE */:
+        case 45 /* DataType.BITARR8 */:
+            return (dv, o) => dv.getUint8(o);
+        case 2 /* DataType.INTEGER8 */:
+            return (dv, o) => dv.getInt8(o);
+        case 3 /* DataType.INTEGER16 */:
+            return (dv, o) => dv.getInt16(o, true);
+        case 6 /* DataType.UNSIGNED16 */:
+        case 31 /* DataType.WORD */:
+        case 46 /* DataType.BITARR16 */:
+            return (dv, o) => dv.getUint16(o, true);
+        case 4 /* DataType.INTEGER32 */:
+            return (dv, o) => dv.getInt32(o, true);
+        case 7 /* DataType.UNSIGNED32 */:
+        case 32 /* DataType.DWORD */:
+        case 47 /* DataType.BITARR32 */:
+            return (dv, o) => dv.getUint32(o, true);
+        case 8 /* DataType.REAL32 */:
+            return (dv, o) => dv.getFloat32(o, true);
+        case 17 /* DataType.REAL64 */:
+            return (dv, o) => dv.getFloat64(o, true);
+        case 21 /* DataType.INTEGER64 */:
+            return (dv, o) => dv.getBigInt64(o, true);
+        case 27 /* DataType.UNSIGNED64 */:
+            return (dv, o) => dv.getBigUint64(o, true);
+        default:
+            return null;
+    }
+}
+/// Fetches the live recorder dump (`GET /api/process-data/dump`) and parses it. `baseUrl` is the
+/// HTTP API origin (e.g. `https://host:61447`). Throws on a non-OK response (the response body's
+/// `error` message when present). Pass `fetch` to inject an implementation (Node, request logging).
+export async function fetchProcessDataDump(baseUrl, options = {}) {
+    const doFetch = options.fetch ?? fetch;
+    const res = await doFetch(`${baseUrl.replace(/\/+$/, '')}/api/process-data/dump`, {
+        headers: { Accept: 'application/octet-stream' },
+        signal: options.signal,
+    });
+    if (!res.ok) {
+        let message = `HTTP ${res.status}`;
+        try {
+            const body = (await res.json());
+            if (body?.error) {
+                message = body.error;
+            }
+        }
+        catch {
+            // Non-JSON error body — keep the status message.
+        }
+        throw new Error(message);
+    }
+    return parseMmpd(await res.arrayBuffer());
+}
+/// Extracts `bitLength` bits starting at `bitOffset` from `src`, returning them LSB-aligned and
+/// little-endian (padded to a byte boundary). Mirrors `extractBits` in libs/node/process_image.cc.
+export function extractBits(src, bitOffset, bitLength) {
+    const out = new Uint8Array((bitLength + 7) >> 3);
+    if (bitOffset % 8 === 0 && bitLength % 8 === 0) {
+        const byteOffset = bitOffset >> 3;
+        for (let i = 0; i < out.length && byteOffset + i < src.length; i++) {
+            out[i] = src[byteOffset + i];
+        }
+        return out;
+    }
+    for (let i = 0; i < bitLength; i++) {
+        const srcBit = bitOffset + i;
+        const srcByte = srcBit >> 3;
+        if (srcByte >= src.length) {
+            break;
+        }
+        const bit = (src[srcByte] >> (srcBit & 7)) & 1;
+        out[i >> 3] |= bit << (i & 7);
+    }
+    return out;
+}
+/// Decodes LSB-aligned little-endian `bytes` (as produced by `extractBits`) for the given ETG.1020
+/// `dataType`. Returns a number for fixed-width numerics, a bigint for 64-bit integers, a string
+/// for VISIBLE/UNICODE strings (trailing NULs/spaces stripped), or null when the type is unknown
+/// (dataType 0) or there are too few bytes. Unmapped codes fall back to an unsigned read of the
+/// available bytes (covers BITn fields).
+export function decodeMmpdValue(dataType, bytes) {
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const n = bytes.byteLength;
+    switch (dataType) {
+        case 1 /* DataType.BOOLEAN */:
+        case 5 /* DataType.UNSIGNED8 */:
+        case 30 /* DataType.BYTE */:
+        case 45 /* DataType.BITARR8 */:
+            return n >= 1 ? dv.getUint8(0) : null;
+        case 2 /* DataType.INTEGER8 */:
+            return n >= 1 ? dv.getInt8(0) : null;
+        case 3 /* DataType.INTEGER16 */:
+            return n >= 2 ? dv.getInt16(0, true) : null;
+        case 6 /* DataType.UNSIGNED16 */:
+        case 31 /* DataType.WORD */:
+        case 46 /* DataType.BITARR16 */:
+            return n >= 2 ? dv.getUint16(0, true) : null;
+        case 4 /* DataType.INTEGER32 */:
+            return n >= 4 ? dv.getInt32(0, true) : null;
+        case 7 /* DataType.UNSIGNED32 */:
+        case 32 /* DataType.DWORD */:
+        case 47 /* DataType.BITARR32 */:
+            return n >= 4 ? dv.getUint32(0, true) : null;
+        case 8 /* DataType.REAL32 */:
+            return n >= 4 ? dv.getFloat32(0, true) : null;
+        case 17 /* DataType.REAL64 */:
+            return n >= 8 ? dv.getFloat64(0, true) : null;
+        case 21 /* DataType.INTEGER64 */:
+            return n >= 8 ? dv.getBigInt64(0, true) : null;
+        case 27 /* DataType.UNSIGNED64 */:
+            return n >= 8 ? dv.getBigUint64(0, true) : null;
+        case 9 /* DataType.VISIBLE_STRING */:
+        case 11 /* DataType.UNICODE_STRING */: {
+            let end = n;
+            while (end > 0 && (bytes[end - 1] === 0x00 || bytes[end - 1] === 0x20)) {
+                end--;
+            }
+            return utf8.decode(bytes.subarray(0, end));
+        }
+        case 0x0000:
+            return null; // OD not enumerated — undecodable
+        default: {
+            // Unknown/sub-byte (e.g. BIT1..BIT16): read the available bytes as a little-endian unsigned.
+            if (n === 0 || n > 4) {
+                return null;
+            }
+            let v = 0;
+            for (let i = 0; i < n; i++) {
+                v |= bytes[i] << (8 * i);
+            }
+            return v >>> 0;
+        }
+    }
+}
+/// Whether `decodeSeries` yields plottable numbers for this ETG.1020 data-type code — a
+/// fixed-width integer/real or a bit field, but not a string, struct, or unenumerated type
+/// (dataType 0). Useful for offering only chartable objects in a UI.
+export function isPlottableDataType(dataType) {
+    return numericReader(dataType) !== null || (dataType >= 0x0030 && dataType <= 0x003f);
+}

package/dist/sdo.d.ts

@@ -0,0 +1,15 @@
+export declare const SDO_TYPES: readonly ["uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "float32", "float64", "string", "raw"];
+export type SdoType = (typeof SDO_TYPES)[number];
+export declare const SDO_TYPE_HINT: Record<SdoType, string>;
+export declare function encodeSdoValue(type: SdoType, raw: string): {
+    bytes: number[];
+} | {
+    error: string;
+};
+export declare function sdoTypeForDataTypeName(dataTypeName: string): SdoType;
+export interface SdoInterpretation {
+    label: string;
+    value: string;
+}
+export declare function interpretSdoBytes(bytes: number[]): SdoInterpretation[];
+export declare function decodeSdoBytes(dataTypeName: string, bytes: number[]): number | string | number[];