Bump version to 2.0.0

Signed-off-by: Paris Kasidiaris <paris@sourcelair.com>

.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["es2015"]
+}

.gitignore

@@ -10,3 +10,4 @@ Makefile.gyp
 example/*.log
 docs/
 npm-debug.log
+/.idea/

AUTHORS

@@ -4,6 +4,7 @@ Alessandro Nadalin <alessandro.nadalin@gmail.com>
 Alexander Olsson <noseglid@gmail.com>
 Antonis Kalipetis <akalipetis@sourcelair.com>
 Anton Skshidlevsky <meefik@gmail.com>
+Anton Yurovskykh <anton.yurovskykh@gmail.com>
 Austin Robertson <austinrobertson@gmail.com>
 ayapi <colors.aya@gmail.com>
 Benjamin Fischer <benjamin.fischer@rwth-aachen.de>
@@ -13,6 +14,7 @@ Daniel Imms <daimms@microsoft.com>
 Daniel Risacher <drisacher@gmail.com>
 Dan Kaplun <dbkaplun@twitch.tv>
 Darin Morrison <freebroccolo@users.noreply.github.com>
+imoses <ido@twiggle.com>
 Jean Bruenn <himself@jeanbruenn.info>
 Jörg Breitbart <jerch@rockborn.de>
 Paris Kasidiaris <pariskasidiaris@gmail.com>

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014, sourceLair Limited (https://github.com/sourcelair/)
+Copyright (c) 2014-2016, SourceLair Private Company (https://www.sourcelair.com)
 Copyright (c) 2012-2013, Christopher Jeffrey (https://github.com/chjj/)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

README.md

@@ -23,7 +23,7 @@ It enables applications to provide fully featured terminals to their users and c
 Xterm.js is used in several world-class applications to provide great terminal experiences.
 
 - [**SourceLair**](https://www.sourcelair.com/): In-browser IDE that provides its users with fully-featured Linux terminals based on xterm.js
-- [**Microsoft Visual Studio Code**](http://code.visualstudio.com/): Modern, versatile, powerful and open source code editor that provides integrated terminal based on xterm.js
+- [**Microsoft Visual Studio Code**](http://code.visualstudio.com/): Modern, versatile and powerful open source code editor that provides an integrated terminal based on xterm.js
 
 Do you use xterm.js in your application as well? Please [open a Pull Request](https://github.com/sourcelair/xterm.js/pulls) to include it here. We would love to have it in our list.
 
@@ -49,7 +49,7 @@ npm install
 npm start
 ```
 
-Then open http://0.0.0.0:3000 in a web browser (use http://127.0.0.1:3000 is running under Windows).
+Then open http://0.0.0.0:3000 in a web browser (use http://127.0.0.1:3000 if running under Windows).
 
 ## Addons
 
@@ -58,7 +58,7 @@ Addons are JavaScript modules that attach functions to the `Terminal` prototype
 To use an addon, just include the JavaScript file after xterm.js and before the `Terminal` object has been instantiated. The function should then be exposed on the `Terminal` object:
 
 ```html
-<script src="node_modules/src/xterm.js"></script>
+<script src="node_modules/dist/xterm.js"></script>
 <script src="node_modules/addons/fit/fit.js"></script>
 ```
 

addons/attach/attach.js

@@ -21,7 +21,7 @@
     /*
      * Plain browser environment
      */
