@paulirish/trace_engine 0.0.9 → 0.0.11

package/models/trace/Processor.js

@@ -0,0 +1,213 @@
+// Copyright 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Handlers from './handlers/handlers.js';
+import * as Types from './types/types.js';
+export class TraceParseProgressEvent extends Event {
+    data;
+    static eventName = 'traceparseprogress';
+    constructor(data, init = { bubbles: true }) {
+        super(TraceParseProgressEvent.eventName, init);
+        this.data = data;
+    }
+}
+export class TraceProcessor extends EventTarget {
+    // We force the Meta handler to be enabled, so the TraceHandlers type here is
+    // the model handlers the user passes in and the Meta handler.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    #traceHandlers;
+    #status = "IDLE" /* Status.IDLE */;
+    #modelConfiguration = Types.Configuration.DEFAULT;
+    static createWithAllHandlers() {
+        return new TraceProcessor(Handlers.ModelHandlers, Types.Configuration.DEFAULT);
+    }
+    constructor(traceHandlers, modelConfiguration) {
+        super();
+        this.#verifyHandlers(traceHandlers);
+        this.#traceHandlers = {
+            Meta: Handlers.ModelHandlers.Meta,
+            ...traceHandlers,
+        };
+        if (modelConfiguration) {
+            this.#modelConfiguration = modelConfiguration;
+        }
+        this.#passConfigToHandlers();
+    }
+    updateConfiguration(config) {
+        this.#modelConfiguration = config;
+        this.#passConfigToHandlers();
+    }
+    #passConfigToHandlers() {
+        for (const handler of Object.values(this.#traceHandlers)) {
+            // Bit of an odd double check, but without this TypeScript refuses to let
+            // you call the function as it thinks it might be undefined.
+            if ('handleUserConfig' in handler && handler.handleUserConfig) {
+                handler.handleUserConfig(this.#modelConfiguration);
+            }
+        }
+    }
+    /**
+     * When the user passes in a set of handlers, we want to ensure that we have all
+     * the required handlers. Handlers can depend on other handlers, so if the user
+     * passes in FooHandler which depends on BarHandler, they must also pass in
+     * BarHandler too. This method verifies that all dependencies are met, and
+     * throws if not.
+     **/
+    #verifyHandlers(providedHandlers) {
+        // Tiny optimisation: if the amount of provided handlers matches the amount
+        // of handlers in the Handlers.ModelHandlers object, that means that the
+        // user has passed in every handler we have. So therefore they cannot have
+        // missed any, and there is no need to iterate through the handlers and
+        // check the dependencies.
+        if (Object.keys(providedHandlers).length === Object.keys(Handlers.ModelHandlers).length) {
+            return;
+        }
+        const requiredHandlerKeys = new Set();
+        for (const [handlerName, handler] of Object.entries(providedHandlers)) {
+            requiredHandlerKeys.add(handlerName);
+            for (const depName of (handler.deps?.() || [])) {
+                requiredHandlerKeys.add(depName);
+            }
+        }
+        const providedHandlerKeys = new Set(Object.keys(providedHandlers));
+        // We always force the Meta handler to be enabled when creating the
+        // Processor, so if it is missing from the set the user gave us that is OK,
+        // as we will have enabled it anyway.
+        requiredHandlerKeys.delete('Meta');
+        for (const requiredKey of requiredHandlerKeys) {
+            if (!providedHandlerKeys.has(requiredKey)) {
+                throw new Error(`Required handler ${requiredKey} not provided.`);
+            }
+        }
+    }
+    reset() {
+        if (this.#status === "PARSING" /* Status.PARSING */) {
+            throw new Error('Trace processor can\'t reset while parsing.');
+        }
+        const handlers = Object.values(this.#traceHandlers);
+        for (const handler of handlers) {
+            handler.reset();
+        }
+        this.#status = "IDLE" /* Status.IDLE */;
+    }
+    async parse(traceEvents, freshRecording = false) {
+        if (this.#status !== "IDLE" /* Status.IDLE */) {
+            throw new Error(`Trace processor can't start parsing when not idle. Current state: ${this.#status}`);
+        }
+        try {
+            this.#status = "PARSING" /* Status.PARSING */;
+            await this.#parse(traceEvents, freshRecording);
+            this.#status = "FINISHED_PARSING" /* Status.FINISHED_PARSING */;
+        }
+        catch (e) {
+            this.#status = "ERRORED_WHILE_PARSING" /* Status.ERRORED_WHILE_PARSING */;
+            throw e;
+        }
+    }
+    async #parse(traceEvents, freshRecording) {
+        // This iterator steps through all events, periodically yielding back to the
+        // main thread to avoid blocking execution. It uses `dispatchEvent` to
+        // provide status update events, and other various bits of config like the
+        // pause duration and frequency.
+        const { pauseDuration, eventsPerChunk } = this.#modelConfiguration.processing;
+        const traceEventIterator = new TraceEventIterator(traceEvents, pauseDuration, eventsPerChunk);
+        // Convert to array so that we are able to iterate all handlers multiple times.
+        const sortedHandlers = [...sortHandlers(this.#traceHandlers).values()];
+        // Reset.
+        for (const handler of sortedHandlers) {
+            handler.reset();
+        }
+        // Initialize.
+        for (const handler of sortedHandlers) {
+            handler.initialize?.(freshRecording);
+        }
+        // Handle each event.
+        for await (const item of traceEventIterator) {
+            if (item.kind === 2 /* IteratorItemType.STATUS_UPDATE */) {
+                this.dispatchEvent(new TraceParseProgressEvent(item.data));
+                continue;
+            }
+            for (const handler of sortedHandlers) {
+                handler.handleEvent(item.data);
+            }
+        }
+        // Finalize.
+        for (const handler of sortedHandlers) {
+            await handler.finalize?.();
+        }
+    }
+    get data() {
+        if (this.#status !== "FINISHED_PARSING" /* Status.FINISHED_PARSING */) {
+            return null;
+        }
+        const data = {};
+        for (const [name, handler] of Object.entries(this.#traceHandlers)) {
+            Object.assign(data, { [name]: handler.data() });
+        }
+        return data;
+    }
+}
+/**
+ * Some Handlers need data provided by others. Dependencies of a handler handler are
+ * declared in the `deps` field.
+ * @returns A map from trace event handler name to trace event hander whose entries
+ * iterate in such a way that each handler is visited after its dependencies.
+ */
+export function sortHandlers(traceHandlers) {
+    const sortedMap = new Map();
+    const visited = new Set();
+    const visitHandler = (handlerName) => {
+        if (sortedMap.has(handlerName)) {
+            return;
+        }
+        if (visited.has(handlerName)) {
+            let stackPath = '';
+            for (const handler of visited) {
+                if (stackPath || handler === handlerName) {
+                    stackPath += `${handler}->`;
+                }
+            }
+            stackPath += handlerName;
+            throw new Error(`Found dependency cycle in trace event handlers: ${stackPath}`);
+        }
+        visited.add(handlerName);
+        const handler = traceHandlers[handlerName];
+        if (!handler) {
+            return;
+        }
+        const deps = handler.deps?.();
+        if (deps) {
+            deps.forEach(visitHandler);
+        }
+        sortedMap.set(handlerName, handler);
+    };
+    for (const handlerName of Object.keys(traceHandlers)) {
+        visitHandler(handlerName);
+    }
+    return sortedMap;
+}
+class TraceEventIterator {
+    traceEvents;
+    pauseDuration;
+    eventsPerChunk;
+    #eventCount;
+    constructor(traceEvents, pauseDuration, eventsPerChunk) {
+        this.traceEvents = traceEvents;
+        this.pauseDuration = pauseDuration;
+        this.eventsPerChunk = eventsPerChunk;
+        this.#eventCount = 0;
+    }
+    async *[Symbol.asyncIterator]() {
+        for (let i = 0, length = this.traceEvents.length; i < length; i++) {
+            // Every so often we take a break just to render.
+            if (++this.#eventCount % this.eventsPerChunk === 0) {
+                // Take the opportunity to provide status update events.
+                yield { kind: 2 /* IteratorItemType.STATUS_UPDATE */, data: { index: i, total: length } };
+                // Wait for rendering before resuming.
+                await new Promise(resolve => setTimeout(resolve, this.pauseDuration));
+            }
+            yield { kind: 1 /* IteratorItemType.TRACE_EVENT */, data: this.traceEvents[i] };
+        }
+    }
+}
+//# sourceMappingURL=Processor.js.map

package/models/trace/Processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Processor.js","sourceRoot":"","sources":["../../../../../../front_end/models/trace/Processor.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\nimport * as Handlers from './handlers/handlers.js';\nimport * as Types from './types/types.js';\n\nconst enum Status {\n  IDLE = 'IDLE',\n  PARSING = 'PARSING',\n  FINISHED_PARSING = 'FINISHED_PARSING',\n  ERRORED_WHILE_PARSING = 'ERRORED_WHILE_PARSING',\n}\n\nexport type TraceParseEventProgressData = {\n  index: number,\n  total: number,\n};\n\nexport class TraceParseProgressEvent extends Event {\n  static readonly eventName = 'traceparseprogress';\n  constructor(public data: TraceParseEventProgressData, init: EventInit = {bubbles: true}) {\n    super(TraceParseProgressEvent.eventName, init);\n  }\n}\ndeclare global {\n  interface HTMLElementEventMap {\n    [TraceParseProgressEvent.eventName]: TraceParseProgressEvent;\n  }\n}\n\nexport class TraceProcessor<EnabledModelHandlers extends {[key: string]: Handlers.Types.TraceEventHandler}> extends\n    EventTarget {\n  // We force the Meta handler to be enabled, so the TraceHandlers type here is\n  // the model handlers the user passes in and the Meta handler.\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  readonly #traceHandlers: Handlers.Types.HandlersWithMeta<EnabledModelHandlers>;\n  #status = Status.IDLE;\n  #modelConfiguration = Types.Configuration.DEFAULT;\n\n  static createWithAllHandlers(): TraceProcessor<typeof Handlers.ModelHandlers> {\n    return new TraceProcessor(Handlers.ModelHandlers, Types.Configuration.DEFAULT);\n  }\n\n  constructor(traceHandlers: EnabledModelHandlers, modelConfiguration?: Types.Configuration.Configuration) {\n    super();\n\n    this.#verifyHandlers(traceHandlers);\n    this.#traceHandlers = {\n      Meta: Handlers.ModelHandlers.Meta,\n      ...traceHandlers,\n    };\n    if (modelConfiguration) {\n      this.#modelConfiguration = modelConfiguration;\n    }\n    this.#passConfigToHandlers();\n  }\n\n  updateConfiguration(config: Types.Configuration.Configuration): void {\n    this.#modelConfiguration = config;\n    this.#passConfigToHandlers();\n  }\n\n  #passConfigToHandlers(): void {\n    for (const handler of Object.values(this.#traceHandlers)) {\n      // Bit of an odd double check, but without this TypeScript refuses to let\n      // you call the function as it thinks it might be undefined.\n      if ('handleUserConfig' in handler && handler.handleUserConfig) {\n        handler.handleUserConfig(this.#modelConfiguration);\n      }\n    }\n  }\n\n  /**\n   * When the user passes in a set of handlers, we want to ensure that we have all\n   * the required handlers. Handlers can depend on other handlers, so if the user\n   * passes in FooHandler which depends on BarHandler, they must also pass in\n   * BarHandler too. This method verifies that all dependencies are met, and\n   * throws if not.\n   **/\n  #verifyHandlers(providedHandlers: EnabledModelHandlers): void {\n    // Tiny optimisation: if the amount of provided handlers matches the amount\n    // of handlers in the Handlers.ModelHandlers object, that means that the\n    // user has passed in every handler we have. So therefore they cannot have\n    // missed any, and there is no need to iterate through the handlers and\n    // check the dependencies.\n    if (Object.keys(providedHandlers).length === Object.keys(Handlers.ModelHandlers).length) {\n      return;\n    }\n    const requiredHandlerKeys: Set<Handlers.Types.TraceEventHandlerName> = new Set();\n    for (const [handlerName, handler] of Object.entries(providedHandlers)) {\n      requiredHandlerKeys.add(handlerName as Handlers.Types.TraceEventHandlerName);\n      for (const depName of (handler.deps?.() || [])) {\n        requiredHandlerKeys.add(depName);\n      }\n    }\n\n    const providedHandlerKeys = new Set(Object.keys(providedHandlers));\n    // We always force the Meta handler to be enabled when creating the\n    // Processor, so if it is missing from the set the user gave us that is OK,\n    // as we will have enabled it anyway.\n    requiredHandlerKeys.delete('Meta');\n\n    for (const requiredKey of requiredHandlerKeys) {\n      if (!providedHandlerKeys.has(requiredKey)) {\n        throw new Error(`Required handler ${requiredKey} not provided.`);\n      }\n    }\n  }\n\n  reset(): void {\n    if (this.#status === Status.PARSING) {\n      throw new Error('Trace processor can\\'t reset while parsing.');\n    }\n\n    const handlers = Object.values(this.#traceHandlers);\n    for (const handler of handlers) {\n      handler.reset();\n    }\n\n    this.#status = Status.IDLE;\n  }\n\n  async parse(traceEvents: readonly Types.TraceEvents.TraceEventData[], freshRecording = false): Promise<void> {\n    if (this.#status !== Status.IDLE) {\n      throw new Error(`Trace processor can't start parsing when not idle. Current state: ${this.#status}`);\n    }\n    try {\n      this.#status = Status.PARSING;\n      await this.#parse(traceEvents, freshRecording);\n      this.#status = Status.FINISHED_PARSING;\n    } catch (e) {\n      this.#status = Status.ERRORED_WHILE_PARSING;\n      throw e;\n    }\n  }\n\n  async #parse(traceEvents: readonly Types.TraceEvents.TraceEventData[], freshRecording: boolean): Promise<void> {\n    // This iterator steps through all events, periodically yielding back to the\n    // main thread to avoid blocking execution. It uses `dispatchEvent` to\n    // provide status update events, and other various bits of config like the\n    // pause duration and frequency.\n    const {pauseDuration, eventsPerChunk} = this.#modelConfiguration.processing;\n    const traceEventIterator = new TraceEventIterator(traceEvents, pauseDuration, eventsPerChunk);\n\n    // Convert to array so that we are able to iterate all handlers multiple times.\n    const sortedHandlers = [...sortHandlers(this.#traceHandlers).values()];\n    // Reset.\n    for (const handler of sortedHandlers) {\n      handler.reset();\n    }\n\n    // Initialize.\n    for (const handler of sortedHandlers) {\n      handler.initialize?.(freshRecording);\n    }\n\n    // Handle each event.\n    for await (const item of traceEventIterator) {\n      if (item.kind === IteratorItemType.STATUS_UPDATE) {\n        this.dispatchEvent(new TraceParseProgressEvent(item.data));\n        continue;\n      }\n      for (const handler of sortedHandlers) {\n        handler.handleEvent(item.data);\n      }\n    }\n\n    // Finalize.\n    for (const handler of sortedHandlers) {\n      await handler.finalize?.();\n    }\n  }\n\n  get data(): Handlers.Types.EnabledHandlerDataWithMeta<EnabledModelHandlers>|null {\n    if (this.#status !== Status.FINISHED_PARSING) {\n      return null;\n    }\n\n    const data = {};\n    for (const [name, handler] of Object.entries(this.#traceHandlers)) {\n      Object.assign(data, {[name]: handler.data()});\n    }\n\n    return data as Handlers.Types.EnabledHandlerDataWithMeta<EnabledModelHandlers>;\n  }\n}\n\n/**\n * Some Handlers need data provided by others. Dependencies of a handler handler are\n * declared in the `deps` field.\n * @returns A map from trace event handler name to trace event hander whose entries\n * iterate in such a way that each handler is visited after its dependencies.\n */\nexport function sortHandlers(\n    traceHandlers: Partial<{[key in Handlers.Types.TraceEventHandlerName]: Handlers.Types.TraceEventHandler}>):\n    Map<Handlers.Types.TraceEventHandlerName, Handlers.Types.TraceEventHandler> {\n  const sortedMap = new Map<Handlers.Types.TraceEventHandlerName, Handlers.Types.TraceEventHandler>();\n  const visited = new Set<Handlers.Types.TraceEventHandlerName>();\n  const visitHandler = (handlerName: Handlers.Types.TraceEventHandlerName): void => {\n    if (sortedMap.has(handlerName)) {\n      return;\n    }\n    if (visited.has(handlerName)) {\n      let stackPath = '';\n      for (const handler of visited) {\n        if (stackPath || handler === handlerName) {\n          stackPath += `${handler}->`;\n        }\n      }\n      stackPath += handlerName;\n      throw new Error(`Found dependency cycle in trace event handlers: ${stackPath}`);\n    }\n    visited.add(handlerName);\n    const handler = traceHandlers[handlerName];\n    if (!handler) {\n      return;\n    }\n    const deps = handler.deps?.();\n    if (deps) {\n      deps.forEach(visitHandler);\n    }\n    sortedMap.set(handlerName, handler);\n  };\n\n  for (const handlerName of Object.keys(traceHandlers)) {\n    visitHandler(handlerName as Handlers.Types.TraceEventHandlerName);\n  }\n  return sortedMap;\n}\n\nconst enum IteratorItemType {\n  TRACE_EVENT = 1,\n  STATUS_UPDATE = 2,\n}\n\ntype IteratorItem = IteratorTraceEventItem|IteratorStatusUpdateItem;\n\ntype IteratorTraceEventItem = {\n  kind: IteratorItemType.TRACE_EVENT,\n  data: Types.TraceEvents.TraceEventData,\n};\n\ntype IteratorStatusUpdateItem = {\n  kind: IteratorItemType.STATUS_UPDATE,\n  data: TraceParseEventProgressData,\n};\n\nclass TraceEventIterator {\n  #eventCount: number;\n\n  constructor(\n      private traceEvents: readonly Types.TraceEvents.TraceEventData[], private pauseDuration: number,\n      private eventsPerChunk: number) {\n    this.#eventCount = 0;\n  }\n\n  async * [Symbol.asyncIterator](): AsyncGenerator<IteratorItem, void, void> {\n    for (let i = 0, length = this.traceEvents.length; i < length; i++) {\n      // Every so often we take a break just to render.\n      if (++this.#eventCount % this.eventsPerChunk === 0) {\n        // Take the opportunity to provide status update events.\n        yield {kind: IteratorItemType.STATUS_UPDATE, data: {index: i, total: length}};\n        // Wait for rendering before resuming.\n        await new Promise(resolve => setTimeout(resolve, this.pauseDuration));\n      }\n\n      yield {kind: IteratorItemType.TRACE_EVENT, data: this.traceEvents[i]};\n    }\n  }\n}\n"]}

package/models/trace/SDKServices.js

@@ -0,0 +1,104 @@
+import * as SDK from "../../core/sdk/sdk.js";
+const domLookUpSingleNodeCache = /* @__PURE__ */ new Map();
+const domLookUpBatchNodesCache = /* @__PURE__ */ new Map();
+export function _TEST_clearCache() {
+  domLookUpSingleNodeCache.clear();
+  domLookUpBatchNodesCache.clear();
+  layoutShiftSourcesCache.clear();
+  normalizedLayoutShiftNodesCache.clear();
+}
+export async function domNodeForBackendNodeID(modelData, nodeId) {
+  const fromCache = domLookUpSingleNodeCache.get(modelData)?.get(nodeId);
+  if (fromCache !== void 0) {
+    return fromCache;
+  }
+  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+  const domModel = target?.model(SDK.DOMModel.DOMModel);
+  if (!domModel) {
+    return null;
+  }
+  const domNodesMap = await domModel.pushNodesByBackendIdsToFrontend(/* @__PURE__ */ new Set([nodeId]));
+  const result = domNodesMap?.get(nodeId) || null;
+  const cacheForModel = domLookUpSingleNodeCache.get(modelData) || /* @__PURE__ */ new Map();
+  cacheForModel.set(nodeId, result);
+  domLookUpSingleNodeCache.set(modelData, cacheForModel);
+  return result;
+}
+export async function domNodesForMultipleBackendNodeIds(modelData, nodeIds) {
+  const fromCache = domLookUpBatchNodesCache.get(modelData)?.get(nodeIds);
+  if (fromCache) {
+    return fromCache;
+  }
+  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+  const domModel = target?.model(SDK.DOMModel.DOMModel);
+  if (!domModel) {
+    return /* @__PURE__ */ new Map();
+  }
+  const domNodesMap = await domModel.pushNodesByBackendIdsToFrontend(nodeIds) || /* @__PURE__ */ new Map();
+  const cacheForModel = domLookUpBatchNodesCache.get(modelData) || /* @__PURE__ */ new Map();
+  cacheForModel.set(nodeIds, domNodesMap);
+  domLookUpBatchNodesCache.set(modelData, cacheForModel);
+  return domNodesMap;
+}
+const layoutShiftSourcesCache = /* @__PURE__ */ new Map();
+const normalizedLayoutShiftNodesCache = /* @__PURE__ */ new Map();
+export async function sourcesForLayoutShift(modelData, event) {
+  const fromCache = layoutShiftSourcesCache.get(modelData)?.get(event);
+  if (fromCache) {
+    return fromCache;
+  }
+  const impactedNodes = event.args.data?.impacted_nodes;
+  if (!impactedNodes) {
+    return [];
+  }
+  const sources = [];
+  await Promise.all(impactedNodes.map(async (node) => {
+    const domNode = await domNodeForBackendNodeID(modelData, node.node_id);
+    if (domNode) {
+      sources.push({
+        previousRect: new DOMRect(node.old_rect[0], node.old_rect[1], node.old_rect[2], node.old_rect[3]),
+        currentRect: new DOMRect(node.new_rect[0], node.new_rect[1], node.new_rect[2], node.new_rect[3]),
+        node: domNode
+      });
+    }
+  }));
+  const cacheForModel = layoutShiftSourcesCache.get(modelData) || /* @__PURE__ */ new Map();
+  cacheForModel.set(event, sources);
+  layoutShiftSourcesCache.set(modelData, cacheForModel);
+  return sources;
+}
+export async function normalizedImpactedNodesForLayoutShift(modelData, event) {
+  const fromCache = normalizedLayoutShiftNodesCache.get(modelData)?.get(event);
+  if (fromCache) {
+    return fromCache;
+  }
+  const impactedNodes = event.args?.data?.impacted_nodes;
+  if (!impactedNodes) {
+    return [];
+  }
+  let viewportScale = null;
+  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+  const evaluateResult = await target?.runtimeAgent().invoke_evaluate({ expression: "window.devicePixelRatio" });
+  if (evaluateResult?.result.type === "number") {
+    viewportScale = evaluateResult?.result.value ?? null;
+  }
+  if (!viewportScale) {
+    return impactedNodes;
+  }
+  const normalizedNodes = [];
+  for (const impactedNode of impactedNodes) {
+    const newNode = { ...impactedNode };
+    for (let i = 0; i < impactedNode.old_rect.length; i++) {
+      newNode.old_rect[i] /= viewportScale;
+    }
+    for (let i = 0; i < impactedNode.new_rect.length; i++) {
+      newNode.new_rect[i] /= viewportScale;
+    }
+    normalizedNodes.push(newNode);
+  }
+  const cacheForModel = normalizedLayoutShiftNodesCache.get(modelData) || /* @__PURE__ */ new Map();
+  cacheForModel.set(event, normalizedNodes);
+  normalizedLayoutShiftNodesCache.set(modelData, cacheForModel);
+  return normalizedNodes;
+}
+//# sourceMappingURL=SDKServices.js.map

package/models/trace/SDKServices.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../front_end/models/trace/SDKServices.ts"],
+  "sourcesContent": ["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport type * as Protocol from '../../generated/protocol.js';\nimport * as SDK from '../../core/sdk/sdk.js';\nimport type * as Handlers from './handlers/handlers.js';\nimport type * as Types from './types/types.js';\n\nconst domLookUpSingleNodeCache =\n    new Map<Handlers.Types.TraceParseData, Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>>();\nconst domLookUpBatchNodesCache = new Map<\n    Handlers.Types.TraceParseData,\n    Map<Set<Protocol.DOM.BackendNodeId>, Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>>>();\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function _TEST_clearCache(): void {\n  domLookUpSingleNodeCache.clear();\n  domLookUpBatchNodesCache.clear();\n  layoutShiftSourcesCache.clear();\n  normalizedLayoutShiftNodesCache.clear();\n}\n\n/**\n * Looks up the DOM Node on the page for the given BackendNodeId. Uses the\n * provided TraceParseData as the cache and will cache the result after the\n * first lookup.\n */\nexport async function domNodeForBackendNodeID(\n    modelData: Handlers.Types.TraceParseData, nodeId: Protocol.DOM.BackendNodeId): Promise<SDK.DOMModel.DOMNode|null> {\n  const fromCache = domLookUpSingleNodeCache.get(modelData)?.get(nodeId);\n  if (fromCache !== undefined) {\n    return fromCache;\n  }\n\n  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();\n  const domModel = target?.model(SDK.DOMModel.DOMModel);\n  if (!domModel) {\n    return null;\n  }\n\n  const domNodesMap = await domModel.pushNodesByBackendIdsToFrontend(new Set([nodeId]));\n  const result = domNodesMap?.get(nodeId) || null;\n\n  const cacheForModel =\n      domLookUpSingleNodeCache.get(modelData) || new Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>();\n  cacheForModel.set(nodeId, result);\n  domLookUpSingleNodeCache.set(modelData, cacheForModel);\n\n  return result;\n}\n\n/**\n * Takes a set of Protocol.DOM.BackendNodeId ids and will return a map of NodeId=>DOMNode.\n * Results are cached based on 1) the provided TraceParseData and 2) the provided set of IDs.\n */\nexport async function domNodesForMultipleBackendNodeIds(\n    modelData: Handlers.Types.TraceParseData,\n    nodeIds: Set<Protocol.DOM.BackendNodeId>): Promise<Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>> {\n  const fromCache = domLookUpBatchNodesCache.get(modelData)?.get(nodeIds);\n  if (fromCache) {\n    return fromCache;\n  }\n  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();\n  const domModel = target?.model(SDK.DOMModel.DOMModel);\n  if (!domModel) {\n    return new Map();\n  }\n\n  const domNodesMap = await domModel.pushNodesByBackendIdsToFrontend(nodeIds) || new Map();\n\n  const cacheForModel = domLookUpBatchNodesCache.get(modelData) ||\n      new Map<Set<Protocol.DOM.BackendNodeId>, Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode|null>>();\n  cacheForModel.set(nodeIds, domNodesMap);\n  domLookUpBatchNodesCache.set(modelData, cacheForModel);\n\n  return domNodesMap;\n}\n\nconst layoutShiftSourcesCache = new Map<\n    Handlers.Types.TraceParseData, Map<Types.TraceEvents.TraceEventLayoutShift, readonly LayoutShiftSource[]>>();\n\nconst normalizedLayoutShiftNodesCache = new Map<\n    Handlers.Types.TraceParseData,\n    Map<Types.TraceEvents.TraceEventLayoutShift, readonly Types.TraceEvents.TraceImpactedNode[]>>();\n\nexport interface LayoutShiftSource {\n  previousRect: DOMRect;\n  currentRect: DOMRect;\n  node: SDK.DOMModel.DOMNode;\n}\n\n/**\n * Calculates and returns a list of sources for a LayoutShift.\n * Here, a source is considered as a node that moved and contributed to the\n * given LayoutShift existing and the score it was given. Each source returned\n * contains a reference to the DOM Node, and its dimensions (as a DOMRect), both\n * before and now, so we can see how this node changed and how that impacted the\n * layout shift.\n *\n * This data is cached based on the provided model data and the given layout\n * shift, so it is is safe to call multiple times with the same input.\n */\nexport async function sourcesForLayoutShift(\n    modelData: Handlers.Types.TraceParseData,\n    event: Types.TraceEvents.TraceEventLayoutShift): Promise<readonly LayoutShiftSource[]> {\n  const fromCache = layoutShiftSourcesCache.get(modelData)?.get(event);\n  if (fromCache) {\n    return fromCache;\n  }\n  const impactedNodes = event.args.data?.impacted_nodes;\n  if (!impactedNodes) {\n    return [];\n  }\n  const sources: LayoutShiftSource[] = [];\n  await Promise.all(impactedNodes.map(async node => {\n    const domNode = await domNodeForBackendNodeID(modelData, node.node_id);\n    if (domNode) {\n      sources.push({\n        previousRect: new DOMRect(node.old_rect[0], node.old_rect[1], node.old_rect[2], node.old_rect[3]),\n        currentRect: new DOMRect(node.new_rect[0], node.new_rect[1], node.new_rect[2], node.new_rect[3]),\n        node: domNode,\n      });\n    }\n  }));\n  const cacheForModel =\n      layoutShiftSourcesCache.get(modelData) || new Map<Types.TraceEvents.TraceEventLayoutShift, LayoutShiftSource[]>();\n  cacheForModel.set(event, sources);\n  layoutShiftSourcesCache.set(modelData, cacheForModel);\n  return sources;\n}\n\n/**\n * Takes a LayoutShift and normalizes its node dimensions based on the device\n * pixel ratio (DPR) of the user's display.\n * This is required because the Layout Instability API is not based on CSS\n * pixels, but physical pixels. Therefore we need to map these to normalized CSS\n * pixels if we can. For example, if the user is on a device with a DPR of 2,\n * the values of the node dimensions reported by the Instability API need to be\n * divided by 2 to be accurate.\n * This function is safe to call multiple times as results are cached based on\n * the provided model data.\n * See https://crbug.com/1300309 for details.\n */\nexport async function normalizedImpactedNodesForLayoutShift(\n    modelData: Handlers.Types.TraceParseData,\n    event: Types.TraceEvents.TraceEventLayoutShift): Promise<readonly Types.TraceEvents.TraceImpactedNode[]> {\n  const fromCache = normalizedLayoutShiftNodesCache.get(modelData)?.get(event);\n  if (fromCache) {\n    return fromCache;\n  }\n  const impactedNodes = event.args?.data?.impacted_nodes;\n  if (!impactedNodes) {\n    return [];\n  }\n\n  let viewportScale: number|null = null;\n  const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();\n  // Get the CSS-to-physical pixel ratio of the device the inspected\n  // target is running at.\n  const evaluateResult = await target?.runtimeAgent().invoke_evaluate({expression: 'window.devicePixelRatio'});\n  if (evaluateResult?.result.type === 'number') {\n    viewportScale = evaluateResult?.result.value as number ?? null;\n  }\n\n  if (!viewportScale) {\n    // Bail and return the nodes as is.\n    return impactedNodes;\n  }\n\n  const normalizedNodes: Types.TraceEvents.TraceImpactedNode[] = [];\n  for (const impactedNode of impactedNodes) {\n    const newNode = {...impactedNode};\n    for (let i = 0; i < impactedNode.old_rect.length; i++) {\n      newNode.old_rect[i] /= viewportScale;\n    }\n    for (let i = 0; i < impactedNode.new_rect.length; i++) {\n      newNode.new_rect[i] /= viewportScale;\n    }\n    normalizedNodes.push(newNode);\n  }\n\n  const cacheForModel = normalizedLayoutShiftNodesCache.get(modelData) ||\n      new Map<Types.TraceEvents.TraceEventLayoutShift, readonly Types.TraceEvents.TraceImpactedNode[]>();\n  cacheForModel.set(event, normalizedNodes);\n  normalizedLayoutShiftNodesCache.set(modelData, cacheForModel);\n\n  return normalizedNodes;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/TraceProcessor.js

@@ -0,0 +1,133 @@
+import { TraceParseEvent } from "./ModelImpl.js";
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2[Status2["IDLE"] = 0] = "IDLE";
+  Status2[Status2["PARSING"] = 1] = "PARSING";
+  Status2[Status2["FINISHED_PARSING"] = 2] = "FINISHED_PARSING";
+  Status2[Status2["ERRORED_WHILE_PARSING"] = 3] = "ERRORED_WHILE_PARSING";
+  return Status2;
+})(Status || {});
+export class TraceProcessor extends EventTarget {
+  #traceHandlers;
+  #pauseDuration;
+  #pauseFrequencyMs;
+  #status = 0 /* IDLE */;
+  constructor(traceHandlers, { pauseDuration = 20, pauseFrequencyMs = 100 } = {}) {
+    super();
+    this.#traceHandlers = traceHandlers;
+    this.#pauseDuration = pauseDuration;
+    this.#pauseFrequencyMs = pauseFrequencyMs;
+  }
+  reset() {
+    if (this.#status === 1 /* PARSING */) {
+      throw new Error("Trace processor can't reset while parsing.");
+    }
+    const handlers = Object.values(this.#traceHandlers);
+    for (const handler of handlers) {
+      handler.reset();
+    }
+    this.#status = 0 /* IDLE */;
+  }
+  async parse(traceEvents, freshRecording = false) {
+    if (this.#status !== 0 /* IDLE */) {
+      throw new Error("Trace processor can't start parsing when not idle.");
+    }
+    try {
+      this.#status = 1 /* PARSING */;
+      await this.#parse(traceEvents, freshRecording);
+      this.#status = 2 /* FINISHED_PARSING */;
+    } catch (e) {
+      this.#status = 3 /* ERRORED_WHILE_PARSING */;
+      throw e;
+    }
+  }
+  async #parse(traceEvents, freshRecording) {
+    const traceEventIterator = new TraceEventIterator(traceEvents, this.#pauseDuration, this.#pauseFrequencyMs);
+    const sortedHandlers = [...sortHandlers(this.#traceHandlers).values()];
+    for (const handler of sortedHandlers) {
+      handler.reset();
+    }
+    for (const handler of sortedHandlers) {
+      handler.initialize?.(freshRecording);
+    }
+    for await (const item of traceEventIterator) {
+      if (item.kind === IteratorItemType.STATUS_UPDATE) {
+        this.dispatchEvent(new TraceParseEvent(item.data));
+        continue;
+      }
+      for (const handler of sortedHandlers) {
+        handler.handleEvent(item.data);
+      }
+    }
+    for (const handler of sortedHandlers) {
+      await handler.finalize?.();
+    }
+  }
+  get data() {
+    if (this.#status !== 2 /* FINISHED_PARSING */) {
+      return null;
+    }
+    const data = {};
+    for (const [name, handler] of Object.entries(this.#traceHandlers)) {
+      Object.assign(data, { [name]: handler.data() });
+    }
+    return data;
+  }
+}
+export function sortHandlers(traceHandlers) {
+  const sortedMap = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const visitHandler = (handlerName) => {
+    if (sortedMap.has(handlerName)) {
+      return;
+    }
+    if (visited.has(handlerName)) {
+      let stackPath = "";
+      for (const handler2 of visited) {
+        if (stackPath || handler2 === handlerName) {
+          stackPath += `${handler2}->`;
+        }
+      }
+      stackPath += handlerName;
+      throw new Error(`Found dependency cycle in trace event handlers: ${stackPath}`);
+    }
+    visited.add(handlerName);
+    const handler = traceHandlers[handlerName];
+    if (!handler) {
+      return;
+    }
+    const deps = handler.deps?.();
+    if (deps) {
+      deps.forEach(visitHandler);
+    }
+    sortedMap.set(handlerName, handler);
+  };
+  for (const handlerName of Object.keys(traceHandlers)) {
+    visitHandler(handlerName);
+  }
+  return sortedMap;
+}
+var IteratorItemType = /* @__PURE__ */ ((IteratorItemType2) => {
+  IteratorItemType2[IteratorItemType2["TRACE_EVENT"] = 1] = "TRACE_EVENT";
+  IteratorItemType2[IteratorItemType2["STATUS_UPDATE"] = 2] = "STATUS_UPDATE";
+  return IteratorItemType2;
+})(IteratorItemType || {});
+class TraceEventIterator {
+  constructor(traceEvents, pauseDuration, pauseFrequencyMs) {
+    this.traceEvents = traceEvents;
+    this.pauseDuration = pauseDuration;
+    this.pauseFrequencyMs = pauseFrequencyMs;
+    this.#time = performance.now();
+  }
+  #time;
+  async *[Symbol.asyncIterator]() {
+    for (let i = 0, length = this.traceEvents.length; i < length; i++) {
+      if (performance.now() - this.#time > this.pauseFrequencyMs) {
+        this.#time = performance.now();
+        yield { kind: 2 /* STATUS_UPDATE */, data: { index: i, total: length } };
+        await new Promise((resolve) => setTimeout(resolve, this.pauseDuration));
+      }
+      yield { kind: 1 /* TRACE_EVENT */, data: this.traceEvents[i] };
+    }
+  }
+}
+//# sourceMappingURL=TraceProcessor.js.map

package/models/trace/TraceProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../front_end/models/trace/TraceProcessor.ts"],
+  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport type * as Handlers from './handlers/handlers.js';\nimport type * as Types from './types/types.js';\n\nimport {type TraceParseEventProgressData, TraceParseEvent} from './ModelImpl.js';\nconst enum Status {\n  IDLE = 0,\n  PARSING = 1,\n  FINISHED_PARSING = 2,\n  ERRORED_WHILE_PARSING = 3,\n}\n\nexport class TraceProcessor<ModelHandlers extends {[key: string]: Handlers.Types.TraceEventHandler}> extends\n    EventTarget {\n  readonly #traceHandlers: {[key: string]: Handlers.Types.TraceEventHandler};\n  #pauseDuration: number;\n  #pauseFrequencyMs: number;\n  #status = Status.IDLE;\n\n  constructor(traceHandlers: ModelHandlers, {pauseDuration = 20, pauseFrequencyMs = 100} = {}) {\n    super();\n\n    this.#traceHandlers = traceHandlers;\n    this.#pauseDuration = pauseDuration;\n    this.#pauseFrequencyMs = pauseFrequencyMs;\n  }\n\n  reset(): void {\n    if (this.#status === Status.PARSING) {\n      throw new Error('Trace processor can\\'t reset while parsing.');\n    }\n\n    const handlers = Object.values(this.#traceHandlers);\n    for (const handler of handlers) {\n      handler.reset();\n    }\n\n    this.#status = Status.IDLE;\n  }\n\n  async parse(traceEvents: readonly Types.TraceEvents.TraceEventData[], freshRecording = false): Promise<void> {\n    if (this.#status !== Status.IDLE) {\n      throw new Error('Trace processor can\\'t start parsing when not idle.');\n    }\n    try {\n      this.#status = Status.PARSING;\n      await this.#parse(traceEvents, freshRecording);\n      this.#status = Status.FINISHED_PARSING;\n    } catch (e) {\n      this.#status = Status.ERRORED_WHILE_PARSING;\n      throw e;\n    }\n  }\n\n  async #parse(traceEvents: readonly Types.TraceEvents.TraceEventData[], freshRecording: boolean): Promise<void> {\n    // This iterator steps through all events, periodically yielding back to the\n    // main thread to avoid blocking execution. It uses `dispatchEvent` to\n    // provide status update events, and other various bits of config like the\n    // pause duration and frequency.\n    const traceEventIterator = new TraceEventIterator(traceEvents, this.#pauseDuration, this.#pauseFrequencyMs);\n\n    // Convert to array so that we are able to iterate all handlers multiple times.\n    const sortedHandlers = [...sortHandlers(this.#traceHandlers).values()];\n    // Reset.\n    for (const handler of sortedHandlers) {\n      handler.reset();\n    }\n\n    // Initialize.\n    for (const handler of sortedHandlers) {\n      handler.initialize?.(freshRecording);\n    }\n\n    // Handle each event.\n    for await (const item of traceEventIterator) {\n      if (item.kind === IteratorItemType.STATUS_UPDATE) {\n        this.dispatchEvent(new TraceParseEvent(item.data));\n        continue;\n      }\n      for (const handler of sortedHandlers) {\n        handler.handleEvent(item.data);\n      }\n    }\n\n    // Finalize.\n    for (const handler of sortedHandlers) {\n      await handler.finalize?.();\n    }\n  }\n\n  get data(): Handlers.Types.HandlerData<ModelHandlers>|null {\n    if (this.#status !== Status.FINISHED_PARSING) {\n      return null;\n    }\n\n    const data = {};\n    for (const [name, handler] of Object.entries(this.#traceHandlers)) {\n      Object.assign(data, {[name]: handler.data()});\n    }\n\n    return data as Handlers.Types.HandlerData<ModelHandlers>;\n  }\n}\n\n/**\n * Some Handlers need data provided by others. Dependencies of a handler handler are\n * declared in the `deps` field.\n * @returns A map from trace event handler name to trace event hander whose entries\n * iterate in such a way that each handler is visited after its dependencies.\n */\nexport function sortHandlers(\n    traceHandlers: Partial<{[key in Handlers.Types.TraceEventHandlerName]: Handlers.Types.TraceEventHandler}>):\n    Map<Handlers.Types.TraceEventHandlerName, Handlers.Types.TraceEventHandler> {\n  const sortedMap = new Map<Handlers.Types.TraceEventHandlerName, Handlers.Types.TraceEventHandler>();\n  const visited = new Set<Handlers.Types.TraceEventHandlerName>();\n  const visitHandler = (handlerName: Handlers.Types.TraceEventHandlerName): void => {\n    if (sortedMap.has(handlerName)) {\n      return;\n    }\n    if (visited.has(handlerName)) {\n      let stackPath = '';\n      for (const handler of visited) {\n        if (stackPath || handler === handlerName) {\n          stackPath += `${handler}->`;\n        }\n      }\n      stackPath += handlerName;\n      throw new Error(`Found dependency cycle in trace event handlers: ${stackPath}`);\n    }\n    visited.add(handlerName);\n    const handler = traceHandlers[handlerName];\n    if (!handler) {\n      return;\n    }\n    const deps = handler.deps?.();\n    if (deps) {\n      deps.forEach(visitHandler);\n    }\n    sortedMap.set(handlerName, handler);\n  };\n\n  for (const handlerName of Object.keys(traceHandlers)) {\n    visitHandler(handlerName as Handlers.Types.TraceEventHandlerName);\n  }\n  return sortedMap;\n}\n\nconst enum IteratorItemType {\n  TRACE_EVENT = 1,\n  STATUS_UPDATE = 2,\n}\n\ntype IteratorItem = IteratorTraceEventItem|IteratorStatusUpdateItem;\n\ntype IteratorTraceEventItem = {\n  kind: IteratorItemType.TRACE_EVENT,\n  data: Types.TraceEvents.TraceEventData,\n};\n\ntype IteratorStatusUpdateItem = {\n  kind: IteratorItemType.STATUS_UPDATE,\n  data: TraceParseEventProgressData,\n};\n\nclass TraceEventIterator {\n  #time: number;\n\n  constructor(\n      private traceEvents: readonly Types.TraceEvents.TraceEventData[], private pauseDuration: number,\n      private pauseFrequencyMs: number) {\n    this.#time = performance.now();\n  }\n\n  async * [Symbol.asyncIterator](): AsyncGenerator<IteratorItem, void, void> {\n    for (let i = 0, length = this.traceEvents.length; i < length; i++) {\n      // Every so often we take a break just to render.\n      if (performance.now() - this.#time > this.pauseFrequencyMs) {\n        this.#time = performance.now();\n        // Take the opportunity to provide status update events.\n        yield {kind: IteratorItemType.STATUS_UPDATE, data: {index: i, total: length}};\n        // Wait for rendering before resuming.\n        await new Promise(resolve => setTimeout(resolve, this.pauseDuration));\n      }\n\n      yield {kind: IteratorItemType.TRACE_EVENT, data: this.traceEvents[i]};\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/TracingManager.d.ts

@@ -0,0 +1 @@
+export {};

package/models/trace/TracingManager.js

@@ -0,0 +1 @@
+export {};

package/models/trace/TracingManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TracingManager.js","sourceRoot":"","sources":["../../../../../../front_end/models/trace/TracingManager.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2014 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';\nimport * as Protocol from '../../generated/protocol.js';\n\nimport * as SDK from '../../core/sdk/sdk.js';\nimport {type ObjectSnapshot} from './LegacyTracingModel.js';\nimport type * as Types from './types/types.js';\n\nexport class TracingManager extends SDK.SDKModel.SDKModel<void> {\n  readonly #tracingAgent: ProtocolProxyApi.TracingApi;\n  #activeClient: TracingManagerClient|null;\n  #eventBufferSize: number|null;\n  #eventsRetrieved: number;\n  #finishing?: boolean;\n  constructor(target: SDK.Target.Target) {\n    super(target);\n    this.#tracingAgent = target.tracingAgent();\n    target.registerTracingDispatcher(new TracingDispatcher(this));\n\n    this.#activeClient = null;\n    this.#eventBufferSize = 0;\n    this.#eventsRetrieved = 0;\n  }\n\n  bufferUsage(usage?: number, eventCount?: number, percentFull?: number): void {\n    this.#eventBufferSize = eventCount === undefined ? null : eventCount;\n    if (this.#activeClient) {\n      this.#activeClient.tracingBufferUsage(usage || percentFull || 0);\n    }\n  }\n\n  eventsCollected(events: EventPayload[]): void {\n    if (!this.#activeClient) {\n      return;\n    }\n    this.#activeClient.traceEventsCollected(events);\n    this.#eventsRetrieved += events.length;\n    if (!this.#eventBufferSize) {\n      this.#activeClient.eventsRetrievalProgress(0);\n      return;\n    }\n\n    if (this.#eventsRetrieved > this.#eventBufferSize) {\n      this.#eventsRetrieved = this.#eventBufferSize;\n    }\n    this.#activeClient.eventsRetrievalProgress(this.#eventsRetrieved / this.#eventBufferSize);\n  }\n\n  tracingComplete(): void {\n    this.#eventBufferSize = 0;\n    this.#eventsRetrieved = 0;\n    if (this.#activeClient) {\n      this.#activeClient.tracingComplete();\n      this.#activeClient = null;\n    }\n    this.#finishing = false;\n  }\n\n  async reset(): Promise<void> {\n    // If we have an active client, we should try to stop\n    // it before resetting it, else we will leave the\n    // backend in a broken state where it thinks we are in\n    // the middle of tracing, but we think we are not.\n    // Then, any subsequent attempts to record will fail\n    // because the backend will not let us start a second\n    // tracing session.\n    if (this.#activeClient) {\n      await this.#tracingAgent.invoke_end();\n    }\n    this.#eventBufferSize = 0;\n    this.#eventsRetrieved = 0;\n    this.#activeClient = null;\n    this.#finishing = false;\n  }\n\n  // TODO(petermarshall): Use the traceConfig argument instead of deprecated\n  // categories + options.\n  async start(client: TracingManagerClient, categoryFilter: string, options: string):\n      Promise<Protocol.ProtocolResponseWithError> {\n    if (this.#activeClient) {\n      throw new Error('Tracing is already started');\n    }\n    const bufferUsageReportingIntervalMs = 500;\n    this.#activeClient = client;\n    const args = {\n      bufferUsageReportingInterval: bufferUsageReportingIntervalMs,\n      categories: categoryFilter,\n      options: options,\n      transferMode: Protocol.Tracing.StartRequestTransferMode.ReportEvents,\n    };\n    const response = await this.#tracingAgent.invoke_start(args);\n    if (response.getError()) {\n      this.#activeClient = null;\n    }\n    await this.warmupJsProfiler();\n    return response;\n  }\n\n  // CPUProfiler::StartProfiling has a non-trivial cost and we'd prefer it not happen within an\n  // interaction as that complicates debugging interaction latency.\n  // To trigger the StartProfiling interrupt and get the warmup cost out of the way, we send a\n  // very soft invocation to V8.\n  // https://crbug.com/1358602\n  async warmupJsProfiler(): Promise<void> {\n    const runtimeModel = this.target().model(SDK.RuntimeModel.RuntimeModel);\n    if (!runtimeModel) {\n      return;\n    }\n    await runtimeModel.checkSideEffectSupport();\n  }\n\n  stop(): void {\n    if (!this.#activeClient) {\n      throw new Error('Tracing is not started');\n    }\n    if (this.#finishing) {\n      throw new Error('Tracing is already being stopped');\n    }\n    this.#finishing = true;\n    void this.#tracingAgent.invoke_end();\n  }\n}\n\nexport interface TracingManagerClient {\n  traceEventsCollected(events: EventPayload[]): void;\n\n  tracingComplete(): void;\n  tracingBufferUsage(usage: number): void;\n  eventsRetrievalProgress(progress: number): void;\n}\n\nclass TracingDispatcher implements ProtocolProxyApi.TracingDispatcher {\n  readonly #tracingManager: TracingManager;\n  constructor(tracingManager: TracingManager) {\n    this.#tracingManager = tracingManager;\n  }\n\n  bufferUsage({value, eventCount, percentFull}: Protocol.Tracing.BufferUsageEvent): void {\n    this.#tracingManager.bufferUsage(value, eventCount, percentFull);\n  }\n\n  dataCollected({value}: Protocol.Tracing.DataCollectedEvent): void {\n    this.#tracingManager.eventsCollected(value);\n  }\n\n  tracingComplete(): void {\n    this.#tracingManager.tracingComplete();\n  }\n}\n\nSDK.SDKModel.SDKModel.register(TracingManager, {capabilities: SDK.Target.Capability.Tracing, autostart: false});\nexport interface EventPayload {\n  cat?: string;\n  pid: number;\n  tid: number;\n  ts: number;\n  ph: Types.TraceEvents.Phase;\n  name: string;\n  args: {\n    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    sort_index: number,\n    name: string,\n    snapshot: ObjectSnapshot,\n    data: Object|null,\n  };\n  dur: number;\n  id?: string;\n  id2?: {\n    global: (string|undefined),\n    local: (string|undefined),\n  };\n  scope: string;\n}\n"]}

package/models/trace/TreeManipulator.js

@@ -0,0 +1,85 @@
+import * as Platform from "../../core/platform/platform.js";
+export var TreeAction = /* @__PURE__ */ ((TreeAction2) => {
+  TreeAction2["MERGE_FUNCTION"] = "MERGE_FUNCTION";
+  TreeAction2["COLLAPSE_FUNCTION"] = "COLLAPSE_FUNCTION";
+  return TreeAction2;
+})(TreeAction || {});
+export class TreeManipulator {
+  #entryToNode;
+  #lastInvisibleEntries = null;
+  #activeActions = [];
+  constructor(entryToNode) {
+    this.#entryToNode = entryToNode;
+  }
+  applyAction(action) {
+    if (this.#actionIsActive(action)) {
+      return;
+    }
+    this.#activeActions.push(action);
+    this.#lastInvisibleEntries = null;
+  }
+  removeActiveAction(action) {
+    let removedAction = false;
+    this.#activeActions = this.#activeActions.filter((activeAction) => {
+      if (activeAction.type === action.type && activeAction.entry === action.entry) {
+        removedAction = true;
+        return false;
+      }
+      return true;
+    });
+    if (removedAction) {
+      this.#lastInvisibleEntries = null;
+    }
+  }
+  #actionIsActive(action) {
+    return this.#activeActions.some((activeAction) => {
+      return action.entry === activeAction.entry && action.type === activeAction.type;
+    });
+  }
+  invisibleEntries() {
+    if (this.#activeActions.length === 0) {
+      return [];
+    }
+    return this.#calculateInvisibleEntries();
+  }
+  #calculateInvisibleEntries() {
+    if (this.#lastInvisibleEntries) {
+      return this.#lastInvisibleEntries;
+    }
+    const entriesToHide = /* @__PURE__ */ new Set();
+    for (const action of this.#activeActions) {
+      switch (action.type) {
+        case "MERGE_FUNCTION" /* MERGE_FUNCTION */: {
+          entriesToHide.add(action.entry);
+          break;
+        }
+        case "COLLAPSE_FUNCTION" /* COLLAPSE_FUNCTION */: {
+          const entryNode = this.#entryToNode.get(action.entry);
+          if (!entryNode) {
+            continue;
+          }
+          const allAncestors = this.#findAllAncestorsOfNode(entryNode);
+          allAncestors.forEach((ancestor) => entriesToHide.add(ancestor));
+          break;
+        }
+        default:
+          Platform.assertNever(action.type, `Unknown TreeManipulator action: ${action.type}`);
+      }
+    }
+    this.#lastInvisibleEntries = [...entriesToHide];
+    return this.#lastInvisibleEntries;
+  }
+  #findAllAncestorsOfNode(root) {
+    const ancestors = [];
+    const children = [...root.children];
+    while (children.length > 0) {
+      const childNode = children.shift();
+      if (childNode) {
+        ancestors.push(childNode.entry);
+        children.push(...childNode.children);
+      }
+    }
+    return ancestors;
+  }
+}
+//# sourceMappingURL=TreeManipulator.js.map