devtools-tracing 1.0.0

package/lib/front_end/models/text_utils/StreamingContentData.ts

@@ -0,0 +1,108 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Common from '../../core/common/common.js';
+import * as Platform from '../../core/platform/platform.js';
+
+import {ContentData, type ContentDataOrError} from './ContentData.js';
+
+/**
+ * Usage of this class is mostly intended for content that is never "complete".
+ * E.g. streaming XHR/fetch requests.
+ *
+ * Due to the streaming nature this class only supports base64-encoded binary data.
+ * Decoding to text only happens on-demand by clients. This ensures that at most we have
+ * incomplete unicode at the end and not in-between chunks.
+ */
+export class StreamingContentData extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  readonly mimeType: string;
+  readonly #charset?: string;
+
+  readonly #disallowStreaming: boolean;
+
+  #chunks: string[] = [];
+  #contentData?: ContentData;
+
+  private constructor(mimeType: string, charset?: string, initialContent?: ContentData) {
+    super();
+    this.mimeType = mimeType;
+    this.#charset = charset;
+    this.#disallowStreaming = Boolean(initialContent && !initialContent.createdFromBase64);
+    this.#contentData = initialContent;
+  }
+
+  /**
+   * Creates a new StreamingContentData with the given MIME type/charset.
+   */
+  static create(mimeType: string, charset?: string): StreamingContentData {
+    return new StreamingContentData(mimeType, charset);
+  }
+
+  /**
+   * Creates a new StringContentData from an existing ContentData instance.
+   *
+   * Calling `addChunk` is on the resulting `StreamingContentData` is illegal if
+   * `content` was not created from base64 data. The reason is that JavaScript TextEncoder
+   * only supports UTF-8. We can't convert text with arbitrary encoding back to base64 for concatenation.
+   */
+  static from(content: ContentData): StreamingContentData {
+    return new StreamingContentData(content.mimeType, content.charset, content);
+  }
+
+  /** @returns true, if this `ContentData` was constructed from text content or the mime type indicates text that can be decoded */
+  get isTextContent(): boolean {
+    if (this.#contentData) {
+      return this.#contentData.isTextContent;
+    }
+    return Platform.MimeType.isTextType(this.mimeType);
+  }
+
+  /** @param chunk base64 encoded data */
+  addChunk(chunk: string): void {
+    if (this.#disallowStreaming) {
+      throw new Error('Cannot add base64 data to a text-only ContentData.');
+    }
+
+    this.#chunks.push(chunk);
+    this.dispatchEventToListeners(Events.CHUNK_ADDED, {content: this, chunk});
+  }
+
+  /** @returns An immutable ContentData with all the bytes received so far */
+  content(): ContentData {
+    if (this.#contentData && this.#chunks.length === 0) {
+      return this.#contentData;
+    }
+
+    const initialBase64 = this.#contentData?.base64 ?? '';
+    const base64Content =
+        this.#chunks.reduce((acc, chunk) => Platform.StringUtilities.concatBase64(acc, chunk), initialBase64);
+    this.#contentData = new ContentData(base64Content, /* isBase64=*/ true, this.mimeType, this.#charset);
+    this.#chunks = [];
+    return this.#contentData;
+  }
+}
+
+export type StreamingContentDataOrError = StreamingContentData|{error: string};
+
+export const isError = function(contentDataOrError: StreamingContentDataOrError): contentDataOrError is {
+error:
+  string,
+} {
+  return 'error' in contentDataOrError;
+};
+
+export const asContentDataOrError = function(contentDataOrError: StreamingContentDataOrError): ContentDataOrError {
+  if (isError(contentDataOrError)) {
+    return contentDataOrError;
+  }
+  return contentDataOrError.content();
+};
+
+export const enum Events {
+  CHUNK_ADDED = 'ChunkAdded',
+}
+
+export interface EventTypes {
+  [Events.CHUNK_ADDED]: {content: StreamingContentData, chunk: string};
+}

package/lib/front_end/models/text_utils/Text.ts

