@opensumi/ide-core-browser 2.21.13 → 2.22.0

package/src/utils/json.ts

@@ -0,0 +1,251 @@
+import stripJsonComments from 'strip-json-comments';
+
+/**
+ * JSON对象的值为引用类型的类型
+ */
+export type JSONPrimitive = boolean | number | string | null;
+
+/**
+ * JSON对象值类型
+ */
+export type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+
+/**
+ * JSON Object值类型
+ */
+export interface JSONObject {
+  [key: string]: JSONValue;
+}
+
+/**
+ * JSON Array值类型
+ */
+export type JSONArray = Array<JSONValue>;
+
+/**
+ * 只读的JSON Object类型
+ */
+export interface ReadonlyJSONObject {
+  readonly [key: string]: ReadonlyJSONValue;
+}
+
+/**
+ * 只读的JSON Array类型
+ */
+export type ReadonlyJSONArray = ReadonlyArray<ReadonlyJSONValue>;
+
+/**
+ * 只读的JSON值类型
+ */
+export type ReadonlyJSONValue = JSONPrimitive | ReadonlyJSONObject | ReadonlyJSONArray;
+
+/**
+ * JSON 工具方法空间
+ */
+export namespace JSONUtils {
+  /**
+   * 冻结的空JSON Object
+   */
+  export const emptyObject = Object.freeze({}) as ReadonlyJSONObject;
+
+  /**
+   * 冻结的空JSON Array
+   */
+  export const emptyArray = Object.freeze([]) as ReadonlyJSONArray;
+
+  /**
+   * 判断JSON是否为普通类型值，如JSONPrimitive
+   * @param value
+   */
+  export function isPrimitive(value: ReadonlyJSONValue): value is JSONPrimitive {
+    return value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string';
+  }
+
+  /**
+   * 判断JSON值是否为Array
+   * @param value
+   */
+  export function isArray(value: JSONValue): value is JSONArray;
+  export function isArray(value: ReadonlyJSONValue): value is ReadonlyJSONArray;
+  export function isArray(value: ReadonlyJSONValue): boolean {
+    return Array.isArray(value);
+  }
+
+  /**
+   * 判断JSON值是否为Object.
+   * @param value
+   */
+  export function isObject(value: JSONValue): value is JSONObject;
+  export function isObject(value: ReadonlyJSONValue): value is ReadonlyJSONObject;
+  export function isObject(value: ReadonlyJSONValue): boolean {
+    return !isPrimitive(value) && !isArray(value);
+  }
+
+  /**
+   * 判断两个值是否深层相等
+   * @param first
+   * @param second
+   */
+  export function deepEqual(first: ReadonlyJSONValue, second: ReadonlyJSONValue): boolean {
+    if (first === second) {
+      return true;
+    }
+
+    if (isPrimitive(first) || isPrimitive(second)) {
+      return false;
+    }
+
+    const a1 = isArray(first);
+    const a2 = isArray(second);
+
+    if (a1 !== a2) {
+      return false;
+    }
+
+    if (a1 && a2) {
+      return deepArrayEqual(first as ReadonlyJSONArray, second as ReadonlyJSONArray);
+    }
+
+    return deepObjectEqual(first as ReadonlyJSONObject, second as ReadonlyJSONObject);
+  }
+
+  /**
+   * 深拷贝JSON值
+   * @param value
+   */
+  export function deepCopy<T extends ReadonlyJSONValue>(value: T): T {
+    if (isPrimitive(value)) {
+      return value;
+    }
+
+    if (isArray(value)) {
+      return deepArrayCopy(value);
+    }
+
+    return deepObjectCopy(value);
+  }
+
+  /**
+   * 对比两个数组类型的JSON是否深匹配
+   */
+  function deepArrayEqual(first: ReadonlyJSONArray, second: ReadonlyJSONArray): boolean {
+    if (first === second) {
+      return true;
+    }
+
+    if (first.length !== second.length) {
+      return false;
+    }
+
+    // Compare the values for equality.
+    for (let i = 0, n = first.length; i < n; ++i) {
+      if (!deepEqual(first[i], second[i])) {
+        return false;
+      }
+    }
+
+    // At this point, the arrays are equal.
+    return true;
+  }
+
+  /**
+   * 对比两个对象类型的JSON是否深匹配
+   */
+  function deepObjectEqual(first: ReadonlyJSONObject, second: ReadonlyJSONObject): boolean {
+    if (first === second) {
+      return true;
+    }
+
+    for (const key in first) {
+      if (!(key in second)) {
+        return false;
+      }
+    }
+
+    // Check for the second object's keys in the first object.
+    for (const key in second) {
+      if (!(key in first)) {
+        return false;
+      }
+    }
+
+    // Compare the values for equality.
+    for (const key in first) {
+      if (!deepEqual(first[key], second[key])) {
+        return false;
+      }
+    }
+
+    // At this point, the objects are equal.
+    return true;
+  }
+
+  /**
+   * 深拷贝Array类型的值
+   */
+  function deepArrayCopy(value: any): any {
+    const result = new Array<any>(value.length);
+    for (let i = 0, n = value.length; i < n; ++i) {
+      result[i] = deepCopy(value[i]);
+    }
+    return result;
+  }
+
+  /**
+   * 深拷贝Object类型的值
+   */
+  function deepObjectCopy(value: any): any {
+    const result: any = {};
+    // eslint-disable-next-line guard-for-in
+    for (const key in value) {
+      result[key] = deepCopy(value[key]);
+    }
+    return result;
+  }
+}
+
+export function parseWithComments<T>(content): T {
+  content = stripTrailingComma(stripJsonComments(content));
+  const res = JSON.parse(content);
+  return res;
+}
+
+export function stripTrailingComma(content: string) {
+  const subStrs: string[] = [];
+  let lastIndex = 0;
+  let inString = false;
+  let i = 0;
+  while (i < content.length) {
+    if (inString) {
+      if (content[i] === '"' && content[i - 1] !== '\\') {
+        inString = false;
+      }
+    } else {
+      if (content[i] === ',') {
+        // 跳过空白
+        const candidate = i;
+        while (content[i + 1] && isWhiteSpace(content[i + 1])) {
+          i++;
+        }
+        if (content[i + 1] === ']' || content[i + 1] === '}') {
+          subStrs.push(content.substring(lastIndex, candidate));
+          lastIndex = candidate + 1;
+        }
+      } else if (content[i] === '"') {
+        // 肯定是开始字符串
+        inString = true;
+      }
+    }
+    i++;
+  }
+  if (lastIndex > 0) {
+    subStrs.push(content.substr(lastIndex));
+    return subStrs.join('');
+  } else {
+    return content;
+  }
+}
+
+function isWhiteSpace(char) {
+  return char === ' ' || char === '\t' || char === '\n' || char === '\r';
+}

