@opensumi/ide-core-browser 2.21.13 → 2.22.0

package/src/bootstrap/app.view.tsx

@@ -0,0 +1,88 @@
+import React from 'react';
+import ReactDom from 'react-dom';
+
+import { ComponentContextProvider, IIconResourceOptions } from '@opensumi/ide-components';
+import { getDebugLogger, IEventBus, URI, localize } from '@opensumi/ide-core-common';
+
+import { IClientApp } from '../browser-module';
+import { DefaultLayout } from '../components/layout/default-layout';
+import { ResizeEvent } from '../layout';
+import { ConfigProvider } from '../react-providers/config-provider';
+import { allSlot } from '../react-providers/slot';
+import { LabelService } from '../services';
+import { getIcon } from '../style/icon/icon';
+
+export interface AppProps {
+  app: IClientApp;
+  main: React.ComponentType;
+  overlays?: React.ComponentType[];
+}
+
+export function App(props: AppProps) {
+  const injector = props.app.injector;
+  const eventBus: IEventBus = injector.get(IEventBus);
+  const labelService: LabelService = injector.get(LabelService);
+  const getResourceIcon = React.useCallback(
+    (uri: string, options: IIconResourceOptions) => labelService.getIcon(URI.parse(uri), options),
+    [],
+  );
+  React.useEffect(() => {
+    let lastFrame: number | null;
+    const handle = () => {
+      if (lastFrame) {
+        window.cancelAnimationFrame(lastFrame);
+      }
+      lastFrame = window.requestAnimationFrame(() => {
+        lastFrame = null;
+        allSlot.forEach((item) => {
+          eventBus.fire(new ResizeEvent({ slotLocation: item.slot }));
+        });
+      });
+    };
+    window.addEventListener('resize', handle);
+    return () => {
+      window.removeEventListener('resize', handle);
+    };
+  }, []);
+  return (
+    <ComponentContextProvider value={{ getIcon, localize, getResourceIcon }}>
+      <ConfigProvider value={props.app.config}>
+        {<props.main />}
+        {props.overlays && props.overlays.map((Component, index) => <Component key={index} />)}
+      </ConfigProvider>
+    </ComponentContextProvider>
+  );
+}
+
+export type IAppRenderer = (app: React.ReactElement) => Promise<void>;
+
+const defaultAppRender =
+  (dom: HTMLElement, onDidRendered?: () => void): IAppRenderer =>
+  (app) =>
+    new Promise((resolve) => {
+      ReactDom.render(app, dom, () => {
+        if (onDidRendered && typeof onDidRendered === 'function') {
+          onDidRendered();
+        }
+        resolve();
+      });
+    });
+
+export function renderClientApp(app: IClientApp, container: HTMLElement | IAppRenderer) {
+  const Layout = app.config.layoutComponent || DefaultLayout;
+  const overlayComponents = app.browserModules
+    .filter((module) => module.isOverlay)
+    .map((module) => {
+      if (!module.component) {
+        getDebugLogger().warn('Overlay module does not have component', module);
+        return () => <></>;
+      }
+      return module.component;
+    });
+
+  const IdeApp = <App app={app} main={Layout} overlays={overlayComponents} />;
+
+  const render = typeof container === 'function' ? container : defaultAppRender(container, app.config.didRendered);
+
+  return render(IdeApp);
+}

package/src/bootstrap/connection.ts

