@nimbus21.ai/chrome-devtools-mcp 0.6.3 → 0.12.2

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/graph/BaseNode.js

@@ -1,276 +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.
-import * as Core from '../core/core.js';
-/**
- * @file This class encapsulates logic for handling resources and tasks used to model the
- * execution dependency graph of the page. A node has a unique identifier and can depend on other
- * nodes/be depended on. The construction of the graph maintains some important invariants that are
- * inherent to the model:
- *
- *    1. The graph is a DAG, there are no cycles.
- *    2. There is always a root node upon which all other nodes eventually depend.
- *
- * This allows particular optimizations in this class so that we do no need to check for cycles as
- * these methods are called and we can always start traversal at the root node.
- */
-class BaseNode {
-    static types = {
-        NETWORK: 'network',
-        CPU: 'cpu',
-    };
-    _id;
-    _isMainDocument;
-    dependents;
-    dependencies;
-    constructor(id) {
-        this._id = id;
-        this._isMainDocument = false;
-        this.dependents = [];
-        this.dependencies = [];
-    }
-    get id() {
-        return this._id;
-    }
-    get type() {
-        throw new Core.LanternError('Unimplemented');
-    }
-    /**
-     * In microseconds
-     */
-    get startTime() {
-        throw new Core.LanternError('Unimplemented');
-    }
-    /**
-     * In microseconds
-     */
-    get endTime() {
-        throw new Core.LanternError('Unimplemented');
-    }
-    setIsMainDocument(value) {
-        this._isMainDocument = value;
-    }
-    isMainDocument() {
-        return this._isMainDocument;
-    }
-    getDependents() {
-        return this.dependents.slice();
-    }
-    getNumberOfDependents() {
-        return this.dependents.length;
-    }
-    getDependencies() {
-        return this.dependencies.slice();
-    }
-    getNumberOfDependencies() {
-        return this.dependencies.length;
-    }
-    getRootNode() {
-        let rootNode = this;
-        while (rootNode.dependencies.length) {
-            rootNode = rootNode.dependencies[0];
-        }
-        return rootNode;
-    }
-    addDependent(node) {
-        node.addDependency(this);
-    }
-    addDependency(node) {
-        // @ts-expect-error - in checkJs, ts doesn't know that CPUNode and NetworkNode *are* BaseNodes.
-        if (node === this) {
-            throw new Core.LanternError('Cannot add dependency on itself');
-        }
-        if (this.dependencies.includes(node)) {
-            return;
-        }
-        node.dependents.push(this);
-        this.dependencies.push(node);
-    }
-    removeDependent(node) {
-        node.removeDependency(this);
-    }
-    removeDependency(node) {
-        if (!this.dependencies.includes(node)) {
-            return;
-        }
-        const thisIndex = node.dependents.indexOf(this);
-        node.dependents.splice(thisIndex, 1);
-        this.dependencies.splice(this.dependencies.indexOf(node), 1);
-    }
-    // Unused in devtools, but used in LH.
-    removeAllDependencies() {
-        for (const node of this.dependencies.slice()) {
-            this.removeDependency(node);
-        }
-    }
-    /**
-     * Computes whether the given node is anywhere in the dependency graph of this node.
-     * While this method can prevent cycles, it walks the graph and should be used sparingly.
-     * Nodes are always considered dependent on themselves for the purposes of cycle detection.
-     */
-    isDependentOn(node) {
-        let isDependentOnNode = false;
-        this.traverse(currentNode => {
-            if (isDependentOnNode) {
-                return;
-            }
-            isDependentOnNode = currentNode === node;
-        }, currentNode => {
-            // If we've already found the dependency, don't traverse further.
-            if (isDependentOnNode) {
-                return [];
-            }
-            // Otherwise, traverse the dependencies.
-            return currentNode.getDependencies();
-        });
-        return isDependentOnNode;
-    }
-    /**
-     * Clones the node's information without adding any dependencies/dependents.
-     */
-    cloneWithoutRelationships() {
-        const node = new BaseNode(this.id);
-        node.setIsMainDocument(this._isMainDocument);
-        return node;
-    }
-    /**
-     * Clones the entire graph connected to this node filtered by the optional predicate. If a node is
-     * included by the predicate, all nodes along the paths between the node and the root will be included. If the
-     * node this was called on is not included in the resulting filtered graph, the method will throw.
-     *
-     * This does not clone NetworkNode's `record` or `rawRecord` fields. It may be reasonable to clone the former,
-     * to assist in graph construction, but the latter should never be cloned as one constraint of Lantern is that
-     * the underlying data records are accessible for plain object reference equality checks.
-     */
-    cloneWithRelationships(predicate) {
-        const rootNode = this.getRootNode();
-        const idsToIncludedClones = new Map();
-        // Walk down dependents.
-        rootNode.traverse(node => {
-            if (idsToIncludedClones.has(node.id)) {
-                return;
-            }
-            if (predicate === undefined) {
-                // No condition for entry, so clone every node.
-                idsToIncludedClones.set(node.id, node.cloneWithoutRelationships());
-                return;
-            }
-            if (predicate(node)) {
-                // Node included, so walk back up dependencies, cloning nodes from here back to the root.
-                node.traverse(node => idsToIncludedClones.set(node.id, node.cloneWithoutRelationships()), 
-                // Dependencies already cloned have already cloned ancestors, so no need to visit again.
-                node => node.dependencies.filter(parent => !idsToIncludedClones.has(parent.id)));
-            }
-        });
-        // Copy dependencies between nodes.
-        rootNode.traverse(originalNode => {
-            const clonedNode = idsToIncludedClones.get(originalNode.id);
-            if (!clonedNode) {
-                return;
-            }
-            for (const dependency of originalNode.dependencies) {
-                const clonedDependency = idsToIncludedClones.get(dependency.id);
-                if (!clonedDependency) {
-                    throw new Core.LanternError('Dependency somehow not cloned');
-                }
-                clonedNode.addDependency(clonedDependency);
-            }
-        });
-        const clonedThisNode = idsToIncludedClones.get(this.id);
-        if (!clonedThisNode) {
-            throw new Core.LanternError('Cloned graph missing node');
-        }
-        return clonedThisNode;
-    }
-    /**
-     * Traverses all connected nodes in BFS order, calling `callback` exactly once
-     * on each. `traversalPath` is the shortest (though not necessarily unique)
-     * path from `node` to the root of the iteration.
-     *
-     * The `getNextNodes` function takes a visited node and returns which nodes to
-     * visit next. It defaults to returning the node's dependents.
-     */
-    traverse(callback, getNextNodes) {
-        for (const { node, traversalPath } of this.traverseGenerator(getNextNodes)) {
-            callback(node, traversalPath);
-        }
-    }
-    /**
-     * @see BaseNode.traverse
-     */
-    // clang-format off
-    *traverseGenerator(getNextNodes) {
-        // clang-format on
-        if (!getNextNodes) {
-            getNextNodes = node => node.getDependents();
-        }
-        // @ts-expect-error - only traverses graphs of Node, so force tsc to treat `this` as one
-        const queue = [[this]];
-        const visited = new Set([this.id]);
-        while (queue.length) {
-            // @ts-expect-error - queue has length so it's guaranteed to have an item
-            const traversalPath = queue.shift();
-            const node = traversalPath[0];
-            yield { node, traversalPath };
-            for (const nextNode of getNextNodes(node)) {
-                if (visited.has(nextNode.id)) {
-                    continue;
-                }
-                visited.add(nextNode.id);
-                queue.push([nextNode, ...traversalPath]);
-            }
-        }
-    }
-    /**
-     * If the given node has a cycle, returns a path representing that cycle.
-     * Else returns null.
-     *
-     * Does a DFS on in its dependent graph.
-     */
-    static findCycle(node, direction = 'both') {
-        // Checking 'both' is the default entrypoint to recursively check both directions
-        if (direction === 'both') {
-            return BaseNode.findCycle(node, 'dependents') || BaseNode.findCycle(node, 'dependencies');
-        }
-        const visited = new Set();
-        const currentPath = [];
-        const toVisit = [node];
-        const depthAdded = new Map([[node, 0]]);
-        // Keep going while we have nodes to visit in the stack
-        while (toVisit.length) {
-            // Get the last node in the stack (DFS uses stack, not queue)
-            // @ts-expect-error - toVisit has length so it's guaranteed to have an item
-            const currentNode = toVisit.pop();
-            // We've hit a cycle if the node we're visiting is in our current dependency path
-            if (currentPath.includes(currentNode)) {
-                return currentPath;
-            }
-            // If we've already visited the node, no need to revisit it
-            if (visited.has(currentNode)) {
-                continue;
-            }
-            // Since we're visiting this node, clear out any nodes in our path that we had to backtrack
-            // @ts-expect-error
-            while (currentPath.length > depthAdded.get(currentNode)) {
-                currentPath.pop();
-            }
-            // Update our data structures to reflect that we're adding this node to our path
-            visited.add(currentNode);
-            currentPath.push(currentNode);
-            // Add all of its dependents to our toVisit stack
-            const nodesToExplore = direction === 'dependents' ? currentNode.dependents : currentNode.dependencies;
-            for (const nextNode of nodesToExplore) {
-                if (toVisit.includes(nextNode)) {
-                    continue;
-                }
-                toVisit.push(nextNode);
-                depthAdded.set(nextNode, currentPath.length);
-            }
-        }
-        return null;
-    }
-    canDependOn(node) {
-        return node.startTime <= this.startTime;
-    }
-}
-export { BaseNode };

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/graph/CPUNode.js