package/src/utils/label.tsx

@@ -0,0 +1,36 @@
+import React, { CSSProperties } from 'react';
+
+import { Icon } from '@opensumi/ide-components/lib/icon/icon';
+
+const SEPERATOR = ' ';
+
+export function transformLabelWithCodicon(
+  label: string,
+  iconStyles: CSSProperties = {},
+  transformer?: (str: string) => string | undefined,
+) {
+  const ICON_REGX = /\$\(([a-z.]+\/)?([a-z-]+)(~[a-z]+)?\)/gi;
+  const ICON_WITH_ANIMATE_REGX = /\$\(([a-z.]+\/)?([a-z-]+)~([a-z]+)\)/gi;
+  return label.split(SEPERATOR).map((e, index) => {
+    if (!transformer) {
+      return e;
+    }
+    const icon = transformer(e);
+    if (icon) {
+      return <Icon className={icon} style={iconStyles} key={`${index}-${icon}`} />;
+    } else if (ICON_REGX.test(e)) {
+      if (e.includes('~')) {
+        const [, , icon, animate] = ICON_WITH_ANIMATE_REGX.exec(e) || [];
+        if (animate && icon) {
+          return (
+            <Icon className={transformer(`$(${icon})`)} style={iconStyles} animate={animate} key={`${index}-${icon}`} />
+          );
+        }
+      }
+      const newStr = e.replaceAll(ICON_REGX, (e) => `${SEPERATOR}${e}${SEPERATOR}`);
+      return transformLabelWithCodicon(newStr, iconStyles, transformer);
+    } else {
+      return <span key={`${index}-${e}`}>{e}</span>;
+    }
+  });
+}

package/src/utils/parse.ts