@@ -0,0 +1,116 @@
+import { Injector, Provider } from '@opensumi/di';
+import { RPCServiceCenter, initRPCService, RPCMessageConnection } from '@opensumi/ide-connection';
+import { WSChannelHandler } from '@opensumi/ide-connection/lib/browser';
+import { createWebSocketConnection } from '@opensumi/ide-connection/lib/common/message';
+import {
+  getDebugLogger,
+  IReporterService,
+  BasicModule,
+  BrowserConnectionCloseEvent,
+  BrowserConnectionOpenEvent,
+  BrowserConnectionErrorEvent,
+  IEventBus,
+  UrlProvider,
+} from '@opensumi/ide-core-common';
+import { BackService } from '@opensumi/ide-core-common/lib/module';
+
+import { ClientAppStateService } from '../application';
+
+import { ModuleConstructor } from './app.interface';
+
+const initialLogger = getDebugLogger();
+
+export async function createClientConnection2(
+  injector: Injector,
+  modules: ModuleConstructor[],
+  wsPath: UrlProvider,
+  onReconnect: () => void,
+  protocols?: string[],
+  clientId?: string,
+) {
+  const reporterService: IReporterService = injector.get(IReporterService);
+  const eventBus = injector.get(IEventBus);
+  const stateService = injector.get(ClientAppStateService);
+
+  const wsChannelHandler = new WSChannelHandler(wsPath, initialLogger, protocols, clientId);
+  wsChannelHandler.setReporter(reporterService);
+  wsChannelHandler.connection.addEventListener('open', async () => {
+    await stateService.reachedState('core_module_initialized');
+    eventBus.fire(new BrowserConnectionOpenEvent());
+  });
+
+  wsChannelHandler.connection.addEventListener('close', async () => {
+    await stateService.reachedState('core_module_initialized');
+    eventBus.fire(new BrowserConnectionCloseEvent());
+  });
+
+  wsChannelHandler.connection.addEventListener('error', async (e) => {
+    await stateService.reachedState('core_module_initialized');
+    eventBus.fire(new BrowserConnectionErrorEvent(e));
+  });
+
+  await wsChannelHandler.initHandler();
+
+  injector.addProviders({
+    token: WSChannelHandler,
+    useValue: wsChannelHandler,
+  });
+  // 重连不会执行后面的逻辑
+  const channel = await wsChannelHandler.openChannel('RPCService');
+  channel.onReOpen(() => onReconnect());
+
+  bindConnectionService(injector, modules, createWebSocketConnection(channel));
+}
+
+export async function bindConnectionService(
+  injector: Injector,
+  modules: ModuleConstructor[],
+  connection: RPCMessageConnection,
+) {
+  const clientCenter = new RPCServiceCenter();
+  clientCenter.setConnection(connection);
+
+  connection.onClose(() => {
+    clientCenter.removeConnection(connection);
+  });
+
+  const { getRPCService } = initRPCService(clientCenter);
+
+  const backServiceArr: BackService[] = [];
+  // 存放依赖前端后端服务，后端服务实例化后再去实例化这些 token
+  const dependClientBackServices: BackService[] = [];
+
+  for (const module of modules) {
+    const moduleInstance = injector.get(module) as BasicModule;
+    if (moduleInstance.backServices) {
+      for (const backService of moduleInstance.backServices) {
+        backServiceArr.push(backService);
+      }
+    }
+  }
+
+  for (const backService of backServiceArr) {
+    const { servicePath } = backService;
+    const rpcService = getRPCService(servicePath);
+
+    const injectService = {
+      token: servicePath,
+      useValue: rpcService,
+    } as Provider;
+
+    injector.addProviders(injectService);
+    // 这里不进行初始化，先收集依赖，等所有 servicePath 实例化完后在做实例化，防止循环依赖
+    if (backService.clientToken) {
+      dependClientBackServices.push(backService);
+    }
+  }
+
+  for (const backService of dependClientBackServices) {
+    const { servicePath } = backService;
+    const rpcService = getRPCService(servicePath);
+    if (backService.clientToken) {
+      const clientService = injector.get(backService.clientToken);
+      rpcService.onRequestService(clientService);
+    }
+  }
+}

package/src/bootstrap/index.ts

@@ -0,0 +1,3 @@
+export * from './app.interface';
+export * from './app.view';
+export * from './connection';

package/src/bootstrap/inner-providers.ts

