rotatingMachine/src/state/stateBindings.js

/**
 * Thin adapter over the generalFunctions state machine emitter.
 * Holds no state of its own — exposes bind/unbind and the
 * shared definition of which states count as "operational" for
 * downstream measurement processing.
 */

const OPERATIONAL_STATES = [
  'operational',
  'accelerating',
  'decelerating',
  'warmingup',
];

/**
 * Attaches positionChange / stateChange listeners to a state machine.
 * Returns an idempotent teardown function. Both handlers are required —
 * the bindings encode the lifecycle contract between the FSM and the
 * specificClass orchestrator, so leaving one half wired is a bug.
 */
function bindStateEvents(ctx) {
  if (!ctx || !ctx.state || !ctx.state.emitter) {
    throw new Error('bindStateEvents: ctx.state.emitter is required');
  }
  const { state, onPositionChange, onStateChange } = ctx;
  if (typeof onPositionChange !== 'function' || typeof onStateChange !== 'function') {
    throw new Error('bindStateEvents: onPositionChange and onStateChange handlers are required');
  }

  state.emitter.on('positionChange', onPositionChange);
  state.emitter.on('stateChange', onStateChange);

  let removed = false;
  return function teardown() {
    if (removed) return;
    removed = true;
    state.emitter.off('positionChange', onPositionChange);
    state.emitter.off('stateChange', onStateChange);
  };
}

/**
 * True when the FSM is in a state that should accept measurement
 * updates and recompute predictions. Pure helper, accepts the state
 * machine instance so callers can pass a fake in tests.
 */
function isOperationalState(stateInstance) {
  if (!stateInstance || typeof stateInstance.getCurrentState !== 'function') {
    return false;
  }
  return OPERATIONAL_STATES.includes(stateInstance.getCurrentState());
}

module.exports = {
  bindStateEvents,
  isOperationalState,
  OPERATIONAL_STATES,
};