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

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSStyleDeclaration.js

@@ -0,0 +1,275 @@
+// Copyright 2016 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 TextUtils from '../../models/text_utils/text_utils.js';
+import { cssMetadata } from './CSSMetadata.js';
+import { CSSProperty } from './CSSProperty.js';
+export class CSSStyleDeclaration {
+    #cssModel;
+    parentRule;
+    #allProperties = [];
+    styleSheetId;
+    range = null;
+    cssText;
+    #shorthandValues = new Map();
+    #shorthandIsImportant = new Set();
+    #activePropertyMap = new Map();
+    #leadingProperties = null;
+    type;
+    // For CSSStyles coming from animations,
+    // This holds the name of the animation.
+    #animationName;
+    constructor(cssModel, parentRule, payload, type, animationName) {
+        this.#cssModel = cssModel;
+        this.parentRule = parentRule;
+        this.#reinitialize(payload);
+        this.type = type;
+        this.#animationName = animationName;
+    }
+    rebase(edit) {
+        if (this.styleSheetId !== edit.styleSheetId || !this.range) {
+            return;
+        }
+        if (edit.oldRange.equal(this.range)) {
+            this.#reinitialize(edit.payload);
+        }
+        else {
+            this.range = this.range.rebaseAfterTextEdit(edit.oldRange, edit.newRange);
+            for (let i = 0; i < this.#allProperties.length; ++i) {
+                this.#allProperties[i].rebase(edit);
+            }
+        }
+    }
+    animationName() {
+        return this.#animationName;
+    }
+    #reinitialize(payload) {
+        this.styleSheetId = payload.styleSheetId;
+        this.range = payload.range ? TextUtils.TextRange.TextRange.fromObject(payload.range) : null;
+        const shorthandEntries = payload.shorthandEntries;
+        this.#shorthandValues = new Map();
+        this.#shorthandIsImportant = new Set();
+        for (let i = 0; i < shorthandEntries.length; ++i) {
+            this.#shorthandValues.set(shorthandEntries[i].name, shorthandEntries[i].value);
+            if (shorthandEntries[i].important) {
+                this.#shorthandIsImportant.add(shorthandEntries[i].name);
+            }
+        }
+        this.#allProperties = [];
+        if (payload.cssText && this.range) {
+            const longhands = [];
+            for (const cssProperty of payload.cssProperties) {
+                const range = cssProperty.range;
+                if (!range) {
+                    continue;
+                }
+                const parsedProperty = CSSProperty.parsePayload(this, this.#allProperties.length, cssProperty);
+                this.#allProperties.push(parsedProperty);
+                for (const longhand of parsedProperty.getLonghandProperties()) {
+                    longhands.push(longhand);
+                }
+            }
+            for (const longhand of longhands) {
+                longhand.index = this.#allProperties.length;
+                this.#allProperties.push(longhand);
+            }
+        }
+        else {
+            for (const cssProperty of payload.cssProperties) {
+                this.#allProperties.push(CSSProperty.parsePayload(this, this.#allProperties.length, cssProperty));
+            }
+        }
+        this.#generateSyntheticPropertiesIfNeeded();
+        this.#computeInactiveProperties();
+        // TODO(changhaohan): verify if this #activePropertyMap is still necessary, or if it is
+        // providing different information against the activeness in #allProperties.
+        this.#activePropertyMap = new Map();
+        for (const property of this.#allProperties) {
+            if (!property.activeInStyle()) {
+                continue;
+            }
+            this.#activePropertyMap.set(property.name, property);
+        }
+        this.cssText = payload.cssText;
+        this.#leadingProperties = null;
+    }
+    #generateSyntheticPropertiesIfNeeded() {
+        if (this.range) {
+            return;
+        }
+        if (!this.#shorthandValues.size) {
+            return;
+        }
+        const propertiesSet = new Set();
+        for (const property of this.#allProperties) {
+            propertiesSet.add(property.name);
+        }
+        const generatedProperties = [];
+        // For style-based properties, generate #shorthands with values when possible.
+        for (const property of this.#allProperties) {
+            // For style-based properties, try generating #shorthands.
+            const shorthands = cssMetadata().getShorthands(property.name) || [];
+            for (const shorthand of shorthands) {
+                if (propertiesSet.has(shorthand)) {
+                    continue;
+                } // There already is a shorthand this #longhand falls under.
+                const shorthandValue = this.#shorthandValues.get(shorthand);
+                if (!shorthandValue) {
+                    continue;
+                } // Never generate synthetic #shorthands when no value is available.
+                // Generate synthetic shorthand we have a value for.
+                const shorthandImportance = Boolean(this.#shorthandIsImportant.has(shorthand));
+                const shorthandProperty = new CSSProperty(this, this.allProperties().length, shorthand, shorthandValue, shorthandImportance, false, true, false);
+                generatedProperties.push(shorthandProperty);
+                propertiesSet.add(shorthand);
+            }
+        }
+        this.#allProperties = this.#allProperties.concat(generatedProperties);
+    }
+    #computeLeadingProperties() {
+        function propertyHasRange(property) {
+            return Boolean(property.range);
+        }
+        if (this.range) {
+            return this.#allProperties.filter(propertyHasRange);
+        }
+        const leadingProperties = [];
+        for (const property of this.#allProperties) {
+            const shorthands = cssMetadata().getShorthands(property.name) || [];
+            let belongToAnyShorthand = false;
+            for (const shorthand of shorthands) {
+                if (this.#shorthandValues.get(shorthand)) {
+                    belongToAnyShorthand = true;
+                    break;
+                }
+            }
+            if (!belongToAnyShorthand) {
+                leadingProperties.push(property);
+            }
+        }
+        return leadingProperties;
+    }
+    leadingProperties() {
+        if (!this.#leadingProperties) {
+            this.#leadingProperties = this.#computeLeadingProperties();
+        }
+        return this.#leadingProperties;
+    }
+    target() {
+        return this.#cssModel.target();
+    }
+    cssModel() {
+        return this.#cssModel;
+    }
+    #computeInactiveProperties() {
+        const activeProperties = new Map();
+        // The order of the properties are:
+        // 1. regular property, including shorthands
+        // 2. longhand components from shorthands, in the order of their shorthands.
+        const processedLonghands = new Set();
+        for (const property of this.#allProperties) {
+            const metadata = cssMetadata();
+            const canonicalName = metadata.canonicalPropertyName(property.name);
+            if (property.disabled || !property.parsedOk) {
+                if (!property.disabled && metadata.isCustomProperty(property.name)) {
+                    // Variable declarations that aren't parsedOk still "overload" other previous active declarations.
+                    activeProperties.get(canonicalName)?.setActive(false);
+                    activeProperties.delete(canonicalName);
+                }
+                property.setActive(false);
+                continue;
+            }
+            if (processedLonghands.has(property)) {
+                continue;
+            }
+            for (const longhand of property.getLonghandProperties()) {
+                const activeLonghand = activeProperties.get(longhand.name);
+                if (!activeLonghand) {
+                    activeProperties.set(longhand.name, longhand);
+                }
+                else if (!activeLonghand.important || longhand.important) {
+                    activeLonghand.setActive(false);
+                    activeProperties.set(longhand.name, longhand);
+                }
+                else {
+                    longhand.setActive(false);
+                }
+                processedLonghands.add(longhand);
+            }
+            const activeProperty = activeProperties.get(canonicalName);
+            if (!activeProperty) {
+                activeProperties.set(canonicalName, property);
+            }
+            else if (!activeProperty.important || property.important) {
+                activeProperty.setActive(false);
+                activeProperties.set(canonicalName, property);
+            }
+            else {
+                property.setActive(false);
+            }
+        }
+    }
+    allProperties() {
+        return this.#allProperties;
+    }
+    hasActiveProperty(name) {
+        return this.#activePropertyMap.has(name);
+    }
+    getPropertyValue(name) {
+        const property = this.#activePropertyMap.get(name);
+        return property ? property.value : '';
+    }
+    isPropertyImplicit(name) {
+        const property = this.#activePropertyMap.get(name);
+        return property ? property.implicit : false;
+    }
+    propertyAt(index) {
+        return (index < this.allProperties().length) ? this.allProperties()[index] : null;
+    }
+    pastLastSourcePropertyIndex() {
+        for (let i = this.allProperties().length - 1; i >= 0; --i) {
+            if (this.allProperties()[i].range) {
+                return i + 1;
+            }
+        }
+        return 0;
+    }
+    #insertionRange(index) {
+        const property = this.propertyAt(index);
+        if (property?.range) {
+            return property.range.collapseToStart();
+        }
+        if (!this.range) {
+            throw new Error('CSSStyleDeclaration.range is null');
+        }
+        return this.range.collapseToEnd();
+    }
+    newBlankProperty(index) {
+        index = (typeof index === 'undefined') ? this.pastLastSourcePropertyIndex() : index;
+        const property = new CSSProperty(this, index, '', '', false, false, true, false, '', this.#insertionRange(index));
+        return property;
+    }
+    setText(text, majorChange) {
+        if (!this.range || !this.styleSheetId) {
+            return Promise.resolve(false);
+        }
+        return this.#cssModel.setStyleText(this.styleSheetId, this.range, text, majorChange);
+    }
+    insertPropertyAt(index, name, value, userCallback) {
+        void this.newBlankProperty(index).setText(name + ': ' + value + ';', false, true).then(userCallback);
+    }
+    appendProperty(name, value, userCallback) {
+        this.insertPropertyAt(this.allProperties().length, name, value, userCallback);
+    }
+}
+export var Type;
+(function (Type) {
+    /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
+    Type["Regular"] = "Regular";
+    Type["Inline"] = "Inline";
+    Type["Attributes"] = "Attributes";
+    Type["Pseudo"] = "Pseudo";
+    Type["Transition"] = "Transition";
+    Type["Animation"] = "Animation";
+    /* eslint-enable @typescript-eslint/naming-convention */
+})(Type || (Type = {}));

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSStyleSheetHeader.js

