@opensumi/ide-core-common 2.21.13 → 2.22.0

package/src/reference.ts

@@ -0,0 +1,141 @@
+import { Emitter, Event, Disposable, MaybePromise } from '@opensumi/ide-utils';
+
+export interface IRef<T> {
+  instance: T;
+  reason?: string;
+  dispose(): void;
+  hold(reason?: string): IRef<T>;
+  disposed: boolean;
+}
+
+export class ReferenceManager<T> {
+  protected instances: Map<string, T> = new Map();
+
+  protected refs: Map<string, Array<IRef<T>>> = new Map();
+
+  protected _onReferenceAllDisposed = new Emitter<string>();
+
+  protected _onInstanceCreated = new Emitter<T>();
+
+  public onReferenceAllDisposed: Event<string> = this._onReferenceAllDisposed.event;
+
+  public onInstanceCreated: Event<T> = this._onInstanceCreated.event;
+
+  protected _creating: Map<string, Promise<void>> = new Map();
+
+  constructor(private factory: (key: string) => MaybePromise<T>) {}
+
+  private getReferenceKey(uri: string) {
+    // 部分情况下可能出现类似 `file:///a//b.js` 的路径，此时需要替换路径中的 `//` 为 `/`
+    return uri.replace(/\w+\/\/\w+/gi, (match) => match.replace('//', '/'));
+  }
+
+  async getReference(uri: string, reason?: string): Promise<IRef<T>> {
+    const key = this.getReferenceKey(uri);
+    if (!this.instances.has(key)) {
+      // 由于创建过程可能为异步，此处标注为 creating， 防止重复创建。
+      if (!this._creating.has(key)) {
+        const promise = (async () => {
+          const instance = await this.factory(key);
+          this.instances.set(key, instance);
+          this._onInstanceCreated.fire(instance);
+        })();
+        this._creating.set(key, promise);
+      }
+      try {
+        await this._creating.get(key);
+      } catch (e) {
+        // 出错时需要清除创建中状态
+        this._creating.delete(key);
+        throw e;
+      }
+    }
+    const ref = this.createRef(key, reason);
+    // 需要在 ref 被创建后再结束 creating 状态，否则如果在 onInstanceCreated 事件中触发了 removeRef 至 0,
+    // 可能导致 instance 意外被删除。
+    if (this._creating.get(key)) {
+      const creatingPromise = this._creating.get(key);
+      this._creating.delete(key);
+      creatingPromise?.then(() => {
+        // 再触发一次空remove，防止被保护的instance意外残留
+        this.removeRef(key, undefined);
+      });
+    }
+    return ref;
+  }
+
+  getReferenceIfHasInstance(key: string, reason?: string): IRef<T> | null {
+    if (this.instances.has(key)) {
+      return this.createRef(key, reason);
+    }
+    return null;
+  }
+
+  private createRef(key: string, reason?: string) {
+    const instance: T = this.instances.get(key)!;
+    const ref = new Ref<T>(instance, reason, (reason?: string) => this.createRef(key, reason));
+    ref.addDispose({
+      dispose: () => {
+        this.removeRef(key, ref);
+      },
+    });
+    this.addRef(key, ref);
+    return ref;
+  }
+
+  private addRef(key: string, ref: Ref<T>) {
+    if (!this.refs.get(key)) {
+      this.refs.set(key, []);
+    }
+    this.refs.get(key)!.push(ref);
+  }
+
+  private removeRef(key: string, ref: Ref<T> | undefined) {
+    if (this.refs.get(key)) {
+      if (ref) {
+        const index = this.refs.get(key)!.indexOf(ref);
+        if (index !== -1) {
+          this.refs.get(key)!.splice(index, 1);
+        }
+      }
+      if (this.refs.get(key)!.length === 0) {
+        if (this._creating.has(key)) {
+          return; // 正在被创建， 进行保护
+        }
+        this.refs.delete(key);
+        this.instances.delete(key);
+        this._onReferenceAllDisposed.fire(key);
+      }
+    }
+  }
+}
+
+export class Ref<T> extends Disposable implements IRef<T> {
+  constructor(
+    private _instance: T | null,
+    public readonly reason: string | undefined,
+    private _clone: null | ((reason?: string) => Ref<T>),
+  ) {
+    super();
+    this.addDispose({
+      dispose: () => {
+        this._instance = null;
+        this._clone = null;
+      },
+    });
+  }
+
+  get instance() {
+    if (this.disposed) {
+      throw new Error('Ref has been disposed!');
+    }
+    return this._instance!;
+  }
+
+  hold(reason?: string): Ref<T> {
+    if (this.disposed) {
+      throw new Error('Ref has been disposed!');
+    }
+    return this._clone!(reason);
+  }
+}