@@ -0,0 +1,90 @@
+// Copyright 2016 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Platform from '../../core/platform/platform.js';
+
+import {TextCursor} from './TextCursor.js';
+import {SourceRange, TextRange} from './TextRange.js';
+
+export class Text {
+  readonly #value: string;
+  #lineEndings?: number[];
+
+  constructor(value: string) {
+    this.#value = value;
+  }
+
+  lineEndings(): number[] {
+    if (!this.#lineEndings) {
+      this.#lineEndings = Platform.StringUtilities.findLineEndingIndexes(this.#value);
+    }
+    return this.#lineEndings;
+  }
+
+  value(): string {
+    return this.#value;
+  }
+
+  lineCount(): number {
+    const lineEndings = this.lineEndings();
+    return lineEndings.length;
+  }
+
+  offsetFromPosition(lineNumber: number, columnNumber: number): number {
+    return (lineNumber ? this.lineEndings()[lineNumber - 1] + 1 : 0) + columnNumber;
+  }
+
+  positionFromOffset(offset: number): Position {
+    const lineEndings = this.lineEndings();
+    const lineNumber =
+        Platform.ArrayUtilities.lowerBound(lineEndings, offset, Platform.ArrayUtilities.DEFAULT_COMPARATOR);
+    return {lineNumber, columnNumber: offset - (lineNumber && (lineEndings[lineNumber - 1] + 1))};
+  }
+
+  lineAt(lineNumber: number): string {
+    const lineEndings = this.lineEndings();
+    const lineStart = lineNumber > 0 ? lineEndings[lineNumber - 1] + 1 : 0;
+    const lineEnd = lineEndings[lineNumber];
+    let lineContent = this.#value.substring(lineStart, lineEnd);
+    if (lineContent.length > 0 && lineContent.charAt(lineContent.length - 1) === '\r') {
+      lineContent = lineContent.substring(0, lineContent.length - 1);
+    }
+    return lineContent;
+  }
+
+  toSourceRange(range: TextRange): SourceRange {
+    const start = this.offsetFromPosition(range.startLine, range.startColumn);
+    const end = this.offsetFromPosition(range.endLine, range.endColumn);
+    return new SourceRange(start, end - start);
+  }
+
+  toTextRange(sourceRange: SourceRange): TextRange {
+    const cursor = new TextCursor(this.lineEndings());
+    const result = TextRange.createFromLocation(0, 0);
+
+    cursor.resetTo(sourceRange.offset);
+    result.startLine = cursor.lineNumber();
+    result.startColumn = cursor.columnNumber();
+
+    cursor.advance(sourceRange.offset + sourceRange.length);
+    result.endLine = cursor.lineNumber();
+    result.endColumn = cursor.columnNumber();
+    return result;
+  }
+
+  replaceRange(range: TextRange, replacement: string): string {
+    const sourceRange = this.toSourceRange(range);
+    return this.#value.substring(0, sourceRange.offset) + replacement +
+        this.#value.substring(sourceRange.offset + sourceRange.length);
+  }
+
+  extract(range: TextRange): string {
+    const sourceRange = this.toSourceRange(range);
+    return this.#value.substr(sourceRange.offset, sourceRange.length);
+  }
+}
+export interface Position {
+  lineNumber: number;
+  columnNumber: number;
+}

package/lib/front_end/models/text_utils/TextCursor.ts

