@opensumi/ide-editor 2.27.3-rc-1708399099.0 → 2.27.3-rc-1710489030.0

package/src/browser/preference/schema.ts

@@ -1,10 +1,10 @@
 import {
-  localize,
-  isOSX,
-  isLinux,
+  PreferenceProxy,
   PreferenceSchema,
   PreferenceSchemaProperties,
-  PreferenceProxy,
+  isLinux,
+  isOSX,
+  localize,
 } from '@opensumi/ide-core-browser';
 
 export const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?';
@@ -80,6 +80,7 @@ export const EDITOR_SUGGEST_DEFAULTS = {
 
 export const EDITOR_INLINE_SUGGEST_DEFAULTS = {
   enabled: true,
+  showToolbar: 'onHover',
 };
 
 export const enum WrappingIndent {
@@ -523,6 +524,23 @@ const monacoEditorSchema: PreferenceSchemaProperties = {
     default: EDITOR_INLINE_SUGGEST_DEFAULTS.enabled,
     description: '%editor.configuration.inlineSuggest.enabled%',
   },
+  'editor.inlineSuggest.showToolbar': {
+    type: 'string',
+    default: EDITOR_INLINE_SUGGEST_DEFAULTS.showToolbar,
+    enum: ['always', 'onHover', 'never'],
+    enumDescriptions: [
+      localize(
+        'editor.configuration.inlineSuggest.showToolbar.always',
+        'Show the inline suggestion toolbar whenever an inline suggestion is shown.',
+      ),
+      localize(
+        'editor.configuration.inlineSuggest.showToolbar.onHover',
+        'Show the inline suggestion toolbar when hovering over an inline suggestion.',
+      ),
+      localize('editor.configuration.inlineSuggest.showToolbar.never', 'Never show the inline suggestion toolbar.'),
+    ],
+    description: '%editor.configuration.inlineSuggest.showToolbar%',
+  },
   'editor.experimental.stickyScroll.enabled': {
     type: 'boolean',
     default: true,

package/src/browser/preference/util.ts

@@ -1,6 +1,6 @@
 import { PreferenceService, createPreferenceProxy } from '@opensumi/ide-core-browser';
 
-import { editorPreferenceSchema, EditorPreferences } from './schema';
+import { EditorPreferences, editorPreferenceSchema } from './schema';
 
 export function createEditorPreferenceProxy(
   preferenceService: PreferenceService,

package/src/browser/quick-open/go-to-line.ts

@@ -1,12 +1,12 @@
-import { Injectable, Autowired } from '@opensumi/di';
+import { Autowired, Injectable } from '@opensumi/di';
 import {
   CommandService,
+  QuickOpenHandler,
   formatLocalize,
   localize,
-  QuickOpenHandler,
   withNullAsUndefined,
 } from '@opensumi/ide-core-browser';
-import { QuickOpenItem, PrefixQuickOpenService, QuickOpenModel, Mode } from '@opensumi/ide-core-browser/lib/quick-open';
+import { Mode, PrefixQuickOpenService, QuickOpenItem, QuickOpenModel } from '@opensumi/ide-core-browser/lib/quick-open';
 import { Event as MonacoEvent } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
 import { IRange as IMonacoRange } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/range';
 import { IEditor as IMonacoCodeEditor } from '@opensumi/monaco-editor-core/esm/vs/editor/common/editorCommon';

package/src/browser/quick-open/workspace-symbol-quickopen.ts

@@ -1,30 +1,30 @@
-import type { SymbolInformation, Range } from 'vscode-languageserver-types';
-
-import { Injectable, Autowired } from '@opensumi/di';
+import { Autowired, Injectable } from '@opensumi/di';
 import {
-  QuickOpenHandler,
-  QuickOpenModel,
+  CancellationToken,
   CancellationTokenSource,
+  QuickOpenHandler,
   QuickOpenItem,
-  CancellationToken,
-  URI,
   QuickOpenMode,
-  getSymbolIcon,
+  QuickOpenModel,
+  URI,
   getIcon,
+  getSymbolIcon,
 } from '@opensumi/ide-core-browser';
-import { ILogger, localize, IReporterService, REPORT_NAME } from '@opensumi/ide-core-common';
-import { QuickOpenBaseAction, QuickOpenActionProvider } from '@opensumi/ide-quick-open';
+import { ILogger, IReporterService, REPORT_NAME, localize } from '@opensumi/ide-core-common';
+import { QuickOpenActionProvider, QuickOpenBaseAction } from '@opensumi/ide-quick-open';
 import { IWorkspaceService } from '@opensumi/ide-workspace';
 import { SymbolKind as SymbolKindEnum } from '@opensumi/monaco-editor-core/esm/vs/editor/common/languages';
 
 import {
-  WorkspaceSymbolProvider,
+  EditorGroupSplitAction,
   ILanguageService,
-  WorkspaceSymbolParams,
   WorkbenchEditorService,
-  EditorGroupSplitAction,
+  WorkspaceSymbolParams,
+  WorkspaceSymbolProvider,
 } from '../../common';
 
+import type { Range, SymbolInformation } from 'vscode-languageserver-types';
+
 @Injectable()
 class WorkspaceSymbolOpenSideAction extends QuickOpenBaseAction {
   constructor() {

package/src/browser/resource.service.ts

@@ -1,19 +1,19 @@
 import { observable } from 'mobx';
 
-import { Injectable, Autowired } from '@opensumi/di';
-import { URI, IDisposable, WithEventBus, OnEvent } from '@opensumi/ide-core-browser';
-import { Disposable, arrays, LRUMap, ILogger, Emitter } from '@opensumi/ide-core-common';
+import { Autowired, Injectable } from '@opensumi/di';
+import { IDisposable, OnEvent, URI, WithEventBus } from '@opensumi/ide-core-browser';
+import { Disposable, Emitter, ILogger, LRUMap, arrays } from '@opensumi/ide-core-common';
 
 import {
-  ResourceService,
+  AskSaveResult,
   IResource,
-  IResourceProvider,
-  ResourceNeedUpdateEvent,
-  ResourceDidUpdateEvent,
   IResourceDecoration,
-  ResourceDecorationNeedChangeEvent,
+  IResourceProvider,
   ResourceDecorationChangeEvent,
-  AskSaveResult,
+  ResourceDecorationNeedChangeEvent,
+  ResourceDidUpdateEvent,
+  ResourceNeedUpdateEvent,
+  ResourceService,
 } from '../common';
 
 const { addElement } = arrays;

package/src/browser/tab.view.tsx

@@ -1,45 +1,52 @@
 import cls from 'classnames';
 import React, {
-  useEffect,
-  useState,
-  useCallback,
-  useRef,
-  useContext,
-  useMemo,
-  forwardRef,
   DragEvent,
   HTMLAttributes,
-  Ref,
   MouseEvent,
+  Ref,
+  forwardRef,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
 } from 'react';
 
 import { Scrollbars } from '@opensumi/ide-components';
 import {
-  getIcon,
-  MaybeNull,
-  IEventBus,
-  getSlotLocation,
+  AppConfig,
   ConfigContext,
-  ResizeEvent,
-  URI,
   Disposable,
-  DomListener,
-  PreferenceService,
   DisposableCollection,
+  DomListener,
   Event,
+  IEventBus,
+  MaybeNull,
+  PreferenceService,
+  ResizeEvent,
+  URI,
   getExternalIcon,
+  getIcon,
+  getSlotLocation,
+  useDesignStyles,
 } from '@opensumi/ide-core-browser';
 import { InlineMenuBar } from '@opensumi/ide-core-browser/lib/components/actions';
-import { LAYOUT_VIEW_SIZE } from '@opensumi/ide-core-browser/lib/layout/constants';
 import { VIEW_CONTAINERS } from '@opensumi/ide-core-browser/lib/layout/view-id';
 import { IMenuRegistry, MenuId } from '@opensumi/ide-core-browser/lib/menu/next';
 import { useInjectable, useUpdateOnEventBusEvent } from '@opensumi/ide-core-browser/lib/react-hooks';
 
-import { IResource, ResourceService, IEditorGroup, WorkbenchEditorService, ResourceDidUpdateEvent } from '../common';
+import { IEditorGroup, IResource, ResourceDidUpdateEvent, ResourceService, WorkbenchEditorService } from '../common';
 
 import styles from './editor.module.less';
 import { TabTitleMenuService } from './menu/title-context.menu';
-import { GridResizeEvent, IEditorActionRegistry, DragOverPosition, EditorGroupFileDropEvent } from './types';
+import {
+  DragOverPosition,
+  EditorGroupFileDropEvent,
+  GridResizeEvent,
+  IEditorActionRegistry,
+  IEditorTabService,
+} from './types';
 import { useUpdateOnGroupTabChange } from './view/react-hook';
 import { EditorGroup, WorkbenchEditorServiceImpl } from './workbench-editor.service';
 
@@ -62,6 +69,21 @@ export const Tabs = ({ group }: ITabsProps) => {
   const tabTitleMenuService = useInjectable(TabTitleMenuService) as TabTitleMenuService;
   const preferenceService = useInjectable<PreferenceService>(PreferenceService);
   const menuRegistry = useInjectable<IMenuRegistry>(IMenuRegistry);
+  const editorTabService = useInjectable<IEditorTabService>(IEditorTabService);
+  const appConfig = useInjectable<AppConfig>(AppConfig);
+
+  const styles_tab_right = useDesignStyles(styles.tab_right);
+  const styles_close_tab = useDesignStyles(styles.close_tab);
+  const styles_kt_editor_close_icon = useDesignStyles(styles.kt_editor_close_icon);
+  const styles_kt_editor_tabs_content = useDesignStyles(styles.kt_editor_tabs_content);
+  const styles_kt_editor_tabs_current_last = useDesignStyles(styles.kt_editor_tabs_current_last);
+  const styles_kt_editor_tab = useDesignStyles(styles.kt_editor_tab);
+  const styles_kt_editor_tab_current_prev = useDesignStyles(styles.kt_editor_tab_current_prev);
+  const styles_kt_editor_tab_current_next = useDesignStyles(styles.kt_editor_tab_current_next);
+  const styles_kt_editor_tab_current = useDesignStyles(styles.kt_editor_tab_current);
+  const styles_kt_editor_tab_dirty = useDesignStyles(styles.kt_editor_tab_dirty);
+  const styles_kt_editor_tabs = useDesignStyles(styles.kt_editor_tabs);
+  const styles_kt_editor_tabs_scroll_wrapper = useDesignStyles(styles.kt_editor_tabs_scroll_wrapper);
 
   const [tabsLoadingMap, setTabsLoadingMap] = useState<{ [resource: string]: boolean }>({});
   const [wrapMode, setWrapMode] = useState<boolean>(!!preferenceService.get<boolean>('editor.wrapTab'));
@@ -314,113 +336,138 @@ export const Tabs = ({ group }: ITabsProps) => {
     [editorService],
   );
 
-  const renderTabContent = () => (
-    <div className={styles.kt_editor_tabs_content} ref={contentRef as any}>
-      {group.resources.map((resource, i) => {
-        let ref: HTMLDivElement | null;
-        const decoration = resourceService.getResourceDecoration(resource.uri);
-        const subname = resourceService.getResourceSubname(resource, group.resources);
-        return (
-          <div
-            draggable={true}
-            title={resource.title}
-            className={cls({
-              [styles.kt_editor_tab]: true,
-              [styles.last_in_row]: tabMap.get(i),
-              [styles.kt_editor_tab_current]: group.currentResource === resource,
-              [styles.kt_editor_tab_preview]: group.previewURI && group.previewURI.isEqual(resource.uri),
-            })}
-            style={
-              wrapMode && i === group.resources.length - 1
-                ? { marginRight: lastMarginRight, height: LAYOUT_VIEW_SIZE.EDITOR_TABS_HEIGHT }
-                : {
-                    height:
-                      group.currentResource === resource
-                        ? LAYOUT_VIEW_SIZE.EDITOR_TABS_HEIGHT + 1
-                        : LAYOUT_VIEW_SIZE.EDITOR_TABS_HEIGHT,
-                  }
-            }
-            onContextMenu={(event) => {
-              tabTitleMenuService.show(event.nativeEvent.x, event.nativeEvent.y, resource && resource.uri, group);
-              event.preventDefault();
-            }}
-            key={resource.uri.toString()}
-            onMouseUp={(e) => {
-              if (e.nativeEvent.which === 2) {
-                e.preventDefault();
+  const renderEditorTab = React.useCallback(
+    (resource: IResource, isCurrent: boolean) => {
+      const decoration = resourceService.getResourceDecoration(resource.uri);
+      const subname = resourceService.getResourceSubname(resource, group.resources);
+
+      return editorTabService.renderEditorTab(
+        <>
+          <div className={tabsLoadingMap[resource.uri.toString()] ? 'loading_indicator' : cls(resource.icon)}> </div>
+          <div>{resource.name}</div>
+          {subname ? <div className={styles.subname}>{subname}</div> : null}
+          {decoration.readOnly ? (
+            <span className={cls(getExternalIcon('lock'), styles.editor_readonly_icon)}></span>
+          ) : null}
+          <div className={styles_tab_right}>
+            <div
+              className={cls({
+                [styles.kt_hidden]: !decoration.dirty,
+                [styles.dirty]: true,
+              })}
+            ></div>
+            <div
+              className={styles_close_tab}
+              onMouseDown={(e) => {
                 e.stopPropagation();
                 group.close(resource.uri);
+              }}
+            >
+              {editorTabService.renderTabCloseComponent(
+                <div className={cls(getIcon('close'), styles_kt_editor_close_icon)} />,
+              )}
+            </div>
+          </div>
+        </>,
+        isCurrent,
+      );
+    },
+    [editorTabService],
+  );
+
+  const renderTabContent = () => {
+    const curTabIndex = group.resources.findIndex((resource) => group.currentResource === resource);
+    return (
+      <div
+        className={cls({
+          [styles_kt_editor_tabs_content]: true,
+          [styles_kt_editor_tabs_current_last]: curTabIndex === group.resources.length - 1,
+        })}
+        ref={contentRef as any}
+      >
+        {group.resources.map((resource, i) => {
+          let ref: HTMLDivElement | null;
+          const decoration = resourceService.getResourceDecoration(resource.uri);
+          return (
+            <div
+              draggable={true}
+              title={resource.title}
+              className={cls({
+                [styles_kt_editor_tab]: true,
+                [styles.last_in_row]: tabMap.get(i),
+                [styles_kt_editor_tab_current_prev]: curTabIndex - 1 === i,
+                [styles_kt_editor_tab_current_next]: curTabIndex + 1 === i,
+                [styles_kt_editor_tab_current]: group.currentResource === resource,
+                [styles.kt_editor_tab_preview]: group.previewURI && group.previewURI.isEqual(resource.uri),
+                [styles_kt_editor_tab_dirty]: decoration.dirty,
+              })}
+              style={
+                wrapMode && i === group.resources.length - 1
+                  ? { marginRight: lastMarginRight, height: appConfig.layoutViewSize!.editorTabsHeight }
+                  : { height: appConfig.layoutViewSize!.editorTabsHeight }
               }
-            }}
-            onMouseDown={(e) => {
-              if (e.nativeEvent.which === 1) {
-                group.open(resource.uri, { focus: true });
-              }
-            }}
-            data-uri={resource.uri.toString()}
-            onDragOver={(e) => {
-              e.preventDefault();
-              e.stopPropagation();
-              if (ref) {
-                ref.classList.add(styles.kt_on_drag_over);
-              }
-            }}
-            onDragLeave={(e) => {
-              if (ref) {
-                ref.classList.remove(styles.kt_on_drag_over);
-              }
-            }}
-            onDrop={(e) => {
-              if (ref) {
-                ref.classList.remove(styles.kt_on_drag_over);
-              }
-              if (onDrop) {
-                onDrop(e, i, resource);
-              }
-            }}
-            onDoubleClick={(e) => {
-              group.pinPreviewed(resource.uri);
-            }}
-            ref={(el) => (ref = el)}
-            onDragStart={(e) => {
-              e.dataTransfer.setData('uri', resource.uri.toString());
-              e.dataTransfer.setData('uri-source-group', group.name);
-            }}
-          >
-            <div className={tabsLoadingMap[resource.uri.toString()] ? 'loading_indicator' : cls(resource.icon)}> </div>
-            <div>{resource.name}</div>
-            {subname ? <div className={styles.subname}>{subname}</div> : null}
-            {decoration.readOnly ? (
-              <span className={cls(getExternalIcon('lock'), styles.editor_readonly_icon)}></span>
-            ) : null}
-            <div className={styles.tab_right}>
-              <div
-                className={cls({
-                  [styles.kt_hidden]: !decoration.dirty,
-                  [styles.dirty]: true,
-                })}
-              ></div>
-              <div
-                className={styles.close_tab}
-                onMouseDown={(e) => {
+              onContextMenu={(event) => {
+                tabTitleMenuService.show(event.nativeEvent.x, event.nativeEvent.y, resource && resource.uri, group);
+                event.preventDefault();
+              }}
+              key={resource.uri.toString()}
+              onMouseUp={(e) => {
+                if (e.nativeEvent.which === 2) {
+                  e.preventDefault();
                   e.stopPropagation();
                   group.close(resource.uri);
-                }}
-              >
-                <div className={cls(getIcon('close'), styles.kt_editor_close_icon)} />
-              </div>
+                }
+              }}
+              onMouseDown={(e) => {
+                if (e.nativeEvent.which === 1) {
+                  group.open(resource.uri, { focus: true });
+                }
+              }}
+              data-uri={resource.uri.toString()}
+              onDragOver={(e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                if (ref) {
+                  ref.classList.add(styles.kt_on_drag_over);
+                }
+              }}
+              onDragLeave={(e) => {
+                if (ref) {
+                  ref.classList.remove(styles.kt_on_drag_over);
+                }
+              }}
+              onDrop={(e) => {
+                if (ref) {
+                  ref.classList.remove(styles.kt_on_drag_over);
+                }
+                if (onDrop) {
+                  onDrop(e, i, resource);
+                }
+              }}
+              onDoubleClick={(e) => {
+                group.pinPreviewed(resource.uri);
+              }}
+              ref={(el) => (ref = el)}
+              onDragStart={(e) => {
+                e.dataTransfer.setData('uri', resource.uri.toString());
+                e.dataTransfer.setData('uri-source-group', group.name);
+              }}
+            >
+              {renderEditorTab(resource, group.currentResource === resource)}
             </div>
-          </div>
-        );
-      })}
-      {wrapMode && <EditorActions className={styles.kt_editor_wrap_mode_action} ref={editorActionRef} group={group} />}
-    </div>
-  );
+          );
+        })}
+        {wrapMode && (
+          <EditorActions className={styles.kt_editor_wrap_mode_action} ref={editorActionRef} group={group} />
+        )}
+      </div>
+    );
+  };
 
   return (
-    <div id={VIEW_CONTAINERS.EDITOR_TABS} className={styles.kt_editor_tabs}>
+    <div id={VIEW_CONTAINERS.EDITOR_TABS} className={styles_kt_editor_tabs}>
       <div
-        className={styles.kt_editor_tabs_scroll_wrapper}
+        className={styles_kt_editor_tabs_scroll_wrapper}
         ref={tabWrapperRef as any}
         onDragOver={handleWrapperDragOver}
         onDragLeave={handleWrapperDragLeave}
@@ -453,6 +500,7 @@ export type IEditorActionsProps = IEditorActionsBaseProps & HTMLAttributes<HTMLD
 
 export const EditorActions = forwardRef<HTMLDivElement, IEditorActionsProps>(
   (props: IEditorActionsProps, ref: Ref<typeof EditorActions>) => {
+    const styles_editor_actions = useDesignStyles(styles.editor_actions);
     const { group, className } = props;
 
     const acquireArgs = useCallback(
@@ -469,6 +517,7 @@ export const EditorActions = forwardRef<HTMLDivElement, IEditorActionsProps>(
 
     const editorActionRegistry = useInjectable<IEditorActionRegistry>(IEditorActionRegistry);
     const editorService: WorkbenchEditorServiceImpl = useInjectable(WorkbenchEditorService);
+    const appConfig = useInjectable<AppConfig>(AppConfig);
     const menu = editorActionRegistry.getMenu(group);
     const [hasFocus, setHasFocus] = useState<boolean>(editorService.currentEditorGroup === group);
     const [args, setArgs] = useState<[URI, IEditorGroup, MaybeNull<URI>] | undefined>(acquireArgs());
@@ -499,8 +548,8 @@ export const EditorActions = forwardRef<HTMLDivElement, IEditorActionsProps>(
     return (
       <div
         ref={ref}
-        className={cls(styles.editor_actions, className)}
-        style={{ height: LAYOUT_VIEW_SIZE.EDITOR_TABS_HEIGHT }}
+        className={cls(styles_editor_actions, className)}
+        style={{ height: appConfig.layoutViewSize!.editorTabsHeight }}
       >
         <InlineMenuBar<URI, IEditorGroup, MaybeNull<URI>>
           menus={menu}

package/src/browser/types.ts

@@ -1,29 +1,31 @@
+import { ReactNode } from 'react';
+
 import {
-  MaybePromise,
-  IDisposable,
   BasicEvent,
+  Event,
+  IDisposable,
   IRange,
-  MaybeNull,
   ISelection,
+  MaybeNull,
+  MaybePromise,
   URI,
-  Event,
 } from '@opensumi/ide-core-browser';
 import { IContextMenu } from '@opensumi/ide-core-browser/lib/menu/next';
 import { IThemeColor } from '@opensumi/ide-core-common';
 import { editor } from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
 
 import {
-  IResource,
-  ResourceService,
-  IEditorGroup,
+  DragOverPosition,
+  EditorOpenType,
   IDecorationRenderOptions,
+  IEditor,
+  IEditorGroup,
+  IEditorOpenType,
+  IResource,
   ITextEditorDecorationType,
-  TrackedRangeStickiness,
   OverviewRulerLane,
-  IEditorOpenType,
-  IEditor,
-  DragOverPosition,
-  EditorOpenType,
+  ResourceService,
+  TrackedRangeStickiness,
 } from '../common';
 
 import { IEditorDocumentModelContentRegistry } from './doc-model/types';
@@ -482,3 +484,10 @@ export class ResoucesOfActiveComponentChangedEvent extends BasicEvent<{
   component: IEditorComponent;
   resources: IResource[];
 }> {}
+
+export const IEditorTabService = Symbol('IEditorTabService');
+
+export interface IEditorTabService {
+  renderEditorTab(component: ReactNode, isCurrent?: boolean): ReactNode;
+  renderTabCloseComponent(component: ReactNode): ReactNode;
+}

package/src/browser/untitled-resource.ts

@@ -1,31 +1,31 @@
-import { Injectable, Autowired } from '@opensumi/di';
+import { Autowired, Injectable } from '@opensumi/di';
 import {
-  URI,
+  AppConfig,
+  CommandService,
   Emitter,
   Event,
-  Schemes,
-  WithEventBus,
+  IApplicationService,
   IEditorDocumentChange,
   IEditorDocumentModelSaveResult,
-  AppConfig,
-  CommandService,
+  MessageType,
   OperatingSystem,
-  IApplicationService,
   PreferenceService,
+  SaveTaskResponseState,
+  Schemes,
+  URI,
+  WithEventBus,
+  formatLocalize,
   getLanguageIdFromMonaco,
+  isWindows,
   localize,
-  formatLocalize,
-  MessageType,
   path,
-  isWindows,
-  SaveTaskResponseState,
 } from '@opensumi/ide-core-browser';
 import { EOL } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
 import { IDialogService } from '@opensumi/ide-overlay';
 
 import { AskSaveResult, IResource, IResourceProvider, WorkbenchEditorService } from '../common';
 
-import { IEditorDocumentModelService, IEditorDocumentModelContentProvider } from './doc-model/types';
+import { IEditorDocumentModelContentProvider, IEditorDocumentModelService } from './doc-model/types';
 
 @Injectable()
 export class UntitledDocumentIdCounter {

package/src/browser/view/editor.react.tsx

@@ -3,7 +3,8 @@ import React from 'react';
 import { URI, useInjectable } from '@opensumi/ide-core-browser';
 
 import { EditorCollectionService, ICodeEditor } from '../../common';
-import { IEditorDocumentModelService, IEditorDocumentModelRef } from '../doc-model/types';
+import { IEditorDocumentModelRef } from '../../common/editor';
+import { IEditorDocumentModelService } from '../doc-model/types';
 
 export interface ICodeEditorProps extends React.HTMLAttributes<HTMLDivElement> {
   uri?: URI;

package/src/browser/view/suggest-widget.ts

@@ -1,6 +1,5 @@
 import { Autowired, Injectable } from '@opensumi/di';
-import { PreferenceService } from '@opensumi/ide-core-browser';
-import { SuggestEvent, DisposableCollection } from '@opensumi/ide-core-browser';
+import { DisposableCollection, PreferenceService, SuggestEvent } from '@opensumi/ide-core-browser';
 import { IEventBus } from '@opensumi/ide-core-common';
 import { SuggestController } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/suggest/browser/suggestController';