@machinemetrics/io-adapter-lib 2.32.0

package/lib/transform/patternReplace.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Replaces all instances in a string using a regex pattern.
+ */
+class PatternReplaceFilter extends TransformState {
+  constructor({ engine, path, args: { pattern, flags, replacement, noMatch } }) {
+    super();
+
+    this.patternPath = `${path}.pattern`;
+    this.withPath = `${path}.with`;
+    this.elsePath = `${path}.else`;
+
+    this.engine = engine;
+    this.staticPattern = engine.expressionService.isStaticExpression(this.patternPath);
+    this.patternSources = engine.expressionService.expressionTriggers(this.patternPath);
+    this.staticWith = engine.expressionService.isStaticExpression(this.withPath);
+    this.withSources = engine.expressionService.expressionTriggers(this.withPath);
+    this.staticElse = engine.expressionService.isStaticExpression(this.elsePath);
+    this.elseSources = engine.expressionService.expressionTriggers(this.elsePath);
+
+    this.flags = flags || '';
+    if (this.flags.indexOf('g') < 0) {
+      this.flags = `${flags}g`;
+    }
+
+    if (this.staticPattern) {
+      this.pattern = new RegExp(pattern, this.flags);
+    }
+
+    this.replacement = replacement;
+    this.noMatch = noMatch;
+
+    if (_.isNil(this.replacement)) {
+      this.replacement = '';
+    }
+  }
+
+  static op = 'pattern-replace';
+
+  static create(args) {
+    return new PatternReplaceFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, 'pattern-replace', {
+      optional: true,
+      availableAttributes: ['pattern', 'with', 'else'],
+    });
+
+    const pattern = _.get(defn.args, 'pattern');
+    if (_.isEmpty(pattern)) {
+      configUtil.throwConfigError('pattern-replace must have an pattern', this.op);
+    }
+
+    const decomp = configUtil.decomposePattern(pattern);
+    configUtil.testPattern(decomp.pattern, decomp.flags, this.op);
+
+    const replacement = _.get(defn.args, 'with');
+    const noMatch = _.get(defn.args, 'else');
+
+    defn.args = { ...decomp, replacement, noMatch };
+  }
+
+  static getStringExpressions(configUtil, body, info) {
+    const patternVal = configUtil.decomposePattern(body?.pattern?.toString(), 'imusg').pattern;
+    const withVal = body?.with?.toString();
+    const elseVal = body?.else?.toString();
+
+    return [
+      ...configUtil.getStringExpressions(body, patternVal, { ...info, field: 'pattern' }),
+      ...configUtil.getStringExpressions(body, withVal, { ...info, field: 'with' }),
+      ...configUtil.getStringExpressions(body, elseVal, { ...info, field: 'else' }),
+    ];
+  }
+
+  filter(context, value, time) {
+    value = value?.toString() ?? '';
+    let pattern = this.pattern;
+
+    if (!this.staticPattern) {
+      const localState = { this: value };
+      const unavailTerm = _.reduce(this.patternSources, (res, name) => {
+        const state = this.engine.getState(name);
+        localState[name] = state?.value;
+        return res || !state || !state.available;
+      }, false);
+
+      if (unavailTerm) {
+        this.setUnavailable(context, time);
+        return;
+      }
+
+      try {
+        pattern = this.engine.expressionService.computeStringExpression(this.patternPath, localState);
+        pattern = new RegExp(pattern, this.flags);
+      } catch (err) {
+        this.recordError(context, err, time);
+        this.setUnavailable(context, time);
+        return;
+      }
+    }
+
+    if (this.noMatch && !pattern.test(value)) {
+      if (this.staticElse) {
+        this.commitValue(context, this.noMatch, time);
+        return;
+      }
+
+      const localState = { this: value };
+      const unavailTerm = _.reduce(this.elseSources, (res, name) => {
+        const state = this.engine.getState(name);
+        localState[name] = state?.value;
+        return res || !state || !state.available;
+      }, false);
+
+      if (unavailTerm) {
+        this.setUnavailable(context, time);
+        return;
+      }
+
+      try {
+        const result = this.engine.expressionService.computeStringExpression(this.elsePath, localState);
+        this.commitValue(context, result, time);
+      } catch (err) {
+        this.recordError(context, err, time);
+        this.setUnavailable(context, time);
+      }
+
+      return;
+    }
+
+    const localState = { this: value };
+    const unavailTerm = _.reduce(this.withSources, (res, name) => {
+      const state = this.engine.getState(name);
+      localState[name] = state?.value;
+      return res || !state || !state.available;
+    }, false);
+
+    let replacement = null;
+    try {
+      if (this.staticWith) {
+        replacement = this.replacement;
+      } else if (unavailTerm) {
+        replacement = null;
+      } else {
+        replacement = this.engine.expressionService.computeStringExpression(this.withPath, localState);
+      }
+    } catch (err) {
+      this.recordError(context, err, time);
+      this.setUnavailable(context, time);
+      return;
+    }
+
+    if (replacement === null) {
+      if (this.pattern.test(value)) {
+        this.setUnavailable(context, time);
+      }
+      return;
+    }
+
+    const sub = value.replace(pattern, replacement);
+    this.commitValue(context, sub, time);
+  }
+}
+
+module.exports = PatternReplaceFilter;