@@ -0,0 +1,297 @@
+import { Provider, Injector } from '@opensumi/di';
+import {
+  IEventBus,
+  EventBusImpl,
+  CommandService,
+  CommandRegistryImpl,
+  CommandContribution,
+  createContributionProvider,
+  CommandServiceImpl,
+  CommandRegistry,
+  IElectronMainMenuService,
+  ReporterMetadata,
+  IReporter,
+  IReporterService,
+  DefaultReporter,
+  ReporterService,
+  REPORT_HOST,
+  IProblemPatternRegistry,
+  ProblemPatternRegistryImpl,
+  IProblemMatcherRegistry,
+  ProblemMatchersRegistryImpl,
+  ITaskDefinitionRegistry,
+  TaskDefinitionRegistryImpl,
+  IApplicationService,
+  IAuthenticationService,
+  AppLifeCycleServiceToken,
+  IExtensionsSchemaService,
+} from '@opensumi/ide-core-common';
+import {
+  IElectronMainUIService,
+  IElectronMainLifeCycleService,
+  IElectronURLService,
+} from '@opensumi/ide-core-common/lib/electron';
+import {
+  HashCalculateServiceImpl,
+  IHashCalculateService,
+} from '@opensumi/ide-core-common/lib/hash-calculate/hash-calculate';
+import {
+  KeyboardNativeLayoutService,
+  KeyboardLayoutChangeNotifierService,
+} from '@opensumi/ide-core-common/lib/keyboard/keyboard-layout-provider';
+
+import { ClientAppStateService } from '../application/application-state-service';
+import { ApplicationService } from '../application/application.service';
+import { AuthenticationService } from '../authentication/authentication.service';
+import { ClientAppContribution } from '../common';
+import { ExtensionsPointServiceImpl } from '../extensions';
+import { FsProviderContribution } from '../fs';
+import { KeybindingContribution, KeybindingService, KeybindingRegistryImpl, KeybindingRegistry } from '../keybinding';
+import { BrowserKeyboardLayoutImpl, KeyValidator } from '../keyboard';
+import { ComponentRegistry, ComponentRegistryImpl, ComponentContribution, TabBarToolbarContribution } from '../layout';
+import { Logger, ILogger } from '../logger';
+import {
+  AbstractMenuService,
+  MenuServiceImpl,
+  AbstractMenubarService,
+  MenubarServiceImpl,
+  IMenuRegistry,
+  MenuRegistryImpl,
+  MenuContribution,
+  AbstractContextMenuService,
+  ContextMenuServiceImpl,
+} from '../menu/next';
+import { ICtxMenuRenderer } from '../menu/next/renderer/ctxmenu/base';
+import { BrowserCtxMenuRenderer } from '../menu/next/renderer/ctxmenu/browser';
+import {
+  ElectronCtxMenuRenderer,
+  ElectronMenuBarService,
+  IElectronMenuFactory,
+  IElectronMenuBarService,
+  ElectronMenuFactory,
+} from '../menu/next/renderer/ctxmenu/electron';
+import { ToolbarActionService, IToolbarActionService } from '../menu/next/toolbar-action.service';
+import { IOpenerService } from '../opener';
+import { OpenerService } from '../opener/opener.service';
+import { PreferenceContribution } from '../preferences';
+import { IProgressService } from '../progress';
+import { ProgressService } from '../progress/progress.service';
+import { AppConfig } from '../react-providers/config-provider';
+import { SlotRendererContribution } from '../react-providers/slot';
+import { CredentialsService, ICredentialsService, CryptoService, ICryptoService } from '../services';
+import { IClipboardService, BrowserClipboardService } from '../services/clipboard.service';
+import { IExternalUriService, ExternalUriService } from '../services/external-uri.service';
+import { IToolbarPopoverRegistry, IToolbarRegistry, ToolBarActionContribution } from '../toolbar';
+import { ToolbarPopoverRegistry } from '../toolbar/toolbar.popover.registry';
+import { NextToolbarRegistryImpl, ToolbarClientAppContribution } from '../toolbar/toolbar.registry';
+import { useNativeContextMenu } from '../utils';
+import { createElectronMainApi } from '../utils/electron';
+import { VariableRegistry, VariableRegistryImpl, VariableContribution } from '../variable';
+import { IWindowService } from '../window';
+import { WindowService } from '../window/window.service';
+
+import { AppLifeCycleService } from './lifecycle.service';
+
+export function injectInnerProviders(injector: Injector) {
+  // 生成 ContributionProvider
+  createContributionProvider(injector, ClientAppContribution);
+  createContributionProvider(injector, CommandContribution);
+  createContributionProvider(injector, FsProviderContribution);
+  createContributionProvider(injector, KeybindingContribution);
+  createContributionProvider(injector, MenuContribution);
+  createContributionProvider(injector, ComponentContribution);
+  createContributionProvider(injector, SlotRendererContribution);
+  createContributionProvider(injector, PreferenceContribution);
+  createContributionProvider(injector, VariableContribution);
+  createContributionProvider(injector, TabBarToolbarContribution);
+  createContributionProvider(injector, ToolBarActionContribution);
+
+  // 一些内置抽象实现
+  const providers: Provider[] = [
+    {
+      token: IEventBus,
+      useClass: EventBusImpl,
+    },
+    {
+      token: CommandService,
+      useClass: CommandServiceImpl,
+    },
+    {
+      token: CommandRegistry,
+      useClass: CommandRegistryImpl,
+    },
+    {
+      token: KeybindingRegistry,
+      useClass: KeybindingRegistryImpl,
+    },
+    {
+      token: KeybindingService,
+      useFactory: (inject: Injector) => inject.get(KeybindingRegistry),
+    },
+    {
+      token: KeyboardNativeLayoutService,
+      useClass: BrowserKeyboardLayoutImpl,
+    },
+    {
+      token: KeyboardLayoutChangeNotifierService,
+      useFactory: (inject: Injector) => inject.get(KeyboardNativeLayoutService),
+    },
+    {
+      token: KeyValidator,
+      useFactory: (inject: Injector) => inject.get(KeyboardNativeLayoutService),
+    },
+    ClientAppStateService,
+    {
+      token: ILogger,
+      useClass: Logger,
+    },
+    {
+      token: ComponentRegistry,
+      useClass: ComponentRegistryImpl,
+    },
+    {
+      token: VariableRegistry,
+      useClass: VariableRegistryImpl,
+    },
+    // next version menu
+    {
+      token: AbstractMenuService,
+      useClass: MenuServiceImpl,
+    },
+    {
+      token: AbstractContextMenuService,
+      useClass: ContextMenuServiceImpl,
+    },
+    {
+      token: IMenuRegistry,
+      useClass: MenuRegistryImpl,
+    },
+    {
+      token: IToolbarActionService,
+      useClass: ToolbarActionService,
+    },
+    {
+      token: ICtxMenuRenderer,
+      useClass: useNativeContextMenu() ? ElectronCtxMenuRenderer : BrowserCtxMenuRenderer,
+    },
+    {
+      token: AbstractMenubarService,
+      useClass: MenubarServiceImpl,
+    },
+    {
+      token: IReporter,
+      useClass: DefaultReporter,
+    },
+    {
+      token: IReporterService,
+      useClass: ReporterService,
+    },
+    {
+      token: ReporterMetadata,
+      useValue: {
+        host: REPORT_HOST.BROWSER,
+      },
+    },
+    {
+      token: IProgressService,
+      useClass: ProgressService,
+    },
+    {
+      token: IToolbarRegistry,
+      useClass: NextToolbarRegistryImpl,
+    },
+    {
+      token: IToolbarPopoverRegistry,
+      useClass: ToolbarPopoverRegistry,
+    },
+    ToolbarClientAppContribution,
+    {
+      token: IProblemPatternRegistry,
+      useClass: ProblemPatternRegistryImpl,
+    },
+    {
+      token: IProblemMatcherRegistry,
+      useClass: ProblemMatchersRegistryImpl,
+    },
+    {
+      token: ITaskDefinitionRegistry,
+      useClass: TaskDefinitionRegistryImpl,
+    },
+    {
+      token: IOpenerService,
+      useClass: OpenerService,
+    },
+    {
+      token: IWindowService,
+      useClass: WindowService,
+    },
+    {
+      token: IApplicationService,
+      useClass: ApplicationService,
+    },
+    {
+      token: IClipboardService,
+      useClass: BrowserClipboardService,
+    },
+    {
+      token: IExternalUriService,
+      useClass: ExternalUriService,
+    },
+    {
+      token: IAuthenticationService,
+      useClass: AuthenticationService,
+    },
+    {
+      token: ICryptoService,
+      useClass: CryptoService,
+    },
+    {
+      token: ICredentialsService,
+      useClass: CredentialsService,
+    },
+    {
+      token: IHashCalculateService,
+      useClass: HashCalculateServiceImpl,
+    },
+    {
+      token: IExtensionsSchemaService,
+      useClass: ExtensionsPointServiceImpl,
+    },
+    {
+      token: AppLifeCycleServiceToken,
+      useClass: AppLifeCycleService,
+    },
+  ];
+  injector.addProviders(...providers);
+
+  const appConfig: AppConfig = injector.get(AppConfig);
+  // Add special API services for Electron, mainly services that make calls to `Electron Main` process.
+  if (appConfig.isElectronRenderer) {
+    injector.addProviders(
+      {
+        token: IElectronMainMenuService,
+        useValue: createElectronMainApi(IElectronMainMenuService),
+      },
+      {
+        token: IElectronMainUIService,
+        useValue: createElectronMainApi(IElectronMainUIService),
+      },
+      {
+        token: IElectronMainLifeCycleService,
+        useValue: createElectronMainApi(IElectronMainLifeCycleService),
+      },
+      {
+        token: IElectronURLService,
+        useValue: createElectronMainApi(IElectronURLService),
+      },
+      {
+        token: IElectronMenuFactory,
+        useClass: ElectronMenuFactory,
+      },
+      {
+        token: IElectronMenuBarService,
+        useClass: ElectronMenuBarService,
+      },
+    );
+  }
+}

