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

package/dist/sdo.js

@@ -0,0 +1,212 @@
+// Encoding and decoding helpers for CoE SDO values: turning the raw little-endian
+// byte arrays exchanged over the wire into human-readable values and back.
+import { parseHexBytes } from './hex.js';
+// CoE data types the SDO download card can encode a value into. `raw` is an
+// escape hatch for entering bytes directly.
+export const SDO_TYPES = [
+    'uint8', 'int8', 'uint16', 'int16', 'uint32', 'int32',
+    'uint64', 'int64', 'float32', 'float64', 'string', 'raw',
+];
+// Placeholder text shown in the value input for each type.
+export const SDO_TYPE_HINT = {
+    uint8: 'e.g. 200 or 0xC8',
+    int8: 'e.g. -42',
+    uint16: 'e.g. 1000 or 0x03E8',
+    int16: 'e.g. -1000',
+    uint32: 'e.g. 100000',
+    int32: 'e.g. -100000',
+    uint64: 'e.g. 4294967296',
+    int64: 'e.g. -4294967296',
+    float32: 'e.g. 3.14',
+    float64: 'e.g. 3.141592653589793',
+    string: 'e.g. SOMANET',
+    raw: 'hex bytes, e.g. 01 02 0A FF',
+};
+const INT_ENC = {
+    uint8: { size: 1, signed: false }, int8: { size: 1, signed: true },
+    uint16: { size: 2, signed: false }, int16: { size: 2, signed: true },
+    uint32: { size: 4, signed: false }, int32: { size: 4, signed: true },
+    uint64: { size: 8, signed: false }, int64: { size: 8, signed: true },
+};
+// Accepts decimal (with optional leading '-') or 0x-prefixed hex; returns null on anything else.
+function parseBigIntFlexible(s) {
+    if (/^-?[0-9]+$/.test(s))
+        return BigInt(s);
+    if (/^0[xX][0-9a-fA-F]+$/.test(s))
+        return BigInt(s);
+    if (/^-0[xX][0-9a-fA-F]+$/.test(s))
+        return -BigInt(s.slice(1));
+    return null;
+}
+// Encodes a human-entered value into the little-endian byte sequence for an SDO download.
+export function encodeSdoValue(type, raw) {
+    const s = raw.trim();
+    const meta = INT_ENC[type];
+    if (meta) {
+        const n = parseBigIntFlexible(s);
+        if (n === null)
+            return { error: 'Not a valid integer' };
+        const bits = BigInt(meta.size * 8);
+        const min = meta.signed ? -(1n << (bits - 1n)) : 0n;
+        const max = meta.signed ? (1n << (bits - 1n)) - 1n : (1n << bits) - 1n;
+        if (n < min || n > max)
+            return { error: `Out of range for ${type} [${min}, ${max}]` };
+        const view = new DataView(new ArrayBuffer(meta.size));
+        if (meta.size === 1)
+            meta.signed ? view.setInt8(0, Number(n)) : view.setUint8(0, Number(n));
+        else if (meta.size === 2)
+            meta.signed ? view.setInt16(0, Number(n), true) : view.setUint16(0, Number(n), true);
+        else if (meta.size === 4)
+            meta.signed ? view.setInt32(0, Number(n), true) : view.setUint32(0, Number(n), true);
+        else
+            meta.signed ? view.setBigInt64(0, n, true) : view.setBigUint64(0, n, true);
+        return { bytes: [...new Uint8Array(view.buffer)] };
+    }
+    if (type === 'float32' || type === 'float64') {
+        if (s === '')
+            return { error: 'Value is empty' };
+        const f = Number(s);
+        if (Number.isNaN(f))
+            return { error: 'Not a valid number' };
+        const size = type === 'float32' ? 4 : 8;
+        const view = new DataView(new ArrayBuffer(size));
+        if (type === 'float32')
+            view.setFloat32(0, f, true);
+        else
+            view.setFloat64(0, f, true);
+        return { bytes: [...new Uint8Array(view.buffer)] };
+    }
+    if (type === 'string') {
+        return { bytes: [...new TextEncoder().encode(raw)] };
+    }
+    // raw: whitespace- or comma-separated hex bytes
+    const bytes = parseHexBytes(s);
+    if (bytes === null)
+        return { error: 'Not a valid even-length hex byte string' };
+    return { bytes };
+}
+// Maps a CoE object's data-type name (as reported by SDO Info) to the SdoType the
+// encoder understands, so a value typed inline against an object can be encoded
+// without the user picking a type. Falls back to `raw` for unknown/complex types.
+export function sdoTypeForDataTypeName(dataTypeName) {
+    switch (dataTypeName) {
+        case 'BOOLEAN':
+        case 'UNSIGNED8':
+        case 'BYTE':
+            return 'uint8';
+        case 'INTEGER8':
+            return 'int8';
+        case 'UNSIGNED16':
+        case 'WORD':
+            return 'uint16';
+        case 'INTEGER16':
+            return 'int16';
+        case 'UNSIGNED32':
+        case 'DWORD':
+            return 'uint32';
+        case 'INTEGER32':
+            return 'int32';
+        case 'UNSIGNED64':
+            return 'uint64';
+        case 'INTEGER64':
+            return 'int64';
+        case 'REAL32':
+            return 'float32';
+        case 'REAL64':
+            return 'float64';
+        case 'VISIBLE_STRING':
+        case 'UNICODE_STRING':
+            return 'string';
+        default:
+            return 'raw';
+    }
+}
+// Best-effort interpretation of raw SDO bytes as every fixed-width type that fits,
+// plus a printable-string reading. Used to show what an uploaded value could mean.
+export function interpretSdoBytes(bytes) {
+    const view = new DataView(new Uint8Array(bytes).buffer);
+    const out = [];
+    if (bytes.length === 1) {
+        out.push({ label: 'int8', value: String(view.getInt8(0)) });
+        out.push({ label: 'uint8', value: String(view.getUint8(0)) });
+    }
+    else if (bytes.length === 2) {
+        out.push({ label: 'int16 LE', value: String(view.getInt16(0, true)) });
+        out.push({ label: 'uint16 LE', value: String(view.getUint16(0, true)) });
+    }
+    else if (bytes.length === 4) {
+        out.push({ label: 'int32 LE', value: String(view.getInt32(0, true)) });
+        out.push({ label: 'uint32 LE', value: String(view.getUint32(0, true)) });
+        out.push({ label: 'float32 LE', value: String(view.getFloat32(0, true)) });
+    }
+    else if (bytes.length === 8) {
+        out.push({ label: 'int64 LE', value: view.getBigInt64(0, true).toString() });
+        out.push({ label: 'uint64 LE', value: view.getBigUint64(0, true).toString() });
+        out.push({ label: 'float64 LE', value: String(view.getFloat64(0, true)) });
+    }
+    if (bytes.length > 0 && bytes.every(b => (b >= 0x20 && b <= 0x7e) || b === 0)) {
+        // VISIBLE_STRING is space-padded to a fixed width and may carry a terminating
+        // NUL — neither is significant, so strip trailing 0x20/0x00 before display.
+        let len = bytes.length;
+        while (len > 0 && (bytes[len - 1] === 0x00 || bytes[len - 1] === 0x20))
+            len--;
+        const str = new TextDecoder().decode(new Uint8Array(bytes.slice(0, len).filter(b => b !== 0)));
+        out.push({ label: 'string', value: `"${str}"` });
+    }
+    return out;
+}
+// Decodes raw SDO bytes into a typed value, given the object's CoE data-type name.
+// Falls back to the raw byte array for unknown types or short reads.
+export function decodeSdoBytes(dataTypeName, bytes) {
+    const view = new DataView(new Uint8Array(bytes).buffer);
+    switch (dataTypeName) {
+        case 'BOOLEAN':
+        case 'UNSIGNED8':
+        case 'BYTE':
+            if (bytes.length >= 1)
+                return view.getUint8(0);
+            break;
+        case 'INTEGER8':
+            if (bytes.length >= 1)
+                return view.getInt8(0);
+            break;
+        case 'INTEGER16':
+            if (bytes.length >= 2)
+                return view.getInt16(0, true);
+            break;
+        case 'INTEGER32':
+            if (bytes.length >= 4)
+                return view.getInt32(0, true);
+            break;
+        case 'UNSIGNED16':
+        case 'WORD':
+            if (bytes.length >= 2)
+                return view.getUint16(0, true);
+            break;
+        case 'UNSIGNED32':
+        case 'DWORD':
+            if (bytes.length >= 4)
+                return view.getUint32(0, true);
+            break;
+        case 'REAL32':
+            if (bytes.length >= 4)
+                return view.getFloat32(0, true);
+            break;
+        case 'REAL64':
+            if (bytes.length >= 8)
+                return view.getFloat64(0, true);
+            break;
+        case 'INTEGER64':
+            if (bytes.length >= 8)
+                return Number(view.getBigInt64(0, true));
+            break;
+        case 'UNSIGNED64':
+            if (bytes.length >= 8)
+                return Number(view.getBigUint64(0, true));
+            break;
+        case 'VISIBLE_STRING':
+        case 'UNICODE_STRING':
+            return new TextDecoder().decode(new Uint8Array(bytes.filter(b => b !== 0)));
+    }
+    return bytes;
+}

