@opensumi/ide-preferences 2.21.13 → 2.22.0

package/src/browser/abstract-resource-preference-provider.ts

@@ -0,0 +1,357 @@
+import * as jsoncparser from 'jsonc-parser';
+
+import { Injectable, Autowired } from '@opensumi/di';
+import {
+  JSONUtils,
+  URI,
+  Disposable,
+  isUndefined,
+  PreferenceProviderDataChanges,
+  ILogger,
+  IResolvedPreferences,
+  Throttler,
+  FileChange,
+  Schemes,
+  AppConfig,
+  VSCODE_WORKSPACE_CONFIGURATION_DIR_NAME,
+} from '@opensumi/ide-core-browser';
+import {
+  PreferenceProvider,
+  PreferenceSchemaProvider,
+  PreferenceScope,
+  PreferenceProviderDataChange,
+  PreferenceConfigurations,
+} from '@opensumi/ide-core-browser';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+import { IPreferenceTask } from '../common';
+
+// vscode 对语言的setting是根据这种格式来的
+// "[json]": { "editor.formatter": "xxxx" }
+// 对其进行兼容
+const OVERRIDE_PROPERTY = '\\[(.*)\\]$';
+export const OVERRIDE_PROPERTY_PATTERN = new RegExp(OVERRIDE_PROPERTY);
+
+@Injectable()
+export abstract class AbstractResourcePreferenceProvider extends PreferenceProvider {
+  protected preferences: IResolvedPreferences = {
+    default: {},
+    languageSpecific: {},
+  };
+
+  @Autowired(PreferenceSchemaProvider)
+  protected readonly schemaProvider: PreferenceSchemaProvider;
+
+  @Autowired(PreferenceConfigurations)
+  protected readonly configurations: PreferenceConfigurations;
+
+  @Autowired(IFileServiceClient)
+  protected readonly fileSystem: IFileServiceClient;
+
+  @Autowired(AppConfig)
+  private appConfig: AppConfig;
+
+  @Autowired(ILogger)
+  private logger: ILogger;
+
+  private preferenceThrottler: Throttler = new Throttler();
+  private preferenceTasks: IPreferenceTask[] = [];
+
+  constructor() {
+    super();
+    this.listen();
+  }
+
+  protected listen() {
+    if (this.fileSystem.handlesScheme(Schemes.file) && this.fileSystem.handlesScheme(Schemes.userStorage)) {
+      this.init();
+    } else {
+      const disposable = this.fileSystem.onFileProviderChanged((scheme: string[]) => {
+        if (this.fileSystem.handlesScheme(Schemes.file) && this.fileSystem.handlesScheme(Schemes.userStorage)) {
+          this.init();
+          disposable.dispose();
+        }
+      });
+    }
+  }
+
+  protected async init(): Promise<void> {
+    // 尝试读取preferences初始内容
+    this.readPreferences()
+      .then(() => this._ready.resolve())
+      .catch(() => this._ready.resolve());
+
+    const uri = this.getUri();
+    const watcher = await this.fileSystem.watchFileChanges(uri.parent);
+    // 配置文件改变时，重新读取配置
+    this.toDispose.push(watcher);
+    watcher.onFilesChanged((e: FileChange[]) => {
+      const effected = e.find((file) => file.uri.startsWith(uri.parent.toString()));
+      if (effected) {
+        return this.readPreferences();
+      }
+    });
+    this.toDispose.push(Disposable.create(() => this.reset()));
+  }
+
+  protected abstract getUri(): URI;
+  protected abstract getScope(): PreferenceScope;
+
+  getConfigUri(): URI;
+  getConfigUri(resourceUri: string | undefined): URI | undefined;
+  getConfigUri(resourceUri?: string): URI | undefined {
+    if (!resourceUri) {
+      return this.getUri();
+    }
+    // 获取configUri不需要等待配置读取完应该就可以读取
+    return this.contains(resourceUri) ? this.getUri() : undefined;
+  }
+
+  contains(resourceUri: string | undefined): boolean {
+    if (!resourceUri) {
+      return true;
+    }
+    const domain = this.getDomain();
+    if (!domain) {
+      return true;
+    }
+    const resourcePath = new URI(resourceUri).path;
+    return domain.some((uri) => new URI(uri).path.relativity(resourcePath) >= 0);
+  }
+
+  getPreferences(resourceUri?: string, language?: string) {
+    return this.loaded && this.contains(resourceUri) ? this.getOnePreference(language) : undefined;
+  }
+
+  getLanguagePreferences(resourceUri?: string) {
+    return this.loaded && this.contains(resourceUri) ? this.preferences.languageSpecific : undefined;
+  }
+
+  getOnePreference(language?: string): { [key: string]: any } {
+    if (language) {
+      return this.preferences.languageSpecific[language] || {};
+    } else {
+      return this.preferences.default;
+    }
+  }
+
+  async resolvePreferenceTasks(tasks: IPreferenceTask[]) {
+    const uri = this.getUri();
+    // 读取配置时同时更新一下资源信息，防止写入时对异步写入情况的错误判断
+    this.resource = this.fileSystem.getFileStat(uri.toString());
+    let resource = await this.resource;
+    let content = ((await this.readContents()) || '').trim();
+
+    // 将多次配置修改合并为一次文件内容变更
+    for (const task of tasks) {
+      const { path, value } = task;
+      if ((!content || path.length === 0) && isUndefined(value)) {
+        continue;
+      }
+      const formattingOptions = { tabSize: 2, insertSpaces: true, eol: '' };
+      const edits = jsoncparser.modify(content, path, value, { formattingOptions });
+      content = jsoncparser.applyEdits(content, edits);
+    }
+
+    try {
+      if (!resource) {
+        // 当资源不存在又需要写入数据时，创建对应文件
+        resource = await this.fileSystem.createFile(uri.toString());
+      }
+      await this.fileSystem.setContent(resource, content);
+      await this.readPreferences(content);
+      return true;
+    } catch (e) {
+      this.logger.error(`${e.toString()}`);
+      return false;
+    }
+  }
+
+  /**
+   * 配置变更队列处理函数
+   */
+  doSetPreferenceTask() {
+    const tasks = this.preferenceTasks.slice(0);
+    this.preferenceTasks = [];
+    return this.resolvePreferenceTasks(tasks);
+  }
+
+  async doSetPreference(key: string, value: any, resourceUri?: string, language?: string): Promise<boolean> {
+    if (!this.contains(resourceUri)) {
+      return false;
+    }
+    const path = this.getPath(key, language);
+    if (!path) {
+      return false;
+    }
+    // 这里将每次配置变更的参数构造为一个 IPreferenceTask
+    this.preferenceTasks.push({ path, key, value });
+    return await this.preferenceThrottler.queue<boolean>(this.doSetPreferenceTask.bind(this));
+  }
+
+  protected getPath(preferenceName: string, language?: string): string[] | undefined {
+    if (language) {
+      return [`[${language}]`, preferenceName];
+    }
+    return [preferenceName];
+  }
+
+  protected loaded = false;
+
+  protected async readPreferences(content?: string): Promise<void> {
+    const newContent = content || (await this.readContents());
+    this.loaded = !isUndefined(newContent);
+    const newPrefs = newContent ? this.getParsedContent(newContent) : { default: {}, languageSpecific: {} };
+    this.handlePreferenceChanges(newPrefs);
+  }
+
+  protected async readContents(): Promise<string | undefined> {
+    const uri = this.getUri();
+    try {
+      const { content } = await this.fileSystem.readFile(uri.toString());
+      return content.toString();
+    } catch (e) {
+      if (this.appConfig.useVSCodeWorkspaceConfiguration) {
+        // 当获取不到工作区配置时，在 `useVSCodeWorkspaceConfiguration` 开启的情况下，尝试获取 `.vscode` 下配置作为默认值
+        if (uri.scheme === Schemes.file) {
+          const vscodeConfigurationUri = uri.parent.parent
+            .resolve(VSCODE_WORKSPACE_CONFIGURATION_DIR_NAME)
+            .resolve(uri.displayName);
+          try {
+            const { content } = await this.fileSystem.readFile(vscodeConfigurationUri.toString());
+            return content.toString();
+          } catch (e) {
+            return undefined;
+          }
+        }
+      }
+      return undefined;
+    }
+  }
+
+  protected getParsedContent(content: string): IResolvedPreferences {
+    const jsonData = this.parse(content);
+
+    const preferences: IResolvedPreferences = {
+      default: {},
+      languageSpecific: {},
+    };
+    if (typeof jsonData !== 'object') {
+      return preferences;
+    }
+    for (const preferenceName of Object.keys(jsonData)) {
+      const preferenceValue = jsonData[preferenceName];
+      // 这里由于插件的schema注册较晚，在第一次获取配置时会校验不通过导致取不到值，读取暂时去掉校验逻辑
+      if (OVERRIDE_PROPERTY_PATTERN.test(preferenceName)) {
+        const language = preferenceName.match(OVERRIDE_PROPERTY_PATTERN)![1];
+        preferences.languageSpecific[language] = preferences.languageSpecific[language] || {};
+        // eslint-disable-next-line guard-for-in
+        for (const overriddenPreferenceName in preferenceValue) {
+          const overriddenValue = preferenceValue[overriddenPreferenceName];
+          preferences.languageSpecific[language][`${overriddenPreferenceName}`] = overriddenValue;
+        }
+      } else {
+        preferences.default[preferenceName] = preferenceValue;
+      }
+    }
+    return preferences;
+  }
+
+  protected validate(preferenceName: string, preferenceValue: any): boolean {
+    if (this.configurations.getPath(this.getUri()) !== this.configurations.getPaths()[0]) {
+      return true;
+    }
+    return isUndefined(preferenceValue) || this.schemaProvider.validate(preferenceName, preferenceValue).valid;
+  }
+
+  protected parse(content: string): any {
+    content = content.trim();
+    if (!content) {
+      return undefined;
+    }
+    const strippedContent = jsoncparser.stripComments(content);
+    return jsoncparser.parse(strippedContent);
+  }
+
+  protected handlePreferenceChanges(newPrefs: IResolvedPreferences): void {
+    const oldPrefs = Object.assign({}, this.preferences);
+    this.preferences = newPrefs;
+    const changes: PreferenceProviderDataChanges = this.collectChanges(this.preferences, oldPrefs);
+
+    if (Object.keys(changes.default).length > 0 || Object.keys(changes.languageSpecific).length > 0) {
+      this.emitPreferencesChangedEvent(changes);
+    }
+  }
+
+  protected reset(): void {
+    const preferences = this.preferences;
+    this.preferences = { default: {}, languageSpecific: {} };
+    const changes: PreferenceProviderDataChanges = this.collectChanges(this.preferences, preferences);
+
+    if (Object.keys(changes.default).length > 0 || Object.keys(changes.languageSpecific).length > 0) {
+      this.emitPreferencesChangedEvent(changes);
+    }
+  }
+
+  private collectChanges(newPref: IResolvedPreferences, oldPref: IResolvedPreferences): PreferenceProviderDataChanges {
+    const changes: PreferenceProviderDataChanges = {
+      default: this.collectOneChanges(newPref.default, oldPref.default),
+      languageSpecific: {},
+    };
+    const languages = new Set<string>([
+      ...Object.keys(newPref.languageSpecific),
+      ...Object.keys(oldPref.languageSpecific),
+    ]);
+    for (const language of languages) {
+      const languageChange = this.collectOneChanges(
+        newPref.languageSpecific[language],
+        oldPref.languageSpecific[language],
+      );
+      if (Object.keys(languageChange).length > 0) {
+        changes.languageSpecific[language] = languageChange;
+      }
+    }
+    return changes;
+  }
+
+  private collectOneChanges(
+    newPref: { [name: string]: any },
+    oldPref: { [name: string]: any },
+  ): { [preferenceName: string]: PreferenceProviderDataChange } {
+    const keys = new Set([...Object.keys(oldPref || {}), ...Object.keys(newPref || {})]);
+    const changes: { [preferenceName: string]: PreferenceProviderDataChange } = {};
+    const uri = this.getUri();
+
+    for (const prefName of keys) {
+      const oldValue = oldPref[prefName];
+      const newValue = newPref[prefName];
+      const schemaProperties = this.schemaProvider.getCombinedSchema().properties[prefName];
+      if (schemaProperties) {
+        const scope = schemaProperties.scope;
+        // do not emit the change event if the change is made out of the defined preference scope
+        if (!this.schemaProvider.isValidInScope(prefName, this.getScope())) {
+          this.logger.warn(
+            `Preference ${prefName} in ${uri} can only be defined in scopes: ${PreferenceScope.getScopeNames(
+              scope,
+            ).join(', ')}.`,
+          );
+          continue;
+        }
+      }
+      if (
+        (isUndefined(newValue) && oldValue !== newValue) ||
+        (isUndefined(oldValue) && newValue !== oldValue) || // JSONUtils.deepEqual() does not support handling `undefined`
+        !JSONUtils.deepEqual(oldValue, newValue)
+      ) {
+        changes[prefName] = {
+          preferenceName: prefName,
+          newValue,
+          oldValue,
+          scope: this.getScope(),
+          domain: this.getDomain(),
+        };
+      }
+    }
+    return changes;
+  }
+}

