devtools-tracing 1.1.1 → 1.2.1

package/lib/front_end/core/common/Console.ts

@@ -1,114 +0,0 @@
-// Copyright 2014 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import {ObjectWrapper} from './Object.js';
-import {reveal} from './Revealer.js';
-
-let consoleInstance: Console|undefined;
-
-export class Console extends ObjectWrapper<EventTypes> {
-  readonly #messages: Message[];
-  /**
-   * Instantiable via the instance() factory below.
-   */
-  constructor() {
-    super();
-    this.#messages = [];
-  }
-
-  static instance(opts?: {forceNew: boolean}): Console {
-    if (!consoleInstance || opts?.forceNew) {
-      consoleInstance = new Console();
-    }
-
-    return consoleInstance;
-  }
-
-  static removeInstance(): void {
-    consoleInstance = undefined;
-  }
-
-  /**
-   * Add a message to the Console panel.
-   *
-   * @param text the message text.
-   * @param level the message level.
-   * @param show whether to show the Console panel (if it's not already shown).
-   * @param source the message source.
-   */
-  addMessage(text: string, level = MessageLevel.INFO, show = false, source?: FrontendMessageSource): void {
-    const message = new Message(text, level, Date.now(), show, source);
-    this.#messages.push(message);
-    this.dispatchEventToListeners(Events.MESSAGE_ADDED, message);
-  }
-
-  log(text: string): void {
-    this.addMessage(text, MessageLevel.INFO);
-  }
-
-  warn(text: string, source?: FrontendMessageSource): void {
-    this.addMessage(text, MessageLevel.WARNING, undefined, source);
-  }
-
-  /**
-   * Adds an error message to the Console panel.
-   *
-   * @param text the message text.
-   * @param show whether to show the Console panel (if it's not already shown).
-   */
-  error(text: string, show = true): void {
-    this.addMessage(text, MessageLevel.ERROR, show);
-  }
-
-  messages(): Message[] {
-    return this.#messages;
-  }
-
-  show(): void {
-    void this.showPromise();
-  }
-
-  showPromise(): Promise<void> {
-    return reveal(this);
-  }
-}
-
-export const enum Events {
-  MESSAGE_ADDED = 'messageAdded',
-}
-
-export interface EventTypes {
-  [Events.MESSAGE_ADDED]: Message;
-}
-
-export const enum MessageLevel {
-  INFO = 'info',
-  WARNING = 'warning',
-  ERROR = 'error',
-}
-
-export enum FrontendMessageSource {
-  CSS = 'css',
-  // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
-  ConsoleAPI = 'console-api',
-  ISSUE_PANEL = 'issue-panel',
-  SELF_XSS = 'self-xss',
-}
-
-export class Message {
-  text: string;
-  level: MessageLevel;
-  timestamp: number;
-  show: boolean;
-  source?: FrontendMessageSource;
-  constructor(text: string, level: MessageLevel, timestamp: number, show: boolean, source?: FrontendMessageSource) {
-    this.text = text;
-    this.level = level;
-    this.timestamp = (typeof timestamp === 'number') ? timestamp : Date.now();
-    this.show = show;
-    if (source) {
-      this.source = source;
-    }
-  }
-}

package/lib/front_end/core/common/Debouncer.ts

@@ -1,15 +0,0 @@
-// 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.
-
-/**
- * Debounce utility function, ensures that the function passed in is only called once the function stops being called and the delay has expired.
- */
-export const debounce = function(func: (...args: any[]) => void, delay: number): (...args: any[]) => void {
-  let timer = 0;
-  const debounced = (...args: any[]): void => {
-    clearTimeout(timer);
-    timer = window.setTimeout(() => func(...args), delay);
-  };
-  return debounced;
-};

package/lib/front_end/core/common/EventTarget.ts

