@opensumi/ide-debug 2.21.8-rc-1670567192.0 → 2.21.8

package/src/browser/debug-exception-widget.tsx

@@ -1,89 +0,0 @@
-import React, { useRef } from 'react';
-import ReactDOM from 'react-dom';
-
-import { Injectable, Autowired } from '@opensumi/di';
-import { AppConfig, ConfigProvider, useInjectable } from '@opensumi/ide-core-browser';
-import { formatLocalize, localize } from '@opensumi/ide-core-common';
-import { ICodeEditor } from '@opensumi/ide-monaco';
-import { ZoneWidget } from '@opensumi/ide-monaco-enhance';
-import { EditorOption } from '@opensumi/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
-import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
-
-import { IDebugExceptionInfo } from '../common';
-
-import { LinkDetector } from './debug-link-detector';
-
-import './components/debug-exception-widget.less';
-
-function ExceptionInfoContainer({ info, layout }: { info: IDebugExceptionInfo; layout: () => void }) {
-  const linkDetector = useInjectable<LinkDetector>(LinkDetector);
-  const stackTraceRef = useRef<HTMLDivElement | null>(null);
-
-  React.useEffect(() => {
-    if (stackTraceRef.current) {
-      stackTraceRef.current.appendChild(linkDetector.linkify(info.details?.stackTrace || '', true));
-    }
-    layout();
-  }, [info.details, info.details?.stackTrace, stackTraceRef]);
-
-  return (
-    <div className={'exception_widget'}>
-      <div className={'title'}>
-        <div className={'label'}>
-          {info.id
-            ? formatLocalize('debug.widget.exception.thrownWithId', info.id)
-            : localize('debug.widget.exception.thrown')}
-        </div>
-      </div>
-      {info.description ? <div className={'description'}>{info.description}</div> : null}
-      {info.details && info.details.stackTrace ? <div className={'stack_trace'} ref={stackTraceRef}></div> : null}
-    </div>
-  );
-}
-
-@Injectable({ multiple: true })
-export class DebugExceptionWidget extends ZoneWidget {
-  @Autowired(AppConfig)
-  private configContext: AppConfig;
-
-  constructor(editor: ICodeEditor, private exceptionInfo: IDebugExceptionInfo) {
-    super(editor);
-
-    this.create();
-  }
-
-  protected applyClass(): void {}
-
-  protected applyStyle(): void {}
-
-  protected _fillContainer(container: HTMLElement): void {
-    this.setCssClass('exception_widget_container');
-    const fontInfo = this.editor.getOption(EditorOption.fontInfo);
-    container.style.fontSize = `${fontInfo.fontSize}px`;
-    container.style.lineHeight = `${fontInfo.lineHeight}px`;
-    container.tabIndex = 0;
-
-    ReactDOM.render(
-      <ConfigProvider value={this.configContext}>
-        <ExceptionInfoContainer
-          info={this.exceptionInfo}
-          layout={() => this.layout(undefined)}
-        ></ExceptionInfoContainer>
-      </ConfigProvider>,
-      container,
-    );
-  }
-
-  public layout(_info: monaco.editor.EditorLayoutInfo | undefined): void {
-    this._container!.style.height = 'initial';
-    const lineHeight = this.editor.getOption(EditorOption.lineHeight);
-    const arrowHeight = Math.round(lineHeight / 3);
-    const computedLinesNumber = Math.ceil((this._container!.offsetHeight + arrowHeight) / lineHeight);
-
-    this._relayout(computedLinesNumber);
-  }
-
-  public focus(): void {
-    this._container.focus();
-  }
-}

package/src/browser/debug-link-detector.ts

