chrome-devtools-mcp 0.10.1 → 0.10.2

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

@@ -0,0 +1,140 @@
+// Copyright 2020 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 i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+import { resolveLazyDescription, } from './MarkdownIssueDescription.js';
+const UIStrings = {
+    /**
+     * @description Title for CSP url link
+     */
+    contentSecurityPolicySource: 'Content Security Policy - Source Allowlists',
+    /**
+     * @description Title for CSP inline issue link
+     */
+    contentSecurityPolicyInlineCode: 'Content Security Policy - Inline Code',
+    /**
+     * @description Title for the CSP eval link
+     */
+    contentSecurityPolicyEval: 'Content Security Policy - Eval',
+    /**
+     * @description Title for Trusted Types policy violation issue link. https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API
+     */
+    trustedTypesFixViolations: 'Trusted Types - Fix violations',
+    /**
+     * @description Title for Trusted Types policy violation issue link. https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API
+     */
+    trustedTypesPolicyViolation: 'Trusted Types - Policy violation',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/ContentSecurityPolicyIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+export class ContentSecurityPolicyIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel, issueId) {
+        const issueCode = [
+            "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+            issueDetails.contentSecurityPolicyViolationType,
+        ].join('::');
+        super(issueCode, issuesModel, issueId);
+        this.#issueDetails = issueDetails;
+    }
+    getCategory() {
+        return "ContentSecurityPolicy" /* IssueCategory.CONTENT_SECURITY_POLICY */;
+    }
+    primaryKey() {
+        return JSON.stringify(this.#issueDetails, [
+            'blockedURL',
+            'contentSecurityPolicyViolationType',
+            'violatedDirective',
+            'isReportOnly',
+            'sourceCodeLocation',
+            'url',
+            'lineNumber',
+            'columnNumber',
+            'violatingNodeId',
+        ]);
+    }
+    getDescription() {
+        const description = issueDescriptions.get(this.#issueDetails.contentSecurityPolicyViolationType);
+        if (!description) {
+            return null;
+        }
+        return resolveLazyDescription(description);
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    getKind() {
+        if (this.#issueDetails.isReportOnly) {
+            return "Improvement" /* IssueKind.IMPROVEMENT */;
+        }
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const cspDetails = inspectorIssue.details.contentSecurityPolicyIssueDetails;
+        if (!cspDetails) {
+            console.warn('Content security policy issue without details received.');
+            return [];
+        }
+        return [new ContentSecurityPolicyIssue(cspDetails, issuesModel, inspectorIssue.issueId)];
+    }
+}
+const cspURLViolation = {
+    file: 'cspURLViolation.md',
+    links: [{
+            link: 'https://developers.google.com/web/fundamentals/security/csp#source_allowlists',
+            linkTitle: i18nLazyString(UIStrings.contentSecurityPolicySource),
+        }],
+};
+const cspInlineViolation = {
+    file: 'cspInlineViolation.md',
+    links: [{
+            link: 'https://developers.google.com/web/fundamentals/security/csp#inline_code_is_considered_harmful',
+            linkTitle: i18nLazyString(UIStrings.contentSecurityPolicyInlineCode),
+        }],
+};
+const cspEvalViolation = {
+    file: 'cspEvalViolation.md',
+    links: [{
+            link: 'https://developers.google.com/web/fundamentals/security/csp#eval_too',
+            linkTitle: i18nLazyString(UIStrings.contentSecurityPolicyEval),
+        }],
+};
+const cspTrustedTypesSinkViolation = {
+    file: 'cspTrustedTypesSinkViolation.md',
+    links: [{
+            link: 'https://web.dev/trusted-types/#fix-the-violations',
+            linkTitle: i18nLazyString(UIStrings.trustedTypesFixViolations),
+        }],
+};
+const cspTrustedTypesPolicyViolation = {
+    file: 'cspTrustedTypesPolicyViolation.md',
+    links: [{ link: 'https://web.dev/trusted-types/', linkTitle: i18nLazyString(UIStrings.trustedTypesPolicyViolation) }],
+};
+export const urlViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kURLViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KURLViolation */,
+].join('::');
+export const inlineViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kInlineViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KInlineViolation */,
+].join('::');
+export const evalViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kEvalViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KEvalViolation */,
+].join('::');
+export const trustedTypesSinkViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kTrustedTypesSinkViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KTrustedTypesSinkViolation */,
+].join('::');
+export const trustedTypesPolicyViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kTrustedTypesPolicyViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KTrustedTypesPolicyViolation */,
+].join('::');
+const issueDescriptions = new Map([
+    ["kURLViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KURLViolation */, cspURLViolation],
+    ["kInlineViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KInlineViolation */, cspInlineViolation],
+    ["kEvalViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KEvalViolation */, cspEvalViolation],
+    ["kTrustedTypesSinkViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KTrustedTypesSinkViolation */, cspTrustedTypesSinkViolation],
+    ["kTrustedTypesPolicyViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KTrustedTypesPolicyViolation */, cspTrustedTypesPolicyViolation],
+]);

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

@@ -0,0 +1,59 @@
+// 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 * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
+import * as SDK from '../../core/sdk/sdk.js';
+let contrastCheckTriggerInstance = null;
+export class ContrastCheckTrigger {
+    #pageLoadListeners = new WeakMap();
+    #frameAddedListeners = new WeakMap();
+    constructor() {
+        SDK.TargetManager.TargetManager.instance().observeModels(SDK.ResourceTreeModel.ResourceTreeModel, this);
+    }
+    static instance({ forceNew } = { forceNew: false }) {
+        if (!contrastCheckTriggerInstance || forceNew) {
+            contrastCheckTriggerInstance = new ContrastCheckTrigger();
+        }
+        return contrastCheckTriggerInstance;
+    }
+    async modelAdded(resourceTreeModel) {
+        this.#pageLoadListeners.set(resourceTreeModel, resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.Load, this.#pageLoaded, this));
+        this.#frameAddedListeners.set(resourceTreeModel, resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameAdded, this.#frameAdded, this));
+    }
+    modelRemoved(resourceTreeModel) {
+        const pageLoadListener = this.#pageLoadListeners.get(resourceTreeModel);
+        if (pageLoadListener) {
+            Common.EventTarget.removeEventListeners([pageLoadListener]);
+        }
+        const frameAddedListeners = this.#frameAddedListeners.get(resourceTreeModel);
+        if (frameAddedListeners) {
+            Common.EventTarget.removeEventListeners([frameAddedListeners]);
+        }
+    }
+    #checkContrast(resourceTreeModel) {
+        if (!Root.Runtime.experiments.isEnabled('contrast-issues')) {
+            return;
+        }
+        void resourceTreeModel.target().auditsAgent().invoke_checkContrast({});
+    }
+    #pageLoaded(event) {
+        const { resourceTreeModel } = event.data;
+        this.#checkContrast(resourceTreeModel);
+    }
+    async #frameAdded(event) {
+        if (!Root.Runtime.experiments.isEnabled('contrast-issues')) {
+            return;
+        }
+        const frame = event.data;
+        if (!frame.isMainFrame()) {
+            return;
+        }
+        // If the target document finished loading, check the contrast immediately.
+        // Otherwise, it should be triggered when the page load event fires.
+        const response = await frame.resourceTreeModel().target().runtimeAgent().invoke_evaluate({ expression: 'document.readyState', returnByValue: true });
+        if (response.result && response.result.value === 'complete') {
+            this.#checkContrast(frame.resourceTreeModel());
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+// Copyright 2023 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 i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+const UIStrings = {
+    /**
+     * @description Label for a link for third-party cookie Issues.
+     */
+    thirdPartyPhaseoutExplained: 'Changes to Chrome\'s treatment of third-party cookies',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/CookieDeprecationMetadataIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+/** TODO(b/305738703): Move this issue into a warning on CookieIssue. **/
+export class CookieDeprecationMetadataIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        // Set a distinct code for ReadCookie and SetCookie issues, so they are grouped separately.
+        const issueCode = "CookieDeprecationMetadataIssue" /* Protocol.Audits.InspectorIssueCode.CookieDeprecationMetadataIssue */ + '_' + issueDetails.operation;
+        super(issueCode, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        const fileName = this.#issueDetails.operation === 'SetCookie' ? 'cookieWarnMetadataGrantSet.md' :
+            'cookieWarnMetadataGrantRead.md';
+        let optOutText = '';
+        if (this.#issueDetails.isOptOutTopLevel) {
+            optOutText = '\n\n (Top level site opt-out: ' + this.#issueDetails.optOutPercentage +
+                '% - [learn more](gracePeriodStagedControlExplainer))';
+        }
+        return {
+            file: fileName,
+            substitutions: new Map([
+                ['PLACEHOLDER_topleveloptout', optOutText],
+            ]),
+            links: [
+                {
+                    link: 'https://goo.gle/changes-to-chrome-browsing',
+                    linkTitle: i18nString(UIStrings.thirdPartyPhaseoutExplained),
+                },
+            ],
+        };
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    getKind() {
+        return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+    }
+    primaryKey() {
+        return JSON.stringify(this.#issueDetails);
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.cookieDeprecationMetadataIssueDetails;
+        if (!details) {
+            console.warn('Cookie deprecation metadata issue without details received.');
+            return [];
+        }
+        return [new CookieDeprecationMetadataIssue(details, issuesModel)];
+    }
+}