@opensumi/ide-editor 2.21.13 → 2.22.0

package/src/common/index.ts

@@ -0,0 +1,6 @@
+export * from './doc-cache';
+export * from './editor';
+export * from './resource';
+export * from './language';
+export * from './utils';
+export * from './language-status';

package/src/common/language-status.ts

@@ -0,0 +1,33 @@
+import {
+  IAccessibilityInformation,
+  IDisposable,
+  Severity,
+  Event,
+  StatusBarHoverCommand,
+} from '@opensumi/ide-core-common';
+// eslint-disable-next-line import/no-restricted-paths
+import type { ITextModel } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+
+import { LanguageSelector } from './language';
+
+export const ILanguageStatusService = Symbol('ILanguageStatusService');
+export interface ILanguageStatusService {
+  onDidChange: Event<void>;
+
+  addStatus(status: ILanguageStatus): IDisposable;
+
+  getLanguageStatus(model: ITextModel): ILanguageStatus[];
+}
+
+export interface ILanguageStatus {
+  readonly id: string;
+  readonly name: string;
+  readonly selector: LanguageSelector;
+  readonly severity: Severity;
+  readonly label: string;
+  readonly detail: string;
+  readonly source: string;
+  readonly command?: StatusBarHoverCommand;
+  readonly accessibilityInfo: IAccessibilityInformation | undefined;
+  readonly busy: boolean;
+}

package/src/common/language.ts

