@opensumi/ide-core-common 2.21.13 → 2.22.0

package/src/comparers.ts

@@ -0,0 +1,152 @@
+/* ---------------------------------------------------------------------------------------------
+ *  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/common/comparers.ts
+
+import { path, IdleValue } from '@opensumi/ide-utils';
+
+import { IRange } from './types';
+const { sep } = path;
+const intlFileNameCollator: IdleValue<{ collator: Intl.Collator; collatorIsNumeric: boolean }> = new IdleValue(() => {
+  const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+  return {
+    collator,
+    collatorIsNumeric: collator.resolvedOptions().numeric,
+  };
+});
+
+export function compareFileNames(one: string | null, other: string | null, caseSensitive = false): number {
+  const a = one || '';
+  const b = other || '';
+  const result = intlFileNameCollator.getValue().collator.compare(a, b);
+
+  // Using the numeric option in the collator will
+  // make compare(`foo1`, `foo01`) === 0. We must disambiguate.
+  if (intlFileNameCollator.getValue().collatorIsNumeric && result === 0 && a !== b) {
+    return a < b ? -1 : 1;
+  }
+
+  return result;
+}
+
+function comparePathComponents(one: string, other: string, caseSensitive = false): number {
+  if (!caseSensitive) {
+    one = one && one.toLowerCase();
+    other = other && other.toLowerCase();
+  }
+
+  if (one === other) {
+    return 0;
+  }
+
+  return one < other ? -1 : 1;
+}
+
+export function comparePaths(one: string, other: string, caseSensitive = false): number {
+  const oneParts = one.split(sep);
+  const otherParts = other.split(sep);
+
+  const lastOne = oneParts.length - 1;
+  const lastOther = otherParts.length - 1;
+  let endOne: boolean;
+  let endOther: boolean;
+
+  for (let i = 0; ; i++) {
+    endOne = lastOne === i;
+    endOther = lastOther === i;
+
+    if (endOne && endOther) {
+      return compareFileNames(oneParts[i], otherParts[i], caseSensitive);
+    } else if (endOne) {
+      return -1;
+    } else if (endOther) {
+      return 1;
+    }
+
+    const result = comparePathComponents(oneParts[i], otherParts[i], caseSensitive);
+
+    if (result !== 0) {
+      return result;
+    }
+  }
+}
+
+export function compareAnything(one: string, other: string, lookFor: string): number {
+  const elementAName = one.toLowerCase();
+  const elementBName = other.toLowerCase();
+
+  // Sort prefix matches over non prefix matches
+  const prefixCompare = compareByPrefix(one, other, lookFor);
+  if (prefixCompare) {
+    return prefixCompare;
+  }
+
+  // Sort suffix matches over non suffix matches
+  const elementASuffixMatch = elementAName.endsWith(lookFor);
+  const elementBSuffixMatch = elementBName.endsWith(lookFor);
+  if (elementASuffixMatch !== elementBSuffixMatch) {
+    return elementASuffixMatch ? -1 : 1;
+  }
+
+  // Understand file names
+  const r = compareFileNames(elementAName, elementBName);
+  if (r !== 0) {
+    return r;
+  }
+
+  // Compare by name
+  return elementAName.localeCompare(elementBName);
+}
+
+export function compareByPrefix(one: string, other: string, lookFor: string): number {
+  const elementAName = one.toLowerCase();
+  const elementBName = other.toLowerCase();
+
+  // Sort prefix matches over non prefix matches
+  const elementAPrefixMatch = elementAName.startsWith(lookFor);
+  const elementBPrefixMatch = elementBName.startsWith(lookFor);
+  if (elementAPrefixMatch !== elementBPrefixMatch) {
+    return elementAPrefixMatch ? -1 : 1;
+  } else if (elementAPrefixMatch && elementBPrefixMatch) {
+    // Same prefix: Sort shorter matches to the top to have those on top that match more precisely
+    if (elementAName.length < elementBName.length) {
+      return -1;
+    }
+
+    if (elementAName.length > elementBName.length) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+export function compareRangesUsingStarts(a: IRange | null | undefined, b: IRange | null | undefined): number {
+  if (a && b) {
+    const aStartLineNumber = a.startLineNumber | 0;
+    const bStartLineNumber = b.startLineNumber | 0;
+
+    if (aStartLineNumber === bStartLineNumber) {
+      const aStartColumn = a.startColumn | 0;
+      const bStartColumn = b.startColumn | 0;
+
+      if (aStartColumn === bStartColumn) {
+        const aEndLineNumber = a.endLineNumber | 0;
+        const bEndLineNumber = b.endLineNumber | 0;
+
+        if (aEndLineNumber === bEndLineNumber) {
+          const aEndColumn = a.endColumn | 0;
+          const bEndColumn = b.endColumn | 0;
+          return aEndColumn - bEndColumn;
+        }
+        return aEndLineNumber - bEndLineNumber;
+      }
+      return aStartColumn - bStartColumn;
+    }
+    return aStartLineNumber - bStartLineNumber;
+  }
+  const aExists = a ? 1 : 0;
+  const bExists = b ? 1 : 0;
+  return aExists - bExists;
+}

package/src/connection.ts

@@ -0,0 +1,7 @@
+import { BasicEvent } from './event-bus';
+
+export class BrowserConnectionCloseEvent extends BasicEvent<void> {}
+
+export class BrowserConnectionOpenEvent extends BasicEvent<void> {}
+
+export class BrowserConnectionErrorEvent extends BasicEvent<Event> {}

package/src/const/application.ts

@@ -0,0 +1,11 @@
+export const DEFAULT_APPLICATION_NAME = 'OpenSumi';
+export const DEFAULT_APPLICATION_DESKTOP_HOST = 'desktop';
+export const DEFAULT_APPLICATION_WEB_HOST = 'web';
+export const DEFAULT_URI_SCHEME = 'sumi';
+export const DEFAULT_OPENVSX_REGISTRY = 'https://open-vsx.org'; // Official Registry
+
+export namespace DEFAULT_TRS_REGISTRY {
+  export const ENDPOINT = 'https://marketplace.opentrs.cn';
+  export const ACCOUNT_ID = 'clcJKq_Gea47whxAJGrgoYqf';
+  export const MASTER_KEY = '_V_LPJ6Ar-1nrSVa05xDGBYp';
+}

package/src/const/index.ts

@@ -0,0 +1 @@
+export * from './application';

package/src/contribution-provider.ts

@@ -0,0 +1,47 @@
+import { Injector, Domain, ConstructorOf } from '@opensumi/di';
+
+export const ContributionProvider = Symbol('ContributionProvider');
+
+export interface ContributionProvider<T extends object> {
+  getContributions(): T[];
+  addContribution(...contributionsCls: ConstructorOf<any>[]): void;
+  reload(): T[];
+}
+
+export class BaseContributionProvider<T extends object> implements ContributionProvider<T> {
+  protected services: T[] | undefined;
+
+  constructor(protected readonly domain: Domain, protected readonly injector: Injector) {}
+
+  addContribution(...contributionsCls: ConstructorOf<T>[]): void {
+    for (const contributionCls of contributionsCls) {
+      this.injector.addProviders(contributionCls);
+      if (this.services) {
+        this.services.push(this.injector.get(contributionCls));
+      }
+    }
+  }
+
+  getContributions(): T[] {
+    return this.injector.getFromDomain(this.domain);
+  }
+
+  reload(): T[] {
+    this.services = this.injector.getFromDomain(this.domain);
+    return this.services;
+  }
+}
+
+/**
+ * 使用工厂函数创建 ContributionProvider
+ * @param injector 全局唯一的 injector，用来获取当前 Domain 的 Contribution、并注册 ContributionProvider
+ * @param domain 用来区分 Contribution 的标识，也是 ContributionProvider 的 Token
+ */
+export function createContributionProvider(injector: Injector, domain: Domain) {
+  const contributionProvider = new BaseContributionProvider(domain, injector);
+
+  injector.addProviders({
+    token: domain,
+    useValue: contributionProvider,
+  });
+}

