chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/CSSProperty.ts

@@ -24,11 +24,11 @@ export class CSSProperty {
   implicit: boolean;
   text: string|null|undefined;
   range: TextUtils.TextRange.TextRange|null;
-  private active: boolean;
-  private nameRangeInternal: TextUtils.TextRange.TextRange|null;
-  private valueRangeInternal: TextUtils.TextRange.TextRange|null;
-  private readonly invalidProperty: string|null;
-  private invalidString?: Common.UIString.LocalizedString;
+  #active: boolean;
+  #nameRangeInternal: TextUtils.TextRange.TextRange|null;
+  #valueRangeInternal: TextUtils.TextRange.TextRange|null;
+  readonly #invalidProperty: string|null;
+  #invalidString?: Common.UIString.LocalizedString;
 
   constructor(
       ownerStyle: CSSStyleDeclaration, index: number, name: string, value: string, important: boolean,
@@ -43,10 +43,10 @@ export class CSSProperty {
     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.nameRangeInternal = null;
-    this.valueRangeInternal = null;
-    this.invalidProperty = null;
+    this.#active = true;
+    this.#nameRangeInternal = null;
+    this.#valueRangeInternal = null;
+    this.#invalidProperty = null;
   }
 
   static parsePayload(ownerStyle: CSSStyleDeclaration, index: number, payload: Protocol.CSS.CSSProperty): CSSProperty {
@@ -63,7 +63,7 @@ export class CSSProperty {
   }
 
   private ensureRanges(): void {
-    if (this.nameRangeInternal && this.valueRangeInternal) {
+    if (this.#nameRangeInternal && this.#valueRangeInternal) {
       return;
     }
     const range = this.range;
@@ -81,8 +81,8 @@ export class CSSProperty {
     const nameSourceRange = new TextUtils.TextRange.SourceRange(nameIndex, this.name.length);
     const valueSourceRange = new TextUtils.TextRange.SourceRange(valueIndex, this.value.length);
 
-    this.nameRangeInternal = rebase(text.toTextRange(nameSourceRange), range.startLine, range.startColumn);
-    this.valueRangeInternal = rebase(text.toTextRange(valueSourceRange), range.startLine, range.startColumn);
+    this.#nameRangeInternal = rebase(text.toTextRange(nameSourceRange), range.startLine, range.startColumn);
+    this.#valueRangeInternal = rebase(text.toTextRange(valueSourceRange), range.startLine, range.startColumn);
 
     function rebase(oneLineRange: TextUtils.TextRange.TextRange, lineOffset: number, columnOffset: number):
         TextUtils.TextRange.TextRange {
@@ -98,12 +98,12 @@ export class CSSProperty {
 
   nameRange(): TextUtils.TextRange.TextRange|null {
     this.ensureRanges();
-    return this.nameRangeInternal;
+    return this.#nameRangeInternal;
   }
 
   valueRange(): TextUtils.TextRange.TextRange|null {
     this.ensureRanges();
-    return this.valueRangeInternal;
+    return this.#valueRangeInternal;
   }
 
   rebase(edit: Edit): void {
@@ -116,7 +116,7 @@ export class CSSProperty {
   }
 
   setActive(active: boolean): void {
-    this.active = active;
+    this.#active = active;
   }
 
   get propertyText(): string|null {
@@ -131,7 +131,7 @@ export class CSSProperty {
   }
 
   activeInStyle(): boolean {
-    return this.active;
+    return this.#active;
   }
 
   trimmedValueWithoutImportant(): string {
@@ -291,13 +291,13 @@ export class CSSProperty {
    * This stores the warning string when a CSS Property is improperly parsed.
    */
   setDisplayedStringForInvalidProperty(invalidString: Common.UIString.LocalizedString): void {
-    this.invalidString = invalidString;
+    this.#invalidString = invalidString;
   }
 
   /**
    * Retrieve the warning string for a screen reader to announce when editing the property.
    */
   getInvalidStringForInvalidProperty(): Common.UIString.LocalizedString|undefined {
-    return this.invalidString;
+    return this.#invalidString;
   }
 }

package/front_end/core/sdk/CSSRule.ts

@@ -203,26 +203,26 @@ export class CSSStyleRule extends CSSRule {
 }
 
 export class CSSKeyframesRule {
-  private readonly cssModel: CSSModel;
-  private readonly animationName: CSSValue;
-  private readonly keyframesInternal: CSSKeyframeRule[];
+  readonly #cssModel: CSSModel;
+  readonly #animationName: CSSValue;
+  readonly #keyframesInternal: CSSKeyframeRule[];
   constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSKeyframesRule) {
-    this.cssModel = cssModel;
-    this.animationName = new CSSValue(payload.animationName);
-    this.keyframesInternal = payload.keyframes.map(keyframeRule => new CSSKeyframeRule(cssModel, keyframeRule));
+    this.#cssModel = cssModel;
+    this.#animationName = new CSSValue(payload.animationName);
+    this.#keyframesInternal = payload.keyframes.map(keyframeRule => new CSSKeyframeRule(cssModel, keyframeRule));
   }
 
   name(): CSSValue {
-    return this.animationName;
+    return this.#animationName;
   }
 
   keyframes(): CSSKeyframeRule[] {
-    return this.keyframesInternal;
+    return this.#keyframesInternal;
   }
 }
 
 export class CSSKeyframeRule extends CSSRule {
-  private keyText!: CSSValue;
+  #keyText!: CSSValue;
   constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSKeyframeRule) {
     // TODO(crbug.com/1011811): Replace with spread operator or better types once Closure is gone.
     super(cssModel, {origin: payload.origin, style: payload.style, styleSheetId: payload.styleSheetId});
@@ -230,21 +230,21 @@ export class CSSKeyframeRule extends CSSRule {
   }
 
   key(): CSSValue {
-    return this.keyText;
+    return this.#keyText;
   }
 
   private reinitializeKey(payload: Protocol.CSS.Value): void {
-    this.keyText = new CSSValue(payload);
+    this.#keyText = new CSSValue(payload);
   }
 
   rebase(edit: Edit): void {
-    if (this.styleSheetId !== edit.styleSheetId || !this.keyText.range) {
+    if (this.styleSheetId !== edit.styleSheetId || !this.#keyText.range) {
       return;
     }
-    if (edit.oldRange.equal(this.keyText.range)) {
+    if (edit.oldRange.equal(this.#keyText.range)) {
       this.reinitializeKey((edit.payload as Protocol.CSS.Value));
     } else {
-      this.keyText.rebase(edit);
+      this.#keyText.rebase(edit);
     }
 
     super.rebase(edit);
@@ -255,7 +255,7 @@ export class CSSKeyframeRule extends CSSRule {
     if (!styleSheetId) {
       throw 'No rule stylesheet id';
     }
-    const range = this.keyText.range;
+    const range = this.#keyText.range;
     if (!range) {
       throw 'Keyframe key is not editable';
     }

package/front_end/core/sdk/CSSStyleDeclaration.ts

@@ -12,19 +12,19 @@ import type {CSSRule} from './CSSRule.js';
 import type {Target} from './Target.js';
 
 export class CSSStyleDeclaration {
-  private readonly cssModelInternal: CSSModel;
+  readonly #cssModelInternal: CSSModel;
   parentRule: CSSRule|null;
-  private allPropertiesInternal!: CSSProperty[];
+  #allPropertiesInternal!: CSSProperty[];
   styleSheetId!: Protocol.CSS.StyleSheetId|undefined;
   range!: TextUtils.TextRange.TextRange|null;
   cssText!: string|undefined;
-  private shorthandValues!: Map<string, string>;
-  private shorthandIsImportant!: Set<string>;
-  private activePropertyMap!: Map<string, CSSProperty>;
-  private leadingPropertiesInternal!: CSSProperty[]|null;
+  #shorthandValues!: Map<string, string>;
+  #shorthandIsImportant!: Set<string>;
+  #activePropertyMap!: Map<string, CSSProperty>;
+  #leadingPropertiesInternal!: CSSProperty[]|null;
   type: Type;
   constructor(cssModel: CSSModel, parentRule: CSSRule|null, payload: Protocol.CSS.CSSStyle, type: Type) {
-    this.cssModelInternal = cssModel;
+    this.#cssModelInternal = cssModel;
     this.parentRule = parentRule;
     this.reinitialize(payload);
     this.type = type;
@@ -38,8 +38,8 @@ export class CSSStyleDeclaration {
       this.reinitialize((edit.payload as Protocol.CSS.CSSStyle));
     } else {
       this.range = this.range.rebaseAfterTextEdit(edit.oldRange, edit.newRange);
-      for (let i = 0; i < this.allPropertiesInternal.length; ++i) {
-        this.allPropertiesInternal[i].rebase(edit);
+      for (let i = 0; i < this.#allPropertiesInternal.length; ++i) {
+        this.#allPropertiesInternal[i].rebase(edit);
       }
     }
   }
@@ -49,16 +49,16 @@ export class CSSStyleDeclaration {
     this.range = payload.range ? TextUtils.TextRange.TextRange.fromObject(payload.range) : null;
 
     const shorthandEntries = payload.shorthandEntries;
-    this.shorthandValues = new Map();
-    this.shorthandIsImportant = new Set();
+    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);
+      this.#shorthandValues.set(shorthandEntries[i].name, shorthandEntries[i].value);
       if (shorthandEntries[i].important) {
-        this.shorthandIsImportant.add(shorthandEntries[i].name);
+        this.#shorthandIsImportant.add(shorthandEntries[i].name);
       }
     }
 
-    this.allPropertiesInternal = [];
+    this.#allPropertiesInternal = [];
 
     if (payload.cssText && this.range) {
       const cssText = new TextUtils.Text.Text(payload.cssText);
@@ -75,28 +75,30 @@ export class CSSStyleDeclaration {
           parseUnusedText.call(this, cssText, start.line, start.column, range.startLine, range.startColumn);
           start = {line: range.endLine, column: range.endColumn};
         }
-        this.allPropertiesInternal.push(CSSProperty.parsePayload(this, this.allPropertiesInternal.length, cssProperty));
+        this.#allPropertiesInternal.push(
+            CSSProperty.parsePayload(this, this.#allPropertiesInternal.length, cssProperty));
       }
       parseUnusedText.call(this, cssText, start.line, start.column, this.range.endLine, this.range.endColumn);
     } else {
       for (const cssProperty of payload.cssProperties) {
-        this.allPropertiesInternal.push(CSSProperty.parsePayload(this, this.allPropertiesInternal.length, cssProperty));
+        this.#allPropertiesInternal.push(
+            CSSProperty.parsePayload(this, this.#allPropertiesInternal.length, cssProperty));
       }
     }
 
     this.generateSyntheticPropertiesIfNeeded();
     this.computeInactiveProperties();
 
-    this.activePropertyMap = new Map();
-    for (const property of this.allPropertiesInternal) {
+    this.#activePropertyMap = new Map();
+    for (const property of this.#allPropertiesInternal) {
       if (!property.activeInStyle()) {
         continue;
       }
-      this.activePropertyMap.set(property.name, property);
+      this.#activePropertyMap.set(property.name, property);
     }
 
     this.cssText = payload.cssText;
-    this.leadingPropertiesInternal = null;
+    this.#leadingPropertiesInternal = null;
 
     function parseUnusedText(
         this: CSSStyleDeclaration, cssText: TextUtils.Text.Text, startLine: number, startColumn: number,
@@ -130,8 +132,8 @@ export class CSSStyleDeclaration {
               value = trimmedProperty.substring(colonIndex + 1).trim();
             }
             const range = new TextUtils.TextRange.TextRange(lineNumber, column, lineNumber, column + property.length);
-            this.allPropertiesInternal.push(new CSSProperty(
-                this, this.allPropertiesInternal.length, name, value, false, false, false, false, property,
+            this.#allPropertiesInternal.push(new CSSProperty(
+                this, this.#allPropertiesInternal.length, name, value, false, false, false, false, property,
                 range.relativeFrom(startLine, startColumn)));
           }
           column += property.length + 1;
@@ -165,38 +167,38 @@ export class CSSStyleDeclaration {
       return;
     }
 
-    if (!this.shorthandValues.size) {
+    if (!this.#shorthandValues.size) {
       return;
     }
 
     const propertiesSet = new Set<string>();
-    for (const property of this.allPropertiesInternal) {
+    for (const property of this.#allPropertiesInternal) {
       propertiesSet.add(property.name);
     }
 
     const generatedProperties = [];
-    // For style-based properties, generate shorthands with values when possible.
-    for (const property of this.allPropertiesInternal) {
-      // For style-based properties, try generating shorthands.
+    // For style-based properties, generate #shorthands with values when possible.
+    for (const property of this.#allPropertiesInternal) {
+      // 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 longhands falls under.
-        const shorthandValue = this.shorthandValues.get(shorthand);
+        }  // There already is a shorthand this #longhands falls under.
+        const shorthandValue = this.#shorthandValues.get(shorthand);
         if (!shorthandValue) {
           continue;
-        }  // Never generate synthetic shorthands when no value is available.
+        }  // 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 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.allPropertiesInternal = this.allPropertiesInternal.concat(generatedProperties);
+    this.#allPropertiesInternal = this.#allPropertiesInternal.concat(generatedProperties);
   }
 
   private computeLeadingProperties(): CSSProperty[] {
@@ -205,15 +207,15 @@ export class CSSStyleDeclaration {
     }
 
     if (this.range) {
-      return this.allPropertiesInternal.filter(propertyHasRange);
+      return this.#allPropertiesInternal.filter(propertyHasRange);
     }
 
     const leadingProperties = [];
-    for (const property of this.allPropertiesInternal) {
+    for (const property of this.#allPropertiesInternal) {
       const shorthands = cssMetadata().getShorthands(property.name) || [];
       let belongToAnyShorthand = false;
       for (const shorthand of shorthands) {
-        if (this.shorthandValues.get(shorthand)) {
+        if (this.#shorthandValues.get(shorthand)) {
           belongToAnyShorthand = true;
           break;
         }
@@ -227,24 +229,24 @@ export class CSSStyleDeclaration {
   }
 
   leadingProperties(): CSSProperty[] {
-    if (!this.leadingPropertiesInternal) {
-      this.leadingPropertiesInternal = this.computeLeadingProperties();
+    if (!this.#leadingPropertiesInternal) {
+      this.#leadingPropertiesInternal = this.computeLeadingProperties();
     }
-    return this.leadingPropertiesInternal;
+    return this.#leadingPropertiesInternal;
   }
 
   target(): Target {
-    return this.cssModelInternal.target();
+    return this.#cssModelInternal.target();
   }
 
   cssModel(): CSSModel {
-    return this.cssModelInternal;
+    return this.#cssModelInternal;
   }
 
   private computeInactiveProperties(): void {
     const activeProperties = new Map<string, CSSProperty>();
-    for (let i = 0; i < this.allPropertiesInternal.length; ++i) {
-      const property = this.allPropertiesInternal[i];
+    for (let i = 0; i < this.#allPropertiesInternal.length; ++i) {
+      const property = this.#allPropertiesInternal[i];
       if (property.disabled || !property.parsedOk) {
         property.setActive(false);
         continue;
@@ -284,16 +286,16 @@ export class CSSStyleDeclaration {
   }
 
   allProperties(): CSSProperty[] {
-    return this.allPropertiesInternal;
+    return this.#allPropertiesInternal;
   }
 
   getPropertyValue(name: string): string {
-    const property = this.activePropertyMap.get(name);
+    const property = this.#activePropertyMap.get(name);
     return property ? property.value : '';
   }
 
   isPropertyImplicit(name: string): boolean {
-    const property = this.activePropertyMap.get(name);
+    const property = this.#activePropertyMap.get(name);
     return property ? property.implicit : false;
   }
 
@@ -301,7 +303,7 @@ export class CSSStyleDeclaration {
     const longhands = cssMetadata().getLonghands(name.toLowerCase());
     const result = [];
     for (let i = 0; longhands && i < longhands.length; ++i) {
-      const property = this.activePropertyMap.get(longhands[i]);
+      const property = this.#activePropertyMap.get(longhands[i]);
       if (property) {
         result.push(property);
       }
@@ -343,7 +345,7 @@ export class CSSStyleDeclaration {
     if (!this.range || !this.styleSheetId) {
       return Promise.resolve(false);
     }
-    return this.cssModelInternal.setStyleText(this.styleSheetId, this.range, text, majorChange);
+    return this.#cssModelInternal.setStyleText(this.styleSheetId, this.range, text, majorChange);
   }
 
   insertPropertyAt(index: number, name: string, value: string, userCallback?: ((arg0: boolean) => void)): void {

package/front_end/core/sdk/CSSStyleSheetHeader.ts

@@ -27,7 +27,7 @@ const str_ = i18n.i18n.registerUIStrings('core/sdk/CSSStyleSheetHeader.ts', UISt
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class CSSStyleSheetHeader implements TextUtils.ContentProvider.ContentProvider, FrameAssociated {
-  private cssModelInternal: CSSModel;
+  #cssModelInternal: CSSModel;
   id: Protocol.CSS.StyleSheetId;
   frameId: Protocol.Page.FrameId;
   sourceURL: string;
@@ -45,10 +45,10 @@ export class CSSStyleSheetHeader implements TextUtils.ContentProvider.ContentPro
   contentLength: number;
   ownerNode: DeferredDOMNode|undefined;
   sourceMapURL: string|undefined;
-  private originalContentProviderInternal: TextUtils.StaticContentProvider.StaticContentProvider|null;
+  #originalContentProviderInternal: TextUtils.StaticContentProvider.StaticContentProvider|null;
 
   constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSStyleSheetHeader) {
-    this.cssModelInternal = cssModel;
+    this.#cssModelInternal = cssModel;
     this.id = payload.styleSheetId;
     this.frameId = payload.frameId;
     this.sourceURL = payload.sourceURL;
@@ -68,22 +68,22 @@ export class CSSStyleSheetHeader implements TextUtils.ContentProvider.ContentPro
       this.ownerNode = new DeferredDOMNode(cssModel.target(), payload.ownerNode);
     }
     this.sourceMapURL = payload.sourceMapURL;
-    this.originalContentProviderInternal = null;
+    this.#originalContentProviderInternal = null;
   }
 
   originalContentProvider(): TextUtils.ContentProvider.ContentProvider {
-    if (!this.originalContentProviderInternal) {
+    if (!this.#originalContentProviderInternal) {
       const lazyContent = (async(): Promise<TextUtils.ContentProvider.DeferredContent> => {
-        const originalText = await this.cssModelInternal.originalStyleSheetText(this);
+        const originalText = await this.#cssModelInternal.originalStyleSheetText(this);
         if (originalText === null) {
           return {content: null, error: i18nString(UIStrings.couldNotFindTheOriginalStyle), isEncoded: false};
         }
         return {content: originalText, isEncoded: false};
       });
-      this.originalContentProviderInternal =
+      this.#originalContentProviderInternal =
           new TextUtils.StaticContentProvider.StaticContentProvider(this.contentURL(), this.contentType(), lazyContent);
     }
-    return this.originalContentProviderInternal;
+    return this.#originalContentProviderInternal;
   }
 
   setSourceMapURL(sourceMapURL?: string): void {
@@ -91,11 +91,11 @@ export class CSSStyleSheetHeader implements TextUtils.ContentProvider.ContentPro
   }
 
   cssModel(): CSSModel {
-    return this.cssModelInternal;
+    return this.#cssModelInternal;
   }
 
   isAnonymousInlineStyleSheet(): boolean {
-    return !this.resourceURL() && !this.cssModelInternal.sourceMapManager().sourceMapForClient(this);
+    return !this.resourceURL() && !this.#cssModelInternal.sourceMapManager().sourceMapForClient(this);
   }
 
   isConstructedByNew(): boolean {
@@ -107,7 +107,7 @@ export class CSSStyleSheetHeader implements TextUtils.ContentProvider.ContentPro
   }
 
   private viaInspectorResourceURL(): string {
-    const model = this.cssModelInternal.target().model(ResourceTreeModel);
+    const model = this.#cssModelInternal.target().model(ResourceTreeModel);
     console.assert(Boolean(model));
     if (!model) {
       return '';
@@ -159,7 +159,7 @@ export class CSSStyleSheetHeader implements TextUtils.ContentProvider.ContentPro
 
   async requestContent(): Promise<TextUtils.ContentProvider.DeferredContent> {
     try {
-      const cssText = await this.cssModelInternal.getStyleSheetText(this.id);
+      const cssText = await this.#cssModelInternal.getStyleSheetText(this.id);
       return {content: (cssText as string), isEncoded: false};
     } catch (err) {
       return {