traffic-light/multi-traffic-light.js

  1. const {Light, TrafficLight} = require('./traffic-light');
  3. ///////////////
  5. /**
  6.  * A composite light that combines all composed lights.
  7.  * @memberof trafficLight
  8.  * @extends trafficLight.Light
  9.  */
  10. class MultiLight extends Light {
  12.   /**
  13.    * @param {trafficLight.Light[]} lights - Lights composed.
  14.    */
  15.   constructor(lights) {
  16.     super();
  17.     this.lights = lights;
  18.     // this.on and this.off might not reflect the underlying lights,
  19.     // just what the multi-light has been through
  20.   }
  22.   /** Toggles the lights. */
  23.   toggle() {
  24.     super.toggle();
  25.     this.lights.forEach(l => l.toggle());
  26.   }
  28.   /** Turns the lights on. */
  29.   turnOn() {
  30.     super.turnOn();
  31.     this.lights.forEach(l => l.turnOn());
  32.   }
  34.   /** Turns the lights off. */
  35.   turnOff() {
  36.     super.turnOff();
  37.     this.lights.forEach(l => l.turnOff());
  38.   }
  40. }
  42. ///////////////
  44. let dummyLight = new Light();
  46. ///////////////
  48. /**
  49.  * A composite traffic light that combines all composed traffic lights.
  50.  * Does not track or raise any `enabled` or `disabled` events for the composed
  51.  * traffic lights.
  52.  * @memberof trafficLight
  53.  * @extends trafficLight.TrafficLight
  54.  */
  55. class MultiTrafficLight extends TrafficLight {
  57.   /**
  58.    * @param {trafficLight.TrafficLight[]} trafficLights - Traffic lights composed.
  59.    */
  60.   constructor(trafficLights) {
  61.     super(dummyLight, dummyLight, dummyLight);
  62.     this.trafficLights = trafficLights;
  63.   }
  65.   get trafficLights() {
  66.     return this._trafficLights;
  67.   }
  68.   set trafficLights(trafficLights) {
  69.     this._trafficLights = trafficLights;
  70.     this.red    = new MultiLight(trafficLights.map(tl => tl.red));    // eslint-disable-line no-multi-spaces
  71.     this.yellow = new MultiLight(trafficLights.map(tl => tl.yellow));
  72.     this.green  = new MultiLight(trafficLights.map(tl => tl.green));  // eslint-disable-line no-multi-spaces
  73.   }
  75.   /**
  76.    * If any of the composed traffic lights is enabled.
  77.    * @type {boolean}
  78.    */
  79.   get isEnabled() {
  80.     return this._trafficLights.some(tl => tl.isEnabled);
  81.   }
  83. }
  85. ///////////////
  87. function unique(a) {
  88.   return [...new Set(a)];
  89. }
  91. ///////////////
  93. /**
  94.  * A composite traffic light with a flexible way to select which composed
  95.  * traffic lights are active or in use.
  96.  * @memberof trafficLight
  97.  * @extends trafficLight.TrafficLight
  98.  */
  99. class FlexMultiTrafficLight extends TrafficLight {
  101.   /**
  102.    * Creates a new instance of this class.
  103.    * Starts off using the first traffic light in the provided `trafficLights`.
  104.    * Tries to check out the provided traffic lights.
  105.    * @param {trafficLight.TrafficLight[]} trafficLights - Traffic lights composed.
  106.    */
  107.   constructor(trafficLights) {
  108.     super(dummyLight, dummyLight, dummyLight);
  109.     this.activeMultiTrafficLight = new MultiTrafficLight([]);
  110.     this.allTrafficLights = trafficLights.filter(tl => tl.checkOut());
  111.     this.allTrafficLights.forEach(tl => this._subscribe(tl));
  112.     this.use([0]);
  113.   }
  115.   /**
  116.    * Adds a traffic light to the composite.
  117.    * Tries to exclusively check it out first and because of that won't add
  118.    * any duplicates.
  119.    * @param {trafficLight.TrafficLight} trafficLight - Traffic light to add.
  120.    *   Must not be null.
  121.    */
  122.   add(trafficLight) {
  123.     if (!trafficLight.checkOut()) return;
  124.     let wasEnabled = this.isEnabled;
  125.     this.allTrafficLights.push(trafficLight);
  126.     this._subscribe(trafficLight);
  127.     if (this.activeTrafficLights.length === 0) {
  128.       this.use([0]);
  129.     }
  130.     if (!wasEnabled && this.isEnabled) {
  131.       this.emit('enabled');
  132.     }
  133.   }
  135.   // returns an array of the tuple: (traffic light, original index)
  136.   get enabledTrafficLights() {
  137.     return (
  138.       this.allTrafficLights
  139.         .map((tl, i) => [tl, i])
  140.         .filter(([tl, _]) => tl.isEnabled));
  141.   }
  143.   // returns an array of the tuple: (traffic light, original index)
  144.   get activeTrafficLights() {
  145.     return (
  146.       this.enabledTrafficLights
  147.         .filter(([tl, _], i) => this.activeIndexes.indexOf(i) >= 0));
  148.   }
  150.   /**
  151.    * Selects which traffic lights to use given their indexes (0-based),
  152.    * only considering enabled traffic lights.
  153.    * Indexes wrap around from the last to the first.
  154.    * @param {number[]} activeIndexes - Traffic light indexes to use.
  155.    *   Must not be empty.
  156.    */
  157.   use(activeIndexes) {
  158.     this._setIndexes(activeIndexes);
  159.     this.activeMultiTrafficLight.trafficLights = this.activeTrafficLights.map(([tl, _]) => tl);
  160.     this.red = this.activeMultiTrafficLight.red;
  161.     this.yellow = this.activeMultiTrafficLight.yellow;
  162.     this.green = this.activeMultiTrafficLight.green;
  163.   }
  165.   _setIndexes(activeIndexes) {
  166.     let tlsEnabled = this.enabledTrafficLights.map(([tl, _]) => tl);
  167.     let l = tlsEnabled.length;
  168.     if (l > 0) {
  169.       activeIndexes = unique(activeIndexes.map(i => i < 0 ? l + i : i % l));
  170.     } else {
  171.       activeIndexes = [];
  172.     }
  173.     activeIndexes.sort();
  174.     this.activeIndexes = activeIndexes;
  175.     this.indexes = this.activeTrafficLights.map(([_, i]) => i);
  176.   }
  178.   _subscribe(tl) {
  179.     tl.on('enabled', () => this._enabled(tl));
  180.     tl.on('disabled', () => this._disabled(tl));
  181.   }
  183.   _enabled(tl) {
  184.     if (this.enabledTrafficLights.length === 1) {
  185.       // the first traffic light is enabled; all were disabled before
  186.       this.use([0]);
  187.       this.emit('enabled');
  188.     } else {
  189.       // recalculate indexes
  190.       let tlIndex = this.allTrafficLights.indexOf(tl);
  191.       let newActiveIndexes = this.indexes.map((i, j) => this.activeIndexes[j] + (tlIndex < i ? 1 : 0));
  192.       this.use(newActiveIndexes);
  193.     }
  194.   }
  196.   _disabled(tl) {
  198.     if (!this.isEnabled) {
  199.       // the only enabled traffic light was disabled
  200.       this.use([]);
  201.       this.emit('disabled'); // 'disabled' instead of 'interrupted'
  202.       return;
  203.     }
  205.     // recalculate indexes
  206.     let tlIndex = this.allTrafficLights.indexOf(tl);
  207.     let activeTrafficLightWasDisabled = this.indexes.indexOf(tlIndex) >= 0;
  209.     let newActiveIndexes = this.indexes
  210.       .map((i, j) => tlIndex === i ? -1 : (this.activeIndexes[j] - (tlIndex < i ? 1 : 0)))
  211.       .filter(i => i >= 0);
  212.     if (newActiveIndexes.length === 0) {
  213.       newActiveIndexes = [0]; // re-assign
  214.     }
  215.     this.use(newActiveIndexes);
  217.     if (activeTrafficLightWasDisabled) {
  218.       /**
  219.        * Interrupted event. In a `FlexMultiTrafficLight`, if an active traffic
  220.        * light gets disabled, and there are still enabled traffic lights left,
  221.        * this event is raised. If no more traffic lights are enabled,
  222.        * then the `disabled` event is raised.
  223.        * @event trafficLight.FlexMultiTrafficLight#interrupted
  224.        */
  225.       this.emit('interrupted');
  226.     }
  228.   }
  230.   /**
  231.    * Gets the traffic light indexes that are in use.
  232.    * If there are no traffic lights in use, or no traffic lights are useable,
  233.    * returns an empty array.
  234.    * @returns {number[]} The traffic light indexes that are in use.
  235.    */
  236.   using() {
  237.     return this.activeIndexes;
  238.   }
  240.   /**
  241.    * Selects the next traffic light to use, going back to the first one if
  242.    * the currently selected one is the last.
  243.    * Also works with multiple selected traffic lights, moving all to the next.
  244.    */
  245.   next() {
  246.     this._move(+1);
  247.   }
  249.   /**
  250.    * Selects the previous traffic light to use, going to the last one if
  251.    * the currently selected one is the first.
  252.    * Also works with multiple selected traffic lights, moving all to the previous.
  253.    */
  254.   previous() {
  255.     this._move(-1);
  256.   }
  258.   /**
  259.    * Selects the nearest traffic light to use, remembering the direction
  260.    * of movement (forwards or backwards).
  261.    * Also works with multiple selected traffic lights, moving all to the nearest,
  262.    * following a single direction (so it's possible to wrap around at the last
  263.    * if both the first and last indexes are in use).
  264.    */
  265.   near() {
  266.     if (this.activeIndexes.length === 0) {
  267.       this.use([0]);
  268.       return;
  269.     }
  271.     let lastIndex = this.enabledTrafficLights.length - 1;
  272.     if (this.activeIndexes.indexOf(0) >= 0) {
  273.       this.direction = +1;
  274.     } else if (this.activeIndexes.indexOf(lastIndex) >= 0) {
  275.       this.direction = -1;
  276.     }
  278.     this._move(this.direction || +1);
  279.   }
  281.   _move(direction) {
  282.     if (this.activeIndexes.length > 0) {
  283.       this.use(this.activeIndexes.map(i => i + direction));
  284.     } else {
  285.       this.use([0]);
  286.     }
  287.   }
  289.   /**
  290.    * Selects the last traffic light to use.
  291.    */
  292.   last() {
  293.     this.use([this.enabledTrafficLights.length - 1]);
  294.   }
  296.   /**
  297.    * Selects all traffic lights to use simultaneously.
  298.    */
  299.   useAll() {
  300.     this.use(this.enabledTrafficLights.map((_, i) => i));
  301.   }
  303.   /**
  304.    * Resets all active traffic lights.
  305.    */
  306.   reset() {
  307.     this.activeMultiTrafficLight.reset();
  308.   }
  310.   /**
  311.    * If there are composed traffic lights and any of them is enabled.
  312.    * @type {boolean}
  313.    */
  314.   get isEnabled() {
  315.     return this.allTrafficLights.length > 0 &&
  316.       this.allTrafficLights.some(tl => tl.isEnabled);
  317.   }
  319.   toString() {
  320.     return `multi (${this.enabledTrafficLights.length};${this.activeTrafficLights.length})`;
  321.   }
  323. }
  325. ///////////////
  327. module.exports = {
  328.   MultiLight, MultiTrafficLight, FlexMultiTrafficLight
  329. };