@opensumi/ide-core-browser 2.21.13 → 2.22.0

package/src/context-key.ts

@@ -0,0 +1,48 @@
+import { Event, BasicEvent } from '@opensumi/ide-core-common';
+import { ContextKeyService } from '@opensumi/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
+import { IContextKeyService as IMonacoContextKeyService } from '@opensumi/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
+import {
+  ContextKeyExpr,
+  IContextKeyServiceTarget,
+  ContextKeyValue,
+} from '@opensumi/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
+
+export interface IContextKey<T extends ContextKeyValue = ContextKeyValue> {
+  set(value: T | undefined): void;
+  reset(): void;
+  get(): T | undefined;
+}
+
+export const IContextKeyService = Symbol('IContextKeyService');
+
+export interface IContextKeyService {
+  onDidChangeContext: Event<ContextKeyChangeEvent>;
+
+  bufferChangeEvents(callback: Function): void;
+
+  getValue<T>(key: string): T | undefined;
+  createKey<T extends ContextKeyValue = any>(key: string, defaultValue: T | undefined): IContextKey<T>;
+  match(expression: string | ContextKeyExpr | undefined, context?: HTMLElement | null): boolean;
+  getKeysInWhen(when: string | ContextKeyExpr | undefined): string[];
+  getContextValue<T>(key: string): T | undefined;
+  contextKeyService: IMonacoContextKeyService;
+
+  createScoped(target?: IContextKeyServiceTarget | ContextKeyService): IScopedContextKeyService;
+
+  parse(when: string | undefined): ContextKeyExpr | undefined;
+  dispose(): void;
+}
+
+export interface IScopedContextKeyService extends IContextKeyService {
+  attachToDomNode(domNode: HTMLElement): void;
+}
+
+export interface IContextKeyChangeEventPayload {
+  affectsSome(keys: IReadableSet<string>): boolean;
+}
+
+export interface IReadableSet<T> {
+  has(value: T): boolean;
+}
+
+export class ContextKeyChangeEvent extends BasicEvent<IContextKeyChangeEventPayload> {}

package/src/contextkey/dialog.ts

@@ -0,0 +1,3 @@
+import { RawContextKey } from '../raw-context-key';
+
+export const DialogViewVisibleContext = new RawContextKey<boolean>('dialogViewVisible', false);

package/src/contextkey/explorer.ts

@@ -0,0 +1,26 @@
+import { RawContextKey } from '../raw-context-key';
+
+/**
+ * Context Keys to use with keybindings for the Explorer and Open Editors view
+ */
+export const ExplorerResourceIsFolderContext = new RawContextKey<boolean>('explorerResourceIsFolder', false);
+export const ExplorerViewletVisibleContext = new RawContextKey<boolean>('explorerViewletVisible', true);
+
+export const ExplorerResourceCut = new RawContextKey<boolean>('explorerResourceCut', false);
+export const ExplorerFocusedContext = new RawContextKey<boolean>('explorerViewletFocus', false);
+export const ExplorerFilteredContext = new RawContextKey<boolean>('explorerViewletFilter', false);
+
+export const FilesExplorerFocusedContext = new RawContextKey<boolean>('filesExplorerFocus', false);
+export const FilesExplorerInputFocusedContext = new RawContextKey<boolean>('filesExplorerInputFocus', false);
+export const FilesExplorerFilteredContext = new RawContextKey<boolean>('filesExplorerFilteredContext', false);
+
+// compressed nodes
+export const ExplorerCompressedFocusContext = new RawContextKey<boolean>('explorerViewletCompressedFocus', false);
+export const ExplorerCompressedFirstFocusContext = new RawContextKey<boolean>(
+  'explorerViewletCompressedFirstFocus',
+  false,
+);
+export const ExplorerCompressedLastFocusContext = new RawContextKey<boolean>(
+  'explorerViewletCompressedLastFocus',
+  false,
+);

package/src/contextkey/index.ts

@@ -0,0 +1,6 @@
+export * from './explorer';
+export * from './resource';
+export * from './terminal';
+export * from './outline';
+export * from './workspace';
+export * from './dialog';

package/src/contextkey/outline.ts

@@ -0,0 +1,4 @@
+import { RawContextKey } from '../raw-context-key';
+
+export const OutlineSortTypeContext = new RawContextKey<number>('outlineSortType', 0);
+export const OutlineFollowCursorContext = new RawContextKey<boolean>('outlineFollowCursor', false);