-    attach(this.Xterm);
+    attach(window.Terminal);
   }
 })(function (Xterm) {
   'use strict';

addons/fit/fit.js

@@ -26,7 +26,7 @@
     /*
      * Plain browser environment
      */
-    fit(this.Xterm);
+    fit(window.Terminal);
   }
 })(function (Xterm) {
   /**

addons/fullscreen/fullscreen.js

@@ -25,7 +25,7 @@
     /*
      * Plain browser environment
      */
-    fullscreen(this.Xterm);
+    fullscreen(window.Terminal);
   }
 })(function (Xterm) {
   var exports = {};

addons/linkify/linkify.js

@@ -13,7 +13,7 @@
     /*
      * Plain browser environment
      */
-    linkify(this.Xterm);
+    linkify(window.Terminal);
   }
 })(function (Xterm) {
   'use strict';

bin/build

@@ -0,0 +1,38 @@
+#! /usr/bin/env node
+
+var child_process = require('child_process');
+var fs = require('fs');
+
+var buildDir = process.env.BUILD_DIR || 'build';
+
+if (!fs.existsSync(buildDir)){
+    fs.mkdirSync(buildDir);
+}
+
+// Add `node_modules/.bin` to PATH
+process.env.PATH = process.cwd() + '/node_modules/.bin:' + process.env.PATH;
+
+console.log('Building xterm.js into ' + buildDir);
+
+// Build ES2015 modules into ES5 form, then concatenate them,
+// then remove unused require calls and save in output file with source map.
+console.log('  - Building ' + buildDir + '/xterm.js...');
+
+var jsBuildCmd = 'browserify src/xterm.js -s Terminal -t [ babelify --presets [ es2015 ] ] --debug | ';
+jsBuildCmd += 'derequire | exorcist ' + buildDir + '/xterm.js.map > ' + buildDir + '/xterm.js';
+
+var jsBuildProcess = child_process.execSync(jsBuildCmd);
+
+if (jsBuildProcess.status) {
+  console.log(jsBuildProcess.error);
+}
+
+console.log('    OK.');
+
+// Copy CSS into $BUILD_DIR
+console.log('  - Building ' + buildDir + '/xterm.css...');
+
+fs.createReadStream('src/xterm.css').pipe(
+  fs.createWriteStream(buildDir + '/xterm.css')
+);
+console.log('    OK.');

bin/prepare-release

@@ -3,6 +3,8 @@
 # Usage: ./bin/prepare-release x.y.z
 # x.y.z should be semver (e.g. 1.0.0)
 
+set -e
+
 NEW_VERSION=$1
 CURRENT_PACKAGE_JSON_VERSION=$(cat package.json \
   | grep version \
@@ -17,12 +19,16 @@ CURRENT_BOWER_JSON_VERSION=$(cat bower.json \
   | sed 's/[",]//g' \
   | tr -d '[[:space:]]')
 
-# Update version in package.json and bower.json
-sed -i "s/\"version\": \"$CURRENT_PACKAGE_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" package.json
-sed -i "s/\"version\": \"$CURRENT_BOWER_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" bower.json
+# Build xterm.js into `dist`
+export BUILD_DIR=dist
+./bin/build
 
 # Update AUTHORS file
 sh bin/generate-authors
 
+# Update version in package.json and bower.json
+sed -i "s/\"version\": \"$CURRENT_PACKAGE_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" package.json
+sed -i "s/\"version\": \"$CURRENT_BOWER_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" bower.json
+
 git commit -S -s -a -m "Bump version to $NEW_VERSION"
 git tag $NEW_VERSION

bin/release

@@ -3,6 +3,8 @@
 # Usage: ./bin/release x.y.z
 # x.y.z should be semver (e.g. 1.0.0)
 
+set -e
+
 if [ -z "$1" ];
   then
     echo "No version supplied. Please a version argument\n"

bower.json

@@ -1,5 +1,5 @@
 {
   "name": "xterm.js",
-  "version": "1.1.3",
+  "version": "2.0.0",
   "ignore": ["demo", "test", ".gitignore"]
 }

demo/app.js

@@ -7,7 +7,7 @@ var pty = require('pty.js');
 var terminals = {},
     logs = {};
 
-app.use('/src', express.static(__dirname + '/../src'));
+app.use('/build', express.static(__dirname + '/../build'));
 app.use('/addons', express.static(__dirname + '/../addons'));
 
 app.get('/', function(req, res){

demo/index.html

@@ -2,11 +2,11 @@
 <html>
     <head>
         <title>xterm.js demo</title>
-        <link rel="stylesheet" href="../src/xterm.css" />
+        <link rel="stylesheet" href="../build/xterm.css" />
         <link rel="stylesheet" href="../addons/fullscreen/fullscreen.css" />
         <link rel="stylesheet" href="style.css" />
       	<script src="https://cdnjs.cloudflare.com/ajax/libs/fetch/1.0.0/fetch.min.js"></script>
-        <script src="../src/xterm.js" ></script>
+        <script src="../build/xterm.js" ></script>
         <script src="../addons/attach/attach.js" ></script>
         <script src="../addons/fit/fit.js" ></script>
         <script src="../addons/fullscreen/fullscreen.js" ></script>

jsdoc.json

@@ -2,6 +2,7 @@
   "source": {
     "include": [
       "src/xterm.js",
+      "src/handlers/Clipboard.js",
       "addons/attach/attach.js",
       "addons/fit/fit.js",
       "addons/fullscreen/fullscreen.js",

package.json

@@ -1,28 +1,36 @@
 {
   "name": "xterm",
-  "version": "1.1.3",
+  "version": "2.0.0",
   "ignore": [
     "demo",
     "test",
     ".gitignore"
   ],
-  "main": "src/xterm.js",
+  "main": "dist/xterm.js",
   "repository": "https://github.com/sourcelair/xterm.js",
   "license": "MIT",
   "devDependencies": {
+    "babel-core": "6.14.0",
+    "babel-preset-es2015": "6.14.0",
+    "babelify": "^7.3.0",
+    "browserify": "^13.1.0",
     "chai": "3.5.0",
+    "derequire": "^2.0.3",
     "docdash": "0.4.0",
+    "exorcist": "^0.4.0",
     "express": "4.13.4",
     "express-ws": "2.0.0-rc.1",
     "glob": "^7.0.5",
     "jsdoc": "3.4.0",
     "mocha": "2.5.3",
+    "nodemon": "1.10.2",
     "pty.js": "0.3.1",
     "sleep": "^3.0.1"
   },
   "scripts": {
-    "start": "node demo/app",
-    "test": "mocha --recursive",
-    "build:docs": "node_modules/.bin/jsdoc -c jsdoc.json"
+    "start": "nodemon --watch src --watch addons --exec bash -c './bin/build && node demo/app'",
+    "test": "mocha --recursive --compilers js:babel-core/register",
+    "build:docs": "jsdoc -c jsdoc.json",
+    "build": "./bin/build"
   }
 }

src/CompositionHelper.js

@@ -0,0 +1,201 @@
+/**
+ * xterm.js: xterm, in the browser
+ * Copyright (c) 2014-2016, SourceLair Private Company (www.sourcelair.com (MIT License)
+ */
+
+/**
+ * Encapsulates the logic for handling compositionstart, compositionupdate and compositionend
+ * events, displaying the in-progress composition to the UI and forwarding the final composition
+ * to the handler.
+ * @param {HTMLTextAreaElement} textarea The textarea that xterm uses for input.
+ * @param {HTMLElement} compositionView The element to display the in-progress composition in.
+ * @param {Terminal} terminal The Terminal to forward the finished composition to.
+ */
+function CompositionHelper(textarea, compositionView, terminal) {
+  this.textarea = textarea;
+  this.compositionView = compositionView;
+  this.terminal = terminal;
+
+  // Whether input composition is currently happening, eg. via a mobile keyboard, speech input
+  // or IME. This variable determines whether the compositionText should be displayed on the UI.
+  this.isComposing = false;
+
+  // The input currently being composed, eg. via a mobile keyboard, speech input or IME.
+  this.compositionText = null;
+
+  // The position within the input textarea's value of the current composition.
+  this.compositionPosition = { start: null, end: null };
+
+  // Whether a composition is in the process of being sent, setting this to false will cancel
+  // any in-progress composition.
+  this.isSendingComposition = false;
+}
+
+/**
+ * Handles the compositionstart event, activating the composition view.
+ */
+CompositionHelper.prototype.compositionstart = function() {
+  this.isComposing = true;
+  this.compositionPosition.start = this.textarea.value.length;
+  this.compositionView.textContent = '';
+  this.compositionView.classList.add('active');
+};
+
+/**
+ * Handles the compositionupdate event, updating the composition view.
+ * @param {CompositionEvent} ev The event.
+ */
+CompositionHelper.prototype.compositionupdate = function(ev) {
+  this.compositionView.textContent = ev.data;
+  this.updateCompositionElements();
+  var self = this;
+  setTimeout(function() {
+    self.compositionPosition.end = self.textarea.value.length;
+  }, 0);
+};
+
+/**
+ * Handles the compositionend event, hiding the composition view and sending the composition to
+ * the handler.
+ */
+CompositionHelper.prototype.compositionend = function() {
+  this.finalizeComposition(true);
+};
+
+/**
+ * Handles the keydown event, routing any necessary events to the CompositionHelper functions.
+ * @return Whether the Terminal should continue processing the keydown event.
+ */
+CompositionHelper.prototype.keydown = function(ev) {
+  if (this.isComposing || this.isSendingComposition) {
+    if (ev.keyCode === 229) {
+      // Continue composing if the keyCode is the "composition character"
+      return false;
+    } else if (ev.keyCode === 16 || ev.keyCode === 17 || ev.keyCode === 18) {
+      // Continue composing if the keyCode is a modifier key
+      return false;
+    } else {
+      // Finish composition immediately. This is mainly here for the case where enter is
+      // pressed and the handler needs to be triggered before the command is executed.
+      this.finalizeComposition(false);
+    }
+  }
+
+  if (ev.keyCode === 229) {
+    // If the "composition character" is used but gets to this point it means a non-composition
+    // character (eg. numbers and punctuation) was pressed when the IME was active.
+    this.handleAnyTextareaChanges();
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Finalizes the composition, resuming regular input actions. This is called when a composition
+ * is ending.
+ * @param {boolean} waitForPropogation Whether to wait for events to propogate before sending
+ *   the input. This should be false if a non-composition keystroke is entered before the
+ *   compositionend event is triggered, such as enter, so that the composition is send before
+ *   the command is executed.
+ */
+CompositionHelper.prototype.finalizeComposition = function(waitForPropogation) {
+  this.compositionView.classList.remove('active');
+  this.isComposing = false;
+  this.clearTextareaPosition();
+
+  if (!waitForPropogation) {
+    // Cancel any delayed composition send requests and send the input immediately.
+    this.isSendingComposition = false;
+    var input = this.textarea.value.substring(this.compositionPosition.start, this.compositionPosition.end);
+    this.terminal.handler(input);
+  } else {
+    // Make a deep copy of the composition position here as a new compositionstart event may
+    // fire before the setTimeout executes.
+    var currentCompositionPosition = {
+      start: this.compositionPosition.start,
+      end: this.compositionPosition.end,
+    }
+
+    // Since composition* events happen before the changes take place in the textarea on most
+    // browsers, use a setTimeout with 0ms time to allow the native compositionend event to
+    // complete. This ensures the correct character is retrieved, this solution was used
+    // because:
+    // - The compositionend event's data property is unreliable, at least on Chromium
+    // - The last compositionupdate event's data property does not always accurately describe
+    //   the character, a counter example being Korean where an ending consonsant can move to
+    //   the following character if the following input is a vowel.
+    var self = this;
+    this.isSendingComposition = true;
+    setTimeout(function () {
+      // Ensure that the input has not already been sent
+      if (self.isSendingComposition) {
+        self.isSendingComposition = false;
+        var input;
+        if (self.isComposing) {
+          // Use the end position to get the string if a new composition has started.
+          input = self.textarea.value.substring(currentCompositionPosition.start, currentCompositionPosition.end);
+        } else {
+          // Don't use the end position here in order to pick up any characters after the
+          // composition has finished, for example when typing a non-composition character
+          // (eg. 2) after a composition character.
+          input = self.textarea.value.substring(currentCompositionPosition.start);
+        }
+        self.terminal.handler(input);
+      }
+    }, 0);
+  }
+};
+
+/**
+ * Apply any changes made to the textarea after the current event chain is allowed to complete.
+ * This should be called when not currently composing but a keydown event with the "composition
+ * character" (229) is triggered, in order to allow non-composition text to be entered when an
+ * IME is active.
+ */
+CompositionHelper.prototype.handleAnyTextareaChanges = function() {
+  var oldValue = this.textarea.value;
+  var self = this;
+  setTimeout(function() {
+    // Ignore if a composition has started since the timeout
+    if (!self.isComposing) {
+      var newValue = self.textarea.value;
+      var diff = newValue.replace(oldValue, '');
+      if (diff.length > 0) {
+        self.terminal.handler(diff);
+      }
+    }
+  }, 0);
+};
+
+/**
+ * Positions the composition view on top of the cursor and the textarea just below it (so the
+ * IME helper dialog is positioned correctly).
+ */
+CompositionHelper.prototype.updateCompositionElements = function(dontRecurse) {
+  if (!this.isComposing) {
+    return;
+  }
+  var cursor = this.terminal.element.querySelector('.terminal-cursor');
+  if (cursor) {
+    this.compositionView.style.left = cursor.offsetLeft + 'px';
+    this.compositionView.style.top = cursor.offsetTop + 'px';
+    var compositionViewBounds = this.compositionView.getBoundingClientRect();
+    this.textarea.style.left = cursor.offsetLeft + compositionViewBounds.width + 'px';
+    this.textarea.style.top = (cursor.offsetTop + cursor.offsetHeight) + 'px';
+  }
+  if (!dontRecurse) {
+    setTimeout(this.updateCompositionElements.bind(this, true), 0);
+  }
+};
+
+/**
+ * Clears the textarea's position so that the cursor does not blink on IE.
+ * @private
+ */
+CompositionHelper.prototype.clearTextareaPosition = function() {
+  this.textarea.style.left = '';
+  this.textarea.style.top = '';
+};
+
+export { CompositionHelper };

src/EventEmitter.js

@@ -0,0 +1,65 @@
+/**
+ * xterm.js: xterm, in the browser
+ * Copyright (c) 2014-2016, SourceLair Private Company (www.sourcelair.com (MIT License)
+ */
+
+function EventEmitter() {
+  this._events = this._events || {};
+}
+
+EventEmitter.prototype.addListener = function(type, listener) {
+  this._events[type] = this._events[type] || [];
+  this._events[type].push(listener);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.removeListener = function(type, listener) {
+  if (!this._events[type]) return;
+
+  var obj = this._events[type]
+  , i = obj.length;
+
+  while (i--) {
+    if (obj[i] === listener || obj[i].listener === listener) {
+      obj.splice(i, 1);
+      return;
+    }
+  }
+};
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+  if (this._events[type]) delete this._events[type];
+};
+
+EventEmitter.prototype.once = function(type, listener) {
+  var self = this;
+  function on() {
+    var args = Array.prototype.slice.call(arguments);
+    this.removeListener(type, on);
+    return listener.apply(this, args);
+  }
+  on.listener = listener;
+  return this.on(type, on);
+};
+
+EventEmitter.prototype.emit = function(type) {
+  if (!this._events[type]) return;
+
+  var args = Array.prototype.slice.call(arguments, 1)
+  , obj = this._events[type]
+  , l = obj.length
+  , i = 0;
+
+  for (; i < l; i++) {
+    obj[i].apply(this, args);
+  }
+};
+
+EventEmitter.prototype.listeners = function(type) {
+  return this._events[type] = this._events[type] || [];
+};
+
+export { EventEmitter };

src/Viewport.js

@@ -0,0 +1,114 @@
+/**
+ * xterm.js: xterm, in the browser
+ * Copyright (c) 2014-2016, SourceLair Private Company (www.sourcelair.com (MIT License)
+ */
+
+/**
+ * Represents the viewport of a terminal, the visible area within the larger buffer of output.
+ * Logic for the virtual scroll bar is included in this object.
+ * @param {Terminal} terminal The Terminal object.
+ * @param {HTMLElement} viewportElement The DOM element acting as the viewport
+ * @param {HTMLElement} charMeasureElement A DOM element used to measure the character size of
+ *   the terminal.
+ */
+function Viewport(terminal, viewportElement, scrollArea, charMeasureElement) {
+  this.terminal = terminal;
+  this.viewportElement = viewportElement;
+  this.scrollArea = scrollArea;
+  this.charMeasureElement = charMeasureElement;
+  this.currentRowHeight = 0;
+  this.lastRecordedBufferLength = 0;
+  this.lastRecordedViewportHeight = 0;
+
+  this.terminal.on('scroll', this.syncScrollArea.bind(this));
+  this.terminal.on('resize', this.syncScrollArea.bind(this));
+  this.viewportElement.addEventListener('scroll', this.onScroll.bind(this));
+
+  this.syncScrollArea();
+}
+
+/**
+ * Refreshes row height, setting line-height, viewport height and scroll area height if
+ * necessary.
+ * @param {number|undefined} charSize A character size measurement bounding rect object, if it
+ *   doesn't exist it will be created.
+ */
+Viewport.prototype.refresh = function(charSize) {
+  var size = charSize || this.charMeasureElement.getBoundingClientRect();
+  if (size.height > 0) {
+    var rowHeightChanged = size.height !== this.currentRowHeight;
+    if (rowHeightChanged) {
+      this.currentRowHeight = size.height;
+      this.viewportElement.style.lineHeight = size.height + 'px';
+      this.terminal.rowContainer.style.lineHeight = size.height + 'px';
+    }
+    var viewportHeightChanged = this.lastRecordedViewportHeight !== this.terminal.rows;
+    if (rowHeightChanged || viewportHeightChanged) {
+      this.lastRecordedViewportHeight = this.terminal.rows;
+      this.viewportElement.style.height = size.height * this.terminal.rows + 'px';
+    }
+    this.scrollArea.style.height = (size.height * this.lastRecordedBufferLength) + 'px';
+  }
+};
+
+/**
+ * Updates dimensions and synchronizes the scroll area if necessary.
+ */
+Viewport.prototype.syncScrollArea = function() {
+  if (this.lastRecordedBufferLength !== this.terminal.lines.length) {
+    // If buffer height changed
+    this.lastRecordedBufferLength = this.terminal.lines.length;
+    this.refresh();
+  } else if (this.lastRecordedViewportHeight !== this.terminal.rows) {
+    // If viewport height changed
+    this.refresh();
+  } else {
+    // If size has changed, refresh viewport
+    var size = this.charMeasureElement.getBoundingClientRect();
+    if (size.height !== this.currentRowHeight) {
+      this.refresh(size);
+    }
+  }
+
+  // Sync scrollTop
+  var scrollTop = this.terminal.ydisp * this.currentRowHeight;
+  if (this.viewportElement.scrollTop !== scrollTop) {
+    this.viewportElement.scrollTop = scrollTop;
+  }
+};
+
+/**
+ * Handles scroll events on the viewport, calculating the new viewport and requesting the
+ * terminal to scroll to it.
+ * @param {Event} ev The scroll event.
+ */
+Viewport.prototype.onScroll = function(ev) {
+  var newRow = Math.round(this.viewportElement.scrollTop / this.currentRowHeight);
+  var diff = newRow - this.terminal.ydisp;
+  this.terminal.scrollDisp(diff, true);
+};
+
+/**
+ * Handles mouse wheel events by adjusting the viewport's scrollTop and delegating the actual
+ * scrolling to `onScroll`, this event needs to be attached manually by the consumer of
+ * `Viewport`.
+ * @param {WheelEvent} ev The mouse wheel event.
+ */
+Viewport.prototype.onWheel = function(ev) {
+  if (ev.deltaY === 0) {
+    // Do nothing if it's not a vertical scroll event
+    return;
+  }
+  // Fallback to WheelEvent.DOM_DELTA_PIXEL
+  var multiplier = 1;
+  if (ev.deltaMode === WheelEvent.DOM_DELTA_LINE) {
+    multiplier = this.currentRowHeight;
+  } else if (ev.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
+    multiplier = this.currentRowHeight * this.terminal.rows;
+  }
+  this.viewportElement.scrollTop += ev.deltaY * multiplier;
+  // Prevent the page from scrolling when the terminal scrolls
+  ev.preventDefault();
+};
+
+export { Viewport };

src/handlers/Clipboard.js

@@ -0,0 +1,126 @@
+/**
+ * xterm.js: xterm, in the browser
+ * Copyright (c) 2016, SourceLair Private Company <www.sourcelair.com> (MIT License)
+ */
+
+/**
+ * Clipboard handler module. This module contains methods for handling all
+ * clipboard-related events appropriately in the terminal.
+ * @module xterm/handlers/Clipboard
+ */
+
+/**
+ * Prepares text copied from terminal selection, to be saved in the clipboard by:
+ *   1. stripping all trailing white spaces
+ *   2. converting all non-breaking spaces to regular spaces
+ * @param {string} text The copied text that needs processing for storing in clipboard
+ * @returns {string}
+ */
+function prepareTextForClipboard(text) {
+  var space = String.fromCharCode(32),
+      nonBreakingSpace = String.fromCharCode(160),
+      allNonBreakingSpaces = new RegExp(nonBreakingSpace, 'g'),
+      processedText = text.split('\n').map(function (line) {
+        // Strip all trailing white spaces and convert all non-breaking spaces
+        // to regular spaces.
+        var processedLine = line.replace(/\s+$/g, '').replace(allNonBreakingSpaces, space);
+
+        return processedLine;
+      }).join('\n');
+
+  return processedText;
+}
+
+/**
+ * Binds copy functionality to the given terminal.
+ * @param {ClipboardEvent} ev The original copy event to be handled
+ */
+function copyHandler (ev) {
+  var copiedText = window.getSelection().toString(),
+      text = prepareTextForClipboard(copiedText);
+
+  ev.clipboardData.setData('text/plain', text);
+  ev.preventDefault(); // Prevent or the original text will be copied.
+}
+
+/**
+ * Redirect the clipboard's data to the terminal's input handler.
+ * @param {ClipboardEvent} ev The original paste event to be handled
+ * @param {Terminal} term The terminal on which to apply the handled paste event
+ */
+function pasteHandler(ev, term) {
+  ev.stopPropagation();
+  if (ev.clipboardData) {
+    var text = ev.clipboardData.getData('text/plain');
+    term.handler(text);
+    term.textarea.value = '';
+    return term.cancel(ev);
+  }
+}
+
+/**
+ * Bind to right-click event and allow right-click copy and paste.
+ *
+ * **Logic**
+ * If text is selected and right-click happens on selected text, then
+ * do nothing to allow seamless copying.
+ * If no text is selected or right-click is outside of the selection
+ * area, then bring the terminal's input below the cursor, in order to
+ * trigger the event on the textarea and allow-right click paste, without
+ * caring about disappearing selection.
+ * @param {ClipboardEvent} ev The original paste event to be handled
+ * @param {Terminal} term The terminal on which to apply the handled paste event
+ */
+function rightClickHandler(ev, term) {
+  var s = document.getSelection(),
+      sText = prepareTextForClipboard(s.toString()),
+      r = s.getRangeAt(0);
+
+  var x = ev.clientX,
+      y = ev.clientY;
+
+  var cr = r.getClientRects(),
+      clickIsOnSelection = false,
+      i, rect;
+
+  for (i=0; i<cr.length; i++) {
+    rect = cr[i];
+    clickIsOnSelection = (
+      (x > rect.left) && (x < rect.right) &&
+      (y > rect.top) && (y < rect.bottom)
+    );
+    // If we clicked on selection and selection is not a single space,
+    // then mark the right click as copy-only. We check for the single
+    // space selection, as this can happen when clicking on an &nbsp;
+    // and there is not much pointing in copying a single space.
+    // Single space is char
+    if (clickIsOnSelection && (sText !== ' ')) {
+      break;
+    }
+  }
+
+  // Bring textarea at the cursor position
+  if (!clickIsOnSelection) {
+    term.textarea.style.position = 'fixed';
+    term.textarea.style.width = '10px';
+    term.textarea.style.height = '10px';
+    term.textarea.style.left = x + 'px';
+    term.textarea.style.top = y + 'px';
+    term.textarea.style.zIndex = 1000;
+    term.textarea.focus();
+
+    // Reset the terminal textarea's styling
+    setTimeout(function () {
+      term.textarea.style.position = null;
+      term.textarea.style.width = null;
+      term.textarea.style.height = null;
+      term.textarea.style.left = null;
+      term.textarea.style.top = null;
+      term.textarea.style.zIndex = null;
+    }, 1);
+  }
+}
+
+export {
+  prepareTextForClipboard, copyHandler, pasteHandler, rightClickHandler
+};

src/xterm.css

@@ -1,6 +1,6 @@
 /**
  * xterm.js: xterm, in the browser
- * Copyright (c) 2014, sourceLair Limited (www.sourcelair.com (MIT License)
+ * Copyright (c) 2014-2016, SourceLair Private Company (www.sourcelair.com (MIT License)
  * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
  * https://github.com/chjj/term.js
  *
@@ -54,13 +54,13 @@
 }
 
 .terminal .xterm-helper-textarea {
-    position: absolute;
     /*
      * HACK: to fix IE's blinking cursor
      * Move textarea out of the screen to the far left, so that the cursor is not visible.
      */
-    left: -9999em;
+    position: absolute;
     opacity: 0;
+    left: -9999em;
     width: 0;
     height: 0;
     z-index: -10;

test/clipboard-test.js

@@ -0,0 +1,18 @@
+var assert = require('chai').assert;
+var Terminal = require('../src/xterm');
+var Clipboard = require('../src/handlers/Clipboard');
+
+
+describe('evaluateCopiedTextProcessing', function () {
+  it('should strip trailing whitespaces and replace nbsps with spaces', function () {
+    var nonBreakingSpace = String.fromCharCode(160),
+        copiedText = 'echo' + nonBreakingSpace + 'hello' + nonBreakingSpace,
+        processedText = Clipboard.prepareTextForClipboard(copiedText);
+
+    // No trailing spaces
+    assert.equal(processedText.match(/\s+$/), null);
+
+    // No non-breaking space
+    assert.equal(processedText.indexOf(nonBreakingSpace), -1);
+  });
+});

test/composition-helper-test.js

@@ -15,7 +15,7 @@ describe('CompositionHelper', function () {
         remove: function () {},
       },
       getBoundingClientRect: function () {
-        return { width: 0 }
+        return { width: 0 };
       },
       style: {
         left: 0,

test/escape_sequences.js

@@ -27,7 +27,7 @@ function pty_write_read(s) {
   return b.toString('utf8', 0, bytes);
 }
 
-// make sure raw pty is at x=0 and has no pending data 
+// make sure raw pty is at x=0 and has no pending data
 function pty_reset() {
     pty_write_read('\r\n');
 }

test/test.js

@@ -8,6 +8,84 @@ describe('xterm.js', function() {
   beforeEach(function () {
     xterm = new Terminal();
     xterm.refresh = function(){};
+    xterm.viewport = {
+      syncScrollArea: function(){}
+    };
+  });
+
+  describe('getOption', function() {
+    it('should retrieve the option correctly', function() {
+      // In the `options` namespace.
+      xterm.options.cursorBlink = true;
+      assert.equal(xterm.getOption('cursorBlink'), true);
+
+      // On the Terminal instance
+      delete xterm.options.cursorBlink;
+      xterm.cursorBlink = false;
+      assert.equal(xterm.getOption('cursorBlink'), false);
+    });
+    it('should throw when retrieving a non-existant option', function() {
+      assert.throws(xterm.getOption.bind(xterm, 'fake', true));
+    });
+  });
+
+  describe('setOption', function() {
+    it('should set the option correctly', function() {
+      xterm.setOption('cursorBlink', true);
+      assert.equal(xterm.cursorBlink, true);
+      assert.equal(xterm.options.cursorBlink, true);
+      xterm.setOption('cursorBlink', false);
+      assert.equal(xterm.cursorBlink, false);
+      assert.equal(xterm.options.cursorBlink, false);
+    });
+    it('should throw when setting a non-existant option', function() {
+      assert.throws(xterm.setOption.bind(xterm, 'fake', true));
+    });
+  });
+
+  describe('clear', function() {
+    it('should clear a buffer equal to rows', function() {
+      var promptLine = xterm.lines[xterm.ybase + xterm.y];
+      xterm.clear();
+      assert.equal(xterm.y, 0);
+      assert.equal(xterm.ybase, 0);
+      assert.equal(xterm.ydisp, 0);
+      assert.equal(xterm.lines.length, xterm.rows);
+      assert.deepEqual(xterm.lines[0], promptLine);
+      for (var i = 1; i < xterm.rows; i++) {
+        assert.deepEqual(xterm.lines[0], xterm.blankLine());
+      }
+    });
+    it('should clear a buffer larger than rows', function() {
+      // Fill the buffer with dummy rows
+      for (var i = 0; i < xterm.rows * 2; i++) {
+        xterm.write('test\n');
+      }
+
+      var promptLine = xterm.lines[xterm.ybase + xterm.y];
+      xterm.clear();
+      assert.equal(xterm.y, 0);
+      assert.equal(xterm.ybase, 0);
+      assert.equal(xterm.ydisp, 0);
+      assert.equal(xterm.lines.length, xterm.rows);
+      assert.deepEqual(xterm.lines[0], promptLine);
+      for (var i = 1; i < xterm.rows; i++) {
+        assert.deepEqual(xterm.lines[i], xterm.blankLine());
+      }
+    });
+    it('should not break the prompt when cleared twice', function() {
+      var promptLine = xterm.lines[xterm.ybase + xterm.y];
+      xterm.clear();
+      xterm.clear();
+      assert.equal(xterm.y, 0);
+      assert.equal(xterm.ybase, 0);
+      assert.equal(xterm.ydisp, 0);
+      assert.equal(xterm.lines.length, xterm.rows);
+      assert.deepEqual(xterm.lines[0], promptLine);
+      for (var i = 1; i < xterm.rows; i++) {
+        assert.deepEqual(xterm.lines[i], xterm.blankLine());
+      }
+    });
   });
 
   describe('evaluateKeyEscapeSequence', function() {
@@ -49,6 +127,15 @@ describe('xterm.js', function() {
       assert.equal(xterm.evaluateKeyEscapeSequence({ keyCode: 122 }).key, '\x1b[23~'); // CSI 2 3 ~
       assert.equal(xterm.evaluateKeyEscapeSequence({ keyCode: 123 }).key, '\x1b[24~'); // CSI 2 4 ~
     });
+    it('should return \\x1b[3;5~ for ctrl+delete', function() {
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 46 }).key, '\x1b[3;5~');
+    });
+    it('should return \\x1b[3;2~ for shift+delete', function() {
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 46 }).key, '\x1b[3;2~');
+    });
+    it('should return \\x1b[3;3~ for alt+delete', function() {
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 46 }).key, '\x1b[3;3~');
+    });
     it('should return \\x1b[5D for ctrl+left', function() {
       assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 37 }).key, '\x1b[1;5D'); // CSI 5 D
     });
@@ -75,6 +162,45 @@ describe('xterm.js', function() {
     it('should return \\x1b[5B for alt+down', function() {
       assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 40 }).key, '\x1b[1;5B'); // CSI 5 B
     });
+    it('should return the correct escape sequence for modified F1-F12 keys', function() {
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 112 }).key, '\x1b[1;2P');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 113 }).key, '\x1b[1;2Q');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 114 }).key, '\x1b[1;2R');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 115 }).key, '\x1b[1;2S');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 116 }).key, '\x1b[15;2~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 117 }).key, '\x1b[17;2~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 118 }).key, '\x1b[18;2~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 119 }).key, '\x1b[19;2~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 120 }).key, '\x1b[20;2~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 121 }).key, '\x1b[21;2~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 122 }).key, '\x1b[23;2~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ shiftKey: true, keyCode: 123 }).key, '\x1b[24;2~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 112 }).key, '\x1b[1;3P');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 113 }).key, '\x1b[1;3Q');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 114 }).key, '\x1b[1;3R');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 115 }).key, '\x1b[1;3S');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 116 }).key, '\x1b[15;3~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 117 }).key, '\x1b[17;3~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 118 }).key, '\x1b[18;3~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 119 }).key, '\x1b[19;3~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 120 }).key, '\x1b[20;3~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 121 }).key, '\x1b[21;3~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 122 }).key, '\x1b[23;3~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 123 }).key, '\x1b[24;3~');
+
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 112 }).key, '\x1b[1;5P');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 113 }).key, '\x1b[1;5Q');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 114 }).key, '\x1b[1;5R');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 115 }).key, '\x1b[1;5S');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 116 }).key, '\x1b[15;5~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 117 }).key, '\x1b[17;5~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 118 }).key, '\x1b[18;5~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 119 }).key, '\x1b[19;5~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 120 }).key, '\x1b[20;5~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 121 }).key, '\x1b[21;5~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 122 }).key, '\x1b[23;5~');
+      assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 123 }).key, '\x1b[24;5~');
+    });
   });
 
   describe('attachCustomEventHandler', function () {
@@ -119,20 +245,6 @@ describe('xterm.js', function() {
     });
   });
 
