@opensumi/ide-preferences 2.21.13 → 2.22.0

package/src/browser/index.ts

@@ -0,0 +1,125 @@
+import { Provider, Injector, Injectable } from '@opensumi/di';
+import { BrowserModule } from '@opensumi/ide-core-browser';
+import {
+  PreferenceScope,
+  PreferenceConfigurations,
+  PreferenceProvider,
+  IPreferenceSettingsService,
+} from '@opensumi/ide-core-browser/lib/preferences';
+
+import { IUserStorageService, SettingContribution } from '../common';
+
+import {
+  FolderFilePreferenceProviderFactory,
+  FolderFilePreferenceProviderOptions,
+  FolderFilePreferenceProvider,
+} from './folder-file-preference-provider';
+import { FoldersPreferencesProvider } from './folders-preferences-provider';
+import { PreferenceContribution } from './preference-contribution';
+import { PreferenceSettingsService } from './preference-settings.service';
+import { UserPreferenceProvider } from './user-preference-provider';
+import { UserStorageContribution, UserStorageServiceImpl } from './userstorage';
+import {
+  WorkspaceFilePreferenceProviderFactory,
+  WorkspaceFilePreferenceProviderOptions,
+  WorkspaceFilePreferenceProvider,
+} from './workspace-file-preference-provider';
+import { WorkspacePreferenceProvider } from './workspace-preference-provider';
+
+@Injectable()
+export class PreferencesModule extends BrowserModule {
+  contributionProvider = SettingContribution;
+  providers: Provider[] = [
+    ...createPreferenceProviders(),
+    {
+      token: IUserStorageService,
+      useClass: UserStorageServiceImpl,
+    },
+    {
+      token: IPreferenceSettingsService,
+      useClass: PreferenceSettingsService,
+    },
+    PreferenceContribution,
+    UserStorageContribution,
+  ];
+
+  preferences = injectPreferenceProviders;
+}
+
+export function injectFolderPreferenceProvider(inject: Injector): void {
+  inject.addProviders({
+    token: FolderFilePreferenceProviderFactory,
+    useFactory: () => (options: FolderFilePreferenceProviderOptions) => {
+      const configurations = inject.get(PreferenceConfigurations);
+      const sectionName = configurations.getName(options.configUri);
+      const child = inject.createChild(
+        [
+          {
+            token: FolderFilePreferenceProviderOptions,
+            useValue: options,
+          },
+        ],
+        {
+          dropdownForTag: true,
+          tag: sectionName,
+        },
+      );
+      // 当传入为配置文件时，如settings.json, 获取Setting
+      if (configurations.isConfigUri(options.configUri)) {
+        child.addProviders({
+          token: FolderFilePreferenceProvider,
+          useClass: FolderFilePreferenceProvider,
+        });
+        return child.get(FolderFilePreferenceProvider);
+      }
+      // 当传入为其他文件时，如launch.json
+      // 需设置对应的FolderPreferenceProvider 及其对应的 FolderFilePreferenceProviderOptions 依赖
+      // 这里的FolderPreferenceProvider获取必须为多例，因为工作区模式下可能存在多个配置文件
+      return child.get(FolderFilePreferenceProvider, { tag: sectionName, multiple: true });
+    },
+  });
+}
+
+export function injectWorkspaceFilePreferenceProvider(inject: Injector): void {
+  inject.addProviders({
+    token: WorkspaceFilePreferenceProviderFactory,
+    useFactory: () => (options: WorkspaceFilePreferenceProviderOptions) => {
+      const child = inject.createChild([
+        {
+          token: WorkspaceFilePreferenceProviderOptions,
+          useValue: options,
+        },
+        {
+          token: WorkspaceFilePreferenceProvider,
+          useClass: WorkspaceFilePreferenceProvider,
+        },
+      ]);
+      return child.get(WorkspaceFilePreferenceProvider);
+    },
+  });
+}
+
+export function injectPreferenceProviders(inject: Injector): void {
+  injectFolderPreferenceProvider(inject);
+  injectWorkspaceFilePreferenceProvider(inject);
+}
+
+export function createPreferenceProviders(): Provider[] {
+  return [
+    {
+      token: PreferenceProvider,
+      tag: PreferenceScope.Folder,
+      useClass: FoldersPreferencesProvider,
+    },
+    {
+      token: PreferenceProvider,
+      tag: PreferenceScope.Workspace,
+      useClass: WorkspacePreferenceProvider,
+    },
+    {
+      token: PreferenceProvider,
+      tag: PreferenceScope.User,
+      useClass: UserPreferenceProvider,
+    },
+  ];
+}

