@opensumi/ide-utils 2.21.13 → 2.22.0

package/src/platform.ts

@@ -0,0 +1,194 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Some code copied and modified from https://github.com/microsoft/vscode/blob/01d1ea52e639615c4513689ce66576829438f748/src/vs/base/common/platform.ts
+
+const LANGUAGE_DEFAULT = 'en';
+
+let _isWindows = false;
+let _isMacintosh = false;
+let _isLinux = false;
+let _isNative = false;
+let _isWeb = false;
+let _locale: string | undefined;
+let _language: string = LANGUAGE_DEFAULT;
+let _translationsConfigFile: string | undefined;
+let _isWebKit = false;
+
+interface NLSConfig {
+  locale: string;
+  availableLanguages: { [key: string]: string };
+  _translationsConfigFile: string;
+}
+
+export interface IProcessEnvironment {
+  [key: string]: string | null | undefined;
+}
+
+interface INodeProcess {
+  platform: string;
+  env: IProcessEnvironment;
+  getuid(): number;
+  nextTick: any;
+  versions?: {
+    electron?: string;
+  };
+  type?: string;
+}
+declare const process: INodeProcess;
+declare const global: any;
+
+interface INavigator {
+  userAgent: string;
+  language: string;
+}
+declare const navigator: INavigator;
+declare const self: any;
+
+const isElectronRenderer =
+  typeof process !== 'undefined' &&
+  typeof process.versions !== 'undefined' &&
+  typeof process.versions.electron !== 'undefined' &&
+  process.type === 'renderer';
+
+// OS detection
+if (typeof navigator === 'object' && !isElectronRenderer) {
+  const userAgent = navigator.userAgent;
+  _isWindows = userAgent.indexOf('Windows') >= 0;
+  _isMacintosh = userAgent.indexOf('Macintosh') >= 0;
+  _isLinux = userAgent.indexOf('Linux') >= 0;
+  _isWeb = true;
+  _locale = navigator.language;
+  _language = _locale;
+  _isWebKit = userAgent.indexOf('AppleWebKit') >= 0;
+} else if (typeof process === 'object') {
+  _isWindows = process.platform === 'win32';
+  _isMacintosh = process.platform === 'darwin';
+  _isLinux = process.platform === 'linux';
+  _locale = LANGUAGE_DEFAULT;
+  _language = LANGUAGE_DEFAULT;
+  const rawNlsConfig = process.env['VSCODE_NLS_CONFIG'];
+  if (rawNlsConfig) {
+    try {
+      const nlsConfig: NLSConfig = JSON.parse(rawNlsConfig);
+      const resolved = nlsConfig.availableLanguages['*'];
+      _locale = nlsConfig.locale;
+      // VSCode's default language is 'en'
+      _language = resolved ? resolved : LANGUAGE_DEFAULT;
+      _translationsConfigFile = nlsConfig._translationsConfigFile;
+    } catch (e) {}
+  }
+  _isNative = true;
+}
+
+export const enum Platform {
+  Web,
+  Mac,
+  Linux,
+  Windows,
+}
+
+export function PlatformToString(platform: Platform) {
+  switch (platform) {
+    case Platform.Web:
+      return 'Web';
+    case Platform.Mac:
+      return 'Mac';
+    case Platform.Linux:
+      return 'Linux';
+    case Platform.Windows:
+      return 'Windows';
+  }
+}
+
+let _platform: Platform = Platform.Web;
+if (_isNative) {
+  if (_isMacintosh) {
+    _platform = Platform.Mac;
+  } else if (_isWindows) {
+    _platform = Platform.Windows;
+  } else if (_isLinux) {
+    _platform = Platform.Linux;
+  }
+}
+
+export const isWindows = _isWindows;
+export const isMacintosh = _isMacintosh;
+export const isOSX = _isMacintosh;
+export const isLinux = _isLinux;
+export const isNative = _isNative;
+export const isWeb = _isWeb;
+export const platform = _platform;
+export const isWebKit = _isWebKit;
+
+export function isRootUser(): boolean {
+  return _isNative && !_isWindows && process.getuid() === 0;
+}
+
+/**
+ * The language used for the user interface. The format of
+ * the string is all lower case (e.g. zh-tw for Traditional
+ * Chinese)
+ */
+export const language = _language;
+
+export namespace Language {
+  export function value(): string {
+    return language;
+  }
+
+  export function isDefaultVariant(): boolean {
+    if (language.length === 2) {
+      return language === 'en';
+    } else if (language.length >= 3) {
+      return language[0] === 'e' && language[1] === 'n' && language[2] === '-';
+    } else {
+      return false;
+    }
+  }
+
+  export function isDefault(): boolean {
+    return language === 'en';
+  }
+}
+
+/**
+ * The OS locale or the locale specified by --locale. The format of
+ * the string is all lower case (e.g. zh-tw for Traditional
+ * Chinese). The UI is not necessarily shown in the provided locale.
+ */
+export const locale = _locale;
+
+/**
+ * The translatios that are available through language packs.
+ */
+export const translationsConfigFile = _translationsConfigFile;
+
+const _globals = typeof self === 'object' ? self : typeof global === 'object' ? global : ({} as any);
+export const globals: any = _globals;
+
+let _setImmediate: ((callback: (...args: any[]) => void) => number) | null = null;
+export function setImmediate(callback: (...args: any[]) => void): number {
+  if (_setImmediate === null) {
+    if (globals.setImmediate) {
+      _setImmediate = globals.setImmediate.bind(globals);
+    } else if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {
+      _setImmediate = process.nextTick.bind(process);
+    } else {
+      _setImmediate = globals.setTimeout.bind(globals);
+    }
+  }
+  return _setImmediate!(callback);
+}
+
+export enum OperatingSystem {
+  Windows = 1,
+  Macintosh = 2,
+  Linux = 3,
+}
+
+export const userAgent = typeof navigator === 'object' ? navigator.userAgent : null;
+
+export const isChrome = userAgent?.indexOf('Chrome')! >= 0;
+export const isSafari = !isChrome && userAgent?.indexOf('Safari')! >= 0;

