chrome-devtools-mcp-for-extension 0.5.0

package/build/node_modules/chrome-devtools-frontend/front_end/models/network_time_calculator/NetworkTimeCalculator.js

@@ -0,0 +1,256 @@
+// 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) 2007, 2008 Apple Inc.  All rights reserved.
+ * Copyright (C) 2008, 2009 Anthony Ricaud <rik@webkit.org>
+ * Copyright (C) 2011 Google 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.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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 * as Common from '../../core/common/common.js';
+import * as i18n from '../../core/i18n/i18n.js';
+const UIStrings = {
+    /**
+     * @description Latency download total format in Network Time Calculator of the Network panel
+     * @example {20ms} PH1
+     * @example {20ms} PH2
+     * @example {40ms} PH3
+     */
+    sLatencySDownloadSTotal: '{PH1} latency, {PH2} download ({PH3} total)',
+    /**
+     * @description Latency format in Network Time Calculator of the Network panel
+     * @example {20ms} PH1
+     */
+    sLatency: '{PH1} latency',
+    /**
+     * @description Duration of the download in ms/s shown for a completed network request.
+     * @example {5ms} PH1
+     */
+    sDownload: '{PH1} download',
+    /**
+     * @description From service worker format in Network Time Calculator of the Network panel
+     * @example {20ms latency} PH1
+     */
+    sFromServiceworker: '{PH1} (from `ServiceWorker`)',
+    /**
+     * @description From cache format in Network Time Calculator of the Network panel
+     * @example {20ms latency} PH1
+     */
+    sFromCache: '{PH1} (from cache)',
+};
+const str_ = i18n.i18n.registerUIStrings('models/network_time_calculator/NetworkTimeCalculator.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class NetworkTimeBoundary {
+    minimum;
+    maximum;
+    constructor(minimum, maximum) {
+        this.minimum = minimum;
+        this.maximum = maximum;
+    }
+    equals(other) {
+        return (this.minimum === other.minimum) && (this.maximum === other.maximum);
+    }
+}
+export class NetworkTimeCalculator extends Common.ObjectWrapper.ObjectWrapper {
+    #minimumBoundary = -1;
+    #maximumBoundary = -1;
+    #boundaryChangedEventThrottler = new Common.Throttler.Throttler(0);
+    #window = null;
+    #workingArea;
+    startAtZero;
+    constructor(startAtZero) {
+        super();
+        this.startAtZero = startAtZero;
+    }
+    setWindow(window) {
+        this.#window = window;
+        this.boundaryChanged();
+    }
+    computePosition(time) {
+        return (time - this.minimumBoundary()) / this.boundarySpan() * (this.#workingArea || 0);
+    }
+    formatValue(value, precision) {
+        return i18n.TimeUtilities.secondsToString(value, Boolean(precision));
+    }
+    minimumBoundary() {
+        return this.#window ? this.#window.minimum : this.#minimumBoundary;
+    }
+    zeroTime() {
+        return this.#minimumBoundary;
+    }
+    maximumBoundary() {
+        return this.#window ? this.#window.maximum : this.#maximumBoundary;
+    }
+    boundary() {
+        return new NetworkTimeBoundary(this.minimumBoundary(), this.maximumBoundary());
+    }
+    boundarySpan() {
+        return this.maximumBoundary() - this.minimumBoundary();
+    }
+    reset() {
+        this.#minimumBoundary = -1;
+        this.#maximumBoundary = -1;
+        this.boundaryChanged();
+    }
+    value() {
+        return 0;
+    }
+    setDisplayWidth(clientWidth) {
+        this.#workingArea = clientWidth;
+    }
+    computeBarGraphPercentages(request) {
+        let start;
+        let middle;
+        let end;
+        if (request.startTime !== -1) {
+            start = ((request.startTime - this.minimumBoundary()) / this.boundarySpan()) * 100;
+        }
+        else {
+            start = 0;
+        }
+        if (request.responseReceivedTime !== -1) {
+            middle = ((request.responseReceivedTime - this.minimumBoundary()) / this.boundarySpan()) * 100;
+        }
+        else {
+            middle = (this.startAtZero ? start : 100);
+        }
+        if (request.endTime !== -1) {
+            end = ((request.endTime - this.minimumBoundary()) / this.boundarySpan()) * 100;
+        }
+        else {
+            end = (this.startAtZero ? middle : 100);
+        }
+        if (this.startAtZero) {
+            end -= start;
+            middle -= start;
+            start = 0;
+        }
+        return { start, middle, end };
+    }
+    boundaryChanged() {
+        void this.#boundaryChangedEventThrottler.schedule(async () => {
+            this.dispatchEventToListeners("BoundariesChanged" /* Events.BOUNDARIES_CHANGED */);
+        });
+    }
+    updateBoundariesForEventTime(eventTime) {
+        if (eventTime === -1 || this.startAtZero) {
+            return;
+        }
+        if (this.#maximumBoundary === undefined || eventTime > this.#maximumBoundary) {
+            this.#maximumBoundary = eventTime;
+            this.boundaryChanged();
+        }
+    }
+    computeBarGraphLabels(request) {
+        let rightLabel = '';
+        if (request.responseReceivedTime !== -1 && request.endTime !== -1) {
+            rightLabel = i18n.TimeUtilities.secondsToString(request.endTime - request.responseReceivedTime);
+        }
+        const hasLatency = request.latency > 0;
+        const leftLabel = hasLatency ? i18n.TimeUtilities.secondsToString(request.latency) : rightLabel;
+        if (request.timing) {
+            return { left: leftLabel, right: rightLabel, tooltip: undefined };
+        }
+        let tooltip;
+        if (hasLatency && rightLabel) {
+            const total = i18n.TimeUtilities.secondsToString(request.duration);
+            tooltip = i18nString(UIStrings.sLatencySDownloadSTotal, { PH1: leftLabel, PH2: rightLabel, PH3: total });
+        }
+        else if (hasLatency) {
+            tooltip = i18nString(UIStrings.sLatency, { PH1: leftLabel });
+        }
+        else if (rightLabel) {
+            tooltip = i18nString(UIStrings.sDownload, { PH1: rightLabel });
+        }
+        if (request.fetchedViaServiceWorker) {
+            tooltip = i18nString(UIStrings.sFromServiceworker, { PH1: String(tooltip) });
+        }
+        else if (request.cached()) {
+            tooltip = i18nString(UIStrings.sFromCache, { PH1: String(tooltip) });
+        }
+        return { left: leftLabel, right: rightLabel, tooltip };
+    }
+    updateBoundaries(request) {
+        const lowerBound = this.lowerBound(request);
+        const upperBound = this.upperBound(request);
+        let changed = false;
+        if (lowerBound !== -1 || this.startAtZero) {
+            changed = this.extendBoundariesToIncludeTimestamp(this.startAtZero ? 0 : lowerBound);
+        }
+        if (upperBound !== -1) {
+            changed = this.extendBoundariesToIncludeTimestamp(upperBound) || changed;
+        }
+        if (changed) {
+            this.boundaryChanged();
+        }
+    }
+    extendBoundariesToIncludeTimestamp(timestamp) {
+        const previousMinimumBoundary = this.#minimumBoundary;
+        const previousMaximumBoundary = this.#maximumBoundary;
+        const minOffset = MINIMUM_SPREAD;
+        if (this.#minimumBoundary === -1 || this.#maximumBoundary === -1) {
+            this.#minimumBoundary = timestamp;
+            this.#maximumBoundary = timestamp + minOffset;
+        }
+        else {
+            this.#minimumBoundary = Math.min(timestamp, this.#minimumBoundary);
+            this.#maximumBoundary = Math.max(timestamp, this.#minimumBoundary + minOffset, this.#maximumBoundary);
+        }
+        return previousMinimumBoundary !== this.#minimumBoundary || previousMaximumBoundary !== this.#maximumBoundary;
+    }
+    lowerBound(_request) {
+        return 0;
+    }
+    upperBound(_request) {
+        return 0;
+    }
+}
+const MINIMUM_SPREAD = 0.1;
+export class NetworkTransferTimeCalculator extends NetworkTimeCalculator {
+    constructor() {
+        super(false);
+    }
+    formatValue(value, precision) {
+        return i18n.TimeUtilities.secondsToString(value - this.zeroTime(), Boolean(precision));
+    }
+    lowerBound(request) {
+        return request.issueTime();
+    }
+    upperBound(request) {
+        return request.endTime;
+    }
+}
+export class NetworkTransferDurationCalculator extends NetworkTimeCalculator {
+    constructor() {
+        super(true);
+    }
+    formatValue(value, precision) {
+        return i18n.TimeUtilities.secondsToString(value, Boolean(precision));
+    }
+    upperBound(request) {
+        return request.duration;
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/network_time_calculator/RequestTimeRanges.js

@@ -0,0 +1,120 @@
+// 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.
+export const ServiceWorkerRangeNames = new Set([
+    "serviceworker" /* RequestTimeRangeNames.SERVICE_WORKER */,
+    "serviceworker-preparation" /* RequestTimeRangeNames.SERVICE_WORKER_PREPARATION */,
+    "serviceworker-respondwith" /* RequestTimeRangeNames.SERVICE_WORKER_RESPOND_WITH */,
+    "serviceworker-routerevaluation" /* RequestTimeRangeNames.SERVICE_WORKER_ROUTER_EVALUATION */,
+    "serviceworker-cachelookup" /* RequestTimeRangeNames.SERVICE_WORKER_CACHE_LOOKUP */,
+]);
+export const ConnectionSetupRangeNames = new Set([
+    "queueing" /* RequestTimeRangeNames.QUEUEING */,
+    "blocking" /* RequestTimeRangeNames.BLOCKING */,
+    "connecting" /* RequestTimeRangeNames.CONNECTING */,
+    "dns" /* RequestTimeRangeNames.DNS */,
+    "proxy" /* RequestTimeRangeNames.PROXY */,
+    "ssl" /* RequestTimeRangeNames.SSL */,
+]);
+export function calculateRequestTimeRanges(request, navigationStart) {
+    const result = [];
+    function addRange(name, start, end) {
+        if (start < Number.MAX_VALUE && start <= end) {
+            result.push({ name, start, end });
+        }
+    }
+    function firstPositive(numbers) {
+        for (let i = 0; i < numbers.length; ++i) {
+            if (numbers[i] > 0) {
+                return numbers[i];
+            }
+        }
+        return undefined;
+    }
+    function addOffsetRange(name, start, end) {
+        if (start >= 0 && end >= 0) {
+            addRange(name, startTime + (start / 1000), startTime + (end / 1000));
+        }
+    }
+    // In some situations, argument `start` may come before `startTime` (`timing.requestStart`). This is especially true
+    // in cases such as SW static routing API where fields like `workerRouterEvaluationStart` or `workerCacheLookupStart`
+    // is set before setting `timing.requestStart`. If the `start` and `end` is known to be a valid value (i.e. not default
+    // invalid value -1 or undefined), we allow adding the range.
+    function addMaybeNegativeOffsetRange(name, start, end) {
+        addRange(name, startTime + (start / 1000), startTime + (end / 1000));
+    }
+    const timing = request.timing;
+    if (!timing) {
+        const start = request.issueTime() !== -1 ? request.issueTime() : request.startTime !== -1 ? request.startTime : 0;
+        const hasDifferentIssueAndStartTime = request.issueTime() !== -1 && request.startTime !== -1 && request.issueTime() !== request.startTime;
+        const middle = (request.responseReceivedTime === -1) ?
+            (hasDifferentIssueAndStartTime ? request.startTime : Number.MAX_VALUE) :
+            request.responseReceivedTime;
+        const end = (request.endTime === -1) ? Number.MAX_VALUE : request.endTime;
+        addRange("total" /* RequestTimeRangeNames.TOTAL */, start, end);
+        addRange("blocking" /* RequestTimeRangeNames.BLOCKING */, start, middle);
+        const state = request.responseReceivedTime === -1 ? "connecting" /* RequestTimeRangeNames.CONNECTING */ : "receiving" /* RequestTimeRangeNames.RECEIVING */;
+        addRange(state, middle, end);
+        return result;
+    }
+    const issueTime = request.issueTime();
+    const startTime = timing.requestTime;
+    const endTime = firstPositive([request.endTime, request.responseReceivedTime]) || startTime;
+    addRange("total" /* RequestTimeRangeNames.TOTAL */, issueTime < startTime ? issueTime : startTime, endTime);
+    if (timing.pushStart) {
+        const pushEnd = timing.pushEnd || endTime;
+        // Only show the part of push that happened after the navigation/reload.
+        // Pushes that happened on the same connection before we started main request will not be shown.
+        if (pushEnd > navigationStart) {
+            addRange("push" /* RequestTimeRangeNames.PUSH */, Math.max(timing.pushStart, navigationStart), pushEnd);
+        }
+    }
+    if (issueTime < startTime) {
+        addRange("queueing" /* RequestTimeRangeNames.QUEUEING */, issueTime, startTime);
+    }
+    const responseReceived = (request.responseReceivedTime - startTime) * 1000;
+    if (request.fetchedViaServiceWorker) {
+        addOffsetRange("blocking" /* RequestTimeRangeNames.BLOCKING */, 0, timing.workerStart);
+        addOffsetRange("serviceworker-preparation" /* RequestTimeRangeNames.SERVICE_WORKER_PREPARATION */, timing.workerStart, timing.workerReady);
+        addOffsetRange("serviceworker-respondwith" /* RequestTimeRangeNames.SERVICE_WORKER_RESPOND_WITH */, timing.workerFetchStart, timing.workerRespondWithSettled);
+        addOffsetRange("serviceworker" /* RequestTimeRangeNames.SERVICE_WORKER */, timing.workerReady, timing.sendEnd);
+        addOffsetRange("waiting" /* RequestTimeRangeNames.WAITING */, timing.sendEnd, responseReceived);
+    }
+    else if (!timing.pushStart) {
+        const blockingEnd = firstPositive([timing.dnsStart, timing.connectStart, timing.sendStart, responseReceived]) || 0;
+        addOffsetRange("blocking" /* RequestTimeRangeNames.BLOCKING */, 0, blockingEnd);
+        addOffsetRange("proxy" /* RequestTimeRangeNames.PROXY */, timing.proxyStart, timing.proxyEnd);
+        addOffsetRange("dns" /* RequestTimeRangeNames.DNS */, timing.dnsStart, timing.dnsEnd);
+        addOffsetRange("connecting" /* RequestTimeRangeNames.CONNECTING */, timing.connectStart, timing.connectEnd);
+        addOffsetRange("ssl" /* RequestTimeRangeNames.SSL */, timing.sslStart, timing.sslEnd);
+        addOffsetRange("sending" /* RequestTimeRangeNames.SENDING */, timing.sendStart, timing.sendEnd);
+        addOffsetRange("waiting" /* RequestTimeRangeNames.WAITING */, Math.max(timing.sendEnd, timing.connectEnd, timing.dnsEnd, timing.proxyEnd, blockingEnd), responseReceived);
+    }
+    const { serviceWorkerRouterInfo } = request;
+    if (serviceWorkerRouterInfo) {
+        if (timing.workerRouterEvaluationStart) {
+            // Depending on the source,the next timestamp will be different. Determine the timestamp by checking
+            // the matched and actual source.
+            let routerEvaluationEnd = timing.sendStart;
+            if (serviceWorkerRouterInfo?.matchedSourceType === "cache" /* Protocol.Network.ServiceWorkerRouterSource.Cache */ &&
+                timing.workerCacheLookupStart) {
+                routerEvaluationEnd = timing.workerCacheLookupStart;
+            }
+            else if (serviceWorkerRouterInfo?.actualSourceType === "fetch-event" /* Protocol.Network.ServiceWorkerRouterSource.FetchEvent */) {
+                routerEvaluationEnd = timing.workerStart;
+            }
+            addMaybeNegativeOffsetRange("serviceworker-routerevaluation" /* RequestTimeRangeNames.SERVICE_WORKER_ROUTER_EVALUATION */, timing.workerRouterEvaluationStart, routerEvaluationEnd);
+        }
+        if (timing.workerCacheLookupStart) {
+            let cacheLookupEnd = timing.sendStart;
+            if (serviceWorkerRouterInfo?.actualSourceType === "cache" /* Protocol.Network.ServiceWorkerRouterSource.Cache */) {
+                cacheLookupEnd = timing.receiveHeadersStart;
+            }
+            addMaybeNegativeOffsetRange("serviceworker-cachelookup" /* RequestTimeRangeNames.SERVICE_WORKER_CACHE_LOOKUP */, timing.workerCacheLookupStart, cacheLookupEnd);
+        }
+    }
+    if (request.endTime !== -1) {
+        addRange(timing.pushStart ? "receiving-push" /* RequestTimeRangeNames.RECEIVING_PUSH */ : "receiving" /* RequestTimeRangeNames.RECEIVING */, request.responseReceivedTime, endTime);
+    }
+    return result;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/network_time_calculator/network_time_calculator.js

@@ -0,0 +1,6 @@
+// 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.
+export * from './Calculator.js';
+export * from './NetworkTimeCalculator.js';
+export * from './RequestTimeRanges.js';