@@ -1,234 +0,0 @@
-/* ---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-// Some code copied and modified from https://github.com/microsoft/vscode/blob/94c9ea46838a9a619aeafb7e8afd1170c967bb55/src/vs/workbench/contrib/debug/browser/linkDetector.ts
-
-import { Injectable, Autowired } from '@opensumi/di';
-import { Schemes, IOpenerService, OS, formatLocalize } from '@opensumi/ide-core-browser';
-import { URI, IRange, isWindows, isMacintosh, path as osPath, OperatingSystem } from '@opensumi/ide-core-common';
-import { WorkbenchEditorService } from '@opensumi/ide-editor';
-import { IFileServiceClient, FileStat } from '@opensumi/ide-file-service/lib/common';
-import { IWorkspaceFolder } from '@opensumi/monaco-editor-core/esm/vs/platform/workspace/common/workspace';
-
-import styles from './view/console/debug-console.module.less';
-
-const CONTROL_CODES = '\\u0000-\\u0020\\u007f-\\u009f';
-const WEB_LINK_REGEX = new RegExp(
-  '(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s' +
-    CONTROL_CODES +
-    '"]{2,}[^\\s' +
-    CONTROL_CODES +
-    '"\')}\\],:;.!?]',
-  'ug',
-);
-
-const WIN_ABSOLUTE_PATH = /(?:[a-zA-Z]:(?:(?:\\|\/)[\w\.-]*)+)/;
-const WIN_RELATIVE_PATH = /(?:(?:\~|\.)(?:(?:\\|\/)[\w\.-]*)+)/;
-const WIN_PATH = new RegExp(`(${WIN_ABSOLUTE_PATH.source}|${WIN_RELATIVE_PATH.source})`);
-const POSIX_PATH = /((?:\~|\.)?(?:\/[\w\.-]*)+)/;
-const LINE_COLUMN = /(?:\:([\d]+))?(?:\:([\d]+))?/;
-const PATH_LINK_REGEX = new RegExp(`${isWindows ? WIN_PATH.source : POSIX_PATH.source}${LINE_COLUMN.source}`, 'g');
-
-const MAX_LENGTH = 2000;
-
-type LinkKind = 'web' | 'path' | 'text';
-interface LinkPart {
-  kind: LinkKind;
-  value: string;
-  captures: string[];
-}
-
-@Injectable({ multiple: true })
-export class LinkDetector {
-  @Autowired(WorkbenchEditorService)
-  private readonly workbenchEditorService: WorkbenchEditorService;
-
-  @Autowired(IFileServiceClient)
-  private readonly fileServiceClient: IFileServiceClient;
-
-  @Autowired(IOpenerService)
-  private readonly openerService: IOpenerService;
-
-  linkify(text: string, splitLines?: boolean, workspaceFolder?: IWorkspaceFolder): HTMLElement {
-    if (splitLines) {
-      const lines = text.split('\n');
-      for (let i = 0; i < lines.length - 1; i++) {
-        lines[i] = lines[i] + '\n';
-      }
-      if (!lines[lines.length - 1]) {
-        lines.pop();
-      }
-      const elements = lines.map((line) => this.linkify(line, false, workspaceFolder));
-      if (elements.length === 1) {
-        return elements[0];
-      }
-      const container = document.createElement('span');
-      elements.forEach((e) => container.appendChild(e));
-      return container;
-    }
-
-    const container = document.createElement('span');
-    for (const part of this.detectLinks(text)) {
-      try {
-        switch (part.kind) {
-          case 'text':
-            container.appendChild(document.createTextNode(part.value));
-            break;
-          case 'web':
-            container.appendChild(this.createWebLink(part.value));
-            break;
-          case 'path': {
-            const path = part.captures[0];
-            const lineNumber = part.captures[1] ? Number(part.captures[1]) : 0;
-            const columnNumber = part.captures[2] ? Number(part.captures[2]) : 0;
-            container.appendChild(this.createPathLink(part.value, path, lineNumber, columnNumber, workspaceFolder));
-            break;
-          }
-        }
-      } catch (e) {
-        container.appendChild(document.createTextNode(part.value));
-      }
-    }
-    return container;
-  }
-
-  private createWebLink(url: string): Node {
-    const link = this.createLink(url);
-
-    const uri = URI.parse(url);
-    this.decorateLink(link, async () => {
-      if (uri.scheme === Schemes.file) {
-        const fsPath = uri.toString();
-        const path = OS.type() === OperatingSystem.Windows ? osPath.win32 : osPath.posix;
-        const fileUrl = osPath.normalize(
-          path.sep === osPath.posix.sep && isWindows ? fsPath.replace(/\\/g, osPath.posix.sep) : fsPath,
-        );
-
-        await this.workbenchEditorService.open(URI.parse(fileUrl));
-        return;
-      }
-
-      this.openerService.open(url);
-    });
-
-    return link;
-  }
-
-  private createPathLink(
-    text: string,
-    path: string,
-    lineNumber: number,
-    columnNumber: number,
-    workspaceFolder: IWorkspaceFolder | undefined,
-  ): Node {
-    if (path[0] === '/' && path[1] === '/') {
-      return document.createTextNode(text);
-    }
-
-    if (path[0] === '.') {
-      if (!workspaceFolder) {
-        return document.createTextNode(text);
-      }
-      const uri = workspaceFolder.toResource(path);
-      const link = this.createLink(text);
-      this.decorateLink(link, () => {
-        this.workbenchEditorService.open(URI.parse(uri.toString()));
-      });
-      return link;
-    }
-
-    const link = this.createLink(text);
-    link.tabIndex = 0;
-    const uri = URI.file(osPath.normalize(path));
-    this.fileServiceClient.getFileStat(uri.toString()).then((stat: FileStat | undefined) => {
-      if (!stat || (stat && stat.isDirectory)) {
-        return;
-      }
-
-      this.decorateLink(link, () => {
-        this.workbenchEditorService.open(URI.parse(uri.toString()), {
-          range: {
-            startColumn: columnNumber,
-            startLineNumber: lineNumber,
-            endLineNumber: lineNumber,
-            endColumn: columnNumber,
-          } as IRange,
-        });
-      });
-    });
-    return link;
-  }
-
-  private createLink(text: string): HTMLElement {
-    const link = document.createElement('a');
-    link.textContent = text;
-    return link;
-  }
-
-  private decorateLink(link: HTMLElement, onClick: (preserveFocus: boolean) => void) {
-    link.classList.add(styles.link);
-    link.title = formatLocalize('debug.console.followLink', isMacintosh ? 'Cmd' : 'Ctrl');
-    link.onmousemove = (event) => {
-      link.classList.toggle(styles.pointer, isMacintosh ? event.metaKey : event.ctrlKey);
-    };
-    link.onmouseleave = () => link.classList.remove(styles.pointer);
-    link.onclick = (event) => {
-      const selection = window.getSelection();
-      if (!selection || selection.type === 'Range') {
-        return;
-      }
-      if (!(isMacintosh ? event.metaKey : event.ctrlKey)) {
-        return;
-      }
-
-      event.preventDefault();
-      event.stopImmediatePropagation();
-      onClick(false);
-    };
-  }
-
-  private detectLinks(text: string): LinkPart[] {
-    if (!text) {
-      return [];
-    }
-    if (text.length > MAX_LENGTH) {
-      return [{ kind: 'text', value: text, captures: [] }];
-    }
-
-    const regexes: RegExp[] = [WEB_LINK_REGEX, PATH_LINK_REGEX];
-    const kinds: LinkKind[] = ['web', 'path'];
-    const result: LinkPart[] = [];
-
-    const splitOne = (text: string, regexIndex: number) => {
-      if (regexIndex >= regexes.length) {
-        result.push({ value: text, kind: 'text', captures: [] });
-        return;
-      }
-      const regex = regexes[regexIndex];
-      let currentIndex = 0;
-      let match: RegExpExecArray | null;
-      regex.lastIndex = 0;
-      while ((match = regex.exec(text)) !== null) {
-        const stringBeforeMatch = text.substring(currentIndex, match.index);
-        if (stringBeforeMatch) {
-          splitOne(stringBeforeMatch, regexIndex + 1);
-        }
-        const value = match[0];
-        result.push({
-          value,
-          kind: kinds[regexIndex],
-          captures: match.slice(1),
-        });
-        currentIndex = match.index + value.length;
-      }
-      const stringAfterMatches = text.substring(currentIndex);
-      if (stringAfterMatches) {
-        splitOne(stringAfterMatches, regexIndex + 1);
-      }
-    };
-
-    splitOne(text, 0);
-    return result;
-  }
-}

package/src/browser/debug-memory.ts

@@ -1,220 +0,0 @@
-import clamp from 'lodash/clamp';
-
-import { Injectable, Autowired } from '@opensumi/di';
-import { path } from '@opensumi/ide-core-common';
-import {
-  Event,
-  FileSystemProvider,
-  FileChangeEvent,
-  FileStat,
-  FileSystemProviderCapabilities,
-  FileType,
-  Uri,
-  BinaryBuffer,
-  Emitter,
-  Disposable,
-  ILogger,
-} from '@opensumi/ide-core-common';
-
-
-import {
-  DEBUG_MEMORY_SCHEME,
-  IDebugSession,
-  IDebugSessionManager,
-  IMemoryInvalidationEvent,
-  IMemoryRegion,
-  MemoryRange,
-  MemoryRangeType,
-} from '../common';
-
-import { DebugSessionManager } from './debug-session-manager';
-
-const { Path } = path;
-
-@Injectable()
-export class DebugMemoryFileSystemProvider implements FileSystemProvider {
-  @Autowired(IDebugSessionManager)
-  protected readonly debugSessionManager: DebugSessionManager;
-
-  @Autowired(ILogger)
-  protected readonly logger: ILogger;
-
-  private memoryFdCounter = 0;
-  private readonly changeEmitter = new Emitter<FileChangeEvent>();
-  private readonly fdMemory = new Map<number, { session: IDebugSession; region: IMemoryRegion }>();
-
-  public readonly capabilities: FileSystemProviderCapabilities =
-    0 | FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.FileOpenReadWriteClose;
-
-  public readonly onDidChangeCapabilities = Event.None;
-
-  public onDidChangeFile: Event<FileChangeEvent> = this.changeEmitter.event;
-
-  public stat(uri: Uri): Promise<void | FileStat> {
-    return Promise.resolve({
-      type: FileType.File,
-      uri: uri.toString(),
-      mtime: 0,
-      ctime: 0,
-      size: 0,
-      lastModification: 0,
-      isDirectory: false,
-    });
-  }
-
-  public async readFile(uri: Uri): Promise<void | Uint8Array> {
-    const parse = this.parseUri(uri);
-    if (!parse) {
-      return this.toBuffer('');
-    }
-
-    if (!parse.offset) {
-      return this.toBuffer('');
-    }
-
-    const { session, memoryReference, offset } = parse;
-
-    const data = new Uint8Array(offset.toOffset - offset.fromOffset);
-
-    const fd = this.memoryFdCounter++;
-    let region = session.getMemory(memoryReference);
-    if (offset) {
-      region = new MemoryRegionView(region, offset);
-    }
-
-    this.fdMemory.set(fd, { session, region });
-    await this.read(fd, offset.fromOffset, data, 0, data.length);
-    return data;
-  }
-
-  public async read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number | void> {
-    const memory = this.fdMemory.get(fd);
-    if (!memory) {
-      return;
-    }
-
-    const ranges = await memory.region.read(pos, length);
-    let readSoFar = 0;
-    for (const range of ranges) {
-      switch (range.type) {
-        case MemoryRangeType.Unreadable:
-          return readSoFar;
-        case MemoryRangeType.Error:
-          if (readSoFar > 0) {
-            return readSoFar;
-          } else {
-            return this.logger.error(range.error);
-          }
-        case MemoryRangeType.Valid: {
-          const start = Math.max(0, pos - range.offset);
-          const toWrite = range.data.slice(start, Math.min(range.data.byteLength, start + (length - readSoFar)));
-          data.set(toWrite.buffer, offset + readSoFar);
-          readSoFar += toWrite.byteLength;
-          break;
-        }
-        default:
-          this.logger.log(range);
-      }
-    }
-
-    return readSoFar;
-  }
-
-  private toBuffer(s: string): Uint8Array {
-    return BinaryBuffer.fromString(s).buffer;
-  }
-
-  private parseUri(uri: Uri) {
-    if (uri.scheme !== DEBUG_MEMORY_SCHEME) {
-      return;
-    }
-
-    const session = this.debugSessionManager.sessions.find((s) => s.id.toLowerCase() === uri.authority.toLowerCase());
-    if (!session) {
-      return;
-    }
-
-    let offset: { fromOffset: number; toOffset: number } | undefined;
-    /**
-     * query 参数是 hex-editor 插件通过覆盖了 debug file accessor 处理过后添加上的，形如
-     * ?range=0:131072
-     */
-    const rangeMatch = /range=([0-9]+):([0-9]+)/.exec(uri.query);
-    if (rangeMatch) {
-      offset = { fromOffset: Number(rangeMatch[1]), toOffset: Number(rangeMatch[2]) };
-    }
-
-    const [, memoryReference] = uri.path.split(Path.separator);
-
-    return {
-      session,
-      offset,
-      readOnly: !session.capabilities.supportsWriteMemoryRequest,
-      sessionId: uri.authority,
-      memoryReference: decodeURIComponent(memoryReference),
-    };
-  }
-
-  public readDirectory(): never {
-    throw new Error('Not allowed');
-  }
-
-  public createDirectory(): never {
-    throw new Error('Not allowed');
-  }
-
-  public rename(): never {
-    throw new Error('Not allowed');
-  }
-
-  public delete(): never {
-    throw new Error('Not allowed');
-  }
-
-  public watch(): never {
-    throw new Error('Not allowed');
-  }
-
-  /**
-   * 目前仅支持读，不支持写
-   */
-  public writeFile(): never {
-    throw new Error('Method not implemented.');
-  }
-}
-
-class MemoryRegionView extends Disposable implements IMemoryRegion {
-  private readonly invalidateEmitter = new Emitter<IMemoryInvalidationEvent>();
-
-  public readonly onDidInvalidate = this.invalidateEmitter.event;
-  public readonly writable: boolean;
-  private readonly width = this.range.toOffset - this.range.fromOffset;
-
-  constructor(private readonly parent: IMemoryRegion, public readonly range: { fromOffset: number; toOffset: number }) {
-    super();
-    this.writable = parent.writable;
-
-    this.registerDispose(parent);
-    this.registerDispose(
-      parent.onDidInvalidate((e) => {
-        const fromOffset = clamp(e.fromOffset - range.fromOffset, 0, this.width);
-        const toOffset = clamp(e.toOffset - range.fromOffset, 0, this.width);
-        if (toOffset > fromOffset) {
-          this.invalidateEmitter.fire({ fromOffset, toOffset });
-        }
-      }),
-    );
-  }
-
-  public read(fromOffset: number, toOffset: number): Promise<MemoryRange[]> {
-    if (fromOffset < 0) {
-      throw new RangeError(`Invalid fromOffset: ${fromOffset}`);
-    }
-
-    return this.parent.read(this.range.fromOffset + fromOffset, this.range.fromOffset + Math.min(toOffset, this.width));
-  }
-
-  public write(offset: number, data: BinaryBuffer): Promise<number> {
-    return this.parent.write(this.range.fromOffset + offset, data);
-  }
-}

