@opensumi/ide-core-browser 2.21.13 → 2.22.0

package/src/dom/index.ts

@@ -0,0 +1,176 @@
+import { Disposable, Emitter, Event as BaseEvent, IDisposable } from '@opensumi/ide-core-common';
+import { isWebKit } from '@opensumi/ide-core-common';
+
+export const EventType = {
+  // Mouse
+  CLICK: 'click',
+  DBLCLICK: 'dblclick',
+  MOUSE_UP: 'mouseup',
+  MOUSE_DOWN: 'mousedown',
+  MOUSE_OVER: 'mouseover',
+  MOUSE_MOVE: 'mousemove',
+  MOUSE_OUT: 'mouseout',
+  MOUSE_ENTER: 'mouseenter',
+  MOUSE_LEAVE: 'mouseleave',
+  CONTEXT_MENU: 'contextmenu',
+  WHEEL: 'wheel',
+  // Keyboard
+  KEY_DOWN: 'keydown',
+  KEY_PRESS: 'keypress',
+  KEY_UP: 'keyup',
+  // HTML Document
+  LOAD: 'load',
+  UNLOAD: 'unload',
+  ABORT: 'abort',
+  ERROR: 'error',
+  RESIZE: 'resize',
+  SCROLL: 'scroll',
+  FULLSCREEN_CHANGE: 'fullscreenchange',
+  WK_FULLSCREEN_CHANGE: 'webkitfullscreenchange',
+  // Form
+  SELECT: 'select',
+  CHANGE: 'change',
+  SUBMIT: 'submit',
+  RESET: 'reset',
+  FOCUS: 'focus',
+  FOCUS_IN: 'focusin',
+  FOCUS_OUT: 'focusout',
+  BLUR: 'blur',
+  INPUT: 'input',
+  // Local Storage
+  STORAGE: 'storage',
+  // Drag
+  DRAG_START: 'dragstart',
+  DRAG: 'drag',
+  DRAG_ENTER: 'dragenter',
+  DRAG_LEAVE: 'dragleave',
+  DRAG_OVER: 'dragover',
+  DROP: 'drop',
+  DRAG_END: 'dragend',
+  // Animation
+  ANIMATION_START: isWebKit ? 'webkitAnimationStart' : 'animationstart',
+  ANIMATION_END: isWebKit ? 'webkitAnimationEnd' : 'animationend',
+  ANIMATION_ITERATION: isWebKit ? 'webkitAnimationIteration' : 'animationiteration',
+};
+
+export type EventHandler = HTMLElement | HTMLDocument | Window;
+
+export interface IFocusTracker extends Disposable {
+  onDidFocus: BaseEvent<void>;
+  onDidBlur: BaseEvent<void>;
+}
+
+export function isAncestor(testChild: Node | null, testAncestor: Node | null): boolean {
+  while (testChild) {
+    if (testChild === testAncestor) {
+      return true;
+    }
+    testChild = testChild.parentNode;
+  }
+
+  return false;
+}
+
+export class DomListener implements IDisposable {
+  private _handler: (e: any) => void;
+  private _node: EventTarget;
+  private readonly _type: string;
+  private readonly _useCapture: boolean | AddEventListenerOptions;
+
+  constructor(
+    node: EventTarget,
+    type: string,
+    handler: (e: any) => void,
+    useCapture?: boolean | AddEventListenerOptions,
+  ) {
+    this._node = node;
+    this._type = type;
+    this._handler = handler;
+    this._useCapture = useCapture || false;
+    this._node.addEventListener(this._type, this._handler, this._useCapture);
+  }
+
+  public dispose(): void {
+    if (!this._handler) {
+      // Already disposed
+      return;
+    }
+
+    this._node.removeEventListener(this._type, this._handler, this._useCapture);
+
+    // Prevent leakers from holding on to the dom or handler func
+    this._node = null!;
+    this._handler = null!;
+  }
+}
+
+export function addDisposableListener<K extends keyof GlobalEventHandlersEventMap>(
+  node: EventTarget,
+  type: K,
+  handler: (event: GlobalEventHandlersEventMap[K]) => void,
+  useCapture?: boolean,
+): IDisposable;
+export function addDisposableListener(
+  node: EventTarget,
+  type: string,
+  handler: (event: any) => void,
+  useCapture?: boolean,
+): IDisposable;
+export function addDisposableListener(
+  node: EventTarget,
+  type: string,
+  handler: (event: any) => void,
+  options: AddEventListenerOptions,
+): IDisposable;
+export function addDisposableListener(
+  node: EventTarget,
+  type: string,
+  handler: (event: any) => void,
+  useCaptureOrOptions?: boolean | AddEventListenerOptions,
+): IDisposable {
+  return new DomListener(node, type, handler, useCaptureOrOptions);
+}
+
+export class FocusTracker extends Disposable {
+  private readonly didFocus = new Emitter<void>();
+  public readonly onDidFocus: BaseEvent<void> = this.didFocus.event;
+
+  private readonly didBlur = new Emitter<void>();
+  public readonly onDidBlur: BaseEvent<void> = this.didBlur.event;
+
+  constructor(element: HTMLElement | Window) {
+    super();
+    let hasFocus = isAncestor(document.activeElement, element as HTMLElement);
+    let loosingFocus = false;
+
+    const onFocus = () => {
+      loosingFocus = false;
+      if (!hasFocus) {
+        hasFocus = true;
+        this.didFocus.fire();
+      }
+    };
+
+    const onBlur = () => {
+      if (hasFocus) {
+        loosingFocus = true;
+        window.setTimeout(() => {
+          if (loosingFocus) {
+            loosingFocus = false;
+            hasFocus = false;
+            this.didBlur.fire();
+          }
+        }, 0);
+      }
+    };
+
+    this.addDispose(this.didBlur);
+    this.addDispose(this.didFocus);
+    this.addDispose(new DomListener(element, EventType.FOCUS, onFocus, true));
+    this.addDispose(new DomListener(element, EventType.BLUR, onBlur, true));
+  }
+}
+
+export function trackFocus(element: HTMLElement | Window): IFocusTracker {
+  return new FocusTracker(element);
+}