package/src/credential.ts

@@ -0,0 +1,21 @@
+export const KeytarServicePath = '/services/keytar';
+
+export const INativeCredentialService = Symbol('INativeCredentialService');
+
+export interface INativeCredentialService {
+  setPassword(service: string, account: string, password: string): Promise<void>;
+  getPassword(service: string, account: string): Promise<string | null>;
+  deletePassword(service: string, account: string): Promise<boolean>;
+  findPassword(service: string): Promise<string | null>;
+  findCredentials(service: string): Promise<Array<{ account: string; password: string }>>;
+}
+
+export interface IChunkedPassword {
+  content: string;
+  hasNextChunk: boolean;
+}
+
+export interface ICredentialsChangeEvent {
+  service: string;
+  account: string;
+}

package/src/crypto.ts

@@ -0,0 +1,8 @@
+export const CryptoServicePath = '/services/crypto';
+
+export const INativeCryptoService = Symbol('INativeCryptoService');
+
+export interface INativeCryptoService {
+  decrypt(hash: string): Promise<string>;
+  encrypt(password: string): Promise<string>;
+}

package/src/declare.ts

@@ -0,0 +1,3 @@
+export type ConstructorOf<T, K extends any[] = any[]> = new (...args: K) => T;
+
+export type MaybeNull<T> = T | null | undefined;

