@machinemetrics/io-adapter-lib 2.32.0

package/lib/transform/max.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+const RingBuffer = require('./util/ringBuffer');
+
+// TODO: Consider changing count implementation to support non-clocked input
+
+/**
+ * For each incoming sample, outputs the max of the last N samples seen.
+ */
+class MaxFilter extends TransformState {
+  constructor(sampleCount) {
+    super();
+
+    this.sampleCount = sampleCount;
+    this.initReset();
+  }
+
+  static op = 'max';
+
+  static create(args) {
+    return new MaxFilter(args.args.count);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const count = _.get(defn.args, 'count');
+    configUtil.requirePositive(count, this.op, this.op);
+
+    defn.args = { count };
+  }
+
+  initReset() {
+    this.buffer = new RingBuffer(this.sampleCount);
+    this.max = 0;
+  }
+
+  filter(context, value, time) {
+    const oldest = this.buffer.get(this.buffer.getTailIndex());
+    this.buffer.push(value);
+
+    if (this.max === oldest) {
+      this.max = _.max(this.buffer.values());
+    } else if (this.max < value) {
+      this.max = value;
+    }
+
+    this.commitValue(context, this.max, time);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = MaxFilter;

package/lib/transform/maxLength.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Truncates string value to maximum specified length
+ */
+class MaxLengthFilter extends TransformState {
+  constructor(count) {
+    super();
+
+    this.maxLength = count;
+  }
+
+  static op = 'max-length';
+
+  static create(args) {
+    return new MaxLengthFilter(args.args.count);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const count = _.get(defn.args, 'count', defn.args[defn.func]);
+    configUtil.requirePositive(count, this.op, this.op);
+
+    defn.args = { count };
+  }
+
+  filter(context, value, time) {
+    if (_.isString(value)) {
+      value = value.substring(0, this.maxLength);
+    } else if (_.isArray(value)) {
+      value = value.slice(0, this.maxLength);
+    }
+    this.commitValue(context, value, time);
+  }
+}
+
+module.exports = MaxLengthFilter;

package/lib/transform/min.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+const RingBuffer = require('./util/ringBuffer');
+
+// TODO: Consider changing count implementation to support non-clocked input
+
+/**
+ * For each incoming sample, outputs the min of the last N samples seen.
+ */
+class MinFilter extends TransformState {
+  constructor(sampleCount) {
+    super();
+
+    this.sampleCount = sampleCount;
+    this.initReset();
+  }
+
+  static op = 'min';
+
+  static create(args) {
+    return new MinFilter(args.args.count);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const count = _.get(defn.args, 'count');
+    configUtil.requirePositive(count, this.op, this.op);
+
+    defn.args = { count };
+  }
+
+  initReset() {
+    this.buffer = new RingBuffer(this.sampleCount);
+    this.min = 0;
+  }
+
+  filter(context, value, time) {
+    const oldest = this.buffer.get(this.buffer.getTailIndex());
+    this.buffer.push(value);
+
+    if (this.min === oldest) {
+      this.min = _.min(this.buffer.values());
+    } else if (this.min > value) {
+      this.min = value;
+    }
+
+    this.commitValue(context, this.min, time);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = MinFilter;

package/lib/transform/minDelta.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Compares each incoming sample with the last change that was emitted.  If the difference between the two is larger
+ * than the specified delta, the new sample is recorded and emitted, otherwise the old sample is emitted.
+ *
+ * This is similar to quantization, but instead of fixed output values, any newly recorded output value is guaranteed
+ * to be at least delta greater or lesser than the previous recorded output value.
+ */
+class MinDelta extends TransformState {
+  constructor(delta) {
+    super();
+
+    this.delta = delta;
+  }
+
+  static op = 'min-delta';
+
+  static create(args) {
+    return new MinDelta(args.args.delta);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const delta = _.get(defn.args, 'delta', defn.args[defn.func]);
+    configUtil.requirePositive(delta, this.op, this.op);
+
+    defn.args = { delta };
+  }
+
+  filter(context, value, time) {
+    if (Math.abs(value - this.value) >= this.delta) {
+      this.commitValue(context, value, time);
+    }
+  }
+}
+
+module.exports = MinDelta;

package/lib/transform/offDelay.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const TransformState = require('./transformState');
+
+/**
+ * Holds a digital signal in the 'on' state for a given window of time when the incoming signal goes low.
+ *
+ * The internal counter of the off delay resets on each falling edge, so a signal that switches state
+ * frequently may be emitted in the on state continuously.
+ *
+ * This transform introduces lag into the signal equal to the window size.
+ */
+class OffDelayFilter extends TransformState {
+  constructor(window) {
+    super();
+
+    this.window = window;
+    this.defaultValue = false;
+    this.initReset();
+  }
+
+  static op = 'off-delay';
+
+  static create(args) {
+    return new OffDelayFilter(args.args.window);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const window = defn.args.window ?? defn.args[defn.func];
+    configUtil.requirePositive(window, this.op, this.op);
+
+    defn.args = { window };
+  }
+
+  initReset() {
+    this.value = false;
+    this.lowStartTime = null;
+    this.pendingChangeTime = null;
+  }
+
+  supportsPendingChanges() {
+    return true;
+  }
+
+  filter(context, value, time) {
+    // Whenever the real signal transitions to low, record a marker at that time.
+    if (!value && this.lowStartTime === null) {
+      this.lowStartTime = time;
+      this.pendingChangeTime = time + this.window;
+    }
+
+    const lowStart = this.lowStartTime || 0;
+    const insideOffDelayWindow = lowStart + this.window > time;
+    if (insideOffDelayWindow && !value) {
+      // When incoming signal is low but has not been held low long enough, skip
+      return;
+    }
+
+    if (value || (!value && time >= this.pendingChangeTime)) {
+      this.pendingChangeTime = null;
+    }
+
+    if (!insideOffDelayWindow && value && this.value && this.lowStartTime !== null) {
+      // If we're outside of the delay window AND both the incoming signal and held signal are high,
+      // AND we recorded a lowStartTime marker, then there is high->low transition between this sample
+      // and the previous sample that must be recognized.
+
+      const offTime = lowStart + this.window;
+      if (offTime === time) {
+        this.commitValue(context, false, offTime);
+        this.emitCommittedUpdate(context);
+      }
+    }
+
+    // When the real signal transitions to high, clear the low signal marker.
+    if (value && this.lowStartTime !== null) {
+      this.lowStartTime = null;
+    }
+
+    this.commitValue(context, value, time);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = OffDelayFilter;

package/lib/transform/onDelay.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const TransformState = require('./transformState');
+
+/**
+ * Holds a digital signal in the 'off' state for a given window of time when the incoming signal goes high.
+ *
+ * The internal counter of the on delay resets on each rising edge, so a signal that switches state
+ * frequently may be emitted in the off state continuously.
+ *
+ * This transform introduces lag into the signal equal to the window size.
+ */
+class OnDelayFilter extends TransformState {
+  constructor(window) {
+    super();
+
+    this.window = window;
+    this.defaultValue = false;
+    this.initReset();
+  }
+
+  static op = 'on-delay';
+
+  static create(args) {
+    return new OnDelayFilter(args.args.window);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const window = defn.args.window ?? defn.args[defn.func];
+    configUtil.requirePositive(window, this.op, this.op);
+
+    defn.args = { window };
+  }
+
+  initReset() {
+    this.value = false;
+    this.highStartTime = null;
+    this.pendingChangeTime = null;
+  }
+
+  supportsPendingChanges() {
+    return true;
+  }
+
+  filter(context, value, time) {
+    // Whenever the real signal transitions to high, record a marker at that time.
+    if (value && this.highStartTime === null) {
+      this.highStartTime = time;
+      this.pendingChangeTime = time + this.window;
+    }
+
+    const highStart = this.highStartTime || 0;
+    const insideOnDelayWindow = highStart + this.window > time;
+    if (insideOnDelayWindow && value) {
+      // When incoming signal is high but has not been held high long enough, skip
+      return;
+    }
+
+    if (!value || (value && time >= this.pendingChangeTime)) {
+      this.pendingChangeTime = null;
+    }
+
+    if (!insideOnDelayWindow && !value && !this.value && this.highStartTime !== null) {
+      // If we're outside of the delay window AND both the incoming signal and held signal are low,
+      // AND we recorded a highStartTime marker, then there is low->high transition between this sample
+      // and the previous sample that must be recognized.
+
+      const onTime = highStart + this.window;
+      if (onTime === time) {
+        this.commitValue(context, true, onTime);
+        this.emitCommittedUpdate(context);
+      }
+    }
+
+    // When the real signal transitions to low, clear the high signal marker.
+    if (!value && this.highStartTime !== null) {
+      this.highStartTime = null;
+    }
+
+    this.commitValue(context, value, time);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = OnDelayFilter;

package/lib/transform/patternEscape.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Escapes a string to be usable as a literal in a regex pattern.
+ */
+class PatternEscapeFilter extends TransformState {
+  static op = 'pattern-escape';
+
+  static create(_args) {
+    return new PatternEscapeFilter();
+  }
+
+  filter(context, value, time) {
+    if (_.isString(value)) {
+      value = _.escapeRegExp(value);
+    }
+    this.commitValue(context, value, time);
+  }
+}
+
+module.exports = PatternEscapeFilter;

package/lib/transform/patternMatch.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Attempts to match a pattern in a source string and capture the match as output.
+ */
+class PatternMatchFilter extends TransformState {
+  constructor({ engine, path, args: { pattern, flags, group, noMatch, matchIndex } }) {
+    super();
+
+    this.patternPath = `${path}.pattern`;
+    this.elsePath = `${path}.else`;
+
+    this.engine = engine;
+    this.staticPattern = engine.expressionService.isStaticExpression(this.patternPath);
+    this.patternSources = engine.expressionService.expressionTriggers(this.patternPath);
+    this.staticElse = engine.expressionService.isStaticExpression(this.elsePath);
+    this.elseSources = engine.expressionService.expressionTriggers(this.elsePath);
+
+    this.flags = flags || '';
+    this.hasMatchIndex = _.isNumber(matchIndex);
+    this.hasGroup = _.isNumber(group);
+
+    const globalFlag = this.flags.indexOf('g') >= 0;
+    if (this.hasMatchIndex && !globalFlag) {
+      this.flags = `${flags}g`;
+    } else if (!this.hasMatchIndex && globalFlag) {
+      this.hasMatchIndex = true;
+      this.matchIndex = 0;
+    }
+
+    if (this.staticPattern) {
+      this.pattern = new RegExp(pattern, this.flags);
+    }
+
+    this.group = group || 0;
+    this.noMatch = noMatch;
+    this.matchIndex = matchIndex || 0;
+  }
+
+  static op = 'pattern-match';
+
+  static create(args) {
+    return new PatternMatchFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, this.op, {
+      optional: false,
+      availableAttributes: ['pattern', 'group', 'index', 'else'],
+      defaultAttribute: 'pattern',
+    });
+
+    const pattern = _.get(defn.args, 'pattern', defn.args[defn.func]);
+    if (_.isEmpty(pattern)) {
+      configUtil.throwConfigError('pattern-match must have an pattern', this.op);
+    }
+
+    const decomp = configUtil.decomposePattern(pattern, 'imusg');
+    configUtil.testPattern(decomp.pattern, decomp.flags, this.op);
+
+    const group = _.get(defn.args, 'group');
+    if (!_.isNil(group)) {
+      configUtil.requireZeroPositive(group, 'group', this.op);
+    }
+
+    const matchIndex = _.get(defn.args, 'index');
+    if (!_.isNil(matchIndex)) {
+      configUtil.requireZeroPositive(matchIndex, 'index', this.op);
+    }
+
+    const noMatch = _.get(defn.args, 'else');
+
+    defn.args = { ...decomp, group, noMatch, matchIndex };
+  }
+
+  static getStringExpressions(configUtil, body, info) {
+    if (_.isString(body)) {
+      body = { pattern: body };
+    }
+
+    const patternVal = configUtil.decomposePattern(body?.pattern?.toString(), 'imusg').pattern;
+    const elseVal = body?.else?.toString();
+
+    return [
+      ...configUtil.getStringExpressions(body, patternVal, { ...info, field: 'pattern' }),
+      ...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;
+      }
+    }
+
+    let match = null;
+
+    try {
+      if (this.hasGroup && this.hasMatchIndex) {
+        match = this.matchGroupIndex(pattern, value);
+      } else if (this.hasGroup) {
+        match = this.matchSimple(pattern, value, this.group);
+      } else if (this.hasMatchIndex) {
+        match = this.matchSimple(pattern, value, this.matchIndex);
+      } else {
+        match = this.matchSimple(pattern, value, 0);
+      }
+    } catch (err) {
+      this.recordError(context, err, time);
+      this.setUnavailable(context, time);
+      return;
+    }
+
+    if (match === null) {
+      this.setUnavailable(context, time);
+    } else {
+      this.commitValue(context, match, time);
+    }
+  }
+
+  matchSimple(pattern, value, index) {
+    const match = value.match(pattern);
+    if (!match || match[index] === undefined) {
+      return this.makeNoMatch(value);
+    }
+
+    return match[index];
+  }
+
+  matchGroupIndex(pattern, value) {
+    const matches = [...value.matchAll(pattern)];
+    if (!matches) {
+      return this.makeNoMatch(value);
+    }
+
+    if (this.matchIndex >= matches.length) {
+      return this.makeNoMatch(value);
+    }
+
+    const match = matches[this.matchIndex];
+    if (!match || match[this.group] === undefined) {
+      return this.makeNoMatch(value);
+    }
+
+    return match[this.group];
+  }
+
+  makeNoMatch(value) {
+    if (_.isUndefined(this.noMatch)) {
+      return '';
+    } else if (this.staticElse) {
+      return this.noMatch;
+    }
+
+    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) {
+      return null;
+    }
+
+    return this.engine.expressionService.computeStringExpression(this.elsePath, localState);
+  }
+}
+
+module.exports = PatternMatchFilter;