@opensumi/ide-core-common 2.21.13 → 2.22.0

package/src/types/index.ts

@@ -0,0 +1,15 @@
+export * from './editor';
+export * from './message';
+export * from './file';
+export * from './markers';
+export * from './extension';
+export * from './reporter';
+export * from './string';
+export * from './dnd';
+export * from './common';
+export * from './application';
+export * from './authentication';
+export * from './accessibility';
+export * from './statusbar';
+export * from './markdown';
+export * from './editor';

package/src/types/markdown.ts

@@ -0,0 +1,10 @@
+import { UriComponents } from '@opensumi/ide-utils';
+
+export interface IMarkdownString {
+  value: string;
+  isTrusted?: boolean;
+  supportThemeIcons?: boolean;
+  supportHtml?: boolean;
+  baseUri?: UriComponents;
+  uris?: { [href: string]: UriComponents };
+}

package/src/types/markers/index.ts

@@ -0,0 +1,2 @@
+export * from './markers';
+export * from './markers-manager';

package/src/types/markers/markers-manager.ts

@@ -0,0 +1,392 @@
+import { Injectable } from '@opensumi/di';
+import { Emitter, Event, IDisposable, arrays } from '@opensumi/ide-utils';
+
+import { WithEventBus } from '../../event-bus';
+
+import { MapMap } from './markers';
+import { IMarker, IMarkerData, MarkerStatistics, MarkerSeverity } from './markers';
+
+const { isFalsyOrEmpty } = arrays;
+
+export interface IBaseMarkerManager {
+  /**
+   * 更新markers
+   * @param type 类型标识
+   * @param uri markers对应的资源
+   * @param markers 所有markers
+   */
+  updateMarkers(type: string, uri: string, markers: IMarkerData[]);
+
+  /**
+   * 清空markers
+   * @param type 类型标识
+   */
+  clearMarkers(type: string);
+
+  /**
+   * 获取所有markers的统计信息
+   */
+  getStats(): MarkerStats;
+
+  /**
+   * 获得当前所有资源
+   */
+  getResources(): string[];
+
+  /**
+   * 获取markers
+   */
+  getMarkers(filter: {
+    type?: string;
+    resource?: string;
+    severities?: number;
+    take?: number;
+    opened?: boolean;
+  }): IMarker[];
+
+  /**
+   * marker变更事件
+   */
+  onMarkerChanged: Event<string[]>;
+
+  /**
+   * 打开编辑器回调
+   * @param resource 资源
+   */
+  onEditorGroupOpen(resource: string);
+
+  /**
+   * 关闭编辑器回调
+   * @param resource 资源
+   */
+  onEditorGroupClose(resource: string);
+}
+
+export class MarkerStats implements MarkerStatistics, IDisposable {
+  public errors = 0;
+  public infos = 0;
+  public warnings = 0;
+  public unknowns = 0;
+
+  private _data?: { [resource: string]: MarkerStatistics } = Object.create(null);
+  private _manager: IBaseMarkerManager;
+  private _subscription: IDisposable;
+
+  constructor(manager: IBaseMarkerManager) {
+    this._manager = manager;
+    this._subscription = manager.onMarkerChanged(this._update, this);
+  }
+
+  dispose(): void {
+    this._subscription.dispose();
+    this._data = undefined;
+  }
+
+  private _update(resources: string[]): void {
+    if (!this._data) {
+      return;
+    }
+
+    for (const resource of resources) {
+      const key = resource.toString();
+      const oldStats = this._data[key];
+      if (oldStats) {
+        this._substract(oldStats);
+      }
+      const newStats = this._resourceStats(resource);
+      this._add(newStats);
+      this._data[key] = newStats;
+    }
+  }
+
+  private _resourceStats(resource: string): MarkerStatistics {
+    const result: MarkerStatistics = { errors: 0, warnings: 0, infos: 0, unknowns: 0 };
+
+    const markers = this._manager.getMarkers({ resource, opened: true });
+    for (const { severity } of markers) {
+      if (severity === MarkerSeverity.Error) {
+        result.errors += 1;
+      } else if (severity === MarkerSeverity.Warning) {
+        result.warnings += 1;
+      } else if (severity === MarkerSeverity.Info) {
+        result.infos += 1;
+      } else {
+        // Hint
+        result.unknowns += 1;
+      }
+    }
+
+    return result;
+  }
+
+  private _substract(op: MarkerStatistics) {
+    this.errors -= op.errors;
+    this.warnings -= op.warnings;
+    this.infos -= op.infos;
+    this.unknowns -= op.unknowns;
+  }
+
+  private _add(op: MarkerStatistics) {
+    this.errors += op.errors;
+    this.warnings += op.warnings;
+    this.infos += op.infos;
+    this.unknowns += op.unknowns;
+  }
+}
+
+@Injectable()
+export class MarkerManager extends WithEventBus implements IBaseMarkerManager {
+  // 所有Marker
+  private readonly _byResource: MapMap<IMarker[]> = Object.create(null);
+  private readonly _byType: MapMap<IMarker[]> = Object.create(null);
+
+  private readonly _byResourceCloseCache: MapMap<IMarker[]> = Object.create(null);
+
+  private readonly _openedResource: Set<string> = new Set();
+
+  // marker 当前状态
+  private _stats: MarkerStats;
+
+  // marker 变更 事件
+  private readonly onMarkerChangedEmitter = new Emitter<string[]>();
+  public readonly onMarkerChanged: Event<string[]> = this.onMarkerChangedEmitter.event;
+
+  constructor() {
+    super();
+    this.addDispose([(this._stats = new MarkerStats(this)), this.onMarkerChangedEmitter]);
+  }
+
+  /**
+   * 接受Diagnostics信息，更新marker
+   * @param type marker 类型，比如 typescript, eslint等
+   * @param uri marker 资源
+   * @param rawMarkers 来源于diagnostics的原始marker信息
+   */
+  public updateMarkers(type: string, uri: string, rawMarkers: IMarkerData[]) {
+    if (isFalsyOrEmpty(rawMarkers)) {
+      // remove marker for this (owner,resource)-tuple
+      const a = MapMap.remove(this._byResource, uri, type);
+      const b = MapMap.remove(this._byType, type, uri);
+      if (a !== b) {
+        throw new Error('invalid marker service state');
+      }
+      if (a && b) {
+        this.onMarkerChangedEmitter.fire([uri]);
+      }
+    } else {
+      // insert marker for this (owner,resource)-tuple
+      const markers: IMarkerData[] = [];
+      for (const data of rawMarkers) {
+        const marker = this.convertToMarker(type, uri, data);
+        if (marker) {
+          markers.push(marker);
+        }
+      }
+      MapMap.set(this._byResource, uri, type, markers);
+      MapMap.set(this._byType, type, uri, markers);
+      this.onMarkerChangedEmitter.fire([uri]);
+    }
+  }
+
+  /**
+   * Marker数据类型转换
+   * @param type marker类型
+   * @param resource 资源uri
+   * @param data marker数据
+   */
+  private convertToMarker(type: string, resource: string, data: IMarkerData): IMarker | undefined {
+    const { message } = data;
+
+    if (!message) {
+      return undefined;
+    }
+
+    let { startLineNumber, startColumn, endLineNumber, endColumn } = data;
+
+    // santize data
+    // marker 的 startLineNumber 等是 1-base 的
+    startLineNumber = startLineNumber > 0 ? startLineNumber : 1;
+    startColumn = startColumn > 0 ? startColumn : 1;
+    endLineNumber = endLineNumber >= startLineNumber ? endLineNumber : startLineNumber;
+    endColumn = endColumn > 0 ? endColumn : startColumn;
+
+    return {
+      ...data,
+      resource,
+      type,
+      message,
+      startLineNumber,
+      startColumn,
+      endLineNumber,
+      endColumn,
+    };
+  }
+
+  /**
+   * 清空特定类型的marker
+   * @param type 消息类型
+   */
+  public clearMarkers(type: string) {
+    const changes: string[] = [];
+    const map = this._byType[type];
+
+    // remove old marker
+    if (map) {
+      delete this._byType[type];
+      // eslint-disable-next-line guard-for-in
+      for (const resource in map) {
+        const entry = MapMap.get(this._byResource, resource, type);
+        if (entry) {
+          // remeber what we remove
+          const [first] = entry;
+          if (first) {
+            changes.push(first.resource);
+          }
+          // actual remove
+          MapMap.remove(this._byResource, resource, type);
+        }
+      }
+    }
+
+    this.onMarkerChangedEmitter.fire(changes);
+  }
+
+  /**
+   * 清空给定uri的所有marker
+   * @param resource 资源uri
+   */
+  public clearMarkersOfUri(resource: string) {
+    const map = this._byResource[resource];
+    if (map) {
+      delete this._byResource[resource];
+      // eslint-disable-next-line guard-for-in
+      for (const type in map) {
+        const entry = MapMap.get(this._byType, type, resource);
+        if (entry) {
+          // actual remove
+          MapMap.remove(this._byType, type, resource);
+        }
+      }
+    }
+    this.onMarkerChangedEmitter.fire([resource]);
+  }
+
+  /**
+   * 根据过滤条件，查询marker列表
+   * - type 类型
+   * - resource 资源URI
+   * - severities 安全等级
+   * - take 提取个数
+   * - opened 是否过滤打开的
+   * @param filter 过滤条件
+   */
+  public getMarkers(
+    filter: { type?: string; resource?: string; severities?: number; take?: number; opened?: boolean } = Object.create(
+      null,
+    ),
+  ): IMarker[] {
+    const { type, resource, severities, opened } = filter;
+    let { take } = filter;
+
+    if (!take || take < 0) {
+      take = -1;
+    }
+
+    if (type && resource) {
+      // exactly one owner AND resource
+      const data = MapMap.get(this._byResource, resource.toString(), type);
+      if (!data) {
+        return [];
+      } else {
+        const result: IMarker[] = [];
+        for (const marker of data) {
+          if (this.isTargetMarker(marker, severities, opened)) {
+            const newLen = result.push(marker);
+            if (take > 0 && newLen === take) {
+              break;
+            }
+          }
+        }
+        return result;
+      }
+    } else if (!type && !resource) {
+      // all
+      const result: IMarker[] = [];
+      // eslint-disable-next-line guard-for-in
+      for (const key1 in this._byResource) {
+        // eslint-disable-next-line guard-for-in
+        for (const key2 in this._byResource[key1]) {
+          for (const data of this._byResource[key1][key2]) {
+            if (this.isTargetMarker(data, severities, opened)) {
+              const newLen = result.push(data);
+              if (take > 0 && newLen === take) {
+                return result;
+              }
+            }
+          }
+        }
+      }
+      return result;
+    } else {
+      // of one resource OR owner
+      const map: { [key: string]: IMarker[] } | undefined = type
+        ? this._byType[type]
+        : resource
+        ? this._byResource[resource.toString()]
+        : undefined;
+
+      if (!map) {
+        return [];
+      }
+
+      const result: IMarker[] = [];
+      // eslint-disable-next-line guard-for-in
+      for (const key in map) {
+        for (const data of map[key]) {
+          if (this.isTargetMarker(data, severities, opened)) {
+            const newLen = result.push(data);
+            if (take > 0 && newLen === take) {
+              return result;
+            }
+          }
+        }
+      }
+      return result;
+    }
+  }
+
+  private isTargetMarker(marker: IMarker, severities?: number, visible?: boolean): boolean {
+    const isTargetSeverity = severities === undefined || (severities & marker.severity) === marker.severity;
+    const isTargetVisible = visible ? this._openedResource.has(marker.resource) : true;
+    return isTargetSeverity && isTargetVisible;
+  }
+
+  public getResources(): string[] {
+    return MapMap.keys(this._byResource);
+  }
+
+  public getStats(): MarkerStats {
+    return this._stats;
+  }
+
+  public onEditorGroupOpen(resource: string) {
+    this._openedResource.add(resource);
+    const cacheMap = MapMap.removeMap(this._byResourceCloseCache, resource);
+    if (cacheMap) {
+      MapMap.setMap(this._byResource, resource, cacheMap);
+      Object.keys(cacheMap).forEach((type) => {
+        MapMap.set(this._byType, type, resource, cacheMap[type]);
+      });
+    }
+    this.onMarkerChangedEmitter.fire([resource]);
+  }
+
+  public onEditorGroupClose(resource: string) {
+    this._openedResource.delete(resource);
+    const resourceToCache = MapMap.getMap(this._byResource, resource);
+    if (resourceToCache) {
+      MapMap.setMap(this._byResourceCloseCache, resource, resourceToCache);
+    }
+    this.clearMarkersOfUri(resource);
+  }
+}