@@ -0,0 +1,206 @@
+import LSTypes from 'vscode-languageserver-types';
+
+import { MarkerSeverity } from '@opensumi/ide-core-common';
+import { CancellationToken, IDisposable, IRelativePattern } from '@opensumi/ide-core-common';
+import { URI as Uri } from '@opensumi/monaco-editor-core/esm/vs/base/common/uri';
+import { editor } from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+import type { IRelatedInformation } from '@opensumi/monaco-editor-core/esm/vs/platform/markers/common/markers';
+
+export const ILanguageService = Symbol('ILanguageService');
+
+export interface ILanguageService {
+  languages: Language[];
+  workspaceSymbolProviders: WorkspaceSymbolProvider[];
+  getLanguage(languageId: string): Language | undefined;
+  registerWorkspaceSymbolProvider(provider: WorkspaceSymbolProvider): IDisposable;
+}
+
+export interface DiagnosticCollection extends IDisposable {
+  set(uri: string, diagnostics: Diagnostic[]): void;
+}
+/**
+ * Represents a related message and source code location for a diagnostic. This should be
+ * used to point to code locations that cause or related to a diagnostics, e.g when duplicating
+ * a symbol in a scope.
+ */
+export interface DiagnosticRelatedInformation {
+  /**
+   * The location of this related diagnostic information.
+   */
+  location: LSTypes.Location;
+  /**
+   * The message of this related diagnostic information.
+   */
+  message: string;
+}
+/**
+ * The DiagnosticRelatedInformation namespace provides helper functions to work with
+ * [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) literals.
+ */
+export declare namespace DiagnosticRelatedInformation {
+  /**
+   * Creates a new DiagnosticRelatedInformation literal.
+   */
+  function create(location: Location, message: string): DiagnosticRelatedInformation;
+  /**
+   * Checks whether the given literal conforms to the [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) interface.
+   */
+  function is(value: any): value is DiagnosticRelatedInformation;
+}
+
+export enum DiagnosticSeverity {
+  Error = 1,
+  Warning = 2,
+  Information = 3,
+  Hint = 4,
+}
+
+/**
+ * Represents a diagnostic, such as a compiler error or warning. Diagnostic objects
+ * are only valid in the scope of a resource.
+ */
+export interface Diagnostic {
+  /**
+   * The range at which the message applies
+   */
+  range: LSTypes.Range;
+  /**
+   * The diagnostic's severity. Can be omitted. If omitted it is up to the
+   * client to interpret diagnostics as error, warning, info or hint.
+   */
+  severity: DiagnosticSeverity;
+
+  /**
+   * A code or identifier for this diagnostic.
+   * Should be used for later processing, e.g. when providing {@link CodeActionContext code actions}.
+   */
+  code?:
+    | string
+    | number
+    | {
+        /**
+         * A code or identifier for this diagnostic.
+         * Should be used for later processing, e.g. when providing {@link CodeActionContext code actions}.
+         */
+        value: string | number;
+
+        /**
+         * A target URI to open with more information about the diagnostic error.
+         */
+        target: Uri;
+      };
+  /**
+   * A human-readable string describing the source of this
+   * diagnostic, e.g. 'typescript' or 'super lint'.
+   */
+  source?: string;
+  /**
+   * The diagnostic's message.
+   */
+  message: string;
+  /**
+   * An array of related diagnostic information, e.g. when symbol-names within
+   * a scope collide all definitions can be marked via this property.
+   */
+  relatedInformation?: DiagnosticRelatedInformation[];
+
+  tags?: DiagnosticTag[];
+}
+
+export enum DiagnosticTag {
+  Unnecessary = 1,
+  Deprecated = 2,
+}
+
+export function asSeverity(severity?: number): MarkerSeverity {
+  if (severity === 1) {
+    return MarkerSeverity.Error;
+  }
+  if (severity === 2) {
+    return MarkerSeverity.Warning;
+  }
+  if (severity === 3) {
+    return MarkerSeverity.Info;
+  }
+  return MarkerSeverity.Hint;
+}
+export function asRelatedInformations(
+  relatedInformation?: DiagnosticRelatedInformation[],
+): IRelatedInformation[] | undefined {
+  if (!relatedInformation) {
+    return undefined;
+  }
+  return relatedInformation.map((item) => asRelatedInformation(item));
+}
+
+export function asRelatedInformation(relatedInformation: DiagnosticRelatedInformation): IRelatedInformation {
+  return {
+    resource: Uri.parse(relatedInformation.location.uri),
+    startLineNumber: relatedInformation.location.range.start.line + 1,
+    startColumn: relatedInformation.location.range.start.character + 1,
+    endLineNumber: relatedInformation.location.range.end.line + 1,
+    endColumn: relatedInformation.location.range.end.character + 1,
+    message: relatedInformation.message,
+  };
+}
+export function asMonacoDiagnostics(diagnostics: Diagnostic[] | undefined): editor.IMarkerData[] | undefined {
+  if (!diagnostics) {
+    return undefined;
+  }
+  return diagnostics.map((diagnostic) => asMonacoDiagnostic(diagnostic));
+}
+
+export function asMonacoDiagnostic(diagnostic: Diagnostic): editor.IMarkerData {
+  return {
+    code:
+      typeof diagnostic.code === 'number'
+        ? diagnostic.code.toString()
+        : typeof diagnostic.code === 'object'
+        ? {
+            value: diagnostic.code.value.toString(),
+            target: diagnostic.code.target,
+          }
+        : diagnostic.code,
+    severity: asSeverity(diagnostic.severity),
+    message: diagnostic.message,
+    source: diagnostic.source,
+    // language server range is 0-based, marker is 1-based
+    startLineNumber: diagnostic.range.start.line + 1,
+    startColumn: diagnostic.range.start.character + 1,
+    endLineNumber: diagnostic.range.end.line + 1,
+    endColumn: diagnostic.range.end.character + 1,
+    relatedInformation: asRelatedInformations(diagnostic.relatedInformation),
+    tags: diagnostic.tags as number[],
+  };
+}
+
+export interface WorkspaceSymbolParams {
+  query: string;
+}
+
+export interface WorkspaceSymbolProvider {
+  provideWorkspaceSymbols(
+    params: WorkspaceSymbolParams,
+    token: CancellationToken,
+  ): Thenable<LSTypes.SymbolInformation[]>;
+  resolveWorkspaceSymbol(
+    symbol: LSTypes.SymbolInformation,
+    token: CancellationToken,
+  ): Thenable<LSTypes.SymbolInformation>;
+}
+
+export interface Language {
+  readonly id: string;
+  readonly name: string;
+  readonly extensions: Set<string>;
+  readonly filenames: Set<string>;
+}
+
+export interface LanguageFilter {
+  language?: string;
+  scheme?: string;
+  pattern?: string | IRelativePattern;
+  hasAccessToAllModels?: boolean;
+}
+
+export type LanguageSelector = string | LanguageFilter | (string | LanguageFilter)[];

