@opensumi/ide-core-browser 2.21.13-rc-1673328992.0 → 2.21.13

package/src/opener/http-opener.ts

@@ -1,25 +0,0 @@
-import { Injectable, Autowired } from '@opensumi/di';
-import { URI, Schemes } from '@opensumi/ide-core-common';
-
-import { IWindowService } from '../window';
-
-import { IOpener } from '.';
-
-@Injectable()
-export class HttpOpener implements IOpener {
-  static standardSupportedLinkSchemes = new Set([Schemes.http, Schemes.https, Schemes.mailto]);
-
-  @Autowired(IWindowService)
-  private readonly windowService: IWindowService;
-
-  handleScheme(scheme: string) {
-    return HttpOpener.standardSupportedLinkSchemes.has(scheme);
-  }
-
-  async open(uri: URI) {
-    this.windowService.openNewWindow(uri.toString(true), {
-      external: true,
-    });
-    return true;
-  }
-}

package/src/opener/index.ts

@@ -1,19 +0,0 @@
-import { URI, IDisposable, MaybePromise } from '..';
-
-export const OpenerContribution = Symbol('OpenerContribution');
-export interface OpenerContribution {
-  registerOpener(registry: IOpenerService): void;
-}
-
-export interface IOpener {
-  open(uri: URI): MaybePromise<boolean>;
-  handleScheme(scheme: string): MaybePromise<boolean>;
-  // 当有 handleURI，会无视 handleScheme
-  handleURI?(uri: URI): MaybePromise<boolean>;
-}
-
-export const IOpenerService = Symbol('IOpenerService');
-export interface IOpenerService extends IDisposable {
-  registerOpener(opener: IOpener): IDisposable;
-  open(resource: URI | string): MaybePromise<boolean>;
-}

package/src/opener/opener.contribution.ts

@@ -1,57 +0,0 @@
-import { Injector, Autowired, INJECTOR_TOKEN } from '@opensumi/di';
-import { Domain, ContributionProvider } from '@opensumi/ide-core-common';
-import { IElectronRendererURLService, IElectronURLService } from '@opensumi/ide-core-common/lib/electron';
-
-import { ClientAppContribution } from '../common/common.define';
-import { AppConfig } from '../react-providers/config-provider';
-import { electronEnv } from '../utils/electron';
-
-import { CommandOpener } from './command-opener';
-import { HttpOpener } from './http-opener';
-
-import { OpenerContribution, IOpenerService } from '.';
-
-@Domain(OpenerContribution)
-export class DefaultOpenerContribution implements OpenerContribution {
-  @Autowired()
-  private readonly commandOpener: CommandOpener;
-
-  @Autowired()
-  private readonly httpOpener: HttpOpener;
-
-  registerOpener(register: IOpenerService): void {
-    register.registerOpener(this.commandOpener);
-    register.registerOpener(this.httpOpener);
-  }
-}
-
-@Domain(ClientAppContribution)
-export class OpenerContributionClient implements ClientAppContribution {
-  @Autowired(INJECTOR_TOKEN)
-  private readonly injector: Injector;
-
-  @Autowired(OpenerContribution)
-  private readonly contributionProvider: ContributionProvider<OpenerContribution>;
-
-  @Autowired(IOpenerService)
-  private readonly openerService: IOpenerService;
-
-  @Autowired(AppConfig)
-  private readonly appConfig: AppConfig;
-
-  onStart() {
-    const contributions = this.contributionProvider.getContributions();
-    for (const contribution of contributions) {
-      contribution.registerOpener(this.openerService);
-    }
-
-    if (this.appConfig.isElectronRenderer) {
-      const electronRendererURLService: IElectronRendererURLService = this.injector.get(IElectronURLService);
-      electronRendererURLService.on('open-url', (payload) => {
-        if (electronEnv.currentWindowId === payload.windowId) {
-          this.openerService.open(payload.url);
-        }
-      });
-    }
-  }
-}

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');
-  }
-}