@@ -0,0 +1,166 @@
+// Copyright 2016 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 TextUtils from '../../models/text_utils/text_utils.js';
+import * as Common from '../common/common.js';
+import * as i18n from '../i18n/i18n.js';
+import * as Platform from '../platform/platform.js';
+import { DeferredDOMNode } from './DOMModel.js';
+import { ResourceTreeModel } from './ResourceTreeModel.js';
+const UIStrings = {
+    /**
+     * @description Error message for when a CSS file can't be loaded
+     */
+    couldNotFindTheOriginalStyle: 'Could not find the original style sheet.',
+    /**
+     * @description Error message to display when a source CSS file could not be retrieved.
+     */
+    thereWasAnErrorRetrievingThe: 'There was an error retrieving the source styles.',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/CSSStyleSheetHeader.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class CSSStyleSheetHeader {
+    #cssModel;
+    id;
+    frameId;
+    sourceURL;
+    hasSourceURL;
+    origin;
+    title;
+    disabled;
+    isInline;
+    isMutable;
+    isConstructed;
+    startLine;
+    startColumn;
+    endLine;
+    endColumn;
+    contentLength;
+    ownerNode;
+    sourceMapURL;
+    loadingFailed;
+    #originalContentProvider;
+    constructor(cssModel, payload) {
+        this.#cssModel = cssModel;
+        this.id = payload.styleSheetId;
+        this.frameId = payload.frameId;
+        this.sourceURL = payload.sourceURL;
+        this.hasSourceURL = Boolean(payload.hasSourceURL);
+        this.origin = payload.origin;
+        this.title = payload.title;
+        this.disabled = payload.disabled;
+        this.isInline = payload.isInline;
+        this.isMutable = payload.isMutable;
+        this.isConstructed = payload.isConstructed;
+        this.startLine = payload.startLine;
+        this.startColumn = payload.startColumn;
+        this.endLine = payload.endLine;
+        this.endColumn = payload.endColumn;
+        this.contentLength = payload.length;
+        if (payload.ownerNode) {
+            this.ownerNode = new DeferredDOMNode(cssModel.target(), payload.ownerNode);
+        }
+        this.sourceMapURL = payload.sourceMapURL;
+        this.loadingFailed = payload.loadingFailed ?? false;
+        this.#originalContentProvider = null;
+    }
+    originalContentProvider() {
+        if (!this.#originalContentProvider) {
+            const lazyContent = (async () => {
+                const originalText = await this.#cssModel.originalStyleSheetText(this);
+                if (originalText === null) {
+                    return { error: i18nString(UIStrings.couldNotFindTheOriginalStyle) };
+                }
+                return new TextUtils.ContentData.ContentData(originalText, /* isBase64=*/ false, 'text/css');
+            });
+            this.#originalContentProvider =
+                new TextUtils.StaticContentProvider.StaticContentProvider(this.contentURL(), this.contentType(), lazyContent);
+        }
+        return this.#originalContentProvider;
+    }
+    setSourceMapURL(sourceMapURL) {
+        this.sourceMapURL = sourceMapURL;
+    }
+    cssModel() {
+        return this.#cssModel;
+    }
+    isAnonymousInlineStyleSheet() {
+        return !this.resourceURL() && !this.#cssModel.sourceMapManager().sourceMapForClient(this);
+    }
+    isConstructedByNew() {
+        return this.isConstructed && this.sourceURL.length === 0;
+    }
+    resourceURL() {
+        return this.isViaInspector() ? this.viaInspectorResourceURL() : this.sourceURL;
+    }
+    getFrameURLPath() {
+        const model = this.#cssModel.target().model(ResourceTreeModel);
+        console.assert(Boolean(model));
+        if (!model) {
+            return '';
+        }
+        const frame = model.frameForId(this.frameId);
+        if (!frame) {
+            return '';
+        }
+        console.assert(Boolean(frame));
+        const parsedURL = new Common.ParsedURL.ParsedURL(frame.url);
+        let urlPath = parsedURL.host;
+        if (parsedURL.port) {
+            urlPath += ':' + parsedURL.port;
+        }
+        urlPath += parsedURL.folderPathComponents;
+        if (!urlPath.endsWith('/')) {
+            urlPath += '/';
+        }
+        return urlPath;
+    }
+    viaInspectorResourceURL() {
+        return `inspector://${this.getFrameURLPath()}inspector-stylesheet#${this.id}`;
+    }
+    lineNumberInSource(lineNumberInStyleSheet) {
+        return this.startLine + lineNumberInStyleSheet;
+    }
+    columnNumberInSource(lineNumberInStyleSheet, columnNumberInStyleSheet) {
+        return (lineNumberInStyleSheet ? 0 : this.startColumn) + columnNumberInStyleSheet;
+    }
+    /**
+     * Checks whether the position is in this style sheet. Assumes that the
+     * position's columnNumber is consistent with line endings.
+     */
+    containsLocation(lineNumber, columnNumber) {
+        const afterStart = (lineNumber === this.startLine && columnNumber >= this.startColumn) || lineNumber > this.startLine;
+        const beforeEnd = lineNumber < this.endLine || (lineNumber === this.endLine && columnNumber <= this.endColumn);
+        return afterStart && beforeEnd;
+    }
+    contentURL() {
+        return this.resourceURL();
+    }
+    contentType() {
+        return Common.ResourceType.resourceTypes.Stylesheet;
+    }
+    async requestContentData() {
+        const cssText = await this.#cssModel.getStyleSheetText(this.id);
+        if (cssText === null) {
+            return { error: i18nString(UIStrings.thereWasAnErrorRetrievingThe) };
+        }
+        return new TextUtils.ContentData.ContentData(cssText, /* isBase64=*/ false, 'text/css');
+    }
+    async searchInContent(query, caseSensitive, isRegex) {
+        const contentData = await this.requestContentData();
+        return TextUtils.TextUtils.performSearchInContentData(contentData, query, caseSensitive, isRegex);
+    }
+    isViaInspector() {
+        return this.origin === 'inspector';
+    }
+    createPageResourceLoadInitiator() {
+        return {
+            target: this.#cssModel.target(),
+            frameId: this.frameId,
+            initiatorUrl: this.hasSourceURL ? Platform.DevToolsPath.EmptyUrlString : this.sourceURL,
+        };
+    }
+    debugId() {
+        return null;
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSSupports.js

@@ -0,0 +1,24 @@
+// Copyright 2022 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 TextUtils from '../../models/text_utils/text_utils.js';
+import { CSSQuery } from './CSSQuery.js';
+export class CSSSupports extends CSSQuery {
+    static parseSupportsPayload(cssModel, payload) {
+        return payload.map(supports => new CSSSupports(cssModel, supports));
+    }
+    #active = true;
+    constructor(cssModel, payload) {
+        super(cssModel);
+        this.reinitialize(payload);
+    }
+    reinitialize(payload) {
+        this.text = payload.text;
+        this.range = payload.range ? TextUtils.TextRange.TextRange.fromObject(payload.range) : null;
+        this.styleSheetId = payload.styleSheetId;
+        this.#active = payload.active;
+    }
+    active() {
+        return this.#active;
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CategorizedBreakpoint.js

@@ -0,0 +1,29 @@
+// 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.
+export class CategorizedBreakpoint {
+    /**
+     * The name of this breakpoint as passed to 'setInstrumentationBreakpoint',
+     * 'setEventListenerBreakpoint' and 'setBreakOnCSPViolation'.
+     *
+     * Note that the backend adds a 'listener:' and 'instrumentation:' prefix
+     * to this name in the 'Debugger.paused' CDP event.
+     */
+    name;
+    #category;
+    #enabled;
+    constructor(category, name) {
+        this.#category = category;
+        this.name = name;
+        this.#enabled = false;
+    }
+    category() {
+        return this.#category;
+    }
+    enabled() {
+        return this.#enabled;
+    }
+    setEnabled(enabled) {
+        this.#enabled = enabled;
+    }
+}