package/src/encoding-registry.ts

@@ -0,0 +1,83 @@
+/** ******************************************************************************
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// based on https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/workbench/services/textfile/browser/textFileService.ts#L491
+
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI, Disposable, IDisposable, UTF8, encodingExists } from '@opensumi/ide-core-common';
+
+import { PreferenceService } from './preferences';
+import { getLanguageIdFromMonaco } from './services/label-service';
+
+export interface EncodingOverride {
+  parent?: URI;
+  extension?: string;
+  scheme?: string;
+  encoding: string;
+}
+
+@Injectable()
+export class EncodingRegistry {
+  protected readonly encodingOverrides: EncodingOverride[] = [];
+
+  @Autowired(PreferenceService)
+  protected readonly preferenceService: PreferenceService;
+
+  registerOverride(override: EncodingOverride): IDisposable {
+    this.encodingOverrides.push(override);
+    return Disposable.create(() => {
+      const index = this.encodingOverrides.indexOf(override);
+      if (index !== -1) {
+        this.encodingOverrides.splice(index, 1);
+      }
+    });
+  }
+
+  getEncodingForResource(resource: URI, preferredEncoding?: string): string {
+    let fileEncoding: string;
+
+    const override = this.getEncodingOverride(resource);
+    if (override) {
+      fileEncoding = override; // encoding override always wins
+    } else if (preferredEncoding) {
+      fileEncoding = preferredEncoding; // preferred encoding comes second
+    } else {
+      fileEncoding =
+        this.preferenceService.get<string>(
+          'files.encoding',
+          undefined,
+          resource.toString(),
+          getLanguageIdFromMonaco(resource) || undefined,
+        ) || '';
+    }
+
+    if (!fileEncoding || !encodingExists(fileEncoding)) {
+      return UTF8; // the default is UTF 8
+    }
+
+    return fileEncoding;
+  }
+
+  protected getEncodingOverride(resource: URI): string | undefined {
+    if (this.encodingOverrides && this.encodingOverrides.length) {
+      for (const override of this.encodingOverrides) {
+        if (override.parent && resource.isEqualOrParent(override.parent)) {
+          return override.encoding;
+        }
+
+        if (override.extension && resource.path.ext === `.${override.extension}`) {
+          return override.encoding;
+        }
+
+        if (override.scheme && override.scheme === resource.scheme) {
+          return override.encoding;
+        }
+      }
+    }
+
+    return undefined;
+  }
+}

package/src/extensions/extensions-point.service.ts

@@ -0,0 +1,78 @@
+import lodashAssign from 'lodash/assign';
+import lodashGet from 'lodash/get';
+import lodashHas from 'lodash/has';
+import lodashSet from 'lodash/set';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { FrameworkKind, IExtensionPointDescriptor, IExtensionsSchemaService } from '@opensumi/ide-core-common';
+
+import { IJSONSchemaRegistry } from '../monaco';
+
+import { OpensumiExtensionPackageSchema } from './schema/opensumiExtensionPackageSchema';
+import { VSCodeExtensionPackageSchema } from './schema/vscodeExtensionPackageSchema';
+
+export const EXTENSION_JSON_URI = 'vscode://schemas/vscode-extensions';
+export const OPENSUMI_EXTENSION_JSON_URI = 'vscode://schemas/opensumi-extensions';
+
+@Injectable()
+export class ExtensionsPointServiceImpl implements IExtensionsSchemaService {
+  @Autowired(IJSONSchemaRegistry)
+  private schemaRegistry: IJSONSchemaRegistry;
+
+  private registerSchema(): void {
+    this.schemaRegistry.registerSchema(OPENSUMI_EXTENSION_JSON_URI, OpensumiExtensionPackageSchema, ['package.json']);
+    this.schemaRegistry.registerSchema(EXTENSION_JSON_URI, VSCodeExtensionPackageSchema, ['package.json']);
+  }
+
+  private appendPropertiesFactory(kind: FrameworkKind): (points: string[], desc: IExtensionPointDescriptor) => void {
+    const properties =
+      kind === 'opensumi'
+        ? OpensumiExtensionPackageSchema.properties!.kaitianContributes.properties
+        : VSCodeExtensionPackageSchema.properties!.contributes.properties;
+
+    return (points: string[], desc: IExtensionPointDescriptor) => {
+      const { extensionPoint, jsonSchema } = desc;
+      const assignExtensionPoint = points.concat(extensionPoint).filter(Boolean);
+
+      if (lodashHas(properties, assignExtensionPoint)) {
+        const perProp = lodashGet(properties, assignExtensionPoint.concat('properties'));
+        lodashAssign(jsonSchema.properties, perProp);
+      }
+      lodashSet(properties, assignExtensionPoint, jsonSchema);
+    };
+  }
+
+  private appendOpensumiProperties(points: string[], desc: IExtensionPointDescriptor): void {
+    this.appendPropertiesFactory('opensumi')(points, desc);
+  }
+
+  private appendVScodeProperties(points: string[], desc: IExtensionPointDescriptor): void {
+    this.appendPropertiesFactory('vscode')(points, desc);
+  }
+
+  public appendExtensionPoint(points: string[], desc: IExtensionPointDescriptor): void {
+    if (!desc) {
+      return;
+    }
+
+    const { frameworkKind = ['vscode'] } = desc;
+
+    if (frameworkKind.includes('opensumi')) {
+      this.appendOpensumiProperties(points, desc);
+    }
+
+    if (frameworkKind.includes('vscode')) {
+      this.appendVScodeProperties(points, desc);
+    }
+
+    this.registerSchema();
+  }
+
+  public registerExtensionPoint(desc: IExtensionPointDescriptor): void {
+    if (!desc) {
+      return;
+    }
+
+    this.appendExtensionPoint([], desc);
+  }
+}

package/src/extensions/index.ts

@@ -0,0 +1,3 @@
+export * from './extensions-point.service';
+export * from './schema/vscodeExtensionPackageSchema';
+export * from './schema/opensumiExtensionPackageSchema';

package/src/extensions/schema/browserViews.ts

@@ -0,0 +1,96 @@
+import { localize } from '@opensumi/ide-core-common';
+
+export namespace browserViews {
+  export const properties = {
+    type: 'object',
+    required: ['type', 'view'],
+    defaultSnippets: [
+      {
+        label: 'type',
+        bodyText: JSON.stringify(
+          {
+            type: '${1:add}',
+            view: [
+              {
+                id: '${2}',
+              },
+            ],
+          },
+          null,
+          '\t',
+        ),
+      },
+    ],
+    properties: {
+      type: {
+        type: 'string',
+        enum: ['add', 'replace'],
+      },
+      view: {
+        type: 'array',
+        items: {
+          type: 'object',
+          required: ['id'],
+          defaultSnippets: [
+            {
+              label: '{"id":""}',
+              description: '',
+              bodyText: JSON.stringify(
+                {
+                  id: '${3}',
+                },
+                null,
+                '\t',
+              ),
+            },
+          ],
+          properties: {
+            id: {
+              type: 'string',
+              description: localize('sumiContributes.browserViews.view.id'),
+            },
+            icon: {
+              type: 'string',
+              markdownDescription: localize('sumiContributes.browserViews.view.icon'),
+            },
+            iconPath: {
+              type: 'string',
+              description: localize('sumiContributes.browserViews.view.iconPath'),
+            },
+            title: {
+              type: 'string',
+              description: localize('sumiContributes.browserViews.view.title'),
+            },
+            titleComponentId: {
+              type: 'string',
+              description: localize('sumiContributes.browserViews.view.titleComponentId'),
+            },
+            expanded: {
+              type: 'boolean',
+              description: localize('sumiContributes.browserViews.view.expanded'),
+            },
+          },
+        },
+      },
+    },
+  };
+
+  export const schema = {
+    description: localize('sumiContributes.browserViews'),
+    type: 'object',
+    properties: {
+      left: {
+        ...properties,
+        description: localize('sumiContributes.browserViews.left'),
+      },
+      right: {
+        ...properties,
+        description: localize('sumiContributes.browserViews.right'),
+      },
+      bottom: {
+        ...properties,
+        description: localize('sumiContributes.browserViews.bottom'),
+      },
+    },
+  };
+}

package/src/extensions/schema/menu.ts

@@ -0,0 +1,245 @@
+import { IJSONSchema, localize } from '@opensumi/ide-core-common';
+
+import { MenuId } from '../../menu/next';
+
+interface IAPIMenu {
+  readonly id: MenuId;
+  readonly description: string;
+}
+
+const menuItem: IJSONSchema = {
+  type: 'object',
+  required: ['command'],
+  defaultSnippets: [
+    {
+      body: {
+        command: '${1}',
+      },
+    },
+  ],
+  properties: {
+    command: {
+      description: localize('sumiContributes.common.command'),
+      type: 'string',
+    },
+    when: {
+      description: localize('sumiContributes.common.when'),
+      type: 'string',
+    },
+    group: {
+      description: localize('sumiContributes.common.group'),
+      type: 'string',
+    },
+  },
+};
+
+const submenu: IJSONSchema = {
+  type: 'object',
+  required: ['id', 'title'],
+  properties: {
+    id: {
+      description: localize('sumiContributes.submenus.id'),
+      type: 'string',
+    },
+    title: {
+      description: localize('sumiContributes.submenus.title'),
+      type: 'string',
+    },
+    group: {
+      description: localize('sumiContributes.common.group'),
+      type: 'string',
+    },
+    when: {
+      type: 'string',
+      description: localize('sumiContributes.common.when'),
+    },
+    icon: {
+      description: localize('sumiContributes.submenus.icon'),
+      anyOf: [
+        {
+          type: 'string',
+        },
+        {
+          type: 'object',
+          properties: {
+            light: {
+              description: localize('sumiContributes.submenus.icon.light'),
+              type: 'string',
+            },
+            dark: {
+              description: localize('sumiContributes.submenus.dark'),
+              type: 'string',
+            },
+          },
+        },
+      ],
+    },
+  },
+};
+
+const apiMenus: IAPIMenu[] = [
+  {
+    id: MenuId.CommandPalette,
+    description: localize('sumiContributes.menu.api.CommandPalette'),
+  },
+  {
+    id: MenuId.ActivityBarExtra,
+    description: localize('sumiContributes.menu.api.ActivityBarExtra'),
+  },
+  {
+    id: MenuId.DebugBreakpointsContext,
+    description: localize('sumiContributes.menu.api.DebugBreakpointsContext'),
+  },
+  {
+    id: MenuId.DebugCallStackContext,
+    description: localize('sumiContributes.menu.api.DebugCallStackContext'),
+  },
+  {
+    id: MenuId.DebugConsoleContext,
+    description: localize('sumiContributes.menu.api.DebugConsoleContext'),
+  },
+  {
+    id: MenuId.DebugVariablesContext,
+    description: localize('sumiContributes.menu.api.DebugVariablesContext'),
+  },
+  {
+    id: MenuId.DebugWatchContext,
+    description: localize('sumiContributes.menu.api.DebugWatchContext'),
+  },
+  {
+    id: MenuId.DebugToolBar,
+    description: localize('sumiContributes.menu.api.DebugToolBar'),
+  },
+  {
+    id: MenuId.EditorContext,
+    description: localize('sumiContributes.menu.api.EditorContext'),
+  },
+  {
+    id: MenuId.EditorTitle,
+    description: localize('sumiContributes.menu.api.EditorTitle'),
+  },
+  {
+    id: MenuId.EditorTitleContext,
+    description: localize('sumiContributes.menu.api.EditorTitleContext'),
+  },
+  {
+    id: MenuId.ExplorerContext,
+    description: localize('sumiContributes.menu.api.ExplorerContext'),
+  },
+  {
+    id: MenuId.MenubarAppMenu,
+    description: localize('sumiContributes.menu.api.MenubarAppMenu'),
+  },
+  {
+    id: MenuId.MenubarEditMenu,
+    description: localize('sumiContributes.menu.api.MenubarEditMenu'),
+  },
+  {
+    id: MenuId.MenubarFileMenu,
+    description: localize('sumiContributes.menu.api.MenubarFileMenu'),
+  },
+  {
+    id: MenuId.MenubarGoMenu,
+    description: localize('sumiContributes.menu.api.MenubarGoMenu'),
+  },
+  {
+    id: MenuId.MenubarHelpMenu,
+    description: localize('sumiContributes.menu.api.MenubarHelpMenu'),
+  },
+  {
+    id: MenuId.MenubarViewMenu,
+    description: localize('sumiContributes.menu.api.MenubarViewMenu'),
+  },
+  {
+    id: MenuId.MenubarSelectionMenu,
+    description: localize('sumiContributes.menu.api.MenubarSelectionMenu'),
+  },
+  {
+    id: MenuId.MenubarTerminalMenu,
+    description: localize('sumiContributes.menu.api.MenubarTerminalMenu'),
+  },
+  {
+    id: MenuId.TerminalInstanceContext,
+    description: localize('sumiContributes.menu.api.TerminalInstanceContext'),
+  },
+  {
+    id: MenuId.TerminalNewDropdownContext,
+    description: localize('sumiContributes.menu.api.TerminalNewDropdownContext'),
+  },
+  {
+    id: MenuId.TerminalTabContext,
+    description: localize('sumiContributes.menu.api.TerminalTabContext'),
+  },
+  {
+    id: MenuId.OpenEditorsContext,
+    description: localize('sumiContributes.menu.api.OpenEditorsContext'),
+  },
+  {
+    id: MenuId.SCMResourceContext,
+    description: localize('sumiContributes.menu.api.SCMResourceContext'),
+  },
+  {
+    id: MenuId.SCMResourceGroupContext,
+    description: localize('sumiContributes.menu.api.SCMResourceGroupContext'),
+  },
+  {
+    id: MenuId.SCMResourceFolderContext,
+    description: localize('sumiContributes.menu.api.SCMResourceFolderContext'),
+  },
+  {
+    id: MenuId.SCMTitle,
+    description: localize('sumiContributes.menu.api.SCMTitle'),
+  },
+  {
+    id: MenuId.SCMInput,
+    description: localize('sumiContributes.menu.api.SCMInput'),
+  },
+  {
+    id: MenuId.SearchContext,
+    description: localize('sumiContributes.menu.api.SearchContext'),
+  },
+  {
+    id: MenuId.StatusBarContext,
+    description: localize('sumiContributes.menu.api.StatusBarContext'),
+  },
+  {
+    id: MenuId.ViewItemContext,
+    description: localize('sumiContributes.menu.api.ViewItemContext'),
+  },
+  {
+    id: MenuId.ViewTitle,
+    description: localize('sumiContributes.menu.api.ViewTitle'),
+  },
+  {
+    id: MenuId.SettingsIconMenu,
+    description: localize('sumiContributes.menu.api.SettingsIconMenu'),
+  },
+];
+
+const index = <T, R>(array: ReadonlyArray<T>, indexer: (t: T) => string, mapper?: (t: T) => R): { [key: string]: R } =>
+  array.reduce((r, t) => {
+    r[indexer(t)] = mapper ? mapper(t) : t;
+    return r;
+  }, Object.create(null));
+
+export namespace menus {
+  export const schema: IJSONSchema = {
+    description: localize('sumiContributes.menu'),
+    type: 'object',
+    properties: index(
+      apiMenus,
+      (menu) => menu.id,
+      (menu) => ({
+        type: 'array',
+        description: menu.description,
+        items: menuItem,
+      }),
+    ),
+  };
+
+  export const subMenusSchema: IJSONSchema = {
+    description: localize('sumiContributes.submenus'),
+    type: 'object',
+    additionalProperties: submenu,
+  };
+}

package/src/extensions/schema/opensumiExtensionPackageSchema.ts

@@ -0,0 +1,12 @@
+import { localize } from '@opensumi/ide-core-common';
+
+export const OpensumiExtensionPackageSchema = {
+  properties: {
+    kaitianContributes: {
+      description: localize('sumiContributes.opensumiContributes'),
+      type: 'object',
+      properties: {} as { [key: string]: any },
+      default: {},
+    },
+  },
+};