package/src/process.ts

@@ -0,0 +1,43 @@
+import { isElectronRenderer } from './os';
+import { isWindows, isMacintosh, setImmediate } from './platform';
+
+interface IProcess {
+  platform: string;
+  env: object;
+  cwd(): string;
+  nextTick(callback: (...args: any[]) => void): number;
+}
+
+declare const process: IProcess;
+
+const _safeProcess = {
+  cwd(): string {
+    return '/';
+  },
+  env: Object.create(null),
+  get platform(): string {
+    return isWindows ? 'win32' : isMacintosh ? 'darwin' : 'linux';
+  },
+  nextTick(callback: (...args: any[]) => void): number {
+    return setImmediate(callback);
+  },
+};
+
+let safeProcess: IProcess;
+if (typeof process === 'undefined') {
+  safeProcess = _safeProcess;
+} else {
+  // 因为我们不推荐开启 browserNodeIntegrated，所以这里需要检查是否为 Electron Renderer 环境
+  if (isElectronRenderer()) {
+    safeProcess = _safeProcess;
+  } else if (typeof process.cwd === 'undefined') {
+    safeProcess = _safeProcess;
+  } else {
+    safeProcess = process;
+  }
+}
+
+export const cwd = safeProcess.cwd;
+export const env = safeProcess.env;
+export const platform = safeProcess.platform;
+export const nextTick = safeProcess.nextTick;

package/src/progress.ts

@@ -0,0 +1,83 @@
+import { IDisposable } from './disposable';
+
+export enum ProgressLocation {
+  Explorer = 1,
+  Scm = 3,
+  Extensions = 5,
+  Window = 10,
+  Notification = 15,
+  Dialog = 20,
+}
+
+export interface IAction extends IDisposable {
+  readonly id: string;
+  label: string;
+  tooltip: string;
+  class: string | undefined;
+  enabled: boolean;
+  checked: boolean;
+  run(event?: any): Promise<any>;
+}
+
+export interface IProgressOptions {
+  readonly location: ProgressLocation | string;
+  readonly title?: string;
+  readonly source?: string;
+  readonly total?: number;
+  readonly cancellable?: boolean;
+  readonly closeable?: boolean;
+  // 暂不支持
+  readonly buttons?: string[];
+}
+
+export interface IProgressNotificationOptions extends IProgressOptions {
+  readonly location: ProgressLocation.Notification;
+  // 暂不支持
+  // readonly primaryActions?: ReadonlyArray<IAction>;
+  // readonly secondaryActions?: ReadonlyArray<IAction>;
+  readonly delay?: number;
+  readonly silent?: boolean;
+}
+
+export interface IProgressWindowOptions extends IProgressOptions {
+  readonly location: ProgressLocation.Window;
+  readonly command?: string;
+}
+
+export interface IProgressCompositeOptions extends IProgressOptions {
+  readonly location:
+    | ProgressLocation.Explorer
+    | ProgressLocation.Extensions
+    | ProgressLocation.Scm
+    | ProgressLocation.Window
+    | ProgressLocation.Notification
+    | ProgressLocation.Dialog
+    | string;
+  readonly delay?: number;
+}
+
+export interface IProgressStep {
+  message?: string;
+  increment?: number;
+  total?: number;
+}
+
+export interface IProgress<T> {
+  report(item: T): void;
+}
+
+export class Progress<T> implements IProgress<T> {
+  static readonly None: IProgress<unknown> = Object.freeze({ report() {} });
+
+  private _value?: T;
+  get value(): T | undefined {
+    return this._value;
+  }
+
+  constructor(private callback: (data: T) => void) {}
+
+  report(item: T) {
+    this._value = item;
+    this.callback(this._value);
+  }
+}

package/src/promises.ts

@@ -0,0 +1,23 @@
+/**
+ * Simple implementation of the deferred pattern.
+ * An object that exposes a promise and functions to resolve and reject it.
+ */
+export class Deferred<T> {
+  resolve: (value?: T | PromiseLike<T>) => void;
+  reject: (err?: any) => void;
+
+  promise = new Promise<T>((resolve, reject) => {
+    this.resolve = resolve;
+    this.reject = reject;
+  });
+}
+
+export async function pSeries<T>(tasks: Iterable<() => Promise<T> | T>): Promise<T[]> {
+  const results = [] as T[];
+
+  for (const task of tasks) {
+    results.push(await task());
+  }
+
+  return results;
+}

package/src/sequence.ts

@@ -0,0 +1,28 @@
+import { Event, Emitter } from './event';
+
+export interface ISplice<T> {
+  readonly start: number;
+  readonly deleteCount: number;
+  readonly toInsert: T[];
+}
+
+export interface ISpliceable<T> {
+  splice(start: number, deleteCount: number, toInsert: T[]): void;
+}
+
+export interface ISequence<T> {
+  readonly elements: T[];
+  readonly onDidSplice: Event<ISplice<T>>;
+}
+
+export class Sequence<T> implements ISequence<T>, ISpliceable<T> {
+  readonly elements: T[] = [];
+
+  private _onDidSplice = new Emitter<ISplice<T>>();
+  readonly onDidSplice: Event<ISplice<T>> = this._onDidSplice.event;
+
+  splice(start: number, deleteCount: number, toInsert: T[] = []): void {
+    this.elements.splice(start, deleteCount, ...toInsert);
+    this._onDidSplice.fire({ start, deleteCount, toInsert });
+  }
+}