@opensumi/ide-core-browser 2.21.8-rc-1670567192.0 → 2.21.8

package/src/opener/opener.service.ts

@@ -1,66 +0,0 @@
-import { Injectable, Autowired } from '@opensumi/di';
-import { URI, ILogger } from '@opensumi/ide-core-common';
-
-import { DefaultOpener } from './default-opener';
-
-import { IOpenerService, IOpener } from '.';
-
-@Injectable()
-export class OpenerService implements IOpenerService {
-  @Autowired(ILogger)
-  private logger: ILogger;
-
-  @Autowired(DefaultOpener)
-  private defaultOpener: IOpener;
-
-  private openers: IOpener[] = [];
-
-  private async getOpeners(uri: URI) {
-    const filterResults = await Promise.all(
-      this.openers.map(async (opener) => {
-        try {
-          if (opener.handleURI) {
-            return await opener.handleURI(uri);
-          }
-          return await opener.handleScheme(uri.scheme);
-        } catch (e) {
-          this.logger.error(e);
-          return false;
-        }
-      }),
-    );
-    return this.openers.filter((_, index) => filterResults[index]);
-  }
-
-  public registerOpener(opener: IOpener) {
-    this.openers.push(opener);
-    return {
-      dispose: () => {
-        const index = this.openers.indexOf(opener);
-        if (index !== -1) {
-          this.openers.splice(index, 1);
-        }
-      },
-    };
-  }
-
-  async open(uri: URI | string): Promise<boolean> {
-    if (typeof uri === 'string') {
-      uri = URI.parse(uri);
-    }
-    const openers = await this.getOpeners(uri);
-
-    for (const opener of openers) {
-      const handled = await opener.open(uri);
-      if (handled) {
-        return true;
-      }
-    }
-
-    return this.defaultOpener.open(uri);
-  }
-
-  dispose() {
-    this.openers = [];
-  }
-}

package/src/preferences/early-preferences.ts

@@ -1,117 +0,0 @@
-import { PreferenceItem, Event, GeneralSettingsId, getLanguageId } from '@opensumi/ide-core-common';
-
-import { IPreferences } from '../bootstrap';
-
-import { PreferenceProvider } from './preference-provider';
-import { PreferenceScope } from './preference-scope';
-
-// 这些设置选项生效时间太早,并且可能在 app 生命周期外生效，不能只由 preference 服务进行管理
-export interface IExternalPreferenceProvider<T = any> {
-  get(scope: PreferenceScope): T | undefined;
-  set(value: T, scope: PreferenceScope): void;
-  onDidChange?: Event<{ newValue?: T; oldValue?: T; scope: PreferenceScope }>;
-}
-
-const providers = new Map<string, IExternalPreferenceProvider>();
-
-export function registerExternalPreferenceProvider<T>(name: string, provider: IExternalPreferenceProvider<T>) {
-  if (providers.get(name)) {
-    return; // 不可覆盖，先注册的生效
-  }
-  providers.set(name, provider);
-}
-
-export function getExternalPreferenceProvider(name: string) {
-  let provider = providers.get(name);
-  if (!provider) {
-    // 尝试使用delegate的配置名获取
-    const delegate = PreferenceProvider.PreferenceDelegates[name];
-    if (delegate) {
-      provider = providers.get(delegate.delegateTo);
-    }
-  }
-  return provider;
-}
-
-export function getPreferenceThemeId(): string {
-  return getExternalPreference<string>(GeneralSettingsId.Theme).value as string;
-}
-
-export function getPreferenceIconThemeId(): string {
-  return getExternalPreference<string>(GeneralSettingsId.Icon).value as string;
-}
-
-/**
- * 如果要判断当前语言，请使用 `getLanguageId` 来判断。
- * 因为集成方可能会在集成后自己设置后调用 `setLanguageId` 来更新默认语言，所以统一收口到 `getLanguageId`。
- */
-export function getPreferenceLanguageId(defaultPreferences?: IPreferences): string {
-  // 因为语言加载的时机比较早，因此会优先从 defaultPreferences 里面读取
-  const langFromDefaultPreferences = defaultPreferences && defaultPreferences[GeneralSettingsId.Language];
-  return (
-    langFromDefaultPreferences || getExternalPreference<string>(GeneralSettingsId.Language).value || getLanguageId()
-  );
-}
-
-// 默认使用 localStorage
-export function registerLocalStorageProvider(key: string, workspaceFolder?: string) {
-  function getScopePrefix(scope: PreferenceScope) {
-    if (scope === PreferenceScope.Workspace) {
-      return workspaceFolder;
-    }
-    return scope;
-  }
-  registerExternalPreferenceProvider<string>(key, {
-    set: (value, scope) => {
-      if (scope >= PreferenceScope.Folder) {
-        // earlyPreference不支持针对作用域大于等于Folder的值设置
-        return;
-      }
-
-      if (!workspaceFolder && scope > PreferenceScope.Default) {
-        // 不传入 workspaceDir 则只支持全局设置
-        return;
-      }
-
-      if ((global as any).localStorage) {
-        if (value !== undefined) {
-          localStorage.setItem(getScopePrefix(scope) + `:${key}`, value);
-        } else {
-          localStorage.removeItem(getScopePrefix(scope) + `:${key}`);
-        }
-      }
-    },
-    get: (scope) => {
-      if ((global as any).localStorage) {
-        return localStorage.getItem(getScopePrefix(scope) + `:${key}`) || undefined;
-      }
-    },
-  });
-}
-
-export function getExternalPreference<T>(
-  preferenceName: string,
-  schema?: PreferenceItem,
-  untilScope?: PreferenceScope,
-): { value: T | undefined; scope: PreferenceScope } {
-  const scopes = untilScope
-    ? PreferenceScope.getReversedScopes().filter((s) => s <= untilScope)
-    : PreferenceScope.getReversedScopes();
-  for (const scope of scopes) {
-    const value = providers.get(preferenceName)?.get(scope);
-    if (value !== undefined) {
-      return {
-        value,
-        scope,
-      };
-    }
-  }
-  return {
-    value: schema && schema.default,
-    scope: PreferenceScope.Default,
-  };
-}
-
-export function getAllExternalProviders(): Array<[string, IExternalPreferenceProvider]> {
-  return Array.from(providers.entries());
-}

