@machinemetrics/io-adapter-lib 2.32.0

package/lib/engine/index.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const EngineV1 = require('./engineV1');
+const EngineV2 = require('./engineV2');
+const TransformBuilderV1 = require('./transformBuilderV1');
+const TransformBuilderV2 = require('./transformBuilderV2');
+
+class Engine {
+  static load(config, options = {}) {
+    if (config.engineVersion === 1) {
+      return new EngineV1(config, options);
+    }
+
+    if (config.engineVersion >= 2) {
+      const pool = new EngineV2(config, options);
+
+      if (config.configVersion === 1) {
+        const builder = new TransformBuilderV1(config);
+        builder.build(pool);
+      } else if (config.configVersion === 2) {
+        const builder = new TransformBuilderV2(config);
+        builder.build(pool);
+      } else {
+        throw new Error('Unsupported config version');
+      }
+
+      return pool;
+    }
+
+    throw new Error('Unable to determine correct engine to load');
+  }
+}
+
+module.exports = Engine;

package/lib/engine/transformBuilderV1.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const _ = require('lodash');
+const Transform = require('../transform');
+
+class TransformBuilderV1 {
+  constructor(config) {
+    this.config = config;
+  }
+
+  build(dataPool) {
+    _.each(this.config.vpins, (vpin) => {
+      let chain = null;
+      if (vpin.type === 'analog') {
+        chain = this.buildAnalogTransformChain(vpin);
+      } else if (vpin.type === 'digital') {
+        chain = this.buildDigitalTransformChain(vpin);
+      } else if (vpin.type === 'counter') {
+        chain = this.buildCounterTransformChain(vpin, dataPool);
+      }
+
+      if (chain) {
+        dataPool.addVariable(vpin.name, chain);
+      }
+    });
+  }
+
+  buildAnalogTransformChain(defn) {
+    if (!defn || defn.type !== 'analog') {
+      return null;
+    }
+
+    const transform = new Transform.sampleInterval(defn.sampleInterval);
+    if (defn.sampleFunc === 'avg') {
+      transform.chain(new Transform.average(defn.sampleWindow));
+    } else if (defn.sampleFunc === 'max') {
+      transform.chain(new Transform.max(defn.sampleWindow));
+    } else if (defn.sampleFunc === 'min') {
+      transform.chain(new Transform.min(defn.sampleWindow));
+    }
+
+    if (defn.minDelta) {
+      transform.chain(new Transform.minDelta(defn.minDelta));
+    }
+
+    return transform;
+  }
+
+  buildDigitalTransformChain(defn) {
+    if (!defn || (defn.type !== 'digital' && defn.type !== 'counter')) {
+      return null;
+    }
+
+    const transform = new Transform.threshold(defn.vThresh);
+    if (defn.invert) {
+      transform.chain(new Transform.invert());
+    }
+
+    if (defn.filter) {
+      transform.chain(new Transform.debounce(defn.filter));
+    }
+
+    if (defn.onDelay) {
+      transform.chain(new Transform.onDelay(defn.onDelay));
+    }
+    if (defn.offDelay) {
+      transform.chain(new Transform.offDelay(defn.offDelay));
+    }
+    if (defn.onLatch) {
+      transform.chain(new Transform.risingEdge());
+      transform.chain(new Transform.offDelay(defn.onLatch));
+    }
+    if (defn.offLatch) {
+      transform.chain(new Transform.fallingEdge());
+      transform.chain(new Transform.onDelay(defn.offLatch));
+    }
+
+    return transform;
+  }
+
+  buildCounterTransformChain(defn, dataPool) {
+    if (!defn || defn.type !== 'counter') {
+      return null;
+    }
+
+    const transform = this.buildDigitalTransformChain(defn);
+
+    if (defn.edge === 'rising') {
+      transform.chain(new Transform.risingEdge({
+        minDwell: defn.minPulseWidth,
+        maxDwell: defn.maxPulseWidth,
+      }));
+    } else if (defn.edge === 'falling') {
+      transform.chain(new Transform.fallingEdge({
+        minDwell: defn.minPulseWidth,
+        maxDwell: defn.maxPulseWidth,
+      }));
+    }
+
+    if (defn.suspend) {
+      transform.chain(new Transform.invert());
+      transform.chain(new Transform.logicAnd(dataPool, defn.suspend));
+    }
+
+    transform.chain(new Transform.risingEdgeCounter());
+
+    return transform;
+  }
+}
+
+module.exports = TransformBuilderV1;

