@mcp-b/chrome-devtools-mcp 1.1.0 → 1.1.1

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

@@ -0,0 +1,182 @@
+// 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';
+export class SASSSourceMapping {
+    #sourceMapManager;
+    #project;
+    #eventListeners;
+    #bindings;
+    #cssWorkspaceBinding;
+    constructor(target, sourceMapManager, workspace, cssWorkspaceBinding) {
+        this.#sourceMapManager = sourceMapManager;
+        this.#cssWorkspaceBinding = cssWorkspaceBinding;
+        this.#project = new ContentProviderBasedProject(workspace, 'cssSourceMaps:' + target.id(), Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
+        NetworkProject.setTargetForProject(this.#project, target);
+        this.#bindings = new Map();
+        this.#eventListeners = [
+            this.#sourceMapManager.addEventListener(SDK.SourceMapManager.Events.SourceMapAttached, this.sourceMapAttached, this),
+            this.#sourceMapManager.addEventListener(SDK.SourceMapManager.Events.SourceMapDetached, this.sourceMapDetached, this),
+        ];
+    }
+    sourceMapAttachedForTest(_sourceMap) {
+    }
+    async sourceMapAttached(event) {
+        const header = event.data.client;
+        const sourceMap = event.data.sourceMap;
+        const project = this.#project;
+        const bindings = this.#bindings;
+        for (const sourceURL of sourceMap.sourceURLs()) {
+            let binding = bindings.get(sourceURL);
+            if (!binding) {
+                binding = new Binding(project, sourceURL, header.createPageResourceLoadInitiator());
+                bindings.set(sourceURL, binding);
+            }
+            binding.addSourceMap(sourceMap, header.frameId);
+        }
+        await this.#cssWorkspaceBinding.updateLocations(header);
+        this.sourceMapAttachedForTest(sourceMap);
+    }
+    async sourceMapDetached(event) {
+        const header = event.data.client;
+        const sourceMap = event.data.sourceMap;
+        const bindings = this.#bindings;
+        for (const sourceURL of sourceMap.sourceURLs()) {
+            const binding = bindings.get(sourceURL);
+            if (binding) {
+                binding.removeSourceMap(sourceMap, header.frameId);
+                if (!binding.getUiSourceCode()) {
+                    bindings.delete(sourceURL);
+                }
+            }
+        }
+        await this.#cssWorkspaceBinding.updateLocations(header);
+    }
+    rawLocationToUILocation(rawLocation) {
+        const header = rawLocation.header();
+        if (!header) {
+            return null;
+        }
+        const sourceMap = this.#sourceMapManager.sourceMapForClient(header);
+        if (!sourceMap) {
+            return null;
+        }
+        let { lineNumber, columnNumber } = rawLocation;
+        // If the source map maps the origin (line:0, column:0) but the CSS header is inline (in a HTML doc),
+        // then adjust the line and column numbers.
+        if (sourceMap.mapsOrigin() && header.isInline) {
+            lineNumber -= header.startLine;
+            if (lineNumber === 0) {
+                columnNumber -= header.startColumn;
+            }
+        }
+        const entry = sourceMap.findEntry(lineNumber, columnNumber);
+        if (!entry?.sourceURL) {
+            return null;
+        }
+        const uiSourceCode = this.#project.uiSourceCodeForURL(entry.sourceURL);
+        if (!uiSourceCode) {
+            return null;
+        }
+        return uiSourceCode.uiLocation(entry.sourceLineNumber, entry.sourceColumnNumber);
+    }
+    uiLocationToRawLocations(uiLocation) {
+        // TODO(crbug.com/1153123): Revisit the `#columnNumber || 0` and also preserve `undefined` for source maps?
+        const { uiSourceCode, lineNumber, columnNumber = 0 } = uiLocation;
+        const binding = uiSourceCodeToBinding.get(uiSourceCode);
+        if (!binding) {
+            return [];
+        }
+        const locations = [];
+        for (const sourceMap of binding.getReferringSourceMaps()) {
+            const entries = sourceMap.findReverseEntries(uiSourceCode.url(), lineNumber, columnNumber);
+            const header = this.#sourceMapManager.clientForSourceMap(sourceMap);
+            if (header) {
+                locations.push(...entries.map(entry => new SDK.CSSModel.CSSLocation(header, entry.lineNumber, entry.columnNumber)));
+            }
+        }
+        return locations;
+    }
+    static uiSourceOrigin(uiSourceCode) {
+        const binding = uiSourceCodeToBinding.get(uiSourceCode);
+        if (binding) {
+            return binding.getReferringSourceMaps().map(sourceMap => sourceMap.compiledURL());
+        }
+        return [];
+    }
+    dispose() {
+        Common.EventTarget.removeEventListeners(this.#eventListeners);
+        this.#project.dispose();
+    }
+}
+const uiSourceCodeToBinding = new WeakMap();
+class Binding {
+    #project;
+    #url;
+    #initiator;
+    referringSourceMaps;
+    uiSourceCode;
+    constructor(project, url, initiator) {
+        this.#project = project;
+        this.#url = url;
+        this.#initiator = initiator;
+        this.referringSourceMaps = [];
+        this.uiSourceCode = null;
+    }
+    recreateUISourceCodeIfNeeded(frameId) {
+        const sourceMap = this.referringSourceMaps[this.referringSourceMaps.length - 1];
+        const contentType = Common.ResourceType.resourceTypes.SourceMapStyleSheet;
+        const embeddedContent = sourceMap.embeddedContentByURL(this.#url);
+        const contentProvider = embeddedContent !== null ?
+            TextUtils.StaticContentProvider.StaticContentProvider.fromString(this.#url, contentType, embeddedContent) :
+            new SDK.CompilerSourceMappingContentProvider.CompilerSourceMappingContentProvider(this.#url, contentType, this.#initiator);
+        const newUISourceCode = this.#project.createUISourceCode(this.#url, contentType);
+        uiSourceCodeToBinding.set(newUISourceCode, this);
+        const mimeType = Common.ResourceType.ResourceType.mimeFromURL(this.#url) || contentType.canonicalMimeType();
+        const metadata = typeof embeddedContent === 'string' ?
+            new Workspace.UISourceCode.UISourceCodeMetadata(null, embeddedContent.length) :
+            null;
+        if (this.uiSourceCode) {
+            NetworkProject.cloneInitialFrameAttribution(this.uiSourceCode, newUISourceCode);
+            this.#project.removeUISourceCode(this.uiSourceCode.url());
+        }
+        else {
+            NetworkProject.setInitialFrameAttribution(newUISourceCode, frameId);
+        }
+        this.uiSourceCode = newUISourceCode;
+        this.#project.addUISourceCodeWithProvider(this.uiSourceCode, contentProvider, metadata, mimeType);
+    }
+    addSourceMap(sourceMap, frameId) {
+        if (this.uiSourceCode) {
+            NetworkProject.addFrameAttribution(this.uiSourceCode, frameId);
+        }
+        this.referringSourceMaps.push(sourceMap);
+        this.recreateUISourceCodeIfNeeded(frameId);
+    }
+    removeSourceMap(sourceMap, frameId) {
+        const uiSourceCode = this.uiSourceCode;
+        NetworkProject.removeFrameAttribution(uiSourceCode, frameId);
+        const lastIndex = this.referringSourceMaps.lastIndexOf(sourceMap);
+        if (lastIndex !== -1) {
+            this.referringSourceMaps.splice(lastIndex, 1);
+        }
+        if (!this.referringSourceMaps.length) {
+            this.#project.removeUISourceCode(uiSourceCode.url());
+            this.uiSourceCode = null;
+        }
+        else {
+            this.recreateUISourceCodeIfNeeded(frameId);
+        }
+    }
+    getReferringSourceMaps() {
+        return this.referringSourceMaps;
+    }
+    getUiSourceCode() {
+        return this.uiSourceCode;
+    }
+}

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, };