package/dist/somanet.d.ts

@@ -0,0 +1,5 @@
+export interface SomanetFile {
+    name: string;
+    size: number | null;
+}
+export declare function parseSomanetFileList(text: string): SomanetFile[];

package/dist/somanet.js

@@ -0,0 +1,15 @@
+// Helpers for SOMANET (Synapticon) drive specifics.
+// Parse the body of a SOMANET `fs-getlist` FoE read. Each entry is one line in
+// the form `<filename>, size: <bytes>`; size is null when a line doesn't match.
+export function parseSomanetFileList(text) {
+    return text
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map(line => {
+        const match = line.match(/^(.*?),\s*size:\s*(\d+)\s*$/);
+        if (match)
+            return { name: match[1].trim(), size: Number(match[2]) };
+        return { name: line, size: null };
+    });
+}

package/dist/web-socket-connection.d.ts

@@ -0,0 +1,69 @@
+export type ReadyState = 'connecting' | 'open' | 'closed';
+export type MonitoringRow = (number | null)[];
+export type MonitoringBatch = MonitoringRow[];
+export interface MonitoringMessage {
+    type: 'monitoring';
+    topic: string;
+    data: MonitoringBatch;
+}
+export interface NotificationMessage {
+    type: 'notification';
+    data: unknown;
+}
+export interface ProgressMessage {
+    type: 'progress';
+    data: unknown;
+}
+export type ServerMessage = MonitoringMessage | NotificationMessage | ProgressMessage;
+type MonitoringListener = (rows: MonitoringBatch) => void;
+type NotificationListener = (data: unknown) => void;
+type ProgressListener = (data: unknown) => void;
+type StateListener = (state: ReadyState) => void;
+export interface WebSocketLike {
+    readyState: number;
+    send(data: string): void;
+    close(): void;
+    onopen: ((event: unknown) => void) | null;
+    onclose: ((event: unknown) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+}
+export type WebSocketConstructor = new (url: string, protocolsOrOptions?: unknown) => WebSocketLike;
+export interface WebSocketConnectionOptions {
+    url: string;
+    WebSocket?: WebSocketConstructor;
+    protocolsOrOptions?: unknown;
+    reconnectDelayMs?: number;
+    maxReconnectDelayMs?: number;
+}
+export declare class WebSocketConnection {
+    private readonly url;
+    private readonly WebSocketImpl?;
+    private readonly protocolsOrOptions?;
+    private readonly reconnectDelayMs;
+    private readonly maxReconnectDelayMs;
+    private socket;
+    private state;
+    private closedByUser;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private readonly topicListeners;
+    private readonly notificationListeners;
+    private readonly progressListeners;
+    private readonly stateListeners;
+    constructor(options: WebSocketConnectionOptions);
+    get readyState(): ReadyState;
+    connect(): void;
+    close(): void;
+    subscribe(topic: string, listener: MonitoringListener): () => void;
+    onNotification(listener: NotificationListener): () => void;
+    onProgress(listener: ProgressListener): () => void;
+    onStateChange(listener: StateListener): () => void;
+    private setState;
+    private send;
+    private handleDisconnect;
+    private route;
+}
+export {};

package/dist/web-socket-connection.js

@@ -0,0 +1,206 @@
+// Framework-agnostic connection to Motion Master's single WebSocket — the one bidirectional
+// socket that carries server->client monitoring batches, notifications, and (planned) procedure
+// progress, and client->server topic subscribe/unsubscribe. It owns reconnection, multiplexes
+// per-topic subscriptions over the one socket (ref-counted: subscribe on the first listener,
+// unsubscribe on the last, re-subscribe everything on reconnect), and routes inbound frames by
+// type. It is isomorphic: the browser global `WebSocket` is used by default, and any compatible
+// implementation (e.g. the Node `ws` package) can be injected — there is no hard dependency on
+// either, so the package stays usable in both environments.
+/// The numeric `readyState` value a WebSocket reports when it is open. Hard-coded (rather than read
+/// off a global) so the client never depends on a particular `WebSocket` implementation's statics.
+const WS_OPEN = 1;
+export class WebSocketConnection {
+    url;
+    WebSocketImpl;
+    protocolsOrOptions;
+    reconnectDelayMs;
+    maxReconnectDelayMs;
+    socket = null;
+    state = 'closed';
+    closedByUser = false;
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    topicListeners = new Map();
+    notificationListeners = new Set();
+    progressListeners = new Set();
+    stateListeners = new Set();
+    constructor(options) {
+        this.url = options.url;
+        this.WebSocketImpl = options.WebSocket;
+        this.protocolsOrOptions = options.protocolsOrOptions;
+        this.reconnectDelayMs = options.reconnectDelayMs ?? 1000;
+        this.maxReconnectDelayMs = options.maxReconnectDelayMs ?? 15000;
+    }
+    get readyState() {
+        return this.state;
+    }
+    /// Opens the socket if it is not already open or connecting. Idempotent — safe to call from every
+    /// subscribe path. Connection is lazy: an HTTP-only consumer that never subscribes never opens a
+    /// socket.
+    connect() {
+        if (this.socket || this.state === 'connecting') {
+            return;
+        }
+        const Impl = this.WebSocketImpl ?? globalThis.WebSocket;
+        if (!Impl) {
+            throw new Error('No WebSocket implementation available. Inject one via the `WebSocket` option (e.g. the ' +
+                '`ws` package on Node < 22).');
+        }
+        this.closedByUser = false;
+        this.setState('connecting');
+        const socket = new Impl(this.url, this.protocolsOrOptions);
+        this.socket = socket;
+        socket.onopen = () => {
+            this.reconnectAttempts = 0;
+            this.setState('open');
+            // (Re)subscribe to every topic that currently has listeners — also covers reconnects.
+            for (const topic of this.topicListeners.keys()) {
+                this.send({ subscribe: topic });
+            }
+        };
+        socket.onmessage = (event) => this.route(event.data);
+        socket.onclose = () => this.handleDisconnect();
+        socket.onerror = () => this.handleDisconnect();
+    }
+    /// Permanently closes the socket and cancels any pending reconnect. Registered listeners are
+    /// kept, so a later `connect()` resumes them.
+    close() {
+        this.closedByUser = true;
+        if (this.reconnectTimer !== null) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        const socket = this.socket;
+        this.socket = null;
+        if (socket) {
+            socket.onopen = null;
+            socket.onmessage = null;
+            socket.onclose = null;
+            socket.onerror = null;
+            socket.close();
+        }
+        this.setState('closed');
+    }
+    /// Subscribes `listener` to a topic's monitoring batches. The first subscriber to a topic sends a
+    /// `subscribe` frame; the last to leave sends `unsubscribe`. Connects lazily. Returns an
+    /// unsubscribe function.
+    subscribe(topic, listener) {
+        let listeners = this.topicListeners.get(topic);
+        if (!listeners) {
+            listeners = new Set();
+            this.topicListeners.set(topic, listeners);
+            this.send({ subscribe: topic });
+        }
+        listeners.add(listener);
+        this.connect();
+        return () => {
+            const current = this.topicListeners.get(topic);
+            if (!current) {
+                return;
+            }
+            current.delete(listener);
+            if (current.size === 0) {
+                this.topicListeners.delete(topic);
+                this.send({ unsubscribe: topic });
+            }
+        };
+    }
+    /// Registers a listener for server notifications (e.g. `{ event: 'slaves_changed' }`). Connects
+    /// lazily. Returns a removal function.
+    onNotification(listener) {
+        this.notificationListeners.add(listener);
+        this.connect();
+        return () => {
+            this.notificationListeners.delete(listener);
+        };
+    }
+    /// Registers a listener for procedure progress messages (reserved; fires once the backend ships
+    /// them). Connects lazily. Returns a removal function.
+    onProgress(listener) {
+        this.progressListeners.add(listener);
+        this.connect();
+        return () => {
+            this.progressListeners.delete(listener);
+        };
+    }
+    /// Observes connection-state changes. Returns a removal function.
+    onStateChange(listener) {
+        this.stateListeners.add(listener);
+        return () => {
+            this.stateListeners.delete(listener);
+        };
+    }
+    setState(state) {
+        if (this.state === state) {
+            return;
+        }
+        this.state = state;
+        for (const listener of this.stateListeners) {
+            listener(state);
+        }
+    }
+    send(payload) {
+        const socket = this.socket;
+        if (socket && socket.readyState === WS_OPEN) {
+            socket.send(JSON.stringify(payload));
+        }
+    }
+    handleDisconnect() {
+        if (this.socket) {
+            this.socket.onopen = null;
+            this.socket.onmessage = null;
+            this.socket.onclose = null;
+            this.socket.onerror = null;
+            this.socket = null;
+        }
+        this.setState('closed');
+        if (this.closedByUser || this.reconnectDelayMs <= 0) {
+            return;
+        }
+        const delay = Math.min(this.reconnectDelayMs * 2 ** this.reconnectAttempts, this.maxReconnectDelayMs);
+        this.reconnectAttempts += 1;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+    }
+    route(raw) {
+        if (typeof raw !== 'string') {
+            return;
+        }
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (!msg || typeof msg !== 'object') {
+            return;
+        }
+        const { type } = msg;
+        if (type === 'monitoring') {
+            const { topic, data } = msg;
+            if (typeof topic === 'string' && Array.isArray(data)) {
+                const listeners = this.topicListeners.get(topic);
+                if (listeners) {
+                    for (const listener of listeners) {
+                        listener(data);
+                    }
+                }
+            }
+        }
+        else if (type === 'notification') {
+            const { data } = msg;
+            for (const listener of this.notificationListeners) {
+                listener(data);
+            }
+        }
+        else if (type === 'progress') {
+            const { data } = msg;
+            for (const listener of this.progressListeners) {
+                listener(data);
+            }
+        }
+    }
+}

package/package.json

@@ -1,44 +1,38 @@
 {
   "name": "@synapticon/motion-master-client",
-  "version": "2.3.0-beta.0",
-  "private": false,
-  "description": "",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "version": "6.0.0-alpha.22",
+  "description": "Isomorphic TypeScript client for Motion Master: the generated HTTP API client, the WebSocket connection, and helpers.",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/synapticon/motion-master-client.git"
+    "url": "git+https://github.com/synapticon/motion-master.git",
+    "directory": "web/packages/motion-master-client"
   },
-  "scripts": {
-    "build": "npx tsc --build tsconfig.json",
-    "watch": "npx tsc --watch",
-    "motion-master-client": "node dist/cli.js",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "licenses": "npx license-checker --csv --out tmp/licenses.csv --customPath licenses.format.json"
+  "homepage": "https://github.com/synapticon/motion-master#readme",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
   },
-  "bin": {
-    "motion-master-client": "dist/cli.js"
+  "devDependencies": {
+    "swagger-typescript-api": "^13.7.2",
+    "typescript": "^5.6.0"
   },
-  "author": "Marko Sanković <msankovic@synapticon.com> (https://github.com/markosankovic)",
-  "license": "MIT",
-  "dependencies": {
-    "@synapticon/motion-master-proto": "^5.2.2",
-    "commander": "^6.1.0",
-    "debug": "^4.1.1",
-    "lodash": "^4.17.20",
-    "long": "^4.0.0",
-    "rxjs": "^6.6.3",
-    "uuid": "^8.3.0",
-    "yaml": "^1.10.0"
+  "scripts": {
+    "generate": "swagger-typescript-api generate -p ../../../apps/motion_master/swagger.yml -o ./src/generated -n api.ts --modular",
+    "build": "tsc -p tsconfig.build.json && node scripts/fix-esm-imports.mjs"
   },
-  "devDependencies": {
-    "@types/commander": "^2.12.2",
-    "@types/lodash": "^4.14.161",
-    "@types/node": "^14.6.4",
-    "@types/uuid": "^8.3.0",
-    "@types/yaml": "^1.9.7",
-    "license-checker": "^25.0.1",
-    "tslint": "^6.1.3",
-    "typescript": "^3.9.7"
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   }
-}
+}

package/.vscode/launch.json

@@ -1,23 +0,0 @@
-{
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Upload 0x1000:0 for device at position 0",
-      "program": "${workspaceFolder}/dist/cli.js",
-      "args": [
-        "-p",
-        "0",
-        "upload",
-        "0x1000:0",
-      ],
-      "outFiles": [
-        "${workspaceFolder}/**/*.js"
-      ]
-    }
-  ]
-}