package/src/common/mocks/workbench-editor.service.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@opensumi/di';
+import { URI, Emitter, MaybeNull, Event } from '@opensumi/ide-core-common';
+
+// eslint-disable-next-line import/no-restricted-paths
+import type { IEditorGroup } from '../../browser';
+import { WorkbenchEditorService, IResourceOpenOptions, IUntitledOptions, IOpenResourceResult } from '../editor';
+import { IResource } from '../resource';
+
+@Injectable()
+export class MockWorkbenchEditorService extends WorkbenchEditorService {
+  private readonly _onActiveResourceChange = new Emitter<MaybeNull<IResource>>();
+  public readonly onActiveResourceChange: Event<MaybeNull<IResource>> = this._onActiveResourceChange.event;
+
+  private readonly _onDidEditorGroupsChanged = new Emitter<void>();
+  public readonly onDidEditorGroupsChanged: Event<void> = this._onDidEditorGroupsChanged.event;
+
+  private readonly _onDidCurrentEditorGroupChanged = new Emitter<IEditorGroup>();
+  public readonly onDidCurrentEditorGroupChanged: Event<IEditorGroup> = this._onDidCurrentEditorGroupChanged.event;
+
+  async closeAll(uri?: URI, force?: boolean): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  async open(uri: URI, options?: IResourceOpenOptions): Promise<IOpenResourceResult> {
+    throw new Error('Method not implemented.');
+  }
+
+  async openUris(uri: URI[]): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  saveAll(includeUntitled?: boolean): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  async close(uri: any, force?: boolean): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  getAllOpenedUris(): URI[] {
+    throw new Error('Method not implemented.');
+  }
+
+  // 创建一个带待存的资源
+  createUntitledResource(options?: IUntitledOptions): Promise<IOpenResourceResult> {
+    throw new Error('Method not implemented.');
+  }
+
+  setEditorContextKeyService() {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/common/resource.ts

@@ -0,0 +1,147 @@
+import { URI, BasicEvent, MaybePromise, IDisposable, Event } from '@opensumi/ide-core-common';
+
+export interface IResourceProvider {
+  scheme?: string; // 相当于 handlesUri => 10
+
+  /**
+   * 一个 provider 是否处理某个资源
+   * 返回优先级，这个值越高的 provider 越优先处理， 小于 0 表示不处理
+   * 这个比较的计算结果会被缓存，仅仅当 provider 数量变更时才会清空
+   * 存在 handlesURI 时， 上面的scheme会被忽略
+   */
+  handlesUri?(uri: URI): number;
+
+  provideResource(uri: URI): MaybePromise<IResource>;
+
+  provideResourceSubname?(resource: IResource, groupResources: IResource[]): string | null;
+
+  shouldCloseResource?(resource: IResource, openedResources: IResource[][]): MaybePromise<boolean>;
+  /**
+   * 只是用来判断一个 resource 是否可以被 Close
+   * 与 shouldCloseResource 的区别是，这个方法不会触发真实的 close，你需要手动调用 `close` 方法
+   */
+  shouldCloseResourceWithoutConfirm?(resource: IResource): MaybePromise<boolean>;
+
+  close?(resource: IResource, saveAction: AskSaveResult): MaybePromise<boolean>;
+
+  onDisposeResource?(resource: IResource): void;
+}
+
+export abstract class ResourceService {
+  /**
+   * 注册一个新的 ResourceProvider 会触发该事件
+   */
+  readonly onRegisterResourceProvider: Event<IResourceProvider>;
+  /**
+   * 写在一个 ResourceProvider 会触发该事件
+   */
+  readonly onUnregisterResourceProvider: Event<IResourceProvider>;
+  /**
+   * 根据uri获得一个资源信息
+   * 如果uri没有对应的resource提供者，则会返回null
+   * @param uri
+   */
+  abstract getResource(uri: URI): Promise<IResource | null>;
+
+  /**
+   * 注册一个resource提供方
+   * @param provider
+   */
+  abstract registerResourceProvider(provider: IResourceProvider): IDisposable;
+
+  /**
+   * 是否能关闭一个资源
+   */
+  abstract shouldCloseResource(resource: IResource, openedResources: IResource[][]): Promise<boolean>;
+
+  /**
+   * 与 `shouldCloseResource` 不同的点在于：不弹窗让用户确认
+   * 返回 true 说明用户可以之后调用 `close` 方法将其关闭
+   */
+  abstract shouldCloseResourceWithoutConfirm(resource: IResource): Promise<boolean>;
+  close?(resource: IResource, saveAction: AskSaveResult): MaybePromise<boolean>;
+
+  abstract getResourceDecoration(uri: URI): IResourceDecoration;
+
+  abstract getResourceSubname(resource: IResource, groupResources: IResource[]): string | null;
+
+  /**
+   * 销毁一个 resource
+   * @param resource
+   */
+  abstract disposeResource(resource: IResource<any>): void;
+
+  /**
+   * 是否存在 provider 可以处理某个 uri
+   */
+  abstract handlesUri(uri: URI): boolean;
+}
+
+/**
+ * 当资源信息被更新时，期望provider发送这么一个事件，让当前使用资源的服务能及时了解
+ */
+export class ResourceNeedUpdateEvent extends BasicEvent<URI> {}
+
+export class ResourceDidUpdateEvent extends BasicEvent<URI> {}
+
+export class ResourceRemoveEvent extends BasicEvent<URI> {}
+
+export class ResourceDecorationChangeEvent extends BasicEvent<IResourceDecorationChangeEventPayload> {}
+
+export class ResourceDecorationNeedChangeEvent extends BasicEvent<IResourceDecorationChangeEventPayload> {}
+
+export type IResourceUpdateType = 'change' | 'remove';
+
+export interface IResourceDecoration {
+  dirty: boolean;
+}
+
+export interface IResourceDecorationChangeEventPayload {
+  uri: URI;
+  decoration: IResourceDecoration;
+}
+
+/**
+ * Resource
+ * 一个资源代表了一个能够在编辑器区域被打开的东西
+ */
+export interface IResource<MetaData = any> {
+  /**
+   * 是否允许刷新后恢复
+   */
+  supportsRevive?: boolean;
+
+  // 资源名称
+  name: string;
+  // 资源URI
+  uri: URI;
+  // 资源icon的class
+  icon: string;
+  // 资源的额外信息
+  metadata?: MetaData;
+  // 资源已被删除
+  deleted?: any;
+}
+
+export type IDiffResource = IResource<{ original: URI; modified: URI }>;
+
+export const DIFF_SCHEME = 'diff';
+
+export function isDiffResource(resource: IResource): resource is IDiffResource {
+  return resource.uri.scheme === DIFF_SCHEME;
+}
+
+export enum AskSaveResult {
+  REVERT = 1,
+  SAVE = 2,
+  CANCEL = 3,
+}
+
+// #region merge editor
+export type IMergeEditorResource = IResource<{
+  ancestor: string;
+  input1: string;
+  input2: string;
+  output: string;
+}>;
+// #endregion merge editor

package/src/common/utils.ts

@@ -0,0 +1,10 @@
+import { DragOverPosition, EditorGroupSplitAction } from './editor';
+
+export function getSplitActionFromDragDrop(position: DragOverPosition): EditorGroupSplitAction {
+  return {
+    [DragOverPosition.LEFT]: EditorGroupSplitAction.Left,
+    [DragOverPosition.RIGHT]: EditorGroupSplitAction.Right,
+    [DragOverPosition.BOTTOM]: EditorGroupSplitAction.Bottom,
+    [DragOverPosition.TOP]: EditorGroupSplitAction.Top,
+  }[position];
+}

package/src/index.ts

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

package/lib/browser/component/scroll/scroll.d.ts

@@ -1,2 +0,0 @@
-export * from '@opensumi/ide-core-browser/lib/components/scroll';
-//# sourceMappingURL=scroll.d.ts.map

package/lib/browser/component/scroll/scroll.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scroll.d.ts","sourceRoot":"","sources":["../../../../src/browser/component/scroll/scroll.tsx"],"names":[],"mappings":"AAAA,cAAc,kDAAkD,CAAC"}

package/lib/browser/component/scroll/scroll.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("@opensumi/ide-core-browser/lib/components/scroll"), exports);
-//# sourceMappingURL=scroll.js.map

package/lib/browser/component/scroll/scroll.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scroll.js","sourceRoot":"","sources":["../../../../src/browser/component/scroll/scroll.tsx"],"names":[],"mappings":";;;AAAA,2FAAiE"}

package/lib/browser/component/scroll/scroll.module.less

@@ -1,86 +0,0 @@
-@import '~@opensumi/ide-core-browser/lib/style/variable.less';
-
-.track-vertical {
-  position: absolute;
-  right: 0;
-  top: 0;
-  height: 100%;
-  width: 10px;
-}
-.scroll-vertical {
-  position: absolute;
-  right: 0;
-  top: 0;
-  height: 100%;
-  width: 10px;
-  z-index: 2;
-}
-
-.track-horizontal {
-  position: absolute;
-  bottom: 0;
-  left: 0;
-  width: 100%;
-  height: 5px;
-}
-.scroll-horizontal {
-  position: absolute;
-  bottom: 0;
-  left: 0;
-  width: 100%;
-  height: 5px;
-  z-index: 2;
-}
-
-:global(.thumb-vertical) {
-  position: absolute;
-  width: 5px;
-  opacity: 0.8;
-  top: 0;
-  right: 0;
-  transition: opacity 200ms ease-out;
-  background: var(--scrollbarSlider-background);
-  box-shadow: 1px 0 0 var(--scrollbar-shadow);
-
-  &:hover {
-    background: var(--scrollbarSlider-hoverBackground);
-  }
-}
-
-:global(.thumb-horizontal) {
-  position: absolute;
-  height: 5px;
-  left: 0;
-  bottom: 0;
-  opacity: 0.8;
-  transition: opacity 200ms ease-out 200ms;
-  background: var(--scrollbarSlider-background);
-  box-shadow: 1px 0 0 var(--scrollbar-shadow);
-
-  &:hover {
-    background: var(--scrollbarSlider-hoverBackground);
-  }
-}
-
-.scroll {
-  position: relative;
-  height: 100%;
-  > *:first-child::-webkit-scrollbar {
-    display: none !important;
-    background: rgb(50, 50, 50);
-  }
-  > *:first-child {
-    overflow: auto;
-    height: 100%;
-    width: 100%;
-  }
-}
-
-.hide-thumb {
-  :global(.thumb-horizontal) {
-    opacity: 0 !important;
-  }
-  :global(.thumb-vertical) {
-    opacity: 0 !important;
-  }
-}