@wendongfly/myhi 1.0.2 → 1.0.4

package/dist/lib/xterm/src/common/services/InstantiationService.ts

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * This was heavily inspired from microsoft/vscode's dependency injection system (MIT).
+ */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IInstantiationService, IServiceIdentifier } from 'common/services/Services';
+import { getServiceDependencies } from 'common/services/ServiceRegistry';
+
+export class ServiceCollection {
+
+  private _entries = new Map<IServiceIdentifier<any>, any>();
+
+  constructor(...entries: [IServiceIdentifier<any>, any][]) {
+    for (const [id, service] of entries) {
+      this.set(id, service);
+    }
+  }
+
+  public set<T>(id: IServiceIdentifier<T>, instance: T): T {
+    const result = this._entries.get(id);
+    this._entries.set(id, instance);
+    return result;
+  }
+
+  public forEach(callback: (id: IServiceIdentifier<any>, instance: any) => any): void {
+    this._entries.forEach((value, key) => callback(key, value));
+  }
+
+  public has(id: IServiceIdentifier<any>): boolean {
+    return this._entries.has(id);
+  }
+
+  public get<T>(id: IServiceIdentifier<T>): T | undefined {
+    return this._entries.get(id);
+  }
+}
+
+export class InstantiationService implements IInstantiationService {
+  public serviceBrand: undefined;
+
+  private readonly _services: ServiceCollection = new ServiceCollection();
+
+  constructor() {
+    this._services.set(IInstantiationService, this);
+  }
+
+  public setService<T>(id: IServiceIdentifier<T>, instance: T): void {
+    this._services.set(id, instance);
+  }
+
+  public getService<T>(id: IServiceIdentifier<T>): T | undefined {
+    return this._services.get(id);
+  }
+
+  public createInstance<T>(ctor: any, ...args: any[]): T {
+    const serviceDependencies = getServiceDependencies(ctor).sort((a, b) => a.index - b.index);
+
+    const serviceArgs: any[] = [];
+    for (const dependency of serviceDependencies) {
+      const service = this._services.get(dependency.id);
+      if (!service) {
+        throw new Error(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`);
+      }
+      serviceArgs.push(service);
+    }
+
+    const firstServiceArgPos = serviceDependencies.length > 0 ? serviceDependencies[0].index : args.length;
+
+    // check for argument mismatches, adjust static args if needed
+    if (args.length !== firstServiceArgPos) {
+      throw new Error(`[createInstance] First service dependency of ${ctor.name} at position ${firstServiceArgPos + 1} conflicts with ${args.length} static arguments`);
+    }
+
+    // now create the instance
+    return new ctor(...[...args, ...serviceArgs]);
+  }
+}

package/dist/lib/xterm/src/common/services/LogService.ts

@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { ILogService, IOptionsService, LogLevelEnum } from 'common/services/Services';
+
+type LogType = (message?: any, ...optionalParams: any[]) => void;
+
+interface IConsole {
+  log: LogType;
+  error: LogType;
+  info: LogType;
+  trace: LogType;
+  warn: LogType;
+}
+
+// console is available on both node.js and browser contexts but the common
+// module doesn't depend on them so we need to explicitly declare it.
+declare const console: IConsole;
+
+const optionsKeyToLogLevel: { [key: string]: LogLevelEnum } = {
+  debug: LogLevelEnum.DEBUG,
+  info: LogLevelEnum.INFO,
+  warn: LogLevelEnum.WARN,
+  error: LogLevelEnum.ERROR,
+  off: LogLevelEnum.OFF
+};
+
+const LOG_PREFIX = 'xterm.js: ';
+
+export class LogService implements ILogService {
+  public serviceBrand: any;
+
+  public logLevel: LogLevelEnum = LogLevelEnum.OFF;
+
+  constructor(
+    @IOptionsService private readonly _optionsService: IOptionsService
+  ) {
+    this._updateLogLevel();
+    this._optionsService.onOptionChange(key => {
+      if (key === 'logLevel') {
+        this._updateLogLevel();
+      }
+    });
+  }
+
+  private _updateLogLevel(): void {
+    this.logLevel = optionsKeyToLogLevel[this._optionsService.rawOptions.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);
+  }
+
+  public debug(message: string, ...optionalParams: any[]): void {
+    if (this.logLevel <= LogLevelEnum.DEBUG) {
+      this._log(console.log, message, optionalParams);
+    }
+  }
+
+  public info(message: string, ...optionalParams: any[]): void {
+    if (this.logLevel <= LogLevelEnum.INFO) {
+      this._log(console.info, message, optionalParams);
+    }
+  }
+
+  public warn(message: string, ...optionalParams: any[]): void {
+    if (this.logLevel <= LogLevelEnum.WARN) {
+      this._log(console.warn, message, optionalParams);
+    }
+  }
+
+  public error(message: string, ...optionalParams: any[]): void {
+    if (this.logLevel <= LogLevelEnum.ERROR) {
+      this._log(console.error, message, optionalParams);
+    }
+  }
+}

package/dist/lib/xterm/src/common/services/OptionsService.ts

@@ -0,0 +1,178 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IOptionsService, ITerminalOptions, FontWeight } from 'common/services/Services';
+import { EventEmitter, IEvent } from 'common/EventEmitter';
+import { isMac } from 'common/Platform';
+
+// Source: https://freesound.org/people/altemark/sounds/45759/
+// This sound is released under the Creative Commons Attribution 3.0 Unported
+// (CC BY 3.0) license. It was created by 'altemark'. No modifications have been
+// made, apart from the conversion to base64.
+export const DEFAULT_BELL_SOUND = 'data:audio/mp3;base64,SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU4LjMyLjEwNAAAAAAAAAAAAAAA//tQxAADB8AhSmxhIIEVCSiJrDCQBTcu3UrAIwUdkRgQbFAZC1CQEwTJ9mjRvBA4UOLD8nKVOWfh+UlK3z/177OXrfOdKl7pyn3Xf//WreyTRUoAWgBgkOAGbZHBgG1OF6zM82DWbZaUmMBptgQhGjsyYqc9ae9XFz280948NMBWInljyzsNRFLPWdnZGWrddDsjK1unuSrVN9jJsK8KuQtQCtMBjCEtImISdNKJOopIpBFpNSMbIHCSRpRR5iakjTiyzLhchUUBwCgyKiweBv/7UsQbg8isVNoMPMjAAAA0gAAABEVFGmgqK////9bP/6XCykxBTUUzLjEwMKqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq';
+
+export const DEFAULT_OPTIONS: Readonly<ITerminalOptions> = {
+  cols: 80,
+  rows: 24,
+  cursorBlink: false,
+  cursorStyle: 'block',
+  cursorWidth: 1,
+  customGlyphs: true,
+  bellSound: DEFAULT_BELL_SOUND,
+  bellStyle: 'none',
+  drawBoldTextInBrightColors: true,
+  fastScrollModifier: 'alt',
+  fastScrollSensitivity: 5,
+  fontFamily: 'courier-new, courier, monospace',
+  fontSize: 15,
+  fontWeight: 'normal',
+  fontWeightBold: 'bold',
+  lineHeight: 1.0,
+  linkTooltipHoverDuration: 500,
+  letterSpacing: 0,
+  logLevel: 'info',
+  scrollback: 1000,
+  scrollSensitivity: 1,
+  screenReaderMode: false,
+  macOptionIsMeta: false,
+  macOptionClickForcesSelection: false,
+  minimumContrastRatio: 1,
+  disableStdin: false,
+  allowProposedApi: true,
+  allowTransparency: false,
+  tabStopWidth: 8,
+  theme: {},
+  rightClickSelectsWord: isMac,
+  rendererType: 'canvas',
+  windowOptions: {},
+  windowsMode: false,
+  wordSeparator: ' ()[]{}\',"`',
+  altClickMovesCursor: true,
+  convertEol: false,
+  termName: 'xterm',
+  cancelEvents: false,
+  overviewRulerWidth: undefined
+};
+
+const FONT_WEIGHT_OPTIONS: Extract<FontWeight, string>[] = ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'];
+
+export class OptionsService implements IOptionsService {
+  public serviceBrand: any;
+
+  public readonly rawOptions: ITerminalOptions;
+  public options: ITerminalOptions;
+
+  private _onOptionChange = new EventEmitter<string>();
+  public get onOptionChange(): IEvent<string> { return this._onOptionChange.event; }
+
+  constructor(options: Partial<ITerminalOptions>) {
+    // set the default value of each option
+    const defaultOptions = { ...DEFAULT_OPTIONS };
+    for (const key in options) {
+      if (key in defaultOptions) {
+        try {
+          const newValue = options[key];
+          defaultOptions[key] = this._sanitizeAndValidateOption(key, newValue);
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    }
+
+    // set up getters and setters for each option
+    this.rawOptions = defaultOptions;
+    this.options = { ... defaultOptions };
+    this._setupOptions();
+  }
+
+  private _setupOptions(): void {
+    const getter = (propName: string): any => {
+      if (!(propName in DEFAULT_OPTIONS)) {
+        throw new Error(`No option with key "${propName}"`);
+      }
+      return this.rawOptions[propName];
+    };
+
+    const setter = (propName: string, value: any): void => {
+      if (!(propName in DEFAULT_OPTIONS)) {
+        throw new Error(`No option with key "${propName}"`);
+      }
+
+      value = this._sanitizeAndValidateOption(propName, value);
+      // Don't fire an option change event if they didn't change
+      if (this.rawOptions[propName] !== value) {
+        this.rawOptions[propName] = value;
+        this._onOptionChange.fire(propName);
+      }
+    };
+
+    for (const propName in this.rawOptions) {
+      const desc = {
+        get: getter.bind(this, propName),
+        set: setter.bind(this, propName)
+      };
+      Object.defineProperty(this.options, propName, desc);
+    }
+  }
+
+  public setOption(key: string, value: any): void {
+    this.options[key] = value;
+  }
+
+  private _sanitizeAndValidateOption(key: string, value: any): any {
+    switch (key) {
+      case 'bellStyle':
+      case 'cursorStyle':
+      case 'rendererType':
+      case 'wordSeparator':
+        if (!value) {
+          value = DEFAULT_OPTIONS[key];
+        }
+        break;
+      case 'fontWeight':
+      case 'fontWeightBold':
+        if (typeof value === 'number' && 1 <= value && value <= 1000) {
+          // already valid numeric value
+          break;
+        }
+        value = FONT_WEIGHT_OPTIONS.includes(value) ? value : DEFAULT_OPTIONS[key];
+        break;
+      case 'cursorWidth':
+        value = Math.floor(value);
+        // Fall through for bounds check
+      case 'lineHeight':
+      case 'tabStopWidth':
+        if (value < 1) {
+          throw new Error(`${key} cannot be less than 1, value: ${value}`);
+        }
+        break;
+      case 'minimumContrastRatio':
+        value = Math.max(1, Math.min(21, Math.round(value * 10) / 10));
+        break;
+      case 'scrollback':
+        value = Math.min(value, 4294967295);
+        if (value < 0) {
+          throw new Error(`${key} cannot be less than 0, value: ${value}`);
+        }
+        break;
+      case 'fastScrollSensitivity':
+      case 'scrollSensitivity':
+        if (value <= 0) {
+          throw new Error(`${key} cannot be less than or equal to 0, value: ${value}`);
+        }
+      case 'rows':
+      case 'cols':
+        if (!value && value !== 0) {
+          throw new Error(`${key} must be numeric, value: ${value}`);
+        }
+        break;
+    }
+    return value;
+  }
+
+  public getOption(key: string): any {
+    return this.options[key];
+  }
+}

package/dist/lib/xterm/src/common/services/ServiceRegistry.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * This was heavily inspired from microsoft/vscode's dependency injection system (MIT).
+ */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IServiceIdentifier } from 'common/services/Services';
+
+const DI_TARGET = 'di$target';
+const DI_DEPENDENCIES = 'di$dependencies';
+
+export const serviceRegistry: Map<string, IServiceIdentifier<any>> = new Map();
+
+export function getServiceDependencies(ctor: any): { id: IServiceIdentifier<any>, index: number, optional: boolean }[] {
+  return ctor[DI_DEPENDENCIES] || [];
+}
+
+export function createDecorator<T>(id: string): IServiceIdentifier<T> {
+  if (serviceRegistry.has(id)) {
+    return serviceRegistry.get(id)!;
+  }
+
+  const decorator: any = function (target: Function, key: string, index: number): any {
+    if (arguments.length !== 3) {
+      throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
+    }
+
+    storeServiceDependency(decorator, target, index);
+  };
+
+  decorator.toString = () => id;
+
+  serviceRegistry.set(id, decorator);
+  return decorator;
+}
+
+function storeServiceDependency(id: Function, target: Function, index: number): void {
+  if ((target as any)[DI_TARGET] === target) {
+    (target as any)[DI_DEPENDENCIES].push({ id, index });
+  } else {
+    (target as any)[DI_DEPENDENCIES] = [{ id, index }];
+    (target as any)[DI_TARGET] = target;
+  }
+}