Use correct var for let

[rbdr/tomato-sauce] / lib / tomato_sauce.js

'use strict';

const Net = require('net');
const EventEmitter = require('events');

const Util = require('./util');

const internals = {
  // Interpret as Command Sequences.
  kEscape: new Buffer([0xFF, 0xF4, 0XFF, 0xFD, 0x06]), // IAC IP IAC DO TIMING_MARK
  kNAWSRequest: new Buffer([0xFF, 0xFD, 0X1F]), // IAC DO NAWS
  kNAWSResponse: new Buffer([0xFF, 0xFB, 0X1F, 0xFF, 0xFA, 0X1F]) // IAC WILL NAWS IAC SB NAWS
};

/**
 * A function that represents a screen, it is called frequently and should
 * return a string consisting of commands to run.
 *
 * @interface IScreen
 * @type function
 * @param {Number} modulation A number between 0 and 255 representing the current
 * step of the modulation
 * @param {Number} width The width of the screen
 * @param {Number} height The height of the screen
 * @param {IRenderer} renderer The renderer used to colorize the scfeen
 * @return {String} The commands used to render the screen elements
 */

/**
 * A function that represents a renderer, it should take in a color in RGB and
 * return a string with the appropriate code to colorize the terminal.
 *
 * @interface IRenderer
 * @type function
 * @param {Number} red The red component of the color between 0 and 255
 * @param {Number} green The green component of the color between 0 and 255
 * @param {Number} blue The green component of the color between 0 and 255
 * @return {String} The commands used to colorize the terminal
 */

/**
 * The main application for tomato sauce. Listens for connections and serves
 * random combinations of screens and renderers
 *
 * The main entry point is the `#run()` function.
 *
 * It emits a listening event that contains the server information on
 * the `server` key inside the `data` property of the event.
 *
 * It also emits an error event that contains the error information on
 * the `error` key inside the `data` property of the event.
 *
 * @class TomatoSauce
 * @extends EventEmitter
 *
 * @param {object} config the configuration object used to extend the properties.
 *
 * @property {Array<IScreen>} screens an array of screens available to serve
 * @property {Array<IRenderer>} renderers an array of renderers available to colorize
 * @property {Number} [port=9999] the port to listen on
 * @property {Number} [frequency=333] how often to update the screen
 * @property {Number} [modulation=5] number between 0-255 depicting current modulation step
 */
const TomatoSauce = class TomatoSauce extends EventEmitter {

  constructor(config = {}) {

    super();

    this.screens = [];
    this.renderers = [];

    // Defaults.
    this.port = 9999;
    this.frequency = 333;
    this.modulation = 5;

    Object.assign(this, config);
  }

  /**
   * Main entry point, initializes the server and binds events for connections
   *
   * @function run
   * @instance
   * @memberof TomatoSauce
   */
  run() {

    this._startServer();
    this._bindEvents();
  }

  // Creates a socket, server based on the configuration. Emits the
  // listening event when ready.

  _startServer() {

    const server = Net.createServer();
    this.server = server;
    server.listen(this.port, () => {

      this.emit('listening', {
        data: {
          server
        }
      });
    });
  }

  // Binds the connection and error events

  _bindEvents() {

    // Send the error event all the way up.
    this.server.on('error', (error) => {

      this.emit('error', {
        data: {
          error
        }
      });
    });

    // Send the error event all the way up.
    this.server.on('connection', (socket) => {

      this._renderScreen(socket);
    });
  }

  // Obtains viewport size, and initializes a random screen with a random
  // renderer, setting the required interval to draw.

  _renderScreen(socket) {

    const connectionData = {
      width: null,
      height: null,
      modulation: 0,
      screen: this._getScreen(),
      renderer: this._getRenderer(),
      socket
    };
    let interval = null;

    socket.write(internals.kNAWSRequest);

    socket.on('data', (data) => {

      if (data.slice(0, 6).compare(internals.kNAWSResponse) === 0) {
        connectionData.width = Util.parse16BitBuffer(data.slice(6, 8));
        connectionData.height = Util.parse16BitBuffer(data.slice(8, 10));

        socket.write('\x1B[2J'); // Clear the Screen (CSI 2 J)
        interval = setInterval(this._writeMessage.bind(this, connectionData), this.frequency);
      }

      if (data.compare(internals.kEscape) === 0) {
        socket.write('\n');
        clearInterval(interval);
        socket.end();
      }
    });
  }

  // Resets the cursor, gets a frame and sends it to the socket.

  _writeMessage(connectionData) {

    const payload = connectionData.screen(connectionData.modulation, connectionData.width, connectionData.height, connectionData.renderer);
    const message = `\x1B[1;1H${payload}`; // reset cursor position before payload

    connectionData.modulation = (connectionData.modulation + this.modulation) % 256;
    connectionData.socket.write(message);
  }

  _getScreen() {

    return Util.pickRandom(this.screens);
  }

  _getRenderer() {

    return Util.pickRandom(this.renderers);
  }
};

module.exports = TomatoSauce;