@angular/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor-migration.js

Angular Material

"use strict";
/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.RippleSpeedFactorMigration = void 0;
const schematics_1 = require("@angular/cdk/schematics");
const ts = require("typescript");
const ripple_speed_factor_1 = require("./ripple-speed-factor");
/** Regular expression that matches [matRippleSpeedFactor]="$NUMBER" in templates. */
const speedFactorNumberRegex = /\[matRippleSpeedFactor]="(\d+(?:\.\d+)?)"/g;
/** Regular expression that matches [matRippleSpeedFactor]="$NOT_A_NUMBER" in templates. */
const speedFactorNotParseable = /\[matRippleSpeedFactor]="(?!\d+(?:\.\d+)?")(.*)"/g;
/**
 * Note that will be added whenever a speed factor expression has been converted to calculate
 * the according duration. This note should encourage people to clean up their code by switching
 * away from the speed factors to explicit durations.
 */
const removeNote = `TODO: Cleanup duration calculation.`;
/**
 * Migration that walks through every property assignment and switches the global `baseSpeedFactor`
 * ripple option to the new global animation config. Also updates every class member assignment
 * that refers to MatRipple#speedFactor.
 */
class RippleSpeedFactorMigration extends schematics_1.Migration {
    constructor() {
        super(...arguments);
        // Only enable this rule if the migration targets version 7 as the ripple
        // speed factor has been removed in that version.
        this.enabled = this.targetVersion === schematics_1.TargetVersion.V7;
    }
    visitNode(node) {
        if (ts.isBinaryExpression(node)) {
            this._visitBinaryExpression(node);
        }
        else if (ts.isPropertyAssignment(node)) {
            this._visitPropertyAssignment(node);
        }
    }
    visitTemplate(template) {
        let match;
        while ((match = speedFactorNumberRegex.exec(template.content)) !== null) {
            const newEnterDuration = (0, ripple_speed_factor_1.convertSpeedFactorToDuration)(parseFloat(match[1]));
            this._replaceText(template.filePath, template.start + match.index, match[0].length, `[matRippleAnimation]="{enterDuration: ${newEnterDuration}}"`);
        }
        while ((match = speedFactorNotParseable.exec(template.content)) !== null) {
            const newDurationExpression = (0, ripple_speed_factor_1.createSpeedFactorConvertExpression)(match[1]);
            this._replaceText(template.filePath, template.start + match.index, match[0].length, `[matRippleAnimation]="{enterDuration: (${newDurationExpression})}"`);
        }
    }
    /** Switches binary expressions (e.g. myRipple.speedFactor = 0.5) to the new animation config. */
    _visitBinaryExpression(expression) {
        if (!ts.isPropertyAccessExpression(expression.left)) {
            return;
        }
        // Left side expression consists of target object and property name (e.g. myInstance.val)
        const leftExpression = expression.left;
        const targetTypeNode = this.typeChecker.getTypeAtLocation(leftExpression.expression);
        if (!targetTypeNode.symbol) {
            return;
        }
        const targetTypeName = targetTypeNode.symbol.getName();
        const propertyName = leftExpression.name.getText();
        const filePath = this.fileSystem.resolve(leftExpression.getSourceFile().fileName);
        if (targetTypeName === 'MatRipple' && propertyName === 'speedFactor') {
            if (ts.isNumericLiteral(expression.right)) {
                const numericValue = parseFloat(expression.right.text);
                const newEnterDurationValue = (0, ripple_speed_factor_1.convertSpeedFactorToDuration)(numericValue);
                // Replace the `speedFactor` property name with `animation`.
                this._replaceText(filePath, leftExpression.name.getStart(), leftExpression.name.getWidth(), 'animation');
                // Replace the value assignment with the new animation config.
                this._replaceText(filePath, expression.right.getStart(), expression.right.getWidth(), `{enterDuration: ${newEnterDurationValue}}`);
            }
            else {
                // Handle the right expression differently if the previous speed factor value can't
                // be resolved statically. In that case, we just create a TypeScript expression that
                // calculates the explicit duration based on the non-static speed factor expression.
                const newExpression = (0, ripple_speed_factor_1.createSpeedFactorConvertExpression)(expression.right.getText());
                // Replace the `speedFactor` property name with `animation`.
                this._replaceText(filePath, leftExpression.name.getStart(), leftExpression.name.getWidth(), 'animation');
                // Replace the value assignment with the new animation config and remove TODO.
                this._replaceText(filePath, expression.right.getStart(), expression.right.getWidth(), `/** ${removeNote} */ {enterDuration: ${newExpression}}`);
            }
        }
    }
    /**
     * Switches the global option `baseSpeedFactor` to the new animation config. For this
     * we assume that the `baseSpeedFactor` is not used in combination with individual
     * speed factors.
     */
    _visitPropertyAssignment(assignment) {
        // For switching the `baseSpeedFactor` global option we expect the property assignment
        // to be inside of a normal object literal. Custom ripple global options cannot be
        // witched automatically.
        if (!ts.isObjectLiteralExpression(assignment.parent)) {
            return;
        }
        // The assignment consists of a name (key) and initializer (value).
        if (assignment.name.getText() !== 'baseSpeedFactor') {
            return;
        }
        // We could technically lazily check for the MAT_RIPPLE_GLOBAL_OPTIONS injection token to
        // be present, but it's not right to assume that everyone sets the ripple global options
        // immediately in the provider object (e.g. it can happen that someone just imports the
        // config from a separate file).
        const { initializer, name } = assignment;
        const filePath = this.fileSystem.resolve(assignment.getSourceFile().fileName);
        if (ts.isNumericLiteral(initializer)) {
            const numericValue = parseFloat(initializer.text);
            const newEnterDurationValue = (0, ripple_speed_factor_1.convertSpeedFactorToDuration)(numericValue);
            // Replace the `baseSpeedFactor` property name with `animation`.
            this._replaceText(filePath, name.getStart(), name.getWidth(), 'animation');
            // Replace the value assignment initializer with the new animation config.
            this._replaceText(filePath, initializer.getStart(), initializer.getWidth(), `{enterDuration: ${newEnterDurationValue}}`);
        }
        else {
            // Handle the right expression differently if the previous speed factor value can't
            // be resolved statically. In that case, we just create a TypeScript expression that
            // calculates the explicit duration based on the non-static speed factor expression.
            const newExpression = (0, ripple_speed_factor_1.createSpeedFactorConvertExpression)(initializer.getText());
            // Replace the `baseSpeedFactor` property name with `animation`.
            this._replaceText(filePath, name.getStart(), name.getWidth(), 'animation');
            // Replace the value assignment with the new animation config and remove TODO.
            this._replaceText(filePath, initializer.getStart(), initializer.getWidth(), `/** ${removeNote} */ {enterDuration: ${newExpression}}`);
        }
    }
    _replaceText(filePath, start, width, newText) {
        const recorder = this.fileSystem.edit(filePath);
        recorder.remove(start, width);
        recorder.insertRight(start, newText);
    }
}
exports.RippleSpeedFactorMigration = RippleSpeedFactorMigration;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple-speed-factor-migration.js","sourceRoot":"","sources":["../../../../../../../../../src/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor-migration.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,wDAAkG;AAClG,iCAAiC;AACjC,+DAG+B;AAE/B,qFAAqF;AACrF,MAAM,sBAAsB,GAAG,4CAA4C,CAAC;AAE5E,2FAA2F;AAC3F,MAAM,uBAAuB,GAAG,mDAAmD,CAAC;AAEpF;;;;GAIG;AACH,MAAM,UAAU,GAAG,qCAAqC,CAAC;AAEzD;;;;GAIG;AACH,MAAa,0BAA2B,SAAQ,sBAAe;IAA/D;;QACE,yEAAyE;QACzE,iDAAiD;QACjD,YAAO,GAAG,IAAI,CAAC,aAAa,KAAK,0BAAa,CAAC,EAAE,CAAC;IAiKpD,CAAC;IA/JU,SAAS,CAAC,IAAa;QAC9B,IAAI,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE;YAC/B,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;SACnC;aAAM,IAAI,EAAE,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE;YACxC,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;SACrC;IACH,CAAC;IAEQ,aAAa,CAAC,QAA0B;QAC/C,IAAI,KAA8B,CAAC;QAEnC,OAAO,CAAC,KAAK,GAAG,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,IAAI,EAAE;YACvE,MAAM,gBAAgB,GAAG,IAAA,kDAA4B,EAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAE5E,IAAI,CAAC,YAAY,CACf,QAAQ,CAAC,QAAQ,EACjB,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC,KAAM,EAC7B,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EACf,yCAAyC,gBAAgB,IAAI,CAC9D,CAAC;SACH;QAED,OAAO,CAAC,KAAK,GAAG,uBAAuB,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,IAAI,EAAE;YACxE,MAAM,qBAAqB,GAAG,IAAA,wDAAkC,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3E,IAAI,CAAC,YAAY,CACf,QAAQ,CAAC,QAAQ,EACjB,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC,KAAM,EAC7B,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EACf,0CAA0C,qBAAqB,KAAK,CACrE,CAAC;SACH;IACH,CAAC;IAED,iGAAiG;IACzF,sBAAsB,CAAC,UAA+B;QAC5D,IAAI,CAAC,EAAE,CAAC,0BAA0B,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACnD,OAAO;SACR;QAED,yFAAyF;QACzF,MAAM,cAAc,GAAG,UAAU,CAAC,IAAmC,CAAC;QACtE,MAAM,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAErF,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE;YAC1B,OAAO;SACR;QAED,MAAM,cAAc,GAAG,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACvD,MAAM,YAAY,GAAG,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC,QAAQ,CAAC,CAAC;QAElF,IAAI,cAAc,KAAK,WAAW,IAAI,YAAY,KAAK,aAAa,EAAE;YACpE,IAAI,EAAE,CAAC,gBAAgB,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE;gBACzC,MAAM,YAAY,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACvD,MAAM,qBAAqB,GAAG,IAAA,kDAA4B,EAAC,YAAY,CAAC,CAAC;gBAEzE,4DAA4D;gBAC5D,IAAI,CAAC,YAAY,CACf,QAAQ,EACR,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,EAC9B,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,EAC9B,WAAW,CACZ,CAAC;gBAEF,8DAA8D;gBAC9D,IAAI,CAAC,YAAY,CACf,QAAQ,EACR,UAAU,CAAC,KAAK,CAAC,QAAQ,EAAE,EAC3B,UAAU,CAAC,KAAK,CAAC,QAAQ,EAAE,EAC3B,mBAAmB,qBAAqB,GAAG,CAC5C,CAAC;aACH;iBAAM;gBACL,mFAAmF;gBACnF,oFAAoF;gBACpF,oFAAoF;gBACpF,MAAM,aAAa,GAAG,IAAA,wDAAkC,EAAC,UAAU,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;gBAErF,4DAA4D;gBAC5D,IAAI,CAAC,YAAY,CACf,QAAQ,EACR,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,EAC9B,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,EAC9B,WAAW,CACZ,CAAC;gBAEF,8EAA8E;gBAC9E,IAAI,CAAC,YAAY,CACf,QAAQ,EACR,UAAU,CAAC,KAAK,CAAC,QAAQ,EAAE,EAC3B,UAAU,CAAC,KAAK,CAAC,QAAQ,EAAE,EAC3B,OAAO,UAAU,uBAAuB,aAAa,GAAG,CACzD,CAAC;aACH;SACF;IACH,CAAC;IAED;;;;OAIG;IACK,wBAAwB,CAAC,UAAiC;QAChE,sFAAsF;QACtF,kFAAkF;QAClF,yBAAyB;QACzB,IAAI,CAAC,EAAE,CAAC,yBAAyB,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;YACpD,OAAO;SACR;QAED,mEAAmE;QACnE,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,iBAAiB,EAAE;YACnD,OAAO;SACR;QAED,yFAAyF;QACzF,wFAAwF;QACxF,uFAAuF;QACvF,gCAAgC;QAEhC,MAAM,EAAC,WAAW,EAAE,IAAI,EAAC,GAAG,UAAU,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC,QAAQ,CAAC,CAAC;QAE9E,IAAI,EAAE,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE;YACpC,MAAM,YAAY,GAAG,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAClD,MAAM,qBAAqB,GAAG,IAAA,kDAA4B,EAAC,YAAY,CAAC,CAAC;YAEzE,gEAAgE;YAChE,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,WAAW,CAAC,CAAC;YAC3E,0EAA0E;YAC1E,IAAI,CAAC,YAAY,CACf,QAAQ,EACR,WAAW,CAAC,QAAQ,EAAE,EACtB,WAAW,CAAC,QAAQ,EAAE,EACtB,mBAAmB,qBAAqB,GAAG,CAC5C,CAAC;SACH;aAAM;YACL,mFAAmF;YACnF,oFAAoF;YACpF,oFAAoF;YACpF,MAAM,aAAa,GAAG,IAAA,wDAAkC,EAAC,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC;YAEhF,gEAAgE;YAChE,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,WAAW,CAAC,CAAC;YAE3E,8EAA8E;YAC9E,IAAI,CAAC,YAAY,CACf,QAAQ,EACR,WAAW,CAAC,QAAQ,EAAE,EACtB,WAAW,CAAC,QAAQ,EAAE,EACtB,OAAO,UAAU,uBAAuB,aAAa,GAAG,CACzD,CAAC;SACH;IACH,CAAC;IAEO,YAAY,CAAC,QAAuB,EAAE,KAAa,EAAE,KAAa,EAAE,OAAe;QACzF,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAChD,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC9B,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACvC,CAAC;CACF;AApKD,gEAoKC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Migration, ResolvedResource, TargetVersion, WorkspacePath} from '@angular/cdk/schematics';\nimport * as ts from 'typescript';\nimport {\n  convertSpeedFactorToDuration,\n  createSpeedFactorConvertExpression,\n} from './ripple-speed-factor';\n\n/** Regular expression that matches [matRippleSpeedFactor]=\"$NUMBER\" in templates. */\nconst speedFactorNumberRegex = /\\[matRippleSpeedFactor]=\"(\\d+(?:\\.\\d+)?)\"/g;\n\n/** Regular expression that matches [matRippleSpeedFactor]=\"$NOT_A_NUMBER\" in templates. */\nconst speedFactorNotParseable = /\\[matRippleSpeedFactor]=\"(?!\\d+(?:\\.\\d+)?\")(.*)\"/g;\n\n/**\n * Note that will be added whenever a speed factor expression has been converted to calculate\n * the according duration. This note should encourage people to clean up their code by switching\n * away from the speed factors to explicit durations.\n */\nconst removeNote = `TODO: Cleanup duration calculation.`;\n\n/**\n * Migration that walks through every property assignment and switches the global `baseSpeedFactor`\n * ripple option to the new global animation config. Also updates every class member assignment\n * that refers to MatRipple#speedFactor.\n */\nexport class RippleSpeedFactorMigration extends Migration<null> {\n  // Only enable this rule if the migration targets version 7 as the ripple\n  // speed factor has been removed in that version.\n  enabled = this.targetVersion === TargetVersion.V7;\n\n  override visitNode(node: ts.Node): void {\n    if (ts.isBinaryExpression(node)) {\n      this._visitBinaryExpression(node);\n    } else if (ts.isPropertyAssignment(node)) {\n      this._visitPropertyAssignment(node);\n    }\n  }\n\n  override visitTemplate(template: ResolvedResource): void {\n    let match: RegExpMatchArray | null;\n\n    while ((match = speedFactorNumberRegex.exec(template.content)) !== null) {\n      const newEnterDuration = convertSpeedFactorToDuration(parseFloat(match[1]));\n\n      this._replaceText(\n        template.filePath,\n        template.start + match.index!,\n        match[0].length,\n        `[matRippleAnimation]=\"{enterDuration: ${newEnterDuration}}\"`,\n      );\n    }\n\n    while ((match = speedFactorNotParseable.exec(template.content)) !== null) {\n      const newDurationExpression = createSpeedFactorConvertExpression(match[1]);\n      this._replaceText(\n        template.filePath,\n        template.start + match.index!,\n        match[0].length,\n        `[matRippleAnimation]=\"{enterDuration: (${newDurationExpression})}\"`,\n      );\n    }\n  }\n\n  /** Switches binary expressions (e.g. myRipple.speedFactor = 0.5) to the new animation config. */\n  private _visitBinaryExpression(expression: ts.BinaryExpression) {\n    if (!ts.isPropertyAccessExpression(expression.left)) {\n      return;\n    }\n\n    // Left side expression consists of target object and property name (e.g. myInstance.val)\n    const leftExpression = expression.left as ts.PropertyAccessExpression;\n    const targetTypeNode = this.typeChecker.getTypeAtLocation(leftExpression.expression);\n\n    if (!targetTypeNode.symbol) {\n      return;\n    }\n\n    const targetTypeName = targetTypeNode.symbol.getName();\n    const propertyName = leftExpression.name.getText();\n    const filePath = this.fileSystem.resolve(leftExpression.getSourceFile().fileName);\n\n    if (targetTypeName === 'MatRipple' && propertyName === 'speedFactor') {\n      if (ts.isNumericLiteral(expression.right)) {\n        const numericValue = parseFloat(expression.right.text);\n        const newEnterDurationValue = convertSpeedFactorToDuration(numericValue);\n\n        // Replace the `speedFactor` property name with `animation`.\n        this._replaceText(\n          filePath,\n          leftExpression.name.getStart(),\n          leftExpression.name.getWidth(),\n          'animation',\n        );\n\n        // Replace the value assignment with the new animation config.\n        this._replaceText(\n          filePath,\n          expression.right.getStart(),\n          expression.right.getWidth(),\n          `{enterDuration: ${newEnterDurationValue}}`,\n        );\n      } else {\n        // Handle the right expression differently if the previous speed factor value can't\n        // be resolved statically. In that case, we just create a TypeScript expression that\n        // calculates the explicit duration based on the non-static speed factor expression.\n        const newExpression = createSpeedFactorConvertExpression(expression.right.getText());\n\n        // Replace the `speedFactor` property name with `animation`.\n        this._replaceText(\n          filePath,\n          leftExpression.name.getStart(),\n          leftExpression.name.getWidth(),\n          'animation',\n        );\n\n        // Replace the value assignment with the new animation config and remove TODO.\n        this._replaceText(\n          filePath,\n          expression.right.getStart(),\n          expression.right.getWidth(),\n          `/** ${removeNote} */ {enterDuration: ${newExpression}}`,\n        );\n      }\n    }\n  }\n\n  /**\n   * Switches the global option `baseSpeedFactor` to the new animation config. For this\n   * we assume that the `baseSpeedFactor` is not used in combination with individual\n   * speed factors.\n   */\n  private _visitPropertyAssignment(assignment: ts.PropertyAssignment) {\n    // For switching the `baseSpeedFactor` global option we expect the property assignment\n    // to be inside of a normal object literal. Custom ripple global options cannot be\n    // witched automatically.\n    if (!ts.isObjectLiteralExpression(assignment.parent)) {\n      return;\n    }\n\n    // The assignment consists of a name (key) and initializer (value).\n    if (assignment.name.getText() !== 'baseSpeedFactor') {\n      return;\n    }\n\n    // We could technically lazily check for the MAT_RIPPLE_GLOBAL_OPTIONS injection token to\n    // be present, but it's not right to assume that everyone sets the ripple global options\n    // immediately in the provider object (e.g. it can happen that someone just imports the\n    // config from a separate file).\n\n    const {initializer, name} = assignment;\n    const filePath = this.fileSystem.resolve(assignment.getSourceFile().fileName);\n\n    if (ts.isNumericLiteral(initializer)) {\n      const numericValue = parseFloat(initializer.text);\n      const newEnterDurationValue = convertSpeedFactorToDuration(numericValue);\n\n      // Replace the `baseSpeedFactor` property name with `animation`.\n      this._replaceText(filePath, name.getStart(), name.getWidth(), 'animation');\n      // Replace the value assignment initializer with the new animation config.\n      this._replaceText(\n        filePath,\n        initializer.getStart(),\n        initializer.getWidth(),\n        `{enterDuration: ${newEnterDurationValue}}`,\n      );\n    } else {\n      // Handle the right expression differently if the previous speed factor value can't\n      // be resolved statically. In that case, we just create a TypeScript expression that\n      // calculates the explicit duration based on the non-static speed factor expression.\n      const newExpression = createSpeedFactorConvertExpression(initializer.getText());\n\n      // Replace the `baseSpeedFactor` property name with `animation`.\n      this._replaceText(filePath, name.getStart(), name.getWidth(), 'animation');\n\n      // Replace the value assignment with the new animation config and remove TODO.\n      this._replaceText(\n        filePath,\n        initializer.getStart(),\n        initializer.getWidth(),\n        `/** ${removeNote} */ {enterDuration: ${newExpression}}`,\n      );\n    }\n  }\n\n  private _replaceText(filePath: WorkspacePath, start: number, width: number, newText: string) {\n    const recorder = this.fileSystem.edit(filePath);\n    recorder.remove(start, width);\n    recorder.insertRight(start, newText);\n  }\n}\n"]}