@opensumi/ide-core-common 2.21.13 → 2.22.0

package/src/log.ts

@@ -0,0 +1,338 @@
+/* eslint-disable no-console */
+import { Event } from '@opensumi/ide-utils';
+
+export enum LogLevel {
+  Verbose,
+  Debug,
+  Info,
+  Warning,
+  Error,
+  Critical,
+  Off,
+}
+
+export enum SupportLogNamespace {
+  // 主进程
+  Main = 'main',
+  // 渲染进程
+  Render = 'render',
+  // Node进程
+  Node = 'node',
+  // 浏览器进程
+  Browser = 'browser',
+  // 插件进程
+  ExtensionHost = 'extHost',
+  // 应用层
+  App = 'app',
+  // 其他未分类
+  OTHER = 'other',
+}
+
+interface ICoreLogger {
+  verbose(...args: any[]): void;
+  debug(...args: any[]): void;
+  log(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+}
+
+export interface BaseLogServiceOptions {
+  /**
+   * 对应存储日志的文件名
+   */
+  namespace?: string;
+  /**
+   * 设置落盘级别，默认 LogLevel.Info
+   */
+  logLevel?: LogLevel;
+  /**
+   * 进程的PID，会作为日志内容的前缀
+   */
+  pid?: number;
+  /**
+   * 落盘日志的存储文件夹
+   * 例如： ~/.sumi/logs/20180909/
+   */
+  logDir?: string;
+}
+
+export interface ILogServiceOptions extends BaseLogServiceOptions {
+  logServiceManager: ILogServiceManager;
+  namespace: string;
+  logLevel?: LogLevel;
+  pid?: number;
+  isShowConsoleLog?: boolean;
+}
+
+export interface Archive {
+  /**
+   * 将压缩的zip文件，写入流；通过该方法可以将zip文件写入本地或上传服务器
+   * @param writeStream fs.WriteStream
+   */
+  pipe(writeStream: any);
+}
+
+export const ILogServiceManager = Symbol('ILogServiceManager');
+export interface ILogServiceManager {
+  onDidChangeLogLevel: Event<LogLevel>;
+
+  getLogger(namespace: SupportLogNamespace, loggerOptions?: BaseLogServiceOptions): ILogService;
+  getGlobalLogLevel(): LogLevel;
+  removeLogger(namespace: SupportLogNamespace);
+  setGlobalLogLevel(level: LogLevel);
+
+  /**
+   * 返回当前日志存放的目录
+   */
+  getLogFolder(): string;
+
+  /**
+   * 返回保存日志的根目录，为 getLogFolder() 的父目录
+   */
+  getRootLogFolder(): string;
+
+  /**
+   * 清理 getRootLogFolder() 中最近5天前的日志，仅保留最近5天日志
+   */
+  cleanOldLogs(): Promise<void>;
+
+  /**
+   * 清理 getRootLogFolder() 中的所有日志
+   */
+  cleanAllLogs(): Promise<void>;
+
+  /**
+   * 清理 day 之前的日志目录
+   * @param day --格式为： 20190807
+   */
+  cleanExpiredLogs(day: number): Promise<void>;
+
+  /**
+   * @param day --格式为： 20190807
+   */
+  getLogZipArchiveByDay(day: number): Promise<Archive>;
+
+  getLogZipArchiveByFolder(foldPath: string): Promise<Archive>;
+
+  dispose();
+}
+
+export interface IBaseLogService extends ICoreLogger {
+  /**
+   * 获取当前的log level
+   */
+  getLevel(): LogLevel;
+
+  /**
+   * 设置 log level
+   */
+  setLevel(level: LogLevel): void;
+  critical(...args: any[]): void;
+
+  /**
+   * 直接发送log 消息，在此函数内部分发到上面的 log、error方法
+   * @param level
+   * @param message
+   */
+  sendLog(level: LogLevel, message: string): void;
+
+  /**
+   * 释放spdlog对象
+   */
+  drop(): Promise<void>;
+
+  /**
+   * 立即写入数据
+   */
+  flush(): Promise<void>;
+
+  /**
+   * 销毁当前实例
+   */
+  dispose(): void;
+}
+
+export interface ILogService extends IBaseLogService {
+  /**
+   * 设置 logger 信息，用于初始化后，更新 logger 设置
+   */
+  setOptions(options: BaseLogServiceOptions);
+}
+
+export const LogServiceForClientPath = 'LogServiceForClientPath';
+
+export interface ILogServiceClient extends ICoreLogger {
+  getLevel(): Promise<LogLevel>;
+  setLevel(level: LogLevel): Promise<void>;
+  critical(...args: any[]): void;
+  dispose(): Promise<void>;
+}
+
+export type IExtensionLogger = ICoreLogger;
+
+export const ILoggerManagerClient = Symbol('ILoggerManagerClient');
+export interface ILoggerManagerClient {
+  onDidChangeLogLevel: Event<LogLevel>;
+  getLogger(namespace: SupportLogNamespace, pid?: number): ILogServiceClient;
+
+  setGlobalLogLevel(level: LogLevel): Promise<void>;
+  getGlobalLogLevel(): Promise<LogLevel>;
+
+  onDidLogLevelChanged(level: LogLevel);
+  dispose(): Promise<void>;
+  getLogFolder(): Promise<string>;
+}
+
+/**
+ * DebugLog
+ */
+export interface IDebugLog extends ICoreLogger {
+  info(...args: any[]): void;
+
+  destroy(): void;
+}
+
+/**
+ * 只输出在控制台，不会落盘
+ * const debugLog = new DebugLog('FileService');
+ *
+ * @export
+ * @class DebugLog
+ * @implements {IDebugLog}
+ */
+const isNode = typeof process !== 'undefined' && process.release;
+const isChrome = !isNode && /Chrome/.test(navigator.userAgent) && /Google Inc/.test(navigator.vendor);
+export class DebugLog implements IDebugLog {
+  private namespace: string;
+  private isEnable = false;
+
+  constructor(namespace?: string) {
+    if (typeof process !== 'undefined' && process.env && process.env.KTLOG_SHOW_DEBUG) {
+      this.isEnable = true;
+    }
+
+    this.namespace = namespace || '';
+  }
+
+  private getPre(level: string, color: string) {
+    const text = this.namespace ? `[${this.namespace}:${level}]` : `[${level}]`;
+    return this.getColor(color, text);
+  }
+
+  private getColor(color: string, message: string) {
+    if (!isNode && !isChrome) {
+      return message;
+    }
+    const colors = {
+      reset: '\x1b[0m',
+
+      // text color
+
+      black: '\x1b[30m',
+      red: '\x1b[31m',
+      green: '\x1b[32m',
+      yellow: '\x1b3[33m',
+      blue: '\x1b[34m',
+      magenta: '\x1b[35m',
+      cyan: '\x1b[36m',
+      white: '\x1b[37m',
+
+      // background color
+
+      blackBg: '\x1b[40m',
+      redBg: '\x1b[41m',
+      greenBg: '\x1b[42m',
+      yellowBg: '\x1b[43m',
+      blueBg: '\x1b[44m',
+      magentaBg: '\x1b[45m',
+      cyanBg: '\x1b[46m',
+      whiteBg: '\x1b[47m',
+    };
+
+    return (colors[color] || '') + message + colors.reset;
+  }
+
+  verbose = (...args: any[]) => {
+    if (!this.isEnable) {
+      return;
+    }
+    return console.debug(this.getPre('verbose', 'green'), ...args);
+  };
+
+  debug = (...args: any[]) => {
+    if (!this.isEnable) {
+      return;
+    }
+    return console.debug(this.getPre('debug', 'blue'), ...args);
+  };
+
+  log = (...args: any[]) => {
+    if (!this.isEnable) {
+      return;
+    }
+    return console.log(this.getPre('log', 'green'), ...args);
+  };
+
+  error = (...args: any[]) =>
+    // 错误一直显示
+    console.error(this.getPre('error', 'red'), ...args);
+
+  warn = (...args: any[]) => {
+    if (!this.isEnable) {
+      return;
+    }
+    return console.warn(this.getPre('warn', 'yellow'), ...args);
+  };
+
+  info = (...args: any[]) => {
+    if (!this.isEnable) {
+      return;
+    }
+    return console.info(this.getPre('log', 'green'), ...args);
+  };
+
+  destroy() {}
+}
+
+/**
+ * 兼容旧logger 提供的类型，同 ILogServiceClient
+ */
+export const ILogger = Symbol('ILogger');
+export type ILogger = ILogServiceClient;
+
+/**
+ * 只输出在控制台，不会落盘
+ */
+export function getDebugLogger(namespace?: string): IDebugLog {
+  function showWarn() {
+    // Do nothing
+  }
+  const debugLog = new DebugLog(namespace);
+  return {
+    get verbose() {
+      showWarn();
+      return debugLog.verbose;
+    },
+    get log() {
+      showWarn();
+      return debugLog.log;
+    },
+    get debug() {
+      showWarn();
+      return debugLog.debug;
+    },
+    get error() {
+      showWarn();
+      return debugLog.error;
+    },
+    get info() {
+      showWarn();
+      return debugLog.info;
+    },
+    get warn() {
+      showWarn();
+      return debugLog.warn;
+    },
+    destroy() {},
+  };
+}

package/src/markdown.ts

@@ -0,0 +1,8 @@
+import { IMarkdownString } from './types/markdown';
+
+export function toMarkdownString(str: string, opts?: Omit<IMarkdownString, 'value'>): IMarkdownString {
+  return {
+    value: str,
+    ...opts,
+  };
+}

package/src/menu.ts

@@ -0,0 +1,31 @@
+import { IDisposable } from '@opensumi/ide-utils';
+
+import { IElectronMainApi } from './electron';
+
+export interface INativeMenuTemplate {
+  id?: string;
+  label?: string;
+  type?: 'separator' | 'checkbox';
+  submenu?: INativeMenuTemplate[];
+  accelerator?: string;
+  disabled?: boolean;
+  selected?: boolean;
+  action?: boolean;
+  role?: string;
+  checked?: boolean;
+}
+
+export interface IElectronMainMenuService extends IElectronMainApi<'menuClick' | 'menuClose'> {
+  showContextMenu(template: INativeMenuTemplate, webContentsId: number): Promise<void>;
+  setApplicationMenu(template: INativeMenuTemplate, windowId: number): Promise<void>;
+  on(event: 'menuClick', listener: (targetId: string, menuId: string) => void): IDisposable;
+  on(event: 'menuClose', listener: (targetId: string, contextMenuId: string) => void): IDisposable;
+  runNativeRoleAction(actionName: string): Promise<void>;
+}
+
+export const IElectronMainMenuService = 'IElectronMainMenuService';
+
+export interface ISumiMenuExtendInfo {
+  command: string;
+  extraDesc?: string;
+}

package/src/mime.ts

@@ -0,0 +1,8 @@
+export const Mimes = Object.freeze({
+  text: 'text/plain',
+  binary: 'application/octet-stream',
+  unknown: 'application/unknown',
+  markdown: 'text/markdown',
+  latex: 'text/latex',
+  uriList: 'text/uri-list',
+});

package/src/mocks/electron/browserMock.ts

@@ -0,0 +1,10 @@
+import { MockedElectronIpcRenderer } from './ipcRenderer';
+
+export function mockElectronRenderer() {
+  const mockedElectronIpcRenderer = new MockedElectronIpcRenderer();
+  jest.mock('electron', () => ({
+    ipcRenderer: mockedElectronIpcRenderer,
+  }));
+
+  (global as any).ipcRenderer = mockedElectronIpcRenderer;
+}

package/src/mocks/electron/ipcRenderer.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from 'events';
+
+export class MockedElectronIpcRenderer extends EventEmitter implements Electron.IpcRenderer {
+  invoke(channel: string, ...args: any[]): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+
+  eventNames() {
+    return super.eventNames().map((s) => s.toString());
+  }
+
+  public targetHost: EventEmitter = new EventEmitter();
+
+  send(channel: string, ...args: any[]): void {
+    this.targetHost.emit('send', { channel }, args);
+  }
+
+  sendSync(channel: string, ...args: any[]) {
+    this.targetHost.emit('sendSync', { channel }, args);
+  }
+  sendTo(webContentsId: number, channel: string, ...args: any[]): void {
+    this.targetHost.emit('sendTo', { webContentsId, channel }, args);
+  }
+
+  sendToHost(channel: string, ...args: any[]): void {
+    this.targetHost.emit('sendToHost', channel, ...args);
+  }
+
+  postMessage(channel: string, message: any, transfer?: MessagePort[]): void {}
+}

package/src/module.ts

@@ -0,0 +1,31 @@
+/**
+ * 项目中会使用到的模块接口定义
+ */
+
+import { Autowired, INJECTOR_TOKEN, Injector, Provider, ConstructorOf, Token, Domain } from '@opensumi/di';
+
+interface FrontService {
+  token: Token;
+  servicePath: string;
+}
+
+export interface BackService {
+  token?: Token;
+  clientToken?: Token;
+  servicePath: string;
+}
+
+export class BasicModule {
+  @Autowired(INJECTOR_TOKEN)
+  protected injector: Injector;
+  providers?: Provider[];
+  backServices?: BackService[];
+  frontServices?: FrontService[];
+  contributionProvider: Domain | Domain[];
+}
+
+export function ModuleDependencies<T extends BasicModule>(dependencies: ConstructorOf<BasicModule>[]) {
+  return (target) => {
+    Reflect.defineMetadata('dependencies', dependencies, target);
+  };
+}

package/src/network.ts

@@ -0,0 +1,47 @@
+export namespace Schemes {
+  /**
+   * A schema that is used for models that exist in memory
+   * only and that have no correspondence on a server or such.
+   */
+  export const inMemory = 'inmemory';
+
+  /**
+   * A schema that is used for setting files
+   */
+  export const vscode = 'vscode';
+
+  /**
+   * A schema that is used for internal private files
+   */
+  export const internal = 'private';
+
+  /**
+   * A walk-through document.
+   */
+  export const walkThrough = 'walkThrough';
+
+  /**
+   * An embedded code snippet.
+   */
+  export const walkThroughSnippet = 'walkThroughSnippet';
+
+  export const http = 'http';
+
+  export const https = 'https';
+
+  export const file = 'file';
+
+  export const mailto = 'mailto';
+
+  export const untitled = 'untitled';
+
+  export const data = 'data';
+
+  export const command = 'command';
+
+  export const vscodeRemote = 'vscode-remote';
+
+  export const userData = 'vscode-userdata';
+
+  export const userStorage = 'user_storage';
+}

package/src/node/cli.ts

@@ -0,0 +1,5 @@
+import { parseArgv } from '@opensumi/ide-utils/lib/argv';
+
+const argv = parseArgv(process.argv);
+
+export { argv };

package/src/node/port.ts

@@ -0,0 +1,134 @@
+/* ---------------------------------------------------------------------------------------------
+ *  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/1.44.0/src/vs/base/node/ports.ts
+
+import net from 'net';
+
+/**
+ * @returns Returns a random port between 1025 and 65535.
+ */
+export function randomPort(): number {
+  const min = 1025;
+  const max = 65535;
+  return min + Math.floor((max - min) * Math.random());
+}
+
+const defaultHost = process.env.HOST || '127.0.0.1';
+
+/**
+ * Given a start point and a max number of retries, will find a port that
+ * is openable. Will return 0 in case no free port can be found.
+ */
+export function findFreePort(startPort: number, giveUpAfter: number, timeout: number): Promise<number> {
+  let done = false;
+
+  return new Promise((resolve) => {
+    const timeoutHandle = setTimeout(() => {
+      if (!done) {
+        done = true;
+        return resolve(0);
+      }
+    }, timeout);
+
+    doFindFreePort(startPort, giveUpAfter, (port) => {
+      if (!done) {
+        done = true;
+        clearTimeout(timeoutHandle);
+        return resolve(port);
+      }
+    });
+  });
+}
+
+function doFindFreePort(startPort: number, giveUpAfter: number, clb: (port: number) => void): void {
+  if (giveUpAfter === 0) {
+    return clb(0);
+  }
+
+  const client = new net.Socket();
+
+  // If we can connect to the port it means the port is already taken so we continue searching
+  client.once('connect', () => {
+    dispose(client);
+
+    return doFindFreePort(startPort + 1, giveUpAfter - 1, clb);
+  });
+
+  client.once('data', () => {
+    // this listener is required since node.js 8.x
+  });
+
+  client.once('error', (err: Error & { code?: string }) => {
+    dispose(client);
+
+    // If we receive any non ECONNREFUSED error, it means the port is used but we cannot connect
+    if (err.code !== 'ECONNREFUSED') {
+      return doFindFreePort(startPort + 1, giveUpAfter - 1, clb);
+    }
+
+    // Otherwise it means the port is free to use!
+    return clb(startPort);
+  });
+
+  client.connect(startPort, defaultHost);
+}
+
+/**
+ * Uses listen instead of connect. Is faster, but if there is another listener on 127.0.0.1 then this will take 127.0.0.1 from that listener.
+ */
+export function findFreePortFaster(startPort: number, giveUpAfter: number, timeout: number): Promise<number> {
+  let resolved = false;
+  let timeoutHandle: NodeJS.Timeout | undefined;
+  let countTried = 1;
+  const server = net.createServer({ pauseOnConnect: true });
+  function doResolve(port: number, resolve: (port: number) => void) {
+    if (!resolved) {
+      resolved = true;
+      server.removeAllListeners();
+      server.close();
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      resolve(port);
+    }
+  }
+  return new Promise<number>((resolve) => {
+    // 使用 global.setTimeout 消除歧义，减少测试问题
+    // ref: https://github.com/Microsoft/TypeScript/issues/30128#issuecomment-467968688
+    timeoutHandle = global.setTimeout(() => {
+      doResolve(0, resolve);
+    }, timeout);
+
+    server.on('listening', () => {
+      doResolve(startPort, resolve);
+    });
+    server.on('error', (err) => {
+      if (err && ((err as any).code === 'EADDRINUSE' || (err as any).code === 'EACCES') && countTried < giveUpAfter) {
+        startPort++;
+        countTried++;
+        server.listen(startPort, defaultHost);
+      } else {
+        doResolve(0, resolve);
+      }
+    });
+    server.on('close', () => {
+      doResolve(0, resolve);
+    });
+    server.listen(startPort, defaultHost);
+  });
+}
+
+function dispose(socket: net.Socket): void {
+  try {
+    socket.removeAllListeners('connect');
+    socket.removeAllListeners('error');
+    socket.end();
+    socket.destroy();
+    socket.unref();
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error(error); // otherwise this error would get lost in the callback chain
+  }
+}

package/src/preferences/index.ts

@@ -0,0 +1,2 @@
+export * from './preference-schema';
+export * from './preference-scope';