motion-master-client 0.0.55 → 0.0.56

package/src/lib/util.ts

@@ -0,0 +1,332 @@
+import { inRange } from "lodash";
+import { DeviceLogLine } from "./device-log-line";
+import { Parameter, ParameterIndexSubindex } from "./parameter";
+import { SystemLogLine } from "./system-log-line";
+import { DeviceRef, DeviceRefObj, IMotionMasterMessage, MotionMasterMessage, ParameterAddressValue, ParameterTypeValue, ParameterTypeValueKey, ParameterValueType, ValueType } from "./types";
+
+export function getParameterTypeValueDefault(key: ParameterTypeValueKey) {
+  if (key === 'floatValue' || key === 'intValue' || key === 'uintValue') {
+    return 0;
+  } else if (key === 'rawValue') {
+    return Uint8Array.from([]);
+  } else if (key === 'stringValue') {
+    return '';
+  } else {
+    return 0;
+  }
+}
+
+export function getParameterTypeValue(parameter: MotionMasterMessage.Status.DeviceParameterValues.IParameterValue): ParameterTypeValueKey | undefined {
+  return (MotionMasterMessage.Status.DeviceParameterValues.ParameterValue.create(parameter)).typeValue;
+}
+
+export function getParameterValue(parameter: MotionMasterMessage.Status.DeviceParameterValues.IParameterValue): ParameterValueType {
+  const key = getParameterTypeValue(parameter);
+  if (key && key in parameter) {
+    return parameter[key] ?? getParameterTypeValueDefault(key);
+  }
+  return 0;
+}
+
+export function makeDeviceRefObj(deviceRef: DeviceRef): DeviceRefObj {
+  if (typeof deviceRef === 'number') {
+    if (deviceRef <= 0xFFFF) {
+      return { devicePosition: deviceRef };
+    } else {
+      return { deviceAddress: deviceRef };
+    }
+  } else {
+    return { deviceSerialNumber: deviceRef };
+  }
+}
+
+// TODO: Write unit tests.
+export function parseSystemLogLine(line: string): SystemLogLine | undefined {
+  const re = /(\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{1,3})\s\((.+)\)\s\[(.+)\](.+:\d+)(.+?)\|(.*)/s;
+  const result = re.exec(line);
+  if (result) {
+    return {
+      line,
+      date: new Date(result[1]),
+      uptime: result[2].trim(),
+      id: result[3].trim(),
+      file: result[4].trim(),
+      level: result[5].trim(),
+      message: result[6],
+    };
+  }
+  return;
+}
+
+// TODO: Write unit tests.
+export function parseSystemLogContent(content: string): SystemLogLine[] {
+  const re = /(\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{1,3}.+?)(?=\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{1,3}|$)/gs;
+  return content.split(re)
+    .filter((l) => l !== '')
+    .map((v) => parseSystemLogLine(v))
+    .filter((l): l is SystemLogLine => l !== undefined);
+}
+
+export function parseDeviceLog(line: string): DeviceLogLine | undefined {
+  const re = /^(\d{2}:\d{2}:\d{2}\.\d+)\s(.*)\|(.*)$/gm;
+  const result = re.exec(line);
+  if (result) {
+    return {
+      time: result[1].trim(),
+      level: result[2].trim(),
+      message: result[3].trim(),
+    };
+  }
+  return;
+}
+
+export function parseDeviceLogContent(content: string): DeviceLogLine[] {
+  return content.split('\n')
+    .map((v) => parseDeviceLog(v))
+    .filter((l): l is DeviceLogLine => l !== undefined);
+}
+
+export function mapParameterTypeValueToObject(type: keyof ParameterTypeValue, value: number | string): ParameterTypeValue {
+  const p: ParameterTypeValue = {};
+  if (type === 'floatValue') {
+    p['floatValue'] = typeof value === 'number' ? value : parseFloat(value);
+  } else if (type === 'intValue') {
+    p['intValue'] = typeof value === 'number' ? value : parseInt(value, 10);
+  } else if (type === 'rawValue') {
+    if (typeof value === 'number') {
+      p['rawValue'] = Uint8Array.from([value]);
+    } else {
+      let bytes: number[] = [];
+      if (value.startsWith('0x')) {
+        bytes = value.slice(2).match(/.{1,2}/g)?.map((h) => parseInt(h, 16)) ?? [];
+      } else {
+        bytes = value.split(',').map((c) => c.trim()).map((c) => parseInt(c, 10));
+      }
+      p['rawValue'] = Uint8Array.from(bytes);
+    }
+  } else if (type === 'stringValue') {
+    p['stringValue'] = typeof value === 'string' ? value : value.toString();
+  } else if (type === 'uintValue') {
+    p['uintValue'] = typeof value === 'number' ? value : parseInt(value, 10);
+  }
+  return p;
+}
+
+// Using bytes fixes: ERROR TypeError: Cannot freeze array buffer views with elements in NgRx
+export function createPlainObjectFromMotionMasterMessage(motionMasterMessage: MotionMasterMessage) {
+  return MotionMasterMessage.toObject(motionMasterMessage, {
+    bytes: Array, // Valid values are `Array`
+    defaults: true, // Also sets default values on the resulting object
+    arrays: true, // Sets empty arrays for missing repeated fields even if `defaults=false`
+    objects: true, // Sets empty objects for missing map fields even if `defaults=false`
+    oneofs: true, // Includes virtual oneof properties set to the present field's name, if any
+    json: true, // Performs additional JSON compatibility conversions, i.e. NaN and Infinity to strings
+  });
+}
+
+export function convertMotionMasterMessageToLoggerContext(motionMasterMessage: IMotionMasterMessage, namespace = 'reqResMessage') {
+  let type;
+  let name;
+
+  if (motionMasterMessage.request) {
+    type = 'request';
+    name = Object.keys(motionMasterMessage.request).join();
+  } else if (motionMasterMessage.status) {
+    type = 'status';
+    name = Object.keys(motionMasterMessage.status).join();
+  }
+
+  return { namespace, motionMasterMessage, type, name };
+}
+
+export function decodeTextContent(content: Uint8Array): string {
+  const decoder = new TextDecoder();
+  const buffer = Uint8Array.from(content);
+  return decoder.decode(buffer);
+}
+
+export function isRxPdoIndex(index: number): boolean {
+  return inRange(index, 0x1600, 0x1800);
+}
+
+export function isTxPdoIndex(index: number): boolean {
+  return inRange(index, 0x1A00, 0x1C00);
+}
+
+export function filterRxPdoParameters<T extends ParameterIndexSubindex>(parameters: T[], excludeSubIndex000 = false): T[] {
+  return parameters.filter((p) => isRxPdoIndex(p.index) && (excludeSubIndex000 ? p.subindex > 0 : true)); // RxPDOs: Index area 0x1600 to 0x17FF
+}
+
+export function filterTxPdoParameters<T extends ParameterIndexSubindex>(parameters: T[], excludeSubIndex000 = false): T[] {
+  return parameters.filter((p) => isTxPdoIndex(p.index) && (excludeSubIndex000 ? p.subindex > 0 : true)); // TxPDOs: Index area 0x1A00 to 0x1BFF
+}
+
+export function fillPdoParametersWithMappingEntries(parameters: Parameter[], entriesPerPdo = 10): Parameter[] {
+  const output: Parameter[] = [];
+  let i = 0;
+  while (i < parameters.length) {
+    if (parameters[i].subindex === 0) {
+      let j = i;
+      while (parameters[j] && (parameters[j].index === parameters[i].index)) {
+        output.push(parameters[j]);
+        j++;
+      }
+      let d = j - i;
+      while (d <= entriesPerPdo) {
+        output.push({
+          index: parameters[i].index,
+          subindex: d,
+          name: parameters[i].name,
+          uintValue: 0,
+          value: 0,
+          valueType: ValueType.UNSIGNED32,
+          group: parameters[i].group,
+          typeValueKey: "uintValue",
+          readAccess: true,
+          writeAccess: true,
+        });
+        d++;
+      }
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  return output;
+}
+
+export function mapParameterToPdoSubItemValue(parameter: Parameter): number {
+  const { index, subindex } = parameter;
+  if (parameter.valueType && parameter.valueType < ValueType.VISIBLE_STRING) {
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    const bitSize = mapValueTypeToBitSize(parameter.valueType);
+    view.setUint16(0, index);
+    view.setUint8(2, subindex);
+    view.setUint8(3, bitSize);
+    return view.getUint32(0);
+  }
+  return 0;
+}
+
+export function mapValueTypeToBitSize(valueType: ValueType): number {
+  switch (valueType) {
+    case ValueType.UNSPECIFIED:
+      return 0;
+    case ValueType.BOOLEAN:
+      return 1;
+    case ValueType.INTEGER8:
+    case ValueType.UNSIGNED8:
+      return 8;
+    case ValueType.INTEGER16:
+    case ValueType.UNSIGNED16:
+      return 16;
+    case ValueType.INTEGER32:
+    case ValueType.UNSIGNED32:
+    case ValueType.REAL32:
+      return 32;
+  }
+  throw new Error(`Non-numeric value type "${valueType}" (data types with variable length) cannot be mapped to bit size. You will have to get this info from ESI.`);
+}
+
+export const valueTypeToParameterTypeValueKeyMap = new Map<ValueType, keyof Required<ParameterTypeValue>>([
+  [ValueType.BOOLEAN, 'uintValue'],
+  [ValueType.INTEGER8, 'intValue'],
+  [ValueType.INTEGER16, 'intValue'],
+  [ValueType.INTEGER32, 'intValue'],
+  [ValueType.UNSIGNED8, 'uintValue'],
+  [ValueType.UNSIGNED16, 'uintValue'],
+  [ValueType.UNSIGNED32, 'uintValue'],
+  [ValueType.REAL32, 'floatValue'],
+  [ValueType.VISIBLE_STRING, 'stringValue'],
+  [ValueType.OCTET_STRING, 'rawValue'],
+  [ValueType.UNICODE_STRING, 'stringValue'],
+  [ValueType.TIME_OF_DAY, 'uintValue'],
+]);
+
+export function isValidDeviceRefObj(obj: DeviceRefObj): boolean {
+  return Number.isFinite(Number(obj.deviceAddress))
+    || (typeof obj.devicePosition === 'number' && obj.devicePosition >= 0)
+    || typeof obj.deviceSerialNumber === 'string';
+}
+
+export function createPdoParameterValues(parameters: Array<{ index: number, subindex: number, typeValue?: ParameterTypeValueKey }>, values: Array<ParameterValueType>) {
+  const output = parameters.map((parameter, i, arr) => {
+    const { index, subindex, typeValue } = parameter;
+    let value = values[i];
+    if (subindex === 0) {
+      value = arr.reduce((n, p, j) => (p.index === index && p.subindex > 0 && values[j]) ? n + 1 : n, 0);
+    }
+    return [index, subindex, value, typeValue];
+  }) as ParameterAddressValue[];
+
+  for (let i = 0; i < output.length - 1; i++) {
+    const [, subindex1, value1] = output[i];
+    if (subindex1 > 0 && value1 === 0) {
+      let j = i + 1;
+      let [, subindex2, value2] = output[j];
+      while (subindex2 > subindex1 && output[j]) {
+        if (typeof value2 === 'number' && value2 > 0) {
+          output[i][2] = value2;
+          output[j][2] = 0;
+          break;
+        }
+        if (output[++j]) {
+          [, subindex2, value2] = output[j];
+        }
+      }
+    }
+  }
+
+  return output;
+}
+
+export function resolveAfter(ms: number, value?: unknown) {
+  return new Promise(function (resolve) {
+    setTimeout(resolve.bind(null, value), ms);
+  });
+}
+
+export function convertRgbToLedColor(value: number) {
+  const r = (value >> 16) & 0xFF;
+  const g = (value >> 8) & 0xFF;
+  const b = value & 0xFF;
+  const ledColorValue = (g << 16) | (r << 8) | b;
+  return ledColorValue;
+}
+
+export function createRandomColor(brightness: number) {
+  function randomChannel(brightness: number) {
+    const r = 255 - brightness;
+    const n = 0 | ((Math.random() * r) + brightness);
+    const s = n.toString(16);
+    return (s.length == 1) ? '0' + s : s;
+  }
+  return '#' + randomChannel(brightness) + randomChannel(brightness) + randomChannel(brightness);
+}
+
+export const emptyAppBase64 = 'UEsDBBQACAAIABBye08AAAAAAAAAAAAAAAANACAAYXBwX2VtcHR5LmJpblVUDQAHMHfeXTB33l0wd95ddXgLAAEE6AMAAAToAwAAAwBQSwcIAAAAAAIAAAAAAAAAUEsBAhQDFAAIAAgAEHJ7TwAAAAACAAAAAAAAAA0AIAAAAAAAAAAAAKSBAAAAAGFwcF9lbXB0eS5iaW5VVA0ABzB33l0wd95dMHfeXXV4CwABBOgDAAAE6AMAAFBLBQYAAAAAAQABAFsAAABdAAAAAAA=';
+
+export function getMapKeyByValue<K, V>(map: Map<K, V>, searchValue: V): K | undefined {
+  for (let [key, value] of map.entries()) {
+    if (value === searchValue) {
+      return key;
+    }
+  }
+  return;
+}
+
+export function findDuplicates<T>(arr: T[]): T[] {
+  const uniqueElements = new Set<T>();
+  const duplicates = new Set<T>();
+
+  for (const item of arr) {
+    if (uniqueElements.has(item)) {
+      duplicates.add(item);
+    } else {
+      uniqueElements.add(item);
+    }
+  }
+
+  return Array.from(duplicates);
+}

package/src/lib/web-socket-connection-close-codes.ts

@@ -0,0 +1,85 @@
+/**
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+ */
+export const webSocketConnectionCloseCodes = [
+  {
+    statusCode: 1000,
+    meaning: 'Normal Closure',
+    description: 'The connection successfully completed the purpose for which it was created.',
+  },
+  {
+    statusCode: 1001,
+    meaning: 'Going Away',
+    description: 'The endpoint is going away, either because of a server failure or because the browser is navigating away from the page that opened the connection.',
+  },
+  {
+    statusCode: 1002,
+    meaning: 'Protocol error',
+    description: 'The endpoint is terminating the connection due to a protocol error.',
+  },
+  {
+    statusCode: 1003,
+    meaning: 'Unsupported Data',
+    description: 'The connection is being terminated because the endpoint received data of a type it cannot accept. (For example, a text-only endpoint received binary data.)',
+  },
+  {
+    statusCode: 1004,
+    meaning: 'Reserved',
+    description: 'Reserved. A meaning might be defined in the future.',
+  },
+  {
+    statusCode: 1005,
+    meaning: 'No Status Rcvd',
+    description: 'Reserved. Indicates that no status code was provided even though one was expected.',
+  },
+  {
+    statusCode: 1006,
+    meaning: 'Abnormal Closure',
+    description: 'Reserved. Indicates that a connection was closed abnormally (that is, with no close frame being sent) when a status code is expected.',
+  },
+  {
+    statusCode: 1007,
+    meaning: 'Invalid frame payload data',
+    description: 'The endpoint is terminating the connection because a message was received that contained inconsistent data (e.g., non-UTF-8 data within a text message).',
+  },
+  {
+    statusCode: 1008,
+    meaning: 'Policy Violation',
+    description: 'The endpoint is terminating the connection because it received a message that violates its policy. This is a generic status code, used when codes 1003 and 1009 are not suitable.',
+  },
+  {
+    statusCode: 1009,
+    meaning: 'Message Too Big',
+    description: 'The endpoint is terminating the connection because a data frame was received that is too large.',
+  },
+  {
+    statusCode: 1010,
+    meaning: 'Mandatory Ext.',
+    description: 'The client is terminating the connection because it expected the server to negotiate one or more extension, but the server didn\'t.',
+  },
+  {
+    statusCode: 1011,
+    meaning: 'Internal Error',
+    description: 'The server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.',
+  },
+  {
+    statusCode: 1012,
+    meaning: 'Service Restart',
+    description: 'The server is terminating the connection because it is restarting.',
+  },
+  {
+    statusCode: 1013,
+    meaning: 'Try Again Later',
+    description: 'The server is terminating the connection due to a temporary condition, e.g. it is overloaded and is casting off some of its clients.',
+  },
+  {
+    statusCode: 1014,
+    meaning: 'Bad Gateway',
+    description: 'The server was acting as a gateway or proxy and received an invalid response from the upstream server. This is similar to 502 HTTP Status Code.',
+  },
+  {
+    statusCode: 1015,
+    meaning: 'TLS handshake',
+    description: 'Reserved. Indicates that the connection was closed due to a failure to perform a TLS handshake (e.g., the server certificate can\'t be verified).',
+  },
+];

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowJs": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,20 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/*.test.tsx",
+    "**/*.spec.tsx",
+    "**/*.test.js",
+    "**/*.spec.js",
+    "**/*.test.jsx",
+    "**/*.spec.jsx",
+    "**/*.d.ts",
+    "jest.config.ts"
+  ]
+}

