chrome-devtools-frontend 1.0.950971 → 1.0.952403

package/front_end/entrypoints/formatter_worker/ESTreeWalker.ts

@@ -7,16 +7,16 @@ import type * as Acorn from '../../third_party/acorn/acorn.js';
 const SkipSubTreeObject: Object = {};
 
 export class ESTreeWalker {
-  private readonly beforeVisit: (arg0: Acorn.ESTree.Node) => (Object | undefined);
-  private readonly afterVisit: Function;
-  private walkNulls: boolean;
+  readonly #beforeVisit: (arg0: Acorn.ESTree.Node) => (Object | undefined);
+  readonly #afterVisit: Function;
+  #walkNulls: boolean;
 
   constructor(
       beforeVisit: (arg0: Acorn.ESTree.Node) => (Object | undefined),
       afterVisit?: ((arg0: Acorn.ESTree.Node) => void)) {
-    this.beforeVisit = beforeVisit;
-    this.afterVisit = afterVisit || function(): void {};
-    this.walkNulls = false;
+    this.#beforeVisit = beforeVisit;
+    this.#afterVisit = afterVisit || function(): void {};
+    this.#walkNulls = false;
   }
 
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
@@ -26,15 +26,15 @@ export class ESTreeWalker {
   }
 
   setWalkNulls(value: boolean): void {
-    this.walkNulls = value;
+    this.#walkNulls = value;
   }
 
   walk(ast: Acorn.ESTree.Node): void {
-    this.innerWalk(ast, null);
+    this.#innerWalk(ast, null);
   }
 
-  private innerWalk(node: Acorn.ESTree.Node, parent: Acorn.ESTree.Node|null): void {
-    if (!node && parent && this.walkNulls) {
+  #innerWalk(node: Acorn.ESTree.Node, parent: Acorn.ESTree.Node|null): void {
+    if (!node && parent && this.#walkNulls) {
       const result = ({raw: 'null', value: null, parent: null} as Acorn.ESTree.SimpleLiteral);
       // Otherwise Closure can't handle the definition
       result.type = 'Literal';
@@ -47,8 +47,8 @@ export class ESTreeWalker {
     }
     node.parent = parent;
 
-    if (this.beforeVisit.call(null, node) === ESTreeWalker.SkipSubtree) {
-      this.afterVisit.call(null, node);
+    if (this.#beforeVisit.call(null, node) === ESTreeWalker.SkipSubtree) {
+      this.#afterVisit.call(null, node);
       return;
     }
 
@@ -62,10 +62,10 @@ export class ESTreeWalker {
       const templateLiteral = (node as Acorn.ESTree.TemplateLiteral);
       const expressionsLength = templateLiteral.expressions.length;
       for (let i = 0; i < expressionsLength; ++i) {
-        this.innerWalk(templateLiteral.quasis[i], templateLiteral);
-        this.innerWalk(templateLiteral.expressions[i], templateLiteral);
+        this.#innerWalk(templateLiteral.quasis[i], templateLiteral);
+        this.#innerWalk(templateLiteral.expressions[i], templateLiteral);
       }
-      this.innerWalk(templateLiteral.quasis[expressionsLength], templateLiteral);
+      this.#innerWalk(templateLiteral.quasis[expressionsLength], templateLiteral);
     } else {
       for (let i = 0; i < walkOrder.length; ++i) {
         // @ts-ignore We are doing type traversal here, but the strings
@@ -75,19 +75,19 @@ export class ESTreeWalker {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const entity = (node[walkOrder[i]] as any);
         if (Array.isArray(entity)) {
-          this.walkArray((entity as Acorn.ESTree.Node[]), node);
+          this.#walkArray((entity as Acorn.ESTree.Node[]), node);
         } else {
-          this.innerWalk((entity as Acorn.ESTree.Node), node);
+          this.#innerWalk((entity as Acorn.ESTree.Node), node);
         }
       }
     }
 
-    this.afterVisit.call(null, node);
+    this.#afterVisit.call(null, node);
   }
 
-  private walkArray(nodeArray: Acorn.ESTree.Node[], parentNode: Acorn.ESTree.Node|null): void {
+  #walkArray(nodeArray: Acorn.ESTree.Node[], parentNode: Acorn.ESTree.Node|null): void {
     for (let i = 0; i < nodeArray.length; ++i) {
-      this.innerWalk(nodeArray[i], parentNode);
+      this.#innerWalk(nodeArray[i], parentNode);
     }
   }
 }

package/front_end/entrypoints/formatter_worker/FormattedContentBuilder.ts

@@ -3,16 +3,16 @@
 // found in the LICENSE file.
 
 export class FormattedContentBuilder {
-  private lastOriginalPosition = 0;
-  private formattedContent: string[] = [];
-  private formattedContentLength = 0;
-  private lastFormattedPosition = 0;
-  private nestingLevel = 0;
-  private newLines = 0;
-  private enforceSpaceBetweenWords = true;
-  private softSpace = false;
-  private hardSpaces = 0;
-  private cachedIndents = new Map<number, string>();
+  #lastOriginalPosition = 0;
+  #formattedContent: string[] = [];
+  #formattedContentLength = 0;
+  #lastFormattedPosition = 0;
+  #nestingLevel = 0;
+  #newLines = 0;
+  #enforceSpaceBetweenWords = true;
+  #softSpace = false;
+  #hardSpaces = 0;
+  #cachedIndents = new Map<number, string>();
 
   mapping = {original: [0], formatted: [0]};
 
@@ -20,110 +20,110 @@ export class FormattedContentBuilder {
   }
 
   setEnforceSpaceBetweenWords(value: boolean): boolean {
-    const oldValue = this.enforceSpaceBetweenWords;
-    this.enforceSpaceBetweenWords = value;
+    const oldValue = this.#enforceSpaceBetweenWords;
+    this.#enforceSpaceBetweenWords = value;
     return oldValue;
   }
 
   addToken(token: string, offset: number): void {
-    const last = this.formattedContent[this.formattedContent.length - 1];
-    if (this.enforceSpaceBetweenWords && last && /\w/.test(last[last.length - 1]) && /\w/.test(token)) {
+    const last = this.#formattedContent[this.#formattedContent.length - 1];
+    if (this.#enforceSpaceBetweenWords && last && /\w/.test(last[last.length - 1]) && /\w/.test(token)) {
       this.addSoftSpace();
     }
 
-    this.appendFormatting();
+    this.#appendFormatting();
 
     // Insert token.
-    this.addMappingIfNeeded(offset);
-    this.addText(token);
+    this.#addMappingIfNeeded(offset);
+    this.#addText(token);
   }
 
   addSoftSpace(): void {
-    if (!this.hardSpaces) {
-      this.softSpace = true;
+    if (!this.#hardSpaces) {
+      this.#softSpace = true;
     }
   }
 
   addHardSpace(): void {
-    this.softSpace = false;
-    ++this.hardSpaces;
+    this.#softSpace = false;
+    ++this.#hardSpaces;
   }
 
   addNewLine(noSquash?: boolean): void {
     // Avoid leading newlines.
-    if (!this.formattedContentLength) {
+    if (!this.#formattedContentLength) {
       return;
     }
     if (noSquash) {
-      ++this.newLines;
+      ++this.#newLines;
     } else {
-      this.newLines = this.newLines || 1;
+      this.#newLines = this.#newLines || 1;
     }
   }
 
   increaseNestingLevel(): void {
-    this.nestingLevel += 1;
+    this.#nestingLevel += 1;
   }
 
   decreaseNestingLevel(): void {
-    if (this.nestingLevel > 0) {
-      this.nestingLevel -= 1;
+    if (this.#nestingLevel > 0) {
+      this.#nestingLevel -= 1;
     }
   }
 
   content(): string {
-    return this.formattedContent.join('') + (this.newLines ? '\n' : '');
+    return this.#formattedContent.join('') + (this.#newLines ? '\n' : '');
   }
 
-  private appendFormatting(): void {
-    if (this.newLines) {
-      for (let i = 0; i < this.newLines; ++i) {
-        this.addText('\n');
+  #appendFormatting(): void {
+    if (this.#newLines) {
+      for (let i = 0; i < this.#newLines; ++i) {
+        this.#addText('\n');
       }
-      this.addText(this.indent());
-    } else if (this.softSpace) {
-      this.addText(' ');
+      this.#addText(this.#indent());
+    } else if (this.#softSpace) {
+      this.#addText(' ');
     }
-    if (this.hardSpaces) {
-      for (let i = 0; i < this.hardSpaces; ++i) {
-        this.addText(' ');
+    if (this.#hardSpaces) {
+      for (let i = 0; i < this.#hardSpaces; ++i) {
+        this.#addText(' ');
       }
     }
-    this.newLines = 0;
-    this.softSpace = false;
-    this.hardSpaces = 0;
+    this.#newLines = 0;
+    this.#softSpace = false;
+    this.#hardSpaces = 0;
   }
 
-  private indent(): string {
-    const cachedValue = this.cachedIndents.get(this.nestingLevel);
+  #indent(): string {
+    const cachedValue = this.#cachedIndents.get(this.#nestingLevel);
     if (cachedValue) {
       return cachedValue;
     }
 
     let fullIndent = '';
-    for (let i = 0; i < this.nestingLevel; ++i) {
+    for (let i = 0; i < this.#nestingLevel; ++i) {
       fullIndent += this.indentString;
     }
 
     // Cache a maximum of 20 nesting level indents.
-    if (this.nestingLevel <= 20) {
-      this.cachedIndents.set(this.nestingLevel, fullIndent);
+    if (this.#nestingLevel <= 20) {
+      this.#cachedIndents.set(this.#nestingLevel, fullIndent);
     }
     return fullIndent;
   }
 
-  private addText(text: string): void {
-    this.formattedContent.push(text);
-    this.formattedContentLength += text.length;
+  #addText(text: string): void {
+    this.#formattedContent.push(text);
+    this.#formattedContentLength += text.length;
   }
 
-  private addMappingIfNeeded(originalPosition: number): void {
-    if (originalPosition - this.lastOriginalPosition === this.formattedContentLength - this.lastFormattedPosition) {
+  #addMappingIfNeeded(originalPosition: number): void {
+    if (originalPosition - this.#lastOriginalPosition === this.#formattedContentLength - this.#lastFormattedPosition) {
       return;
     }
     this.mapping.original.push(originalPosition);
-    this.lastOriginalPosition = originalPosition;
-    this.mapping.formatted.push(this.formattedContentLength);
-    this.lastFormattedPosition = this.formattedContentLength;
+    this.#lastOriginalPosition = originalPosition;
+    this.mapping.formatted.push(this.#formattedContentLength);
+    this.#lastFormattedPosition = this.#formattedContentLength;
   }
 }