@opensumi/ide-core-common 2.21.13 → 2.22.0

package/src/json-schema.ts

@@ -0,0 +1,80 @@
+export interface IJSONSchema {
+  id?: string;
+  $id?: string;
+  $schema?: string;
+  type?: string | string[];
+  title?: string;
+  default?: any;
+  definitions?: IJSONSchemaMap;
+  description?: string;
+  properties?: IJSONSchemaMap;
+  patternProperties?: IJSONSchemaMap;
+  additionalProperties?: boolean | IJSONSchema;
+  minProperties?: number;
+  maxProperties?: number;
+  dependencies?: IJSONSchemaMap | { [prop: string]: string[] };
+  items?: IJSONSchema | IJSONSchema[];
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  additionalItems?: boolean | IJSONSchema;
+  pattern?: string;
+  minLength?: number;
+  maxLength?: number;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: boolean | number;
+  exclusiveMaximum?: boolean | number;
+  multipleOf?: number;
+  required?: string[];
+  $ref?: string;
+  anyOf?: IJSONSchema[];
+  allOf?: IJSONSchema[];
+  oneOf?: IJSONSchema[];
+  not?: IJSONSchema;
+  enum?: any[];
+  format?: string;
+
+  // schema draft 06
+  const?: any;
+  contains?: IJSONSchema;
+  propertyNames?: IJSONSchema;
+
+  // schema draft 07
+  $comment?: string;
+  if?: IJSONSchema;
+  then?: IJSONSchema;
+  else?: IJSONSchema;
+
+  // VSCode extensions
+  defaultSnippets?: IJSONSchemaSnippet[]; // VSCode extension
+  errorMessage?: string; // VSCode extension
+  patternErrorMessage?: string; // VSCode extension
+  deprecationMessage?: string; // VSCode extension
+  enumDescriptions?: string[]; // VSCode extension
+  markdownEnumDescriptions?: string[]; // VSCode extension
+  markdownDescription?: string; // VSCode extension
+  doNotSuggest?: boolean; // VSCode extension
+  allowComments?: boolean; // VSCode extension
+}
+
+export interface IJSONSchemaMap {
+  [name: string]: IJSONSchema;
+}
+
+export interface IJSONSchemaSnippet {
+  label?: string;
+  description?: string;
+  body?: any; // a object that will be JSON stringified
+  bodyText?: string; // an already stringified JSON object that can contain new lines (\n) and tabs (\t)
+}
+
+export const enum CodeSchemaId {
+  defaultSettings = 'vscode://schemas/settings/default',
+  userSettings = 'vscode://schemas/settings/user',
+  machineSettings = 'vscode://schemas/settings/machine',
+  workspaceSettings = 'vscode://schemas/settings/workspace',
+  folderSettings = 'vscode://schemas/settings/folder',
+  launch = 'vscode://schemas/launch',
+  tasks = 'vscode://schemas/tasks',
+}

package/src/keyboard/index.ts

@@ -0,0 +1,2 @@
+export * from './keymap';
+export * from './keyboard-layout-provider';

package/src/keyboard/keyboard-layout-provider.ts