package/src/preferences/index.ts

@@ -1,9 +0,0 @@
-export * from './preference-configurations';
-export * from './preference-contribution';
-export * from './preference-provider';
-export * from './preference-scope';
-export * from './preference-service';
-export * from './preference-proxy';
-export * from './early-preferences';
-export * from './types';
-export * from './settings';

package/src/preferences/preference-configurations.ts

@@ -1,77 +0,0 @@
-import { Injectable, Autowired, Injector } from '@opensumi/di';
-import { URI, createContributionProvider } from '@opensumi/ide-core-common';
-import { ContributionProvider, DEFAULT_WORKSPACE_CONFIGURATION_DIR_NAME } from '@opensumi/ide-core-common';
-
-import { AppConfig } from '../react-providers/config-provider';
-
-export const PreferenceConfiguration = Symbol('PreferenceConfiguration');
-
-export interface PreferenceConfiguration {
-  name: string;
-}
-
-export function injectPreferenceConfigurations(injector: Injector): void {
-  createContributionProvider(injector, PreferenceConfiguration);
-  injector.addProviders({
-    token: PreferenceConfigurations,
-    useClass: PreferenceConfigurations,
-  });
-}
-
-@Injectable()
-export class PreferenceConfigurations {
-  @Autowired(AppConfig)
-  private readonly appConfig: AppConfig;
-
-  @Autowired(PreferenceConfiguration)
-  private readonly preferenceConfigurationProvider: ContributionProvider<PreferenceConfiguration>;
-
-  getPaths(): string[] {
-    if (this.appConfig.workspacePreferenceDirName) {
-      return [this.appConfig.workspacePreferenceDirName];
-    } else if (this.appConfig.preferenceDirName) {
-      return [this.appConfig.preferenceDirName];
-    }
-    return [DEFAULT_WORKSPACE_CONFIGURATION_DIR_NAME];
-  }
-
-  public getConfigName(): string {
-    return 'settings';
-  }
-
-  protected sectionNames: string[] | undefined;
-  public getSectionNames(): string[] {
-    if (!this.sectionNames) {
-      this.sectionNames = this.preferenceConfigurationProvider.getContributions().map((p) => p.name);
-    }
-    return this.sectionNames;
-  }
-
-  public isSectionName(name: string): boolean {
-    return this.getSectionNames().indexOf(name) !== -1;
-  }
-
-  public isSectionUri(configUri: URI | undefined): boolean {
-    return !!configUri && this.isSectionName(this.getName(configUri));
-  }
-
-  public isConfigUri(configUri: URI | undefined): boolean {
-    return !!configUri && this.getName(configUri) === this.getConfigName();
-  }
-
-  public getName(configUri: URI): string {
-    return configUri.path.name;
-  }
-
-  public getPath(configUri: URI): string {
-    return configUri.parent.path.base;
-  }
-
-  public createUri(
-    folder: URI,
-    configPath: string = this.getPaths()[0],
-    configName: string = this.getConfigName(),
-  ): URI {
-    return folder.resolve(configPath).resolve(configName + '.json');
-  }
-}

