chrome-devtools-mcp 0.0.2 → 0.2.0

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

@@ -0,0 +1,268 @@
+// Copyright 2012 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+import { ContentProviderBasedProject } from './ContentProviderBasedProject.js';
+import { NetworkProject } from './NetworkProject.js';
+import { metadataForURL } from './ResourceUtils.js';
+const uiSourceCodeToStyleMap = new WeakMap();
+export class StylesSourceMapping {
+    #cssModel;
+    #project;
+    #styleFiles = new Map();
+    #eventListeners;
+    constructor(cssModel, workspace) {
+        this.#cssModel = cssModel;
+        const target = this.#cssModel.target();
+        this.#project = new ContentProviderBasedProject(workspace, 'css:' + target.id(), Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
+        NetworkProject.setTargetForProject(this.#project, target);
+        this.#eventListeners = [
+            this.#cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetAdded, this.styleSheetAdded, this),
+            this.#cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetRemoved, this.styleSheetRemoved, this),
+            this.#cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetChanged, this.styleSheetChanged, this),
+        ];
+    }
+    addSourceMap(sourceUrl, sourceMapUrl) {
+        this.#styleFiles.get(sourceUrl)?.addSourceMap(sourceUrl, sourceMapUrl);
+    }
+    rawLocationToUILocation(rawLocation) {
+        const header = rawLocation.header();
+        if (!header || !this.acceptsHeader(header)) {
+            return null;
+        }
+        const styleFile = this.#styleFiles.get(header.resourceURL());
+        if (!styleFile) {
+            return null;
+        }
+        let lineNumber = rawLocation.lineNumber;
+        let columnNumber = rawLocation.columnNumber;
+        if (header.isInline && header.hasSourceURL) {
+            lineNumber -= header.lineNumberInSource(0);
+            const headerColumnNumber = header.columnNumberInSource(lineNumber, 0);
+            if (typeof headerColumnNumber === 'undefined') {
+                columnNumber = headerColumnNumber;
+            }
+            else {
+                columnNumber -= headerColumnNumber;
+            }
+        }
+        return styleFile.getUiSourceCode().uiLocation(lineNumber, columnNumber);
+    }
+    uiLocationToRawLocations(uiLocation) {
+        const styleFile = uiSourceCodeToStyleMap.get(uiLocation.uiSourceCode);
+        if (!styleFile) {
+            return [];
+        }
+        const rawLocations = [];
+        for (const header of styleFile.getHeaders()) {
+            let lineNumber = uiLocation.lineNumber;
+            let columnNumber = uiLocation.columnNumber;
+            if (header.isInline && header.hasSourceURL) {
+                // TODO(crbug.com/1153123): Revisit the `#columnNumber || 0` and also preserve `undefined` for source maps?
+                columnNumber = header.columnNumberInSource(lineNumber, uiLocation.columnNumber || 0);
+                lineNumber = header.lineNumberInSource(lineNumber);
+            }
+            rawLocations.push(new SDK.CSSModel.CSSLocation(header, lineNumber, columnNumber));
+        }
+        return rawLocations;
+    }
+    acceptsHeader(header) {
+        if (header.isConstructedByNew()) {
+            return false;
+        }
+        if (header.isInline && !header.hasSourceURL && header.origin !== 'inspector') {
+            return false;
+        }
+        if (!header.resourceURL()) {
+            return false;
+        }
+        return true;
+    }
+    styleSheetAdded(event) {
+        const header = event.data;
+        if (!this.acceptsHeader(header)) {
+            return;
+        }
+        const url = header.resourceURL();
+        let styleFile = this.#styleFiles.get(url);
+        if (!styleFile) {
+            styleFile = new StyleFile(this.#cssModel, this.#project, header);
+            this.#styleFiles.set(url, styleFile);
+        }
+        else {
+            styleFile.addHeader(header);
+        }
+    }
+    styleSheetRemoved(event) {
+        const header = event.data;
+        if (!this.acceptsHeader(header)) {
+            return;
+        }
+        const url = header.resourceURL();
+        const styleFile = this.#styleFiles.get(url);
+        if (styleFile) {
+            if (styleFile.getHeaders().size === 1) {
+                styleFile.dispose();
+                this.#styleFiles.delete(url);
+            }
+            else {
+                styleFile.removeHeader(header);
+            }
+        }
+    }
+    styleSheetChanged(event) {
+        const header = this.#cssModel.styleSheetHeaderForId(event.data.styleSheetId);
+        if (!header || !this.acceptsHeader(header)) {
+            return;
+        }
+        const styleFile = this.#styleFiles.get(header.resourceURL());
+        if (styleFile) {
+            styleFile.styleSheetChanged(header);
+        }
+    }
+    dispose() {
+        for (const styleFile of this.#styleFiles.values()) {
+            styleFile.dispose();
+        }
+        this.#styleFiles.clear();
+        Common.EventTarget.removeEventListeners(this.#eventListeners);
+        this.#project.removeProject();
+    }
+}
+export class StyleFile {
+    #cssModel;
+    #project;
+    headers;
+    uiSourceCode;
+    #eventListeners;
+    #throttler = new Common.Throttler.Throttler(200);
+    #terminated = false;
+    #isAddingRevision;
+    #isUpdatingHeaders;
+    constructor(cssModel, project, header) {
+        this.#cssModel = cssModel;
+        this.#project = project;
+        this.headers = new Set([header]);
+        const target = cssModel.target();
+        const url = header.resourceURL();
+        const metadata = metadataForURL(target, header.frameId, url);
+        this.uiSourceCode = this.#project.createUISourceCode(url, header.contentType());
+        uiSourceCodeToStyleMap.set(this.uiSourceCode, this);
+        NetworkProject.setInitialFrameAttribution(this.uiSourceCode, header.frameId);
+        this.#project.addUISourceCodeWithProvider(this.uiSourceCode, this, metadata, 'text/css');
+        this.#eventListeners = [
+            this.uiSourceCode.addEventListener(Workspace.UISourceCode.Events.WorkingCopyChanged, this.workingCopyChanged, this),
+            this.uiSourceCode.addEventListener(Workspace.UISourceCode.Events.WorkingCopyCommitted, this.workingCopyCommitted, this),
+        ];
+    }
+    addHeader(header) {
+        this.headers.add(header);
+        NetworkProject.addFrameAttribution(this.uiSourceCode, header.frameId);
+    }
+    removeHeader(header) {
+        this.headers.delete(header);
+        NetworkProject.removeFrameAttribution(this.uiSourceCode, header.frameId);
+    }
+    styleSheetChanged(header) {
+        console.assert(this.headers.has(header));
+        if (this.#isUpdatingHeaders || !this.headers.has(header)) {
+            return;
+        }
+        const mirrorContentBound = this.mirrorContent.bind(this, header, true /* majorChange */);
+        void this.#throttler.schedule(mirrorContentBound, "Default" /* Common.Throttler.Scheduling.DEFAULT */);
+    }
+    workingCopyCommitted() {
+        if (this.#isAddingRevision) {
+            return;
+        }
+        const mirrorContentBound = this.mirrorContent.bind(this, this.uiSourceCode, true /* majorChange */);
+        void this.#throttler.schedule(mirrorContentBound, "AsSoonAsPossible" /* Common.Throttler.Scheduling.AS_SOON_AS_POSSIBLE */);
+    }
+    workingCopyChanged() {
+        if (this.#isAddingRevision) {
+            return;
+        }
+        const mirrorContentBound = this.mirrorContent.bind(this, this.uiSourceCode, false /* majorChange */);
+        void this.#throttler.schedule(mirrorContentBound, "Default" /* Common.Throttler.Scheduling.DEFAULT */);
+    }
+    async mirrorContent(fromProvider, majorChange) {
+        if (this.#terminated) {
+            this.styleFileSyncedForTest();
+            return;
+        }
+        let newContent = null;
+        if (fromProvider === this.uiSourceCode) {
+            newContent = this.uiSourceCode.workingCopy();
+        }
+        else {
+            newContent = TextUtils.ContentData.ContentData.textOr(await fromProvider.requestContentData(), null);
+        }
+        if (newContent === null || this.#terminated) {
+            this.styleFileSyncedForTest();
+            return;
+        }
+        if (fromProvider !== this.uiSourceCode) {
+            this.#isAddingRevision = true;
+            this.uiSourceCode.setWorkingCopy(newContent);
+            this.#isAddingRevision = false;
+        }
+        this.#isUpdatingHeaders = true;
+        const promises = [];
+        for (const header of this.headers) {
+            if (header === fromProvider) {
+                continue;
+            }
+            promises.push(this.#cssModel.setStyleSheetText(header.id, newContent, majorChange));
+        }
+        // ------ ASYNC ------
+        await Promise.all(promises);
+        this.#isUpdatingHeaders = false;
+        this.styleFileSyncedForTest();
+    }
+    styleFileSyncedForTest() {
+    }
+    dispose() {
+        if (this.#terminated) {
+            return;
+        }
+        this.#terminated = true;
+        this.#project.removeUISourceCode(this.uiSourceCode.url());
+        Common.EventTarget.removeEventListeners(this.#eventListeners);
+    }
+    contentURL() {
+        console.assert(this.headers.size > 0);
+        return this.#firstHeader().originalContentProvider().contentURL();
+    }
+    contentType() {
+        console.assert(this.headers.size > 0);
+        return this.#firstHeader().originalContentProvider().contentType();
+    }
+    requestContentData() {
+        console.assert(this.headers.size > 0);
+        return this.#firstHeader().originalContentProvider().requestContentData();
+    }
+    searchInContent(query, caseSensitive, isRegex) {
+        console.assert(this.headers.size > 0);
+        return this.#firstHeader().originalContentProvider().searchInContent(query, caseSensitive, isRegex);
+    }
+    #firstHeader() {
+        console.assert(this.headers.size > 0);
+        return this.headers.values().next().value;
+    }
+    getHeaders() {
+        return this.headers;
+    }
+    getUiSourceCode() {
+        return this.uiSourceCode;
+    }
+    addSourceMap(sourceUrl, sourceMapUrl) {
+        const sourceMapManager = this.#cssModel.sourceMapManager();
+        this.headers.forEach(header => {
+            sourceMapManager.detachSourceMap(header);
+            sourceMapManager.attachSourceMap(header, sourceUrl, sourceMapUrl);
+        });
+    }
+}

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

@@ -0,0 +1,55 @@
+// Copyright 2013 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+import { ChunkedFileReader } from './FileUtils.js';
+export class TempFile {
+    #lastBlob;
+    constructor() {
+        this.#lastBlob = null;
+    }
+    write(pieces) {
+        if (this.#lastBlob) {
+            pieces.unshift(this.#lastBlob);
+        }
+        this.#lastBlob = new Blob(pieces, { type: 'text/plain' });
+    }
+    read() {
+        return this.readRange();
+    }
+    size() {
+        return this.#lastBlob ? this.#lastBlob.size : 0;
+    }
+    async readRange(startOffset, endOffset) {
+        if (!this.#lastBlob) {
+            Common.Console.Console.instance().error('Attempt to read a temp file that was never written');
+            return '';
+        }
+        const blob = typeof startOffset === 'number' || typeof endOffset === 'number' ?
+            this.#lastBlob.slice(startOffset, endOffset) :
+            this.#lastBlob;
+        const reader = new FileReader();
+        try {
+            await new Promise((resolve, reject) => {
+                reader.onloadend = resolve;
+                reader.onerror = reject;
+                reader.readAsText(blob);
+            });
+        }
+        catch (error) {
+            Common.Console.Console.instance().error('Failed to read from temp file: ' + error.message);
+        }
+        return reader.result;
+    }
+    async copyToOutputStream(outputStream, progress) {
+        if (!this.#lastBlob) {
+            void outputStream.close();
+            return null;
+        }
+        const reader = new ChunkedFileReader(this.#lastBlob, 10 * 1000 * 1000, progress);
+        return await reader.read(outputStream).then(success => success ? null : reader.error());
+    }
+    remove() {
+        this.#lastBlob = null;
+    }
+}

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

@@ -0,0 +1,20 @@
+// 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 * as CompilerScriptMapping from './CompilerScriptMapping.js';
+import * as ContentProviderBasedProject from './ContentProviderBasedProject.js';
+import * as CSSWorkspaceBinding from './CSSWorkspaceBinding.js';
+import * as DebuggerLanguagePlugins from './DebuggerLanguagePlugins.js';
+import * as DebuggerWorkspaceBinding from './DebuggerWorkspaceBinding.js';
+import * as DefaultScriptMapping from './DefaultScriptMapping.js';
+import * as FileUtils from './FileUtils.js';
+import * as LiveLocation from './LiveLocation.js';
+import * as NetworkProject from './NetworkProject.js';
+import * as PresentationConsoleMessageHelper from './PresentationConsoleMessageHelper.js';
+import * as ResourceMapping from './ResourceMapping.js';
+import * as ResourceScriptMapping from './ResourceScriptMapping.js';
+import * as ResourceUtils from './ResourceUtils.js';
+import * as SASSSourceMapping from './SASSSourceMapping.js';
+import * as StylesSourceMapping from './StylesSourceMapping.js';
+import * as TempFile from './TempFile.js';
+export { CompilerScriptMapping, ContentProviderBasedProject, CSSWorkspaceBinding, DebuggerLanguagePlugins, DebuggerWorkspaceBinding, DefaultScriptMapping, FileUtils, LiveLocation, NetworkProject, PresentationConsoleMessageHelper, ResourceMapping, ResourceScriptMapping, ResourceUtils, SASSSourceMapping, StylesSourceMapping, TempFile, };

package/build/node_modules/chrome-devtools-frontend/front_end/models/crux-manager/CrUXManager.js

@@ -0,0 +1,283 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+import * as i18n from '../../core/i18n/i18n.js';
+import * as Root from '../../core/root/root.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import * as EmulationModel from '../../models/emulation/emulation.js';
+const UIStrings = {
+    /**
+     * @description Warning message indicating that the user will see real user data for a URL which is different from the URL they are currently looking at.
+     */
+    fieldOverrideWarning: 'Field metrics are configured for a different URL than the current page.',
+};
+const str_ = i18n.i18n.registerUIStrings('models/crux-manager/CrUXManager.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+// This key is expected to be visible in the frontend.
+// b/349721878
+const CRUX_API_KEY = 'AIzaSyCCSOx25vrb5z0tbedCB3_JRzzbVW6Uwgw';
+const DEFAULT_ENDPOINT = `https://chromeuxreport.googleapis.com/v1/records:queryRecord?key=${CRUX_API_KEY}`;
+let cruxManagerInstance;
+// TODO: Potentially support `TABLET`. Tablet field data will always be `null` until then.
+export const DEVICE_SCOPE_LIST = ['ALL', 'DESKTOP', 'PHONE'];
+const pageScopeList = ['origin', 'url'];
+const metrics = [
+    'first_contentful_paint',
+    'largest_contentful_paint',
+    'cumulative_layout_shift',
+    'interaction_to_next_paint',
+    'round_trip_time',
+    'form_factors',
+    'largest_contentful_paint_image_time_to_first_byte',
+    'largest_contentful_paint_image_resource_load_delay',
+    'largest_contentful_paint_image_resource_load_duration',
+    'largest_contentful_paint_image_element_render_delay',
+];
+export class CrUXManager extends Common.ObjectWrapper.ObjectWrapper {
+    #originCache = new Map();
+    #urlCache = new Map();
+    #mainDocumentUrl;
+    #configSetting;
+    #endpoint = DEFAULT_ENDPOINT;
+    #pageResult;
+    fieldDeviceOption = 'AUTO';
+    fieldPageScope = 'url';
+    constructor() {
+        super();
+        /**
+         * In an incognito or guest window - which is called an "OffTheRecord"
+         * profile in Chromium -, we do not want to persist the user consent and
+         * should ask for it every time. This is why we see what window type the
+         * user is in before choosing where to look/create this setting. If the
+         * user is in OTR, we store it in the session, which uses sessionStorage
+         * and is short-lived. If the user is not in OTR, we use global, which is
+         * the default behaviour and persists the value to the Chrome profile.
+         * This behaviour has been approved by Chrome Privacy as part of the launch
+         * review.
+         */
+        const useSessionStorage = Root.Runtime.hostConfig.isOffTheRecord === true;
+        const storageTypeForConsent = useSessionStorage ? "Session" /* Common.Settings.SettingStorageType.SESSION */ : "Global" /* Common.Settings.SettingStorageType.GLOBAL */;
+        this.#configSetting = Common.Settings.Settings.instance().createSetting('field-data', { enabled: false, override: '', originMappings: [], overrideEnabled: false }, storageTypeForConsent);
+        this.#configSetting.addChangeListener(() => {
+            void this.refresh();
+        });
+        SDK.TargetManager.TargetManager.instance().addModelListener(SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.FrameNavigated, this.#onFrameNavigated, this);
+    }
+    static instance(opts = { forceNew: null }) {
+        const { forceNew } = opts;
+        if (!cruxManagerInstance || forceNew) {
+            cruxManagerInstance = new CrUXManager();
+        }
+        return cruxManagerInstance;
+    }
+    /** The most recent page result from the CrUX service. */
+    get pageResult() {
+        return this.#pageResult;
+    }
+    getConfigSetting() {
+        return this.#configSetting;
+    }
+    isEnabled() {
+        return this.#configSetting.get().enabled;
+    }
+    async getFieldDataForPage(pageUrl) {
+        const pageResult = {
+            'origin-ALL': null,
+            'origin-DESKTOP': null,
+            'origin-PHONE': null,
+            'origin-TABLET': null,
+            'url-ALL': null,
+            'url-DESKTOP': null,
+            'url-PHONE': null,
+            'url-TABLET': null,
+            warnings: [],
+        };
+        try {
+            const normalizedUrl = this.#normalizeUrl(pageUrl);
+            const promises = [];
+            for (const pageScope of pageScopeList) {
+                for (const deviceScope of DEVICE_SCOPE_LIST) {
+                    const promise = this.#getScopedData(normalizedUrl, pageScope, deviceScope).then(response => {
+                        pageResult[`${pageScope}-${deviceScope}`] = response;
+                    });
+                    promises.push(promise);
+                }
+            }
+            await Promise.all(promises);
+        }
+        catch (err) {
+            console.error(err);
+        }
+        finally {
+            return pageResult;
+        }
+    }
+    #getMappedUrl(unmappedUrl) {
+        try {
+            const unmapped = new URL(unmappedUrl);
+            const mappings = this.#configSetting.get().originMappings || [];
+            const mapping = mappings.find(m => m.developmentOrigin === unmapped.origin);
+            if (!mapping) {
+                return unmappedUrl;
+            }
+            const mapped = new URL(mapping.productionOrigin);
+            mapped.pathname = unmapped.pathname;
+            return mapped.href;
+        }
+        catch {
+            return unmappedUrl;
+        }
+    }
+    async getFieldDataForCurrentPageForTesting() {
+        return await this.#getFieldDataForCurrentPage();
+    }
+    /**
+     * In general, this function should use the main document URL
+     * (i.e. the URL after all redirects but before SPA navigations)
+     *
+     * However, we can't detect the main document URL of the current page if it's
+     * navigation occurred before DevTools was first opened. This function will fall
+     * back to the currently inspected URL (i.e. what is displayed in the omnibox) if
+     * the main document URL cannot be found.
+     */
+    async #getFieldDataForCurrentPage() {
+        const currentUrl = this.#mainDocumentUrl || await this.#getInspectedURL();
+        const urlForCrux = this.#configSetting.get().overrideEnabled ? this.#configSetting.get().override || '' :
+            this.#getMappedUrl(currentUrl);
+        const result = await this.getFieldDataForPage(urlForCrux);
+        if (currentUrl !== urlForCrux) {
+            result.warnings.push(i18nString(UIStrings.fieldOverrideWarning));
+        }
+        return result;
+    }
+    async #getInspectedURL() {
+        const targetManager = SDK.TargetManager.TargetManager.instance();
+        let inspectedURL = targetManager.inspectedURL();
+        if (!inspectedURL) {
+            inspectedURL = await new Promise(resolve => {
+                function handler(event) {
+                    const newInspectedURL = event.data.inspectedURL();
+                    if (newInspectedURL) {
+                        resolve(newInspectedURL);
+                        targetManager.removeEventListener("InspectedURLChanged" /* SDK.TargetManager.Events.INSPECTED_URL_CHANGED */, handler);
+                    }
+                }
+                targetManager.addEventListener("InspectedURLChanged" /* SDK.TargetManager.Events.INSPECTED_URL_CHANGED */, handler);
+            });
+        }
+        return inspectedURL;
+    }
+    async #onFrameNavigated(event) {
+        if (!event.data.isPrimaryFrame()) {
+            return;
+        }
+        this.#mainDocumentUrl = event.data.url;
+        await this.refresh();
+    }
+    async refresh() {
+        // This does 2 things:
+        // - Tells listeners to clear old data so it isn't shown during a URL transition
+        // - Tells listeners to clear old data when field data is disabled.
+        this.#pageResult = undefined;
+        this.dispatchEventToListeners("field-data-changed" /* Events.FIELD_DATA_CHANGED */, undefined);
+        if (!this.#configSetting.get().enabled) {
+            return;
+        }
+        this.#pageResult = await this.#getFieldDataForCurrentPage();
+        this.dispatchEventToListeners("field-data-changed" /* Events.FIELD_DATA_CHANGED */, this.#pageResult);
+    }
+    #normalizeUrl(inputUrl) {
+        const normalizedUrl = new URL(inputUrl);
+        normalizedUrl.hash = '';
+        normalizedUrl.search = '';
+        return normalizedUrl;
+    }
+    async #getScopedData(normalizedUrl, pageScope, deviceScope) {
+        const { origin, href: url, hostname } = normalizedUrl;
+        if (hostname === 'localhost' || hostname === '127.0.0.1' || !origin.startsWith('http')) {
+            return null;
+        }
+        const cache = pageScope === 'origin' ? this.#originCache : this.#urlCache;
+        const cacheKey = pageScope === 'origin' ? `${origin}-${deviceScope}` : `${url}-${deviceScope}`;
+        const cachedResponse = cache.get(cacheKey);
+        if (cachedResponse !== undefined) {
+            return cachedResponse;
+        }
+        // We shouldn't cache the result in the case of an error
+        // The error could be a transient issue with the network/CrUX server/etc.
+        try {
+            const formFactor = deviceScope === 'ALL' ? undefined : deviceScope;
+            const result = pageScope === 'origin' ? await this.#makeRequest({ origin, metrics, formFactor }) :
+                await this.#makeRequest({ url, metrics, formFactor });
+            cache.set(cacheKey, result);
+            return result;
+        }
+        catch (err) {
+            console.error(err);
+            return null;
+        }
+    }
+    async #makeRequest(request) {
+        const body = JSON.stringify(request);
+        const response = await fetch(this.#endpoint, {
+            method: 'POST',
+            body,
+        });
+        if (!response.ok && response.status !== 404) {
+            throw new Error(`Failed to fetch data from CrUX server (Status code: ${response.status})`);
+        }
+        const responseData = await response.json();
+        if (response.status === 404) {
+            // This is how CrUX tells us that there is not data available for the provided url/origin
+            // Since it's a valid response, just return null instead of throwing an error.
+            if (responseData?.error?.status === 'NOT_FOUND') {
+                return null;
+            }
+            throw new Error(`Failed to fetch data from CrUX server (Status code: ${response.status})`);
+        }
+        if (!('record' in responseData)) {
+            throw new Error(`Failed to find data in CrUX response: ${JSON.stringify(responseData)}`);
+        }
+        return responseData;
+    }
+    #getAutoDeviceScope() {
+        const emulationModel = EmulationModel.DeviceModeModel.DeviceModeModel.tryInstance();
+        if (emulationModel === null) {
+            return 'ALL';
+        }
+        if (emulationModel.isMobile()) {
+            if (this.#pageResult?.[`${this.fieldPageScope}-PHONE`]) {
+                return 'PHONE';
+            }
+            return 'ALL';
+        }
+        if (this.#pageResult?.[`${this.fieldPageScope}-DESKTOP`]) {
+            return 'DESKTOP';
+        }
+        return 'ALL';
+    }
+    resolveDeviceOptionToScope(option) {
+        return option === 'AUTO' ? this.#getAutoDeviceScope() : option;
+    }
+    getSelectedDeviceScope() {
+        return this.resolveDeviceOptionToScope(this.fieldDeviceOption);
+    }
+    getSelectedScope() {
+        return { pageScope: this.fieldPageScope, deviceScope: this.getSelectedDeviceScope() };
+    }
+    getSelectedFieldResponse() {
+        const pageScope = this.fieldPageScope;
+        const deviceScope = this.getSelectedDeviceScope();
+        return this.getFieldResponse(pageScope, deviceScope);
+    }
+    getSelectedFieldMetricData(fieldMetric) {
+        return this.getSelectedFieldResponse()?.record.metrics[fieldMetric];
+    }
+    getFieldResponse(pageScope, deviceScope) {
+        return this.#pageResult?.[`${pageScope}-${deviceScope}`];
+    }
+    setEndpointForTesting(endpoint) {
+        this.#endpoint = endpoint;
+    }
+}

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

@@ -0,0 +1,4 @@
+// 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.
+export * from './CrUXManager.js';