@@ -0,0 +1,46 @@
+/** ******************************************************************************
+ * 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/keyboard/browser-keyboard-layout-provider.ts
+
+import { Event } from '@opensumi/ide-utils';
+
+import { KeymapInfo } from './keymap';
+
+export const keyboardPath = '/services/keyboard';
+
+export const KeyboardNativeLayoutService = Symbol('KeyboardNativeLayoutService');
+
+export interface KeyboardNativeLayoutService {
+  getNativeLayout(): Promise<KeymapInfo | void>;
+  allLayoutData: KeymapInfo[];
+  currentLayoutData: KeymapInfo | null;
+  currentLayoutSource: string;
+  setLayoutData(layout: KeymapInfo | 'autodetect'): Promise<KeymapInfo | null>;
+}
+
+export const KeyboardLayoutChangeNotifierService = Symbol('KeyboardLayoutChangeNotifierService');
+
+export interface KeyboardLayoutChangeNotifierService {
+  onDidChangeNativeLayout: Event<KeymapInfo>;
+}
+
+export interface KeyValidationInput {
+  code: string;
+  character: string;
+  shiftKey?: boolean;
+  ctrlKey?: boolean;
+  altKey?: boolean;
+}

package/src/keyboard/keymap.ts

@@ -0,0 +1,224 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { isLinux, isWindows } from '@opensumi/ide-utils';
+
+// https://github.com/microsoft/node-native-keymap/blob/master/index.d.ts
+
+export interface IWindowsKeyboardMapping {
+  [code: string]: IWindowsKeyMapping;
+}
+
+export interface IWindowsKeyMapping {
+  vkey: string;
+  value: string;
+  withShift: string;
+  withAltGr: string;
+  withShiftAltGr: string;
+}
+
+export interface IWindowsKeyboardLayoutInfo {
+  name: string;
+  id: string;
+  text: string;
+}
+
+export interface ILinuxKeyboardLayoutInfo {
+  model: string;
+  layout: string;
+  variant: string;
+  options: string;
+  rules: string;
+}
+
+export interface IMacKeyboardLayoutInfo {
+  id: string;
+  localizedName?: string;
+  lang: string;
+}
+
+export interface IWindowsKeyboardLayoutInfo {
+  name: string;
+  id: string;
+  text: string;
+}
+
+export type IKeyboardLayoutInfo = (IWindowsKeyboardLayoutInfo | ILinuxKeyboardLayoutInfo | IMacKeyboardLayoutInfo) & {
+  isUserKeyboardLayout?: boolean;
+  isUSStandard?: true;
+};
+
+export interface ISerializedMapping {
+  [key: string]: (string | number)[];
+}
+
+export interface IKeymapInfo {
+  layout: IKeyboardLayoutInfo;
+  secondaryLayouts: IKeyboardLayoutInfo[];
+  mapping: ISerializedMapping;
+  isUserKeyboardLayout?: boolean;
+}
+
+export interface IRawMixedKeyboardMapping {
+  [key: string]: {
+    value: string;
+    withShift: string;
+    withAltGr: string;
+    withShiftAltGr: string;
+    valueIsDeadKey?: boolean;
+    withShiftIsDeadKey?: boolean;
+    withAltGrIsDeadKey?: boolean;
+    withShiftAltGrIsDeadKey?: boolean;
+  };
+}
+
+function deserializeMapping(serializedMapping: ISerializedMapping) {
+  const mapping = serializedMapping;
+
+  const ret: { [key: string]: any } = {};
+  // eslint-disable-next-line guard-for-in
+  for (const key in mapping) {
+    const result: (string | number)[] = mapping[key];
+    if (result.length) {
+      const value = result[0];
+      const withShift = result[1];
+      const withAltGr = result[2];
+      const withShiftAltGr = result[3];
+      const mask = Number(result[4]);
+      const vkey = result.length === 6 ? result[5] : undefined;
+      ret[key] = {
+        value,
+        vkey,
+        withShift,
+        withAltGr,
+        withShiftAltGr,
+        valueIsDeadKey: (mask & 1) > 0,
+        withShiftIsDeadKey: (mask & 2) > 0,
+        withAltGrIsDeadKey: (mask & 4) > 0,
+        withShiftAltGrIsDeadKey: (mask & 8) > 0,
+      };
+    } else {
+      ret[key] = {
+        value: '',
+        valueIsDeadKey: false,
+        withShift: '',
+        withShiftIsDeadKey: false,
+        withAltGr: '',
+        withAltGrIsDeadKey: false,
+        withShiftAltGr: '',
+        withShiftAltGrIsDeadKey: false,
+      };
+    }
+  }
+
+  return ret;
+}
+
+export function getKeyboardLayoutId(layout: IKeyboardLayoutInfo): string {
+  if ((layout as IWindowsKeyboardLayoutInfo).name) {
+    return (layout as IWindowsKeyboardLayoutInfo).name;
+  }
+
+  if ((layout as IMacKeyboardLayoutInfo).id) {
+    return (layout as IMacKeyboardLayoutInfo).id;
+  }
+  return (layout as ILinuxKeyboardLayoutInfo).layout;
+}
+
+export class KeymapInfo {
+  mapping: IRawMixedKeyboardMapping;
+  isUserKeyboardLayout: boolean;
+
+  constructor(
+    public layout: IKeyboardLayoutInfo,
+    public secondaryLayouts: IKeyboardLayoutInfo[],
+    keyboardMapping: ISerializedMapping,
+    isUserKeyboardLayout?: boolean,
+  ) {
+    this.mapping = deserializeMapping(keyboardMapping);
+    this.isUserKeyboardLayout = !!isUserKeyboardLayout;
+    this.layout.isUserKeyboardLayout = !!isUserKeyboardLayout;
+  }
+
+  static createKeyboardLayoutFromDebugInfo(
+    layout: IKeyboardLayoutInfo,
+    value: IRawMixedKeyboardMapping,
+    isUserKeyboardLayout?: boolean,
+  ): KeymapInfo {
+    const keyboardLayoutInfo = new KeymapInfo(layout, [], {}, true);
+    keyboardLayoutInfo.mapping = value;
+    return keyboardLayoutInfo;
+  }
+
+  update(other: KeymapInfo) {
+    this.layout = other.layout;
+    this.secondaryLayouts = other.secondaryLayouts;
+    this.mapping = other.mapping;
+    this.isUserKeyboardLayout = other.isUserKeyboardLayout;
+    this.layout.isUserKeyboardLayout = other.isUserKeyboardLayout;
+  }
+
+  getScore(other: IRawMixedKeyboardMapping): number {
+    let score = 0;
+    for (const key in other) {
+      if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
+        // keymap from Chromium is probably wrong.
+        continue;
+      }
+
+      if (isLinux && (key === 'Backspace' || key === 'Escape')) {
+        // native keymap doesn't align with keyboard event
+        continue;
+      }
+
+      const currentMapping = this.mapping[key];
+
+      if (currentMapping === undefined) {
+        score -= 1;
+      }
+
+      const otherMapping = other[key];
+
+      if (currentMapping && otherMapping && currentMapping.value !== otherMapping.value) {
+        score -= 1;
+      }
+    }
+
+    return score;
+  }
+
+  equal(other: KeymapInfo): boolean {
+    if (this.isUserKeyboardLayout !== other.isUserKeyboardLayout) {
+      return false;
+    }
+
+    if (getKeyboardLayoutId(this.layout) !== getKeyboardLayoutId(other.layout)) {
+      return false;
+    }
+
+    return this.fuzzyEqual(other.mapping);
+  }
+
+  fuzzyEqual(other: IRawMixedKeyboardMapping): boolean {
+    for (const key in other) {
+      if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
+        // keymap from Chromium is probably wrong.
+        continue;
+      }
+      if (this.mapping[key] === undefined) {
+        return false;
+      }
+
+      const currentMapping = this.mapping[key];
+      const otherMapping = other[key];
+
+      if (currentMapping.value !== otherMapping.value) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}

package/src/line-text.ts

@@ -0,0 +1,93 @@
+/**
+ * 用于实现效率更高的编辑操作
+ */
+
+import { IRange, IPosition, IEditOperation } from './types/editor';
+
+export class BasicTextLines {
+  constructor(protected readonly _lines: string[], protected _eol: '\n' | '\r\n') {}
+
+  getContent() {
+    return this._lines.join(this._eol);
+  }
+
+  private _setLineText(lineIndex: number, newValue: string): void {
+    this._lines[lineIndex] = newValue;
+  }
+
+  public acceptEol(eol: '\n' | '\r\n') {
+    this._eol = eol;
+  }
+
+  public acceptChange(change: IEditOperation) {
+    this._acceptDeleteRange(change.range);
+    this._acceptInsertText(
+      { lineNumber: change.range.startLineNumber, column: change.range.startColumn },
+      change.text || '',
+    );
+  }
+
+  private _getLineContent(index: number): string {
+    return this._lines[index] || '';
+  }
+
+  private _acceptDeleteRange(range: IRange): void {
+    if (range.startLineNumber === range.endLineNumber) {
+      if (range.startColumn === range.endColumn) {
+        // Nothing to delete
+        return;
+      }
+      // Delete text on the affected line
+      this._setLineText(
+        range.startLineNumber - 1,
+        this._getLineContent(range.startLineNumber - 1).substring(0, range.startColumn - 1) +
+          this._getLineContent(range.startLineNumber - 1).substring(range.endColumn - 1),
+      );
+      return;
+    }
+
+    // Take remaining text on last line and append it to remaining text on first line
+    this._setLineText(
+      range.startLineNumber - 1,
+      this._getLineContent(range.startLineNumber - 1).substring(0, range.startColumn - 1) +
+        this._getLineContent(range.endLineNumber - 1).substring(range.endColumn - 1),
+    );
+
+    // Delete middle lines
+    this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);
+  }
+
+  private _acceptInsertText(position: IPosition, insertText: string): void {
+    if (insertText.length === 0) {
+      // Nothing to insert
+      return;
+    }
+    const insertLines = insertText.split(/\r\n|\r|\n/);
+    if (insertLines.length === 1) {
+      // Inserting text on one line
+      this._setLineText(
+        position.lineNumber - 1,
+        this._getLineContent(position.lineNumber - 1).substring(0, position.column - 1) +
+          insertLines[0] +
+          this._getLineContent(position.lineNumber - 1).substring(position.column - 1),
+      );
+      return;
+    }
+
+    // Append overflowing text from first line to the end of text to insert
+    insertLines[insertLines.length - 1] += this._getLineContent(position.lineNumber - 1).substring(position.column - 1);
+
+    // Delete overflowing text from first line and insert text on first line
+    this._setLineText(
+      position.lineNumber - 1,
+      this._getLineContent(position.lineNumber - 1).substring(0, position.column - 1) + insertLines[0],
+    );
+
+    // Insert new lines & store lengths
+    const newLengths = new Uint32Array(insertLines.length - 1);
+    for (let i = 1; i < insertLines.length; i++) {
+      this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);
+      newLengths[i - 1] = insertLines[i].length + this._eol.length;
+    }
+  }
+}