package/src/browser/folder-file-preference-provider.ts

@@ -0,0 +1,56 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { URI, PreferenceScope } from '@opensumi/ide-core-browser';
+import { FileStat } from '@opensumi/ide-file-service';
+import { IWorkspaceService } from '@opensumi/ide-workspace/lib/common';
+
+import { AbstractResourcePreferenceProvider } from './abstract-resource-preference-provider';
+
+export const FolderFilePreferenceProviderFactory = Symbol('FolderFilePreferenceProviderFactory');
+export type FolderFilePreferenceProviderFactory = (
+  options: FolderFilePreferenceProviderOptions,
+) => FolderFilePreferenceProvider;
+
+export const FolderFilePreferenceProviderOptions = Symbol('FolderFilePreferenceProviderOptions');
+export interface FolderFilePreferenceProviderOptions {
+  readonly folder: FileStat;
+  readonly configUri: URI;
+}
+
+/**
+ * 配置文件夹比如 `.sumi` 内可以存在多个这样的文件, 比如: settings.json, launch.json, tasks.json 等
+ */
+@Injectable()
+export class FolderFilePreferenceProvider extends AbstractResourcePreferenceProvider {
+  // 与 `launch.json` 等其他配置文件不同，options 会有所差异
+  @Autowired(FolderFilePreferenceProviderOptions)
+  protected readonly options: FolderFilePreferenceProviderOptions;
+
+  @Autowired(IWorkspaceService)
+  protected readonly workspaceService: IWorkspaceService;
+
+  // 缓存目录URI
+  private _folderUri: URI;
+
+  get folderUri(): URI {
+    if (!this._folderUri) {
+      this._folderUri = new URI(this.options.folder.uri);
+    }
+    return this._folderUri;
+  }
+
+  public getUri(): URI {
+    return this.options.configUri;
+  }
+
+  protected getScope(): PreferenceScope {
+    // 当在非工作区场景下时，采用PreferenceScope.Workspace作为配置作用域
+    if (!this.workspaceService.isMultiRootWorkspaceOpened) {
+      return PreferenceScope.Workspace;
+    }
+    return PreferenceScope.Folder;
+  }
+
+  getDomain(): string[] {
+    return [this.folderUri.toString()];
+  }
+}

