Merge remote-tracking branch 'ups/master' into pr/jerch/2393

src/common/services/OptionsService.ts

@@ -53,7 +53,7 @@ export const DEFAULT_OPTIONS: ITerminalOptions = Object.freeze({
   cancelEvents: false,
   useFlowControl: false,
   windowOptions: {},
-  wordSeparator: ' ()[]{}\',:;"`'
+  wordSeparator: ' ()[]{}\',"`'
 });
 
 /**

src/common/services/Services.ts

@@ -309,3 +309,25 @@ export interface ITheme {
   brightWhite?: string;
 }
 
+export const IUnicodeService = createDecorator<IUnicodeService>('UnicodeService');
+export interface IUnicodeService {
+  /** Register an Unicode version provider. */
+  register(provider: IUnicodeVersionProvider): void;
+  /** Registered Unicode versions. */
+  readonly versions: string[];
+  /** Currently active version. */
+  activeVersion: string;
+  /** Event triggered, when activate version changed. */
+  readonly onChange: IEvent<string>;
+
+  /**
+   * Unicode version dependent
+   */
+  wcwidth(codepoint: number): number;
+  getStringCellWidth(s: string): number;
+}
+
+export interface IUnicodeVersionProvider {
+  readonly version: string;
+  wcwidth(ucs: number): 0 | 1 | 2;
+}

src/common/services/UnicodeService.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { assert } from 'chai';
+import { UnicodeService } from 'common/services/UnicodeService';
+import { IUnicodeVersionProvider } from 'common/services/Services';
+
+class DummyProvider implements IUnicodeVersionProvider {
+  version = '123';
+  wcwidth(n: number): 0 | 1 | 2 {
+    return 2;
+  }
+}
+
+describe('unicode provider', () => {
+  let us: UnicodeService;
+  beforeEach(() => {
+    us = new UnicodeService();
+  });
+  it('default to V6', () => {
+    assert.equal(us.activeVersion, '6');
+    assert.deepEqual(us.versions, ['6']);
+    assert.doesNotThrow(() => { us.activeVersion = '6'; }, `unknown Unicode version "6"`);
+    assert.equal(us.getStringCellWidth('hello'), 5);
+  });
+  it('activate should throw for unknown version', () => {
+    assert.throws(() => { us.activeVersion = '55'; }, 'unknown Unicode version "55"');
+  });
+  it('should notify about version change', () => {
+    const notes: string[] = [];
+    us.onChange(version => notes.push(version));
+    const dummyProvider = new DummyProvider();
+    us.register(dummyProvider);
+    us.activeVersion = dummyProvider.version;
+    assert.deepEqual(notes, [dummyProvider.version]);
+  });
+  it('correctly changes provider impl', () => {
+    assert.equal(us.getStringCellWidth('hello'), 5);
+    const dummyProvider = new DummyProvider();
+    us.register(dummyProvider);
+    us.activeVersion = dummyProvider.version;
+    assert.equal(us.getStringCellWidth('hello'), 2 * 5);
+  });
+  it('wcwidth V6 emoji test', () => {
+    const widthV6 = us.getStringCellWidth('🤣🤣🤣🤣🤣🤣🤣🤣🤣🤣');
+    assert.equal(widthV6, 10);
+  });
+});

src/common/services/UnicodeService.ts

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+import { IUnicodeService, IUnicodeVersionProvider } from 'common/services/Services';
+import { EventEmitter, IEvent } from 'common/EventEmitter';
+import { UnicodeV6 } from 'common/input/UnicodeV6';
+
+
+export class UnicodeService implements IUnicodeService {
+  private _providers: {[key: string]: IUnicodeVersionProvider} = Object.create(null);
+  private _active: string = '';
+  private _activeProvider: IUnicodeVersionProvider;
+  private _onChange = new EventEmitter<string>();
+  public get onChange(): IEvent<string> { return this._onChange.event; }
+
+  constructor() {
+    const defaultProvider = new UnicodeV6();
+    this.register(defaultProvider);
+    this._active = defaultProvider.version;
+    this._activeProvider = defaultProvider;
+  }
+
+  public get versions(): string[] {
+    return Object.keys(this._providers);
+  }
+
+  public get activeVersion(): string {
+    return this._active;
+  }
+
+  public set activeVersion(version: string) {
+    if (!this._providers[version]) {
+      throw new Error(`unknown Unicode version "${version}"`);
+    }
+    this._active = version;
+    this._activeProvider = this._providers[version];
+    this._onChange.fire(version);
+  }
+
+  public register(provider: IUnicodeVersionProvider): void {
+    this._providers[provider.version] = provider;
+  }
+
+  /**
+   * Unicode version dependent interface.
+   */
+  public wcwidth(num: number): number {
+    return this._activeProvider.wcwidth(num);
+  }
+
+  public getStringCellWidth(s: string): number {
+    let result = 0;
+    const length = s.length;
+    for (let i = 0; i < length; ++i) {
+      let code = s.charCodeAt(i);
+      // surrogate pair first
+      if (0xD800 <= code && code <= 0xDBFF) {
+        if (++i >= length) {
+          // this should not happen with strings retrieved from
+          // Buffer.translateToString as it converts from UTF-32
+          // and therefore always should contain the second part
+          // for any other string we still have to handle it somehow:
+          // simply treat the lonely surrogate first as a single char (UCS-2 behavior)
+          return result + this.wcwidth(code);
+        }
+        const second = s.charCodeAt(i);
+        // convert surrogate pair to high codepoint only for valid second part (UTF-16)
+        // otherwise treat them independently (UCS-2 behavior)
+        if (0xDC00 <= second && second <= 0xDFFF) {
+          code = (code - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+        } else {
+          result += this.wcwidth(second);
+        }
+      }
+      result += this.wcwidth(code);
+    }
+    return result;
+  }
+}