package/src/reporter.ts

@@ -0,0 +1,64 @@
+import { Injectable, Inject } from '@opensumi/di';
+import { IDisposable } from '@opensumi/ide-utils';
+
+import { getDebugLogger } from './log';
+import {
+  IReporterService,
+  ReporterMetadata,
+  IReporter,
+  PerformanceData,
+  PointData,
+  IReporterTimer,
+  REPORT_NAME,
+} from './types/reporter';
+
+class ReporterTimer implements IReporterTimer {
+  private now: number;
+  constructor(private name: string, private reporter: IReporter, private metadata?: ReporterMetadata) {
+    this.now = Date.now();
+  }
+
+  timeEnd(msg?: string, extra?: any) {
+    const duration = Date.now() - this.now;
+    this.reporter.performance(this.name, {
+      duration,
+      metadata: this.metadata,
+      msg,
+      extra,
+    });
+    return duration;
+  }
+}
+
+@Injectable()
+export class DefaultReporter implements IReporter {
+  private logger = getDebugLogger();
+  performance(name: string, data: PerformanceData): void {
+    this.logger.log(name, data);
+  }
+  point(name: string, data: PointData): void {
+    this.logger.log(name, data);
+  }
+}
+
+@Injectable()
+export class ReporterService implements IReporterService, IDisposable {
+  constructor(
+    @Inject(IReporter) private reporter: IReporter,
+    @Inject(ReporterMetadata) private metadata?: ReporterMetadata,
+  ) {}
+
+  time(name: REPORT_NAME | string): IReporterTimer {
+    return new ReporterTimer(name, this.reporter, this.metadata);
+  }
+
+  point(name: REPORT_NAME | string, msg?: string, extra?: any): void {
+    this.reporter.point(name, {
+      metadata: this.metadata,
+      msg,
+      extra,
+    });
+  }
+
+  dispose() {}
+}

package/src/settings/general.ts

@@ -0,0 +1,5 @@
+export const enum GeneralSettingsId {
+  Icon = 'general.icon',
+  Theme = 'general.theme',
+  Language = 'general.language',
+}

package/src/settings/index.ts

@@ -0,0 +1,3 @@
+export * from './general';
+export * from './search';
+export * from './terminal';

package/src/settings/search.ts

@@ -0,0 +1,7 @@
+export const enum SearchSettingId {
+  Exclude = 'search.exclude',
+  Include = 'search.include',
+  UseReplacePreview = 'search.useReplacePreview',
+  SearchOnType = 'search.searchOnType',
+  SearchOnTypeDebouncePeriod = 'search.searchOnTypeDebouncePeriod',
+}

package/src/settings/terminal.ts

@@ -0,0 +1,9 @@
+export const enum TerminalSettingsId {
+  Type = 'terminal.type',
+  FontFamily = 'terminal.fontFamily',
+  FontSize = 'terminal.fontSize',
+  FontWeight = 'terminal.fontWeight',
+  LineHeight = 'terminal.lineHeight',
+  CursorBlink = 'terminal.cursorBlink',
+  Scrollback = 'terminal.scrollback',
+}

package/src/storage.ts