package/src/di-helper/domain-helper.ts

@@ -0,0 +1,48 @@
+import { markInjectable, getInjectableOpts, Domain } from '@opensumi/di';
+
+import { ConstructorOf } from '../declare';
+
+/**
+ * 修饰一个 Class 是某个特定的 DI 分组的装饰器
+ * @param domains
+ */
+export function Domain(...domains: Domain[]) {
+  return (target: ConstructorOf<any>) => {
+    const opts = getInjectableOpts(target) || {};
+    opts.domain = domains;
+    markInjectable(target, opts);
+  };
+}
+
+const domainMap = new Map<Domain, ConstructorOf<any>>();
+
+/**
+ * 带全局记录的 Domain 装饰器
+ * @param domain
+ */
+export function EffectDomain(domain: Domain) {
+  return (target: ConstructorOf<any>) => {
+    const opts = getInjectableOpts(target) || {};
+    opts.domain = domain;
+    markInjectable(target, opts);
+
+    const tmp = domainMap.get(domain);
+    if (!tmp) {
+      domainMap.set(domain, target);
+    }
+  };
+}
+
+export function getDomainConstructors(...domains: Domain[]) {
+  const constructorSet = new Set<ConstructorOf<any>>();
+  for (const domain of domains) {
+    const constructor = domainMap.get(domain);
+    if (constructor) {
+      constructorSet.add(constructor);
+    } else {
+      // eslint-disable-next-line no-console
+      console.error(`没有获取到 ${String(domain)} 对应的Constructor！`);
+    }
+  }
+  return Array.from(constructorSet);
+}

package/src/di-helper/index.ts

@@ -0,0 +1 @@
+export * from './domain-helper';

package/src/editor.ts

@@ -0,0 +1,6 @@
+export const CUSTOM_EDITOR_SCHEME = 'vscode_customEditor';
+
+export const enum CommonLanguageId {
+  JSONC = 'jsonc',
+  Log = 'log',
+}

package/src/electron.ts

