Merge branch 'main' into feat/add-polling-watcher

packages/ai-native/src/browser/contrib/intelligent-completions/source/base.ts

@@ -69,8 +69,6 @@ export abstract class BaseCodeEditsSource extends Disposable {
   private cancellationTokenSource = new CancellationTokenSource();
   private readonly relationID = observableValue<string | undefined>(this, undefined);
 
-  protected abstract doTrigger(...args: any[]): MaybePromise<void>;
-
   public readonly codeEditsContextBean = disposableObservableValue<CodeEditsContextBean | undefined>(this, undefined);
   public abstract priority: number;
   public abstract mount(): IDisposable;

packages/ai-native/src/browser/contrib/intelligent-completions/source/line-change.source.ts

@@ -1,47 +1,102 @@
 import { Injectable } from '@opensumi/di';
 import { AINativeSettingSectionsId, ECodeEditsSourceTyping, IDisposable } from '@opensumi/ide-core-common';
-import { ICursorPositionChangedEvent, Position } from '@opensumi/ide-monaco';
+import { ICursorPositionChangedEvent, IModelContentChangedEvent } from '@opensumi/ide-monaco';
+import {
+  autorunDelta,
+  derivedHandleChanges,
+  observableFromEvent,
+  recomputeInitiallyAndOnChange,
+} from '@opensumi/ide-monaco/lib/common/observable';
 
 import { BaseCodeEditsSource } from './base';
 
 export interface ILineChangeData {
   currentLineNumber: number;
   preLineNumber?: number;
+  change?: IModelContentChangedEvent;
 }
 
 @Injectable({ multiple: true })
 export class LineChangeCodeEditsSource extends BaseCodeEditsSource {
   public priority = 2;
 
-  private prePosition = this.monacoEditor.getPosition();
-
   public mount(): IDisposable {
+    const modelContentChangeObs = observableFromEvent<IModelContentChangedEvent>(
+      this,
+      this.monacoEditor.onDidChangeModelContent,
+      (event: IModelContentChangedEvent) => event,
+    );
+    const positionChangeObs = observableFromEvent<ICursorPositionChangedEvent>(
+      this,
+      this.monacoEditor.onDidChangeCursorPosition,
+      (event: ICursorPositionChangedEvent) => event,
+    );
+
+    const latestModelContentChangeObs = derivedHandleChanges(
+      {
+        owner: this,
+        createEmptyChangeSummary: () => ({ change: undefined }),
+        handleChange: (ctx, changeSummary: { change: IModelContentChangedEvent | undefined }) => {
+          // 如果只是改了光标则设置 change 为空，避免获取到缓存的 change
+          if (ctx.didChange(positionChangeObs)) {
+            changeSummary.change = undefined;
+          } else {
+            changeSummary.change = modelContentChangeObs.get();
+          }
+          return true;
+        },
+      },
+      (reader, changeSummary) => {
+        positionChangeObs.read(reader);
+        modelContentChangeObs.read(reader);
+        return changeSummary.change;
+      },
+    );
+
+    this.addDispose(recomputeInitiallyAndOnChange(latestModelContentChangeObs));
+
+    let lastModelContent: IModelContentChangedEvent | undefined;
     this.addDispose(
-      this.monacoEditor.onDidChangeCursorPosition((event: ICursorPositionChangedEvent) => {
-        const currentPosition = event.position;
-        if (this.prePosition && this.prePosition.lineNumber !== currentPosition.lineNumber) {
-          this.doTrigger(currentPosition);
-          this.prePosition = currentPosition;
-        }
+      /**
+       * 由于 monaco 的 changeModelContent 事件比 changeCursorPosition 事件先触发，所以这里需要拿上一次的值进行消费
+       * 否则永远返回 undefined
+       */
+      autorunDelta(latestModelContentChangeObs, ({ lastValue }) => {
+        lastModelContent = lastValue;
       }),
     );
-    return this;
-  }
 
-  protected doTrigger(position: Position) {
-    const isLineChangeEnabled = this.preferenceService.getValid(AINativeSettingSectionsId.CodeEditsLineChange, false);
+    this.addDispose(
+      autorunDelta(positionChangeObs, ({ lastValue, newValue }) => {
+        const contentChange = lastModelContent;
 
-    if (!isLineChangeEnabled || !position) {
-      return;
-    }
+        const isLineChangeEnabled = this.preferenceService.getValid(
+          AINativeSettingSectionsId.CodeEditsLineChange,
+          false,
+        );
+        if (!isLineChangeEnabled) {
+          return false;
+        }
 
-    this.setBean({
-      typing: ECodeEditsSourceTyping.LineChange,
-      position,
-      data: {
-        preLineNumber: this.prePosition?.lineNumber,
-        currentLineNumber: position.lineNumber,
-      },
-    });
+        const prePosition = lastValue?.position;
+        const currentPosition = newValue?.position;
+        if (prePosition && prePosition.lineNumber !== currentPosition?.lineNumber) {
+          this.setBean({
+            typing: ECodeEditsSourceTyping.LineChange,
+            position: currentPosition,
+            data: {
+              preLineNumber: prePosition.lineNumber,
+              currentLineNumber: currentPosition.lineNumber,
+              change: contentChange,
+            },
+          });
+        }
+
+        // 消费完之后设置为 undefined，避免下次获取到缓存的值
+        lastModelContent = undefined;
+      }),
+    );
+
+    return this;
   }
 }

packages/express-file-server/src/node/express-file-server.contribution.ts

@@ -44,12 +44,47 @@ export class ExpressFileServerContribution implements ServerAppContribution {
           // 在允许的 contentType
           contentType
         ) {
-          ctx.set('Content-Type', contentType);
+          const range = ctx.headers.range;
+
+          if (!fs.existsSync(filePath)) {
+            ctx.status = 404;
+            ctx.body = '文件未找到';
+            return;
+          }
+
           if (this.appConfig.staticAllowOrigin) {
             ctx.set('Access-Control-Allow-Origin', this.appConfig.staticAllowOrigin);
           }
 
-          ctx.body = fs.createReadStream(filePath);
+          const stats = await fs.promises.stat(filePath);
+          const total = stats.size;
+
+          if (!range) {
+            ctx.status = 200;
+            ctx.set('Content-Type', contentType);
+            ctx.set('Content-Length', String(total));
+            ctx.body = fs.createReadStream(filePath);
+            return;
+          }
+
+          const parts = range.replace(/bytes=/, '').split('-');
+          const start = parseInt(parts[0], 10);
+          const end = parts[1] ? parseInt(parts[1], 10) : total - 1;
+
+          if (start >= total || end >= total || start > end) {
+            ctx.status = 416; // Range Not Satisfiable
+            ctx.set('Content-Range', `bytes */${total}`);
+            return;
+          }
+
+          ctx.status = 206;
+          ctx.set('Content-Range', `bytes ${start}-${end}/${total}`);
+          ctx.set('Accept-Ranges', 'bytes');
+          ctx.set('Content-Length', String(end - start + 1));
+          ctx.set('Content-Type', contentType);
+
+          const stream = fs.createReadStream(filePath, { start, end });
+          ctx.body = stream;
         } else {
           ctx.status = 403;
         }

packages/file-scheme/src/browser/preview.view.tsx

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { memo } from 'react';
 
 import { Disposable, useInjectable } from '@opensumi/ide-core-browser';
 import { StaticResourceService } from '@opensumi/ide-core-browser/lib/static-resource';
@@ -16,15 +16,14 @@ const useResource = (resource: IResource) => {
   };
 };
 
-export const VideoPreview: ReactEditorComponent<null> = (props) => {
+export const VideoPreview: ReactEditorComponent<null> = memo((props) => {
   const { src } = useResource(props.resource);
-
   return (
     <div className={styles.kt_video_preview}>
-      <video autoPlay controls className={styles.kt_video} src={src}></video>
+      <video playsInline controls className={styles.kt_video} src={src} />
     </div>
   );
-};
+});
 
 export const ImagePreview: ReactEditorComponent<null> = (props) => {
   const imgRef = React.useRef<HTMLImageElement>();

packages/file-scheme/src/browser/style.module.less

@@ -43,11 +43,15 @@
 
 .kt_video_preview {
   height: 100%;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  padding: 40px;
 }
 
 .kt_video {
-  width: 100%;
-  height: 100%;
+  max-width: 100%;
+  max-height: 100%;
 }
 
 .error-page {

packages/terminal-next/__tests__/browser/links/word-link-provider.test.ts

@@ -0,0 +1,75 @@
+import { ILink, Terminal } from '@xterm/xterm';
+
+import { URI } from '@opensumi/ide-core-common';
+import { createBrowserInjector } from '@opensumi/ide-dev-tool/src/injector-helper';
+
+import { TerminalWordLinkProvider } from '../../../src/browser/links/word-link-provider';
+
+describe('Workbench - TerminalWordLinkProvider', () => {
+  const injector = createBrowserInjector([]);
+
+  async function assertLink(text: string, isWindows: boolean, expected: { text: string; range: [number, number][] }[]) {
+    const xterm = new Terminal({ allowProposedApi: true });
+    const provider = injector.get(TerminalWordLinkProvider, [
+      xterm,
+      (link: string, callback: (result: { uri: URI; isDirectory: boolean } | undefined) => void) => {},
+      (_: string, cb: (result: { uri: URI; isDirectory: boolean } | undefined) => void) => {
+        cb({ uri: URI.file('/'), isDirectory: false });
+      },
+    ]);
+
+    // Write the text and wait for the parser to finish
+    await new Promise<void>((r) => xterm.write(text, r));
+
+    // Ensure all links are provided
+    const links = (await new Promise<ILink[] | undefined>((r) => provider.provideLinks(1, r)))!;
+    expect(links.length).toStrictEqual(expected.length);
+    const actual = links.map((e) => ({
+      text: e.text,
+      range: e.range,
+    }));
+    const expectedVerbose = expected.map((e) => ({
+      text: e.text,
+      range: {
+        start: { x: e.range[0][0], y: e.range[0][1] },
+        end: { x: e.range[1][0], y: e.range[1][1] },
+      },
+    }));
+
+    expect(actual).toEqual(expectedVerbose);
+  }
+
+  test('parse word link', async () => {
+    const text = '000000.mp4       dist             dsada            dsadas';
+    await assertLink(text, false, [
+      {
+        text: '000000.mp4',
+        range: [
+          [1, 1],
+          [10, 1],
+        ],
+      },
+      {
+        text: 'dist',
+        range: [
+          [18, 1],
+          [21, 1],
+        ],
+      },
+      {
+        text: 'dsada',
+        range: [
+          [35, 1],
+          [39, 1],
+        ],
+      },
+      {
+        text: 'dsadas',
+        range: [
+          [52, 1],
+          [57, 1],
+        ],
+      },
+    ]);
+  });
+});

packages/terminal-next/src/browser/links/link-manager.ts

@@ -41,6 +41,7 @@ import {
   winLineAndColumnMatchIndex,
   winLocalLinkClause,
 } from './validated-local-link-provider';
+import { TerminalWordLinkProvider } from './word-link-provider';
 
 const { posix, win32 } = path;
 
@@ -136,6 +137,13 @@ export class TerminalLinkManager extends Disposable {
     ]);
     this._standardLinkProviders.push(validatedProvider);
 
+    const wordLinkProvider = this.injector.get(TerminalWordLinkProvider, [
+      this._xterm,
+      async (link, cb) => cb(await this._resolvePath(link)),
+      wrappedTextLinkActivateCallback,
+    ]);
+    this._standardLinkProviders.push(wordLinkProvider);
+
     this._registerStandardLinkProviders();
   }
 
@@ -165,8 +173,8 @@ export class TerminalLinkManager extends Disposable {
   ) {
     const core = (this._xterm as any)._core as XTermCore;
     const cellDimensions = {
-      width: core._renderService.dimensions.actualCellWidth,
-      height: core._renderService.dimensions.actualCellHeight,
+      width: core._renderService.dimensions.css.cell.width,
+      height: core._renderService.dimensions.css.cell.height,
     };
     const terminalDimensions = {
       width: this._xterm.cols,