Merge pull request #2436 from Tyriar/r4_0_release

v4.0.2

addons/xterm-addon-attach/README.md

@@ -12,7 +12,7 @@ npm install --save xterm-addon-attach
 
 ```ts
 import { Terminal } from 'xterm';
-import { AttachAddon } from 'xterm-addon-attach';
+import { FitAddon } from 'xterm-addon-attach';
 
 const terminal = new Terminal();
 const attachAddon = new AttachAddon(webSocket);

addons/xterm-addon-attach/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-attach",
-  "version": "0.3.0",
+  "version": "0.2.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"
@@ -16,6 +16,6 @@
     "prepublishOnly": "npm run package"
   },
   "peerDependencies": {
-    "xterm": "^4.0.0"
+    "xterm": "^3.14.0"
   }
 }

addons/xterm-addon-attach/src/AttachAddon.api.ts

@@ -54,7 +54,7 @@ describe('AttachAddon', () => {
     const server = new WebSocket.Server({ port });
     const data = new Uint8Array([102, 111, 111]);
     server.on('connection', socket => socket.send(data));
-    await page.evaluate(`window.term.loadAddon(new window.AttachAddon(new WebSocket('ws://localhost:${port}')))`);
+    await page.evaluate(`window.term.loadAddon(new window.AttachAddon(new WebSocket('ws://localhost:${port}'), { inputUtf8: true }))`);
     assert.equal(await page.evaluate(`window.term.buffer.getLine(0).translateToString(true)`), 'foo');
     server.close();
   });

addons/xterm-addon-attach/src/AttachAddon.ts

@@ -9,11 +9,13 @@ import { Terminal, IDisposable, ITerminalAddon } from 'xterm';
 
 interface IAttachOptions {
   bidirectional?: boolean;
+  inputUtf8?: boolean;
 }
 
 export class AttachAddon implements ITerminalAddon {
   private _socket: WebSocket;
   private _bidirectional: boolean;
+  private _utf8: boolean;
   private _disposables: IDisposable[] = [];
 
   constructor(socket: WebSocket, options?: IAttachOptions) {
@@ -21,15 +23,17 @@ export class AttachAddon implements ITerminalAddon {
     // always set binary type to arraybuffer, we do not handle blobs
     this._socket.binaryType = 'arraybuffer';
     this._bidirectional = (options && options.bidirectional === false) ? false : true;
+    this._utf8 = !!(options && options.inputUtf8);
   }
 
   public activate(terminal: Terminal): void {
-    this._disposables.push(
-      addSocketListener(this._socket, 'message', ev => {
-        const data: ArrayBuffer | string = ev.data;
-        terminal.write(typeof data === 'string' ? data : new Uint8Array(data));
-      })
-    );
+    if (this._utf8) {
+      this._disposables.push(addSocketListener(this._socket, 'message',
+        (ev: MessageEvent | Event | CloseEvent) => terminal.writeUtf8(new Uint8Array((ev as any).data as ArrayBuffer))));
+    } else {
+      this._disposables.push(addSocketListener(this._socket, 'message',
+        (ev: MessageEvent | Event | CloseEvent) => terminal.write((ev as any).data as string)));
+    }
 
     if (this._bidirectional) {
       this._disposables.push(terminal.onData(data => this._sendData(data)));
@@ -53,7 +57,7 @@ export class AttachAddon implements ITerminalAddon {
   }
 }
 
-function addSocketListener<K extends keyof WebSocketEventMap>(socket: WebSocket, type: K, handler: (this: WebSocket, ev: WebSocketEventMap[K]) => any): IDisposable {
+function addSocketListener(socket: WebSocket, type: string, handler: (this: WebSocket, ev: MessageEvent | Event | CloseEvent) => any): IDisposable {
   socket.addEventListener(type, handler);
   return {
     dispose: () => {

addons/xterm-addon-attach/typings/xterm-addon-attach.d.ts

@@ -11,6 +11,14 @@ declare module 'xterm-addon-attach' {
      * Whether input should be written to the backend. Defaults to `true`.
      */
     bidirectional?: boolean;
+
+    /**
+     * Whether to use UTF8 binary transport for incoming messages. Defaults to `false`.
+     * Note: This must be in line with the server side of the websocket.
+     *       Always send string messages from the backend if this options is false,
+     *       otherwise always binary UTF8 data.
+     */
+    inputUtf8?: boolean;
   }
 
   export class AttachAddon implements ITerminalAddon {

addons/xterm-addon-fit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-fit",
-  "version": "0.2.1",
+  "version": "0.2.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"
@@ -16,6 +16,6 @@
     "prepublishOnly": "npm run package"
   },
   "peerDependencies": {
-    "xterm": "^4.0.0"
+    "xterm": "^3.14.0"
   }
 }

addons/xterm-addon-search/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-search",
-  "version": "0.2.1",
+  "version": "0.2.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"
@@ -16,6 +16,6 @@
     "prepublishOnly": "npm run package"
   },
   "peerDependencies": {
-    "xterm": "^4.0.0"
+    "xterm": "^3.14.0"
   }
 }

addons/xterm-addon-search/src/SearchAddon.api.ts

@@ -111,7 +111,12 @@ async function openTerminal(options: ITerminalOptions = {}): Promise<void> {
 }
 
 async function writeSync(data: string): Promise<void> {
-  return page.evaluate(`new Promise(resolve => window.term.write('${data}', resolve))`);
+  await page.evaluate(`window.term.write('${data}');`);
+  while (true) {
+    if (await page.evaluate(`window.term._core.writeBuffer.length === 0`)) {
+      break;
+    }
+  }
 }
 
 function makeData(length: number): string {

addons/xterm-addon-web-links/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-web-links",
-  "version": "0.2.1",
+  "version": "0.2.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"
@@ -16,6 +16,6 @@
     "prepublishOnly": "npm run package"
   },
   "peerDependencies": {
-    "xterm": "^4.0.0"
+    "xterm": "^3.14.0"
   }
 }

addons/xterm-addon-webgl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-webgl",
-  "version": "0.2.1",
+  "version": "0.2.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"
@@ -16,6 +16,6 @@
     "prepublishOnly": "npm run package"
   },
   "peerDependencies": {
-    "xterm": "^4.0.0"
+    "xterm": "^3.14.0"
   }
 }

addons/xterm-addon-webgl/src/WebglRenderer.api.ts

@@ -145,7 +145,12 @@ async function openTerminal(options: ITerminalOptions = {}): Promise<void> {
 }
 
 async function writeSync(data: string): Promise<void> {
-  return page.evaluate(`new Promise(resolve => window.term.write('${data}', resolve))`);
+  await page.evaluate(`window.term.write('${data}');`);
+  while (true) {
+    if (await page.evaluate(`window.term._core.writeBuffer.length === 0`)) {
+      break;
+    }
+  }
 }
 
 async function getCellColor(col: number, row: number): Promise<number[]> {

azure-pipelines.yml

@@ -121,7 +121,8 @@ jobs:
     displayName: 'Install Yarn'
   - script: |
       yarn
+      BUILD_DIR=dist npm run build
     displayName: 'Install dependencies and build'
   - script: |
       NPM_AUTH_TOKEN="$(NPM_AUTH_TOKEN)" node ./bin/publish.js
-    displayName: 'Package and publish to npm'
+    displayName: 'Publish to npm'

demo/client.ts

@@ -167,7 +167,14 @@ function createTerminal(): void {
 }
 
 function runRealTerminal(): void {
+  /**
+   * The demo defaults to string transport by default.
+   * To run it with UTF8 binary transport, swap comment on
+   * the lines below. (Must also be switched in server.js)
+   */
   term.loadAddon(new AttachAddon(socket));
+  // term.loadAddon(new AttachAddon(socket, {inputUtf8: true}));
+
   term._initialized = true;
 }
 

demo/server.js

@@ -3,8 +3,12 @@ var expressWs = require('express-ws');
 var os = require('os');
 var pty = require('node-pty');
 
-// Whether to use binary transport.
-const USE_BINARY = os.platform() !== "win32";
+/**
+ * Whether to use UTF8 binary transport.
+ * (Must also be switched in client.ts)
+ */
+const USE_BINARY_UTF8 = false;
+
 
 function startServer() {
   var app = express();
@@ -42,7 +46,7 @@ function startServer() {
           rows: rows || 24,
           cwd: env.PWD,
           env: env,
-          encoding: USE_BINARY ? null : 'utf8'
+          encoding: USE_BINARY_UTF8 ? null : 'utf8'
         });
 
     console.log('Created terminal with PID: ' + term.pid);
@@ -104,7 +108,7 @@ function startServer() {
         }
       };
     }
-    const send = USE_BINARY ? bufferUtf8(ws, 5) : buffer(ws, 5);
+    const send = USE_BINARY_UTF8 ? bufferUtf8(ws, 5) : buffer(ws, 5);
 
     term.on('data', function(data) {
       try {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "4.1.0",
+  "version": "4.0.2",
   "main": "lib/xterm.js",
   "style": "css/xterm.css",
   "types": "typings/xterm.d.ts",
@@ -47,7 +47,7 @@
     "ts-loader": "^6.0.4",
     "tslint": "^5.18.0",
     "tslint-consistent-codestyle": "^1.13.0",
-    "typescript": "3.6",
+    "typescript": "3.5",
     "utf8": "^3.0.0",
     "webpack": "^4.35.3",
     "webpack-cli": "^3.1.0",

src/InputHandler.ts

@@ -324,7 +324,7 @@ export class InputHandler extends Disposable implements IInputHandler {
     super.dispose();
   }
 
-  public parse(data: string | Uint8Array): void {
+  public parse(data: string): void {
     let buffer = this._bufferService.buffer;
     const cursorStartX = buffer.x;
     const cursorStartY = buffer.y;
@@ -334,17 +334,30 @@ export class InputHandler extends Disposable implements IInputHandler {
     if (this._parseBuffer.length < data.length) {
       this._parseBuffer = new Uint32Array(data.length);
     }
-    this._parser.parse(this._parseBuffer,
-      (typeof data === 'string')
-        ? this._stringDecoder.decode(data, this._parseBuffer)
-        : this._utf8Decoder.decode(data, this._parseBuffer)
-    );
+    this._parser.parse(this._parseBuffer, this._stringDecoder.decode(data, this._parseBuffer));
+
+    buffer = this._bufferService.buffer;
+    if (buffer.x !== cursorStartX || buffer.y !== cursorStartY) {
+      this._onCursorMove.fire();
+    }
+  }
+
+  public parseUtf8(data: Uint8Array): void {
+    let buffer = this._bufferService.buffer;
+    const cursorStartX = buffer.x;
+    const cursorStartY = buffer.y;
+
+    this._logService.debug('parsing data', data);
+
+    if (this._parseBuffer.length < data.length) {
+      this._parseBuffer = new Uint32Array(data.length);
+    }
+    this._parser.parse(this._parseBuffer, this._utf8Decoder.decode(data, this._parseBuffer));
 
     buffer = this._bufferService.buffer;
     if (buffer.x !== cursorStartX || buffer.y !== cursorStartY) {
       this._onCursorMove.fire();
     }
-    this._terminal.refresh(this._dirtyRowService.start, this._dirtyRowService.end);
   }
 
   public print(data: Uint32Array, start: number, end: number): void {

src/Terminal.test.ts

@@ -29,6 +29,11 @@ describe('Terminal', () => {
     (<any>term).renderer = new MockRenderer();
     term.viewport = new MockViewport();
     (<any>term)._compositionHelper = new MockCompositionHelper();
+    // Force synchronous writes
+    term.write = (data) => {
+      term.writeBuffer.push(data);
+      (<any>term)._innerWrite();
+    };
     (<any>term).element = {
       classList: {
         toggle: () => { },
@@ -54,18 +59,18 @@ describe('Terminal', () => {
     // });
     it('should fire the onCursorMove event', (done) => {
       term.onCursorMove(() => done());
-      term.writeSync('foo');
+      term.write('foo');
     });
     it('should fire the onLineFeed event', (done) => {
       term.onLineFeed(() => done());
-      term.writeSync('\n');
+      term.write('\n');
     });
     it('should fire a scroll event when scrollback is created', (done) => {
       term.onScroll(() => done());
-      term.writeSync('\n'.repeat(INIT_ROWS));
+      term.write('\n'.repeat(INIT_ROWS));
     });
     it('should fire a scroll event when scrollback is cleared', (done) => {
-      term.writeSync('\n'.repeat(INIT_ROWS));
+      term.write('\n'.repeat(INIT_ROWS));
       term.onScroll(() => done());
       term.clear();
     });
@@ -190,7 +195,7 @@ describe('Terminal', () => {
     it('should clear a buffer larger than rows', () => {
       // Fill the buffer with dummy rows
       for (let i = 0; i < term.rows * 2; i++) {
-        term.writeSync('test\n');
+        term.write('test\n');
       }
 
       const promptLine = term.buffer.lines.get(term.buffer.ybase + term.buffer.y);
@@ -239,7 +244,7 @@ describe('Terminal', () => {
         assert.equal(e, '\x1b[200~foo\x1b[201~');
         done();
       });
-      term.writeSync('\x1b[?2004h');
+      term.write('\x1b[?2004h');
       term.paste('foo');
     });
   });
@@ -249,7 +254,7 @@ describe('Terminal', () => {
       let startYDisp: number;
       beforeEach(() => {
         for (let i = 0; i < INIT_ROWS * 2; i++) {
-          term.writeSync('test\r\n');
+          term.writeln('test');
         }
         startYDisp = INIT_ROWS + 1;
       });
@@ -284,7 +289,7 @@ describe('Terminal', () => {
       let startYDisp: number;
       beforeEach(() => {
         for (let i = 0; i < term.rows * 3; i++) {
-          term.writeSync('test\r\n');
+          term.writeln('test');
         }
         startYDisp = (term.rows * 2) + 1;
       });
@@ -307,7 +312,7 @@ describe('Terminal', () => {
     describe('scrollToTop', () => {
       beforeEach(() => {
         for (let i = 0; i < term.rows * 3; i++) {
-          term.writeSync('test\r\n');
+          term.writeln('test');
         }
       });
       it('should scroll to the top', () => {
@@ -321,7 +326,7 @@ describe('Terminal', () => {
       let startYDisp: number;
       beforeEach(() => {
         for (let i = 0; i < term.rows * 3; i++) {
-          term.writeSync('test\r\n');
+          term.writeln('test');
         }
         startYDisp = (term.rows * 2) + 1;
       });
@@ -342,7 +347,7 @@ describe('Terminal', () => {
       let startYDisp: number;
       beforeEach(() => {
         for (let i = 0; i < term.rows * 3; i++) {
-          term.writeSync('test\r\n');
+          term.writeln('test');
         }
         startYDisp = (term.rows * 2) + 1;
       });
@@ -387,7 +392,7 @@ describe('Terminal', () => {
       it('should not scroll down, when a custom keydown handler prevents the event', () => {
         // Add some output to the terminal
         for (let i = 0; i < term.rows * 3; i++) {
-          term.writeSync('test\r\n');
+          term.writeln('test');
         }
         const startYDisp = (term.rows * 2) + 1;
         term.attachCustomKeyEventHandler(() => {
@@ -732,7 +737,7 @@ describe('Terminal', () => {
       const high = String.fromCharCode(0xD800);
       const cell = new CellData();
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
-        term.writeSync(high + String.fromCharCode(i));
+        term.write(high + String.fromCharCode(i));
         const tchar = term.buffer.lines.get(0).loadCell(0, cell);
         expect(tchar.getChars()).eql(high + String.fromCharCode(i));
         expect(tchar.getChars().length).eql(2);
@@ -746,7 +751,7 @@ describe('Terminal', () => {
       const cell = new CellData();
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
         term.buffer.x = term.cols - 1;
-        term.writeSync(high + String.fromCharCode(i));
+        term.write(high + String.fromCharCode(i));
         expect(term.buffer.lines.get(0).loadCell(term.buffer.x - 1, cell).getChars()).eql(high + String.fromCharCode(i));
         expect(term.buffer.lines.get(0).loadCell(term.buffer.x - 1, cell).getChars().length).eql(2);
         expect(term.buffer.lines.get(1).loadCell(0, cell).getChars()).eql('');
@@ -759,7 +764,7 @@ describe('Terminal', () => {
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
         term.buffer.x = term.cols - 1;
         term.wraparoundMode = true;
-        term.writeSync('a' + high + String.fromCharCode(i));
+        term.write('a' + high + String.fromCharCode(i));
         expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars()).eql('a');
         expect(term.buffer.lines.get(1).loadCell(0, cell).getChars()).eql(high + String.fromCharCode(i));
         expect(term.buffer.lines.get(1).loadCell(0, cell).getChars().length).eql(2);
@@ -777,7 +782,7 @@ describe('Terminal', () => {
         if (width !== 1) {
           continue;
         }
-        term.writeSync('a' + high + String.fromCharCode(i));
+        term.write('a' + high + String.fromCharCode(i));
         // auto wraparound mode should cut off the rest of the line
         expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars()).eql(high + String.fromCharCode(i));
         expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars().length).eql(2);
@@ -789,8 +794,8 @@ describe('Terminal', () => {
       const high = String.fromCharCode(0xD800);
       const cell = new CellData();
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
-        term.writeSync(high);
-        term.writeSync(String.fromCharCode(i));
+        term.write(high);
+        term.write(String.fromCharCode(i));
         const tchar = term.buffer.lines.get(0).loadCell(0, cell);
         expect(tchar.getChars()).eql(high + String.fromCharCode(i));
         expect(tchar.getChars().length).eql(2);
@@ -804,7 +809,7 @@ describe('Terminal', () => {
   describe('unicode - combining characters', () => {
     const cell = new CellData();
     it('café', () => {
-      term.writeSync('cafe\u0301');
+      term.write('cafe\u0301');
       term.buffer.lines.get(0).loadCell(3, cell);
       expect(cell.getChars()).eql('e\u0301');
       expect(cell.getChars().length).eql(2);
@@ -812,7 +817,7 @@ describe('Terminal', () => {
     });
     it('café - end of line', () => {
       term.buffer.x = term.cols - 1 - 3;
-      term.writeSync('cafe\u0301');
+      term.write('cafe\u0301');
       term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
       expect(cell.getChars()).eql('e\u0301');
       expect(cell.getChars().length).eql(2);
@@ -824,7 +829,7 @@ describe('Terminal', () => {
     });
     it('multiple combined é', () => {
       term.wraparoundMode = true;
-      term.writeSync(Array(100).join('e\u0301'));
+      term.write(Array(100).join('e\u0301'));
       for (let i = 0; i < term.cols; ++i) {
         term.buffer.lines.get(0).loadCell(i, cell);
         expect(cell.getChars()).eql('e\u0301');
@@ -838,7 +843,7 @@ describe('Terminal', () => {
     });
     it('multiple surrogate with combined', () => {
       term.wraparoundMode = true;
-      term.writeSync(Array(100).join('\uD800\uDC00\u0301'));
+      term.write(Array(100).join('\uD800\uDC00\u0301'));
       for (let i = 0; i < term.cols; ++i) {
         term.buffer.lines.get(0).loadCell(i, cell);
         expect(cell.getChars()).eql('\uD800\uDC00\u0301');
@@ -856,18 +861,18 @@ describe('Terminal', () => {
     const cell = new CellData();
     it('cursor movement even', () => {
       expect(term.buffer.x).eql(0);
-      term.writeSync('￥');
+      term.write('￥');
       expect(term.buffer.x).eql(2);
     });
     it('cursor movement odd', () => {
       term.buffer.x = 1;
       expect(term.buffer.x).eql(1);
-      term.writeSync('￥');
+      term.write('￥');
       expect(term.buffer.x).eql(3);
     });
     it('line of ￥ even', () => {
       term.wraparoundMode = true;
-      term.writeSync(Array(50).join('￥'));
+      term.write(Array(50).join('￥'));
       for (let i = 0; i < term.cols; ++i) {
         term.buffer.lines.get(0).loadCell(i, cell);
         if (i % 2) {
@@ -888,7 +893,7 @@ describe('Terminal', () => {
     it('line of ￥ odd', () => {
       term.wraparoundMode = true;
       term.buffer.x = 1;
-      term.writeSync(Array(50).join('￥'));
+      term.write(Array(50).join('￥'));
       for (let i = 1; i < term.cols - 1; ++i) {
         term.buffer.lines.get(0).loadCell(i, cell);
         if (!(i % 2)) {
@@ -913,7 +918,7 @@ describe('Terminal', () => {
     it('line of ￥ with combining odd', () => {
       term.wraparoundMode = true;
       term.buffer.x = 1;
-      term.writeSync(Array(50).join('￥\u0301'));
+      term.write(Array(50).join('￥\u0301'));
       for (let i = 1; i < term.cols - 1; ++i) {
         term.buffer.lines.get(0).loadCell(i, cell);
         if (!(i % 2)) {
@@ -937,7 +942,7 @@ describe('Terminal', () => {
     });
     it('line of ￥ with combining even', () => {
       term.wraparoundMode = true;
-      term.writeSync(Array(50).join('￥\u0301'));
+      term.write(Array(50).join('￥\u0301'));
       for (let i = 0; i < term.cols; ++i) {
         term.buffer.lines.get(0).loadCell(i, cell);
         if (i % 2) {
@@ -958,7 +963,7 @@ describe('Terminal', () => {
     it('line of surrogate fullwidth with combining odd', () => {
       term.wraparoundMode = true;
       term.buffer.x = 1;
-      term.writeSync(Array(50).join('\ud843\ude6d\u0301'));
+      term.write(Array(50).join('\ud843\ude6d\u0301'));
       for (let i = 1; i < term.cols - 1; ++i) {
         term.buffer.lines.get(0).loadCell(i, cell);
         if (!(i % 2)) {
@@ -982,7 +987,7 @@ describe('Terminal', () => {
     });
     it('line of surrogate fullwidth with combining even', () => {
       term.wraparoundMode = true;
-      term.writeSync(Array(50).join('\ud843\ude6d\u0301'));
+      term.write(Array(50).join('\ud843\ude6d\u0301'));
       for (let i = 0; i < term.cols; ++i) {
         term.buffer.lines.get(0).loadCell(i, cell);
         if (i % 2) {
@@ -1005,11 +1010,11 @@ describe('Terminal', () => {
   describe('insert mode', () => {
     const cell = new CellData();
     it('halfwidth - all', () => {
-      term.writeSync(Array(9).join('0123456789').slice(-80));
+      term.write(Array(9).join('0123456789').slice(-80));
       term.buffer.x = 10;
       term.buffer.y = 0;
       term.insertMode = true;
-      term.writeSync('abcde');
+      term.write('abcde');
       expect(term.buffer.lines.get(0).length).eql(term.cols);
       expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('a');
       expect(term.buffer.lines.get(0).loadCell(14, cell).getChars()).eql('e');
@@ -1017,11 +1022,11 @@ describe('Terminal', () => {
       expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('4');
     });
     it('fullwidth - insert', () => {
-      term.writeSync(Array(9).join('0123456789').slice(-80));
+      term.write(Array(9).join('0123456789').slice(-80));
       term.buffer.x = 10;
       term.buffer.y = 0;
       term.insertMode = true;
-      term.writeSync('￥￥￥');
+      term.write('￥￥￥');
       expect(term.buffer.lines.get(0).length).eql(term.cols);
       expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('￥');
       expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('');
@@ -1030,16 +1035,16 @@ describe('Terminal', () => {
       expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('3');
     });
     it('fullwidth - right border', () => {
-      term.writeSync(Array(41).join('￥'));
+      term.write(Array(41).join('￥'));
       term.buffer.x = 10;
       term.buffer.y = 0;
       term.insertMode = true;
-      term.writeSync('a');
+      term.write('a');
       expect(term.buffer.lines.get(0).length).eql(term.cols);
       expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('a');
       expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('￥');
       expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('');  // fullwidth char got replaced
-      term.writeSync('b');
+      term.write('b');
       expect(term.buffer.lines.get(0).length).eql(term.cols);
       expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('b');
       expect(term.buffer.lines.get(0).loadCell(12, cell).getChars()).eql('￥');

src/Terminal.ts

@@ -62,11 +62,25 @@ import { ILinkifier, IMouseZoneManager, LinkMatcherHandler, ILinkMatcherOptions,
 import { DirtyRowService } from 'common/services/DirtyRowService';
 import { InstantiationService } from 'common/services/InstantiationService';
 import { CoreMouseService } from 'common/services/CoreMouseService';
-import { WriteBuffer } from 'common/input/WriteBuffer';
 
 // Let it work inside Node.js for automated testing purposes.
 const document = (typeof window !== 'undefined') ? window.document : null;
 
+/**
+ * The amount of write requests to queue before sending an XOFF signal to the
+ * pty process. This number must be small in order for ^C and similar sequences
+ * to be responsive.
+ */
+const WRITE_BUFFER_PAUSE_THRESHOLD = 5;
+
+/**
+ * The max number of ms to spend on writes before allowing the renderer to
+ * catch up with a 0ms setTimeout. A value of < 33 to keep us close to
+ * 30fps, and a value of < 16 to try to run at 60fps. Of course, the real FPS
+ * depends on the time it takes for the renderer to draw the frame.
+ */
+const WRITE_TIMEOUT_MS = 12;
+const WRITE_BUFFER_LENGTH_THRESHOLD = 50;
 
 export class Terminal extends Disposable implements ITerminal, IDisposable, IInputHandlingTerminal {
   public textarea: HTMLTextAreaElement;
@@ -139,8 +153,21 @@ export class Terminal extends Disposable implements ITerminal, IDisposable, IInp
   public params: (string | number)[];
   public currentParam: string | number;
 
-  // write buffer
-  private _writeBuffer: WriteBuffer;
+  // user input states
+  public writeBuffer: string[];
+  public writeBufferUtf8: Uint8Array[];
+  private _writeInProgress: boolean;
+
+  /**
+   * Whether _xterm.js_ sent XOFF in order to catch up with the pty process.
+   * This is a distinct state from writeStopped so that if the user requested
+   * XOFF via ^S that it will not automatically resume when the writeBuffer goes
+   * below threshold.
+   */
+  private _xoffSentToCatchUp: boolean;
+
+  /** Whether writing has been stopped as a result of XOFF */
+  // private _writeStopped: boolean;
 
   // Store if user went browsing history in scrollback
   private _userScrolling: boolean;
@@ -231,8 +258,6 @@ export class Terminal extends Disposable implements ITerminal, IDisposable, IInp
 
     this._setupOptionsListeners();
     this._setup();
-
-    this._writeBuffer = new WriteBuffer(data => this._inputHandler.parse(data));
   }
 
   public dispose(): void {
@@ -281,6 +306,13 @@ export class Terminal extends Disposable implements ITerminal, IDisposable, IInp
     this.params = [];
     this.currentParam = 0;
 
+    // user input states
+    this.writeBuffer = [];
+    this.writeBufferUtf8 = [];
+    this._writeInProgress = false;
+
+    this._xoffSentToCatchUp = false;
+    // this._writeStopped = false;
     this._userScrolling = false;
 
     // Register input handler and refire/handle events
@@ -1112,6 +1144,168 @@ export class Terminal extends Disposable implements ITerminal, IDisposable, IInp
     }
   }
 
+  /**
+   * Writes raw utf8 bytes to the terminal.
+   * @param data UintArray with UTF8 bytes to write to the terminal.
+   */
+  public writeUtf8(data: Uint8Array): void {
+    // Ensure the terminal isn't disposed
+    if (this._isDisposed) {
+      return;
+    }
+
+    // Ignore falsy data values
+    if (!data) {
+      return;
+    }
+
+    this.writeBufferUtf8.push(data);
+
+    // Send XOFF to pause the pty process if the write buffer becomes too large so
+    // xterm.js can catch up before more data is sent. This is necessary in order
+    // to keep signals such as ^C responsive.
+    if (this.options.useFlowControl && !this._xoffSentToCatchUp && this.writeBufferUtf8.length >= WRITE_BUFFER_PAUSE_THRESHOLD) {
+      // XOFF - stop pty pipe
+      // XON will be triggered by emulator before processing data chunk
+      this._coreService.triggerDataEvent(C0.DC3);
+      this._xoffSentToCatchUp = true;
+    }
+
+    if (!this._writeInProgress && this.writeBufferUtf8.length > 0) {
+      // Kick off a write which will write all data in sequence recursively
+      this._writeInProgress = true;
+      // Kick off an async innerWrite so more writes can come in while processing data
+      setTimeout(() => {
+        this._innerWriteUtf8();
+      });
+    }
+  }
+
+  protected _innerWriteUtf8(bufferOffset: number = 0): void {
+    // Ensure the terminal isn't disposed
+    if (this._isDisposed) {
+      this.writeBufferUtf8 = [];
+    }
+
+    const startTime = Date.now();
+    while (this.writeBufferUtf8.length > bufferOffset) {
+      const data = this.writeBufferUtf8[bufferOffset];
+      bufferOffset++;
+
+      // If XOFF was sent in order to catch up with the pty process, resume it if
+      // we reached the end of the writeBuffer to allow more data to come in.
+      if (this._xoffSentToCatchUp && this.writeBufferUtf8.length === bufferOffset) {
+        this._coreService.triggerDataEvent(C0.DC1);
+        this._xoffSentToCatchUp = false;
+      }
+
+      this._inputHandler.parseUtf8(data);
+
+      this.refresh(this._dirtyRowService.start, this._dirtyRowService.end);
+
+      if (Date.now() - startTime >= WRITE_TIMEOUT_MS) {
+        break;
+      }
+    }
+    if (this.writeBufferUtf8.length > bufferOffset) {
+      // Allow renderer to catch up before processing the next batch
+      // trim already processed chunks if we are above threshold
+      if (bufferOffset > WRITE_BUFFER_LENGTH_THRESHOLD) {
+        this.writeBufferUtf8 = this.writeBufferUtf8.slice(bufferOffset);
+        bufferOffset = 0;
+      }
+      setTimeout(() => this._innerWriteUtf8(bufferOffset), 0);
+    } else {
+      this._writeInProgress = false;
+      this.writeBufferUtf8 = [];
+    }
+  }
+
+  /**
+   * Writes text to the terminal.
+   * @param data The text to write to the terminal.
+   */
+  public write(data: string): void {
+    // Ensure the terminal isn't disposed
+    if (this._isDisposed) {
+      return;
+    }
+
+    // Ignore falsy data values (including the empty string)
+    if (!data) {
+      return;
+    }
+
+    this.writeBuffer.push(data);
+
+    // Send XOFF to pause the pty process if the write buffer becomes too large so
+    // xterm.js can catch up before more data is sent. This is necessary in order
+    // to keep signals such as ^C responsive.
+    if (this.options.useFlowControl && !this._xoffSentToCatchUp && this.writeBuffer.length >= WRITE_BUFFER_PAUSE_THRESHOLD) {
+      // XOFF - stop pty pipe
+      // XON will be triggered by emulator before processing data chunk
+      this._coreService.triggerDataEvent(C0.DC3);
+      this._xoffSentToCatchUp = true;
+    }
+
+    if (!this._writeInProgress && this.writeBuffer.length > 0) {
+      // Kick off a write which will write all data in sequence recursively
+      this._writeInProgress = true;
+      // Kick off an async innerWrite so more writes can come in while processing data
+      setTimeout(() => {
+        this._innerWrite();
+      });
+    }
+  }
+
+  protected _innerWrite(bufferOffset: number = 0): void {
+    // Ensure the terminal isn't disposed
+    if (this._isDisposed) {
+      this.writeBuffer = [];
+    }
+
+    const startTime = Date.now();
+    while (this.writeBuffer.length > bufferOffset) {
+      const data = this.writeBuffer[bufferOffset];
+      bufferOffset++;
+
+      // If XOFF was sent in order to catch up with the pty process, resume it if
+      // we reached the end of the writeBuffer to allow more data to come in.
+      if (this._xoffSentToCatchUp && this.writeBuffer.length === bufferOffset) {
+        this._coreService.triggerDataEvent(C0.DC1);
+        this._xoffSentToCatchUp = false;
+      }
+
+      this._inputHandler.parse(data);
+
+      this.refresh(this._dirtyRowService.start, this._dirtyRowService.end);
+
+      if (Date.now() - startTime >= WRITE_TIMEOUT_MS) {
+        break;
+      }
+    }
+    if (this.writeBuffer.length > bufferOffset) {
+      // Allow renderer to catch up before processing the next batch
+      // trim already processed chunks if we are above threshold
+      if (bufferOffset > WRITE_BUFFER_LENGTH_THRESHOLD) {
+        this.writeBuffer = this.writeBuffer.slice(bufferOffset);
+        bufferOffset = 0;
+      }
+      setTimeout(() => this._innerWrite(bufferOffset), 0);
+    } else {
+      this._writeInProgress = false;
+      this.writeBuffer = [];
+    }
+  }
+
+  /**
+   * Writes text to the terminal, followed by a break line character (\n).
+   * @param data The text to write to the terminal.
+   */
+  public writeln(data: string): void {
+    this.write(data + '\r\n');
+  }
+
   public paste(data: string): void {
     paste(data, this.textarea, this.bracketedPasteMode, this._coreService);
   }
@@ -1549,6 +1743,10 @@ export class Terminal extends Disposable implements ITerminal, IDisposable, IInp
     const customKeyEventHandler = this._customKeyEventHandler;
     const inputHandler = this._inputHandler;
     const cursorState = this.cursorState;
+    const writeBuffer = this.writeBuffer;
+    const writeBufferUtf8 = this.writeBufferUtf8;
+    const writeInProgress = this._writeInProgress;
+    const xoffSentToCatchUp = this._xoffSentToCatchUp;
     const userScrolling = this._userScrolling;
 
     this._setup();
@@ -1563,6 +1761,10 @@ export class Terminal extends Disposable implements ITerminal, IDisposable, IInp
     this._customKeyEventHandler = customKeyEventHandler;
     this._inputHandler = inputHandler;
     this.cursorState = cursorState;
+    this.writeBuffer = writeBuffer;
+    this.writeBufferUtf8 = writeBufferUtf8;
+    this._writeInProgress = writeInProgress;
+    this._xoffSentToCatchUp = xoffSentToCatchUp;
     this._userScrolling = userScrolling;
 
     // do a full screen refresh
@@ -1593,14 +1795,6 @@ export class Terminal extends Disposable implements ITerminal, IDisposable, IInp
     // return this.options.bellStyle === 'sound' ||
     //     this.options.bellStyle === 'both';
   }
-
-  public write(data: string | Uint8Array, callback?: () => void): void {
-    this._writeBuffer.write(data, callback);
-  }
-
-  public writeSync(data: string | Uint8Array): void {
-    this._writeBuffer.writeSync(data);
-  }
 }
 
 /**

src/TestUtils.test.ts

@@ -19,6 +19,10 @@ import { IParams, IFunctionIdentifier } from 'common/parser/Types';
 import { ISelectionService } from 'browser/services/Services';
 
 export class TestTerminal extends Terminal {
+  writeSync(data: string): void {
+    this.writeBuffer.push(data);
+    this._innerWrite();
+  }
   keyDown(ev: any): boolean { return this._keyDown(ev); }
   keyPress(ev: any): boolean { return this._keyPress(ev); }
 }

src/Types.d.ts

@@ -73,7 +73,8 @@ export interface ICompositionHelper {
  * Calls the parser and handles actions generated by the parser.
  */
 export interface IInputHandler {
-  parse(data: string | Uint8Array): void;
+  parse(data: string): void;
+  parseUtf8(data: Uint8Array): void;
   print(data: Uint32Array, start: number, end: number): void;
 
   /** C0 BEL */ bell(): void;
@@ -150,6 +151,7 @@ export interface IInputHandler {
 export interface ITerminal extends IPublicTerminal, IElementAccessor, IBufferAccessor, ILinkifierAccessor {
   screenElement: HTMLElement;
   browser: IBrowser;
+  writeBuffer: string[];
   cursorHidden: boolean;
   cursorState: number;
   buffer: IBuffer;
@@ -190,6 +192,7 @@ export interface IPublicTerminal extends IDisposable {
   blur(): void;
   focus(): void;
   resize(columns: number, rows: number): void;
+  writeln(data: string): void;
   open(parent: HTMLElement): void;
   attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void;
   addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable;
@@ -215,7 +218,8 @@ export interface IPublicTerminal extends IDisposable {
   scrollToBottom(): void;
   scrollToLine(line: number): void;
   clear(): void;
-  write(data: string | Uint8Array, callback?: () => void): void;
+  write(data: string): void;
+  writeUtf8(data: Uint8Array): void;
   paste(data: string): void;
   refresh(start: number, end: number): void;
   reset(): void;

src/common/input/Keyboard.ts

@@ -113,9 +113,6 @@ export function evaluateKeyboardEvent(
       break;
     case 37:
       // left-arrow
-      if (ev.metaKey) {
-        break;
-      }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'D';
         // HACK: Make Alt + left-arrow behave like Ctrl + left-arrow: move one word backwards
@@ -132,9 +129,6 @@ export function evaluateKeyboardEvent(
       break;
     case 39:
       // right-arrow
-      if (ev.metaKey) {
-        break;
-      }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'C';
         // HACK: Make Alt + right-arrow behave like Ctrl + right-arrow: move one word forward
@@ -151,9 +145,6 @@ export function evaluateKeyboardEvent(
       break;
     case 38:
       // up-arrow
-      if (ev.metaKey) {
-        break;
-      }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'A';
         // HACK: Make Alt + up-arrow behave like Ctrl + up-arrow
@@ -169,9 +160,6 @@ export function evaluateKeyboardEvent(
       break;
     case 40:
       // down-arrow
-      if (ev.metaKey) {
-        break;
-      }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'B';
         // HACK: Make Alt + down-arrow behave like Ctrl + down-arrow
@@ -328,18 +316,23 @@ export function evaluateKeyboardEvent(
         if (ev.keyCode >= 65 && ev.keyCode <= 90) {
           result.key = String.fromCharCode(ev.keyCode - 64);
         } else if (ev.keyCode === 32) {
-          result.key = C0.NUL;
+          // NUL
+          result.key = String.fromCharCode(0);
         } else if (ev.keyCode >= 51 && ev.keyCode <= 55) {
           // escape, file sep, group sep, record sep, unit sep
           result.key = String.fromCharCode(ev.keyCode - 51 + 27);
         } else if (ev.keyCode === 56) {
-          result.key = C0.DEL;
+          // delete
+          result.key = String.fromCharCode(127);
         } else if (ev.keyCode === 219) {
-          result.key = C0.ESC;
+          // ^[ - Control Sequence Introducer (CSI)
+          result.key = String.fromCharCode(27);
         } else if (ev.keyCode === 220) {
-          result.key = C0.FS;
+          // ^\ - String Terminator (ST)
+          result.key = String.fromCharCode(28);
         } else if (ev.keyCode === 221) {
-          result.key = C0.GS;
+          // ^] - Operating System Command (OSC)
+          result.key = String.fromCharCode(29);
         }
       } else if ((!isMac || macOptionIsMeta) && ev.altKey && !ev.metaKey) {
         // On macOS this is a third level shift when !macOptionIsMeta. Use <Esc> instead.

src/common/input/WriteBuffer.test.ts

@@ -1,88 +0,0 @@
-/**
- * Copyright (c) 2019 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { assert } from 'chai';
-import { WriteBuffer } from './WriteBuffer';
-
-declare let Buffer: any;
-
-function toBytes(s: string): Uint8Array {
-  return Buffer.from(s);
-}
-
-function fromBytes(bytes: Uint8Array): string {
-  return bytes.toString();
-}
-
-describe('WriteBuffer', () => {
-  let wb: WriteBuffer;
-  let stack: (string | Uint8Array)[] = [];
-  let cbStack: string[] = [];
-  beforeEach(() => {
-    stack = [];
-    cbStack = [];
-    wb = new WriteBuffer(data => { stack.push(data); });
-  });
-  describe('write input', () => {
-    it('string', done => {
-      wb.write('a._');
-      wb.write('b.x', () => { cbStack.push('b'); });
-      wb.write('c._');
-      wb.write('d.x', () => { cbStack.push('d'); });
-      wb.write('e', () => {
-        assert.deepEqual(stack, ['a._', 'b.x', 'c._', 'd.x', 'e']);
-        assert.deepEqual(cbStack, ['b', 'd']);
-        done();
-      });
-    });
-    it('bytes', done => {
-      wb.write(toBytes('a._'));
-      wb.write(toBytes('b.x'), () => { cbStack.push('b'); });
-      wb.write(toBytes('c._'));
-      wb.write(toBytes('d.x'), () => { cbStack.push('d'); });
-      wb.write(toBytes('e'), () => {
-        assert.deepEqual(stack.map(val => typeof val === 'string' ? '' :  fromBytes(val)), ['a._', 'b.x', 'c._', 'd.x', 'e']);
-        assert.deepEqual(cbStack, ['b', 'd']);
-        done();
-      });
-    });
-    it('string/bytes mixed', done => {
-      wb.write('a._');
-      wb.write('b.x', () => { cbStack.push('b'); });
-      wb.write(toBytes('c._'));
-      wb.write(toBytes('d.x'), () => { cbStack.push('d'); });
-      wb.write(toBytes('e'), () => {
-        assert.deepEqual(stack.map(val => typeof val === 'string' ? val :  fromBytes(val)), ['a._', 'b.x', 'c._', 'd.x', 'e']);
-        assert.deepEqual(cbStack, ['b', 'd']);
-        done();
-      });
-    });
-    it('write callback works for empty chunks', done => {
-      wb.write('a', () => { cbStack.push('a'); });
-      wb.write('', () => { cbStack.push('b'); });
-      wb.write(toBytes('c'), () => { cbStack.push('c'); });
-      wb.write(new Uint8Array(0), () => { cbStack.push('d'); });
-      wb.write('e', () => {
-        assert.deepEqual(stack.map(val => typeof val === 'string' ? val :  fromBytes(val)), ['a', '', 'c', '', 'e']);
-        assert.deepEqual(cbStack, ['a', 'b', 'c', 'd']);
-        done();
-      });
-    });
-    it('writeSync', done => {
-      wb.write('a', () => { cbStack.push('a'); });
-      wb.write('b', () => { cbStack.push('b'); });
-      wb.write('c', () => { cbStack.push('c'); });
-      wb.writeSync('d');
-      assert.deepEqual(stack, ['a', 'b', 'c', 'd']);
-      assert.deepEqual(cbStack, ['a', 'b', 'c']);
-      wb.write('x', () => { cbStack.push('x'); });
-      wb.write('', () => {
-        assert.deepEqual(stack, ['a', 'b', 'c', 'd', 'x', '']);
-        assert.deepEqual(cbStack, ['a', 'b', 'c', 'x']);
-        done();
-      });
-    });
-  });
-});

src/common/input/WriteBuffer.ts

@@ -1,110 +0,0 @@
-
-/**
- * Copyright (c) 2019 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-declare const setTimeout: (handler: () => void, timeout?: number) => void;
-
-/**
- * Safety watermark to avoid memory exhaustion and browser engine crash on fast data input.
- * Enable flow control to avoid this limit and make sure that your backend correctly
- * propagates this to the underlying pty. (see docs for further instructions)
- * Since this limit is meant as a safety parachute to prevent browser crashs,
- * it is set to a very high number. Typically xterm.js gets unresponsive with
- * a 100 times lower number (>500 kB).
- */
-const DISCARD_WATERMARK = 50000000; // ~50 MB
-
-/**
- * The max number of ms to spend on writes before allowing the renderer to
- * catch up with a 0ms setTimeout. A value of < 33 to keep us close to
- * 30fps, and a value of < 16 to try to run at 60fps. Of course, the real FPS
- * depends on the time it takes for the renderer to draw the frame.
- */
-const WRITE_TIMEOUT_MS = 12;
-
-/**
- * Threshold of max held chunks in the write buffer, that were already processed.
- * This is a tradeoff between extensive write buffer shifts (bad runtime) and high
- * memory consumption by data thats not used anymore.
- */
-const WRITE_BUFFER_LENGTH_THRESHOLD = 50;
-
-export class WriteBuffer {
-  private _writeBuffer: (string | Uint8Array)[] = [];
-  private _callbacks: ((() => void) | undefined)[] = [];
-  private _pendingData = 0;
-  private _bufferOffset = 0;
-
-  constructor(private _action: (data: string | Uint8Array) => void) { }
-
-  public writeSync(data: string | Uint8Array): void {
-    // force sync processing on pending data chunks to avoid in-band data scrambling
-    // does the same as innerWrite but without event loop
-    if (this._writeBuffer.length) {
-      for (let i = this._bufferOffset; i < this._writeBuffer.length; ++i) {
-        const data = this._writeBuffer[i];
-        const cb = this._callbacks[i];
-        this._action(data);
-        if (cb) cb();
-      }
-      // reset all to avoid reprocessing of chunks with scheduled innerWrite call
-      this._writeBuffer = [];
-      this._callbacks = [];
-      this._pendingData = 0;
-      // stop scheduled innerWrite by offset > length condition
-      this._bufferOffset = 0x7FFFFFFF;
-    }
-    // handle current data chunk
-    this._action(data);
-  }
-
-  public write(data: string | Uint8Array, callback?: () => void): void {
-    if (this._pendingData > DISCARD_WATERMARK) {
-      throw new Error('write data discarded, use flow control to avoid losing data');
-    }
-
-    // schedule chunk processing for next event loop run
-    if (!this._writeBuffer.length) {
-      this._bufferOffset = 0;
-      setTimeout(() => this._innerWrite());
-    }
-
-    this._pendingData += data.length;
-    this._writeBuffer.push(data);
-    this._callbacks.push(callback);
-  }
-
-  protected _innerWrite(): void {
-    const startTime = Date.now();
-    while (this._writeBuffer.length > this._bufferOffset) {
-      const data = this._writeBuffer[this._bufferOffset];
-      const cb = this._callbacks[this._bufferOffset];
-      this._bufferOffset++;
-
-      this._action(data);
-      this._pendingData -= data.length;
-      if (cb) cb();
-
-      if (Date.now() - startTime >= WRITE_TIMEOUT_MS) {
-        break;
-      }
-    }
-    if (this._writeBuffer.length > this._bufferOffset) {
-      // Allow renderer to catch up before processing the next batch
-      // trim already processed chunks if we are above threshold
-      if (this._bufferOffset > WRITE_BUFFER_LENGTH_THRESHOLD) {
-        this._writeBuffer = this._writeBuffer.slice(this._bufferOffset);
-        this._callbacks = this._callbacks.slice(this._bufferOffset);
-        this._bufferOffset = 0;
-      }
-      setTimeout(() => this._innerWrite(), 0);
-    } else {
-      this._writeBuffer = [];
-      this._callbacks = [];
-      this._pendingData = 0;
-      this._bufferOffset = 0;
-    }
-  }
-}

src/common/services/CoreService.ts

@@ -54,7 +54,7 @@ export class CoreService implements ICoreService {
     }
 
     // Fire onData API
-    this._logService.debug(`sending data "${data}"`, () => data.split('').map(e => e.charCodeAt(0)));
+    this._logService.debug('sending data', data);
     this._onData.fire(data);
   }
 }

src/common/services/LogService.ts

@@ -5,14 +5,12 @@
 
 import { ILogService, IOptionsService } from 'common/services/Services';
 
-type LogType = (message?: any, ...optionalParams: any[]) => void;
-
 interface IConsole {
-  log: LogType;
-  error: LogType;
-  info: LogType;
-  trace: LogType;
-  warn: LogType;
+  log(message?: any, ...optionalParams: any[]): void;
+  error(message?: any, ...optionalParams: any[]): void;
+  info(message?: any, ...optionalParams: any[]): void;
+  trace(message?: any, ...optionalParams: any[]): void;
+  warn(message?: any, ...optionalParams: any[]): void;
 }
 
 // console is available on both node.js and browser contexts but the common
@@ -58,40 +56,27 @@ export class LogService implements ILogService {
     this._logLevel = optionsKeyToLogLevel[this._optionsService.options.logLevel];
   }
 
-  private _evalLazyOptionalParams(optionalParams: any[]): void {
-    for (let i = 0; i < optionalParams.length; i++) {
-      if (typeof optionalParams[i] === 'function') {
-        optionalParams[i] = optionalParams[i]();
-      }
-    }
-  }
-
-  private _log(type: LogType, message: string, optionalParams: any[]): void {
-    this._evalLazyOptionalParams(optionalParams);
-    type.call(console, LOG_PREFIX + message, ...optionalParams);
-  }
-
   debug(message: string, ...optionalParams: any[]): void {
     if (this._logLevel <= LogLevel.DEBUG) {
-      this._log(console.log, message, optionalParams);
+      console.log.call(console, LOG_PREFIX + message, ...optionalParams);
     }
   }
 
   info(message: string, ...optionalParams: any[]): void {
     if (this._logLevel <= LogLevel.INFO) {
-      this._log(console.info, message, optionalParams);
+      console.info.call(console, LOG_PREFIX + message, ...optionalParams);
     }
   }
 
   warn(message: string, ...optionalParams: any[]): void {
     if (this._logLevel <= LogLevel.WARN) {
-      this._log(console.warn, message, optionalParams);
+      console.warn.call(console, LOG_PREFIX + message, ...optionalParams);
     }
   }
 
   error(message: string, ...optionalParams: any[]): void {
     if (this._logLevel <= LogLevel.ERROR) {
-      this._log(console.error, message, optionalParams);
+      console.error.call(console, LOG_PREFIX + message, ...optionalParams);
     }
   }
 }

src/public/Terminal.ts

@@ -55,6 +55,9 @@ export class Terminal implements ITerminalApi {
     this._verifyIntegers(columns, rows);
     this._core.resize(columns, rows);
   }
+  public writeln(data: string): void {
+    this._core.writeln(data);
+  }
   public open(parent: HTMLElement): void {
     this._core.open(parent);
   }
@@ -125,15 +128,11 @@ export class Terminal implements ITerminalApi {
   public clear(): void {
     this._core.clear();
   }
-  public write(data: string | Uint8Array, callback?: () => void): void {
-    this._core.write(data, callback);
-  }
-  public writeUtf8(data: Uint8Array, callback?: () => void): void {
-    this._core.write(data, callback);
-  }
-  public writeln(data: string | Uint8Array, callback?: () => void): void {
+  public write(data: string): void {
     this._core.write(data);
-    this._core.write('\r\n', callback);
+  }
+  public writeUtf8(data: Uint8Array): void {
+    this._core.writeUtf8(data);
   }
   public paste(data: string): void {
     this._core.paste(data);

test/api/InputHandler.api.ts

@@ -196,36 +196,6 @@ describe('InputHandler Integration Tests', function(): void {
       assert.deepEqual(await getLinesAsArray(5), ['   4', '    5', 'abc', 'def', 'ghi']);
     });
 
-    it('IL: Insert Ps Line(s) (default = 1) - CSI Ps L', async function(): Promise<any> {
-      await page.evaluate(`
-        // Default
-        window.term.write('foo\x1b[La')
-        // Explicit
-        window.term.write('\x1b[2Lb')
-      `);
-      assert.deepEqual(await getLinesAsArray(4), ['b', '', 'a', 'foo']);
-    });
-
-    it('DL: Delete Ps Line(s) (default = 1) - CSI Ps M', async function(): Promise<any> {
-      await page.evaluate(`
-        // Default
-        window.term.write('a\\nb\x1b[1F\x1b[M')
-        // Explicit
-        window.term.write('\x1b[1Ed\\ne\\nf\x1b[2F\x1b[2M')
-      `);
-      assert.deepEqual(await getLinesAsArray(5), [' b', '  f', '', '', '']);
-    });
-
-    it('DCH: Delete Ps Character(s) (default = 1) - CSI Ps P', async function(): Promise<any> {
-      await page.evaluate(`
-        // Default
-        window.term.write('abc\x1b[1;1H\x1b[P')
-        // Explicit
-        window.term.write('\\n\\rdef\x1b[2;1H\x1b[2P')
-      `);
-      assert.deepEqual(await getLinesAsArray(2), ['bc', 'f']);
-    });
-
     describe('DSR: Device Status Report', () => {
       it('Status Report - CSI 5 n', async function(): Promise<any> {
         await page.evaluate(`

