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

package/src/bootstrap/app.view.tsx

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

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

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

package/src/bootstrap/inner-providers.ts

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

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

@@ -1,24 +0,0 @@
-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;
-}