package/src/bootstrap/lifecycle.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@opensumi/di';
+import { Emitter, IAppLifeCycleService, LifeCyclePhase } from '@opensumi/ide-core-common';
+
+@Injectable()
+export class AppLifeCycleService implements IAppLifeCycleService {
+  private onDidChangeLifecyclePhaseEmitter: Emitter<LifeCyclePhase> = new Emitter();
+  public onDidLifeCyclePhaseChange = this.onDidChangeLifecyclePhaseEmitter.event;
+
+  private lifeCyclePhase: LifeCyclePhase;
+
+  set phase(value: LifeCyclePhase) {
+    this.lifeCyclePhase = value;
+    this.onDidChangeLifecyclePhaseEmitter.fire(this.lifeCyclePhase);
+  }
+
+  get phase() {
+    return this.lifeCyclePhase;
+  }
+}

package/src/browser-module.ts

@@ -0,0 +1,24 @@
+import { Injector, Autowired } from '@opensumi/di';
+import { BasicModule, CommandRegistry, Deferred } from '@opensumi/ide-core-common';
+
+import { AppConfig } from './react-providers/config-provider';
+
+export const IClientApp = Symbol('CLIENT_APP_TOKEN');
+
+export interface IClientApp {
+  appInitialized: Deferred<void>;
+  browserModules: BrowserModule<any>[];
+  injector: Injector;
+  config: AppConfig;
+  commandRegistry: CommandRegistry;
+  fireOnReload: (forcedReload?: boolean) => void;
+}
+
+export abstract class BrowserModule<T = any> extends BasicModule {
+  @Autowired(IClientApp)
+  protected app: IClientApp;
+  public preferences?: (inject: Injector) => void;
+  public component?: React.ComponentType<T>;
+  // 脱离于layout渲染的模块
+  public isOverlay?: boolean;
+}