@@ -0,0 +1,99 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { IDisposable, MaybePromise, Event, URI } from '@opensumi/ide-utils';
+
+import { ContributionProvider } from './contribution-provider';
+
+export const StorageProvider = Symbol('StorageProvider');
+export type StorageProvider = (storageId: URI) => Promise<IStorage>;
+
+export const StorageResolverContribution = Symbol('StorageResolverContribution');
+
+export interface StorageResolverContribution {
+  resolve(storageId: URI): MaybePromise<void | IStorage>;
+}
+
+export interface IStorage extends IDisposable {
+  readonly items: Map<string, string>;
+  readonly size: number;
+  readonly onDidChangeStorage: Event<string>;
+  readonly whenReady: Promise<any>;
+
+  init(storageId: string): Promise<IStorage | void>;
+
+  get(key: string, fallbackValue: string): string;
+  get(key: string, fallbackValue?: string): string | undefined;
+  get<T>(key: string, fallbackValue?: T): T;
+
+  getBoolean(key: string, fallbackValue: boolean): boolean;
+  getBoolean(key: string, fallbackValue?: boolean): boolean | undefined;
+
+  getNumber(key: string, fallbackValue: number): number;
+  getNumber(key: string, fallbackValue?: number): number | undefined;
+
+  set(key: string, value: object | string | boolean | number | undefined | null): Promise<void>;
+  delete(key: string): Promise<void>;
+
+  close(): Promise<void>;
+  reConnectInit(): Promise<void>;
+}
+
+export const STORAGE_SCHEMA = {
+  SCOPE: 'wsdb',
+  GLOBAL: 'gldb',
+};
+
+// 在该对象定义的存储对象在初始化阶段时将默认通过 LocalStorage 缓存
+// ref: https://github.com/opensumi/core/blob/f512897d691f1aa0d89ff6469ff2251ab2124f71/packages/storage/src/browser/storage.contribution.ts#L49
+export const STORAGE_NAMESPACE = {
+  // workspace database
+  WORKBENCH: new URI('workbench').withScheme(STORAGE_SCHEMA.SCOPE),
+  EXTENSIONS: new URI('extensions').withScheme(STORAGE_SCHEMA.SCOPE),
+  EXPLORER: new URI('explorer').withScheme(STORAGE_SCHEMA.SCOPE),
+  LAYOUT: new URI('layout').withScheme(STORAGE_SCHEMA.SCOPE),
+  RECENT_DATA: new URI('recent').withScheme(STORAGE_SCHEMA.SCOPE),
+  DEBUG: new URI('debug').withScheme(STORAGE_SCHEMA.SCOPE),
+  OUTLINE: new URI('outline').withScheme(STORAGE_SCHEMA.SCOPE),
+  // global database
+  GLOBAL_LAYOUT: new URI('layout-global').withScheme(STORAGE_SCHEMA.GLOBAL),
+  GLOBAL_EXTENSIONS: new URI('extensions').withScheme(STORAGE_SCHEMA.GLOBAL),
+  GLOBAL_RECENT_DATA: new URI('recent').withScheme(STORAGE_SCHEMA.GLOBAL),
+};
+
+@Injectable()
+export class DefaultStorageProvider {
+  @Autowired(StorageResolverContribution)
+  protected readonly resolversProvider: ContributionProvider<StorageResolverContribution>;
+
+  private storageCacheMap: Map<string, IStorage> = new Map();
+
+  /**
+   * 返回对应storageId的Storage类
+   */
+  async get(storageId: URI): Promise<IStorage | void> {
+    if (this.storageCacheMap.has(storageId.toString())) {
+      return this.storageCacheMap.get(storageId.toString());
+    }
+    const resolvers = this.resolversProvider.getContributions();
+    return Promise.race(
+      resolvers.map(async (resolver) => {
+        const storageResolver = await resolver.resolve(storageId);
+        if (storageResolver) {
+          this.storageCacheMap.set(storageId.toString(), storageResolver);
+          return storageResolver;
+        }
+      }),
+    );
+  }
+}
+
+export namespace StoragePaths {
+  export const WINDOWS_APP_DATA_DIR = 'AppData';
+  export const WINDOWS_ROAMING_DIR = 'Roaming';
+  // 可通过AppConfig配置替换，目前仅作为默认值使用
+  export const DEFAULT_STORAGE_DIR_NAME = '.sumi';
+  export const DEFAULT_DATA_DIR_NAME = 'datas';
+  export const MARKETPLACE_DIR = 'extensions';
+  export const EXTENSIONS_LOGS_DIR = 'extensions';
+  export const EXTENSIONS_GLOBAL_STORAGE_DIR = 'extension-storage';
+  export const EXTENSIONS_WORKSPACE_STORAGE_DIR = 'workspace-storage';
+}