@@ -1,52 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import type * as Platform from '../platform/platform.js';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface EventDescriptor<Events = any, T extends keyof Events = any> {
-  eventTarget: EventTarget<Events>;
-  eventType: T;
-  thisObject?: Object;
-  listener: EventListener<Events, T>;
-}
-
-export function removeEventListeners(eventList: EventDescriptor[]): void {
-  for (const eventInfo of eventList) {
-    eventInfo.eventTarget.removeEventListener(eventInfo.eventType, eventInfo.listener, eventInfo.thisObject);
-  }
-  // Do not hold references on unused event descriptors.
-  eventList.splice(0);
-}
-
-// This type can be used as the type parameter for `EventTarget`/`ObjectWrapper`
-// when the set of events is not known at compile time.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type GenericEvents = Record<string, any>;
-
-export type EventPayloadToRestParameters<Events, T extends keyof Events> = Events[T] extends void ? [] : [Events[T]];
-export type EventListener<Events, T extends keyof Events> = (arg0: EventTargetEvent<Events[T], Events>) => void;
-
-export interface EventTarget<Events> {
-  addEventListener<T extends keyof Events>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object):
-      EventDescriptor<Events, T>;
-  once<T extends keyof Events>(eventType: T): Promise<Events[T]>;
-  removeEventListener<T extends keyof Events>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object):
-      void;
-  hasEventListeners(eventType: keyof Events): boolean;
-  dispatchEventToListeners<T extends keyof Events>(
-      eventType: Platform.TypeScriptUtilities.NoUnion<T>,
-      ...[eventData]: EventPayloadToRestParameters<Events, T>): void;
-}
-
-export function fireEvent(name: string, detail: unknown = {}, target: HTMLElement|Window = window): void {
-  const evt = new CustomEvent(name, {bubbles: true, cancelable: true, detail});
-  target.dispatchEvent(evt);
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface EventTargetEvent<T, Events = any> {
-  data: T;
-  source?: EventTarget<Events>;
-}

package/lib/front_end/core/common/Gzip.ts

@@ -1,74 +0,0 @@
-// Copyright 2025 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-/**
- * Quickly determine if gzipped, by seeing if the first 3 bytes of the file header match the gzip signature
- */
-export function isGzip(ab: ArrayBuffer): boolean {
-  const buf = new Uint8Array(ab);
-  if (!buf || buf.length < 3) {
-    return false;
-  }
-  // https://www.rfc-editor.org/rfc/rfc1952#page-6
-  return buf[0] === 0x1F && buf[1] === 0x8B && buf[2] === 0x08;
-}
-
-/** Decode a gzipped _or_ plain text ArrayBuffer to a decoded string */
-export async function arrayBufferToString(ab: ArrayBuffer): Promise<string> {
-  if (isGzip(ab)) {
-    return await decompress(ab);
-  }
-  const str = new TextDecoder('utf-8').decode(ab);
-  return str;
-}
-
-export async function fileToString(file: File): Promise<string> {
-  let stream = file.stream();
-  if (file.type.endsWith('gzip')) {
-    stream = decompressStream(stream);
-  }
-  const arrayBuffer = await new Response(stream).arrayBuffer();
-  const str = new TextDecoder('utf-8').decode(arrayBuffer);
-  return str;
-}
-
-/**
- * Decompress a gzipped ArrayBuffer to a string.
- * Consider using `arrayBufferToString` instead, which can handle both gzipped and plain text buffers.
- */
-export async function decompress(gzippedBuffer: ArrayBuffer): Promise<string> {
-  const buffer = await gzipCodec(gzippedBuffer, new DecompressionStream('gzip'));
-  const str = new TextDecoder('utf-8').decode(buffer);
-  return str;
-}
-export async function compress(str: string): Promise<ArrayBuffer> {
-  const encoded = new TextEncoder().encode(str);
-  const buffer = await gzipCodec(encoded, new CompressionStream('gzip'));
-  return buffer;
-}
-
-/** Private coder/decoder **/
-async function gzipCodec(
-    buffer: Uint8Array<ArrayBufferLike>|ArrayBuffer,
-    codecStream: CompressionStream|DecompressionStream): Promise<ArrayBuffer> {
-  const readable = new ReadableStream({
-    start(controller) {
-      controller.enqueue(buffer);
-      controller.close();
-    }
-  });
-  const codecReadable = readable.pipeThrough(codecStream);
-  // A response is a convenient way to get an ArrayBuffer from a ReadableStream.
-  return await new Response(codecReadable).arrayBuffer();
-}
-
-export function decompressStream(stream: ReadableStream): ReadableStream {
-  // https://github.com/wicg/compression/blob/main/explainer.md#deflate-compress-an-arraybuffer
-  const ds = new DecompressionStream('gzip');
-  return stream.pipeThrough(ds);
-}
-export function compressStream(stream: ReadableStream): ReadableStream {
-  const cs = new CompressionStream('gzip');
-  return stream.pipeThrough(cs);
-}

package/lib/front_end/core/common/JavaScriptMetaData.ts

@@ -1,29 +0,0 @@
-// Copyright 2019 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-export interface DOMPinnedWebIDLProp {
-  global?: boolean;
-  specs?: number;
-  rules?: DOMPinnedWebIDLRule[];
-}
-
-export interface DOMPinnedWebIDLType {
-  inheritance?: string;
-  includes?: string[];
-  props?: Record<string, DOMPinnedWebIDLProp>;
-  rules?: DOMPinnedWebIDLRule[];
-}
-
-export interface DOMPinnedWebIDLRule {
-  when: string;
-  is: string;
-}
-
-export interface JavaScriptMetaData {
-  signaturesForNativeFunction(name: string): string[][]|null;
-
-  signaturesForInstanceMethod(name: string, receiverClassName: string): string[][]|null;
-
-  signaturesForStaticMethod(name: string, receiverConstructorName: string): string[][]|null;
-}