test/api/Terminal.api.ts

@@ -51,44 +51,6 @@ describe('API Integration Tests', function(): void {
     assert.equal(await page.evaluate(`window.term.buffer.getLine(0).translateToString(true)`), 'foobar文');
   });
 
-  it('write with callback', async function(): Promise<any> {
-    await openTerminal();
-    await page.evaluate(`
-      window.term.write('foo', () => { window.__x = 'a'; });
-      window.term.write('bar', () => { window.__x += 'b'; });
-      window.term.write('文', () => { window.__x += 'c'; });
-    `);
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(0).translateToString(true)`), 'foobar文');
-    assert.equal(await page.evaluate(`window.__x`), 'abc');
-  });
-
-  it('write - bytes (UTF8)', async function(): Promise<any> {
-    await openTerminal();
-    await page.evaluate(`
-      // foo
-      window.term.write(new Uint8Array([102, 111, 111]));
-      // bar
-      window.term.write(new Uint8Array([98, 97, 114]));
-      // 文
-      window.term.write(new Uint8Array([230, 150, 135]));
-    `);
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(0).translateToString(true)`), 'foobar文');
-  });
-
-  it('write - bytes (UTF8) with callback', async function(): Promise<any> {
-    await openTerminal();
-    await page.evaluate(`
-      // foo
-      window.term.write(new Uint8Array([102, 111, 111]), () => { window.__x = 'A'; });
-      // bar
-      window.term.write(new Uint8Array([98, 97, 114]), () => { window.__x += 'B'; });
-      // 文
-      window.term.write(new Uint8Array([230, 150, 135]), () => { window.__x += 'C'; });
-    `);
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(0).translateToString(true)`), 'foobar文');
-    assert.equal(await page.evaluate(`window.__x`), 'ABC');
-  });
-
   it('writeln', async function(): Promise<any> {
     await openTerminal();
     await page.evaluate(`
@@ -101,29 +63,17 @@ describe('API Integration Tests', function(): void {
     assert.equal(await page.evaluate(`window.term.buffer.getLine(2).translateToString(true)`), '文');
   });
 
-  it('writeln with callback', async function(): Promise<any> {
+  it('writeUtf8', async function(): Promise<any> {
     await openTerminal();
     await page.evaluate(`
-      window.term.writeln('foo', () => { window.__x = '1'; });
-      window.term.writeln('bar', () => { window.__x += '2'; });
-      window.term.writeln('文', () => { window.__x += '3'; });
+      // foo
+      window.term.writeUtf8(new Uint8Array([102, 111, 111]));
+      // bar
+      window.term.writeUtf8(new Uint8Array([98, 97, 114]));
+      // 文
+      window.term.writeUtf8(new Uint8Array([230, 150, 135]));
     `);
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(0).translateToString(true)`), 'foo');
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(1).translateToString(true)`), 'bar');
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(2).translateToString(true)`), '文');
-    assert.equal(await page.evaluate(`window.__x`), '123');
-  });
-
-  it('writeln - bytes (UTF8)', async function(): Promise<any> {
-    await openTerminal();
-    await page.evaluate(`
-      window.term.writeln(new Uint8Array([102, 111, 111]));
-      window.term.writeln(new Uint8Array([98, 97, 114]));
-      window.term.writeln(new Uint8Array([230, 150, 135]));
-    `);
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(0).translateToString(true)`), 'foo');
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(1).translateToString(true)`), 'bar');
-    assert.equal(await page.evaluate(`window.term.buffer.getLine(2).translateToString(true)`), '文');
+    assert.equal(await page.evaluate(`window.term.buffer.getLine(0).translateToString(true)`), 'foobar文');
   });
 
   it('paste', async function(): Promise<any> {
@@ -133,9 +83,11 @@ describe('API Integration Tests', function(): void {
       window.term.onData(e => calls.push(e));
       window.term.paste('foo');
       window.term.paste('\\r\\nfoo\\nbar\\r');
-      window.term.write('\\x1b[?2004h', () => {
-        window.term.paste('foo');
-      });
+      window.term.write('\\x1b[?2004h');
+      // TODO: Use promise/callback for write when we support that
+      // Force sync write
+      window.term._core._innerWrite();
+      window.term.paste('foo');
     `);
     assert.deepEqual(await page.evaluate(`window.calls`), ['foo', '\rfoo\rbar\r', '\x1b[200~foo\x1b[201~']);
   });