package/src/localize.ts

@@ -0,0 +1,203 @@
+import { strings, CaseInsensitiveMap } from '@opensumi/ide-utils';
+
+const { format, mnemonicButtonLabel } = strings;
+
+export type ILocalizationKey = string; // ts不支持symbol作为key
+
+let _currentLanguageId = 'zh-CN';
+
+const localizationRegistryMap = new CaseInsensitiveMap<string, LocalizationRegistry>();
+
+export function localize(
+  symbol: ILocalizationKey,
+  defaultMessage?: string | undefined,
+  scope = 'host',
+  language = _currentLanguageId,
+): string {
+  const localizationRegistry = getLocalizationRegistry(scope);
+  return localizationRegistry.getLocalizeString(symbol, defaultMessage, language);
+}
+
+export function formatLocalize(symbol: ILocalizationKey, ...args: any) {
+  return format(localize(symbol), ...args);
+}
+
+export function registerLocalizationBundle(bundle: ILocalizationBundle, scope = 'host') {
+  return getLocalizationRegistry(scope).registerLocalizationBundle(bundle);
+}
+
+interface IExtensionLocalizationValue {
+  message: string;
+  comment: string;
+}
+
+export interface IExtensionLocalizationContents {
+  [key: string]: string | IExtensionLocalizationValue;
+}
+
+export interface ILocalizationBundle extends ILocalizationInfo {
+  contents: IExtensionLocalizationContents;
+}
+
+export interface ILocalizationInfo {
+  languageId: string;
+  languageName: string;
+  localizedLanguageName: string;
+}
+
+export interface ILocalizationContents {
+  [key: string]: string;
+}
+
+interface ILocalizationRegistry {
+  registerLocalizationBundle(bundle: ILocalizationBundle): void;
+
+  getLocalizeString(symbol: ILocalizationKey, defaultLabel?: string, languageId?: string): string;
+
+  getAllLanguages(): ILocalizationInfo[];
+}
+
+function isExtensionLocalizationValue(thing: any): thing is IExtensionLocalizationValue {
+  return typeof thing === 'object' && thing.message;
+}
+
+class LocalizationRegistry implements ILocalizationRegistry {
+  private localizationMap = new CaseInsensitiveMap<string, ILocalizationContents>();
+
+  public readonly localizationInfo = new CaseInsensitiveMap<string, ILocalizationInfo>();
+
+  registerLocalizationBundle(bundle: ILocalizationBundle): void {
+    const languageId = bundle.languageId;
+    if (!languageId) {
+      return;
+    }
+    const existingMessages = this.getContents(languageId);
+    Object.keys(bundle.contents).forEach((key: ILocalizationKey) => {
+      const rawContent = bundle.contents[key];
+      let content: string;
+      if (isExtensionLocalizationValue(rawContent)) {
+        content = rawContent.message;
+      } else {
+        content = rawContent;
+      }
+      existingMessages[key] = mnemonicButtonLabel(content, true); // 暂时去除所有注记符
+    });
+    if (!this.localizationInfo.has(languageId)) {
+      this.localizationInfo.set(languageId, Object.assign({}, bundle, { contents: undefined }));
+    }
+  }
+
+  getLocalizeString(key: ILocalizationKey, defaultValue?: string | null, languageId = _currentLanguageId): string {
+    return this.getContents(languageId)[key] || this.getContents('default')[key] || defaultValue || '';
+  }
+
+  private getContents(languageId: string | undefined = 'zh-CN'): ILocalizationContents {
+    if (!languageId) {
+      return {};
+    }
+    if (!this.localizationMap.has(languageId)) {
+      this.localizationMap.set(languageId, {});
+    }
+    return this.localizationMap.get(languageId) as ILocalizationContents;
+  }
+
+  getAllLanguages(): ILocalizationInfo[] {
+    return Array.from(this.localizationInfo.values());
+  }
+}
+
+/**
+ * 获取当前语言别名，默认为中文
+ * TODO 临时通过 href 获取
+ * @returns 当前语言别名
+ */
+export function getLanguageId(scope = 'host'): string {
+  return _currentLanguageId;
+}
+
+/**
+ * for vscode extension use.
+ *
+ * vscode consider that `en` and `en-us` are the same language(you can search for `en-us` in their code base).
+ * and their default language is `en`, so we should transform the language id to the vscode language id.
+ *
+ * and vscode fetch the language id from the browser (`navigator.language`) or electron's [`app.getLocale()`](https://www.electronjs.org/zh/docs/latest/api/app#appgetlocale).
+ * they both using Chromium's l10n_util library. Possible values are here: https://source.chromium.org/chromium/chromium/src/+/master:ui/base/l10n/l10n_util.cc
+ *
+ * The language used for the user interface. The format of the string is all lower case (e.g. zh-tw for Traditional Chinese)
+ * see: [language](https://github.com/microsoft/vscode/blob/32b031eeefc4fd27a21659d35070967bfe965bcc/src/vs/base/common/platform.ts#L165)
+ */
+export function getCodeLanguage(): string {
+  const languageId = _currentLanguageId.toLowerCase();
+  return (
+    {
+      'en-us': 'en',
+    }[languageId] ?? languageId
+  );
+}
+
+export function getCurrentLanguageInfo(scope = 'host'): ILocalizationInfo {
+  return getLocalizationRegistry(scope).localizationInfo.get(_currentLanguageId)!;
+}
+
+export function setLanguageId(languageId: string): void {
+  _currentLanguageId = languageId;
+}
+
+export function getAvailableLanguages(scope = 'host'): ILocalizationInfo[] {
+  return getLocalizationRegistry(scope).getAllLanguages();
+}
+
+function getLocalizationRegistry(scope: string): LocalizationRegistry {
+  if (!localizationRegistryMap.has(scope)) {
+    localizationRegistryMap.set(scope, new LocalizationRegistry());
+  }
+  return localizationRegistryMap.get(scope)!;
+}
+
+/**
+ * 将整段字符串中所有的占位符标识的做一遍转换，
+ * 标识符转换失败则返回该字符串本身：
+ * ```js
+ * "%abcd%1 %1234%2".replace(/%(.*?)%/g, (c, a)=>{return c;})
+ * -> "%abcd%1 %1234%2"
+ * ```
+ * @param label 要转换的字段
+ * @param scope 默认为 host
+ */
+export function replaceLocalizePlaceholder(label?: string, scope?: string): string | undefined {
+  if (label) {
+    return label.replace(/%(.*?)%/g, (w, p) => localize(p, w, scope).replace(/\"/g, '\\"'));
+  }
+  return label;
+}
+
+/**
+ * 含有占位符标识的字段转换，字段为 falsy 的时候返回该字段
+ * 占位符找不到时返回 fallback 值(默认为 undefined)
+ * @param label 要转换的字段
+ * @param scope 默认为 host
+ * @param fallback 默认为 undefined
+ */
+export function replaceNlsField(label: string, scope: string, fallback: string, language?: string): string;
+export function replaceNlsField(
+  label?: string,
+  scope?: string,
+  fallback?: string,
+  language?: string,
+): string | undefined;
+export function replaceNlsField(
+  label?: string,
+  scope?: string,
+  fallback: string | undefined = undefined,
+  language = _currentLanguageId,
+): string | undefined {
+  if (label) {
+    const nlsRegex = /^%([\w\d.-]+)%$/i;
+    const result = nlsRegex.exec(label);
+    if (result) {
+      return localize(result[1], fallback, scope, language);
+    }
+  }
+  return label;
+}