@@ -1,63 +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.
-import { BaseNode } from './BaseNode.js';
-class CPUNode extends BaseNode {
-    _event;
-    _childEvents;
-    correctedEndTs;
-    constructor(parentEvent, childEvents = [], correctedEndTs) {
-        const nodeId = `${parentEvent.tid}.${parentEvent.ts}`;
-        super(nodeId);
-        this._event = parentEvent;
-        this._childEvents = childEvents;
-        this.correctedEndTs = correctedEndTs;
-    }
-    get type() {
-        return BaseNode.types.CPU;
-    }
-    get startTime() {
-        return this._event.ts;
-    }
-    get endTime() {
-        if (this.correctedEndTs) {
-            return this.correctedEndTs;
-        }
-        return this._event.ts + this._event.dur;
-    }
-    get duration() {
-        return this.endTime - this.startTime;
-    }
-    get event() {
-        return this._event;
-    }
-    get childEvents() {
-        return this._childEvents;
-    }
-    /**
-     * Returns true if this node contains a Layout task.
-     */
-    didPerformLayout() {
-        return this._childEvents.some(evt => evt.name === 'Layout');
-    }
-    /**
-     * Returns the script URLs that had their EvaluateScript events occur in this task.
-     */
-    getEvaluateScriptURLs() {
-        const urls = new Set();
-        for (const event of this._childEvents) {
-            if (event.name !== 'EvaluateScript') {
-                continue;
-            }
-            if (!event.args.data?.url) {
-                continue;
-            }
-            urls.add(event.args.data.url);
-        }
-        return urls;
-    }
-    cloneWithoutRelationships() {
-        return new CPUNode(this._event, this._childEvents, this.correctedEndTs);
-    }
-}
-export { CPUNode };

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/graph/NetworkNode.js