package/src/browser/debug-preferences.ts

@@ -1,70 +0,0 @@
-import { Injector } from '@opensumi/di';
-import {
-  PreferenceSchema,
-  PreferenceProxy,
-  PreferenceService,
-  createPreferenceProxy,
-  PreferenceContribution,
-  localize,
-} from '@opensumi/ide-core-browser';
-
-export const debugPreferencesSchema: PreferenceSchema = {
-  type: 'object',
-  properties: {
-    'debug.trace': {
-      type: 'boolean',
-      default: false,
-      description: localize('preference.debug.trace'),
-    },
-    'debug.debugViewLocation': {
-      enum: ['default', 'left', 'right', 'bottom'],
-      default: 'default',
-      description: localize('preference.debug.debugViewLocation'),
-    },
-    'debug.openDebug': {
-      enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart', 'openOnDebugBreak'],
-      default: 'openOnDebugBreak',
-      description: localize('preference.debug.openDebug'),
-    },
-    'debug.internalConsoleOptions': {
-      enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart'],
-      default: 'openOnFirstSessionStart',
-      description: localize('preference.debug.internalConsoleOptions'),
-    },
-    'debug.allowBreakpointsEverywhere': {
-      type: 'boolean',
-      description: localize('preference.debug.allowBreakpointsEverywhere'),
-      default: false,
-    },
-  },
-};
-
-export class IDebugConfiguration {
-  'debug.trace': boolean;
-  'debug.debugViewLocation': 'default' | 'left' | 'right' | 'bottom';
-  'debug.openDebug': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart' | 'openOnDebugBreak';
-  'debug.internalConsoleOptions': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart';
-  'debug.allowBreakpointsEverywhere': boolean;
-}
-
-export const DebugPreferences = Symbol('DebugPreferences');
-export type DebugPreferences = PreferenceProxy<IDebugConfiguration>;
-
-export function createDebugPreferences(preferences: PreferenceService): DebugPreferences {
-  return createPreferenceProxy(preferences, debugPreferencesSchema);
-}
-
-export function injectDebugPreferences(injector: Injector): void {
-  injector.addProviders({
-    token: DebugPreferences,
-    useFactory: (injector: Injector) => {
-      const preferences = injector.get(PreferenceService);
-      return createDebugPreferences(preferences);
-    },
-  });
-
-  injector.addProviders({
-    token: PreferenceContribution,
-    useValue: { schema: debugPreferencesSchema },
-  });
-}