@xterm/xterm 5.6.0-beta.1 → 5.6.0-beta.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xterm/xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "5.6.0-beta.1",
+  "version": "5.6.0-beta.11",
   "main": "lib/xterm.js",
   "style": "css/xterm.css",
   "types": "typings/xterm.d.ts",

package/src/browser/Viewport.ts

@@ -36,6 +36,8 @@ export class Viewport extends Disposable implements IViewport {
   private _activeBuffer: IBuffer;
   private _renderDimensions: IRenderDimensions;
 
+  private _smoothScrollAnimationFrame: number = 0;
+
   // Stores a partial line amount when scrolling, this is used to keep track of how much of a line
   // is scrolled so we can "scroll" over partial lines and feel natural on touchpads. This is a
   // quick fix and could have a more robust solution in place that reset the value when needed.
@@ -49,6 +51,8 @@ export class Viewport extends Disposable implements IViewport {
     target: -1
   };
 
+  private _ensureTimeout: number;
+
   private readonly _onRequestScrollLines = this.register(new EventEmitter<{ amount: number, suppressScrollEvent: boolean }>());
   public readonly onRequestScrollLines = this._onRequestScrollLines.event;
 
@@ -81,7 +85,7 @@ export class Viewport extends Disposable implements IViewport {
     this.register(this._optionsService.onSpecificOptionChange('scrollback', () => this.syncScrollArea()));
 
     // Perform this async to ensure the ICharSizeService is ready.
-    setTimeout(() => this.syncScrollArea());
+    this._ensureTimeout = window.setTimeout(() => this.syncScrollArea());
   }
 
   private _handleThemeChange(colors: ReadonlyColorSet): void {
@@ -211,7 +215,12 @@ export class Viewport extends Disposable implements IViewport {
 
     // Continue or finish smooth scroll
     if (percent < 1) {
-      this._coreBrowserService.window.requestAnimationFrame(() => this._smoothScroll());
+      if (!this._smoothScrollAnimationFrame) {
+        this._smoothScrollAnimationFrame = this._coreBrowserService.window.requestAnimationFrame(() => {
+          this._smoothScrollAnimationFrame = 0;
+          this._smoothScroll();
+        });
+      }
     } else {
       this._clearSmoothScrollState();
     }
@@ -398,4 +407,8 @@ export class Viewport extends Disposable implements IViewport {
     this._viewportElement.scrollTop += deltaY;
     return this._bubbleScroll(ev, deltaY);
   }
+
+  public dispose(): void {
+    clearTimeout(this._ensureTimeout);
+  }
 }

package/src/browser/public/Terminal.ts

@@ -20,6 +20,8 @@ import { IBufferNamespace as IBufferNamespaceApi, IDecoration, IDecorationOption
  */
 const CONSTRUCTOR_ONLY_OPTIONS = ['cols', 'rows'];
 
+let $value = 0;
+
 export class Terminal extends Disposable implements ITerminalApi {
   private _core: ITerminal;
   private _addonManager: AddonManager;
@@ -249,16 +251,16 @@ export class Terminal extends Disposable implements ITerminalApi {
   }
 
   private _verifyIntegers(...values: number[]): void {
-    for (const value of values) {
-      if (value === Infinity || isNaN(value) || value % 1 !== 0) {
+    for ($value of values) {
+      if ($value === Infinity || isNaN($value) || $value % 1 !== 0) {
         throw new Error('This API only accepts integers');
       }
     }
   }
 
   private _verifyPositiveIntegers(...values: number[]): void {
-    for (const value of values) {
-      if (value && (value === Infinity || isNaN(value) || value % 1 !== 0 || value < 0)) {
+    for ($value of values) {
+      if ($value && ($value === Infinity || isNaN($value) || $value % 1 !== 0 || $value < 0)) {
         throw new Error('This API only accepts positive integers');
       }
     }

package/src/browser/renderer/dom/DomRenderer.ts

@@ -343,6 +343,9 @@ export class DomRenderer extends Disposable implements IRenderer {
     }
 
     this._selectionRenderModel.update(this._terminal, start, end, columnSelectMode);
+    if (!this._selectionRenderModel.hasSelection) {
+      return;
+    }
 
     // Translate from buffer position to viewport position
     const viewportStartRow = this._selectionRenderModel.viewportStartRow;
@@ -350,11 +353,6 @@ export class DomRenderer extends Disposable implements IRenderer {
     const viewportCappedStartRow = this._selectionRenderModel.viewportCappedStartRow;
     const viewportCappedEndRow = this._selectionRenderModel.viewportCappedEndRow;
 
-    // No need to draw the selection
-    if (viewportCappedStartRow >= this._bufferService.rows || viewportCappedEndRow < 0) {
-      return;
-    }
-
     // Create the selections
     const documentFragment = this._document.createDocumentFragment();
 

package/src/common/InputHandler.ts

@@ -2979,7 +2979,7 @@ export class InputHandler extends Disposable implements IInputHandler {
     if (args[1]) {
       return this._createHyperlink(args[0], args[1]);
     }
-    if (args[0]) {
+    if (args[0].trim()) {
       return false;
     }
     return this._finishHyperlink();

package/src/common/SortedList.ts

@@ -3,16 +3,27 @@
  * @license MIT
  */
 
+import { IdleTaskQueue } from 'common/TaskQueue';
+
 // Work variables to avoid garbage collection.
 let i = 0;
 
 /**
- * A generic list that is maintained in sorted order and allows values with duplicate keys. This
- * list is based on binary search and as such locating a key will take O(log n) amortized, this
- * includes the by key iterator.
+ * A generic list that is maintained in sorted order and allows values with duplicate keys. Deferred
+ * batch insertion and deletion is used to significantly reduce the time it takes to insert and
+ * delete a large amount of items in succession. This list is based on binary search and as such
+ * locating a key will take O(log n) amortized, this includes the by key iterator.
  */
 export class SortedList<T> {
-  private readonly _array: T[] = [];
+  private _array: T[] = [];
+
+  private readonly _insertedValues: T[] = [];
+  private readonly _flushInsertedTask = new IdleTaskQueue();
+  private _isFlushingInserted = false;
+
+  private readonly _deletedIndices: number[] = [];
+  private readonly _flushDeletedTask = new IdleTaskQueue();
+  private _isFlushingDeleted = false;
 
   constructor(
     private readonly _getKey: (value: T) => number
@@ -21,18 +32,50 @@ export class SortedList<T> {
 
   public clear(): void {
     this._array.length = 0;
+    this._insertedValues.length = 0;
+    this._flushInsertedTask.clear();
+    this._isFlushingInserted = false;
+    this._deletedIndices.length = 0;
+    this._flushDeletedTask.clear();
+    this._isFlushingDeleted = false;
   }
 
   public insert(value: T): void {
-    if (this._array.length === 0) {
-      this._array.push(value);
-      return;
+    this._flushCleanupDeleted();
+    if (this._insertedValues.length === 0) {
+      this._flushInsertedTask.enqueue(() => this._flushInserted());
+    }
+    this._insertedValues.push(value);
+  }
+
+  private _flushInserted(): void {
+    const sortedAddedValues = this._insertedValues.sort((a, b) => this._getKey(a) - this._getKey(b));
+    let sortedAddedValuesIndex = 0;
+    let arrayIndex = 0;
+
+    const newArray = new Array(this._array.length + this._insertedValues.length);
+
+    for (let newArrayIndex = 0; newArrayIndex < newArray.length; newArrayIndex++) {
+      if (arrayIndex >= this._array.length || this._getKey(sortedAddedValues[sortedAddedValuesIndex]) <= this._getKey(this._array[arrayIndex])) {
+        newArray[newArrayIndex] = sortedAddedValues[sortedAddedValuesIndex];
+        sortedAddedValuesIndex++;
+      } else {
+        newArray[newArrayIndex] = this._array[arrayIndex++];
+      }
+    }
+
+    this._array = newArray;
+    this._insertedValues.length = 0;
+  }
+
+  private _flushCleanupInserted(): void {
+    if (!this._isFlushingInserted && this._insertedValues.length > 0) {
+      this._flushInsertedTask.flush();
     }
-    i = this._search(this._getKey(value));
-    this._array.splice(i, 0, value);
   }
 
   public delete(value: T): boolean {
+    this._flushCleanupInserted();
     if (this._array.length === 0) {
       return false;
     }
@@ -49,14 +92,43 @@ export class SortedList<T> {
     }
     do {
       if (this._array[i] === value) {
-        this._array.splice(i, 1);
+        if (this._deletedIndices.length === 0) {
+          this._flushDeletedTask.enqueue(() => this._flushDeleted());
+        }
+        this._deletedIndices.push(i);
         return true;
       }
     } while (++i < this._array.length && this._getKey(this._array[i]) === key);
     return false;
   }
 
+  private _flushDeleted(): void {
+    this._isFlushingDeleted = true;
+    const sortedDeletedIndices = this._deletedIndices.sort((a, b) => a - b);
+    let sortedDeletedIndicesIndex = 0;
+    const newArray = new Array(this._array.length - sortedDeletedIndices.length);
+    let newArrayIndex = 0;
+    for (let i = 0; i < this._array.length; i++) {
+      if (sortedDeletedIndices[sortedDeletedIndicesIndex] === i) {
+        sortedDeletedIndicesIndex++;
+      } else {
+        newArray[newArrayIndex++] = this._array[i];
+      }
+    }
+    this._array = newArray;
+    this._deletedIndices.length = 0;
+    this._isFlushingDeleted = false;
+  }
+
+  private _flushCleanupDeleted(): void {
+    if (!this._isFlushingDeleted && this._deletedIndices.length > 0) {
+      this._flushDeletedTask.flush();
+    }
+  }
+
   public *getKeyIterator(key: number): IterableIterator<T> {
+    this._flushCleanupInserted();
+    this._flushCleanupDeleted();
     if (this._array.length === 0) {
       return;
     }
@@ -73,6 +145,8 @@ export class SortedList<T> {
   }
 
   public forEachByKey(key: number, callback: (value: T) => void): void {
+    this._flushCleanupInserted();
+    this._flushCleanupDeleted();
     if (this._array.length === 0) {
       return;
     }
@@ -89,6 +163,8 @@ export class SortedList<T> {
   }
 
   public values(): IterableIterator<T> {
+    this._flushCleanupInserted();
+    this._flushCleanupDeleted();
     // Duplicate the array to avoid issues when _array changes while iterating
     return [...this._array].values();
   }

package/src/common/services/DecorationService.ts

@@ -45,7 +45,8 @@ export class DecorationService extends Disposable implements IDecorationService
     const decoration = new Decoration(options);
     if (decoration) {
       const markerDispose = decoration.marker.onDispose(() => decoration.dispose());
-      decoration.onDispose(() => {
+      const listener = decoration.onDispose(() => {
+        listener.dispose();
         if (decoration) {
           if (this._decorations.delete(decoration)) {
             this._onDecorationRemoved.fire(decoration);

package/typings/xterm.d.ts

@@ -47,11 +47,13 @@ declare module '@xterm/xterm' {
 
     /**
      * When enabled the cursor will be set to the beginning of the next line
-     * with every new line. This is equivalent to sending '\r\n' for each '\n'.
-     * Normally the termios settings of the underlying PTY deals with the
-     * translation of '\n' to '\r\n' and this setting should not be used. If you
+     * with every new line. This is equivalent to sending `\r\n` for each `\n`.
+     * Normally the settings of the underlying PTY (`termios`) deal with the
+     * translation of `\n` to `\r\n` and this setting should not be used. If you
      * deal with data from a non-PTY related source, this settings might be
      * useful.
+     *
+     * @see https://pubs.opengroup.org/onlinepubs/007904975/basedefs/termios.h.html
      */
     convertEol?: boolean;