@@ -0,0 +1,82 @@
+/** ******************************************************************************
+ * Copyright (C) 2018 Red Hat, Inc. and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+// Some code copied and modified from https://github.com/eclipse-theia/theia/tree/v1.14.0/packages/core/src/browser/label-parser.ts
+
+export interface LabelIcon {
+  name: string;
+  owner?: string;
+  animation?: string;
+}
+
+export namespace LabelIcon {
+  export function is(val: object): val is LabelIcon {
+    return 'name' in val;
+  }
+}
+
+export type LabelPart = string | LabelIcon;
+
+export function parseLabel(text: string): LabelPart[] {
+  const parserArray: LabelPart[] = [];
+  let arrPointer = 0;
+  let potentialIcon = '';
+
+  for (let idx = 0; idx < text.length; idx++) {
+    const char = text.charAt(idx);
+    parserArray[arrPointer] = parserArray[arrPointer] || '';
+    if (potentialIcon === '') {
+      if (char === '$') {
+        potentialIcon += char;
+      } else {
+        parserArray[arrPointer] += char;
+      }
+    } else if (potentialIcon === '$') {
+      if (char === '(') {
+        potentialIcon += char;
+      } else {
+        parserArray[arrPointer] += potentialIcon + char;
+        potentialIcon = '';
+      }
+    } else {
+      if (char === ')') {
+        const iconClassArr = potentialIcon.substring(2, potentialIcon.length).split('~');
+        let name = iconClassArr[0];
+        let owner: string | undefined;
+        if (name) {
+          const index = name.indexOf('/');
+          if (index !== -1) {
+            owner = name.substring(0, index);
+            name = name.substring(index + 1);
+          }
+        }
+        if (parserArray[arrPointer] !== '') {
+          arrPointer++;
+        }
+        parserArray[arrPointer] = { name, owner, animation: iconClassArr[1] };
+        arrPointer++;
+        potentialIcon = '';
+      } else {
+        potentialIcon += char;
+      }
+    }
+  }
+
+  if (potentialIcon !== '') {
+    parserArray[arrPointer] += potentialIcon;
+  }
+
+  return parserArray;
+}

package/src/utils/react-hooks.ts

@@ -0,0 +1,118 @@
+import _debounce from 'lodash/debounce';
+import { useState, useEffect, DependencyList } from 'react';
+
+import { Disposable, DisposableStore, IDisposable } from '@opensumi/ide-core-common';
+
+import { MenuNode } from '../menu/next/base';
+import { generateInlineActions } from '../menu/next/menu-util';
+import { IMenu, IMenuSeparator, IContextMenu } from '../menu/next/menu.interface';
+import { PreferenceService } from '../preferences/types';
+import { useInjectable } from '../react-hooks/injectable-hooks';
+
+export function useDebounce(value, delay) {
+  const [denouncedValue, setDenouncedValue] = useState(value);
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDenouncedValue(value);
+    }, delay);
+
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+
+  return denouncedValue;
+}
+
+export function useDisposable(callback: () => IDisposable | IDisposable[], deps: DependencyList = []) {
+  useEffect(() => {
+    const disposableStore = new DisposableStore();
+    const disposables = callback();
+    if (Array.isArray(disposables)) {
+      disposables.forEach((disposable) => {
+        disposableStore.add(disposable);
+      });
+    } else {
+      disposableStore.add(disposables);
+    }
+
+    return () => {
+      disposableStore.dispose();
+    };
+  }, deps);
+}
+
+export function useMenus(
+  menus: IMenu,
+  separator?: IMenuSeparator,
+  args?: any[],
+  // 防止 menu 快速变化
+  debounce?: { delay: number; maxWait?: number },
+) {
+  const [menuConfig, setMenuConfig] = useState<[MenuNode[], MenuNode[]]>([[], []]);
+
+  useDisposable(() => {
+    let updateMenuConfig = () => {
+      const result = generateInlineActions({
+        menus,
+        separator,
+        args,
+      });
+
+      setMenuConfig(result);
+    };
+
+    if (debounce) {
+      updateMenuConfig = _debounce(updateMenuConfig, debounce.delay, { maxWait: debounce.maxWait });
+    }
+
+    // initialize
+    updateMenuConfig();
+
+    return [
+      menus.onDidChange(() => {
+        updateMenuConfig();
+      }),
+    ];
+  }, [menus, args]);
+
+  return menuConfig;
+}
+
+export function useContextMenus(menus: IContextMenu) {
+  const [menuConfig, setMenuConfig] = useState<[MenuNode[], MenuNode[]]>([[], []]);
+  useDisposable(() => {
+    updateMenuConfig(menus);
+
+    function updateMenuConfig(menuArg: IContextMenu) {
+      const result = menuArg.getGroupedMenuNodes();
+      setMenuConfig(result);
+    }
+
+    return [
+      menus.onDidChange(() => {
+        updateMenuConfig(menus);
+      }),
+    ];
+  }, [menus]);
+
+  return menuConfig;
+}
+
+export function usePreference<T>(key: string, defaultValue: T) {
+  const preferenceService: PreferenceService = useInjectable(PreferenceService);
+  const [value, setValue] = useState<T>(preferenceService.get<T>(key, defaultValue) ?? defaultValue);
+
+  useEffect(() => {
+    const disposer = new Disposable(
+      preferenceService.onSpecificPreferenceChange(key, (change) => {
+        setValue(change.newValue);
+      }),
+    );
+    return () => {
+      disposer.dispose();
+    };
+  }, []);
+  return value;
+}

package/src/variable/index.ts

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

package/src/variable/variable.ts

@@ -0,0 +1,84 @@
+import { Injectable } from '@opensumi/di';
+import { URI, IDisposable, Disposable, DisposableCollection, MaybePromise } from '@opensumi/ide-core-common';
+
+export type TVariableResolve = string | undefined | { [x: string]: string | undefined };
+export interface Variable {
+  /**
+   * 变量名，也作为唯一标识使用
+   */
+  readonly name: string;
+
+  /**
+   * 描述信息
+   */
+  readonly description?: string;
+
+  /**
+   * 处理返回值
+   */
+  resolve(context?: URI): MaybePromise<TVariableResolve>;
+}
+
+export const VariableContribution = Symbol('VariableContribution');
+
+export interface VariableContribution {
+  registerVariables(variables: VariableRegistry): void;
+}
+
+export const VariableRegistry = Symbol('VariableRegistry');
+
+export interface VariableRegistry {
+  registerVariable(variable: Variable): IDisposable;
+  getVariables(): Variable[];
+  getVariable(name: string): Variable | undefined;
+  registerVariables(variables: Variable[]): IDisposable[];
+}
+
+@Injectable()
+export class VariableRegistryImpl implements IDisposable {
+  protected readonly variables: Map<string, Variable> = new Map();
+  protected readonly toDispose = new DisposableCollection();
+
+  dispose(): void {
+    this.toDispose.dispose();
+  }
+
+  /**
+   * 为给定的变量名注册处理函数
+   * 忽略已处理的变量
+   */
+  registerVariable(variable: Variable): IDisposable {
+    if (this.variables.has(variable.name)) {
+      // eslint-disable-next-line no-console
+      console.warn(`A variables with name ${variable.name} is already registered.`);
+      return Disposable.NULL;
+    }
+    this.variables.set(variable.name, variable);
+    const disposable = {
+      dispose: () => this.variables.delete(variable.name),
+    };
+    this.toDispose.push(disposable);
+    return disposable;
+  }
+
+  /**
+   * 返回所有已注册的变量
+   */
+  getVariables(): Variable[] {
+    return [...this.variables.values()];
+  }
+
+  /**
+   * 通过名称获取变量
+   */
+  getVariable(name: string): Variable | undefined {
+    return this.variables.get(name);
+  }
+
+  /**
+   * 注册多个变量
+   */
+  registerVariables(variables: Variable[]): IDisposable[] {
+    return variables.map((v) => this.registerVariable(v));
+  }
+}

