@opensumi/ide-core-browser 2.21.13 → 2.22.0

package/src/preferences/preference-provider.ts

@@ -0,0 +1,414 @@
+import { Injectable } from '@opensumi/di';
+import {
+  IDisposable,
+  DisposableCollection,
+  Emitter,
+  Event,
+  URI,
+  Deferred,
+  isEmptyObject,
+  FileStat,
+} from '@opensumi/ide-core-common';
+import { PreferenceScope } from '@opensumi/ide-core-common/lib/preferences/preference-scope';
+
+import { JSONUtils, JSONValue } from '../utils';
+
+import { getExternalPreferenceProvider, getAllExternalProviders } from './early-preferences';
+import { PreferenceResolveResult } from './types';
+export interface IResolvedPreferences {
+  default: { [key: string]: any };
+  languageSpecific: {
+    [languageId: string]: { [key: string]: any };
+  };
+}
+export interface PreferenceProviderDataChange {
+  readonly preferenceName: string;
+  readonly newValue?: any;
+  readonly oldValue?: any;
+  readonly scope: PreferenceScope;
+  readonly domain?: string[];
+}
+
+export interface PreferenceProviderDataChanges {
+  default: {
+    [preferenceName: string]: PreferenceProviderDataChange;
+  };
+  languageSpecific: ILanguagePreferenceProviderDataChanges;
+}
+
+export interface ILanguagePreferenceProviderDataChanges {
+  [languageId: string]: {
+    [preferenceName: string]: PreferenceProviderDataChange;
+  };
+}
+
+function transformReverse(delegates: {
+  [delegated: string]: {
+    delegateTo: string;
+    transform?: (delegateValue: any) => any;
+  };
+}): {
+  [delegated: string]: {
+    delegated: string;
+    delegateTo: string;
+    transform?: (delegateValue: any) => any;
+  };
+} {
+  const res = {};
+  for (const key of Object.keys(delegates)) {
+    res[delegates[key].delegateTo] = {
+      delegated: key,
+      ...delegates[key],
+    };
+  }
+  return res;
+}
+
+@Injectable()
+export abstract class PreferenceProvider implements IDisposable {
+  public readonly name: string;
+
+  private readonly onDidPreferencesChangedEmitter = new Emitter<PreferenceProviderDataChanges>();
+  public readonly onDidPreferencesChanged: Event<PreferenceProviderDataChanges> =
+    this.onDidPreferencesChangedEmitter.event;
+
+  protected readonly toDispose = new DisposableCollection();
+
+  protected readonly _ready = new Deferred<void>();
+
+  public resource: Promise<FileStat | void>;
+
+  private _scope: PreferenceScope;
+
+  // preferenceDelegate 原则, delegate值优先，不改变原有 delegateTo 的行为
+  // 1. 当修改 delegate 设置值发生改变时，同时发出 delegate 和 delegateTo 的 change 事件。
+  // 2. 当尝试获取 delegateTo 的值时，会尝试先获取 delegate 的值，如果没有值，继续原来的逻辑。
+  // 3. 当尝试修改 delegateTo 的值时，删除 delegate 的值
+  // 4. 当尝试获取 delegate 的值时，如果 delegate 没有值， 尝试获取 delegateTo 的值
+  // 5. schema 只会检测改变后 delegatedTo 的值
+  // 6. 不对语言特定的设置生效
+  static PreferenceDelegates: {
+    [delegated: string]: {
+      delegateTo: string;
+      transform?: (delegatedValue: any) => any;
+      transformFrom?: (delegatedToValue: any) => any;
+    };
+  } = {
+    'workbench.colorTheme': {
+      delegateTo: 'general.theme',
+    },
+  };
+
+  static PreferenceDelegatesReverse: {
+    [delegated: string]: {
+      delegated: string;
+      delegateTo: string;
+      transform?: (delegatedValue: any) => any;
+      transformFrom?: (delegatedToValue: any) => any;
+    };
+  } = transformReverse(PreferenceProvider.PreferenceDelegates);
+
+  constructor() {
+    this.toDispose.push(this.onDidPreferencesChangedEmitter);
+  }
+
+  public asScope(scope: PreferenceScope) {
+    if (typeof this._scope !== 'undefined') {
+      return;
+    }
+    this._scope = scope;
+    // 如果 external provider 有监听器，监听
+    getAllExternalProviders().forEach(([preferenceName, provider]) => {
+      if (provider.onDidChange) {
+        provider.onDidChange((e) => {
+          if (e.scope === this._scope) {
+            this.emitPreferencesChangedEvent(
+              [
+                {
+                  preferenceName,
+                  scope: e.scope,
+                  newValue: e.newValue,
+                  oldValue: e.oldValue,
+                },
+              ],
+              true,
+            );
+          }
+        });
+      }
+    });
+  }
+
+  public dispose(): void {
+    this.toDispose.dispose();
+  }
+
+  /**
+   * 处理事件监听中接收到的Event数据对象
+   * 以便后续接收到数据后能确认来自那个配置项的值
+   */
+  protected emitPreferencesChangedEvent(
+    changes: PreferenceProviderDataChanges | PreferenceProviderDataChange[],
+    noFilterExternal?: boolean,
+  ): boolean {
+    let prefChanges: PreferenceProviderDataChanges;
+    if (Array.isArray(changes)) {
+      prefChanges = { default: {}, languageSpecific: {} };
+      for (const change of changes) {
+        prefChanges.default[change.preferenceName] = change;
+      }
+    } else {
+      prefChanges = changes;
+    }
+    if (typeof this._scope !== 'undefined') {
+      const preferenceNames = Object.keys(prefChanges.default);
+      // 只对scope preference provider做处理
+      for (const preferenceName of preferenceNames) {
+        const change = prefChanges.default[preferenceName];
+        if (PreferenceProvider.PreferenceDelegates[change.preferenceName]) {
+          const delegate = PreferenceProvider.PreferenceDelegates[change.preferenceName];
+          if (this.get(delegate.delegateTo) !== undefined && this.get(change.preferenceName) === undefined) {
+            // 这种情况不发出 delegateTo 的改变
+          } else {
+            prefChanges.default[delegate.delegateTo] = {
+              ...change,
+              oldValue: undefined,
+              newValue:
+                change.newValue !== undefined
+                  ? delegate.transform
+                    ? delegate.transform(change.newValue)
+                    : change.newValue
+                  : undefined,
+              preferenceName: delegate.delegateTo,
+            };
+          }
+        }
+        if (!noFilterExternal && !!getExternalPreferenceProvider(preferenceName)) {
+          // 过滤externalProvider管理的preference
+          delete prefChanges.default[preferenceName];
+        }
+        if (change.oldValue === change.newValue) {
+          delete prefChanges.default[preferenceName];
+        }
+      }
+    }
+    if (prefChanges && !isEmptyObject(prefChanges)) {
+      this.onDidPreferencesChangedEmitter.fire(prefChanges);
+      return true;
+    }
+    return false;
+  }
+
+  // @final 不要 override 这个
+  public get<T>(preferenceName: string, resourceUri?: string, language?: string): T | undefined {
+    if (PreferenceProvider.PreferenceDelegatesReverse[preferenceName]) {
+      const res = this.getDelegateToValueFromDelegated(preferenceName);
+      if (res !== undefined) {
+        return res;
+      }
+    }
+    const value = this.getWithoutDelegate<T>(preferenceName, resourceUri, language);
+    if (value === undefined && PreferenceProvider.PreferenceDelegates[preferenceName]) {
+      return this.getDelegatedValueFromDelegateTo(preferenceName);
+    } else {
+      return value;
+    }
+  }
+
+  public getWithoutDelegate<T>(preferenceName: string, resourceUri?: string, language?: string): T | undefined {
+    if (typeof this._scope !== 'undefined') {
+      const externalProvider = getExternalPreferenceProvider(preferenceName);
+      if (externalProvider) {
+        return externalProvider.get(this._scope);
+      }
+    }
+    return this.doGet<T>(preferenceName, resourceUri, language);
+  }
+
+  // 从delegateTo 获取 delegated
+  private getDelegatedValueFromDelegateTo(delegatedPreferenceName: string) {
+    const delegate = PreferenceProvider.PreferenceDelegates[delegatedPreferenceName];
+    const value = this.getWithoutDelegate(delegate!.delegateTo);
+    if (delegate.transformFrom) {
+      return delegate.transformFrom(value);
+    } else {
+      return value;
+    }
+  }
+
+  // 从delegate 获取 delegateTo
+  private getDelegateToValueFromDelegated(delegateToPreferenceName: string) {
+    const delegate = PreferenceProvider.PreferenceDelegatesReverse[delegateToPreferenceName];
+    const value = this.getWithoutDelegate(delegate!.delegated);
+    if (delegate.transform) {
+      return delegate.transform(value);
+    } else {
+      return value;
+    }
+  }
+
+  protected doGet<T>(preferenceName: string, resourceUri?: string, language?: string): T | undefined {
+    return this.doResolve<T>(preferenceName, resourceUri, language).value;
+  }
+
+  // @final 不要 override 这个
+  public resolve<T>(preferenceName: string, resourceUri?: string, language?: string): PreferenceResolveResult<T> {
+    if (PreferenceProvider.PreferenceDelegatesReverse[preferenceName]) {
+      const res = this.getDelegateToValueFromDelegated(preferenceName);
+      if (res !== undefined) {
+        return { value: res, scope: this._scope }; // FIXME: 这里好像scope有点问题，暂时不影响
+      }
+    }
+    if (typeof this._scope !== 'undefined') {
+      const externalProvider = getExternalPreferenceProvider(preferenceName);
+      if (externalProvider) {
+        return {
+          value: externalProvider.get(this._scope),
+          scope: this._scope,
+        };
+      }
+    }
+    const res = this.doResolve<T>(preferenceName, resourceUri, language);
+    if (res.value === undefined && PreferenceProvider.PreferenceDelegates[preferenceName]) {
+      return { value: this.getDelegatedValueFromDelegateTo(preferenceName), scope: this._scope }; // FIXME: 这里好像scope有点问题，暂时不影响
+    } else {
+      return res;
+    }
+  }
+
+  protected doResolve<T>(preferenceName: string, resourceUri?: string, language?: string): PreferenceResolveResult<T> {
+    const preferences = this.getPreferences(resourceUri, language);
+    if (!preferences) {
+      return {};
+    }
+    const value = preferences[preferenceName];
+    if (value !== undefined) {
+      return {
+        value,
+        configUri: this.getConfigUri(resourceUri),
+      };
+    }
+    return {};
+  }
+
+  /**
+   * 获取制定资源或语言的所有配置，当返回值为undefined时代表无应资源或语言配置
+   *
+   * @abstract
+   * @param {string} [resourceUri] 资源路径
+   * @param {string} [language] 语言标识符
+   * @returns {({ [p: string]: any } | undefined)}
+   * @memberof PreferenceProvider
+   */
+  public abstract getPreferences(resourceUri?: string, language?: string): { [p: string]: any } | undefined;
+
+  /**
+   * 获取制定资源或语言的所有语言配置，当返回值为undefined时代表无对应资源或语言配置
+   *
+   * @abstract
+   * @param {string} [resourceUri] 资源路径
+   * @param {string} [language] 语言标识符
+   * @returns {({ [language: string]: {[p: string]: any} } | undefined)}
+   * @memberof PreferenceProvider
+   */
+  public abstract getLanguagePreferences(
+    resourceUri?: string,
+    language?: string,
+  ): { [language: string]: { [p: string]: any } } | undefined;
+
+  public async setPreference(
+    preferenceName: string,
+    value: any,
+    resourceUri?: string,
+    language?: string,
+  ): Promise<boolean> {
+    // 对于我们 workbench.colorTheme -> general.theme 这种托管，
+    // 修改 workbench.colorTheme 为 'themeA' 的时候，get('general.theme')，会首先查看 workbench.colorTheme，
+    // 如果有值，则采用 workbench.colorTheme， 而不管配置文件中是否 general.theme 有值，
+    // 换言之，在 workbench.colorTheme  有值的情况下，general.theme 无论怎么修改都是无效的，
+    // 因此如果 setPreference('general.theme', 'themeA' ) 的话，必须先把 workbench.colorTheme 置空才能生效。
+    //
+    // 这种情况下，插件进程的 vscode.workspace.onDidConfigurationChange 会触发两次事件变化
+    // 一个为 general.theme, 一个为workbench.colorTheme
+    if (PreferenceProvider.PreferenceDelegatesReverse[preferenceName]) {
+      // 将delegate置空
+      const delegate = PreferenceProvider.PreferenceDelegatesReverse[preferenceName];
+      await this.setPreference(delegate.delegated, undefined);
+    }
+    if (typeof this._scope !== 'undefined') {
+      const externalProvider = getExternalPreferenceProvider(preferenceName);
+      if (externalProvider) {
+        try {
+          const oldValue = externalProvider.get(this._scope);
+          await externalProvider.set(value, this._scope);
+          // 如果外部provider没有监听器，帮助他发送改变事件
+          if (!externalProvider.onDidChange) {
+            this.emitPreferencesChangedEvent(
+              [
+                {
+                  preferenceName,
+                  scope: this._scope,
+                  oldValue,
+                  newValue: externalProvider.get(this._scope),
+                },
+              ],
+              true,
+            );
+          }
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+    }
+    return await this.doSetPreference(preferenceName, value, resourceUri, language);
+  }
+
+  protected abstract doSetPreference(
+    preferenceName: string,
+    value: any,
+    resourceUri?: string,
+    language?: string,
+  ): Promise<boolean>;
+
+  /**
+   * 返回promise，当 preference provider 已经可以提供配置时返回resolved
+   */
+  get ready() {
+    return this._ready.promise;
+  }
+
+  /**
+   * 默认返回undefined
+   */
+  public getDomain(): string[] | undefined {
+    return undefined;
+  }
+
+  /**
+   * 默认返回undefined
+   */
+  public getConfigUri(resourceUri?: string): URI | undefined {
+    return undefined;
+  }
+
+  public static merge(source: JSONValue | undefined, target: JSONValue): JSONValue {
+    if (source === undefined || !JSONUtils.isObject(source)) {
+      return JSONUtils.deepCopy(target);
+    }
+    if (JSONUtils.isPrimitive(target)) {
+      return {};
+    }
+    for (const key of Object.keys(target)) {
+      const value = (target as any)[key];
+      if (key in source) {
+        if (JSONUtils.isObject(source[key]) && JSONUtils.isObject(value)) {
+          this.merge(source[key], value);
+          continue;
+        }
+      }
+      source[key] = JSONUtils.deepCopy(value);
+    }
+    return source;
+  }
+}

package/src/preferences/preference-proxy.ts

@@ -0,0 +1,291 @@
+import { Disposable, Event, isObject, isUndefined, PreferenceSchema, PreferenceScope } from '@opensumi/ide-core-common';
+
+import { PreferenceService } from './types';
+
+export interface PreferenceChangeEvent<T> {
+  readonly preferenceName: keyof T;
+  readonly newValue?: T[keyof T];
+  readonly oldValue?: T[keyof T];
+  affects(resourceUri?: string, overrideIdentifier?: string): boolean;
+}
+
+export interface PreferenceProxyOptions {
+  /**
+   * 所有配置的默认前缀
+   */
+  prefix?: string;
+  /**
+   * 获取或设置配置的默认资源路径
+   */
+  resourceUri?: string;
+  /**
+   * 对齐VSCode实现，overrideIdentifier主要用于实现针对不同编辑器设置不同配置的能力
+   * 与原有的language设定一致
+   *
+   * 如 [markdown].editor.autoIndent、[json].editor.autoIndent 及 editor.autoIndent 等
+   */
+  overrideIdentifier?: string;
+  /**
+   * 用来指代获取一个配置时是否为“平面含义”上的获取
+   *
+   * 如：
+   * a.b.c 在flat模式下为单个配置的值
+   * deep模式下则可以为 a 配置下的 b 配置下的 c 的值
+   * both指代同时在两种配置模式下检索值
+   */
+  style?: 'flat' | 'deep' | 'both';
+}
+
+export interface PreferenceEventEmitter<T> {
+  readonly onPreferenceChanged: Event<PreferenceChangeEvent<T>>;
+  readonly ready: Promise<void>;
+}
+
+export interface PreferenceRetrieval<T> {
+  get<K extends keyof T>(preferenceName: K, defaultValue?: T[K], resourceUri?: string): T[K];
+}
+
+export type PreferenceProxy<T> = Readonly<T> & Disposable & PreferenceEventEmitter<T> & PreferenceRetrieval<T>;
+
+export function createPreferenceProxy<T>(
+  preferences: PreferenceService,
+  schema: PreferenceSchema,
+  options?: PreferenceProxyOptions,
+): PreferenceProxy<T> {
+  const opts = options || {};
+  const prefix = opts.prefix || '';
+  const style = opts.style || 'flat';
+  const isDeep = style === 'deep' || style === 'both';
+  const isFlat = style === 'both' || style === 'flat';
+  const onPreferenceChanged = (
+    listener: (e: PreferenceChangeEvent<T>) => any,
+    thisArgs?: any,
+    disposables?: Disposable[],
+  ) => {
+    const disposer = new Disposable();
+    disposer.addDispose(
+      preferences.onPreferencesChanged(
+        (changes) => {
+          for (const key of Object.keys(changes)) {
+            const e = changes[key];
+            const preferenceName: any = e.preferenceName;
+            if (preferenceName.startsWith(prefix)) {
+              if (schema.properties[preferenceName]) {
+                if (opts.resourceUri) {
+                  if (e.affects(opts.resourceUri)) {
+                    if (
+                      opts.overrideIdentifier &&
+                      !preferences.hasLanguageSpecific(preferenceName, opts.overrideIdentifier, opts.resourceUri)
+                    ) {
+                      continue;
+                    }
+                    listener(e as any);
+                  }
+                } else {
+                  listener(e as any);
+                }
+              }
+            }
+          }
+        },
+        thisArgs,
+        disposables,
+      ),
+    );
+    // 添加语言相关 changes 变更
+    if (opts.overrideIdentifier) {
+      disposer.addDispose(
+        preferences.onLanguagePreferencesChanged(
+          (event) => {
+            if (event.overrideIdentifier === opts.overrideIdentifier) {
+              for (const key of Object.keys(event.changes)) {
+                const e = event.changes[key];
+                const preferenceName: any = e.preferenceName;
+                if (preferenceName.startsWith(prefix)) {
+                  if (schema.properties[preferenceName]) {
+                    if (opts.resourceUri) {
+                      if (e.affects(opts.resourceUri)) {
+                        listener(e as any);
+                      }
+                    } else {
+                      listener(e as any);
+                    }
+                  }
+                }
+              }
+            }
+          },
+          thisArgs,
+          disposables,
+        ),
+      );
+    }
+    return disposer;
+  };
+
+  const unsupportedOperation = (_: any, __: string) => {
+    throw new Error('Unsupported operation');
+  };
+
+  const getValue: PreferenceRetrieval<any>['get'] = (
+    preferenceName: any,
+    defaultValue,
+    resourceUri,
+    overrideIdentifier?: string,
+  ) =>
+    preferences.get(
+      preferenceName,
+      defaultValue,
+      resourceUri || opts.resourceUri,
+      overrideIdentifier || opts.overrideIdentifier,
+    );
+
+  const ownKeys: () => string[] = () => {
+    const properties: string[] = [];
+    for (const p of Object.keys(schema.properties)) {
+      if (p.startsWith(prefix)) {
+        const idx = p.indexOf('.', prefix.length);
+        if (idx !== -1 && isDeep) {
+          const pre = p.substr(prefix.length, idx - prefix.length);
+          if (properties.indexOf(pre) === -1) {
+            properties.push(pre);
+          }
+        }
+        const prop = p.substr(prefix.length);
+        if (isFlat || prop.indexOf('.') === -1) {
+          properties.push(prop);
+        }
+      }
+    }
+    return properties;
+  };
+
+  const set: (target: any, prop: string, value: any, receiver: any) => boolean = (
+    _,
+    property: string | symbol | number,
+    value: any,
+  ) => {
+    if (typeof property !== 'string') {
+      throw new Error(`unexpected property: ${String(property)}`);
+    }
+    if (style === 'deep' && property.indexOf('.') !== -1) {
+      return false;
+    }
+    const fullProperty = prefix ? prefix + property : property;
+    if (schema.properties[fullProperty]) {
+      preferences.set(fullProperty, value, PreferenceScope.Default);
+      return true;
+    }
+    const newPrefix = fullProperty + '.';
+    for (const p of Object.keys(schema.properties)) {
+      if (p.startsWith(newPrefix)) {
+        const subProxy: { [k: string]: any } = createPreferenceProxy(preferences, schema, {
+          prefix: newPrefix,
+          resourceUri: opts.resourceUri,
+          overrideIdentifier: opts.overrideIdentifier,
+          style,
+        });
+        for (const k of Object.keys(value)) {
+          subProxy[k] = value[k];
+        }
+      }
+    }
+    return false;
+  };
+
+  const get: (target: any, prop: string) => any = (_, property: string | symbol | number) => {
+    if (typeof property !== 'string') {
+      throw new Error(`unexpected property: ${String(property)}`);
+    }
+    const fullProperty = prefix ? prefix + property : property;
+    if (isFlat || property.indexOf('.') === -1) {
+      if (schema.properties[fullProperty]) {
+        return preferences.get(fullProperty, undefined, opts.resourceUri, opts.overrideIdentifier);
+      }
+    }
+    if (property === 'onPreferenceChanged') {
+      return onPreferenceChanged;
+    }
+    if (property === 'dispose') {
+      return () => {
+        /* do nothing */
+      };
+    }
+    if (property === 'ready') {
+      return preferences.ready;
+    }
+    if (property === 'get') {
+      return getValue;
+    }
+    if (property === 'toJSON') {
+      return toJSON();
+    }
+    if (isDeep) {
+      const newPrefix = fullProperty + '.';
+      for (const p of Object.keys(schema.properties)) {
+        // 这里实际上要求 Configuration 在注册的时候声明全量配置名
+        // 如，获取 a.b, 则要求 Configuration 声明时必须为 a.b.c
+        if (p.startsWith(newPrefix)) {
+          return createPreferenceProxy(preferences, schema, {
+            prefix: newPrefix,
+            resourceUri: opts.resourceUri,
+            overrideIdentifier: opts.overrideIdentifier,
+            style,
+          });
+        }
+      }
+
+      // 升级 Monaco 0.20.0 版本后，Monaco 中的ConfigurationService会尝试通过配置全称获取配置值
+      // 如，直接获取 a.b.c.d 配置值
+      // 下面的逻辑兼容了通过 a.b 获取 a.b.c， a.b.c.d 的方式
+      let value;
+      let parentSegment = fullProperty;
+      const segments: string[] = [];
+      for (let index; parentSegment && isUndefined(value); ) {
+        index = parentSegment.lastIndexOf('.');
+        // 查找到对应值后退出查询
+        segments.push(parentSegment.substring(index + 1));
+        parentSegment = parentSegment.substring(0, index);
+        if (parentSegment in schema.properties) {
+          value = get(_, parentSegment);
+        }
+      }
+
+      let segment;
+      while (isObject(value) && (segment = segments.pop())) {
+        // 进一步遍历获取配置值
+        value = value[segment];
+      }
+      return segments.length ? undefined : value;
+    }
+    return undefined;
+  };
+
+  const toJSON = () => {
+    const result: any = {};
+    for (const k of ownKeys()) {
+      result[k] = get(undefined, k);
+    }
+    return result;
+  };
+
+  return new Proxy(
+    {},
+    {
+      get,
+      ownKeys,
+      getOwnPropertyDescriptor: (_, property: string) => {
+        if (ownKeys().indexOf(property) !== -1) {
+          return {
+            enumerable: true,
+            configurable: true,
+          };
+        }
+        return {};
+      },
+      set,
+      deleteProperty: unsupportedOperation,
+      defineProperty: unsupportedOperation,
+    },
+  );
+}

package/src/preferences/preference-scope.ts

@@ -0,0 +1,3 @@
+import { PreferenceScope } from '@opensumi/ide-core-common/lib/preferences/preference-scope';
+
+export { PreferenceScope };