package/src/contextkey/resource.ts

@@ -0,0 +1,61 @@
+import { Schemes, URI } from '@opensumi/ide-core-common';
+
+import { IContextKeyService, IContextKey } from '../context-key';
+import { getLanguageIdFromMonaco } from '../services/label-service';
+
+export type ILanguageResolver = (uri: URI) => string | null;
+
+export class ResourceContextKey {
+  private resourceScheme: IContextKey<string>;
+  private resourceFilename: IContextKey<string>;
+  private resourceExtname: IContextKey<string>;
+  private resourceLangId: IContextKey<string>;
+  private resourceKey: IContextKey<string>;
+  private isFileSystemResource: IContextKey<boolean>;
+
+  constructor(
+    private contextKeyService: IContextKeyService,
+    private languageResolver: ILanguageResolver = getLanguageIdFromMonaco,
+    prefix = 'resource',
+  ) {
+    if (!prefix) {
+      throw new Error('resource key prefix cannot be empty!');
+    }
+    this.resourceScheme = this.contextKeyService.createKey<string>(prefix + 'Scheme', '');
+    this.resourceFilename = this.contextKeyService.createKey<string>(prefix + 'Filename', '');
+    this.resourceExtname = this.contextKeyService.createKey<string>(prefix + 'Extname', '');
+    this.resourceLangId = this.contextKeyService.createKey<string>(prefix + 'LangId', '');
+    this.resourceKey = this.contextKeyService.createKey<string>(prefix, '');
+    this.isFileSystemResource = this.contextKeyService.createKey<boolean>(
+      'isFileSystem' + prefix.substr(0, 1).toUpperCase() + prefix.substr(1),
+      false,
+    );
+  }
+
+  set(uri: URI | undefined) {
+    if (!uri) {
+      this.reset();
+      return;
+    }
+
+    const resource = this.resourceKey.get();
+    // 相同的 URI 则不再重新设置
+    if (!uri.isEqual(new URI(resource))) {
+      this.resourceScheme.set(uri.scheme);
+      this.resourceFilename.set(uri.path.name + uri.path.ext);
+      this.resourceExtname.set(uri.path.ext);
+      this.resourceLangId.set(this.languageResolver(uri)!);
+      this.resourceKey.set(uri.toString());
+      this.isFileSystemResource.set(uri.scheme === Schemes.file);
+    }
+  }
+
+  reset() {
+    this.resourceScheme.set('');
+    this.resourceFilename.set('');
+    this.resourceExtname.set('');
+    this.resourceLangId.set('');
+    this.resourceKey.set('');
+    this.isFileSystemResource.set(false);
+  }
+}

package/src/contextkey/search.ts

@@ -0,0 +1,30 @@
+import { RawContextKey } from '../raw-context-key';
+
+// https://github.com/microsoft/vscode/blob/9318bcc5183dbbc49cea8843859cbdeb59b94eaf/src/vs/workbench/contrib/search/common/constants.ts
+export const SearchViewFocusedKey = new RawContextKey<boolean>('searchViewletFocus', false);
+export const SearchInputBoxFocusedKey = new RawContextKey<boolean>('searchInputBoxFocus', false);
+export const ReplaceInputBoxFocusedKey = new RawContextKey<boolean>('replaceInputBoxFocus', false);
+export const HasSearchResults = new RawContextKey<boolean>('hasSearchResult', false);
+
+// not impliments
+export const SearchViewVisibleKey = new RawContextKey<boolean>('searchViewletVisible', true);
+export const InputBoxFocusedKey = new RawContextKey<boolean>('inputBoxFocus', false);
+export const PatternIncludesFocusedKey = new RawContextKey<boolean>('patternIncludesInputBoxFocus', false);
+export const PatternExcludesFocusedKey = new RawContextKey<boolean>('patternExcludesInputBoxFocus', false);
+export const ReplaceActiveKey = new RawContextKey<boolean>('replaceActive', false);
+export const FirstMatchFocusKey = new RawContextKey<boolean>('firstMatchFocus', false);
+export const FileMatchOrMatchFocusKey = new RawContextKey<boolean>('fileMatchOrMatchFocus', false); // This is actually, Match or File or Folder
+export const FileMatchOrFolderMatchFocusKey = new RawContextKey<boolean>('fileMatchOrFolderMatchFocus', false);
+export const FileMatchOrFolderMatchWithResourceFocusKey = new RawContextKey<boolean>(
+  'fileMatchOrFolderMatchWithResourceFocus',
+  false,
+); // Excludes "Other files"
+export const FileFocusKey = new RawContextKey<boolean>('fileMatchFocus', false);
+export const FolderFocusKey = new RawContextKey<boolean>('folderMatchFocus', false);
+export const ResourceFolderFocusKey = new RawContextKey<boolean>('folderMatchWithResourceFocus', false);
+export const MatchFocusKey = new RawContextKey<boolean>('matchFocus', false);
+export const ViewHasSearchPatternKey = new RawContextKey<boolean>('viewHasSearchPattern', false);
+export const ViewHasReplacePatternKey = new RawContextKey<boolean>('viewHasReplacePattern', false);
+export const ViewHasFilePatternKey = new RawContextKey<boolean>('viewHasFilePattern', false);
+export const ViewHasSomeCollapsibleKey = new RawContextKey<boolean>('viewHasSomeCollapsibleResult', false);
+export const InTreeViewKey = new RawContextKey<boolean>('inTreeView', false);

