Use Terminal type in attach, fit and fullscreen

src/addons/attach/Intefaces.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * Implements the attach method, that attaches the terminal to a WebSocket stream.
+ */
+
+import { Terminal } from 'xterm';
+
+export interface IAttachAddonTerminal extends Terminal {
+  __socket?: WebSocket;
+  __attachSocketBuffer?: string;
+
+  __getMessage?(ev: MessageEvent): void;
+  __flushBuffer?(): void;
+  __pushToBuffer?(data: string): void;
+  __sendData?(data: string): void;
+}

src/addons/attach/attach.test.ts

@@ -12,7 +12,7 @@ class MockTerminal {}
 describe('attach addon', () => {
   describe('apply', () => {
     it('should do register the `attach` and `detach` methods', () => {
-      attach.apply(MockTerminal);
+      attach.apply(<any>MockTerminal);
       assert.equal(typeof (<any>MockTerminal).prototype.attach, 'function');
       assert.equal(typeof (<any>MockTerminal).prototype.detach, 'function');
     });

src/addons/attach/attach.ts

@@ -5,38 +5,42 @@
  * Implements the attach method, that attaches the terminal to a WebSocket stream.
  */
 
+/// <reference path="../../../typings/xterm.d.ts"/>
+
+import { Terminal } from 'xterm';
+import { IAttachAddonTerminal } from './Intefaces';
+
 /**
  * Attaches the given terminal to the given socket.
  *
- * @param {Terminal} term - The terminal to be attached to the given socket.
- * @param {WebSocket} socket - The socket to attach the current terminal.
- * @param {boolean} bidirectional - Whether the terminal should send data
- *                                  to the socket as well.
- * @param {boolean} buffered - Whether the rendering of incoming data
- *                             should happen instantly or at a maximum
- *                             frequency of 1 rendering per 10ms.
+ * @param term The terminal to be attached to the given socket.
+ * @param socket The socket to attach the current terminal.
+ * @param bidirectional Whether the terminal should send data to the socket as well.
+ * @param buffered Whether the rendering of incoming data should happen instantly or at a maximum
+ * frequency of 1 rendering per 10ms.
  */
-export function attach(term: any, socket: WebSocket, bidirectional: boolean, buffered: boolean): void {
+export function attach(term: Terminal, socket: WebSocket, bidirectional: boolean, buffered: boolean): void {
+  const addonTerminal = <IAttachAddonTerminal>term;
   bidirectional = (typeof bidirectional === 'undefined') ? true : bidirectional;
-  term.socket = socket;
+  addonTerminal.__socket = socket;
 
-  term._flushBuffer = () => {
-    term.write(term._attachSocketBuffer);
-    term._attachSocketBuffer = null;
+  addonTerminal.__flushBuffer = () => {
+    addonTerminal.write(addonTerminal.__attachSocketBuffer);
+    addonTerminal.__attachSocketBuffer = null;
   };
 
-  term._pushToBuffer = (data: string) => {
-    if (term._attachSocketBuffer) {
-      term._attachSocketBuffer += data;
+  addonTerminal.__pushToBuffer = (data: string) => {
+    if (addonTerminal.__attachSocketBuffer) {
+      addonTerminal.__attachSocketBuffer += data;
     } else {
-      term._attachSocketBuffer = data;
-      setTimeout(term._flushBuffer, 10);
+      addonTerminal.__attachSocketBuffer = data;
+      setTimeout(addonTerminal.__flushBuffer, 10);
     }
   };
 
   let myTextDecoder;
 
-  term._getMessage = function(ev: MessageEvent): void {
+  addonTerminal.__getMessage = function(ev: MessageEvent): void {
     let str;
     if (typeof ev.data === 'object') {
       if (ev.data instanceof ArrayBuffer) {
@@ -51,71 +55,68 @@ export function attach(term: any, socket: WebSocket, bidirectional: boolean, buf
     }
 
     if (buffered) {
-      term._pushToBuffer(str || ev.data);
+      addonTerminal.__pushToBuffer(str || ev.data);
     } else {
-      term.write(str || ev.data);
+      addonTerminal.write(str || ev.data);
     }
   };
 
-  term._sendData = (data: string) => {
+  addonTerminal.__sendData = (data: string) => {
     if (socket.readyState !== 1) {
       return;
     }
     socket.send(data);
   };
 
-  socket.addEventListener('message', term._getMessage);
+  socket.addEventListener('message', addonTerminal.__getMessage);
 
   if (bidirectional) {
-    term.on('data', term._sendData);
+    addonTerminal.on('data', addonTerminal.__sendData);
   }
 
-  socket.addEventListener('close', term.detach.bind(term, socket));
-  socket.addEventListener('error', term.detach.bind(term, socket));
+  socket.addEventListener('close', () => detach(addonTerminal, socket));
+  socket.addEventListener('error', () => detach(addonTerminal, socket));
 }
 
 /**
  * Detaches the given terminal from the given socket
  *
- * @param {Terminal} term - The terminal to be detached from the given socket.
- * @param {WebSocket} socket - The socket from which to detach the current
- *                             terminal.
+ * @param term The terminal to be detached from the given socket.
+ * @param socket The socket from which to detach the current terminal.
  */
-export function detach(term: any, socket: WebSocket): void {
-  term.off('data', term._sendData);
+export function detach(term: Terminal, socket: WebSocket): void {
+  const addonTerminal = <IAttachAddonTerminal>term;
+  addonTerminal.off('data', addonTerminal.__sendData);
 
-  socket = (typeof socket === 'undefined') ? term.socket : socket;
+  socket = (typeof socket === 'undefined') ? addonTerminal.__socket : socket;
 
   if (socket) {
-    socket.removeEventListener('message', term._getMessage);
+    socket.removeEventListener('message', addonTerminal.__getMessage);
   }
 
-  delete term.socket;
+  delete addonTerminal.__socket;
 }
 
 
-export function apply(terminalConstructor: any): void {
+export function apply(terminalConstructor: typeof Terminal): void {
   /**
    * Attaches the current terminal to the given socket
    *
-   * @param {WebSocket} socket - The socket to attach the current terminal.
-   * @param {boolean} bidirectional - Whether the terminal should send data
-   *                                  to the socket as well.
-   * @param {boolean} buffered - Whether the rendering of incoming data
-   *                             should happen instantly or at a maximum
-   *                             frequency of 1 rendering per 10ms.
+   * @param socket The socket to attach the current terminal.
+   * @param bidirectional Whether the terminal should send data to the socket as well.
+   * @param buffered Whether the rendering of incoming data should happen instantly or at a maximum
+   * frequency of 1 rendering per 10ms.
    */
-  terminalConstructor.prototype.attach = function (socket: WebSocket, bidirectional: boolean, buffered: boolean): void {
+  (<any>terminalConstructor.prototype).attach = function (socket: WebSocket, bidirectional: boolean, buffered: boolean): void {
     attach(this, socket, bidirectional, buffered);
   };
 
   /**
    * Detaches the current terminal from the given socket.
    *
-   * @param {WebSocket} socket - The socket from which to detach the current
-   *                             terminal.
+   * @param socket The socket from which to detach the current terminal.
    */
-  terminalConstructor.prototype.detach = function (socket: WebSocket): void {
+  (<any>terminalConstructor.prototype).detach = function (socket: WebSocket): void {
     detach(this, socket);
   };
 }