@@ -0,0 +1,168 @@
+import type Electron from 'electron';
+
+import { IDisposable } from '@opensumi/ide-utils';
+
+import { ExtensionCandidate } from './types';
+
+export interface IElectronMainApi<Events> {
+  on(event: Events, listener: (...args) => void): IDisposable;
+}
+
+export type IElectronPlainWebviewWindowOptions = Electron.BrowserWindowConstructorOptions;
+
+export interface IElectronMainUIServiceShape {
+  openPath(path: string): Promise<string>;
+
+  openExternal(uri: string): void;
+
+  moveToTrash(path: string): Promise<void>;
+
+  isMaximized(windowId: number): Promise<boolean>;
+
+  maximize(windowId: number): Promise<void>;
+
+  isFullScreen(windowId: number): Promise<boolean>;
+
+  showOpenDialog(windowId: number, options: Electron.OpenDialogOptions): Promise<string[] | undefined>;
+
+  showSaveDialog(windowId: number, options: Electron.SaveDialogOptions): Promise<string | undefined>;
+
+  /**
+   * 默认：最小缩放因子为 0.25，最大缩放因子为 5.0
+   */
+  setZoomFactor(
+    webContentsId: number,
+    options: { value?: number; delta?: number; minValue?: number | undefined; maxValue?: number | undefined },
+  ): Promise<void>;
+  getZoomFactor(webContentsId: number): Promise<number | undefined>;
+
+  /**
+   * 在资源管理器里打开文件
+   * @param path 文件路径（不带file协议头)
+   */
+  revealInFinder(path: string): Promise<void>;
+
+  /**
+   * 在系统终端中打开文件路径
+   * @param path 文件路径（不带file协议头)
+   */
+  revealInSystemTerminal(path: string): Promise<void>;
+
+  /**
+   * 创建一个browserWindow
+   * @param options
+   * @returns windowId
+   */
+  createBrowserWindow(options?: IElectronPlainWebviewWindowOptions): Promise<number>;
+
+  /**
+   * 显示指定的窗口
+   * @param windowId
+   */
+  showBrowserWindow(windowId: number): Promise<void>;
+
+  /**
+   * 隐藏指定的窗口
+   * @param windowId
+   */
+  hideBrowserWindow(windowId: number): Promise<void>;
+
+  /**
+   * 设置窗口大小
+   * @param windowId
+   * @param size
+   */
+  setSize(windowId: number, size: { width: number; height: number }): Promise<void>;
+
+  /**
+   * 设置窗口是否始终置顶
+   * @param windowId
+   * @param flag
+   */
+  setAlwaysOnTop(windowId: number, flag: boolean): Promise<void>;
+
+  /**
+   * 让一个指定的 browserWindow 加载一个url
+   * @param windowId
+   * @param url
+   */
+  browserWindowLoadUrl(windowId: number, url: string): Promise<void>;
+  /**
+   * 关闭一个browserWindow
+   * @param windowId
+   */
+  closeBrowserWindow(windowId: number): Promise<void>;
+
+  /**
+   * 向一个browserWindow发送消息
+   * @param windowId: window的id
+   * @param message: 消息体，需要能被序列化
+   */
+  postMessageToBrowserWindow(windowId: number, channel: string, message: any): Promise<void>;
+
+  /**
+   * 获得一个 browserWindow 的 webContentsId
+   * @param windowId
+   */
+  getWebContentsId(windowId: number): Promise<number>;
+
+  /**
+   * clipboard 相关 read/write Text/Buffer
+   */
+  readClipboardText(): Promise<string>;
+  writeClipboardText(text: string): Promise<void>;
+  readClipboardBuffer(field: string): Promise<Uint8Array>;
+  writeClipboardBuffer(field: string, buffer: Uint8Array): Promise<void>;
+  /**
+   * Specifies whether the window’s document has been edited, and the icon in title
+   * bar will become gray when set to `true`.
+   *
+   * @platform darwin
+   */
+  setDocumentEdited(windowId: number, edited: boolean): void;
+}
+
+export interface IElectronMainUIService
+  extends IElectronMainUIServiceShape,
+    IElectronMainApi<'fullScreenStatusChange' | 'windowClosed' | 'maximizeStatusChange'> {}
+
+export const IElectronMainUIService = 'IElectronMainUIService';
+
+export interface IElectronMainLifeCycleService extends IElectronMainApi<void> {
+  minimizeWindow(windowId: number);
+  fullscreenWindow(windowId: number);
+  maximizeWindow(windowId: number);
+  unmaximizeWindow(windowId: number);
+  closeWindow(windowId: number);
+  reloadWindow(windowId: number);
+
+  /**
+   * 在某个窗口打开新的工作区
+   * @param workspace 工作区主Uri
+   * @param options
+   */
+  openWorkspace(workspace: string, options?: any);
+
+  setExtensionDir(path: string, windowId: number);
+  setExtensionCandidate(candidate: ExtensionCandidate[], windowId: number): void;
+}
+
+export const IElectronMainLifeCycleService = 'IElectronMainLifeCycleService';
+
+export interface IURLHandler {
+  handleURL(url: string): Promise<boolean>;
+}
+
+export const IElectronURLService = 'IElectronURLService';
+
+export interface IElectronURLService {
+  open(url: string): Promise<boolean>;
+
+  registerHandler(handler: IURLHandler): void;
+
+  registerDefaultHandler(handler: IURLHandler): void;
+
+  deregisterHandler(handler: IURLHandler): void;
+}
+
+export interface IElectronRendererURLService extends IElectronMainApi<string>, IElectronURLService {}