test/benchmark/Terminal.benchmark.ts

@@ -9,6 +9,17 @@ import { spawn } from 'node-pty';
 import { Utf8ToUtf32, stringFromCodePoint } from 'common/input/TextDecoder';
 import { Terminal } from 'Terminal';
 
+class TestTerminal extends Terminal {
+  writeSync(data: string): void {
+    this.writeBuffer.push(data);
+    this._innerWrite();
+  }
+  writeSyncUtf8(data: Uint8Array): void {
+    this.writeBufferUtf8.push(data);
+    this._innerWriteUtf8();
+  }
+}
+
 perfContext('Terminal: ls -lR /usr/lib', () => {
   let content = '';
   let contentUtf8: Uint8Array;
@@ -45,9 +56,9 @@ perfContext('Terminal: ls -lR /usr/lib', () => {
   });
 
   perfContext('write', () => {
-    let terminal: Terminal;
+    let terminal: TestTerminal;
     before(() => {
-      terminal = new Terminal({cols: 80, rows: 25, scrollback: 1000});
+      terminal = new TestTerminal({cols: 80, rows: 25, scrollback: 1000});
     });
     new ThroughputRuntimeCase('', () => {
       terminal.writeSync(content);
@@ -56,12 +67,12 @@ perfContext('Terminal: ls -lR /usr/lib', () => {
   });
 
   perfContext('writeUtf8', () => {
-    let terminal: Terminal;
+    let terminal: TestTerminal;
     before(() => {
-      terminal = new Terminal({cols: 80, rows: 25, scrollback: 1000});
+      terminal = new TestTerminal({cols: 80, rows: 25, scrollback: 1000});
     });
     new ThroughputRuntimeCase('', () => {
-      terminal.writeSync(content);
+      terminal.writeSyncUtf8(contentUtf8);
       return {payloadSize: contentUtf8.length};
     }, {fork: false}).showAverageThroughput();
   });

typings/xterm.d.ts

@@ -650,32 +650,24 @@ declare module 'xterm' {
     clear(): void;
 
     /**
-     * Write data to the terminal.
-     * @param data The data to write to the terminal. This can either be raw
-     * bytes given as Uint8Array from the pty or a string. Raw bytes will always
-     * be treated as UTF-8 encoded, string data as UTF-16.
-     * @param callback Optional callback that fires when the data was processed
-     * by the parser.
+     * Writes text to the terminal.
+     * @param data The text to write to the terminal.
      */
-    write(data: string | Uint8Array, callback?: () => void): void;
+    write(data: string): void;
 
     /**
-     * Writes data to the terminal, followed by a break line character (\n).
-     * @param data The data to write to the terminal. This can either be raw
-     * bytes given as Uint8Array from the pty or a string. Raw bytes will always
-     * be treated as UTF-8 encoded, string data as UTF-16.
-     * @param callback Optional callback that fires when the data was processed
-     * by the parser.
+     * Writes text to the terminal, followed by a break line character (\n).
+     * @param data The text to write to the terminal.
      */
-    writeln(data: string | Uint8Array, callback?: () => void): void;
+    writeln(data: string): void;
 
     /**
-     * Write UTF8 data to the terminal.
+     * Writes UTF8 data to the terminal. This has a slight performance advantage
+     * over the string based write method due to lesser data conversions needed
+     * on the way from the pty to xterm.js.
      * @param data The data to write to the terminal.
-     * @param callback Optional callback when data was processed.
-     * @deprecated use `write` instead
      */
-    writeUtf8(data: Uint8Array, callback?: () => void): void;
+    writeUtf8(data: Uint8Array): void;
 
     /**
      * Writes text to the terminal, performing the necessary transformations for pasted text.

yarn.lock

@@ -4719,12 +4719,7 @@ typedarray@^0.0.6:
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
 
-typescript@3.6:
-  version "3.6.3"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.6.3.tgz#fea942fabb20f7e1ca7164ff626f1a9f3f70b4da"
-  integrity sha512-N7bceJL1CtRQ2RiG0AQME13ksR7DiuQh/QehubYcghzv20tnh+MQnQIuJddTmsbqYj+dztchykemz0zFzlvdQw==
-
-typescript@^3.5.1:
+typescript@3.5, typescript@^3.5.1:
   version "3.5.1"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.5.1.tgz#ba72a6a600b2158139c5dd8850f700e231464202"
   integrity sha512-64HkdiRv1yYZsSe4xC1WVgamNigVYjlssIoaH2HcZF0+ijsk5YK2g0G34w9wJkze8+5ow4STd22AynfO6ZYYLw==