package/src/task-definition.ts

@@ -0,0 +1,172 @@
+import { Injectable } from '@opensumi/di';
+import { objects, IDisposable, Disposable } from '@opensumi/ide-utils';
+
+import { IJSONSchemaMap, IJSONSchema } from './json-schema';
+import { formatLocalize } from './localize';
+import { IStringDictionary } from './types/string';
+
+const { deepClone } = objects;
+
+interface TaskDefinition {
+  extensionId: string;
+  taskType: string;
+  required: string[];
+  properties: IJSONSchemaMap;
+}
+
+export interface TaskIdentifier {
+  type: string;
+  [name: string]: any;
+}
+
+export interface KeyedTaskIdentifier extends TaskIdentifier {
+  _key: string;
+}
+
+export namespace KeyedTaskIdentifier {
+  function sortedStringify(literal: any): string {
+    const keys = Object.keys(literal).sort();
+    let result = '';
+    for (const key of keys) {
+      let stringified = literal[key];
+      if (stringified instanceof Object) {
+        stringified = sortedStringify(stringified);
+      } else if (typeof stringified === 'string') {
+        stringified = stringified.replace(/,/g, ',,');
+      }
+      result += key + ',' + stringified + ',';
+    }
+    return result;
+  }
+  export function create(value: TaskIdentifier): KeyedTaskIdentifier {
+    const resultKey = sortedStringify(value);
+    const result = { _key: resultKey, type: value.taskType };
+    Object.assign(result, value);
+    return result;
+  }
+}
+
+export const ITaskDefinitionRegistry = Symbol('ITaskDefinitionRegistry');
+
+export interface ITaskDefinitionRegistry {
+  onReady(): Promise<void>;
+  register(taskType: string, definition: TaskDefinition): IDisposable;
+  get(key: string): TaskDefinition;
+  all(): TaskDefinition[];
+  getJsonSchema(): IJSONSchema;
+  createTaskIdentifier(
+    external: TaskIdentifier,
+    reporter: { error(message: string): void },
+  ): KeyedTaskIdentifier | undefined;
+}
+
+@Injectable()
+export class TaskDefinitionRegistryImpl implements ITaskDefinitionRegistry {
+  private taskTypes: IStringDictionary<TaskDefinition>;
+  private readyPromise: Promise<void>;
+  private _schema: IJSONSchema;
+
+  constructor() {
+    this.taskTypes = Object.create(null);
+    this.readyPromise = new Promise<void>((res, rej) => res(undefined));
+  }
+
+  public onReady(): Promise<void> {
+    return this.readyPromise;
+  }
+
+  register(taskType: string, definition: TaskDefinition) {
+    this.taskTypes[taskType] = definition;
+    return Disposable.create(() => delete this.taskTypes[taskType]);
+  }
+
+  public get(key: string): TaskDefinition {
+    return this.taskTypes[key];
+  }
+
+  public all(): TaskDefinition[] {
+    return Object.keys(this.taskTypes).map((key) => this.taskTypes[key]);
+  }
+
+  public createTaskIdentifier = (
+    external: TaskIdentifier,
+    reporter: { error(message: string): void },
+  ): KeyedTaskIdentifier | undefined => {
+    const definition = this.get(external.type);
+    if (definition === undefined) {
+      // We have no task definition so we can't sanitize the literal. Take it as is
+      const copy = deepClone(external);
+      delete copy._key;
+      return KeyedTaskIdentifier.create(copy);
+    }
+
+    const literal: { type: string; [name: string]: any } = Object.create(null);
+    literal.type = definition.taskType;
+    const required: Set<string> = new Set();
+    definition.required.forEach((element) => required.add(element));
+
+    const properties = definition.properties;
+    for (const property of Object.keys(properties)) {
+      const value = external[property];
+      if (value !== undefined && value !== null) {
+        literal[property] = value;
+      } else if (required.has(property)) {
+        const schema = properties[property];
+        if (schema.default !== undefined) {
+          literal[property] = deepClone(schema.default);
+        } else {
+          switch (schema.type) {
+            case 'boolean':
+              literal[property] = false;
+              break;
+            case 'number':
+            case 'integer':
+              literal[property] = 0;
+              break;
+            case 'string':
+              literal[property] = '';
+              break;
+            default:
+              reporter.error(
+                formatLocalize(
+                  'TaskDefinition.missingRequiredProperty',
+                  "Error: the task identifier '{0}' is missing the required property '{1}'. The task identifier will be ignored.",
+                  JSON.stringify(external, undefined, 0),
+                  property,
+                ),
+              );
+              return undefined;
+          }
+        }
+      }
+    }
+    return KeyedTaskIdentifier.create(literal);
+  };
+
+  public getJsonSchema(): IJSONSchema {
+    if (this._schema === undefined) {
+      const schemas: IJSONSchema[] = [];
+      for (const definition of this.all()) {
+        const schema: IJSONSchema = {
+          type: 'object',
+          additionalProperties: false,
+        };
+        if (definition.required.length > 0) {
+          schema.required = definition.required.slice(0);
+        }
+        if (definition.properties !== undefined) {
+          schema.properties = deepClone(definition.properties);
+        } else {
+          schema.properties = Object.create(null);
+        }
+        schema.properties!.type = {
+          type: 'string',
+          enum: [definition.taskType],
+        };
+        schemas.push(schema);
+      }
+      this._schema = { oneOf: schemas };
+    }
+    return this._schema;
+  }
+}