@@ -0,0 +1,44 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Platform from '../../core/platform/platform.js';
+
+export class TextCursor {
+  readonly #lineEndings: number[];
+
+  #offset = 0;
+  #lineNumber = 0;
+  #columnNumber = 0;
+
+  constructor(lineEndings: number[]) {
+    this.#lineEndings = lineEndings;
+  }
+
+  advance(offset: number): void {
+    this.#offset = offset;
+    while (this.#lineNumber < this.#lineEndings.length && this.#lineEndings[this.#lineNumber] < this.#offset) {
+      ++this.#lineNumber;
+    }
+    this.#columnNumber = this.#lineNumber ? this.#offset - this.#lineEndings[this.#lineNumber - 1] - 1 : this.#offset;
+  }
+
+  offset(): number {
+    return this.#offset;
+  }
+
+  resetTo(offset: number): void {
+    this.#offset = offset;
+    this.#lineNumber =
+        Platform.ArrayUtilities.lowerBound(this.#lineEndings, offset, Platform.ArrayUtilities.DEFAULT_COMPARATOR);
+    this.#columnNumber = this.#lineNumber ? this.#offset - this.#lineEndings[this.#lineNumber - 1] - 1 : this.#offset;
+  }
+
+  lineNumber(): number {
+    return this.#lineNumber;
+  }
+
+  columnNumber(): number {
+    return this.#columnNumber;
+  }
+}

package/lib/front_end/models/text_utils/TextRange.ts

@@ -0,0 +1,266 @@
+// Copyright 2013 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Platform from '../../core/platform/platform.js';
+
+const MAX_SAFE_INT32 = 2 ** 31 - 1;
+
+export interface SerializedTextRange {
+  startLine: number;
+  startColumn: number;
+  endLine: number;
+  endColumn: number;
+}
+
+export class TextRange {
+  constructor(public startLine: number, public startColumn: number, public endLine: number, public endColumn: number) {
+  }
+
+  static createFromLocation(line: number, column: number): TextRange {
+    return new TextRange(line, column, line, column);
+  }
+
+  static createUnboundedFromLocation(line: number, column: number): TextRange {
+    return new TextRange(line, column, MAX_SAFE_INT32, MAX_SAFE_INT32);
+  }
+
+  static fromObject(serializedTextRange: SerializedTextRange): TextRange {
+    return new TextRange(
+        serializedTextRange.startLine, serializedTextRange.startColumn, serializedTextRange.endLine,
+        serializedTextRange.endColumn);
+  }
+
+  static comparator(range1: TextRange, range2: TextRange): number {
+    return range1.compareTo(range2);
+  }
+
+  static fromEdit(oldRange: TextRange, newText: string): TextRange {
+    let endLine: number = oldRange.startLine;
+    let endColumn: number = oldRange.startColumn + newText.length;
+
+    const lineEndings = Platform.StringUtilities.findLineEndingIndexes(newText);
+    if (lineEndings.length > 1) {
+      endLine = oldRange.startLine + lineEndings.length - 1;
+      const len = lineEndings.length;
+      endColumn = lineEndings[len - 1] - lineEndings[len - 2] - 1;
+    }
+    return new TextRange(oldRange.startLine, oldRange.startColumn, endLine, endColumn);
+  }
+
+  isEmpty(): boolean {
+    return this.startLine === this.endLine && this.startColumn === this.endColumn;
+  }
+
+  immediatelyPrecedes(range?: TextRange): boolean {
+    if (!range) {
+      return false;
+    }
+    return this.endLine === range.startLine && this.endColumn === range.startColumn;
+  }
+
+  immediatelyFollows(range?: TextRange): boolean {
+    if (!range) {
+      return false;
+    }
+    return range.immediatelyPrecedes(this);
+  }
+
+  follows(range: TextRange): boolean {
+    return (range.endLine === this.startLine && range.endColumn <= this.startColumn) || range.endLine < this.startLine;
+  }
+
+  get linesCount(): number {
+    return this.endLine - this.startLine;
+  }
+
+  collapseToEnd(): TextRange {
+    return new TextRange(this.endLine, this.endColumn, this.endLine, this.endColumn);
+  }
+
+  collapseToStart(): TextRange {
+    return new TextRange(this.startLine, this.startColumn, this.startLine, this.startColumn);
+  }
+
+  normalize(): TextRange {
+    if (this.startLine > this.endLine || (this.startLine === this.endLine && this.startColumn > this.endColumn)) {
+      return new TextRange(this.endLine, this.endColumn, this.startLine, this.startColumn);
+    }
+    return this.clone();
+  }
+
+  clone(): TextRange {
+    return new TextRange(this.startLine, this.startColumn, this.endLine, this.endColumn);
+  }
+
+  serializeToObject(): {
+    startLine: number,
+    startColumn: number,
+    endLine: number,
+    endColumn: number,
+  } {
+    return {
+      startLine: this.startLine,
+      startColumn: this.startColumn,
+      endLine: this.endLine,
+      endColumn: this.endColumn,
+    };
+  }
+
+  compareTo(other: TextRange): number {
+    if (this.startLine > other.startLine) {
+      return 1;
+    }
+    if (this.startLine < other.startLine) {
+      return -1;
+    }
+    if (this.startColumn > other.startColumn) {
+      return 1;
+    }
+    if (this.startColumn < other.startColumn) {
+      return -1;
+    }
+    return 0;
+  }
+
+  compareToPosition(lineNumber: number, columnNumber: number): number {
+    if (lineNumber < this.startLine || (lineNumber === this.startLine && columnNumber < this.startColumn)) {
+      return -1;
+    }
+    if (lineNumber > this.endLine || (lineNumber === this.endLine && columnNumber > this.endColumn)) {
+      return 1;
+    }
+    return 0;
+  }
+
+  equal(other: TextRange): boolean {
+    return this.startLine === other.startLine && this.endLine === other.endLine &&
+        this.startColumn === other.startColumn && this.endColumn === other.endColumn;
+  }
+
+  relativeTo(line: number, column: number): TextRange {
+    const relative = this.clone();
+
+    if (this.startLine === line) {
+      relative.startColumn -= column;
+    }
+    if (this.endLine === line) {
+      relative.endColumn -= column;
+    }
+
+    relative.startLine -= line;
+    relative.endLine -= line;
+    return relative;
+  }
+
+  relativeFrom(line: number, column: number): TextRange {
+    const relative = this.clone();
+
+    if (this.startLine === 0) {
+      relative.startColumn += column;
+    }
+    if (this.endLine === 0) {
+      relative.endColumn += column;
+    }
+
+    relative.startLine += line;
+    relative.endLine += line;
+    return relative;
+  }
+
+  rebaseAfterTextEdit(originalRange: TextRange, editedRange: TextRange): TextRange {
+    console.assert(originalRange.startLine === editedRange.startLine);
+    console.assert(originalRange.startColumn === editedRange.startColumn);
+    const rebase = this.clone();
+    if (!this.follows(originalRange)) {
+      return rebase;
+    }
+    const lineDelta = editedRange.endLine - originalRange.endLine;
+    const columnDelta = editedRange.endColumn - originalRange.endColumn;
+    rebase.startLine += lineDelta;
+    rebase.endLine += lineDelta;
+    if (rebase.startLine === editedRange.endLine) {
+      rebase.startColumn += columnDelta;
+    }
+    if (rebase.endLine === editedRange.endLine) {
+      rebase.endColumn += columnDelta;
+    }
+    return rebase;
+  }
+
+  toString(): string {
+    return JSON.stringify(this);
+  }
+
+  /**
+   * Checks whether this {@link TextRange} contains the location identified by the
+   * {@link lineNumber} and {@link columnNumber}. The beginning of the text range is
+   * considered inclusive while the end of the text range is considered exclusive
+   * for this comparison, meaning that for example a range `(0,1)-(1,4)` contains the
+   * location `(0,1)` but does not contain the location `(1,4)`.
+   *
+   * @param lineNumber the location's line offset.
+   * @param columnNumber the location's column offset.
+   * @returns `true` if the location identified by {@link lineNumber} and {@link columnNumber}
+   *          is contained within this text range.
+   */
+  containsLocation(lineNumber: number, columnNumber: number): boolean {
+    if (this.startLine === this.endLine) {
+      return this.startLine === lineNumber && this.startColumn <= columnNumber && columnNumber < this.endColumn;
+    }
+    if (this.startLine === lineNumber) {
+      return this.startColumn <= columnNumber;
+    }
+    if (this.endLine === lineNumber) {
+      return columnNumber < this.endColumn;
+    }
+    return this.startLine < lineNumber && lineNumber < this.endLine;
+  }
+
+  get start(): {lineNumber: number, columnNumber: number} {
+    return {lineNumber: this.startLine, columnNumber: this.startColumn};
+  }
+
+  get end(): {lineNumber: number, columnNumber: number} {
+    return {lineNumber: this.endLine, columnNumber: this.endColumn};
+  }
+
+  /**
+   * Checks whether this and `that` {@link TextRange} overlap and if they do, computes the
+   * intersection range. If they don't overlap an empty text range is returned instead (for
+   * which {@link #isEmpty()} yields `true`).
+   *
+   * The beginning of text ranges is considered to be includes while the end of the text
+   * ranges is considered exclusive for the intersection, meaning that for example intersecting
+   * `(0,1)-(1,4)` and `(1,4)-(1,6)` yields an empty range.
+   *
+   * @param that the other text range.
+   * @returns the intersection of this and `that` text range, which might be empty if their don't
+   *          overlap.
+   */
+  intersection(that: TextRange): TextRange {
+    let {startLine, startColumn} = this;
+    if (startLine < that.startLine) {
+      startLine = that.startLine;
+      startColumn = that.startColumn;
+    } else if (startLine === that.startLine) {
+      startColumn = Math.max(startColumn, that.startColumn);
+    }
+    let {endLine, endColumn} = this;
+    if (endLine > that.endLine) {
+      endLine = that.endLine;
+      endColumn = that.endColumn;
+    } else if (endLine === that.endLine) {
+      endColumn = Math.min(endColumn, that.endColumn);
+    }
+    if (startLine > endLine || (startLine === endLine && startColumn >= endColumn)) {
+      return new TextRange(0, 0, 0, 0);
+    }
+    return new TextRange(startLine, startColumn, endLine, endColumn);
+  }
+}
+
+export class SourceRange {
+  constructor(public offset: number, public length: number) {
+  }
+}