package/src/browser/folders-preferences-provider.ts

@@ -0,0 +1,262 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import {
+  URI,
+  PreferenceProvider,
+  PreferenceResolveResult,
+  PreferenceConfigurations,
+  ILogger,
+} from '@opensumi/ide-core-browser';
+import { IFileServiceClient } from '@opensumi/ide-file-service/lib/common/file-service-client';
+import { IWorkspaceService } from '@opensumi/ide-workspace';
+
+import {
+  FolderFilePreferenceProvider,
+  FolderFilePreferenceProviderFactory,
+  FolderFilePreferenceProviderOptions,
+} from './folder-file-preference-provider';
+
+@Injectable()
+export class FoldersPreferencesProvider extends PreferenceProvider {
+  @Autowired(FolderFilePreferenceProviderFactory)
+  protected readonly FolderFilePreferenceProviderFactory: FolderFilePreferenceProviderFactory;
+
+  @Autowired(PreferenceConfigurations)
+  protected readonly configurations: PreferenceConfigurations;
+
+  @Autowired(IWorkspaceService)
+  protected readonly workspaceService: IWorkspaceService;
+
+  @Autowired(IFileServiceClient)
+  protected readonly fileSystem: IFileServiceClient;
+
+  @Autowired(ILogger)
+  protected readonly logger: ILogger;
+
+  protected readonly providers = new Map<string, FolderFilePreferenceProvider>();
+
+  constructor() {
+    super();
+    this.init();
+  }
+
+  protected async init(): Promise<void> {
+    await this.workspaceService.roots;
+
+    this.updateProviders();
+    this.workspaceService.onWorkspaceChanged(() => this.updateProviders());
+
+    const readyPromises: Promise<void>[] = [];
+    for (const provider of this.providers.values()) {
+      readyPromises.push(provider.ready.catch((e) => this.logger.error(e)));
+    }
+    if (readyPromises.length > 0) {
+      Promise.all(readyPromises).then(() => this._ready.resolve());
+    } else {
+      this._ready.resolve();
+    }
+  }
+
+  /**
+   * 根据当前工作区文件结构重新初始化配置项获取逻辑
+   *
+   * @protected
+   * @memberof FoldersPreferencesProvider
+   */
+  protected updateProviders(): void {
+    const roots = this.workspaceService.tryGetRoots();
+    const toDelete = new Set(this.providers.keys());
+    for (const folder of roots) {
+      // 这里根据当前工作区的根目录分别创建 `setting.json`, `launch.json`, `task.json` 等文件的 FolderPreferenceProvider
+      const folderUri = new URI(folder.uri);
+      for (const configPath of this.configurations.getPaths()) {
+        for (const configName of [...this.configurations.getSectionNames(), this.configurations.getConfigName()]) {
+          const configUri = this.configurations.createUri(folderUri, configPath, configName);
+          const key = configUri.toString();
+          toDelete.delete(key);
+          if (!this.providers.has(key)) {
+            const provider = this.createProvider({ folder, configUri });
+            this.providers.set(key, provider);
+          }
+        }
+      }
+    }
+
+    // 去重，移除旧的配置文件Provider
+    for (const key of toDelete) {
+      const provider = this.providers.get(key);
+      if (provider) {
+        this.providers.delete(key);
+        provider.dispose();
+      }
+    }
+  }
+
+  getConfigUri(resourceUri?: string): URI | undefined {
+    for (const provider of this.getFolderProviders(resourceUri)) {
+      const configUri = provider.getConfigUri(resourceUri);
+      if (this.configurations.isConfigUri(configUri)) {
+        return configUri;
+      }
+    }
+    return undefined;
+  }
+
+  getContainingConfigUri(resourceUri?: string): URI | undefined {
+    for (const provider of this.getFolderProviders(resourceUri)) {
+      const configUri = provider.getConfigUri();
+      if (this.configurations.isConfigUri(configUri) && provider.contains(resourceUri)) {
+        return configUri;
+      }
+    }
+    return undefined;
+  }
+
+  getDomain(): string[] {
+    return this.workspaceService.tryGetRoots().map((root) => root.uri);
+  }
+
+  doResolve<T>(preferenceName: string, resourceUri?: string, language?: string): PreferenceResolveResult<T> {
+    const result: PreferenceResolveResult<T> = {};
+    const groups = this.groupProvidersByConfigName(resourceUri);
+    for (const group of groups.values()) {
+      for (const provider of group) {
+        const { value, configUri } = provider.resolve<T>(preferenceName, resourceUri, language);
+        if (configUri && value !== undefined) {
+          result.configUri = configUri;
+          result.value = PreferenceProvider.merge(result.value as any, value as any) as any;
+          break;
+        }
+      }
+    }
+    return result;
+  }
+
+  getPreferences(resourceUri?: string, language?: string) {
+    let result;
+    const groups = this.groupProvidersByConfigName(resourceUri);
+    for (const group of groups.values()) {
+      for (const provider of group) {
+        if (provider.getConfigUri(resourceUri)) {
+          const preferences = provider.getPreferences(undefined, language);
+          if (preferences) {
+            result = PreferenceProvider.merge(result, preferences) as any;
+          }
+          break;
+        }
+      }
+    }
+    return result;
+  }
+
+  getLanguagePreferences(resourceUri?: string) {
+    let result;
+    const groups = this.groupProvidersByConfigName(resourceUri);
+    for (const group of groups.values()) {
+      for (const provider of group) {
+        if (provider.getConfigUri(resourceUri)) {
+          const preferences = provider.getLanguagePreferences();
+          if (preferences) {
+            result = PreferenceProvider.merge(result, preferences) as any;
+          }
+          break;
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * 根据传入的 preferenceName 对配置项进行值的更新
+   * 这里一个配置项，如 launch.json 可能对应多个 Provider，故需要遍历进行配置设置
+   *
+   * @param {string} preferenceName 配置项
+   * @param {*} value 值
+   * @param {string} [resourceUri] 资源路径
+   * @param {string} [language] 语言标识符
+   * @returns {Promise<boolean>}
+   * @memberof FoldersPreferencesProvider
+   */
+  async doSetPreference(preferenceName: string, value: any, resourceUri?: string, language?: string): Promise<boolean> {
+    const sectionName = preferenceName.split('.', 1)[0];
+    const configName = this.configurations.isSectionName(sectionName)
+      ? sectionName
+      : this.configurations.getConfigName();
+
+    const providers = this.getFolderProviders(resourceUri);
+    let configPath: string | undefined;
+
+    for (const provider of providers) {
+      if (configPath === undefined) {
+        const configUri = provider.getConfigUri(resourceUri);
+        if (configUri) {
+          configPath = this.configurations.getPath(configUri);
+        }
+      }
+      if (this.configurations.getName(provider.getConfigUri()) === configName) {
+        if (provider.getConfigUri(resourceUri)) {
+          // 当存在配置文件路径时，尝试执行设置配置
+          if (await provider.setPreference(preferenceName, value, resourceUri, language)) {
+            return true;
+          }
+        } else if (this.configurations.getPath(provider.getConfigUri()) === configPath) {
+          // 当存在配置文件父路径与当前传入的resourceUri所指定的配置文件父路径一致时，尝试执行设置配置
+          if (await provider.setPreference(preferenceName, value, resourceUri, language)) {
+            return true;
+          }
+        } else {
+          // 为不存在配置文件的配置尝试执行一次配置修改
+          if (await provider.setPreference(preferenceName, value, resourceUri, language)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  protected groupProvidersByConfigName(resourceUri?: string): Map<string, FolderFilePreferenceProvider[]> {
+    const groups = new Map<string, FolderFilePreferenceProvider[]>();
+    const providers = this.getFolderProviders(resourceUri);
+    for (const configName of [this.configurations.getConfigName(), ...this.configurations.getSectionNames()]) {
+      const group: any[] = [];
+      for (const provider of providers) {
+        if (this.configurations.getName(provider.getConfigUri()) === configName) {
+          group.push(provider);
+        }
+      }
+      groups.set(configName, group);
+    }
+    return groups;
+  }
+
+  protected getFolderProviders(resourceUri?: string): FolderFilePreferenceProvider[] {
+    if (!resourceUri) {
+      return [];
+    }
+    const resourcePath = new URI(resourceUri).path;
+    let folder: Readonly<{ relativity: number; uri?: string }> = { relativity: Number.MAX_SAFE_INTEGER };
+    const providers = new Map<string, FolderFilePreferenceProvider[]>();
+    for (const provider of this.providers.values()) {
+      const uri = provider.folderUri.toString();
+      const folderProviders = providers.get(uri) || [];
+      folderProviders.push(provider);
+      providers.set(uri, folderProviders);
+      const relativity = provider.folderUri.path.relativity(resourcePath);
+      if (relativity >= 0 && folder.relativity > relativity) {
+        folder = { relativity, uri };
+      }
+    }
+    return (folder.uri && providers.get(folder.uri)) || [];
+  }
+
+  protected createProvider(options: FolderFilePreferenceProviderOptions): FolderFilePreferenceProvider {
+    const provider = this.FolderFilePreferenceProviderFactory(options);
+    this.toDispose.push(provider);
+    this.toDispose.push(
+      provider.onDidPreferencesChanged((change) => {
+        this.emitPreferencesChangedEvent(change);
+      }),
+    );
+    return provider;
+  }
+}