@@ -1,82 +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.
-import { BaseNode } from './BaseNode.js';
-const NON_NETWORK_SCHEMES = [
-    'blob', // @see https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
-    'data', // @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
-    'intent', // @see https://developer.chrome.com/docs/multidevice/android/intents/
-    'file', // @see https://en.wikipedia.org/wiki/File_URI_scheme
-    'filesystem', // @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystem
-    'chrome-extension',
-];
-/**
- * Note: the `protocol` field from CDP can be 'h2', 'http', (not 'https'!) or it'll be url's scheme.
- *   https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/protocol/network_handler.cc;l=598-611;drc=56d4a9a9deb30be73adcee8737c73bcb2a5ab64f
- * However, a `new URL(href).protocol` has a colon suffix.
- *   https://url.spec.whatwg.org/#dom-url-protocol
- * A URL's `scheme` is specced as the `protocol` sans-colon, but isn't exposed on a URL object.
- * This method can take all 3 of these string types as a parameter.
- *
- * @param protocol Either a networkRequest's `protocol` per CDP or a `new URL(href).protocol`
- */
-function isNonNetworkProtocol(protocol) {
-    // Strip off any colon
-    const urlScheme = protocol.includes(':') ? protocol.slice(0, protocol.indexOf(':')) : protocol;
-    return NON_NETWORK_SCHEMES.includes(urlScheme);
-}
-class NetworkNode extends BaseNode {
-    _request;
-    constructor(networkRequest) {
-        super(networkRequest.requestId);
-        this._request = networkRequest;
-    }
-    get type() {
-        return BaseNode.types.NETWORK;
-    }
-    get startTime() {
-        return this._request.rendererStartTime * 1000;
-    }
-    get endTime() {
-        return this._request.networkEndTime * 1000;
-    }
-    get rawRequest() {
-        return this._request.rawRequest;
-    }
-    get request() {
-        return this._request;
-    }
-    get initiatorType() {
-        return this._request.initiator.type;
-    }
-    get fromDiskCache() {
-        return Boolean(this._request.fromDiskCache);
-    }
-    get isNonNetworkProtocol() {
-        // The 'protocol' field in devtools a string more like a `scheme`
-        return isNonNetworkProtocol(this.request.protocol) ||
-            // But `protocol` can fail to be populated if the request fails, so fallback to scheme.
-            isNonNetworkProtocol(this.request.parsedURL.scheme);
-    }
-    /**
-     * Returns whether this network request can be downloaded without a TCP connection.
-     * During simulation we treat data coming in over a network connection separately from on-device data.
-     */
-    get isConnectionless() {
-        return this.fromDiskCache || this.isNonNetworkProtocol;
-    }
-    hasRenderBlockingPriority() {
-        const priority = this._request.priority;
-        const isScript = this._request.resourceType === 'Script';
-        const isDocument = this._request.resourceType === 'Document';
-        const isBlockingScript = priority === 'High' && isScript;
-        const isBlockingHtmlImport = priority === 'High' && isDocument;
-        return priority === 'VeryHigh' || isBlockingScript || isBlockingHtmlImport;
-    }
-    cloneWithoutRelationships() {
-        const node = new NetworkNode(this._request);
-        node.setIsMainDocument(this._isMainDocument);
-        return node;
-    }
-}
-export { NetworkNode };