@machinemetrics/io-adapter-lib 2.32.0

package/lib/transform/ignoreValue.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Ignores matching incoming value, persisting the previous unignored value instead.
+ *
+ * For every incoming sample, check if the value should be ignored (either by static equality
+ * check, pattern match, or expression evaluation).  If the check passes, the value will be
+ * ignored, and the previous unignored value will be emitted instead.
+ */
+class IgnoreValueFilter extends TransformState {
+  constructor({ engine, path, args }) {
+    super();
+
+    this.engine = engine;
+    this.defaultValue = args.init !== undefined ? args.init : 0;
+    this.value = this.defaultValue;
+
+    if (args.expression) {
+      this.compiledExpression = args.compiledExpression;
+      this.selfSources = engine.expressionService.expressionTriggers(`${path}.expression`);
+    } else if (args.pattern) {
+      this.pattern = new RegExp(args.pattern, args.flags);
+    } else {
+      this.equalityTest = String(args.value);
+    }
+  }
+
+  static op = 'ignore-value';
+
+  static create(args) {
+    return new IgnoreValueFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, this.op, {
+      optional: false,
+      exclusive: true,
+      availableAttributes: ['value', 'pattern', 'expression'],
+      defaultAttribute: 'value',
+    });
+
+    const init = defn.args.default;
+
+    let expression = defn.args.expression;
+    if (!_.isEmpty(expression)) {
+      expression = expression.toString();
+      const compiledExpression = configUtil.compileExpression(expression, this.op);
+
+      defn.args = { init, expression, compiledExpression };
+    }
+
+    const pattern = defn.args.pattern;
+    if (!_.isEmpty(pattern)) {
+      defn.args = { init, ...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 = { init, value };
+    }
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return configUtil.getExpressions(body, { ...info, field: 'expression' });
+  }
+
+  filter(context, value, time) {
+    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 = { this: value };
+    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 {
+      if (!this.compiledExpression.evaluate(localState)) {
+        this.commitValue(context, value, 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) {
+    if (!this.pattern.test(value)) {
+      this.commitValue(context, value, time);
+    }
+  }
+
+  filterEquality(context, value, time) {
+    if (value?.toString() !== this.equalityTest) {
+      this.commitValue(context, value, time);
+    }
+  }
+}
+
+module.exports = IgnoreValueFilter;

package/lib/transform/index.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const AccumulateFilter = require('./accumulate');
+const AverageFilter = require('./average');
+const DebounceFilter = require('./debounce');
+const DownsampleFilter = require('./downsample');
+const EdgeFilter = require('./edge');
+const ExpressionFilter = require('./expression');
+const FallingEdgeFilter = require('./fallingEdge');
+const FromBufferFilter = require('./fromBuffer');
+const HashFilter = require('./hash');
+const IgnoreValueFilter = require('./ignoreValue');
+const InvertFilter = require('./invert');
+const LatchFilter = require('./latch');
+const LatchValueFilter = require('./latchValue');
+const LogicAndFilter = require('./logicAnd');
+const LogicOrFilter = require('./logicOr');
+const MapFilter = require('./map');
+const MaxFilter = require('./max');
+const MaxLengthFilter = require('./maxLength');
+const MinDeltaFilter = require('./minDelta');
+const MinFilter = require('./min');
+const OffDelayFilter = require('./offDelay');
+const OnDelayFilter = require('./onDelay');
+const PatternEscapeFilter = require('./patternEscape');
+const PatternMatchFilter = require('./patternMatch');
+const PatternReplaceFilter = require('./patternReplace');
+const PatternTestFilter = require('./patternTest');
+const RateOfChangeFilter = require('./rateOfChange');
+const RejectFilter = require('./reject');
+const ResampleFilter = require('./resample');
+const RisingEdgeCounterFilter = require('./risingEdgeCounter');
+const RisingEdgeFilter = require('./risingEdge');
+const SampleIntervalFilter = require('./sampleInterval');
+const SourceFilter = require('./source');
+const StateFilter = require('./state');
+const ThresholdFilter = require('./threshold');
+const ToBufferFilter = require('./toBuffer');
+const ToggleFilter = require('./toggle');
+const TrimFilter = require('./trim');
+const ValueChangeFilter = require('./valueChange');
+const ValueDecreaseFilter = require('./valueDecrease');
+const ValueIncreaseFilter = require('./valueIncrease');
+const ValueIncreaseDiffFilter = require('./valueIncreaseDiff');
+const WhenUnavailableFilter = require('./whenUnavailable');
+const WindowCountFilter = require('./windowCount');
+
+module.exports = {
+  accumulate: AccumulateFilter,
+  average: AverageFilter,
+  debounce: DebounceFilter,
+  downsample: DownsampleFilter,
+  edge: EdgeFilter,
+  expression: ExpressionFilter,
+  fallingEdge: FallingEdgeFilter,
+  fromBuffer: FromBufferFilter,
+  hash: HashFilter,
+  ignoreValue: IgnoreValueFilter,
+  invert: InvertFilter,
+  latch: LatchFilter,
+  latchValue: LatchValueFilter,
+  logicAnd: LogicAndFilter,
+  logicOr: LogicOrFilter,
+  map: MapFilter,
+  max: MaxFilter,
+  maxLength: MaxLengthFilter,
+  min: MinFilter,
+  minDelta: MinDeltaFilter,
+  offDelay: OffDelayFilter,
+  onDelay: OnDelayFilter,
+  patternEscape: PatternEscapeFilter,
+  patternMatch: PatternMatchFilter,
+  patternReplace: PatternReplaceFilter,
+  patternTest: PatternTestFilter,
+  rateOfChange: RateOfChangeFilter,
+  reject: RejectFilter,
+  resample: ResampleFilter,
+  risingEdgeCounter: RisingEdgeCounterFilter,
+  risingEdge: RisingEdgeFilter,
+  sampleInterval: SampleIntervalFilter,
+  source: SourceFilter,
+  state: StateFilter,
+  threshold: ThresholdFilter,
+  toBuffer: ToBufferFilter,
+  toggle: ToggleFilter,
+  trim: TrimFilter,
+  valueChange: ValueChangeFilter,
+  valueDecrease: ValueDecreaseFilter,
+  valueIncrease: ValueIncreaseFilter,
+  valueIncreaseDiff: ValueIncreaseDiffFilter,
+  whenUnavailable: WhenUnavailableFilter,
+  windowCount: WindowCountFilter,
+};

package/lib/transform/invert.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Inverts each sample in a digital stream.
+ */
+class InvertFilter extends TransformState {
+  static op = 'invert';
+
+  static create(_args) {
+    return new InvertFilter();
+  }
+
+  filter(context, value, time) {
+    if (_.isNumber(value)) {
+      this.commitValue(context, 0 - value, time);
+    } else {
+      this.commitValue(context, !value, time);
+    }
+  }
+}
+
+module.exports = InvertFilter;

package/lib/transform/latch.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+// Deprecated: Use latch-value for similar behavior
+
+/**
+ * Latches the last incoming value received when the corresponding expression evaluates true
+ *
+ * Latch will transparently pass through all values, including unavailable state, when its
+ * expression evaluates false.  When the expression evaluates true, all incoming values including
+ * changes in unavail state are ignored, with the stored value being re-emitted each time.
+ */
+class LatchFilter extends TransformState {
+  constructor({ engine, path, args: { condition = {} } }) {
+    super();
+
+    this.engine = engine;
+    this.conditionExpression = condition.compiledExpression;
+    this.conditionSources = engine.expressionService.expressionTriggers(`${path}.condition`);
+  }
+
+  static op = 'latch';
+
+  static create(args) {
+    return new LatchFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const expression = _.get(defn.args, 'condition', defn.args[defn.func] ?? '').toString();
+    const compiledExpression = configUtil.compileExpression(expression, this.op);
+
+    const condition = { expression, compiledExpression };
+
+    defn.args = { condition };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return configUtil.getExpressions(body, { ...info, field: 'condition' }, true);
+  }
+
+  update(context, value, time) {
+    if (this.checkConditionUnavail(context, value, time)) {
+      return;
+    }
+
+    if (this.checkCondition(context, value, time)) {
+      if (this.available) {
+        this.lastSuppliedValue = value;
+        this.lastSampleTime = time;
+
+        this.emitUpdate(context);
+      } else {
+        this.emit('unavailable', this.valueTime, context);
+      }
+      return;
+    }
+
+    if (value === 'UNAVAILABLE') {
+      this.setUnavailable(context, time);
+    } else {
+      super.update(context, value, time);
+    }
+  }
+
+  checkConditionUnavail(context, value, time) {
+    const unavailTerm = _.reduce(this.conditionSources, (res, name) => {
+      const state = this.engine.getState(name);
+      return res || !state || !state.available;
+    }, false);
+
+    if (unavailTerm) {
+      this.setUnavailable(context, time);
+      this.valueTime = time;
+      return true;
+    }
+
+    return false;
+  }
+
+  checkCondition(context, value, time) {
+    try {
+      let scope = this.engine.currentState();
+      if (!this.origin) {
+        scope = { ...scope, this: value };
+      }
+      return this.conditionExpression.evaluate(scope);
+    } catch (err) {
+      // Probably a type error in one of the arguments.
+      this.recordError(context, err, time);
+      this.setUnavailable(context, time);
+      this.valueTime = time;
+      return true;
+    }
+  }
+}
+
+module.exports = LatchFilter;

package/lib/transform/latchValue.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Latches an incoming value until the reset condition is met
+ *
+ * If the latch is in an open state, the first incoming value will close the latch,
+ * and for every subseqeunt incoming value, the latch will re-emit its held value.
+ *
+ * The latch has additional options to either delay closing the latch until the incoming
+ * value is different than the previous observed value, and to set its held value to a
+ * specified default whenever the reset condition is active.
+ */
+class LatchValueFilter extends TransformState {
+  constructor({ engine, path, args }) {
+    super();
+
+    this.engine = engine;
+    this.resetExpression = args.reset?.compiledExpression;
+    this.resetSources = engine.expressionService.expressionTriggers(`${path}.reset`);
+    this.latchOnChange = args.latchOnChange;
+
+    this.hasResetValue = args.resetValue !== undefined;
+    if (this.hasResetValue) {
+      this.resetValue = args.resetValue;
+      this.defaultValue = this.resetValue;
+    }
+
+    this.initReset();
+  }
+
+  static op = 'latch-value';
+
+  static create(args) {
+    return new LatchValueFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, this.op, {
+      optional: true,
+      availableAttributes: ['reset', 'reset-value', 'latch-on-change'],
+    });
+
+    let latchOnChange = _.get(defn.args, 'latch-on-change');
+    if (!_.isUndefined(latchOnChange)) {
+      latchOnChange = configUtil.parseBool(latchOnChange);
+    }
+
+    const resetValue = _.get(defn.args, 'reset-value');
+
+    let reset = _.get(defn.args, 'reset');
+    if (!_.isUndefined(reset)) {
+      try {
+        const expression = reset.toString();
+        const compiledExpression = configUtil.compileExpression(expression, this.op);
+        reset = { expression, compiledExpression };
+      } catch (err) {
+        configUtil.throwConfigError(`Problem evaluating expression: ${err.message}`, this.op);
+      }
+    }
+
+    defn.args = { latchOnChange, reset, resetValue };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return configUtil.getExpressions(body, { ...info, field: 'reset' });
+  }
+
+  initReset() {
+    this.value = this.defaultValue;
+    this.previousValue = this.defaultValue;
+    this.previousInputValue = this.defaultValue;
+    this.latchValue = this.defaultValue;
+    this.open = true;
+  }
+
+  filter(context, value, time) {
+    let resetResult = false;
+
+    if (this.resetExpression) {
+      const localState = { this: this.value };
+      const unavailTerm = this.resetSources.reduce((res, name) => {
+        const state = this.engine.getState(name);
+        localState[name] = state?.value;
+        return res || !state || !state.available;
+      }, false);
+
+      if (!unavailTerm && this.resetExpression.evaluate(localState)) {
+        this.open = true;
+        resetResult = true;
+      }
+    }
+
+    if (this.open) {
+      let changed = this.latchValue !== value;
+      if (this.hasResetValue && !this.latchOnChange) {
+        changed = this.value !== value;
+      }
+
+      const commitValue = resetResult && this.hasResetValue ? this.resetValue : value;
+      this.latchValue = value;
+      if (resetResult || changed) {
+        this.commitValue(context, commitValue, time);
+      }
+
+      if (!this.latchOnChange || changed) {
+        this.open = resetResult;
+      }
+    }
+  }
+}
+
+module.exports = LatchValueFilter;

package/lib/transform/logicAnd.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Performs logical AND with incoming value and the result of a pre-parsed mathjs expression.
+ *
+ * Filter must be provided with the backing engine to have access to current variable states, which can
+ * be referenced in expressions by name.
+ */
+class LogicAndFilter extends TransformState {
+  constructor({ engine, path, args: { compiledExpression } }) {
+    super();
+
+    this.engine = engine;
+    this.expression = compiledExpression;
+    this.selfSources = engine.expressionService.expressionTriggers(path);
+  }
+
+  static op = 'logic-and';
+
+  static opAliases = ['and'];
+
+  static create(args) {
+    return new LogicAndFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const expression = (defn.args[defn.func] ?? '').toString();
+    const compiledExpression = configUtil.compileExpression(expression, this.op);
+
+    defn.args = { expression, compiledExpression };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return configUtil.getExpressions(body, info);
+  }
+
+  filter(context, value, time) {
+    const localState = {};
+    const unavailTerm = _.reduce(this.selfSources, (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;
+    }
+
+    if (!value) {
+      this.commitValue(context, false, time);
+    } else {
+      try {
+        this.commitValue(context, this.expression.evaluate(localState), time);
+      } catch (err) {
+        // Probably a type error in one of the arguments.
+        this.recordError(context, err, time);
+        this.setUnavailable(context, time);
+      }
+    }
+  }
+}
+
+module.exports = LogicAndFilter;

package/lib/transform/logicOr.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Performs logical OR with incoming value and the result of a pre-parsed mathjs expression.
+ *
+ * Filter must be provided with the backing engine to have access to current variable states, which can
+ * be referenced in expressions by name.
+ */
+class LogicOrFilter extends TransformState {
+  constructor({ engine, path, args: { compiledExpression } }) {
+    super();
+
+    this.engine = engine;
+    this.expression = compiledExpression;
+    this.selfSources = engine.expressionService.expressionTriggers(path);
+  }
+
+  static op = 'logic-or';
+
+  static opAliases = ['or'];
+
+  static create(args) {
+    return new LogicOrFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const expression = (defn.args[defn.func] ?? '').toString();
+    const compiledExpression = configUtil.compileExpression(expression, this.op);
+
+    defn.args = { expression, compiledExpression };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return configUtil.getExpressions(body, info);
+  }
+
+  filter(context, value, time) {
+    const localState = {};
+    const unavailTerm = _.reduce(this.selfSources, (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;
+    }
+
+    if (value) {
+      this.commitValue(context, true, time);
+    } else {
+      try {
+        this.commitValue(context, this.expression.evaluate(localState), time);
+      } catch (err) {
+        // Probably a type error in one of the arguments.
+        this.recordError(context, err, time);
+        this.setUnavailable(context, time);
+      }
+    }
+  }
+}
+
+module.exports = LogicOrFilter;

package/lib/transform/map.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+class MapChain {
+  constructor(chain) {
+    this.chain = chain;
+    this.opResult = null;
+
+    const end = this.chain.chainEnd();
+    end.on('update', (value /* , valueTime, avail */) => {
+      this.opResult = value;
+    });
+    end.on('unavailable', (/* time */) => {
+      this.opResult = null;
+    });
+  }
+
+  update(context, value, time) {
+    this.chain.update(context, value, time);
+    return this.opResult;
+  }
+
+  probe(context, time) {
+    this.chain.probe(context, time);
+  }
+
+  probeOrForward(context, time) {
+    this.chain.probeOrForward(context, time);
+  }
+
+  setUnavailable(context, time) {
+    this.chain.setUnavailable(context, time);
+  }
+}
+
+/**
+ * Executes a subprogram (chain of transforms) for each element in an incoming update.
+ *
+ * Map is intended to work on updates that contain an array of data, and is one of the few transforms to
+ * be able to support arrays.  A separate transform chain instance will be maintained for each element
+ * in the array, with the assumption that the length of the incoming array will stay consistent.  If the
+ * length changes, all states will be discarded and new ones will be generated.
+ */
+class MapFilter extends TransformState {
+  constructor({ engine, /* path, rootPath, baseTransform, */ args: { transforms } }, builder) {
+    super();
+
+    this.chain = builder.createTransformChain(engine, transforms);
+
+    this.makeChain = () => {
+      return new MapChain(builder.createTransformChain(engine, transforms));
+    };
+
+    this.defaultValue = [];
+    this.initReset();
+  }
+
+  static op = 'map';
+
+  static create(args) {
+    return new MapFilter(args, args.builder);
+  }
+
+  static parseConfig(configUtil, defn) {
+    if (!_.isArray(defn.args)) {
+      configUtil.throwConfigError('map must contain a list of operations', this.op);
+    }
+
+    const transforms = configUtil.loadTransformList(defn.args, defn.path, false).transform;
+    defn.args = { transforms };
+  }
+
+  initReset() {
+    this.chainList = [];
+    this.value = [];
+  }
+
+  supportsPendingChanges() {
+    return this.chain.supportsPendingChanges();
+  }
+
+  updateChainList(size) {
+    if (this.chainList.length === size) {
+      return;
+    }
+
+    this.chainList = _.times(size, () => this.makeChain());
+  }
+
+  update(context, value, time) {
+    if (value === 'UNAVAILABLE') {
+      this.setUnavailable(context, time);
+    } else {
+      super.update(context, value, time);
+    }
+  }
+
+  filter(context, value, time) {
+    this.updateChainList(value.length);
+    const mappedValue = _.map(_.zip(value, this.chainList), ([subValue, chain]) => {
+      return chain.update(context, subValue, time);
+    });
+
+    this.commitValue(context, mappedValue, time);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = MapFilter;