package/lib/transform/patternTest.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Attempts to match a pattern in a source string and return true if found and false otherwise
+ */
+class PatternTestFilter extends TransformState {
+  constructor({ engine, path, args: { pattern, flags } }) {
+    super();
+
+    this.patternPath = `${path}.pattern`;
+
+    this.engine = engine;
+    this.staticPattern = engine.expressionService.isStaticExpression(this.patternPath);
+    this.patternSources = engine.expressionService.expressionTriggers(this.patternPath);
+
+    this.flags = flags || '';
+    if (this.staticPattern) {
+      this.pattern = new RegExp(pattern, this.flags);
+    }
+  }
+
+  static op = 'pattern-test';
+
+  static create(args) {
+    return new PatternTestFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const pattern = defn.args.pattern ?? defn.args[defn.func];
+    if (_.isEmpty(pattern)) {
+      configUtil.throwConfigError('pattern-test must have an pattern', this.op);
+    }
+
+    defn.args = configUtil.decomposePattern(pattern);
+    configUtil.testPattern(defn.args.pattern, defn.args.flags, this.op);
+  }
+
+  static getStringExpressions(configUtil, body, info) {
+    if (_.isString(body)) {
+      body = { pattern: body };
+    }
+
+    const patternVal = configUtil.decomposePattern(body?.pattern?.toString(), 'imusg').pattern;
+
+    return [
+      ...configUtil.getStringExpressions(body, patternVal, { ...info, field: 'pattern' }),
+    ];
+  }
+
+  filter(context, value, time) {
+    value = value?.toString() ?? '';
+    let pattern = this.pattern;
+
+    if (!this.staticPattern) {
+      const localState = { this: value };
+      const unavailTerm = this.patternSources.reduce((res, name) => {
+        const state = this.engine.getState(name);
+        localState[name] = state?.value;
+        return res || !state || !state.available;
+      }, false);
+
+      if (unavailTerm) {
+        this.setUnavailable(context, time);
+        return;
+      }
+
+      try {
+        pattern = this.engine.expressionService.computeStringExpression(this.patternPath, localState);
+        pattern = new RegExp(pattern, this.flags);
+      } catch (err) {
+        this.recordError(context, err, time);
+        this.setUnavailable(context, time);
+        return;
+      }
+    }
+
+    const test = pattern.test(value);
+    this.commitValue(context, test, time);
+  }
+}
+
+module.exports = PatternTestFilter;