-  describe('evaluateCopiedTextProcessing', function () {
-    it('should strip trailing whitespaces and replace nbsps with spaces', function () {
-			var nonBreakingSpace = String.fromCharCode(160),
-          copiedText = 'echo' + nonBreakingSpace + 'hello' + nonBreakingSpace,
-          processedText = Terminal.prepareCopiedTextForClipboard(copiedText);
-
-      // No trailing spaces
-      assert.equal(processedText.match(/\s+$/), null);
-
-      // No non-breaking space
-      assert.equal(processedText.indexOf(nonBreakingSpace), -1);
-    });
-  });
-
   describe('Third level shift', function() {
     var evKeyDown = {
           preventDefault: function() {},
@@ -271,7 +383,7 @@ describe('xterm.js', function() {
 
   describe('unicode - surrogates', function() {
     it('2 characters per cell', function () {
-      var high = '\uD800';
+      var high = String.fromCharCode(0xD800);
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.write(high + String.fromCharCode(i));
         var tchar = xterm.lines[0][0];
@@ -283,7 +395,7 @@ describe('xterm.js', function() {
       }
     });
     it('2 characters at last cell', function() {
-      var high = '\uD800';
+      var high = String.fromCharCode(0xD800);
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.x = xterm.cols - 1;
         xterm.write(high + String.fromCharCode(i));
@@ -294,7 +406,7 @@ describe('xterm.js', function() {
       }
     });
     it('2 characters per cell over line end with autowrap', function() {
-      var high = '\uD800';
+      var high = String.fromCharCode(0xD800);
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.x = xterm.cols - 1;
         xterm.wraparoundMode = true;
@@ -307,7 +419,7 @@ describe('xterm.js', function() {
       }
     });
     it('2 characters per cell over line end without autowrap', function() {
-      var high = '\uD800';
+      var high = String.fromCharCode(0xD800);
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.x = xterm.cols - 1;
         xterm.wraparoundMode = false;
@@ -319,7 +431,7 @@ describe('xterm.js', function() {
       }
     });
     it('splitted surrogates', function() {
-      var high = '\uD800';
+      var high = String.fromCharCode(0xD800);
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.write(high);
         xterm.write(String.fromCharCode(i));

test/viewport-test.js

@@ -6,6 +6,7 @@ describe('Viewport', function () {
   var viewportElement;
   var charMeasureElement;
   var viewport;
+  var scrollAreaElement;
 
   var CHARACTER_HEIGHT = 10;
 
@@ -45,23 +46,6 @@ describe('Viewport', function () {
     it('should define Viewport.prototype.onWheel', function () {
       assert.isDefined(Terminal.Viewport.prototype.onWheel);
     });
-    it('should define Viewport.prototype.setApplicationMode', function () {
-      assert.isDefined(Terminal.Viewport.prototype.setApplicationMode);
-    });
-  });
-
-  describe('setApplicationMode', function () {
-    it('should restrict the scroll area to the viewport', function () {
-      terminal.lines.push('');
-      terminal.lines.push('');
-      terminal.rows = 1;
-      viewport.syncScrollArea();
-      assert.equal(scrollAreaElement.style.height, 2 * CHARACTER_HEIGHT + 'px');
-      viewport.setApplicationMode(true);
-      assert.equal(scrollAreaElement.style.height, CHARACTER_HEIGHT + 'px');
-      viewport.setApplicationMode(false);
-      assert.equal(scrollAreaElement.style.height, 2 * CHARACTER_HEIGHT + 'px');
-    });
   });
 
   describe('refresh', function () {