package/src/env.ts

@@ -0,0 +1 @@
+export const firstSessionDateStorageKey = 'sumi.env.firstSessionDate';

package/src/event-bus/basic-event.ts

@@ -0,0 +1,3 @@
+export class BasicEvent<T> {
+  constructor(public payload: T) {}
+}

package/src/event-bus/event-bus-types.ts

@@ -0,0 +1,68 @@
+import { IAsyncResult, IDisposable } from '@opensumi/ide-utils';
+
+import { ConstructorOf } from '../declare';
+
+export interface IEventFireOpts {
+  nextTick?: boolean;
+}
+
+export interface IAsyncEventFireOpts {
+  /**
+   * 异步事件发送时，listener的最大执行时长（listener并发执行)
+   */
+  timeout?: number;
+}
+export type IEventListener<T> = (target: T) => void;
+
+export const IEventBus = Symbol('IEventBus');
+export interface IEventBus {
+  /**
+   * 发出一个事件
+   * Sample:
+    class ResizeEvent extends BasicEvent<number> {}
+
+    class LayoutStore {
+      @Autowired(IEventBus)
+      private eventBus: IEventBus;
+
+      public fireResizeEvent() {
+        const size = this.getSize();
+        const resizeEvent = new ResizeEvent(size);
+        this.eventBus.fire(resizeEvent);
+      }
+
+      // 不推荐，但是兼容 vscode 的 Event 设计
+      public onDidResize(listener: (t: ResizeEvent) => void) {
+        return this.eventBus.on(ResizeEvent, listener)
+      }
+    }
+   */
+  fire(target: any, opts?: IEventFireOpts): void;
+
+  /**
+   * 发送一个异步事件，等待并收集结果
+   * @param e
+   * @param opts
+   */
+  fireAndAwait<R>(e: any, opts?: IAsyncEventFireOpts): Promise<IAsyncResult<R>[]>;
+
+  /**
+   * 监听 EventBus 中的事件
+   * Sample:
+    @Injectable()
+    class FileTreeStore extends WitEventBus {
+      @Autowired(IEventBus)
+      private eventBus: IEventBus;
+
+      @OnEvent(LayoutResize)
+      public onLayoutResize(event: LayoutResize) {
+        console.log(event.payload); // size number
+      }
+    }
+  */
+  on<T>(constructor: ConstructorOf<T>, listener: IEventListener<T>): IDisposable;
+  /**
+   * 监听 EventBus 中的事件，只会触发一次
+   */
+  once<T>(constructor: ConstructorOf<T>, listener: IEventListener<T>): IDisposable;
+}

package/src/event-bus/event-bus.ts