package/src/types/markers/markers.ts

@@ -0,0 +1,125 @@
+import { isEmptyObject, URI } from '@opensumi/ide-utils';
+
+export interface MapMap<V> {
+  [key: string]: { [key: string]: V };
+}
+
+export namespace MapMap {
+  export function get<V>(map: MapMap<V>, key1: string, key2: string): V | undefined {
+    if (map[key1]) {
+      return map[key1][key2];
+    }
+    return undefined;
+  }
+
+  export function getMap<V>(map: MapMap<V>, key: string): { [key: string]: V } | undefined {
+    return map[key];
+  }
+
+  export function set<V>(map: MapMap<V>, key1: string, key2: string, value: V): void {
+    if (!map[key1]) {
+      map[key1] = Object.create(null);
+    }
+    map[key1][key2] = value;
+  }
+
+  export function setMap<V>(map: MapMap<V>, key: string, value: { [key: string]: V }): void {
+    map[key] = value;
+  }
+
+  export function remove(map: MapMap<any>, key1: string, key2: string): boolean {
+    if (map[key1] && map[key1][key2]) {
+      delete map[key1][key2];
+      if (isEmptyObject(map[key1])) {
+        delete map[key1];
+      }
+      return true;
+    }
+    return false;
+  }
+
+  export function removeMap<V>(map: MapMap<V>, key: string): { [key: string]: V } | undefined {
+    if (map[key]) {
+      const result = map[key];
+      delete map[key];
+      return result;
+    }
+    return undefined;
+  }
+
+  export function keys(map: MapMap<any>): string[] {
+    const result: string[] = [];
+    if (map) {
+      // eslint-disable-next-line guard-for-in
+      for (const key in map) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+}
+
+/**
+ * Marker的严重程度
+ */
+export enum MarkerSeverity {
+  Hint = 1,
+  Info = 2,
+  Warning = 4,
+  Error = 8,
+}
+
+export namespace MarkerSeverity {
+  export function compare(a: MarkerSeverity, b: MarkerSeverity): number {
+    return b - a;
+  }
+}
+
+export const enum MarkerTag {
+  Unnecessary = 1,
+  Deprecated = 2,
+}
+
+/**
+ * diagnosis的相关信息
+ */
+export interface IRelatedInformation {
+  resource: string;
+  message: string;
+  startLineNumber: number;
+  startColumn: number;
+  endLineNumber: number;
+  endColumn: number;
+}
+
+/**
+ * A structure defining a problem/warning/etc.
+ */
+export interface IMarkerData {
+  code?: string;
+  codeHref?: URI;
+  severity: MarkerSeverity;
+  message: string;
+  source?: string;
+  startLineNumber: number;
+  startColumn: number;
+  endLineNumber: number;
+  endColumn: number;
+  relatedInformation?: IRelatedInformation[];
+  tags?: MarkerTag[];
+}
+
+export interface IMarker extends IMarkerData {
+  type: string;
+  resource: string;
+}
+
+/**
+ * marker 信息统计
+ */
+export interface MarkerStatistics {
+  errors: number;
+  warnings: number;
+  infos: number;
+  unknowns: number;
+}

package/src/types/message.ts

@@ -0,0 +1,6 @@
+export enum MessageType {
+  Error,
+  Warning,
+  Info,
+  Empty,
+}

package/src/types/reporter.ts

@@ -0,0 +1,96 @@
+export enum REPORT_NAME {
+  ACTIVE_EXTENSION = 'activateExtension',
+  RUNTIME_ERROR_EXTENSION = 'runtimeErrorExtension',
+  LOAD_EXTENSION_MAIN = 'loadExtensionMain',
+  PROVIDE_COMPLETION_ITEMS = 'provideCompletionItems',
+  RESOLVE_COMPLETION_ITEM = 'resolveCompletionItem',
+  PROVIDE_DOCUMENT_FORMATTING_EDITS = 'provideDocumentFormattingEdits',
+  PROVIDE_DOCUMENT_RANGE_FORMATTING_EDITS = 'provideDocumentRangeFormattingEdits',
+  EDITOR_REACTIVE = 'editorReactive',
+  CHANNEL_RECONNECT = 'channelReconnect',
+  MEASURE = 'measure',
+  FORMAT_ON_SAVE_TIMEOUT_ERROR = 'formatOnSaveTimeoutError',
+  FORMAT_ON_SAVE = 'formatOnSave',
+  NOT_FOUND_COMMAND = 'notFoundCommand',
+  INSTALL_EXTENSION_ERROR = 'installExtensionError',
+  EXTENSION_CRASH = 'extensionCrash',
+  EXTENSION_NOT_EXIST = 'extensionNotExist',
+  THEME_LOAD = 'themeLoad',
+  PROVIDE_HOVER = 'provideHover',
+  PROVIDE_DEFINITION = 'provideDefinition',
+  PROVIDE_TYPE_DEFINITION = 'provideTypeDefinition',
+  PROVIDE_FOLDING_RANGES = 'provideFoldingRanges',
+  PROVIDE_DOCUMENT_COLORS = 'provideDocumentColors',
+  PROVIDE_COLOR_PRESENTATIONS = 'provideColorPresentations',
+  PROVIDE_DOCUMENT_HIGHLIGHTS = 'provideDocumentHighlights',
+  PROVIDE_LINKS = 'provideLinks',
+  PROVIDE_REFERENCES = 'provideReferences',
+  PROVIDE_DOCUMENT_SYMBOLS = 'provideDocumentSymbols',
+  PROVIDE_IMPLEMENTATION = 'provideImplementation',
+  PROVIDE_CODE_ACTIONS = 'provideCodeActions',
+  PROVIDE_RENAME_EDITS = 'provideRenameEdits',
+  PROVIDE_SIGNATURE_HELP = 'provideSignatureHelp',
+  PROVIDE_CODE_LENSES = 'provideCodeLenses',
+  RESOLVE_CODE_LENS = 'resolveCodeLens',
+  PROVIDE_ON_TYPE_FORMATTING_EDITS = 'provideOnTypeFormattingEdits',
+  PROVIDE_SELECTION_RANGES = 'provideSelectionRanges',
+  TERMINAL_MEASURE = 'terminalMeasure',
+  SEARCH_MEASURE = 'searchMeasure',
+  QUICK_OPEN_MEASURE = 'quickOpenMeasure',
+}
+
+export enum REPORT_HOST {
+  BROWSER = 'browser',
+  NODE = 'node',
+  WORKER = 'worker',
+  EXTENSION = 'extension',
+}
+
+export enum REPORT_TYPE {
+  PERFORMANCE = 'performance',
+  POINT = 'point',
+}
+
+export const ReporterMetadata = Symbol('ReporterMetadata');
+export interface ReporterMetadata {
+  extensionId?: string;
+  extensionVersion?: string;
+  host?: REPORT_HOST;
+}
+
+export interface PointData {
+  metadata?: ReporterMetadata;
+  extra?: any;
+  msg?: string;
+}
+
+export interface PerformanceData extends PointData {
+  duration: number;
+}
+
+// ide-framework 调用
+export const IReporterService = Symbol('IReporterService');
+
+export interface IReporterTimer {
+  timeEnd(msg?: string, extra?: any): number;
+}
+
+export interface IReporterService {
+  time(name: REPORT_NAME | string): IReporterTimer;
+  point(name: REPORT_NAME | string, msg?: string, extra?: any): void;
+}
+
+// 集成方实现
+// 前端和后端各有一套实现
+export const IReporter = Symbol('IReporter');
+
+export interface IReporter {
+  performance(name: string, data: PerformanceData): void;
+  point(name: string, data: PointData): void;
+}
+
+export interface ReporterProcessMessage {
+  reportType: REPORT_TYPE;
+  name: string;
+  data: PerformanceData | PointData;
+}

package/src/types/statusbar.ts

@@ -0,0 +1,6 @@
+export interface StatusBarHoverCommand {
+  id: string;
+  title: string;
+  tooltip?: string;
+  arguments?: any[];
+}

package/src/types/string.ts

@@ -0,0 +1,3 @@
+export interface IStringDictionary<V> {
+  [name: string]: V;
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from '@opensumi/ide-utils';

package/src/utils/ipc.ts

@@ -0,0 +1,28 @@
+import { tmpdir } from 'os';
+import { join, dirname } from 'path';
+
+import { ensureDirSync, ensureDir } from 'fs-extra';
+
+import { isWindows, uuid } from '@opensumi/ide-utils';
+
+export function normalizedIpcHandlerPath(name: string, uuidSuffix = false, ipcPath = tmpdir()) {
+  let handler: string;
+  if (!isWindows) {
+    handler = join(ipcPath, 'sumi-ipc', `sumi-ipc-${name}${uuidSuffix ? uuid() : ''}.sock`);
+    ensureDirSync(dirname(handler));
+  } else {
+    handler = `\\\\.\\pipe\\sumi-ipc-${name}${uuidSuffix ? uuid() : ''}`;
+  }
+  return handler;
+}
+
+export async function normalizedIpcHandlerPathAsync(name: string, uuidSuffix = false, ipcPath = tmpdir()) {
+  let handler: string;
+  if (!isWindows) {
+    handler = join(ipcPath, 'sumi-ipc', `sumi-ipc-${name}${uuidSuffix ? uuid() : ''}.sock`);
+    await ensureDir(dirname(handler));
+  } else {
+    handler = `\\\\.\\pipe\\sumi-ipc-${name}${uuidSuffix ? uuid() : ''}`;
+  }
+  return handler;
+}