@opensumi/ide-core-browser 2.21.13 → 2.22.0

package/src/opener/http-opener.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,77 @@
+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');
+  }
+}