package/src/browser/preference-contribution.ts

@@ -0,0 +1,432 @@
+import * as jsoncParser from 'jsonc-parser';
+
+import { Autowired, Injectable, INJECTOR_TOKEN, Injector } from '@opensumi/di';
+import {
+  ClientAppContribution,
+  PreferenceSchemaProvider,
+  URI,
+  Domain,
+  CommandContribution,
+  CommandRegistry,
+  COMMON_COMMANDS,
+  KeybindingContribution,
+  KeybindingRegistry,
+  PreferenceScope,
+  PreferenceProvider,
+  WithEventBus,
+  MaybePromise,
+  localize,
+  CommandService,
+  EDITOR_COMMANDS,
+  JsonSchemaContribution,
+  IJSONSchemaRegistry,
+  IPreferenceSettingsService,
+  ContributionProvider,
+  ISettingGroup,
+  IDisposable,
+  arrays,
+  Command,
+  getIcon,
+  isString,
+  ISettingSection,
+  CodeSchemaId,
+} from '@opensumi/ide-core-browser';
+import { MenuContribution, IMenuRegistry, MenuId } from '@opensumi/ide-core-browser/lib/menu/next';
+import { ResourceService, IResourceProvider, IResource } from '@opensumi/ide-editor';
+import {
+  BrowserEditorContribution,
+  EditorComponentRegistry,
+  EditorOpenType,
+  IEditor,
+  IEditorFeatureRegistry,
+  IResourceOpenResult,
+  WorkbenchEditorService,
+} from '@opensumi/ide-editor/lib/browser';
+import { IFileServiceClient } from '@opensumi/ide-file-service/lib/common';
+
+import { PREF_SCHEME, SettingContribution } from '../common';
+
+import { PreferenceSettingsService, defaultSettingGroup, defaultSettingSections } from './preference-settings.service';
+import { EditPreferenceDecorationsContribution } from './preference-widgets';
+import { PreferenceView } from './preferences.view';
+import { USER_PREFERENCE_URI } from './user-preference-provider';
+import { WorkspacePreferenceProvider } from './workspace-preference-provider';
+
+const PREF_PREVIEW_COMPONENT_ID = 'pref-preview';
+const { addElement } = arrays;
+
+@Injectable()
+export class PrefResourceProvider extends WithEventBus implements IResourceProvider {
+  readonly scheme: string = PREF_SCHEME;
+
+  constructor() {
+    super();
+  }
+
+  provideResource(uri: URI): MaybePromise<IResource<any>> {
+    // 获取文件类型 getFileType: (path: string) => string
+    return {
+      supportsRevive: true,
+      name: localize('preference.tab.name'),
+      icon: getIcon('setting'),
+      uri,
+    };
+  }
+
+  provideResourceSubname(resource: IResource, groupResources: IResource[]): string | null {
+    return null;
+  }
+
+  async shouldCloseResource(resource: IResource, openedResources: IResource[][]): Promise<boolean> {
+    return true;
+  }
+}
+
+export namespace PreferenceContextMenu {
+  // 1_, 2_用于菜单排序，这样能保证分组顺序顺序
+  export const OPEN = '1_open';
+}
+
+export namespace PREFERENCE_COMMANDS {
+  const CATEGORY = 'preference';
+
+  export const OPEN_USER_SETTING_FILE: Command = {
+    id: 'preference.open.user',
+    label: localize('preference.editorTitle.openUserSource'),
+    category: CATEGORY,
+  };
+
+  export const OPEN_WORKSPACE_SETTING_FILE: Command = {
+    id: 'preference.open.workspace',
+    label: localize('preference.editorTitle.openWorkspaceSource'),
+    category: CATEGORY,
+  };
+
+  export const OPEN_SOURCE_FILE: Command = {
+    id: 'preference.open.source',
+    label: localize('preference.editorTitle.openSource'),
+    category: CATEGORY,
+  };
+
+  export const PREFERENCE_INPUT_FOCUS: Command = {
+    id: 'preference.input.focus',
+    category: CATEGORY,
+  };
+}
+
+@Domain(
+  CommandContribution,
+  KeybindingContribution,
+  ClientAppContribution,
+  BrowserEditorContribution,
+  MenuContribution,
+  JsonSchemaContribution,
+)
+export class PreferenceContribution
+  implements
+    CommandContribution,
+    KeybindingContribution,
+    ClientAppContribution,
+    BrowserEditorContribution,
+    MenuContribution,
+    JsonSchemaContribution
+{
+  @Autowired(INJECTOR_TOKEN)
+  private readonly injector: Injector;
+
+  @Autowired(PreferenceSchemaProvider)
+  private readonly schemaProvider: PreferenceSchemaProvider;
+
+  @Autowired(PreferenceProvider, { tag: PreferenceScope.Workspace })
+  protected readonly workspacePreferenceProvider: WorkspacePreferenceProvider;
+
+  @Autowired(IFileServiceClient)
+  protected readonly filesystem: IFileServiceClient;
+
+  @Autowired(PrefResourceProvider)
+  private readonly prefResourceProvider: PrefResourceProvider;
+
+  @Autowired(CommandService)
+  private readonly commandService: CommandService;
+
+  @Autowired(IJSONSchemaRegistry)
+  private readonly schemaRegistry: IJSONSchemaRegistry;
+
+  @Autowired(IPreferenceSettingsService)
+  private readonly preferenceService: PreferenceSettingsService;
+
+  @Autowired(SettingContribution)
+  private readonly contributions: ContributionProvider<SettingContribution>;
+
+  @Autowired(WorkbenchEditorService)
+  private readonly workbenchEditorService: WorkbenchEditorService;
+
+  private settingGroupsWillRegister: ISettingGroup[] = defaultSettingGroup;
+
+  private settingSectionsWillRegister: {
+    [key: string]: ISettingSection[];
+  } = defaultSettingSections;
+
+  onStart() {
+    /**
+     * 处理各个模块下贡献的 PreferenceSettingSectionContribution， 组成默认的设置面板内容
+     */
+    /**
+     * 收集 contribution 里对 settingGroupsWillRegister, settingSectionsWillRegister 增删
+     */
+    this.saveSettings();
+    this.handleSettingGroups();
+    this.handleSettingSections();
+
+    /**
+     * 将收集到的 group 和 section 真正注册到 service
+     */
+    this.registerSettings();
+    this.registerSettingSections();
+
+    this.preferenceService.fireDidSettingsChange();
+  }
+
+  registerCommands(commands: CommandRegistry) {
+    commands.registerCommand(COMMON_COMMANDS.OPEN_PREFERENCES, {
+      execute: async (search?: string) => {
+        await this.openPreferences(search);
+      },
+    });
+
+    commands.registerCommand(COMMON_COMMANDS.LOCATE_PREFERENCES, {
+      execute: async (groupId: string) => {
+        await this.openPreferences();
+        return await this.preferenceService.scrollToGroup(groupId);
+      },
+    });
+
+    commands.registerCommand(PREFERENCE_COMMANDS.OPEN_USER_SETTING_FILE, {
+      execute: () => {
+        this.openResource(PreferenceScope.User);
+      },
+    });
+
+    commands.registerCommand(PREFERENCE_COMMANDS.OPEN_WORKSPACE_SETTING_FILE, {
+      execute: () => {
+        this.openResource(PreferenceScope.Workspace);
+      },
+    });
+
+    commands.registerCommand(PREFERENCE_COMMANDS.OPEN_SOURCE_FILE, {
+      execute: async (scopeOrUrl?: PreferenceScope | URI, preferenceId?: string) => {
+        // 这里可能被 Editor 的 Toolbar 调用
+        // 传入 URI 及 EditorGroup
+        if (!scopeOrUrl || typeof scopeOrUrl !== 'number') {
+          this.openResource();
+        } else {
+          this.openResource(scopeOrUrl as PreferenceScope, preferenceId);
+        }
+      },
+    });
+
+    commands.registerCommand(PREFERENCE_COMMANDS.PREFERENCE_INPUT_FOCUS, {
+      execute: () => {
+        this.preferenceService.focusInput();
+      },
+    });
+  }
+
+  registerMenus(menus: IMenuRegistry) {
+    menus.registerMenuItem(MenuId.SettingsIconMenu, {
+      command: COMMON_COMMANDS.OPEN_PREFERENCES.id,
+      group: PreferenceContextMenu.OPEN,
+    });
+
+    menus.registerMenuItem(MenuId.EditorTitle, {
+      command: PREFERENCE_COMMANDS.OPEN_SOURCE_FILE.id,
+      iconClass: getIcon('open'),
+      group: 'navigation',
+      order: 4,
+      when: `resourceScheme == ${PREF_SCHEME}`,
+    });
+
+    menus.registerMenuItem(MenuId.EditorTitle, {
+      command: COMMON_COMMANDS.OPEN_PREFERENCES.id,
+      iconClass: getIcon('open'),
+      group: 'navigation',
+      order: 4,
+      when: 'resourceFilename =~ /settings.json/',
+    });
+  }
+
+  registerKeybindings(keybindings: KeybindingRegistry): void {
+    keybindings.registerKeybinding({
+      command: COMMON_COMMANDS.OPEN_PREFERENCES.id,
+      keybinding: 'ctrlcmd+,',
+    });
+
+    keybindings.registerKeybinding({
+      command: PREFERENCE_COMMANDS.PREFERENCE_INPUT_FOCUS.id,
+      keybinding: 'ctrlcmd+f',
+      when: 'resourceScheme == pref',
+    });
+  }
+
+  handleSettingGroups() {
+    for (const contrib of this.contributions.getContributions()) {
+      if (contrib.handleSettingGroup) {
+        this.settingGroupsWillRegister = contrib.handleSettingGroup(this.settingGroupsWillRegister);
+      }
+    }
+  }
+
+  handleSettingSections() {
+    for (const contrib of this.contributions.getContributions()) {
+      if (contrib.handleSettingSections) {
+        this.settingSectionsWillRegister = contrib.handleSettingSections({ ...this.settingSectionsWillRegister });
+      }
+    }
+  }
+
+  saveSettings() {
+    for (const contrib of this.contributions.getContributions()) {
+      contrib.registerSetting &&
+        contrib.registerSetting({
+          registerSettingGroup: (settingGroup: ISettingGroup): IDisposable =>
+            addElement(this.settingGroupsWillRegister, settingGroup),
+          registerSettingSection: (key, section): IDisposable => {
+            const has = (key: string) => Object.keys(this.settingSectionsWillRegister).includes(key);
+            if (!has(key)) {
+              this.settingSectionsWillRegister[key] = [];
+            }
+            return addElement(this.settingSectionsWillRegister[key], section);
+          },
+        });
+    }
+  }
+
+  registerSettings() {
+    this.settingGroupsWillRegister.forEach((g) => {
+      this.preferenceService.registerSettingGroup(g);
+    });
+  }
+
+  registerSettingSections() {
+    Object.keys(this.settingSectionsWillRegister).forEach((key) => {
+      this.settingSectionsWillRegister[key].forEach((section) => {
+        this.preferenceService.registerSettingSection(key, section);
+      });
+    });
+  }
+
+  async openPreferences(search?: string, prefernceId?: string) {
+    await this.commandService.executeCommand(EDITOR_COMMANDS.OPEN_RESOURCE.id, new URI('/').withScheme(PREF_SCHEME), {
+      preview: false,
+    });
+    if (isString(search)) {
+      this.preferenceService.search(search);
+    }
+  }
+
+  async openResource(scope?: PreferenceScope, preferenceId?: string) {
+    const url = await this.preferenceService.getCurrentPreferenceUrl(scope);
+    const openResult = await this.commandService.executeCommand<IResourceOpenResult>(
+      EDITOR_COMMANDS.OPEN_RESOURCE.id,
+      new URI(url),
+      {
+        focus: true,
+        groupIndex: this.workbenchEditorService.currentEditorGroup.index,
+      },
+    );
+    if (openResult && preferenceId) {
+      const editor = this.workbenchEditorService.editorGroups.find((g) => g.name === openResult.groupId)?.currentEditor;
+      if (editor) {
+        const { _commandService: commandService } = editor.monacoEditor as any;
+        let text = editor.monacoEditor.getValue();
+        let lines;
+        let numReturns;
+        let preferenceLine: string | undefined;
+        let preferenceLineNumber: number | undefined;
+        const { index } = text.match(new RegExp(`\\"${preferenceId}\\"`)) || {};
+        if (index && index >= 0) {
+          numReturns = text.slice(0, index).match(new RegExp('\\n', 'g'))?.length || -1 + 1;
+          if (numReturns > 0) {
+            lines = text.split('\n');
+            preferenceLine = lines[numReturns];
+            preferenceLineNumber = numReturns;
+          }
+        } else {
+          // 如果不存在配置项，追加配置项内容
+          const formattingOptions = { tabSize: 2, insertSpaces: true, eol: '' };
+          const edits = jsoncParser.modify(text, [preferenceId], '', { formattingOptions });
+          const content = jsoncParser.applyEdits(text, edits);
+          editor.monacoEditor.setValue(content);
+          text = content;
+          numReturns = text.slice(0, index).match(new RegExp('\\n', 'g'))?.length || -1;
+          if (numReturns > 1) {
+            lines = text.split('\n');
+            preferenceLine = lines[numReturns - 1];
+            preferenceLineNumber = numReturns - 1;
+          }
+        }
+
+        if (!(preferenceLine && preferenceLineNumber)) {
+          return;
+        }
+
+        const regStr = `\\s+\\"${preferenceId}\\":\\s?["|{|t|f|[]`;
+        const match = new RegExp(regStr, 'g').exec(preferenceLine);
+        if (match) {
+          const isStringExpr = match[0].slice(-1) === '"';
+          editor.monacoEditor.setPosition({ lineNumber: preferenceLineNumber + 1, column: match[0].length + 1 });
+          setTimeout(() => {
+            editor.monacoEditor.revealPositionInCenter(
+              { lineNumber: preferenceLineNumber! + 1, column: match[0].length + 1 },
+              1,
+            );
+          });
+          if (isStringExpr) {
+            // 只对 String 类型配置展示提示，包括不存在配置项时追加的情况
+            await commandService.executeCommand('editor.action.triggerSuggest');
+          }
+        }
+      }
+    }
+  }
+
+  initialize() {
+    this.schemaProvider.onDidPreferenceSchemaChanged(() => {
+      this.registerSchema(this.schemaRegistry);
+    });
+  }
+
+  registerSchema(registry: IJSONSchemaRegistry) {
+    registry.registerSchema(CodeSchemaId.userSettings, this.schemaProvider.getCombinedSchema(), [
+      'settings.json',
+      USER_PREFERENCE_URI.toString(),
+    ]);
+  }
+
+  registerResource(resourceService: ResourceService) {
+    resourceService.registerResourceProvider(this.prefResourceProvider);
+  }
+
+  registerEditorComponent(editorComponentRegistry: EditorComponentRegistry) {
+    editorComponentRegistry.registerEditorComponent({
+      component: PreferenceView,
+      uid: PREF_PREVIEW_COMPONENT_ID,
+      scheme: PREF_SCHEME,
+    });
+
+    editorComponentRegistry.registerEditorComponentResolver(PREF_SCHEME, (_, __, resolve) => {
+      resolve([
+        {
+          type: EditorOpenType.component,
+          componentId: PREF_PREVIEW_COMPONENT_ID,
+        },
+      ]);
+    });
+  }
+
+  registerEditorFeature(registry: IEditorFeatureRegistry) {
+    registry.registerEditorFeatureContribution({
+      contribute: (editor: IEditor) => this.injector.get(EditPreferenceDecorationsContribution, [editor]).contribute(),
+    });
+  }
+}