chrome-devtools-mcp 0.0.1 → 0.0.2

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

@@ -0,0 +1,53 @@
+// 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.
+import { CSSLocation } from './CSSModel.js';
+export class CSSQuery {
+    text = '';
+    range;
+    styleSheetId;
+    cssModel;
+    constructor(cssModel) {
+        this.cssModel = cssModel;
+    }
+    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);
+        }
+    }
+    equal(other) {
+        if (!this.styleSheetId || !this.range || !other.range) {
+            return false;
+        }
+        return this.styleSheetId === other.styleSheetId && this.range.equal(other.range);
+    }
+    lineNumberInSource() {
+        if (!this.range) {
+            return undefined;
+        }
+        return this.header()?.lineNumberInSource(this.range.startLine);
+    }
+    columnNumberInSource() {
+        if (!this.range) {
+            return undefined;
+        }
+        return this.header()?.columnNumberInSource(this.range.startLine, this.range.startColumn);
+    }
+    header() {
+        return this.styleSheetId ? this.cssModel.styleSheetHeaderForId(this.styleSheetId) : null;
+    }
+    rawLocation() {
+        const header = this.header();
+        if (!header || this.lineNumberInSource() === undefined) {
+            return null;
+        }
+        const lineNumber = Number(this.lineNumberInSource());
+        return new CSSLocation(header, lineNumber, this.columnNumberInSource());
+    }
+}

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