package/typedoc.json

@@ -0,0 +1,10 @@
+{
+  "entryPoints": [
+    "./src/index.ts"
+  ],
+  "out": "../../docs/motion-master-client",
+  "tsconfig": "./tsconfig.json",
+  "exclude": [
+    "**/*+(.spec|.e2e).ts"
+  ]
+}

package/src/index.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/cia402"), exports);
-tslib_1.__exportStar(require("./lib/config-file"), exports);
-tslib_1.__exportStar(require("./lib/device-log-line"), exports);
-tslib_1.__exportStar(require("./lib/device-parameter"), exports);
-tslib_1.__exportStar(require("./lib/device"), exports);
-tslib_1.__exportStar(require("./lib/hardware-description"), exports);
-tslib_1.__exportStar(require("./lib/monitoring-config"), exports);
-tslib_1.__exportStar(require("./lib/monitoring-entry"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-client"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-pub-sub-client"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-pub-sub-socket"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-pub-sub-web-socket"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-pub-sub-worker-socket"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-req-res-client"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-req-res-socket"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-req-res-web-socket"), exports);
-tslib_1.__exportStar(require("./lib/motion-master-req-res-worker-socket"), exports);
-tslib_1.__exportStar(require("./lib/operators"), exports);
-tslib_1.__exportStar(require("./lib/options"), exports);
-tslib_1.__exportStar(require("./lib/parameter"), exports);
-tslib_1.__exportStar(require("./lib/request-status-resolver"), exports);
-tslib_1.__exportStar(require("./lib/system-log-line"), exports);
-tslib_1.__exportStar(require("./lib/types"), exports);
-tslib_1.__exportStar(require("./lib/urls"), exports);
-tslib_1.__exportStar(require("./lib/util"), exports);
-tslib_1.__exportStar(require("./lib/web-socket-connection-close-codes"), exports);
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/motion-master-client/src/index.ts"],"names":[],"mappings":";;;AAAA,uDAA6B;AAC7B,4DAAkC;AAClC,gEAAsC;AACtC,iEAAuC;AACvC,uDAA6B;AAC7B,qEAA2C;AAC3C,kEAAwC;AACxC,iEAAuC;AACvC,qEAA2C;AAC3C,6EAAmD;AACnD,6EAAmD;AACnD,iFAAuD;AACvD,oFAA0D;AAC1D,6EAAmD;AACnD,6EAAmD;AACnD,iFAAuD;AACvD,oFAA0D;AAC1D,0DAAgC;AAChC,wDAA8B;AAC9B,0DAAgC;AAChC,wEAA8C;AAC9C,gEAAsC;AACtC,sDAA4B;AAC5B,qDAA2B;AAC3B,qDAA2B;AAC3B,kFAAwD"}