package/src/contextkey/terminal.ts

@@ -0,0 +1,7 @@
+import { RawContextKey } from '../raw-context-key';
+
+/**
+ * Context Keys to use with keybindings for the Terminal
+ */
+export const IsTerminalViewInitialized = new RawContextKey<boolean>('isTerminalViewInitialized', false);
+export const IsTerminalFocused = new RawContextKey<boolean>('isTerminalFocused', false);

package/src/contextkey/testing.ts

@@ -0,0 +1,9 @@
+import { RawContextKey } from '../raw-context-key';
+
+export const TestingServiceProviderCount = new RawContextKey('service.testing.providerCount', 0);
+export const TestingServiceHasDebuggableContextKey = new RawContextKey('service.testing.hasDebuggableContext', false);
+export const TestingHasAnyResults = new RawContextKey('testing.hasAnyResults', false);
+export const TestingIsRunning = new RawContextKey('testing.isRunning', false);
+export const TestingIsInPeek = new RawContextKey('testing.isInPeek', true);
+export const TestingIsPeekVisible = new RawContextKey('testing.isPeekVisible', false);
+export const TestingCanRefreshTests = new RawContextKey('testing.canRefresh', false);

package/src/contextkey/workspace.ts

@@ -0,0 +1,7 @@
+import { RawContextKey } from '../raw-context-key';
+
+/**
+ * Context Keys to use with keybindings for the Workspace
+ */
+export const WorkbenchState = new RawContextKey<string>('workbenchState', 'empty');
+export const WorkspaceFolderCount = new RawContextKey<number>('workspaceFolderCount', 0);

package/src/core-preferences.ts

