@opensumi/ide-debug 2.21.13-rc-1673418254.0 → 2.21.13

package/src/browser/tree/debug-tree-node.define.ts

@@ -1,768 +0,0 @@
-import { TreeNode, CompositeTreeNode, ITree, ITreeNodeOrCompositeTreeNode } from '@opensumi/ide-components';
-import { MessageType, localize } from '@opensumi/ide-core-browser';
-import { IRange, isDefined } from '@opensumi/ide-core-common';
-import { Range } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/range';
-import { DebugProtocol } from '@opensumi/vscode-debugprotocol/lib/debugProtocol';
-
-import { DebugSession } from '../debug-session';
-
-import { AnsiConsoleNode } from './debug-console-tree-node.define';
-
-const UNDEFINED_VALUE = 'undefined';
-
-export class ExpressionTreeService {
-  constructor(private session?: DebugSession, private source?: DebugProtocol.Source, private line?: number | string) {}
-
-  async resolveChildren(
-    parent?: ExpressionContainer,
-  ): Promise<(ExpressionContainer | ExpressionNode | DebugVirtualVariable)[]> {
-    if (DebugVariableRoot.is(parent) && !parent.variablesReference && !parent.presetChildren) {
-      return (await this.session?.getScopes(parent)) || [];
-    }
-    return await this.doResolve(parent);
-  }
-
-  protected async doResolve(
-    parent?: ExpressionContainer,
-  ): Promise<(ExpressionContainer | DebugVirtualVariable | ExpressionNode)[]> {
-    const result: (ExpressionContainer | DebugVirtualVariable)[] = [];
-    if (!parent) {
-      return result;
-    }
-    if (Array.isArray(parent.presetChildren)) {
-      return parent.presetChildren;
-    }
-    if (!this.session || this.session.terminated) {
-      return result;
-    }
-    const { variablesReference, startOfVariables, indexedVariables } = parent;
-    if (parent.namedVariables) {
-      await this.fetch(result, variablesReference, 'named', parent);
-    }
-    if (indexedVariables) {
-      let chunkSize = ExpressionContainer.BASE_CHUNK_SIZE;
-      while (indexedVariables > chunkSize * ExpressionContainer.BASE_CHUNK_SIZE) {
-        chunkSize *= ExpressionContainer.BASE_CHUNK_SIZE;
-      }
-      if (indexedVariables > chunkSize) {
-        const numberOfChunks = Math.ceil(indexedVariables / chunkSize);
-        for (let i = 0; i < numberOfChunks; i++) {
-          const start = parent.startOfVariables + i * chunkSize;
-          const count = Math.min(chunkSize, indexedVariables - i * chunkSize);
-          result.push(
-            new DebugVirtualVariable(
-              {
-                session: this.session,
-                variablesReference: parent.variablesReference,
-                namedVariables: 0,
-                indexedVariables: count,
-                startOfVariables: start,
-                name: `[${start}..${start + count - 1}]`,
-              },
-              parent,
-            ),
-          );
-        }
-        return result;
-      }
-    }
-    await this.fetch(result, variablesReference, 'indexed', parent, startOfVariables, indexedVariables);
-    return result;
-  }
-
-  protected fetch(
-    result: any,
-    variablesReference: number,
-    filter: 'named',
-    parent?: ExpressionContainer,
-  ): Promise<void>;
-  protected fetch(
-    result: any,
-    variablesReference: number,
-    filter: 'indexed',
-    parent: ExpressionContainer,
-    start: number,
-    count?: number,
-  ): Promise<void>;
-  protected async fetch(
-    result: any,
-    variablesReference: number,
-    filter: 'indexed' | 'named',
-    parent?: ExpressionContainer,
-    start?: number,
-    count?: number,
-  ): Promise<void> {
-    try {
-      const response = await this.session!.sendRequest('variables', { variablesReference, filter, start, count });
-      const { variables } = response.body;
-      for (const variable of variables) {
-        if (variable.variablesReference) {
-          result.push(new DebugVariableContainer(this.session, variable, parent, this.source, this.line));
-        } else {
-          result.push(new DebugVariable((this as any).session, variable, parent));
-        }
-      }
-    } catch (e) {
-      result.push({
-        severity: MessageType.Error,
-        visible: !!e.message,
-        message: e.message,
-      });
-    }
-  }
-
-  sortComparator(a: ITreeNodeOrCompositeTreeNode, b: ITreeNodeOrCompositeTreeNode) {
-    // 当存在 variablesReference 属性时，默认按大小进行排序
-    if (isDefined((a as any).variablesReference) && isDefined((b as any).variablesReference)) {
-      return (a as any).variablesReference - (b as any).variablesReference;
-    }
-    if (a.constructor === b.constructor) {
-      return a.name > b.name ? 1 : a.name < b.name ? -1 : 0;
-    }
-    return CompositeTreeNode.is(a) ? 1 : CompositeTreeNode.is(b) ? -1 : 0;
-  }
-}
-
-export class DebugConsoleTreeService extends ExpressionTreeService {
-  // 按照默认次序排序
-  sortComparator(a: ITreeNodeOrCompositeTreeNode, b: ITreeNodeOrCompositeTreeNode) {
-    if (!a) {
-      return 1;
-    }
-    if (!b) {
-      return -1;
-    }
-    return 0;
-  }
-}
-
-export class ExpressionNode extends TreeNode {
-  public source: DebugProtocol.Source | undefined;
-  public line: number | string | undefined;
-  public variablesReference: number;
-  public namedVariables: number | undefined;
-  public indexedVariables: number | undefined;
-  public memoryReference: string | undefined;
-
-  constructor(options: ExpressionNode.Options, parent?: ExpressionContainer) {
-    super(new ExpressionTreeService(options.session, options.source, options.line) as ITree, parent, undefined, {
-      name: String(options.session?.id),
-    });
-    this.variablesReference = options.variablesReference || 0;
-    this.namedVariables = options.namedVariables;
-    this.indexedVariables = options.indexedVariables;
-    this.memoryReference = options.memoryReference;
-    this.source = options.source;
-    this.line = options.line;
-  }
-
-  get badge() {
-    return this.source ? `${this.source.name}:${this.line}` : '';
-  }
-
-  get displayName() {
-    return this.name;
-  }
-}
-
-export namespace ExpressionNode {
-  export interface Options {
-    session: DebugSession | undefined;
-    variablesReference: number;
-    namedVariables?: number;
-    indexedVariables?: number;
-    startOfVariables?: number;
-    memoryReference?: string;
-    source?: DebugProtocol.Source;
-    line?: number | string;
-  }
-}
-
-export class ExpressionContainer extends CompositeTreeNode {
-  public static readonly BASE_CHUNK_SIZE = 100;
-
-  protected readonly session: DebugSession | undefined;
-  public variablesReference: number;
-  public namedVariables: number | undefined;
-  public indexedVariables: number | undefined;
-  public startOfVariables: number;
-  public memoryReference: string | undefined;
-
-  public source: DebugProtocol.Source | undefined;
-  public line: number | string | undefined;
-
-  public presetChildren: (ExpressionContainer | ExpressionNode)[];
-
-  constructor(options: ExpressionContainer.Options, parent?: ExpressionContainer, tree?: ITree, name?: string) {
-    super(
-      tree || (new ExpressionTreeService(options.session, options.source, options.line) as ITree),
-      parent,
-      undefined,
-      { name: name || options.session?.id },
-    );
-    this.session = options.session;
-    this.variablesReference = options.variablesReference || 0;
-    this.namedVariables = options.namedVariables;
-    this.indexedVariables = options.indexedVariables;
-    this.startOfVariables = options.startOfVariables || 0;
-    this.memoryReference = options.memoryReference;
-    this.source = options.source;
-    this.line = options.line;
-  }
-
-  get badge() {
-    return this.source ? `${this.source.name}:${this.line}` : '';
-  }
-
-  get displayName() {
-    return this.name;
-  }
-
-  get path(): string {
-    /**
-     * 默认实现中，path 是通过 name 进行组装
-     * 而在调试场景中，为了保证每个节点的唯一性，需要为每个节点指定唯一的 path 值
-     * 故这里使用 id 作为 path 值
-     */
-    return String(this.id);
-  }
-}
-
-export namespace ExpressionContainer {
-  export interface Options {
-    session: DebugSession | undefined;
-    variablesReference?: number;
-    namedVariables?: number;
-    indexedVariables?: number;
-    startOfVariables?: number;
-    memoryReference?: string;
-    source?: DebugProtocol.Source;
-    line?: number | string;
-  }
-}
-
-export namespace DebugVirtualVariable {
-  export interface Options extends ExpressionContainer.Options {
-    name: string;
-  }
-}
-
-/**
- * 临时的变量节点，如数组节点需要通过该节点插件成[0..100]
- */
-export class DebugVirtualVariable extends ExpressionContainer {
-  private _name: string;
-
-  constructor(options: DebugVirtualVariable.Options, parent?: ExpressionContainer) {
-    super(options, parent, undefined, options.name);
-    this._name = options.name;
-  }
-}
-
-export class DebugVariable extends ExpressionNode {
-  constructor(
-    public readonly session: DebugSession | undefined,
-    /**
-     * https://code.visualstudio.com/updates/v1_49#_contributable-context-menu-for-variables-view
-     */
-    public readonly variable: DebugProtocol.Variable & { __vscodeVariableMenuContext?: string },
-    parent?: ExpressionContainer,
-  ) {
-    super(
-      {
-        session,
-        variablesReference: variable.variablesReference,
-        namedVariables: variable.namedVariables,
-        indexedVariables: variable.indexedVariables,
-        memoryReference: variable.memoryReference,
-      },
-      parent,
-    );
-  }
-
-  get variableMenuContext(): string {
-    return this.variable.__vscodeVariableMenuContext || '';
-  }
-
-  toDebugProtocolObject(): DebugProtocol.Variable {
-    return {
-      name: this.name,
-      variablesReference: this.variable.variablesReference || 0,
-      value: this.value,
-      evaluateName: this.evaluateName,
-      memoryReference: this.memoryReference,
-    };
-  }
-
-  get name(): string {
-    if (this.variable) {
-      if (this.variable.name) {
-        return this.variable.name;
-      } else if (this.variable.evaluateName) {
-        const isSymbolExpression = /\["(.+)"]/.exec(this.variable.evaluateName);
-        if (isSymbolExpression) {
-          return isSymbolExpression[1];
-        } else {
-          const evaluateProps = this.variable.evaluateName.split('.');
-          return evaluateProps[evaluateProps.length - 1];
-        }
-      }
-    }
-    return String(this.id);
-  }
-
-  get evaluateName(): string {
-    return this.variable?.evaluateName || '';
-  }
-
-  get description(): string {
-    return this.value || UNDEFINED_VALUE;
-  }
-
-  protected _value: string | undefined;
-  get value(): string {
-    return this._value || this.variable.value;
-  }
-
-  protected _type: string | undefined;
-  get variableType(): string | undefined {
-    return this._type || this.variable.type;
-  }
-
-  get supportSetVariable(): boolean {
-    return !!this.session && !!this.session.capabilities.supportsSetVariable;
-  }
-
-  async setValue(value: string): Promise<void> {
-    if (!this.session || this.session.terminated) {
-      return;
-    }
-    const { name, parent } = this;
-    const variablesReference = (parent as DebugScope).variablesReference;
-    try {
-      const response = await this.session.sendRequest('setVariable', { variablesReference, name, value });
-      this._value = response.body.value;
-      this._type = response.body.type;
-      this.variablesReference = response.body.variablesReference || 0;
-      this.namedVariables = response.body.namedVariables;
-      this.indexedVariables = response.body.indexedVariables;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  public getRawScope(): DebugProtocol.Scope | undefined {
-    let parent = this.parent;
-    while (parent !== undefined && !(parent instanceof DebugScope)) {
-      parent = parent?.parent;
-    }
-    return parent!.getRawScope();
-  }
-}
-
-export class DebugVariableContainer extends ExpressionContainer {
-  static BOOLEAN_REGEX = /^true|false$/i;
-  static STRING_REGEX = /^(['"]).*\1$/;
-
-  constructor(
-    public readonly session: DebugSession | undefined,
-    public readonly variable: DebugProtocol.Variable & { __vscodeVariableMenuContext?: string },
-    parent: ExpressionContainer | undefined,
-    source?: DebugProtocol.Source,
-    line?: string | number,
-  ) {
-    super(
-      {
-        session,
-        variablesReference: variable.variablesReference,
-        namedVariables: variable.namedVariables,
-        indexedVariables: variable.indexedVariables,
-        memoryReference: variable.memoryReference,
-        source,
-        line,
-      },
-      parent,
-      undefined,
-      variable?.name ||
-        (variable.evaluateName
-          ? /\["(.+)"]/.exec(variable.evaluateName)
-            ? /\["(.+)"]/.exec(variable.evaluateName)![1]
-            : variable.evaluateName.split('.')[variable.evaluateName.split('.').length - 1]
-          : ''),
-    );
-  }
-
-  get variableMenuContext(): string {
-    return this.variable.__vscodeVariableMenuContext || '';
-  }
-
-  toDebugProtocolObject(): DebugProtocol.Variable {
-    return {
-      name: this.name,
-      variablesReference: this.variable.variablesReference || 0,
-      value: this.value,
-      evaluateName: this.evaluateName,
-      memoryReference: this.memoryReference,
-    };
-  }
-
-  get name(): string {
-    if (this.variable) {
-      if (this.variable.name) {
-        return this.variable.name;
-      } else if (this.variable.evaluateName) {
-        const isSymbolExpression = /\["(.+)"]/.exec(this.variable.evaluateName);
-        if (isSymbolExpression) {
-          return isSymbolExpression[1];
-        } else {
-          const evaluateProps = this.variable.evaluateName.split('.');
-          return evaluateProps[evaluateProps.length - 1];
-        }
-      }
-    }
-    return String(this.id);
-  }
-
-  get evaluateName(): string {
-    return this.variable?.evaluateName || '';
-  }
-
-  get description(): string {
-    return this._value || this.variable.value || UNDEFINED_VALUE;
-  }
-
-  get tooltip(): string {
-    return this.variableType || this.description;
-  }
-
-  protected _variableType: string | undefined;
-  get variableType(): string | undefined {
-    return this._variableType || this.variable.type;
-  }
-
-  protected _value: string | undefined;
-  get value(): string {
-    return this._value || this.variable.value;
-  }
-
-  get supportSetVariable(): boolean {
-    return !!this.session && !!this.session.capabilities.supportsSetVariable;
-  }
-
-  async setValue(value: string): Promise<void> {
-    if (!this.session || this.session.terminated) {
-      return;
-    }
-    const { name, parent } = this;
-    if (!parent) {
-      return;
-    }
-    const variablesReference = (parent as DebugScope).variablesReference;
-    try {
-      const response = await this.session.sendRequest('setVariable', { variablesReference, name, value });
-      this._value = response.body.value;
-      this._variableType = response.body.type;
-      this.variablesReference = response.body.variablesReference || 0;
-      this.namedVariables = response.body.namedVariables;
-      this.indexedVariables = response.body.indexedVariables;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  public getRawScope(): DebugProtocol.Scope | undefined {
-    let parent = this.parent;
-    while (parent !== undefined && !(parent instanceof DebugScope)) {
-      parent = parent?.parent;
-    }
-    return parent!.getRawScope();
-  }
-}
-
-export class DebugScope extends ExpressionContainer {
-  constructor(
-    protected readonly raw: DebugProtocol.Scope,
-    protected readonly session: DebugSession,
-    parent?: ExpressionContainer,
-  ) {
-    super(
-      {
-        session,
-        variablesReference: raw.variablesReference,
-        namedVariables: raw.namedVariables,
-        indexedVariables: raw.indexedVariables,
-      },
-      parent,
-      undefined,
-      raw.name,
-    );
-  }
-
-  public getRawScope(): DebugProtocol.Scope {
-    return this.raw;
-  }
-
-  public range(): IRange | undefined {
-    const rs = this.getRawScope();
-    return rs.line && rs.column && rs.endLine && rs.endColumn
-      ? new Range(rs.line, rs.column, rs.endLine, rs.endColumn)
-      : undefined;
-  }
-}
-
-export class DebugWatchNode extends ExpressionContainer {
-  static notAvailable = localize('debug.watch.notAvailable');
-
-  static is(node?: any): node is DebugWatchNode {
-    return !!node && !!(node as DebugWatchNode).expression;
-  }
-
-  private _description: string;
-  private _available: boolean;
-  private raw: DebugProtocol.EvaluateResponse['body'];
-
-  constructor(
-    public readonly session: DebugSession | undefined,
-    public readonly expression: string,
-    parent: ExpressionContainer | undefined,
-  ) {
-    super(
-      {
-        session,
-      },
-      parent,
-      undefined,
-      expression,
-    );
-  }
-
-  get description() {
-    return this._available ? this._description || UNDEFINED_VALUE : DebugWatchNode.notAvailable;
-  }
-
-  get available() {
-    return this._available;
-  }
-
-  public getRawWatch(): DebugProtocol.EvaluateResponse['body'] {
-    return this.raw;
-  }
-
-  async evaluate(context = 'watch'): Promise<void> {
-    if (this.session) {
-      try {
-        this._available = true;
-        const { expression } = this;
-        const body = await this.session.evaluate(expression, context);
-        if (body) {
-          this.name = this.expression;
-          this._description = body.result;
-          this.variablesReference = body.variablesReference;
-          this.namedVariables = body.namedVariables;
-          this.indexedVariables = body.indexedVariables;
-          this.memoryReference = body.memoryReference;
-          this.raw = body;
-        }
-      } catch (err) {
-        this.name = this.expression;
-        this._description = err.message;
-      }
-    } else {
-      this.name = this.expression;
-      this._available = false;
-    }
-  }
-
-  async getClipboardValue() {
-    if (this.session && this.session.capabilities.supportsValueFormattingOptions) {
-      try {
-        const { expression } = this;
-        const body = await this.session.evaluate(expression, 'clipboard');
-        if (body) {
-          return body.result;
-        }
-      } catch (err) {
-        return '';
-      }
-    } else {
-      return this._description;
-    }
-  }
-}
-
-export class DebugConsoleVariableContainer extends DebugVariableContainer {
-  static is(node?: any): node is DebugConsoleVariableContainer {
-    return !!node && (node as DebugConsoleVariableContainer).uniqueID === DebugConsoleVariableContainer.uniqueID;
-  }
-
-  static uniqueID = 'DebugConsoleVariable';
-
-  get uniqueID() {
-    return DebugConsoleVariableContainer.uniqueID;
-  }
-
-  get description() {
-    if (this.variable) {
-      return this.variable.value;
-    }
-    return UNDEFINED_VALUE;
-  }
-
-  get tooltip() {
-    if (this.variable) {
-      return this.variable.value;
-    }
-    return '';
-  }
-}
-
-export class DebugConsoleNode extends ExpressionContainer {
-  static is(node?: any): node is DebugConsoleNode {
-    return !!node && !!(node as DebugConsoleNode).expression;
-  }
-
-  private _available: boolean;
-  private _description: string;
-
-  get available() {
-    return this._available;
-  }
-
-  constructor(
-    public readonly session: DebugSession | undefined,
-    public readonly expression: string,
-    parent: ExpressionContainer | undefined,
-  ) {
-    super(
-      {
-        session,
-      },
-      parent,
-      undefined,
-      expression,
-    );
-  }
-
-  get description() {
-    return this._description || UNDEFINED_VALUE;
-  }
-
-  async evaluate(context = 'repl'): Promise<void> {
-    const { expression } = this;
-    if (this.session) {
-      try {
-        if (typeof expression === 'string') {
-          const body = await this.session.evaluate(expression, context);
-          if (body) {
-            this.name = expression;
-            this._description = body.result;
-            this.variablesReference = body.variablesReference;
-            this.namedVariables = body.namedVariables;
-            this.indexedVariables = body.indexedVariables;
-            this.memoryReference = body.memoryReference;
-            this._available = true;
-          }
-        }
-      } catch (err) {
-        this._available = false;
-        this.name = expression;
-        this._description = err.message;
-      }
-    } else {
-      this._available = false;
-      this.name = expression;
-    }
-  }
-}
-
-export class DebugConsoleRoot extends ExpressionContainer {
-  static is(node?: ExpressionContainer): node is DebugConsoleRoot {
-    return !!node && !node.parent;
-  }
-
-  constructor(public readonly session: DebugSession | undefined, presets: DebugConsoleNode[] = []) {
-    super({ session }, undefined, new DebugConsoleTreeService(session) as ITree);
-    this.presetChildren = presets;
-  }
-
-  get expanded() {
-    return true;
-  }
-
-  updatePresetChildren(presets: (AnsiConsoleNode | DebugConsoleNode | DebugVariableContainer)[]) {
-    this.presetChildren = presets as (ExpressionNode | ExpressionContainer)[];
-  }
-}
-
-export class DebugWatchRoot extends ExpressionContainer {
-  static is(node?: ExpressionContainer): node is DebugWatchRoot {
-    return !!node && !node.parent;
-  }
-
-  constructor(public readonly session: DebugSession | undefined, presets: DebugWatchNode[] = []) {
-    super({ session }, undefined);
-    this.presetChildren = presets;
-  }
-
-  get expanded() {
-    return true;
-  }
-
-  updatePresetChildren(presets: DebugWatchNode[]) {
-    this.presetChildren = presets;
-  }
-}
-
-export class DebugVariableRoot extends DebugVariableContainer {
-  static is(node?: ExpressionContainer): node is DebugVariableRoot {
-    return !!node && !node.parent;
-  }
-
-  constructor(public readonly session: DebugSession | undefined) {
-    super(session, {} as any, undefined);
-  }
-
-  get expanded() {
-    return true;
-  }
-}
-
-export class DebugHoverVariableRoot extends ExpressionContainer {
-  private _value = '';
-
-  constructor(protected readonly expression: string, protected readonly session: DebugSession | undefined) {
-    super({ session });
-  }
-
-  get name() {
-    return this._value;
-  }
-
-  protected _available = false;
-  get available(): boolean {
-    return this._available;
-  }
-
-  async evaluate(context = 'repl'): Promise<void> {
-    if (this.session) {
-      try {
-        const { expression } = this;
-        const body = await this.session.evaluate(expression, context);
-        if (body) {
-          this._value = body.result;
-          this._available = true;
-          this.variablesReference = body.variablesReference;
-          this.namedVariables = body.namedVariables;
-          this.indexedVariables = body.indexedVariables;
-          this.memoryReference = body.memoryReference;
-        }
-      } catch (err) {
-        this._value = err.message;
-        this._available = false;
-      }
-    } else {
-      this._value = 'Please start a debug session to evaluate';
-      this._available = false;
-    }
-  }
-}