UnicodeService & provider

src/common/services/Services.ts

@@ -285,15 +285,13 @@ export interface ITheme {
 export const IUnicodeService = createDecorator<IUnicodeService>('UnicodeService');
 export interface IUnicodeService {
   /** Register an Unicode version provider. */
-  registerVersion(provider: IUnicodeVersionProvider): void;
+  register(provider: IUnicodeVersionProvider): void;
   /** Registered Unicode versions. */
   readonly versions: string[];
   /** Currently active version. */
   readonly activeVersion: string;
   /** Event triggered, when activate version changed. */
   readonly onChange: IEvent<string>;
-  /** Event triggered, when a new version provider was registered. */
-  readonly onRegister: IEvent<string>;
 
   /**
    * Unicode version dependent

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): number {
+    return 123;
+  }
+}
+
+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'), 123 * 5);
+  });
+  it('wcwidth V6 emoji test', () => {
+    const widthV6 = us.getStringCellWidth('🤣🤣🤣🤣🤣🤣🤣🤣🤣🤣');
+    assert.equal(widthV6, 10);
+  });
+});

src/common/services/UnicodeService.ts

@@ -4,16 +4,23 @@
  */
 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 _onRegister = new EventEmitter<string>();
-  public get onRegister(): IEvent<string> { return this._onRegister.event; }
+  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);
   }
@@ -27,22 +34,20 @@ export class UnicodeService implements IUnicodeService {
       throw new Error(`unknown Unicode version "${version}"`);
     }
     this._active = version;
-    this.wcwidth = (num: number) => this._providers[version].wcwidth(num);  // perf an issue here?
+    this._activeProvider = this._providers[version];
     this._onChange.fire(version);
   }
 
-  public registerVersion(provider: IUnicodeVersionProvider): void {
+  public register(provider: IUnicodeVersionProvider): void {
     this._providers[provider.version] = provider;
-    this._onRegister.fire(provider.version);
-    if (!this.activeVersion) {
-      this.activeVersion = provider.version;
-    }
   }
 
   /**
    * Unicode version dependent interface.
    */
-  public wcwidth: (num: number) => number = () => { throw new Error('no Unicode version registered and activated'); }
+  public wcwidth(num: number): number {
+    return this._activeProvider.wcwidth(num);
+  }
 
   public getStringCellWidth(s: string): number {
     let result = 0;