chrome-devtools-frontend 1.0.951864 → 1.0.952284

package/front_end/ui/components/tree_outline/TreeOutline.ts

@@ -123,19 +123,19 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
   attributeChangedCallback(name: 'nowrap'|'toplevelbordercolor', oldValue: string|null, newValue: string|null): void {
     switch (name) {
       case 'nowrap': {
-        this.setNodeKeyNoWrapCSSVariable(newValue);
+        this.#setNodeKeyNoWrapCSSVariable(newValue);
         break;
       }
       case 'toplevelbordercolor': {
-        this.setTopLevelNodeBorderColorCSSVariable(newValue);
+        this.#setTopLevelNodeBorderColorCSSVariable(newValue);
         break;
       }
     }
   }
 
   connectedCallback(): void {
-    this.setTopLevelNodeBorderColorCSSVariable(this.getAttribute('toplevelbordercolor'));
-    this.setNodeKeyNoWrapCSSVariable(this.getAttribute('nowrap'));
+    this.#setTopLevelNodeBorderColorCSSVariable(this.getAttribute('toplevelbordercolor'));
+    this.#setNodeKeyNoWrapCSSVariable(this.getAttribute('nowrap'));
     this.#shadow.adoptedStyleSheets = [treeOutlineStyles, CodeHighlighter.Style.default];
   }
 
@@ -153,7 +153,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
     if (!this.#hasRenderedAtLeastOnce) {
       this.#selectedTreeNode = this.#treeData[0];
     }