package/src/preferences/preference-contribution.ts

@@ -1,401 +0,0 @@
-import Ajv from 'ajv';
-
-import { Injectable, Autowired, Injector } from '@opensumi/di';
-import {
-  Mutable,
-  ContributionProvider,
-  Emitter,
-  Event,
-  ILogger,
-  Disposable,
-  IDisposable,
-} from '@opensumi/ide-core-common';
-import {
-  PreferenceSchema,
-  PreferenceSchemaProperties,
-  PreferenceDataSchema,
-  PreferenceItem,
-  PreferenceSchemaProperty,
-  PreferenceDataProperty,
-  JsonType,
-} from '@opensumi/ide-core-common/lib/preferences/preference-schema';
-
-import { AppConfig } from '../react-providers/config-provider';
-
-import { PreferenceConfigurations, injectPreferenceConfigurations } from './preference-configurations';
-import { PreferenceProvider, PreferenceProviderDataChange, IResolvedPreferences } from './preference-provider';
-import { PreferenceScope } from './preference-scope';
-
-export {
-  PreferenceSchema,
-  PreferenceSchemaProperties,
-  PreferenceDataSchema,
-  PreferenceItem,
-  PreferenceSchemaProperty,
-  PreferenceDataProperty,
-  JsonType,
-};
-
-export const PreferenceContribution = Symbol('PreferenceContribution');
-export interface PreferenceContribution {
-  readonly schema: PreferenceSchema;
-}
-
-export function injectPreferenceSchemaProvider(injector: Injector): void {
-  injectPreferenceConfigurations(injector);
-  injector.addProviders({
-    token: PreferenceSchemaProvider,
-    useClass: PreferenceSchemaProvider,
-  });
-  injector.addProviders({
-    token: PreferenceProvider,
-    tag: PreferenceScope.Default,
-    useClass: DefaultPreferenceProvider,
-  });
-}
-
-export interface OverridePreferenceName {
-  preferenceName: string;
-  overrideIdentifier: string;
-}
-
-export namespace OverridePreferenceName {
-  export function is(arg: any): arg is OverridePreferenceName {
-    return !!arg && typeof arg === 'object' && 'preferenceName' in arg && 'overrideIdentifier' in arg;
-  }
-}
-
-const OVERRIDE_PROPERTY = '\\[(.*)\\]$';
-export const OVERRIDE_PROPERTY_PATTERN = new RegExp(OVERRIDE_PROPERTY);
-
-@Injectable()
-export class PreferenceSchemaProvider extends PreferenceProvider {
-  @Autowired(PreferenceContribution)
-  protected readonly preferenceContributions: ContributionProvider<PreferenceContribution>;
-  private _validateFunction: Ajv.ValidateFunction | undefined;
-
-  @Autowired(PreferenceConfigurations)
-  protected readonly configurations: PreferenceConfigurations;
-
-  @Autowired(ILogger)
-  protected readonly logger: ILogger;
-
-  @Autowired(AppConfig)
-  protected readonly appConfig: AppConfig;
-
-  protected preferences: { [name: string]: any } = {};
-  protected combinedSchema: PreferenceDataSchema = { properties: {}, patternProperties: {} };
-  protected readonly onDidPreferenceSchemaChangedEmitter = new Emitter<void>();
-  public readonly onDidPreferenceSchemaChanged: Event<void> = this.onDidPreferenceSchemaChangedEmitter.event;
-
-  private validationFunctions = new Map<string, Ajv.ValidateFunction>();
-
-  protected fireDidPreferenceSchemaChanged(): void {
-    this.onDidPreferenceSchemaChangedEmitter.fire(undefined);
-  }
-
-  protected get validateFunction(): Ajv.ValidateFunction {
-    if (!this._validateFunction) {
-      this.doUpdateValidate();
-    }
-    return this._validateFunction!;
-  }
-
-  constructor() {
-    super();
-    this.init();
-
-    this.toDispose.push(
-      Disposable.create(() => {
-        this.preferences = {};
-        this.validationFunctions.clear();
-        this.combinedSchema = { properties: {}, patternProperties: {} };
-      }),
-    );
-
-    this.toDispose.push(this.onDidPreferenceSchemaChangedEmitter);
-  }
-
-  protected init(): void {
-    this.preferenceContributions?.getContributions().forEach((contrib) => {
-      this.doSetSchema(contrib.schema);
-    });
-    this.combinedSchema.additionalProperties = false;
-    this.updateValidate();
-    this.onDidPreferencesChanged(() => this.updateValidate());
-    this._ready.resolve();
-  }
-
-  protected doUnsetSchema(changes: PreferenceProviderDataChange[]): PreferenceProviderDataChange[] {
-    const inverseChanges: PreferenceProviderDataChange[] = [];
-    for (const change of changes) {
-      const preferenceName = change.preferenceName;
-      const newValue = change.oldValue;
-      const oldValue = change.newValue;
-      const { scope, domain } = change;
-      const inverseChange: Mutable<PreferenceProviderDataChange> = { preferenceName, oldValue, scope, domain };
-
-      delete this.combinedSchema.properties[preferenceName];
-
-      if (typeof newValue === undefined) {
-        delete this.preferences[preferenceName];
-      } else {
-        inverseChange.newValue = newValue;
-        this.preferences[preferenceName] = newValue;
-      }
-      inverseChanges.push(inverseChange);
-    }
-    return inverseChanges;
-  }
-
-  protected doSetSchema(schema: PreferenceSchema, override?: boolean): PreferenceProviderDataChange[] {
-    const scope = PreferenceScope.Default;
-    const domain = this.getDomain();
-    const changes: PreferenceProviderDataChange[] = [];
-    const defaultScope = PreferenceSchema.getDefaultScope(schema);
-    const overridable = schema.overridable || false;
-    for (const preferenceName of Object.keys(schema.properties)) {
-      if (this.combinedSchema.properties[preferenceName] && !override) {
-        this.logger.warn('Preference name collision detected in the schema for property: ' + preferenceName);
-        continue;
-      } else {
-        const schemaProps = PreferenceDataProperty.fromPreferenceSchemaProperty(
-          schema.properties[preferenceName],
-          defaultScope,
-        );
-        if (typeof schemaProps.overridable !== 'boolean' && overridable) {
-          schemaProps.overridable = true;
-        }
-        this.combinedSchema.properties[preferenceName] = schemaProps;
-        this.unsupportedPreferences.delete(preferenceName);
-
-        const value = (schemaProps.defaultValue = this.getDefaultValue(schemaProps, preferenceName));
-        changes.push(this.doSetPreferenceValue(preferenceName, value, { scope, domain }));
-      }
-    }
-    return changes;
-  }
-
-  protected doSetPreferenceValue(
-    preferenceName: string,
-    newValue: any,
-    {
-      scope,
-      domain,
-    }: {
-      scope: PreferenceScope;
-      domain?: string[];
-    },
-  ): PreferenceProviderDataChange {
-    const oldValue = this.preferences[preferenceName];
-    this.preferences[preferenceName] = newValue;
-    return { preferenceName, oldValue, newValue, scope, domain };
-  }
-
-  protected getDefaultValue(property: PreferenceItem): any;
-  // eslint-disable-next-line @typescript-eslint/unified-signatures
-  protected getDefaultValue(property: PreferenceItem, preferenceName: string): any;
-  protected getDefaultValue(property: PreferenceItem, preferenceName?: string): any {
-    if (preferenceName && this.appConfig.defaultPreferences && preferenceName in this.appConfig.defaultPreferences) {
-      return this.appConfig.defaultPreferences[preferenceName];
-    }
-    if (property.defaultValue !== undefined) {
-      return property.defaultValue;
-    }
-    if (property.default !== undefined) {
-      return property.default;
-    }
-    const type = Array.isArray(property.type) ? property.type[0] : property.type;
-    switch (type) {
-      case 'boolean':
-        return false;
-      case 'integer':
-      case 'number':
-        return 0;
-      case 'string':
-        return '';
-      case 'array':
-        return [];
-      case 'object':
-        return {};
-    }
-    return null;
-  }
-
-  protected updateValidate(): void {
-    this._validateFunction = undefined;
-  }
-
-  private doUpdateValidate(): void {
-    const schema = {
-      ...this.combinedSchema,
-      properties: {
-        ...this.combinedSchema.properties,
-      },
-    };
-    for (const sectionName of this.configurations.getSectionNames()) {
-      delete schema.properties[sectionName];
-    }
-    this._validateFunction = new Ajv().compile(schema);
-  }
-
-  protected readonly unsupportedPreferences = new Set<string>();
-
-  public validate(name: string, value: any): { valid: boolean; reason?: string } {
-    if (this.configurations.isSectionName(name)) {
-      return { valid: true };
-    }
-    // 对于不存在的先过
-    if (!this.getPreferenceProperty(name)) {
-      return { valid: true };
-    }
-    if (!this.validationFunctions.has(name)) {
-      this.validationFunctions.set(name, new Ajv().compile(this.getPreferenceProperty(name)!));
-    }
-    // 验证是否合并schema配置
-    const validationFn = this.validationFunctions.get(name)!;
-    const result = validationFn(value) as boolean;
-    if (!result && !(name in this.combinedSchema.properties)) {
-      // 避免每次发生变化时重复提示警告
-      if (!this.unsupportedPreferences.has(name)) {
-        this.unsupportedPreferences.add(name);
-        this.logger.warn(`"${name}" preference is not supported`);
-      }
-    }
-    const errorReason =
-      validationFn.errors && validationFn.errors[0] ? normalizeAjvValidationError(validationFn.errors[0]) : undefined;
-    return { valid: result, reason: errorReason };
-  }
-
-  public getCombinedSchema(): PreferenceDataSchema {
-    return this.combinedSchema;
-  }
-
-  public setSchema(schema: PreferenceSchema, override?: boolean): IDisposable {
-    const changes = this.doSetSchema(schema, override);
-
-    if (!changes.length) {
-      return Disposable.NULL;
-    }
-
-    this.fireDidPreferenceSchemaChanged();
-    this.emitPreferencesChangedEvent(changes);
-
-    return Disposable.create(() => {
-      const inverseChanges = this.doUnsetSchema(changes);
-      if (!inverseChanges.length) {
-        return;
-      }
-      this.fireDidPreferenceSchemaChanged();
-      this.emitPreferencesChangedEvent(inverseChanges);
-    });
-  }
-
-  public getPreferences(): { [name: string]: any } {
-    return this.preferences;
-  }
-
-  getLanguagePreferences(resourceUri?: string) {
-    return {};
-  }
-
-  public async doSetPreference(): Promise<boolean> {
-    return false;
-  }
-
-  public isValidInScope(preferenceName: string, scope: PreferenceScope): boolean {
-    const preference = this.getPreferenceProperty(preferenceName);
-    if (preference) {
-      return preference.scope! >= scope;
-    }
-    return false;
-  }
-
-  public *getPreferenceNames(): IterableIterator<string> {
-    // eslint-disable-next-line guard-for-in
-    for (const preferenceName in this.combinedSchema.properties) {
-      yield preferenceName;
-    }
-  }
-
-  public getPreferenceProperty(preferenceName: string): PreferenceItem | undefined {
-    return this.combinedSchema.properties[preferenceName];
-  }
-}
-
-@Injectable()
-export class DefaultPreferenceProvider extends PreferenceProvider {
-  @Autowired(PreferenceSchemaProvider)
-  public preferenceSchemaProvider: PreferenceSchemaProvider;
-
-  private preferences: IResolvedPreferences = {
-    default: {},
-    languageSpecific: {},
-  };
-
-  constructor() {
-    super();
-    this.init();
-  }
-
-  protected async init() {
-    this._ready.resolve();
-  }
-
-  public getPreferences(resourceUri?: string, language?: string) {
-    if (!language) {
-      return {
-        ...this.preferenceSchemaProvider.getPreferences(),
-        ...this.preferences.default,
-      };
-    } else {
-      return this.preferences.languageSpecific[language] || {};
-    }
-  }
-
-  getLanguagePreferences(resourceUri?: string) {
-    return this.preferences.languageSpecific;
-  }
-
-  public async doSetPreference(key: string, value: any, resourceUri?: string, language?: string) {
-    if (!language) {
-      const oldValue = this.preferences.default[key];
-      this.preferences.default[key] = value;
-      this.handlePreferenceChanges(key, value, oldValue);
-    } else {
-      if (!this.preferences.languageSpecific[language]) {
-        this.preferences.languageSpecific[language] = {};
-      }
-      const oldValue = this.preferences.languageSpecific[language][key];
-      this.preferences.languageSpecific[language][key] = value;
-      this.handlePreferenceChanges(key, value, oldValue, language);
-    }
-    return true;
-  }
-
-  public handlePreferenceChanges(preferenceName: string, newValue: any, oldValue: any, language?: string) {
-    const prefChange: PreferenceProviderDataChange = {
-      preferenceName,
-      newValue,
-      oldValue,
-      scope: PreferenceScope.Default,
-      domain: undefined,
-    };
-    if (language) {
-      this.emitPreferencesChangedEvent({
-        default: {},
-        languageSpecific: {
-          [language]: {
-            [preferenceName]: prefChange,
-          },
-        },
-      });
-    } else {
-      this.emitPreferencesChangedEvent([prefChange]);
-    }
-  }
-}
-
-function normalizeAjvValidationError(error: Ajv.ErrorObject) {
-  return error.message;
-}