package/src/window/index.ts

@@ -0,0 +1,34 @@
+import { URI } from '@opensumi/ide-core-common';
+
+export const IWindowService = Symbol('WindowService');
+
+export interface NewWindowOptions {
+  readonly external?: boolean;
+}
+
+export interface IOpenWorkspaceOption {
+  newWindow?: boolean;
+}
+
+export interface IWindowService {
+  /**
+   * 打开新的window窗口
+   * @param {string} url
+   * @param {NewWindowOptions} [options]
+   * @returns {(Window | undefined)}
+   * @memberof WindowService
+   */
+  openNewWindow(url: string, options?: NewWindowOptions): Window | undefined;
+
+  openWorkspace(workspace?: URI, options?: IOpenWorkspaceOption): void;
+
+  close(): void;
+
+  maximize(): void;
+
+  unmaximize(): void;
+
+  fullscreen(): void;
+
+  minimize(): void;
+}

package/src/window/window.service.ts

@@ -0,0 +1,100 @@
+import { Injectable, Autowired, INJECTOR_TOKEN, Injector } from '@opensumi/di';
+import { URI } from '@opensumi/ide-core-common';
+import { IElectronMainLifeCycleService, IElectronMainUIService } from '@opensumi/ide-core-common/lib/electron';
+
+import { AppConfig } from '../react-providers/config-provider';
+import { IExternalUriService } from '../services';
+import { electronEnv } from '../utils/electron';
+
+import { IWindowService, IOpenWorkspaceOption, NewWindowOptions } from '.';
+
+@Injectable()
+export class WindowService implements IWindowService {
+  @Autowired(INJECTOR_TOKEN)
+  private readonly injector: Injector;
+
+  @Autowired(AppConfig)
+  private readonly appConfig: AppConfig;
+
+  openNewWindow(url: string, options?: NewWindowOptions): Window | undefined {
+    if (this.appConfig.isElectronRenderer) {
+      // Electron 环境下使用 shell.openExternal 方法打开外部 Uri
+      const electronMainUIService: IElectronMainUIService = this.injector.get(IElectronMainUIService);
+      // TODO: 由于 electron 下没有打开外部的警告（静默打开），此处直接 openExternal 可能会存在一定的安全隐患
+      // 需要给用户添加一点提示。 或者这个也可以统一做到 OpenerService 里面。
+      electronMainUIService.openExternal(url);
+      return undefined;
+    } else {
+      if (options?.external) {
+        const externalUriService = this.injector.get(IExternalUriService);
+        url = externalUriService.resolveExternalUri(new URI(url)).toString(true);
+      }
+      const newWindow = window.open(url);
+      if (newWindow === null) {
+        throw new Error('Cannot open a new window for URL: ' + url);
+      }
+      return newWindow;
+    }
+  }
+
+  openWorkspace(workspace: URI, options: IOpenWorkspaceOption = {}): void {
+    if (this.appConfig.isElectronRenderer) {
+      const electronMainLifecycle: IElectronMainLifeCycleService = this.injector.get(IElectronMainLifeCycleService);
+      if (options.newWindow) {
+        electronMainLifecycle.openWorkspace(workspace.toString());
+      } else {
+        electronMainLifecycle.openWorkspace(workspace.toString(), {
+          windowId: electronEnv.currentWindowId,
+          replace: true,
+        });
+      }
+    } else {
+      throw new Error('Method not implemented.');
+    }
+  }
+
+  close(): void {
+    if (this.appConfig.isElectronRenderer) {
+      // 防止 node 进程被先关闭掉，导致再也无法关闭
+      window.close();
+    } else {
+      throw new Error('Method not implemented.');
+    }
+  }
+
+  maximize(): void {
+    if (this.appConfig.isElectronRenderer) {
+      const electronMainLifecycle: IElectronMainLifeCycleService = this.injector.get(IElectronMainLifeCycleService);
+      electronMainLifecycle.maximizeWindow(electronEnv.currentWindowId);
+    } else {
+      throw new Error('Method not implemented.');
+    }
+  }
+
+  unmaximize(): void {
+    if (this.appConfig.isElectronRenderer) {
+      const electronMainLifecycle: IElectronMainLifeCycleService = this.injector.get(IElectronMainLifeCycleService);
+      electronMainLifecycle.unmaximizeWindow(electronEnv.currentWindowId);
+    } else {
+      throw new Error('Method not implemented.');
+    }
+  }
+
+  fullscreen(): void {
+    if (this.appConfig.isElectronRenderer) {
+      const electronMainLifecycle: IElectronMainLifeCycleService = this.injector.get(IElectronMainLifeCycleService);
+      electronMainLifecycle.fullscreenWindow(electronEnv.currentWindowId);
+    } else {
+      throw new Error('Method not implemented.');
+    }
+  }
+
+  minimize(): void {
+    if (this.appConfig.isElectronRenderer) {
+      const electronMainLifecycle: IElectronMainLifeCycleService = this.injector.get(IElectronMainLifeCycleService);
+      electronMainLifecycle.minimizeWindow(electronEnv.currentWindowId);
+    } else {
+      throw new Error('Method not implemented.');
+    }
+  }
+}