package/lib/front_end/core/common/Lazy.ts

@@ -1,31 +0,0 @@
-// 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.
-
-const UNINITIALIZED = Symbol('uninitialized');
-const ERROR_STATE = Symbol('error');
-
-/**
- * Very basic memoizer. Will only invoke its callback the first time, returning the cached value all subsequent calls.
- */
-export function lazy<T>(producer: () => T): () => symbol | T {
-  let value: T|typeof ERROR_STATE|typeof UNINITIALIZED = UNINITIALIZED;
-  let error: Error = new Error('Initial');
-
-  return (): symbol|T => {
-    if (value === ERROR_STATE) {
-      throw error;
-    } else if (value !== UNINITIALIZED) {
-      return value;
-    }
-
-    try {
-      value = producer();
-      return value;
-    } catch (err) {
-      error = err instanceof Error ? err : new Error(err);
-      value = ERROR_STATE;
-      throw error;
-    }
-  };
-}

package/lib/front_end/core/common/Linkifier.ts

@@ -1,55 +0,0 @@
-// Copyright 2019 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import type * as Platform from '../platform/platform.js';
-
-export abstract class Linkifier {
-  abstract linkify(object: Object, options?: Options): Node;
-
-  static async linkify(object: Object|null, options?: Options): Promise<Node> {
-    if (!object) {
-      throw new Error('Can\'t linkify ' + object);
-    }
-    const linkifierRegistration = getApplicableRegisteredlinkifiers(object)[0];
-    if (!linkifierRegistration) {
-      throw new Error('No linkifiers registered for object ' + object);
-    }
-    const linkifier = await linkifierRegistration.loadLinkifier();
-    return linkifier.linkify(object, options);
-  }
-}
-export interface Options {
-  tooltip?: string;
-  preventKeyboardFocus?: boolean;
-  textContent?: string;
-  // Dynamic links include hyperlinks and anchorlinks -- links that navigate the content.
-  isDynamicLink?: boolean;
-}
-
-const registeredLinkifiers: LinkifierRegistration[] = [];
-
-export function registerLinkifier(registration: LinkifierRegistration): void {
-  registeredLinkifiers.push(registration);
-}
-
-export function getApplicableRegisteredlinkifiers(object: Object): LinkifierRegistration[] {
-  return registeredLinkifiers.filter(isLinkifierApplicableToContextTypes);
-
-  function isLinkifierApplicableToContextTypes(linkifierRegistration: LinkifierRegistration): boolean {
-    if (!linkifierRegistration.contextTypes) {
-      return true;
-    }
-    for (const contextType of linkifierRegistration.contextTypes()) {
-      if (object instanceof contextType) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-export interface LinkifierRegistration {
-  loadLinkifier: () => Promise<Linkifier>;
-  contextTypes?: () => Array<Platform.Constructor.Constructor<unknown>>;
-}

package/lib/front_end/core/common/MapWithDefault.ts

@@ -1,26 +0,0 @@
-// 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.
-
-/**
- * Polyfill of https://github.com/tc39/proposal-upsert with a subclass.
- *
- * TODO: Once the proposal is merged, just replace `MapWithDefault` with `Map` and remove it.
- **/
-export class MapWithDefault<K, V> extends Map<K, V> {
-  getOrInsert(key: K, defaultValue: V): V {
-    if (!this.has(key)) {
-      this.set(key, defaultValue);
-    }
-
-    return this.get(key) as V;
-  }
-
-  getOrInsertComputed(key: K, callbackFunction: (key: K) => V): V {
-    if (!this.has(key)) {
-      this.set(key, callbackFunction(key));
-    }
-
-    return this.get(key) as V;
-  }
-}

package/lib/front_end/core/common/Mutex.ts

@@ -1,55 +0,0 @@
-// Copyright 2022 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-type ReleaseFunction = () => void;
-
-/**
- * Use Mutex class to coordinate local concurrent operations.
- * Once `acquire` promise resolves, you hold the lock and must
- * call `release` function returned by `acquire` to release the
- * lock. Failing to `release` the lock may lead to deadlocks.
- */
-export class Mutex {
-  #locked = false;
-  #acquirers: Array<() => void> = [];
-
-  // This is FIFO.
-  acquire(): Promise<ReleaseFunction> {
-    const state = {resolved: false};
-    if (this.#locked) {
-      return new Promise(resolve => {
-        this.#acquirers.push(() => resolve(this.#release.bind(this, state)));
-      });
-    }
-    this.#locked = true;
-    return Promise.resolve(this.#release.bind(this, state));
-  }
-
-  #release(state: {resolved: boolean}): void {
-    if (state.resolved) {
-      throw new Error('Cannot release more than once.');
-    }
-    state.resolved = true;
-
-    const resolve = this.#acquirers.shift();
-    if (!resolve) {
-      this.#locked = false;
-      return;
-    }
-    resolve();
-  }
-
-  async run<T>(action: () => Promise<T>): Promise<T> {
-    const release = await this.acquire();
-    try {
-      // Note we need to await here because we want the await to release AFTER
-      // that await happens. Returning action() will trigger the release
-      // immediately which is counter to what we want.
-      const result = await action();
-      return result;
-    } finally {
-      release();
-    }
-  }
-}

package/lib/front_end/core/common/Object.ts

@@ -1,145 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-/*
- * Copyright (C) 2008 Apple Inc. All Rights Reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-import type * as Platform from '../platform/platform.js';
-
-import type {
-  EventDescriptor, EventListener, EventPayloadToRestParameters, EventTarget, EventTargetEvent} from './EventTarget.js';
-
-export interface ListenerCallbackTuple<Events, T extends keyof Events> {
-  thisObject?: Object;
-  listener: EventListener<Events, T>;
-  disposed?: boolean;
-}
-
-export class ObjectWrapper<Events> implements EventTarget<Events> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  listeners?: Map<keyof Events, Set<ListenerCallbackTuple<Events, any>>>;
-
-  addEventListener<T extends keyof Events>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object):
-      EventDescriptor<Events, T> {
-    if (!this.listeners) {
-      this.listeners = new Map();
-    }
-
-    let listenersForEventType = this.listeners.get(eventType);
-    if (!listenersForEventType) {
-      listenersForEventType = new Set();
-      this.listeners.set(eventType, listenersForEventType);
-    }
-    listenersForEventType.add({thisObject, listener});
-    return {eventTarget: this, eventType, thisObject, listener};
-  }
-
-  once<T extends keyof Events>(eventType: T): Promise<Events[T]> {
-    return new Promise(resolve => {
-      const descriptor = this.addEventListener(eventType, event => {
-        this.removeEventListener(eventType, descriptor.listener);
-        resolve(event.data);
-      });
-    });
-  }
-
-  removeEventListener<T extends keyof Events>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object):
-      void {
-    const listeners = this.listeners?.get(eventType);
-    if (!listeners) {
-      return;
-    }
-    for (const listenerTuple of listeners) {
-      if (listenerTuple.listener === listener && listenerTuple.thisObject === thisObject) {
-        listenerTuple.disposed = true;
-        listeners.delete(listenerTuple);
-      }
-    }
-
-    if (!listeners.size) {
-      this.listeners?.delete(eventType);
-    }
-  }
-
-  hasEventListeners(eventType: keyof Events): boolean {
-    return Boolean(this.listeners?.has(eventType));
-  }
-
-  dispatchEventToListeners<T extends keyof Events>(
-      eventType: Platform.TypeScriptUtilities.NoUnion<T>,
-      ...[eventData]: EventPayloadToRestParameters<Events, T>): void {
-    const listeners = this.listeners?.get(eventType);
-    if (!listeners) {
-      return;
-    }
-    // `eventData` is typed as `Events[T] | undefined`:
-    //   - `undefined` when `Events[T]` is void.
-    //   - `Events[T]` otherwise.
-    // We cast it to `Events[T]` which is the correct type in all instances, as
-    // `void` will be cast and used as `undefined`.
-    const event = {data: eventData as Events[T], source: this};
-    // Work on a snapshot of the current listeners, callbacks might remove/add
-    // new listeners.
-    for (const listener of [...listeners]) {
-      if (!listener.disposed) {
-        listener.listener.call(listener.thisObject, event);
-      }
-    }
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function eventMixin<Events, Base extends Platform.Constructor.Constructor<object>>(base: Base) {
-  console.assert(base !== HTMLElement);
-  return class EventHandling extends base implements EventTarget<Events> {
-    #events = new ObjectWrapper<Events>();
-
-    addEventListener<T extends keyof Events>(
-        eventType: T, listener: (arg0: EventTargetEvent<Events[T]>) => void,
-        thisObject?: Object): EventDescriptor<Events, T> {
-      return this.#events.addEventListener(eventType, listener, thisObject);
-    }
-
-    once<T extends keyof Events>(eventType: T): Promise<Events[T]> {
-      return this.#events.once(eventType);
-    }
-
-    removeEventListener<T extends keyof Events>(
-        eventType: T, listener: (arg0: EventTargetEvent<Events[T]>) => void, thisObject?: Object): void {
-      this.#events.removeEventListener(eventType, listener, thisObject);
-    }
-
-    hasEventListeners(eventType: keyof Events): boolean {
-      return this.#events.hasEventListeners(eventType);
-    }
-
-    dispatchEventToListeners<T extends keyof Events>(
-        eventType: Platform.TypeScriptUtilities.NoUnion<T>,
-        ...eventData: EventPayloadToRestParameters<Events, T>): void {
-      this.#events.dispatchEventToListeners(eventType, ...eventData);
-    }
-  };
-}