@@ -0,0 +1,318 @@
+import { Injector } from '@opensumi/di';
+import {
+  localize,
+  getAvailableLanguages,
+  SUPPORTED_ENCODINGS,
+  GeneralSettingsId,
+  PreferenceSchema,
+} from '@opensumi/ide-core-common';
+
+import { createPreferenceProxy, PreferenceProxy, PreferenceService } from './preferences';
+
+const EXPLORER_DEFAULTS = {
+  confirmDelete: true,
+  confirmMove: true,
+};
+
+export const FILES_DEFAULTS = {
+  filesWatcherExclude: {
+    '**/.git/objects/**': true,
+    '**/.git/subtree-cache/**': true,
+    '**/node_modules/**/*': true,
+    '**/.hg/store/**': true,
+  },
+  filesExclude: {
+    '**/.git': true,
+    '**/.svn': true,
+    '**/.hg': true,
+    '**/CVS': true,
+    '**/.DS_Store': true,
+  },
+};
+
+export const FILE_TREE_DEFAULTS = {
+  baseIndent: 10,
+  indent: 8,
+};
+
+export const corePreferenceSchema: PreferenceSchema = {
+  type: 'object',
+  properties: {
+    'general.language': {
+      type: 'string',
+      enum: getAvailableLanguages().map((l) => l.languageId),
+      default: 'zh-CN',
+    },
+    'general.theme': {
+      type: 'string',
+      default: 'vs-dark',
+      enum: [],
+    },
+    'general.askReloadOnLanguageChange': {
+      type: 'boolean',
+      default: true,
+      description: '%preference.description.general.askReloadOnLanguageChange%',
+    },
+    [GeneralSettingsId.Icon]: {
+      type: 'string',
+      default: 'vs-minimal',
+      enum: [],
+    },
+    'workbench.colorCustomizations': {
+      type: 'object',
+      description: '%preference.workbench.colorCustomizations%',
+      default: {},
+    },
+
+    // 是否允许打开文件夹
+    'application.supportsOpenFolder': {
+      type: 'boolean',
+      default: false,
+      description: 'Whether default open folder behavior is supported',
+    },
+    'application.supportsOpenWorkspace': {
+      type: 'boolean',
+      default: false,
+      description: 'Whether default open workspace behavior is supported',
+    },
+    'application.confirmExit': {
+      type: 'string',
+      enum: ['never', 'ifRequired', 'always'],
+      default: 'always',
+      description: 'When to confirm before closing the application window.',
+    },
+    'application.preferMarkdownPreview': {
+      type: 'boolean',
+      default: false,
+      description: 'Use markdown preview first',
+    },
+    'application.invalidExthostReload': {
+      type: 'string',
+      enum: ['ifRequired', 'always'],
+      default: 'ifRequired',
+      description: 'Reload strategy when exthost process became invalid.',
+    },
+    'workbench.list.openMode': {
+      type: 'string',
+      enum: ['singleClick', 'doubleClick'],
+      default: 'singleClick',
+      description: localize('preference.workbench.list.openMode'),
+    },
+    'workbench.commandPalette.history': {
+      type: 'number',
+      default: 50,
+      minimum: 0,
+      description:
+        'Controls the number of recently used commands to keep in history for the command palette. Set to 0 to disable command history.',
+    },
+    'workbench.refactoringChanges.showPreviewStrategy': {
+      type: 'string',
+      default: 'askMe',
+      enum: ['show', 'hide', 'askMe'],
+      description: '%preference.workbench.refactoringChanges.showPreviewStrategy%',
+    },
+    'workbench.quickOpen.preserveInput': {
+      type: 'boolean',
+      default: true,
+      description: '%workbench.quickOpen.preserveInput%',
+    },
+    'workbench.hideSlotTabBarWhenHidePanel': {
+      type: 'boolean',
+      default: false,
+      description: '%workbench.hideSlotTabBarWhenHidePanel%',
+    },
+    'explorer.confirmMove': {
+      type: 'boolean',
+      default: EXPLORER_DEFAULTS.confirmDelete,
+      description: '%preference.explorer.confirm.move%',
+    },
+    'explorer.confirmDelete': {
+      type: 'boolean',
+      default: EXPLORER_DEFAULTS.confirmMove,
+      description: '%preference.explorer.confirm.delete%',
+    },
+    'explorer.fileTree.baseIndent': {
+      type: 'number',
+      default: FILE_TREE_DEFAULTS.baseIndent,
+    },
+    'explorer.fileTree.indent': {
+      type: 'number',
+      default: FILE_TREE_DEFAULTS.indent,
+    },
+    'explorer.compactFolders': {
+      type: 'boolean',
+      description: '%preference.explorer.compactFolders%',
+      default: true,
+    },
+    'explorer.autoReveal': {
+      type: 'boolean',
+      default: true,
+    },
+    'debug.toolbar.float': {
+      type: 'boolean',
+      default: true,
+    },
+    'debug.toolbar.top': {
+      type: 'number',
+      default: 0,
+      description: '%preference.debug.toolbar.top%',
+    },
+    'debug.toolbar.height': {
+      type: 'number',
+      default: 30,
+      description: '%preference.debug.toolbar.height%',
+    },
+    'debug.console.filter.mode': {
+      type: 'string',
+      enum: ['filter', 'matcher'],
+      default: 'filter',
+    },
+    'files.exclude': {
+      type: 'object',
+      description: '%preference.files.exclude%',
+      default: FILES_DEFAULTS.filesExclude,
+      additionalProperties: {
+        anyOf: [
+          {
+            type: 'boolean',
+            description: localize(
+              'files.exclude.boolean',
+              'The glob pattern to match file paths against. Set to true or false to enable or disable the pattern.',
+            ),
+          },
+        ],
+      },
+    },
+    'files.watcherExclude': {
+      type: 'object',
+      default: FILES_DEFAULTS.filesWatcherExclude,
+      description: '%preference.files.watcherExclude%',
+    },
+    'files.associations': {
+      type: 'object',
+      markdownDescription: '%preference.files.associations%',
+    },
+    'files.encoding': {
+      type: 'string',
+      description: '%preference.files.encoding%',
+      default: 'utf8',
+      enum: Object.keys(SUPPORTED_ENCODINGS),
+    },
+    'files.eol': {
+      type: 'string',
+      enum: ['\n', '\r\n', 'auto'],
+      default: 'auto',
+    },
+    'files.trimFinalNewlines': {
+      type: 'boolean',
+      default: false,
+    },
+    'files.trimTrailingWhitespace': {
+      type: 'boolean',
+      default: false,
+    },
+    'files.insertFinalNewline': {
+      type: 'boolean',
+      default: false,
+    },
+    'files.autoGuessEncoding': {
+      type: 'boolean',
+      default: false,
+      description: '%preference.files.autoGuessEncoding%',
+      included: Object.keys(SUPPORTED_ENCODINGS).length > 1,
+    },
+    // 设置面板是否用户Scope在前
+    'settings.userBeforeWorkspace': {
+      type: 'boolean',
+      default: false,
+      description: '%settings.configuration.userBeforeWorkspace%',
+    },
+    'output.maxChannelLine': {
+      type: 'number',
+      default: 50000,
+      description: '%output.maxChannelLineDesc%',
+    },
+    'output.enableLogHighlight': {
+      type: 'boolean',
+      default: true,
+      description: '%output.enableLogHighlightDesc%',
+    },
+    'output.enableSmartScroll': {
+      type: 'boolean',
+      default: true,
+      description: '%output.enableSmartScrollDesc%',
+    },
+    'debug.inline.values': {
+      type: 'boolean',
+      default: false,
+    },
+    'debug.console.wordWrap': {
+      type: 'boolean',
+      default: true,
+    },
+    'toolbar.ignoreActions': {
+      type: 'object',
+      patternProperties: {
+        '.*': {
+          type: 'array',
+          items: [{ type: 'string' }],
+        },
+      },
+      description: '%preference.toolbar.ignoreActions%',
+    },
+    'toolbar.buttonDisplay': {
+      type: 'string',
+      enum: ['icon', 'iconAndText'],
+      default: 'iconAndText',
+      description: '%preference.toolbar.buttonDisplay%',
+    },
+    'toolbar.buttonTitleStyle': {
+      type: 'string',
+      enum: ['vertical', 'horizontal'],
+      default: 'horizontal',
+    },
+    'view.saveLayoutWithWorkspace': {
+      type: 'boolean',
+      default: false,
+    },
+  },
+};
+
+export interface CoreConfiguration {
+  'application.confirmExit': 'never' | 'ifRequired' | 'always';
+  'application.invalidExthostReload': 'ifRequired' | 'always';
+  'workbench.list.openMode': 'singleClick' | 'doubleClick';
+  'debug.console.filter.mode': 'filter' | 'matcher';
+  'workbench.commandPalette.history': number;
+  'workbench.refactoringChanges.showPreviewStrategy': string;
+  'workbench.quickOpen.preserveInput': boolean;
+  'explorer.confirmDelete': boolean;
+  'explorer.fileTree.baseIndent': number;
+  'explorer.fileTree.indent': number;
+  'explorer.autoReveal': boolean;
+  'explorer.confirmMove': boolean;
+  'explorer.compactFolders': boolean;
+  'debug.toolbar.float': boolean;
+  'debug.toolbar.top': number;
+  'debug.toolbar.height': number;
+  'files.watcherExclude': { [key: string]: boolean };
+  'files.exclude': { [key: string]: boolean };
+  'files.associations': { [key: string]: string };
+  'files.encoding': string;
+  'general.language': string;
+  'general.theme': string;
+  'view.saveLayoutWithWorkspace': boolean;
+}
+
+export const CorePreferences = Symbol('CorePreferences');
+export type CorePreferences = PreferenceProxy<CoreConfiguration>;
+
+export function injectCorePreferences(inject: Injector) {
+  inject.addProviders({
+    token: CorePreferences,
+    useFactory: (inject: Injector) => {
+      const preferences: PreferenceService = inject.get(PreferenceService);
+      return createPreferenceProxy(preferences, corePreferenceSchema);
+    },
+  });
+}