package/src/theme.ts

@@ -0,0 +1,7 @@
+export interface IThemeColor {
+  id: string;
+}
+
+export function isThemeColor(obj: any): obj is IThemeColor {
+  return obj && typeof obj === 'object' && typeof (obj as IThemeColor).id === 'string';
+}

package/src/types/accessibility.ts

@@ -0,0 +1,4 @@
+export interface IAccessibilityInformation {
+  label: string;
+  role?: string;
+}

package/src/types/application.ts

@@ -0,0 +1,14 @@
+import { OperatingSystem } from '@opensumi/ide-utils';
+
+export const IApplicationService = Symbol('IApplicationService');
+
+export interface IApplicationService {
+  /** 前端 OS */
+  frontendOS: OperatingSystem;
+  /** 后端 OS */
+  backendOS: OperatingSystem;
+  /**
+   * 获取后端 OS
+   */
+  getBackendOS(): Promise<OperatingSystem>;
+}

package/src/types/authentication.ts

@@ -0,0 +1,120 @@
+import { IDisposable, Event } from '@opensumi/ide-utils';
+
+export const noAccountsId = 'authentication.noAccounts';
+
+export const ACCOUNTS_MENU = ['accounts_menu'];
+export const ACCOUNTS_SUBMENU = [...ACCOUNTS_MENU, '1_accounts_submenu'];
+
+export interface AllowedExtension {
+  id: string;
+  name: string;
+}
+
+export interface AuthenticationSessionsChangeEvent {
+  added: ReadonlyArray<AuthenticationSession>;
+  removed: ReadonlyArray<AuthenticationSession>;
+  changed: ReadonlyArray<AuthenticationSession>;
+}
+
+export interface AuthenticationSession {
+  id: string;
+  accessToken: string;
+  account: {
+    label: string;
+    id: string;
+  };
+  scopes: ReadonlyArray<string>;
+}
+
+export interface AuthenticationProviderInformation {
+  id: string;
+  label: string;
+}
+
+export interface AllowedExtension {
+  id: string;
+  name: string;
+  allowed?: boolean;
+}
+
+export interface IAuthenticationProvider {
+  id: string;
+  label: string;
+  supportsMultipleAccounts: boolean;
+  manageTrustedExtensions(accountName: string): Promise<void>;
+  updateSessionItems(event: AuthenticationSessionsChangeEvent): Promise<void>;
+  getSessions(): Promise<ReadonlyArray<AuthenticationSession>>;
+  hasSessions(): boolean;
+  login(scopes: string[]): Promise<AuthenticationSession>;
+  logout(sessionId: string): Promise<void>;
+  signOut(accountName: string): Promise<void>;
+  dispose(): void;
+}
+
+export const IAuthenticationService = Symbol('IAuthenticationService');
+export interface IAuthenticationService {
+  readonly onDidRegisterAuthenticationProvider: Event<AuthenticationProviderInformation>;
+  readonly onDidUnregisterAuthenticationProvider: Event<AuthenticationProviderInformation>;
+  readonly onDidChangeSessions: Event<{ providerId: string; label: string; event: AuthenticationSessionsChangeEvent }>;
+  initialize(): Promise<void>;
+  isAuthenticationProviderRegistered(id: string): boolean;
+  getProviderIds(): string[];
+  registerAuthenticationProvider(id: string, provider: IAuthenticationProvider): void;
+  unregisterAuthenticationProvider(id: string): void;
+  requestNewSession(providerId: string, scopes: string[], extensionId: string, extensionName: string): Promise<void>;
+  sessionsUpdate(providerId: string, event: AuthenticationSessionsChangeEvent): void;
+
+  getSessions(
+    id: string,
+    scopes?: string[],
+    activateImmediate?: boolean,
+  ): Promise<ReadonlyArray<AuthenticationSession>>;
+  getLabel(providerId: string): string;
+  supportsMultipleAccounts(providerId: string): boolean;
+  login(providerId: string, scopes: string[]): Promise<AuthenticationSession>;
+  logout(providerId: string, sessionId: string): Promise<void>;
+
+  manageTrustedExtensionsForAccount(providerId: string, accountName: string): Promise<void>;
+  signOutOfAccount(providerId: string, accountName: string): Promise<void>;
+
+  getExtensionSessionId(extensionName: string, providerId: string): Promise<string | undefined>;
+  setExtensionSessionId(extensionName: string, providerId: string, sessionId: string): Promise<void>;
+  removeExtensionSessionId(extensionName: string, providerId: string): Promise<void>;
+  updatedAllowedExtension(
+    providerId: string,
+    accountName: string,
+    extensionId: string,
+    extensionName: string,
+    isAllowed: boolean,
+  ): Promise<void>;
+  getAllowedExtensions(providerId: string, accountName: string): Promise<AllowedExtension[]>;
+  setAllowedExtensions(providerId: string, accountName: string, allowList: AllowedExtension[]): Promise<void>;
+  removeAllowedExtensions(providerId: any, accountName: string): Promise<void>;
+  isAccessAllowed(providerId: string, accountName: string, extensionId: string): Promise<boolean | undefined>;
+
+  getAccountUsages(providerId: string, accountName: string): Promise<IAccountUsage[]>;
+  addAccountUsage(providerId: string, accountName: string, extensionId: string, extensionName: string): Promise<void>;
+  removeAccountUsage(providerId: string, accountName: string): Promise<void>;
+}
+
+export interface IAccountUsage {
+  extensionId: string;
+  extensionName: string;
+  lastUsed: number;
+}
+
+export interface SessionRequest {
+  disposables: IDisposable[];
+  requestingExtensionIds: string[];
+}
+
+export interface SessionRequestInfo {
+  [scopes: string]: SessionRequest;
+}
+
+export interface AuthenticationGetSessionOptions {
+  createIfNone: boolean;
+  clearSessionPreference: boolean;
+  forceNewSession?: boolean | { detail: string };
+  silent?: boolean;
+}

package/src/types/common.ts

@@ -0,0 +1,14 @@
+import { OperatingSystem } from '@opensumi/ide-utils';
+
+export const CommonServerPath = 'CommonServerPath';
+
+export const ICommonServer = Symbol('ICommonServer');
+
+export interface ICommonServer {
+  /**
+   * 获取后端 OS
+   */
+  getBackendOS(): Promise<OperatingSystem>;
+}
+
+export type UrlProvider = string | (() => string) | (() => Promise<string>);

package/src/types/dnd.ts

@@ -0,0 +1,8 @@
+import { BasicEvent } from '../event-bus';
+
+export interface IFileTreeDropEventPayload {
+  event: DragEvent;
+  targetDir?: string;
+}
+
+export class FileTreeDropEvent extends BasicEvent<IFileTreeDropEventPayload> {}