package/lib/engine/transformBuilderV2.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const _ = require('lodash');
+const Transform = require('../transform');
+
+class TransformBuilderV2 {
+  constructor(config) {
+    this.config = config;
+
+    this.transformMap = Object.values(Transform).reduce((trmap, transform) => {
+      trmap[transform.op] = transform;
+      transform.opAliases.forEach((alias) => {
+        trmap[alias] = transform;
+      });
+      return trmap;
+    }, {});
+  }
+
+  build(engine) {
+    // NB: This is required if using native node events
+    // If there's a lot of variables, increase the max listener count for engine
+    // const varCount = _.size(this.config.engine.variables);
+    // if (varCount > engine.getMaxListeners()) {
+    //   engine.setMaxListeners(varCount);
+    // }
+
+    _.each(this.config.engine.variables, (v, varName) => {
+      if (!v.transform) {
+        return;
+      }
+
+      const transform = this.createTransformChain(engine, v.transform, varName, true);
+      if (transform) {
+        engine.addVariable(varName, transform);
+      }
+    });
+  }
+
+  createTransformChain(engine, transformList, varName, base = false) {
+    return _.reduce(transformList, (transform, transDefn) => {
+      const step = this.createTransformStep(transDefn, varName, engine, base && transform === null);
+      if (step !== null) {
+        if (transform === null) {
+          transform = step;
+        } else {
+          transform.chain(step);
+        }
+      }
+      return transform;
+    }, null);
+  }
+
+  createTransformStep(transDefn, varName, engine, base = false) {
+    const makeTransformArgs = (defn) => {
+      return {
+        engine,
+        config: this.config,
+        path: defn.path,
+        rootPath: `variables.${varName}`,
+        baseTransform: base,
+        args: defn.args,
+        builder: this,
+      };
+    };
+
+    const args = makeTransformArgs(transDefn);
+    if (!this.transformMap[transDefn.func]) {
+      return null;
+    }
+    return this.transformMap[transDefn.func].create(args);
+  }
+}
+
+module.exports = TransformBuilderV2;

package/lib/expressionService.js