@@ -0,0 +1,57 @@
+import { Injectable } from '@opensumi/di';
+import { Emitter, IAsyncResult, Event } from '@opensumi/ide-utils';
+
+import { ConstructorOf } from '../declare';
+
+import { BasicEvent } from './basic-event';
+import { IEventBus, IEventListener, IEventFireOpts, IAsyncEventFireOpts } from './event-bus-types';
+
+@Injectable()
+export class EventBusImpl implements IEventBus {
+  private emitterMap = new Map<any, Emitter<any>>();
+
+  fire<T extends BasicEvent<any>>(e: T, opts: IEventFireOpts = {}) {
+    const Constructor = e && e.constructor;
+    if (typeof Constructor === 'function' && BasicEvent.isPrototypeOf(Constructor)) {
+      const emitter = this.emitterMap.get(Constructor);
+      if (emitter) {
+        emitter.fire(e);
+      }
+    }
+  }
+
+  async fireAndAwait<T extends BasicEvent<any>, R>(
+    e: T,
+    opts: IAsyncEventFireOpts = { timeout: 2000 },
+  ): Promise<IAsyncResult<R>[]> {
+    const Constructor = e && e.constructor;
+    if (typeof Constructor === 'function' && BasicEvent.isPrototypeOf(Constructor)) {
+      const emitter = this.emitterMap.get(Constructor);
+      if (emitter) {
+        return emitter.fireAndAwait<R>(e, opts.timeout);
+      }
+    }
+    return [];
+  }
+
+  on<T>(Constructor: ConstructorOf<T>, listener: IEventListener<T>) {
+    const emitter = this.getOrCreateEmitter(Constructor);
+    return emitter.event(listener);
+  }
+
+  once<T>(Constructor: ConstructorOf<T>, listener: IEventListener<T>) {
+    const emitter = this.getOrCreateEmitter(Constructor);
+    return Event.once(emitter.event)(listener);
+  }
+
+  private getOrCreateEmitter(key: any) {
+    const current = this.emitterMap.get(key);
+    if (current) {
+      return current;
+    }
+
+    const emitter = new Emitter();
+    this.emitterMap.set(key, emitter);
+    return emitter;
+  }
+}

package/src/event-bus/event-decorator.ts

@@ -0,0 +1,32 @@
+import { Autowired } from '@opensumi/di';
+import { Disposable } from '@opensumi/ide-utils';
+
+import { ConstructorOf } from '../declare';
+
+import { BasicEvent } from './basic-event';
+import { IEventBus } from './event-bus-types';
+
+const EVENT_TOKEN = Symbol('EVENT_TOKEN');
+
+export class WithEventBus extends Disposable {
+  @Autowired(IEventBus)
+  protected eventBus: IEventBus;
+
+  constructor(...args: any[]) {
+    super(...args);
+
+    const map: Map<string, ConstructorOf<any>> = Reflect.getMetadata(EVENT_TOKEN, this) || new Map();
+    for (const [key, Constructor] of map.entries()) {
+      const dispose = this.eventBus.on(Constructor, (event: any) => (this as any)[key](event));
+      this.addDispose(dispose);
+    }
+  }
+}
+
+export function OnEvent<T extends BasicEvent<any>>(Constructor: ConstructorOf<T>) {
+  return (target: object, key: string, descriptor: TypedPropertyDescriptor<(event: T) => void>) => {
+    const map: Map<string, ConstructorOf<any>> = Reflect.getMetadata(EVENT_TOKEN, target) || new Map();
+    map.set(key, Constructor);
+    Reflect.defineMetadata(EVENT_TOKEN, map, target);
+  };
+}

package/src/event-bus/index.ts

@@ -0,0 +1,4 @@
+export * from './basic-event';
+export * from './event-bus-types';
+export * from './event-bus';
+export * from './event-decorator';

package/src/extension.schema.ts

@@ -0,0 +1,16 @@
+import { IJSONSchema } from './json-schema';
+
+export type FrameworkKind = 'vscode' | 'opensumi';
+
+export interface IExtensionPointDescriptor {
+  extensionPoint: string;
+  jsonSchema: IJSONSchema;
+  frameworkKind?: FrameworkKind[];
+}
+
+export const IExtensionsSchemaService = Symbol('IExtensionsSchemaService');
+
+export interface IExtensionsSchemaService {
+  registerExtensionPoint(desc: IExtensionPointDescriptor): void;
+  appendExtensionPoint(points: string[], desc: IExtensionPointDescriptor): void;
+}