@@ -0,0 +1,361 @@
+// 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 Platform from '../platform/platform.js';
+import { CSSContainerQuery } from './CSSContainerQuery.js';
+import { CSSLayer } from './CSSLayer.js';
+import { CSSMedia } from './CSSMedia.js';
+import { CSSScope } from './CSSScope.js';
+import { CSSStyleDeclaration, Type } from './CSSStyleDeclaration.js';
+import { CSSSupports } from './CSSSupports.js';
+function styleSheetHeaderForRule(cssModel, { styleSheetId }) {
+    return styleSheetId && cssModel.styleSheetHeaderForId(styleSheetId) || null;
+}
+export class CSSRule {
+    cssModelInternal;
+    origin;
+    style;
+    header;
+    constructor(cssModel, payload) {
+        this.header = payload.header;
+        this.cssModelInternal = cssModel;
+        this.origin = payload.origin;
+        this.style = new CSSStyleDeclaration(this.cssModelInternal, this, payload.style, Type.Regular);
+    }
+    get sourceURL() {
+        return this.header?.sourceURL;
+    }
+    rebase(edit) {
+        if (this.header?.id !== edit.styleSheetId) {
+            return;
+        }
+        this.style.rebase(edit);
+    }
+    resourceURL() {
+        return this.header?.resourceURL() ?? Platform.DevToolsPath.EmptyUrlString;
+    }
+    isUserAgent() {
+        return this.origin === "user-agent" /* Protocol.CSS.StyleSheetOrigin.UserAgent */;
+    }
+    isInjected() {
+        return this.origin === "injected" /* Protocol.CSS.StyleSheetOrigin.Injected */;
+    }
+    isViaInspector() {
+        return this.origin === "inspector" /* Protocol.CSS.StyleSheetOrigin.Inspector */;
+    }
+    isRegular() {
+        return this.origin === "regular" /* Protocol.CSS.StyleSheetOrigin.Regular */;
+    }
+    isKeyframeRule() {
+        return false;
+    }
+    cssModel() {
+        return this.cssModelInternal;
+    }
+}
+class CSSValue {
+    text;
+    range;
+    specificity;
+    constructor(payload) {
+        this.text = payload.text;
+        if (payload.range) {
+            this.range = TextUtils.TextRange.TextRange.fromObject(payload.range);
+        }
+        if (payload.specificity) {
+            this.specificity = payload.specificity;
+        }
+    }
+    rebase(edit) {
+        if (!this.range) {
+            return;
+        }
+        this.range = this.range.rebaseAfterTextEdit(edit.oldRange, edit.newRange);
+    }
+}
+export class CSSStyleRule extends CSSRule {
+    selectors;
+    nestingSelectors;
+    media;
+    containerQueries;
+    supports;
+    scopes;
+    layers;
+    ruleTypes;
+    wasUsed;
+    constructor(cssModel, payload, wasUsed) {
+        super(cssModel, { origin: payload.origin, style: payload.style, header: styleSheetHeaderForRule(cssModel, payload) });
+        this.reinitializeSelectors(payload.selectorList);
+        this.nestingSelectors = payload.nestingSelectors;
+        this.media = payload.media ? CSSMedia.parseMediaArrayPayload(cssModel, payload.media) : [];
+        this.containerQueries = payload.containerQueries ?
+            CSSContainerQuery.parseContainerQueriesPayload(cssModel, payload.containerQueries) :
+            [];
+        this.scopes = payload.scopes ? CSSScope.parseScopesPayload(cssModel, payload.scopes) : [];
+        this.supports = payload.supports ? CSSSupports.parseSupportsPayload(cssModel, payload.supports) : [];
+        this.layers = payload.layers ? CSSLayer.parseLayerPayload(cssModel, payload.layers) : [];
+        this.ruleTypes = payload.ruleTypes || [];
+        this.wasUsed = wasUsed || false;
+    }
+    static createDummyRule(cssModel, selectorText) {
+        const dummyPayload = {
+            selectorList: {
+                text: '',
+                selectors: [{ text: selectorText, value: undefined }],
+            },
+            style: {
+                styleSheetId: '0',
+                range: new TextUtils.TextRange.TextRange(0, 0, 0, 0),
+                shorthandEntries: [],
+                cssProperties: [],
+            },
+            origin: "inspector" /* Protocol.CSS.StyleSheetOrigin.Inspector */,
+        };
+        return new CSSStyleRule(cssModel, dummyPayload);
+    }
+    reinitializeSelectors(selectorList) {
+        this.selectors = [];
+        for (let i = 0; i < selectorList.selectors.length; ++i) {
+            this.selectors.push(new CSSValue(selectorList.selectors[i]));
+        }
+    }
+    setSelectorText(newSelector) {
+        const styleSheetId = this.header?.id;
+        if (!styleSheetId) {
+            throw new Error('No rule stylesheet id');
+        }
+        const range = this.selectorRange();
+        if (!range) {
+            throw new Error('Rule selector is not editable');
+        }
+        return this.cssModelInternal.setSelectorText(styleSheetId, range, newSelector);
+    }
+    selectorText() {
+        return this.selectors.map(selector => selector.text).join(', ');
+    }
+    selectorRange() {
+        // Nested group rules might not contain a selector.
+        // https://www.w3.org/TR/css-nesting-1/#conditionals
+        if (this.selectors.length === 0) {
+            return null;
+        }
+        const firstRange = this.selectors[0].range;
+        const lastRange = this.selectors[this.selectors.length - 1].range;
+        if (!firstRange || !lastRange) {
+            return null;
+        }
+        return new TextUtils.TextRange.TextRange(firstRange.startLine, firstRange.startColumn, lastRange.endLine, lastRange.endColumn);
+    }
+    lineNumberInSource(selectorIndex) {
+        const selector = this.selectors[selectorIndex];
+        if (!selector?.range || !this.header) {
+            return 0;
+        }
+        return this.header.lineNumberInSource(selector.range.startLine);
+    }
+    columnNumberInSource(selectorIndex) {
+        const selector = this.selectors[selectorIndex];
+        if (!selector?.range || !this.header) {
+            return undefined;
+        }
+        return this.header.columnNumberInSource(selector.range.startLine, selector.range.startColumn);
+    }
+    rebase(edit) {
+        if (this.header?.id !== edit.styleSheetId) {
+            return;
+        }
+        const range = this.selectorRange();
+        if (range?.equal(edit.oldRange)) {
+            this.reinitializeSelectors(edit.payload);
+        }
+        else {
+            for (let i = 0; i < this.selectors.length; ++i) {
+                this.selectors[i].rebase(edit);
+            }
+        }
+        this.media.forEach(media => media.rebase(edit));
+        this.containerQueries.forEach(cq => cq.rebase(edit));
+        this.scopes.forEach(scope => scope.rebase(edit));
+        this.supports.forEach(supports => supports.rebase(edit));
+        super.rebase(edit);
+    }
+}
+export class CSSPropertyRule extends CSSRule {
+    #name;
+    constructor(cssModel, payload) {
+        super(cssModel, { origin: payload.origin, style: payload.style, header: styleSheetHeaderForRule(cssModel, payload) });
+        this.#name = new CSSValue(payload.propertyName);
+    }
+    propertyName() {
+        return this.#name;
+    }
+    initialValue() {
+        return this.style.hasActiveProperty('initial-value') ? this.style.getPropertyValue('initial-value') : null;
+    }
+    syntax() {
+        return this.style.getPropertyValue('syntax');
+    }
+    inherits() {
+        return this.style.getPropertyValue('inherits') === 'true';
+    }
+    setPropertyName(newPropertyName) {
+        const styleSheetId = this.header?.id;
+        if (!styleSheetId) {
+            throw new Error('No rule stylesheet id');
+        }
+        const range = this.#name.range;
+        if (!range) {
+            throw new Error('Property name is not editable');
+        }
+        return this.cssModelInternal.setPropertyRulePropertyName(styleSheetId, range, newPropertyName);
+    }
+}
+export class CSSFontPaletteValuesRule extends CSSRule {
+    #paletteName;
+    constructor(cssModel, payload) {
+        super(cssModel, { origin: payload.origin, style: payload.style, header: styleSheetHeaderForRule(cssModel, payload) });
+        this.#paletteName = new CSSValue(payload.fontPaletteName);
+    }
+    name() {
+        return this.#paletteName;
+    }
+}
+export class CSSKeyframesRule {
+    #animationName;
+    #keyframes;
+    constructor(cssModel, payload) {
+        this.#animationName = new CSSValue(payload.animationName);
+        this.#keyframes =
+            payload.keyframes.map(keyframeRule => new CSSKeyframeRule(cssModel, keyframeRule, this.#animationName.text));
+    }
+    name() {
+        return this.#animationName;
+    }
+    keyframes() {
+        return this.#keyframes;
+    }
+}
+export class CSSKeyframeRule extends CSSRule {
+    #keyText;
+    #parentRuleName;
+    constructor(cssModel, payload, parentRuleName) {
+        super(cssModel, { origin: payload.origin, style: payload.style, header: styleSheetHeaderForRule(cssModel, payload) });
+        this.reinitializeKey(payload.keyText);
+        this.#parentRuleName = parentRuleName;
+    }
+    parentRuleName() {
+        return this.#parentRuleName;
+    }
+    key() {
+        return this.#keyText;
+    }
+    reinitializeKey(payload) {
+        this.#keyText = new CSSValue(payload);
+    }
+    rebase(edit) {
+        if (this.header?.id !== edit.styleSheetId || !this.#keyText.range) {
+            return;
+        }
+        if (edit.oldRange.equal(this.#keyText.range)) {
+            this.reinitializeKey(edit.payload);
+        }
+        else {
+            this.#keyText.rebase(edit);
+        }
+        super.rebase(edit);
+    }
+    isKeyframeRule() {
+        return true;
+    }
+    setKeyText(newKeyText) {
+        const styleSheetId = this.header?.id;
+        if (!styleSheetId) {
+            throw new Error('No rule stylesheet id');
+        }
+        const range = this.#keyText.range;
+        if (!range) {
+            throw new Error('Keyframe key is not editable');
+        }
+        return this.cssModelInternal.setKeyframeKey(styleSheetId, range, newKeyText);
+    }
+}
+export class CSSPositionTryRule extends CSSRule {
+    #name;
+    #active;
+    constructor(cssModel, payload) {
+        super(cssModel, { origin: payload.origin, style: payload.style, header: styleSheetHeaderForRule(cssModel, payload) });
+        this.#name = new CSSValue(payload.name);
+        this.#active = payload.active;
+    }
+    name() {
+        return this.#name;
+    }
+    active() {
+        return this.#active;
+    }
+}
+export class CSSFunctionRule extends CSSRule {
+    #name;
+    #parameters;
+    #children;
+    constructor(cssModel, payload) {
+        super(cssModel, {
+            origin: payload.origin,
+            style: { cssProperties: [], shorthandEntries: [] },
+            header: styleSheetHeaderForRule(cssModel, payload)
+        });
+        this.#name = new CSSValue(payload.name);
+        this.#parameters = payload.parameters.map(({ name }) => name);
+        this.#children = this.protocolNodesToNestedStyles(payload.children);
+    }
+    functionName() {
+        return this.#name;
+    }
+    parameters() {
+        return this.#parameters;
+    }
+    children() {
+        return this.#children;
+    }
+    nameWithParameters() {
+        return `${this.functionName().text}(${this.parameters().join(', ')})`;
+    }
+    protocolNodesToNestedStyles(nodes) {
+        const result = [];
+        for (const node of nodes) {
+            const nestedStyle = this.protocolNodeToNestedStyle(node);
+            if (nestedStyle) {
+                result.push(nestedStyle);
+            }
+        }
+        return result;
+    }
+    protocolNodeToNestedStyle(node) {
+        if (node.style) {
+            return { style: new CSSStyleDeclaration(this.cssModelInternal, this, node.style, Type.Regular) };
+        }
+        if (node.condition) {
+            const children = this.protocolNodesToNestedStyles(node.condition.children);
+            if (node.condition.media) {
+                return { children, media: new CSSMedia(this.cssModelInternal, node.condition.media) };
+            }
+            if (node.condition.containerQueries) {
+                return {
+                    children,
+                    container: new CSSContainerQuery(this.cssModelInternal, node.condition.containerQueries),
+                };
+            }
+            if (node.condition.supports) {
+                return {
+                    children,
+                    supports: new CSSSupports(this.cssModelInternal, node.condition.supports),
+                };
+            }
+            console.error('A function rule condition must have a media, container, or supports');
+            return;
+        }
+        console.error('A function rule node must have a style or condition');
+        return;
+    }
+}

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

@@ -0,0 +1,22 @@
+// 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 CSSScope extends CSSQuery {
+    static parseScopesPayload(cssModel, payload) {
+        return payload.map(scope => new CSSScope(cssModel, scope));
+    }
+    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;
+    }
+    active() {
+        return true;
+    }
+}