-    this.render();
+    this.#render();
   }
 
   /**
@@ -162,8 +162,8 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
    * 1 and 2.
    */
   async expandRecursively(maxDepth = 2): Promise<void> {
-    await Promise.all(this.#treeData.map(rootNode => this.expandAndRecurse(rootNode, 0, maxDepth)));
-    await this.render();
+    await Promise.all(this.#treeData.map(rootNode => this.#expandAndRecurse(rootNode, 0, maxDepth)));
+    await this.#render();
   }
 
   /**
@@ -171,7 +171,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
    */
   async collapseAllNodes(): Promise<void> {
     this.#nodeExpandedMap.clear();
-    await this.render();
+    await this.#render();
   }
 
   /**
@@ -193,13 +193,13 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
     pathToTreeNode.forEach((node, index) => {
       // We don't expand the very last node, which was the target node.
       if (index < pathToTreeNode.length - 1) {
-        this.setNodeExpandedState(node, true);
+        this.#setNodeExpandedState(node, true);
       }
     });
 
     // Mark the node as pending focus so when it is rendered into the DOM we can focus it
     this.#nodeIdPendingFocus = targetTreeNodeId;
-    await this.render();
+    await this.#render();
   }
 
   /**
@@ -207,7 +207,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
    */
   expandNodeIds(nodeIds: TreeNodeId[]): Promise<void> {
     nodeIds.forEach(id => this.#nodeExpandedMap.set(id, true));
-    return this.render();
+    return this.#render();
   }
 
   /**
@@ -215,7 +215,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
    */
   focusNodeId(nodeId: TreeNodeId): Promise<void> {
     this.#nodeIdPendingFocus = nodeId;
-    return this.render();
+    return this.#render();
   }
 
   async collapseChildrenOfNode(domNode: HTMLLIElement): Promise<void> {
@@ -223,38 +223,38 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
     if (!treeNode) {
       return;
     }
-    await this.recursivelyCollapseTreeNodeChildren(treeNode);
-    await this.render();
+    await this.#recursivelyCollapseTreeNodeChildren(treeNode);
+    await this.#render();
   }
 
-  private setNodeKeyNoWrapCSSVariable(attributeValue: string|null): void {
+  #setNodeKeyNoWrapCSSVariable(attributeValue: string|null): void {
     ComponentHelpers.SetCSSProperty.set(
         this, '--override-key-whitespace-wrapping', attributeValue !== null ? 'nowrap' : 'initial');
   }
 
-  private setTopLevelNodeBorderColorCSSVariable(attributeValue: string|null): void {
+  #setTopLevelNodeBorderColorCSSVariable(attributeValue: string|null): void {
     ComponentHelpers.SetCSSProperty.set(
         this, '--override-top-node-border', attributeValue ? `1px solid ${attributeValue}` : '');
   }
 
-  private async recursivelyCollapseTreeNodeChildren(treeNode: TreeNode<TreeNodeDataType>): Promise<void> {
-    if (!isExpandableNode(treeNode) || !this.nodeIsExpanded(treeNode)) {
+  async #recursivelyCollapseTreeNodeChildren(treeNode: TreeNode<TreeNodeDataType>): Promise<void> {
+    if (!isExpandableNode(treeNode) || !this.#nodeIsExpanded(treeNode)) {
       return;
     }
-    const children = await this.fetchNodeChildren(treeNode);
-    const childRecursions = Promise.all(children.map(child => this.recursivelyCollapseTreeNodeChildren(child)));
+    const children = await this.#fetchNodeChildren(treeNode);
+    const childRecursions = Promise.all(children.map(child => this.#recursivelyCollapseTreeNodeChildren(child)));
     await childRecursions;
-    this.setNodeExpandedState(treeNode, false);
+    this.#setNodeExpandedState(treeNode, false);
   }
 
-  private getSelectedTreeNode(): TreeNode<TreeNodeDataType> {
+  #getSelectedTreeNode(): TreeNode<TreeNodeDataType> {
     if (!this.#selectedTreeNode) {
       throw new Error('getSelectedNode was called but selectedTreeNode is null');
     }
     return this.#selectedTreeNode;
   }
 
-  private async fetchNodeChildren(node: TreeNodeWithChildren<TreeNodeDataType>): Promise<TreeNode<TreeNodeDataType>[]> {
+  async #fetchNodeChildren(node: TreeNodeWithChildren<TreeNodeDataType>): Promise<TreeNode<TreeNodeDataType>[]> {
     const children = await getNodeChildren(node);
     if (!this.#nodeFilter) {
       return children;
@@ -263,77 +263,76 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
     for (const child of children) {
       const filtering = this.#nodeFilter(child.treeNodeData);
       // We always include the selected node in the tree, regardless of its filtering status.
-      if (filtering === FilterOption.SHOW || this.isSelectedNode(child) || child.id === this.#nodeIdPendingFocus) {
+      if (filtering === FilterOption.SHOW || this.#isSelectedNode(child) || child.id === this.#nodeIdPendingFocus) {
         filteredChildren.push(child);
       } else if (filtering === FilterOption.FLATTEN && isExpandableNode(child)) {
-        const grandChildren = await this.fetchNodeChildren(child);
+        const grandChildren = await this.#fetchNodeChildren(child);
         filteredChildren.push(...grandChildren);
       }
     }
     return filteredChildren;
   }
 
-  private setNodeExpandedState(node: TreeNode<TreeNodeDataType>, newExpandedState: boolean): void {
+  #setNodeExpandedState(node: TreeNode<TreeNodeDataType>, newExpandedState: boolean): void {
     this.#nodeExpandedMap.set(node.id, newExpandedState);
   }
 
-  private nodeIsExpanded(node: TreeNode<TreeNodeDataType>): boolean {
+  #nodeIsExpanded(node: TreeNode<TreeNodeDataType>): boolean {
     return this.#nodeExpandedMap.get(node.id) || false;
   }
 
-  private async expandAndRecurse(node: TreeNode<TreeNodeDataType>, currentDepth: number, maxDepth: number):
-      Promise<void> {
+  async #expandAndRecurse(node: TreeNode<TreeNodeDataType>, currentDepth: number, maxDepth: number): Promise<void> {
     if (!isExpandableNode(node)) {
       return;
     }
-    this.setNodeExpandedState(node, true);
+    this.#setNodeExpandedState(node, true);
     if (currentDepth === maxDepth || !isExpandableNode(node)) {
       return;
     }
-    const children = await this.fetchNodeChildren(node);
-    await Promise.all(children.map(child => this.expandAndRecurse(child, currentDepth + 1, maxDepth)));
+    const children = await this.#fetchNodeChildren(node);
+    await Promise.all(children.map(child => this.#expandAndRecurse(child, currentDepth + 1, maxDepth)));
   }
 
-  private onArrowClick(node: TreeNode<TreeNodeDataType>): ((e: Event) => void) {
+  #onArrowClick(node: TreeNode<TreeNodeDataType>): ((e: Event) => void) {
     return (event: Event): void => {
       event.stopPropagation();
       if (isExpandableNode(node)) {
-        this.setNodeExpandedState(node, !this.nodeIsExpanded(node));
-        this.render();
+        this.#setNodeExpandedState(node, !this.#nodeIsExpanded(node));
+        this.#render();
       }
     };
   }
 
-  private onNodeClick(event: Event): void {
+  #onNodeClick(event: Event): void {
     // Avoid it bubbling up to parent tree elements, else clicking a node deep in the tree will toggle it + all its ancestor's visibility.
     event.stopPropagation();
     const nodeClickExpandsOrContracts = this.getAttribute('clickabletitle') !== null;
     const domNode = event.currentTarget as HTMLLIElement;
     const node = this.#domNodeToTreeNodeMap.get(domNode);
     if (nodeClickExpandsOrContracts && node && isExpandableNode(node)) {
-      this.setNodeExpandedState(node, !this.nodeIsExpanded(node));
+      this.#setNodeExpandedState(node, !this.#nodeIsExpanded(node));
     }
-    this.focusTreeNode(domNode);
+    this.#focusTreeNode(domNode);
   }
 
-  private async focusTreeNode(domNode: HTMLLIElement): Promise<void> {
+  async #focusTreeNode(domNode: HTMLLIElement): Promise<void> {
     const treeNode = this.#domNodeToTreeNodeMap.get(domNode);
     if (!treeNode) {
       return;
     }
     this.#selectedTreeNode = treeNode;
-    await this.render();
+    await this.#render();
     this.dispatchEvent(new ItemSelectedEvent(treeNode));
     coordinator.write('DOMNode focus', () => {
       domNode.focus();
     });
   }
 
-  private processHomeAndEndKeysNavigation(key: 'Home'|'End'): void {
+  #processHomeAndEndKeysNavigation(key: 'Home'|'End'): void {
     if (key === 'Home') {
       const firstRootNode = this.#shadow.querySelector<HTMLLIElement>('ul[role="tree"] > li[role="treeitem"]');
       if (firstRootNode) {
-        this.focusTreeNode(firstRootNode);
+        this.#focusTreeNode(firstRootNode);
       }
     } else if (key === 'End') {
       /**
@@ -348,12 +347,12 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
       const allTreeItems = this.#shadow.querySelectorAll<HTMLLIElement>('li[role="treeitem"]');
       const lastTreeItem = allTreeItems[allTreeItems.length - 1];
       if (lastTreeItem) {
-        this.focusTreeNode(lastTreeItem);
+        this.#focusTreeNode(lastTreeItem);
       }
     }
   }
 
-  private async processArrowKeyNavigation(key: Platform.KeyboardUtilities.ArrowKey, currentDOMNode: HTMLLIElement):
+  async #processArrowKeyNavigation(key: Platform.KeyboardUtilities.ArrowKey, currentDOMNode: HTMLLIElement):
       Promise<void> {
     const currentTreeNode = this.#domNodeToTreeNodeMap.get(currentDOMNode);
     if (!currentTreeNode) {
@@ -364,65 +363,65 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
       currentDOMNode,
       currentTreeNode,
       direction: key,
-      setNodeExpandedState: (node, expanded) => this.setNodeExpandedState(node, expanded),
+      setNodeExpandedState: (node, expanded) => this.#setNodeExpandedState(node, expanded),
     });
-    await this.focusTreeNode(domNode);
+    await this.#focusTreeNode(domNode);
   }
 
-  private processEnterOrSpaceNavigation(currentDOMNode: HTMLLIElement): void {
+  #processEnterOrSpaceNavigation(currentDOMNode: HTMLLIElement): void {
     const currentTreeNode = this.#domNodeToTreeNodeMap.get(currentDOMNode);
     if (!currentTreeNode) {
       return;
     }
     if (isExpandableNode(currentTreeNode)) {
-      const currentExpandedState = this.nodeIsExpanded(currentTreeNode);
-      this.setNodeExpandedState(currentTreeNode, !currentExpandedState);
-      this.render();
+      const currentExpandedState = this.#nodeIsExpanded(currentTreeNode);
+      this.#setNodeExpandedState(currentTreeNode, !currentExpandedState);
+      this.#render();
     }
   }
 
-  private async onTreeKeyDown(event: KeyboardEvent): Promise<void> {
+  async #onTreeKeyDown(event: KeyboardEvent): Promise<void> {
     if (!(event.target instanceof HTMLLIElement)) {
       throw new Error('event.target was not an <li> element');
     }
 
     if (event.key === 'Home' || event.key === 'End') {
       event.preventDefault();
-      this.processHomeAndEndKeysNavigation(event.key);
+      this.#processHomeAndEndKeysNavigation(event.key);
     } else if (Platform.KeyboardUtilities.keyIsArrowKey(event.key)) {
       event.preventDefault();
-      await this.processArrowKeyNavigation(event.key, event.target);
+      await this.#processArrowKeyNavigation(event.key, event.target);
     } else if (event.key === 'Enter' || event.key === ' ') {
       event.preventDefault();
-      this.processEnterOrSpaceNavigation(event.target);
+      this.#processEnterOrSpaceNavigation(event.target);
     }
   }
 
-  private focusPendingNode(domNode: HTMLLIElement): void {
+  #focusPendingNode(domNode: HTMLLIElement): void {
     this.#nodeIdPendingFocus = null;
-    this.focusTreeNode(domNode);
+    this.#focusTreeNode(domNode);
   }
 
-  private isSelectedNode(node: TreeNode<TreeNodeDataType>): boolean {
+  #isSelectedNode(node: TreeNode<TreeNodeDataType>): boolean {
     if (this.#selectedTreeNode) {
       return node.id === this.#selectedTreeNode.id;
     }
     return false;
   }
 
-  private renderNode(node: TreeNode<TreeNodeDataType>, {depth, setSize, positionInSet}: {
+  #renderNode(node: TreeNode<TreeNodeDataType>, {depth, setSize, positionInSet}: {
     depth: number,
     setSize: number,
     positionInSet: number,
   }): LitHtml.TemplateResult {
     let childrenToRender;
-    const nodeIsExpanded = this.nodeIsExpanded(node);
+    const nodeIsExpanded = this.#nodeIsExpanded(node);
     if (!isExpandableNode(node) || !nodeIsExpanded) {
       childrenToRender = LitHtml.nothing;
     } else {
-      const childNodes = this.fetchNodeChildren(node).then(children => {
+      const childNodes = this.#fetchNodeChildren(node).then(children => {
         return children.map((childNode, index) => {
-          return this.renderNode(childNode, {depth: depth + 1, setSize: children.length, positionInSet: index});
+          return this.#renderNode(childNode, {depth: depth + 1, setSize: children.length, positionInSet: index});
         });
       });
       // Disabled until https://crbug.com/1079231 is fixed.
@@ -431,12 +430,12 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
       // clang-format on
     }
 
-    const nodeIsFocusable = this.getSelectedTreeNode() === node;
+    const nodeIsFocusable = this.#getSelectedTreeNode() === node;
     const tabIndex = nodeIsFocusable ? 0 : -1;
     const listItemClasses = LitHtml.Directives.classMap({
       expanded: isExpandableNode(node) && nodeIsExpanded,
       parent: isExpandableNode(node),
-      selected: this.isSelectedNode(node),
+      selected: this.#isSelectedNode(node),
       'is-top-level': depth === 0,
     });
     const ariaExpandedAttribute =
@@ -459,7 +458,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
         aria-level=${depth + 1}
         aria-posinset=${positionInSet + 1}
         class=${listItemClasses}
-        @click=${this.onNodeClick}
+        @click=${this.#onNodeClick}
         track-dom-node-to-tree-node=${trackDOMNodeToTreeNode(this.#domNodeToTreeNodeMap, node)}
         on-render=${ComponentHelpers.Directives.nodeRenderedCallback(domNode => {
          /**
@@ -474,7 +473,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
           }
 
           if (this.#nodeIdPendingFocus && node.id === this.#nodeIdPendingFocus) {
-            this.focusPendingNode(domNode);
+            this.#focusPendingNode(domNode);
           }
         })}
       >
@@ -486,7 +485,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
             this.dispatchEvent(new ItemMouseOutEvent(node));
           }}
         >
-          <span class="arrow-icon" @click=${this.onArrowClick(node)}>
+          <span class="arrow-icon" @click=${this.#onArrowClick(node)}>
           </span>
           <span class="tree-node-key" data-node-key=${node.treeNodeData}>${renderedNodeKey}</span>
         </span>
@@ -496,7 +495,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
     // clang-format on
   }
 
-  private async render(): Promise<void> {
+  async #render(): Promise<void> {
     if (this.#scheduledRender) {
       // If we are already rendering, don't render again immediately, but
       // enqueue it to be run after we're done on our current render.
@@ -511,9 +510,9 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
       // clang-format off
       LitHtml.render(LitHtml.html`
       <div class="wrapping-container">
-      <ul role="tree" @keydown=${this.onTreeKeyDown}>
+      <ul role="tree" @keydown=${this.#onTreeKeyDown}>
         ${this.#treeData.map((topLevelNode, index) => {
-          return this.renderNode(topLevelNode, {
+          return this.#renderNode(topLevelNode, {
             depth: 0,
             setSize: this.#treeData.length,
             positionInSet: index,
@@ -533,7 +532,7 @@ export class TreeOutline<TreeNodeDataType> extends HTMLElement {
     // to ensure we're not rendering any stale UI.
     if (this.#enqueuedRender) {
       this.#enqueuedRender = false;
-      return this.render();
+      return this.#render();
     }
   }
 }

package/front_end/ui/legacy/themeColors.css

@@ -15,6 +15,7 @@
   --color-primary-variant: rgb(66 133 244);
   --color-background: rgb(255 255 255);
   --color-background-inverted: rgb(0 0 0);
+  --color-background-inverted-opacity-2: rgb(0 0 0 / 2%);
   --color-background-inverted-opacity-30: rgb(0 0 0 / 30%);
   --color-background-inverted-opacity-50: rgb(0 0 0 / 50%);
   --color-background-opacity-50: rgb(255 255 255 / 50%);
@@ -192,6 +193,7 @@
   --color-primary-variant: rgb(102 157 246);
   --color-background: rgb(32 33 36);
   --color-background-inverted: rgb(255 255 255);
+  --color-background-inverted-opacity-2: rgb(255 255 255 / 2%);
   --color-background-inverted-opacity-30: rgb(255 255 255 / 30%);
   --color-background-inverted-opacity-50: rgb(255 255 255 / 50%);
   --color-background-opacity-50: rgb(32 33 36 / 50%);

package/front_end/ui/legacy/theme_support/theme_support_impl.ts

@@ -291,6 +291,12 @@ export class ThemeSupport {
     output.push(';');
   }
 
+  /**
+   * This legacy function has been supeseded by CSS custom properties. Wherever possible, please use
+   * the values declared in global stylesheets.
+   *
+   * @deprecated
+   */
   patchColorText(text: string, colorUsage: number): string {
     const color = Common.Color.Color.parse(text);
     if (!color) {
@@ -304,6 +310,12 @@ export class ThemeSupport {
     return outText || text;
   }
 
+  /**
+   * This legacy function has been supeseded by CSS custom properties. Wherever possible, please use
+   * the values declared in global stylesheets.
+   *
+   * @deprecated
+   */
   patchColor(color: Common.Color.Color, colorUsage: number): Common.Color.Color {
     const hsla = color.hsla();
     this.patchHSLA(hsla, colorUsage);

package/package.json

@@ -53,5 +53,5 @@
     "unittest": "scripts/test/run_unittests.py --no-text-coverage",
     "watch": "third_party/node/node.py --output scripts/watch_build.js"
   },
-  "version": "1.0.951864"
+  "version": "1.0.952284"
 }

package/scripts/eslint_rules/lib/use_private_class_members.js

@@ -0,0 +1,41 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * @fileoverview Rule to ban private keyword in components
+ * @author Tim van der Lippe
+ */
+'use strict';
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    type: 'problem',
+
+    docs: {
+      description: 'Usage of private keyword',
+      category: 'Possible Errors',
+    },
+
+    fixable: 'code',
+    schema: [],  // no options
+    messages:
+        {do_not_use_private: 'Use private class notation (start the name with a `#`) rather than the private keyword'},
+  },
+  create: function(context) {
+    return {
+      ['MethodDefinition, PropertyDefinition'](node) {
+        if (node.accessibility === 'private' && node.kind !== 'constructor') {
+          context.report({
+            node: node.key,
+            messageId: 'do_not_use_private',
+          });
+        }
+      }
+    };
+  }
+};

package/scripts/eslint_rules/tests/use_private_class_members_test.js

@@ -0,0 +1,62 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+const rule = require('../lib/use_private_class_members.js');
+const ruleTester = new (require('eslint').RuleTester)({
+  parser: require.resolve('@typescript-eslint/parser'),
+  parserOptions: {ecmaVersion: 9, sourceType: 'module'},
+});
+
+ruleTester.run('use_private_class_members', rule, {
+  valid: [
+    {
+      code: `class Foo {
+        #method() {}
+      }
+      `,
+      filename: 'test/e2e/folder/file.ts',
+    },
+    {
+      code: `class Foo {
+        public method() {}
+      }
+      `,
+      filename: 'test/e2e/folder/file.ts',
+    },
+    {
+      code: `class Foo {
+        public field: string;
+      }
+      `,
+      filename: 'test/e2e/folder/file.ts',
+    },
+    {
+      code: `class Foo {
+        private constructor() {}
+      }
+      `,
+      filename: 'test/e2e/folder/file.ts',
+    },
+  ],
+
+  invalid: [
+    {
+      code: `class Foo {
+        private method() {}
+      }
+      `,
+      filename: 'test/e2e/folder/file.ts',
+      errors: [{messageId: 'do_not_use_private'}],
+    },
+    {
+      code: `class Foo {
+        private field: string;
+      }
+      `,
+      filename: 'test/e2e/folder/file.ts',
+      errors: [{messageId: 'do_not_use_private'}],
+    },
+  ]
+});

package/scripts/migration/class-fields/migrate.js

@@ -33,7 +33,7 @@ for (const file of files) {
   }
   const classNodes = file.getClasses();
   for (const classNode of classNodes) {
-    for (const property of classNode.getInstanceProperties()) {
+    for (const property of classNode.getInstanceMembers()) {
       const name = property.getStructure().name;
       console.log(name);
       if (name.startsWith('#') || !property.hasModifier(SyntaxKind.PrivateKeyword)) {
@@ -44,8 +44,7 @@ for (const file of files) {
         continue;
       }
 
-      // https://github.com/dsherret/ts-morph/issues/1198
-      const newName = `SOME_STUPID_PREFIX_${name}`;
+      const newName = `#${name}`;
 
       property.toggleModifier('private', false);
       property.rename(newName);

package/scripts/migration/class-fields/migrate.sh

@@ -3,8 +3,6 @@
 # scripts/migration/class-fields/migrate.sh panels/console
 #
 $PWD/third_party/node/node.py --output scripts/migration/class-fields/migrate.js $1/
-find $PWD/front_end/$1/ -type f -exec sed -i -e 's/SOME_STUPID_PREFIX_/#/g' {} \;
 git cl format --js
 NINJA_SUMMARIZE_BUILD=1 autoninja -C out/Default front_end/$1:bundle
-git add .
-git commit -m "Migrate to private class fields in $1" -m "" -m "R=szuend@chromium.org" -m "" -m "Bug: 1222126"
+echo 'git commit -m "Migrate to private class fields in $1" -m "" -m "R=szuend@chromium.org" -m "" -m "Bug: 1222126"'

package/scripts/migration/class-fields/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "ts-morph": "^12.0.0"
+    "ts-morph": "^13.0.1"
   }
 }