package/lib/transform/rateOfChange.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const TransformState = require('./transformState');
+
+/**
+ * Compares each incoming sample with the previous sample and emits the difference between them divided by
+ * the time between the samples.
+ */
+class RateOfChange extends TransformState {
+  constructor() {
+    super();
+    this.initReset();
+  }
+
+  static op = 'rate-of-change';
+
+  static create(_args) {
+    return new RateOfChange();
+  }
+
+  initReset() {
+    this.previousSample = null;
+    this.previousSampleTime = null;
+  }
+
+  filter(context, value, time) {
+    if (this.previousSample === null) {
+      this.capturePrevious(value, time);
+      return;
+    }
+
+    const valDiff = value - this.previousSample;
+    const timeDiff = time - this.previousSampleTime;
+
+    this.capturePrevious(value, time);
+
+    if (timeDiff === 0) {
+      return;
+    }
+
+    const rate = valDiff / timeDiff;
+    this.commitValue(context, rate, time);
+  }
+
+  capturePrevious(value, time) {
+    this.previousSample = value;
+    this.previousSampleTime = time;
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = RateOfChange;

package/lib/transform/reject.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Filters out any null elements from an array data value
+ */
+class RejectFilter extends TransformState {
+  constructor({ engine, path, args }) {
+    super();
+
+    this.engine = engine;
+
+    if (args.expression) {
+      this.compiledExpression = args.compiledExpression;
+      this.selfSources = engine.expressionService.expressionTriggers(path);
+    } else if (args.pattern) {
+      this.pattern = new RegExp(args.pattern, args.flags);
+    } else {
+      this.equalityTest = String(args.value);
+    }
+  }
+
+  static op = 'reject';
+
+  static create(args) {
+    return new RejectFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, this.op, {
+      optional: false,
+      exclusive: true,
+      availableAttributes: ['pattern', 'expression', 'value'],
+      defaultAttribute: 'value',
+    });
+
+    let expression = _.get(defn.args, 'expression');
+    if (!_.isEmpty(expression)) {
+      expression = expression.toString();
+      const compiledExpression = configUtil.compileExpression(expression, this.op);
+
+      defn.args = { expression, compiledExpression };
+    }
+
+    const pattern = _.get(defn.args, 'pattern');
+    if (!_.isEmpty(pattern)) {
+      defn.args = configUtil.decomposePattern(pattern);
+      configUtil.testPattern(defn.args.pattern, defn.args.flags, 'pattern');
+    }
+
+    const value = _.get(defn.args, 'value', defn.args[defn.func]);
+    if (!_.isUndefined(value) && !_.isObject(value) && !_.isArray(value)) {
+      defn.args = { value };
+    }
+  }
+
+  filter(context, value, time) {
+    if (!_.isArray(value)) {
+      this.commitValue(value, time);
+      return;
+    }
+
+    if (this.compiledExpression) {
+      this.filterExpression(context, value, time);
+    } else if (this.pattern) {
+      this.filterPattern(context, value, time);
+    } else {
+      this.filterEquality(context, value, time);
+    }
+  }
+
+  filterExpression(context, value, time) {
+    const localState = {};
+    const unavailTerm = this.selfSources.reduce((res, name) => {
+      const state = this.engine.getState(name);
+      localState[name] = state?.value;
+      return res || !state || !state.available;
+    }, false);
+
+    if (unavailTerm) {
+      this.setUnavailable(context, time);
+      return;
+    }
+
+    try {
+      const filtered = _.reject(value, (item) => {
+        localState.this = item;
+        return this.compiledExpression.evaluate(localState);
+      });
+      this.commitValue(context, filtered, time);
+    } catch (err) {
+      // Probably a type error in one of the arguments.
+      this.recordError(context, err, time);
+      this.setUnavailable(context, time);
+    }
+  }
+
+  filterPattern(context, value, time) {
+    const filtered = _.reject(value, (item) => {
+      return this.pattern.test(item);
+    });
+    this.commitValue(context, filtered, time);
+  }
+
+  filterEquality(context, value, time) {
+    const filtered = _.reject(value, (item) => {
+      return String(item) === this.equalityTest;
+    });
+    this.commitValue(context, filtered, time);
+  }
+}
+
+module.exports = RejectFilter;

package/lib/transform/resample.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+const E = 0.000001;
+function floatLessEq(a, b) {
+  return a <= b + E;
+}
+
+const MAX_FILL_TIME = 300;
+
+/**
+ * Takes an analog stream and resamples it to a given rate.
+ *
+ * If the resample interval is larger than the source interval, resampling is calculated by taking every
+ * Nth sample in the source where N is resample-interval / source-interval.  If N is a fraction and a calculated
+ * sample falls between source samples, the older sample will be emitted.
+ *
+ * If the resample interval is smaller than the source interval, resampling is calculated by emitting N samples for
+ * every source sample, where N is source-interval / resample-interval.  The previous received source sample is repeated
+ * for each of N samples until a sample's time matches or crosses the new sample time.
+ */
+class ResampleFilter extends TransformState {
+  constructor({ interval, limit }) {
+    super();
+
+    this.interval = interval;
+    this.limit = limit;
+    this.initReset();
+  }
+
+  static op = 'resample';
+
+  static create(args) {
+    return new ResampleFilter(args.args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, this.op, {
+      optional: true,
+      availableAttributes: ['interval', 'interpolate', 'limit'],
+      defaultAttribute: 'interval',
+    });
+
+    const interval = _.get(defn.args, 'interval', defn.args[defn.func]);
+    configUtil.requirePositive(interval, 'interval', this.op);
+
+    const interpolate = _.get(defn.args, 'interpolate');
+    if (!_.isUndefined(interpolate)) {
+      if (!_.isBoolean(interpolate)) {
+        configUtil.throwConfigError('interpolate must be true or false', this.op);
+      }
+    }
+
+    const limit = _.get(defn.args, 'limit', 1);
+    configUtil.requireZeroPositive(limit, 'limit', this.op);
+
+    defn.args = { interval, interpolate, limit };
+  }
+
+  initReset() {
+    this.pendingChangeTime = null;
+  }
+
+  supportsPendingChanges() {
+    return true;
+  }
+
+  nextPendingChange(time) {
+    // Safety limit.  If resample hasn't been probed in at least 5 minutes, do now allow filling in
+    // the missing samples.
+    if (this.lastSampleTime > -1 && time - this.lastSampleTime >= MAX_FILL_TIME) {
+      return time - this.interval;
+    }
+    return this.pendingChangeTime;
+  }
+
+  emitUpdate(context) {
+    if (!this.pendingChangeTime) {
+      this.pendingChangeTime = this.lastSampleTime;
+    }
+
+    if (floatLessEq(this.pendingChangeTime, this.lastSampleTime)) {
+      super.emitUpdate(context);
+      this.pendingChangeTime = this.lastSampleTime + this.interval;
+    }
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = ResampleFilter;

package/lib/transform/risingEdge.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Finds all rising edges (F->T) in a digital stream.
+ *
+ * For every incoming sample, the outgoing sample will be false.  When a rising edge is found, an additional true
+ * value will be emitted before the false value, resulting in a 0-duration "event".
+ *
+ * The filter can be modified with a min-dwell and max-dwell property, which will only emit edge events if the
+ * preceding state duration was within the window of time bounded by min-dwell and max-dwell.
+ */
+class RisingEdgeFilter extends TransformState {
+  constructor({ minDwell, maxDwell } = {}) {
+    super();
+
+    this.defaultValue = false;
+    this.value = false;
+    this.previousValue = false;
+
+    this.minDwell = minDwell;
+    this.maxDwell = maxDwell;
+  }
+
+  static op = 'rising-edge';
+
+  static create(args) {
+    return new RisingEdgeFilter(args.args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, this.op, {
+      optional: true,
+      availableAttributes: ['min-dwell', 'max-dwell'],
+    });
+
+    const minDwell = defn.args['min-dwell'];
+    if (!_.isUndefined(minDwell)) {
+      configUtil.requireZeroPositive(minDwell, 'min-dwell', this.op);
+    }
+
+    const maxDwell = defn.args['max-dwell'];
+    if (!_.isUndefined(maxDwell)) {
+      configUtil.requireZeroPositive(maxDwell, 'max-dwell', this.op);
+      if (_.isNumber(minDwell) && maxDwell <= minDwell) {
+        configUtil.throwConfigError('max-dwell must be greater than min-dwell', this.op);
+      }
+    }
+
+    defn.args = { minDwell, maxDwell };
+  }
+
+  update(context, value, time) {
+    let skip = false;
+    if (!this.available) {
+      this.available = true;
+      this.forceEmit = true;
+      skip = true;
+    }
+
+    this.lastSuppliedValue = value;
+    this.lastSampleTime = time;
+    this.filter(context, value, time);
+    if (this.available) {
+      if (skip) {
+        this.emit('update', false, this.lastSampleTime, context);
+      } else {
+        this.emitUpdate(context);
+      }
+    }
+  }
+
+  emitUpdate(context) {
+    if (this.value && this.valueTime === this.lastSampleTime) {
+      const duration = this.valueTime - this.previousValueTime;
+      const pass = true
+        && (!this.minDwell || duration >= this.minDwell)
+        && (!this.maxDwell || duration <= this.maxDwell);
+
+      if (pass) {
+        this.emit('update', true, this.lastSampleTime, context);
+      }
+    }
+    this.emit('update', false, this.lastSampleTime, context);
+  }
+}
+
+module.exports = RisingEdgeFilter;