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

package/dist/generated/data-contracts.js

@@ -0,0 +1,12 @@
+/* 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 {};

package/dist/generated/http-client.d.ts

@@ -0,0 +1,60 @@
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, "body" | "bodyUsed">;
+export interface FullRequestParams extends Omit<RequestInit, "body"> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseFormat;
+    /** request body */
+    body?: unknown;
+    /** base url */
+    baseUrl?: string;
+    /** request cancellation token */
+    cancelToken?: CancelToken;
+}
+export type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;
+export interface ApiConfig<SecurityDataType = unknown> {
+    baseUrl?: string;
+    baseApiParams?: Omit<RequestParams, "baseUrl" | "cancelToken" | "signal">;
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
+    customFetch?: typeof fetch;
+}
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+type CancelToken = Symbol | string | number;
+export declare enum ContentType {
+    Json = "application/json",
+    JsonApi = "application/vnd.api+json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    baseUrl: string;
+    private securityData;
+    private securityWorker?;
+    private abortControllers;
+    private customFetch;
+    private baseApiParams;
+    constructor(apiConfig?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected encodeQueryParam(key: string, value: any): string;
+    protected addQueryParam(query: QueryParamsType, key: string): string;
+    protected addArrayQueryParam(query: QueryParamsType, key: string): any;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    protected addQueryParams(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams;
+    protected createAbortSignal: (cancelToken: CancelToken) => AbortSignal | undefined;
+    abortRequest: (cancelToken: CancelToken) => void;
+    request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<HttpResponse<T, E>>;
+}
+export {};

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,13 @@
-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 './api-error.js';
+export * from './constants.js';
+export * from './web-socket-connection.js';
+export * from './client.js';
+export * from './lan.js';
+export * from './eni.js';
+export * from './hex.js';
+export * from './sdo.js';
+export * from './mmpd.js';
+export * from './wire-time.js';

package/dist/index.js

@@ -1,22 +1,20 @@
-"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 './api-error.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, SOMANET file-list parsing, the ENI export, and the LAN hostname mapping that lets
+// a browser reach a server on another machine under a name the bundled certificate covers.
+export * from './lan.js';
+export * from './eni.js';
+export * from './hex.js';
+export * from './sdo.js';
+export * from './mmpd.js';
+export * from './wire-time.js';

package/dist/lan.d.ts

@@ -0,0 +1,4 @@
+export declare const LAN_DOMAIN = "ip.motion-master.synapticon.com";
+export declare function isIpv4(value: string): boolean;
+export declare function lanHostname(host: string): string;
+export declare function lanAddress(host: string): string | null;

package/dist/lan.js

@@ -0,0 +1,59 @@
+// Reaching a Motion Master that runs on another machine (an appliance on the workshop LAN, say)
+// over TLS, from a page served at https://motion-master.synapticon.com.
+//
+// The obvious address — https://192.168.1.50:61447 — cannot work: no public CA will issue a
+// certificate for a private IP, and a cross-origin fetch() offers no click-through for a
+// self-signed one. The way out is a real, publicly-trusted name pointing at the private address.
+// Names under `ip.motion-master.synapticon.com` write the address into their leftmost label, and
+// the certificate every server ships carries the `*.ip.motion-master.synapticon.com` wildcard, so
+// any such name validates with nothing to install.
+//
+// These names are resolved on the client machine by a hosts-file entry, not by public DNS — which
+// is sufficient, because TLS checks a certificate against the name and never against how the name
+// was resolved.
+//
+// The mapping is *offered* to the user, never applied behind their back: connecting straight to the
+// IP address is a legitimate second path. It works once that origin has been opened in a tab and its
+// certificate warning accepted, and it is the only path when the Console is being viewed from a
+// phone or tablet — those cannot edit a hosts file, and it is the *browser's* machine that needs
+// the entry, not the one running Motion Master. So these helpers convert on request; the caller
+// decides.
+// The subdomain whose leftmost label encodes an IPv4 address.
+export const LAN_DOMAIN = 'ip.motion-master.synapticon.com';
+// True when `value` is a dotted-quad IPv4 literal (each octet 0-255). Hostnames, IPv6 literals,
+// and anything with a port or scheme attached are not.
+export function isIpv4(value) {
+    const octets = value.trim().split('.');
+    if (octets.length !== 4) {
+        return false;
+    }
+    return octets.every((octet) => /^\d{1,3}$/.test(octet) && Number(octet) <= 255);
+}
+// Map a host to the name the bundled certificate covers: an IPv4 literal becomes its dashed form
+// under LAN_DOMAIN (192.168.1.50 -> 192-168-1-50.ip.motion-master.synapticon.com); anything else
+// is already a hostname and is returned trimmed but otherwise untouched — so a user who types
+// `local.motion-master.synapticon.com`, or the dashed name itself, is left alone.
+//
+// Loopback is not special-cased: 127.0.0.1 maps to 127-0-0-1.ip.… which the same certificate
+// covers. For a same-machine server the shorter `local.motion-master.synapticon.com` is still the
+// better answer, since it is a public A record and so needs no hosts entry at all.
+export function lanHostname(host) {
+    const trimmed = host.trim();
+    if (!isIpv4(trimmed)) {
+        return trimmed;
+    }
+    return `${trimmed.split('.').join('-')}.${LAN_DOMAIN}`;
+}
+// The inverse of lanHostname: recovers the address a LAN hostname encodes, or null if the host is
+// not one of ours. Used to build the hosts-file line the user needs, since these names resolve
+// nowhere until they add it.
+export function lanAddress(host) {
+    const trimmed = host.trim().toLowerCase();
+    const suffix = `.${LAN_DOMAIN}`;
+    if (!trimmed.endsWith(suffix)) {
+        return null;
+    }
+    const label = trimmed.slice(0, -suffix.length);
+    const address = label.split('-').join('.');
+    return isIpv4(address) ? address : null;
+}

package/dist/mmpd.d.ts

@@ -0,0 +1,53 @@
+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;
+    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;