@@ -0,0 +1,330 @@
+'use strict';
+
+const _ = require('lodash');
+const math = require('./math');
+
+class ExpressionService {
+  constructor(config = {}) {
+    this.config = config;
+    this.availableNamesByChannel = {};
+    this.referencedNamesByChannel = {};
+    this.referencedNamesByPath = {};
+    this.pathsByReferenceName = {};
+    this.defaultValues = {};
+    this.channelsLookup = {};
+    this.stringExpressionsByPath = {};
+
+    this.resetStatistics();
+  }
+
+  resetStatistics() {
+    this.stats = {
+      parseStringExprCount: 0,
+      parseStringExprCounts: {},
+      computeStringExprCount: 0,
+      computeStringExprCounts: {},
+    };
+  }
+
+  isNameValid(name) {
+    if (_.isEmpty(name)) {
+      return false;
+    }
+    return !!name.match(/^\w($|[\w-]*\w)$/);
+  }
+
+  isNameDefined(name, channel) {
+    return this.channelSetValueExists(this.availableNamesByChannel, name, channel);
+  }
+
+  definedNames(channel) {
+    return this.channelSetValues(this.availableNamesByChannel, channel);
+  }
+
+  isNameReferenced(name, channel) {
+    return this.channelSetValueExists(this.referencedNamesByChannel, name, channel);
+  }
+
+  referencedNames(channel) {
+    return this.channelSetValues(this.referencedNamesByChannel, channel);
+  }
+
+  channelSetValueExists(channelSet, value, channel) {
+    if (channel) {
+      return _.includes(channelSet[channel], value);
+    }
+    return _.reduce(channelSet, (res, set) => {
+      return res || _.includes(set, value);
+    }, false);
+  }
+
+  channelSetValues(channelSet, channel) {
+    if (channel) {
+      return channelSet[channel] || [];
+    }
+    return _(channelSet).values().flatten().uniq().value();
+  }
+
+  addName({ name, channel, defaultValue } = {}) {
+    if (!name || !channel) {
+      throw new Error('Incomplete identifier');
+    }
+    if (this.isNameDefined(name)) {
+      return false;
+    }
+
+    this.defaultValues[name] = defaultValue;
+    this.channelsLookup[name] = channel;
+
+    if (!this.availableNamesByChannel[channel]) {
+      this.availableNamesByChannel[channel] = [];
+    }
+    this.availableNamesByChannel[channel].push(name);
+
+    return true;
+  }
+
+  addExpression({ expression, path } = {}) {
+    if (!expression || !path) {
+      throw new Error('Incomplete expression');
+    }
+
+    const names = this.definedNames();
+    _.each(names, (name) => {
+      if (this.findName(expression, name)) {
+        const channel = this.channelsLookup[name];
+        if (channel) {
+          if (!this.referencedNamesByChannel[channel]) {
+            this.referencedNamesByChannel[channel] = [];
+          }
+          if (!this.isNameReferenced(name, channel)) {
+            this.referencedNamesByChannel[channel].push(name);
+          }
+        }
+
+        if (!this.referencedNamesByPath[path]) {
+          this.referencedNamesByPath[path] = [];
+        }
+        if (!_.includes(this.referencedNamesByPath[path], name)) {
+          this.referencedNamesByPath[path].push(name);
+        }
+
+        if (!this.pathsByReferenceName[name]) {
+          this.pathsByReferenceName[name] = [];
+        }
+        if (!_.includes(this.pathsByReferenceName[name], path)) {
+          this.pathsByReferenceName[name].push(path);
+        }
+      }
+    });
+  }
+
+  addStringExpression({ string, path, withThis } = {}) {
+    if (!string || !path) {
+      throw new Error('Incomplete expression');
+    }
+
+    const parts = this.parseStringExpr(string);
+    _.each(parts, (part) => {
+      if (part.expression) {
+        this.addExpression({
+          expression: part.expression,
+          path,
+        });
+      }
+    });
+
+    const state = { };
+    if (withThis) {
+      state.this = 0;
+    }
+
+    this.stringExpressionsByPath[path] = _.map(parts, (part) => {
+      if (part.expression) {
+        part.compiledExpression = this.compileExpression(part.expression, state);
+      }
+      return part;
+    });
+  }
+
+  parseStringExpr(str, exprSet = []) {
+    if (_.isNil(str)) {
+      return exprSet;
+    }
+
+    str = str.toString();
+    this.stats.parseStringExprCount += 1;
+    this.stats.parseStringExprCounts[str] = (this.stats.parseStringExprCounts[str] ?? 0) + 1;
+
+    const match = str.match(/(?<!\\)\${((\\}|[^}])*)}/);
+    if (!match) {
+      return [...exprSet, { text: this.unescapeText(str) }];
+    }
+
+    const part1 = {
+      text: this.unescapeText(str.slice(0, match.index)),
+    };
+    const part2 = {
+      text: str.slice(match.index, match.index + match[0].length),
+      expression: this.unescapeExpression(match[1]),
+    };
+    const part3 = str.slice(match.index + match[0].length);
+
+    let parts12 = [part1, part2];
+    if (_.isEmpty(part1.text)) {
+      parts12 = [part2];
+    }
+
+    if (_.isEmpty(part3)) {
+      return [...exprSet, ...parts12];
+    }
+
+    return this.parseStringExpr(part3, [...exprSet, ...parts12]);
+  }
+
+  unescapeText(str) {
+    return str.replace(/\\\${/g, '${');
+  }
+
+  unescapeExpression(str) {
+    return str.replace(/\\}/g, '}');
+  }
+
+  findName(exprStr, name) {
+    const pattern = new RegExp(`(?:^|(?<=[\\s\\[(,:?]))${name}(?:(?=[\\[\\]\\s),.:?])|$)`, 'g');
+    return exprStr.match(pattern) !== null;
+  }
+
+  findCompoundIdentifiers(str) {
+    const matches = str.match(/[A-Za-z_][A-Za-z0-9_-]*(?:(?:\.[A-Za-z][A-Za-z0-9_-]*)|(?:\['[^'"]+'\]))+/g);
+    return matches ?? [];
+  }
+
+  tokenizeCompoundIdentifier(compound) {
+    const first = (compound.match(/^[A-Za-z_][A-Za-z0-9_-]*/) ?? [])[0];
+    const rest = [];
+
+    compound = compound.substr(first.length);
+    while (compound.length > 0) {
+      let match = compound.match(/^\.([A-Za-z_][A-Za-z0-9_-]*)/);
+      if (match) {
+        rest.push(match[1]);
+        compound = compound.substr(match[0].length);
+      } else {
+        match = compound.match(/^\['([^'"]+)'\]/);
+        if (match) {
+          rest.push(match[1]);
+          compound = compound.substr(match[0].length);
+        } else {
+          break;
+        }
+      }
+    }
+
+    return compound.length === 0 ? [first, ...rest] : null;
+  }
+
+  compileExpression(expression, scope = {}) {
+    if (_.isEmpty(expression)) {
+      throw new Error('expression must have an expression');
+    }
+
+    let errMessage = null;
+    let compiledExpression = null;
+
+    try {
+      compiledExpression = this.compileInnerExpression(expression, scope);
+    } catch (err) {
+      errMessage = err.message;
+    }
+
+    // Do a second compile test with this referencing an object
+    // Allows expressions of type: this.subkey, this.subkey.subsubkey, etc.
+    if (errMessage) {
+      const objThisMatch = this.findCompoundIdentifiers(expression);
+      if (objThisMatch) {
+        const addedScope = objThisMatch.reduce((accum, s) => {
+          const tokens = this.tokenizeCompoundIdentifier(s);
+          if (tokens) {
+            const first = tokens[0];
+            if (first === 'this' || this.channelsLookup[first]) {
+              accum[first] = _.reduceRight(_.tail(tokens), (sub, item) => {
+                return { [item]: sub };
+              }, 0);
+            } else {
+              accum[first] = 0;
+            }
+          }
+          return accum;
+        }, {});
+
+        try {
+          return this.compileInnerExpression(expression, { ...scope, ...addedScope });
+        } catch (err) {
+          throw new Error(`Problem evaluating expression: ${errMessage}`);
+        }
+      }
+
+      // Not an exception we know how to handle
+      throw new Error(`Problem evaluating expression: ${errMessage}`);
+    }
+
+    return compiledExpression;
+  }
+
+  compileInnerExpression(exprStr, extraState = {}) {
+    const compiledExpr = math.compile(exprStr);
+    compiledExpr.evaluate({ ...this.defaultValues, ...extraState });
+    return compiledExpr;
+  }
+
+  expressionTriggers(path) {
+    return this.referencedNamesByPath[path] || [];
+  }
+
+  expressionsTriggeredBy(name) {
+    return this.pathsByReferenceName[name] || [];
+  }
+
+  hasStringExpression(path) {
+    return !!this.stringExpressionsByPath[path];
+  }
+
+  isStaticExpression(path) {
+    if (!this.hasStringExpression(path)) {
+      return false;
+    }
+
+    const parts = this.stringExpressionsByPath[path];
+    if (parts.length > 1) {
+      return false;
+    }
+
+    return !parts[0].expression;
+  }
+
+  computeStringExpression(path, state) {
+    this.stats.computeStringExprCount += 1;
+    this.stats.computeStringExprCounts[path] = (this.stats.computeStringExprCounts[path] ?? 0) + 1;
+
+    const expr = this.stringExpressionsByPath[path];
+    if (!expr || expr.length === 0) {
+      return null;
+    }
+
+    if (expr.length === 1 && !expr[0].compiledExpression) {
+      return expr[0].text;
+    }
+
+    const parts = _.map(expr, (part) => {
+      if (part.compiledExpression) {
+        return part.compiledExpression.evaluate(state);
+      }
+      return part.text;
+    });
+
+    return parts.join('');
+  }
+}
+
+module.exports = ExpressionService;

package/lib/math.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const _ = require('lodash');
+const mathjs = require('mathjs');
+const md5 = require('md5');
+
+const math = mathjs.create(mathjs.all, {
+  matrix: 'Array',
+});
+
+const isAlpha = math.parse.isAlpha;
+math.parse.isAlpha = (c, prev, next) => {
+  return isAlpha(c, prev, next) || (c === '-' && prev && next);
+};
+
+const equalText = math.equalText;
+const concat = math.concat;
+const size = math.size;
+
+const equal = (a, b) => {
+  const aStr = _.isString(a);
+  const bStr = _.isString(b);
+  if (aStr && !bStr && !_.isNil(b)) {
+    b = b.toString();
+  } else if (bStr && !aStr && !_.isNil(a)) {
+    a = a.toString();
+  }
+
+  return a === b;
+};
+
+math.import({
+  import: () => { throw new Error('Function import is disabled'); },
+  createUnit: () => { throw new Error('Function createUnit is disabled'); },
+  evaluate: () => { throw new Error('Function evaluate is disabled'); },
+  // parse: () => { throw new Error('Function parse is disabled'); },
+  simplify: () => { throw new Error('Function simplify is disabled'); },
+  derivative: () => { throw new Error('Function derivative is disabled'); },
+  equal,
+  unequal: (a, b) => {
+    return !equal(a, b);
+  },
+  equalText: (a, b) => { return equalText(a.toString(), b.toString()); },
+  concat: (...args) => { return concat(...args.map(arg => arg.toString())); },
+  size: (v) => {
+    if (_.isString(v)) {
+      return v.length;
+    }
+    return size(v);
+  },
+  flag: (value, index) => {
+    if (_.isArray(value)) {
+      return (index < value.length) ? !!value[index] : false;
+    }
+    return (value & (1 << index)) !== 0;
+  },
+  startsWith: (s, v) => {
+    if (!_.isString(s)) {
+      return false;
+    }
+    return s.startsWith(v);
+  },
+  endsWith: (s, v) => {
+    if (!_.isString(s)) {
+      return false;
+    }
+    return s.endsWith(v);
+  },
+  contains: (s, v) => {
+    if (_.isString(s)) {
+      return s.includes(v);
+    } else if (_.isArray(s)) {
+      v = v?.toString();
+      return s.find(p => p?.toString() === v) !== undefined;
+    }
+    return false;
+  },
+  match: (s, pattern, group = 0) => {
+    if (!_.isString(s)) {
+      return '';
+    }
+    const regex = new RegExp(pattern);
+    const match = s.match(regex);
+    if (!match || _.isNil(match[group])) {
+      return '';
+    }
+    return match[group];
+  },
+  test: (s, pattern) => {
+    if (!_.isString(s)) {
+      return false;
+    }
+    return new RegExp(pattern).test(s);
+  },
+  replace: (s, pattern, replacement) => {
+    if (!_.isString(s)) {
+      return s;
+    }
+    const regex = new RegExp(pattern, 'g');
+    return s.replace(regex, replacement);
+  },
+  md5: (s) => {
+    return md5(s);
+  },
+  lpad: (s, length, v) => {
+    if (!_.isString(s)) {
+      s = s.toString();
+    }
+    return s.padStart(length, v);
+  },
+  rpad: (s, length, v) => {
+    if (!_.isString(s)) {
+      s = s.toString();
+    }
+    return s.padEnd(length, v);
+  },
+  asc: (n) => {
+    const inner = (n) => {
+      if (_.isString(n)) {
+        n = Number(n);
+      }
+      if (n <= 0) {
+        return '';
+      }
+      return String.fromCharCode(n);
+    };
+
+    if (_.isArray(n)) {
+      return _.map(n, inner).join('');
+    }
+    return inner(n);
+  },
+  ord: (s, index = 0) => {
+    if (!_.isString(s)) {
+      return NaN;
+    }
+
+    return s.charCodeAt(index);
+  }
+}, { override: true });
+
+module.exports = math;