chrome-devtools-mcp 0.9.0 → 0.10.1

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/InspectorBackend.js

@@ -2,13 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
+import { CDPErrorStatus } from './CDPConnection.js';
 import { ConnectionTransport } from './ConnectionTransport.js';
 import { NodeURL } from './NodeURL.js';
-export const DevToolsStubErrorCode = -32015;
-// TODO(dgozman): we are not reporting generic errors in tests, but we should
-// instead report them and just have some expected errors in test expectations.
-const GenericErrorCode = -32000;
-const ConnectionClosedErrorCode = -32001;
 export const splitQualifiedName = (string) => {
     const [domain, eventName] = string.split('.');
     return [domain, eventName];
@@ -18,7 +14,6 @@ export const qualifyName = (domain, name) => {
 };
 export class InspectorBackend {
     agentPrototypes = new Map();
-    #initialized = false;
     #eventParameterNamesForDomain = new Map();
     typeMap = new Map();
     enumMap = new Map();
@@ -49,9 +44,6 @@ export class InspectorBackend {
     static reportProtocolWarning(error, messageObject) {
         console.warn(error + ': ' + JSON.stringify(messageObject));
     }
-    isInitialized() {
-        return this.#initialized;
-    }
     agentPrototype(domain) {
         let prototype = this.agentPrototypes.get(domain);
         if (!prototype) {
@@ -63,7 +55,6 @@ export class InspectorBackend {
     registerCommand(method, parameters, replyArgs, description) {
         const [domain, command] = splitQualifiedName(method);
         this.agentPrototype(domain).registerCommand(command, parameters, replyArgs, description);
-        this.#initialized = true;
     }
     registerEnum(type, values) {
         const [domain, name] = splitQualifiedName(type);
@@ -75,17 +66,14 @@ export class InspectorBackend {
         // @ts-expect-error globalThis global namespace pollution
         globalThis.Protocol[domain][name] = values;
         this.enumMap.set(type, values);
-        this.#initialized = true;
     }
     registerType(method, parameters) {
         this.typeMap.set(method, parameters);
-        this.#initialized = true;
     }
     registerEvent(eventName, params) {
         const domain = eventName.split('.')[0];
         const eventParameterNames = this.getOrCreateEventParameterNamesForDomain(domain);
         eventParameterNames.set(eventName, params);
-        this.#initialized = true;
     }
 }
 export const test = {
@@ -125,6 +113,8 @@ export class SessionRouter {
     #pendingLongPollingMessageIds = new Set();
     #sessions = new Map();
     #pendingScripts = [];
+    #callbacks = new Map();
+    #observers = new Set();
     constructor(connection) {
         this.#connection = connection;
         test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
@@ -135,45 +125,43 @@ export class SessionRouter {
             if (session) {
                 session.target.dispose(reason);
             }
+            this.#observers.forEach(observer => observer.onDisconnect(reason));
         });
     }
-    registerSession(target, sessionId, proxyConnection) {
-        // Only the Audits panel uses proxy connections. If it is ever possible to have multiple active at the
-        // same time, it should be tested thoroughly.
-        if (proxyConnection) {
-            for (const session of this.#sessions.values()) {
-                if (session.proxyConnection) {
-                    console.error('Multiple simultaneous proxy connections are currently unsupported');
-                    break;
-                }
-            }
-        }
-        this.#sessions.set(sessionId, { target, callbacks: new Map(), proxyConnection });
+    observe(observer) {
+        this.#observers.add(observer);
+    }
+    unobserve(observer) {
+        this.#observers.delete(observer);
+    }
+    registerSession(target, sessionId) {
+        this.#sessions.set(sessionId, { target });
     }
     unregisterSession(sessionId) {
         const session = this.#sessions.get(sessionId);
         if (!session) {
             return;
         }
-        for (const callback of session.callbacks.values()) {
-            SessionRouter.dispatchUnregisterSessionError(callback);
+        for (const { resolve, method, sessionId: callbackSessionId } of this.#callbacks.values()) {
+            if (sessionId !== callbackSessionId) {
+                continue;
+            }
+            resolve({
+                error: {
+                    message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
+                    code: CDPErrorStatus.SESSION_NOT_FOUND,
+                }
+            });
         }
         this.#sessions.delete(sessionId);
     }
-    getTargetBySessionId(sessionId) {
-        const session = this.#sessions.get(sessionId ? sessionId : '');
-        if (!session) {
-            return null;
-        }
-        return session.target;
-    }
     nextMessageId() {
         return this.#lastMessageId++;
     }
     connection() {
         return this.#connection;
     }
-    sendMessage(sessionId, domain, method, params, callback) {
+    send(method, params, sessionId) {
         const messageId = this.nextMessageId();
         const messageObject = {
             id: messageId,
@@ -189,23 +177,28 @@ export class SessionRouter {
             test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
         }
         if (test.onMessageSent) {
+            const domain = method.split('.')[0];
             const paramsObject = JSON.parse(JSON.stringify(params || {}));
-            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId }, this.getTargetBySessionId(sessionId));
+            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId });
         }
         ++this.#pendingResponsesCount;
         if (LongPollingMethods.has(method)) {
             this.#pendingLongPollingMessageIds.add(messageId);
         }
-        const session = this.#sessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        session.callbacks.set(messageId, { callback, method });
-        this.#connection.sendRawMessage(JSON.stringify(messageObject));
+        return new Promise(resolve => {
+            this.#callbacks.set(messageId, { resolve, method, sessionId });
+            this.#connection.sendRawMessage(JSON.stringify(messageObject));
+        });
     }
     sendRawMessageForTesting(method, params, callback, sessionId = '') {
-        const domain = method.split('.')[0];
-        this.sendMessage(sessionId, domain, method, params, callback || (() => { }));
+        void this.send(method, params, sessionId).then(response => {
+            if ('error' in response && response.error) {
+                callback?.(response.error, null);
+            }
+            else if ('result' in response) {
+                callback?.(null, response.result);
+            }
+        });
     }
     onMessage(message) {
         if (test.dumpProtocol) {
@@ -213,64 +206,35 @@ export class SessionRouter {
         }
         if (test.onMessageReceived) {
             const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
-            test.onMessageReceived(messageObjectCopy, this.getTargetBySessionId(messageObjectCopy.sessionId));
+            test.onMessageReceived(messageObjectCopy);
         }
         const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message);
-        // Send all messages to proxy connections.
-        let suppressUnknownMessageErrors = false;
-        for (const session of this.#sessions.values()) {
-            if (!session.proxyConnection) {
-                continue;
-            }
-            if (!session.proxyConnection.onMessage) {
-                InspectorBackend.reportProtocolError('Protocol Error: the session has a proxyConnection with no _onMessage', messageObject);
-                continue;
-            }
-            session.proxyConnection.onMessage(messageObject);
-            suppressUnknownMessageErrors = true;
-        }
         const sessionId = messageObject.sessionId || '';
         const session = this.#sessions.get(sessionId);
-        if (!session) {
-            // In the DevTools MCP case, we may share the transport with puppeteer so we silently
-            // ignore unknown sessions.
-            return;
-        }
-        // If this message is directly for the target controlled by the proxy connection, don't handle it.
-        if (session.proxyConnection) {
-            return;
-        }
-        if (session.target.getNeedsNodeJSPatching()) {
+        if (session?.target.getNeedsNodeJSPatching()) {
             NodeURL.patch(messageObject);
         }
-        if (messageObject.id !== undefined) { // just a response for some request
-            const callback = session.callbacks.get(messageObject.id);
-            session.callbacks.delete(messageObject.id);
+        if ('id' in messageObject && messageObject.id !== undefined) { // just a response for some request
+            const callback = this.#callbacks.get(messageObject.id);
+            this.#callbacks.delete(messageObject.id);
             if (!callback) {
-                if (messageObject.error?.code === ConnectionClosedErrorCode) {
-                    // Ignore the errors that are sent as responses after the session closes.
-                    return;
-                }
-                if (!suppressUnknownMessageErrors) {
-                    InspectorBackend.reportProtocolError('Protocol Error: the message with wrong id', messageObject);
-                }
+                // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
                 return;
             }
-            callback.callback(messageObject.error || null, messageObject.result || null);
+            callback.resolve(messageObject);
             --this.#pendingResponsesCount;
             this.#pendingLongPollingMessageIds.delete(messageObject.id);
             if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
                 this.deprecatedRunAfterPendingDispatches();
             }
         }
-        else {
-            if (messageObject.method === undefined) {
-                InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
-                return;
-            }
+        else if ('method' in messageObject) {
             // This cast is justified as we just checked for the presence of messageObject.method.
-            const eventMessage = messageObject;
-            session.target.dispatch(eventMessage);
+            session?.target.dispatch(messageObject);
+            this.#observers.forEach(observer => observer.onEvent(messageObject));
+        }
+        else {
+            InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
         }
     }
     hasOutstandingNonLongPollingRequests() {
@@ -299,22 +263,6 @@ export class SessionRouter {
             }
         }
     }
-    static dispatchConnectionError(callback, method) {
-        const error = {
-            message: `Connection is closed, can\'t dispatch pending call to ${method}`,
-            code: ConnectionClosedErrorCode,
-            data: null,
-        };
-        window.setTimeout(() => callback(error, null), 0);
-    }
-    static dispatchUnregisterSessionError({ callback, method }) {
-        const error = {
-            message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
-            code: ConnectionClosedErrorCode,
-            data: null,
-        };
-        window.setTimeout(() => callback(error, null), 0);
-    }
 }
 export class TargetBase {
     needsNodeJSPatching;
@@ -626,6 +574,12 @@ export class TargetBase {
         return this.needsNodeJSPatching;
     }
 }
+/** These are not logged as console.error */
+const IGNORED_ERRORS = new Set([
+    CDPErrorStatus.DEVTOOLS_STUB_ERROR,
+    CDPErrorStatus.SERVER_ERROR,
+    CDPErrorStatus.SESSION_NOT_FOUND,
+]);
 /**
  * This is a class that serves as the prototype for a domains #agents (every target
  * has it's own set of #agents). The InspectorBackend keeps an instance of this class
@@ -636,113 +590,39 @@ export class TargetBase {
  * of the invoke_enable, etc. methods that the front-end uses.
  */
 class AgentPrototype {
-    replyArgs;
     description = '';
     metadata;
     domain;
     target;
     constructor(domain) {
-        this.replyArgs = {};
         this.domain = domain;
         this.metadata = {};
     }
     registerCommand(methodName, parameters, replyArgs, description) {
         const domainAndMethod = qualifyName(this.domain, methodName);
-        function sendMessagePromise(...args) {
-            return AgentPrototype.prototype.sendMessageToBackendPromise.call(this, domainAndMethod, parameters, args);
-        }
-        // @ts-expect-error Method code generation
-        this[methodName] = sendMessagePromise;
         this.metadata[domainAndMethod] = { parameters, description, replyArgs };
         function invoke(request = {}) {
             return this.invoke(domainAndMethod, request);
         }
         // @ts-expect-error Method code generation
         this['invoke_' + methodName] = invoke;
-        this.replyArgs[domainAndMethod] = replyArgs;
-    }
-    prepareParameters(method, parameters, args, errorCallback) {
-        const params = {};
-        let hasParams = false;
-        for (const param of parameters) {
-            const paramName = param.name;
-            const typeName = param.type;
-            const optionalFlag = param.optional;
-            if (!args.length && !optionalFlag) {
-                errorCallback(`Protocol Error: Invalid number of arguments for method '${method}' call. ` +
-                    `It must have the following arguments ${JSON.stringify(parameters)}'.`);
-                return null;
-            }
-            const value = args.shift();
-            if (optionalFlag && typeof value === 'undefined') {
-                continue;
-            }
-            const expectedJSType = typeName === 'array' ? 'object' : typeName;
-            if (typeof value !== expectedJSType) {
-                errorCallback(`Protocol Error: Invalid type of argument '${paramName}' for method '${method}' call. ` +
-                    `It must be '${typeName}' but it is '${typeof value}'.`);
-                return null;
-            }
-            params[paramName] = value;
-            hasParams = true;
-        }
-        if (args.length) {
-            errorCallback(`Protocol Error: Extra ${args.length} arguments in a call to method '${method}'.`);
-            return null;
-        }
-        return hasParams ? params : null;
-    }
-    sendMessageToBackendPromise(method, parameters, args) {
-        let errorMessage;
-        function onError(message) {
-            console.error(message);
-            errorMessage = message;
-        }
-        const params = this.prepareParameters(method, parameters, args, onError);
-        if (errorMessage) {
-            return Promise.resolve(null);
-        }
-        return new Promise(resolve => {
-            // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const callback = (error, result) => {
-                if (error) {
-                    if (!test.suppressRequestErrors && error.code !== DevToolsStubErrorCode && error.code !== GenericErrorCode &&
-                        error.code !== ConnectionClosedErrorCode) {
-                        console.error('Request ' + method + ' failed. ' + JSON.stringify(error));
-                    }
-                    resolve(null);
-                    return;
-                }
-                const args = this.replyArgs[method];
-                resolve(result && args.length ? result[args[0]] : undefined);
-            };
-            const router = this.target.router();
-            if (!router) {
-                SessionRouter.dispatchConnectionError(callback, method);
-            }
-            else {
-                router.sendMessage(this.target.sessionId, this.domain, method, params, callback);
-            }
-        });
     }
     invoke(method, request) {
-        return new Promise(fulfill => {
-            const callback = (error, result) => {
-                if (error && !test.suppressRequestErrors && error.code !== DevToolsStubErrorCode &&
-                    error.code !== GenericErrorCode && error.code !== ConnectionClosedErrorCode) {
-                    console.error('Request ' + method + ' failed. ' + JSON.stringify(error));
+        const router = this.target.router();
+        if (!router) {
+            return Promise.resolve({ result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}` });
+        }
+        return router.send(method, request, this.target.sessionId).then(response => {
+            if ('error' in response && response.error) {
+                if (!test.suppressRequestErrors && !IGNORED_ERRORS.has(response.error.code)) {
+                    console.error('Request ' + method + ' failed. ' + JSON.stringify(response.error));
                 }
-                const errorMessage = error?.message;
-                fulfill({ ...result, getError: () => errorMessage });
-            };
-            const router = this.target.router();
-            if (!router) {
-                SessionRouter.dispatchConnectionError(callback, method);
+                return { getError: () => response.error.message };
             }
-            else {
-                router.sendMessage(this.target.sessionId, this.domain, method, request, callback);
+            if ('result' in response) {
+                return { ...response.result, getError: () => undefined };
             }
+            return { getError: () => undefined };
         });
     }
 }

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

@@ -1,7 +1,8 @@
 // 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 CDPConnection from './CDPConnection.js';
 import * as ConnectionTransport from './ConnectionTransport.js';
 import * as InspectorBackend from './InspectorBackend.js';
 import * as NodeURL from './NodeURL.js';
-export { ConnectionTransport, InspectorBackend, NodeURL, };
+export { CDPConnection, ConnectionTransport, InspectorBackend, NodeURL, };

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

@@ -678,12 +678,11 @@ export class AnimationGroup {
     #id;
     #scrollNode;
     #animations;
-    #paused;
+    #paused = false;
     constructor(animationModel, id, animations) {
         this.#animationModel = animationModel;
         this.#id = id;
         this.#animations = animations;
-        this.#paused = false;
     }
     isScrollDriven() {
         return Boolean(this.#animations[0]?.viewOrScrollTimeline());

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

@@ -5,7 +5,7 @@ import * as Platform from '../platform/platform.js';
 import { CSSMetadata, cssMetadata } from './CSSMetadata.js';
 import { CSSProperty } from './CSSProperty.js';
 import * as PropertyParser from './CSSPropertyParser.js';
-import { AnchorFunctionMatcher, AngleMatcher, AttributeMatcher, AutoBaseMatcher, BaseVariableMatcher, BezierMatcher, BinOpMatcher, ColorMatcher, ColorMixMatcher, CustomFunctionMatcher, defaultValueForCSSType, EnvFunctionMatcher, FlexGridMatcher, GridTemplateMatcher, LengthMatcher, LightDarkColorMatcher, LinearGradientMatcher, LinkableNameMatcher, localEvalCSS, MathFunctionMatcher, PositionAnchorMatcher, PositionTryMatcher, RelativeColorChannelMatcher, ShadowMatcher, StringMatcher, URLMatcher, VariableMatcher } from './CSSPropertyParserMatchers.js';
+import { AnchorFunctionMatcher, AngleMatcher, AttributeMatcher, AutoBaseMatcher, BaseVariableMatcher, BezierMatcher, BinOpMatcher, ColorMatcher, ColorMixMatcher, CustomFunctionMatcher, defaultValueForCSSType, EnvFunctionMatcher, FlexGridMasonryMatcher, GridTemplateMatcher, LengthMatcher, LightDarkColorMatcher, LinearGradientMatcher, LinkableNameMatcher, localEvalCSS, MathFunctionMatcher, PositionAnchorMatcher, PositionTryMatcher, RelativeColorChannelMatcher, ShadowMatcher, StringMatcher, URLMatcher, VariableMatcher } from './CSSPropertyParserMatchers.js';
 import { CSSFontPaletteValuesRule, CSSFunctionRule, CSSKeyframeRule, CSSKeyframesRule, CSSPositionTryRule, CSSPropertyRule, CSSStyleRule, } from './CSSRule.js';
 import { CSSStyleDeclaration, Type } from './CSSStyleDeclaration.js';
 function containsStyle(styles, query) {
@@ -242,7 +242,7 @@ export class CSSMatchedStyles {
         for (const inheritedResult of inheritedPayload) {
             inheritedResult.matchedCSSRules = cleanUserAgentPayload(inheritedResult.matchedCSSRules);
         }
-        this.#environmentVariables = await this.cssModel().getEnvironmentVariales();
+        this.#environmentVariables = await this.cssModel().getEnvironmentVariables();
         this.#mainDOMCascade = await this.buildMainCascade(inlinePayload, attributesPayload, matchedPayload, inheritedPayload, animationStylesPayload, transitionsStylePayload, inheritedAnimatedPayload);
         [this.#pseudoDOMCascades, this.#customHighlightPseudoDOMCascades] =
             this.buildPseudoCascades(pseudoPayload, inheritedPseudoPayload);
@@ -714,7 +714,7 @@ export class CSSMatchedStyles {
             new LinearGradientMatcher(),
             new AnchorFunctionMatcher(),
             new PositionAnchorMatcher(),
-            new FlexGridMatcher(),
+            new FlexGridMasonryMatcher(),
             new PositionTryMatcher(),
             new LengthMatcher(),
             new MathFunctionMatcher(),

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

@@ -321,7 +321,7 @@ export class CSSModel extends SDKModel {
             hasScroll,
         };
     }
-    async getEnvironmentVariales() {
+    async getEnvironmentVariables() {
         const response = await this.agent.invoke_getEnvironmentVariables();
         if (response.getError()) {
             return {};

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

@@ -20,9 +20,9 @@ export class CSSProperty extends Common.ObjectWrapper.ObjectWrapper {
     implicit;
     text;
     range;
-    #active;
-    #nameRange;
-    #valueRange;
+    #active = true;
+    #nameRange = null;
+    #valueRange = null;
     #invalidString;
     #longhandProperties = [];
     constructor(ownerStyle, index, name, value, important, disabled, parsedOk, implicit, text, range, longhandProperties) {
@@ -37,9 +37,6 @@ export class CSSProperty extends Common.ObjectWrapper.ObjectWrapper {
         this.implicit = implicit; // A longhand, implicitly set by missing values of shorthand.
         this.text = text;
         this.range = range ? TextUtils.TextRange.TextRange.fromObject(range) : null;
-        this.#active = true;
-        this.#nameRange = null;
-        this.#valueRange = null;
         if (longhandProperties && longhandProperties.length > 0) {
             for (const property of longhandProperties) {
                 this.#longhandProperties.push(new CSSProperty(ownerStyle, ++index, property.name, property.value, important, disabled, parsedOk, true));

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

@@ -1,7 +1,7 @@
 // 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.
-/* eslint-disable rulesdir/no-imperative-dom-api */
+/* eslint-disable @devtools/no-imperative-dom-api */
 import * as Common from '../../core/common/common.js';
 import { CSSMetadata, cssMetadata, CubicBezierKeywordValues, } from './CSSMetadata.js';
 import { ASTUtils, matchDeclaration, matcherBase, tokenizeDeclaration } from './CSSPropertyParser.js';
@@ -993,21 +993,22 @@ export class CustomFunctionMatcher extends matcherBase(CustomFunctionMatch) {
         return new CustomFunctionMatch(text, node, callee, args);
     }
 }
-export class FlexGridMatch {
+export class FlexGridMasonryMatch {
     text;
     node;
-    isFlex;
-    constructor(text, node, isFlex) {
+    layoutType;
+    constructor(text, node, layoutType) {
         this.text = text;
         this.node = node;
-        this.isFlex = isFlex;
+        this.layoutType = layoutType;
     }
 }
 // clang-format off
-export class FlexGridMatcher extends matcherBase(FlexGridMatch) {
+export class FlexGridMasonryMatcher extends matcherBase(FlexGridMasonryMatch) {
     // clang-format on
     static FLEX = ['flex', 'inline-flex', 'block flex', 'inline flex'];
     static GRID = ['grid', 'inline-grid', 'block grid', 'inline grid'];
+    static MASONRY = ['masonry', 'inline-masonry', 'block masonry', 'inline masonry'];
     accepts(propertyName) {
         return propertyName === 'display';
     }
@@ -1023,11 +1024,14 @@ export class FlexGridMatcher extends matcherBase(FlexGridMatch) {
             .map(node => matching.getComputedText(node).trim())
             .filter(value => value);
         const text = values.join(' ');
-        if (FlexGridMatcher.FLEX.includes(text)) {
-            return new FlexGridMatch(matching.ast.text(node), node, true);
+        if (FlexGridMasonryMatcher.FLEX.includes(text)) {
+            return new FlexGridMasonryMatch(matching.ast.text(node), node, "flex" /* LayoutType.FLEX */);
         }
-        if (FlexGridMatcher.GRID.includes(text)) {
-            return new FlexGridMatch(matching.ast.text(node), node, false);
+        if (FlexGridMasonryMatcher.GRID.includes(text)) {
+            return new FlexGridMasonryMatch(matching.ast.text(node), node, "grid" /* LayoutType.GRID */);
+        }
+        if (FlexGridMasonryMatcher.MASONRY.includes(text)) {
+            return new FlexGridMasonryMatch(matching.ast.text(node), node, "masonry" /* LayoutType.MASONRY */);
         }
         return null;
     }

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

@@ -7,14 +7,14 @@ import { CSSProperty } from './CSSProperty.js';
 export class CSSStyleDeclaration {
     #cssModel;
     parentRule;
-    #allProperties;
+    #allProperties = [];
     styleSheetId;
-    range;
+    range = null;
     cssText;
     #shorthandValues = new Map();
     #shorthandIsImportant = new Set();
     #activePropertyMap = new Map();
-    #leadingProperties;
+    #leadingProperties = null;
     type;
     // For CSSStyles coming from animations,
     // This holds the name of the animation.
@@ -82,7 +82,7 @@ export class CSSStyleDeclaration {
         this.#generateSyntheticPropertiesIfNeeded();
         this.#computeInactiveProperties();
         // TODO(changhaohan): verify if this #activePropertyMap is still necessary, or if it is
-        // providing different information against the activeness in allPropertiesInternal.
+        // providing different information against the activeness in #allProperties.
         this.#activePropertyMap = new Map();
         for (const property of this.#allProperties) {
             if (!property.activeInStyle()) {

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

@@ -4,7 +4,6 @@
 import * as i18n from '../../core/i18n/i18n.js';
 import * as Common from '../common/common.js';
 import * as Host from '../host/host.js';
-import { ParallelConnection } from './Connections.js';
 import { ResourceTreeModel } from './ResourceTreeModel.js';
 import { SDKModel } from './SDKModel.js';
 import { SecurityOriginManager } from './SecurityOriginManager.js';
@@ -29,7 +28,6 @@ export class ChildTargetManager extends SDKModel {
     #targetInfos = new Map();
     #childTargetsBySessionId = new Map();
     #childTargetsById = new Map();
-    #parallelConnections = new Map();
     #parentTargetId = null;
     constructor(parentTarget) {
         super(parentTarget);
@@ -221,42 +219,16 @@ export class ChildTargetManager extends SDKModel {
         }
     }
     detachedFromTarget({ sessionId }) {
-        if (this.#parallelConnections.has(sessionId)) {
-            this.#parallelConnections.delete(sessionId);
-        }
-        else {
-            const target = this.#childTargetsBySessionId.get(sessionId);
-            if (target) {
-                target.dispose('target terminated');
-                this.#childTargetsBySessionId.delete(sessionId);
-                this.#childTargetsById.delete(target.id());
-            }
+        const target = this.#childTargetsBySessionId.get(sessionId);
+        if (target) {
+            target.dispose('target terminated');
+            this.#childTargetsBySessionId.delete(sessionId);
+            this.#childTargetsById.delete(target.id());
         }
     }
     receivedMessageFromTarget({}) {
         // We use flatten protocol.
     }
-    async createParallelConnection(onMessage) {
-        // The main Target id is actually just `main`, instead of the real targetId.
-        // Get the real id (requires an async operation) so that it can be used synchronously later.
-        const targetId = await this.getParentTargetId();
-        const { connection, sessionId } = await this.createParallelConnectionAndSessionForTarget(this.#parentTarget, targetId);
-        connection.setOnMessage(onMessage);
-        this.#parallelConnections.set(sessionId, connection);
-        return { connection, sessionId };
-    }
-    async createParallelConnectionAndSessionForTarget(target, targetId) {
-        const targetAgent = target.targetAgent();
-        const targetRouter = target.router();
-        const sessionId = (await targetAgent.invoke_attachToTarget({ targetId, flatten: true })).sessionId;
-        const connection = new ParallelConnection(targetRouter.connection(), sessionId);
-        targetRouter.registerSession(target, sessionId, connection);
-        connection.setOnDisconnect(() => {
-            targetRouter.unregisterSession(sessionId);
-            void targetAgent.invoke_detachFromTarget({ sessionId });
-        });
-        return { connection, sessionId };
-    }
     targetInfos() {
         return Array.from(this.#targetInfos.values());
     }