@angular/material
Version:
Angular Material
147 lines • 25.5 kB
JavaScript
/**
* @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
*/
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define("@angular/material/schematics/ng-update/upgrade-rules/misc-ripples-v7/ripple-speed-factor-rule", ["require", "exports", "@angular/cdk/schematics", "typescript", "@angular/material/schematics/ng-update/upgrade-rules/misc-ripples-v7/ripple-speed-factor"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const schematics_1 = require("@angular/cdk/schematics");
const ts = require("typescript");
const ripple_speed_factor_1 = require("@angular/material/schematics/ng-update/upgrade-rules/misc-ripples-v7/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.`;
/**
* Rule 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 RippleSpeedFactorRule extends schematics_1.MigrationRule {
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.ruleEnabled = 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 = 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 = 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 = leftExpression.getSourceFile().fileName;
if (targetTypeName === 'MatRipple' && propertyName === 'speedFactor') {
if (ts.isNumericLiteral(expression.right)) {
const numericValue = parseFloat(expression.right.text);
const newEnterDurationValue = 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 = 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 = assignment.getSourceFile().fileName;
if (ts.isNumericLiteral(initializer)) {
const numericValue = parseFloat(initializer.text);
const newEnterDurationValue = 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 = 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.getUpdateRecorder(filePath);
recorder.remove(start, width);
recorder.insertRight(start, newText);
}
}
exports.RippleSpeedFactorRule = RippleSpeedFactorRule;
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple-speed-factor-rule.js","sourceRoot":"","sources":["../../../../../../../../../src/material/schematics/ng-update/upgrade-rules/misc-ripples-v7/ripple-speed-factor-rule.ts"],"names":[],"mappings":"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","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 {MigrationRule, ResolvedResource, TargetVersion} 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 * Rule 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 RippleSpeedFactorRule extends MigrationRule<null> {\n\n  // Only enable this rule if the migration targets version 7 as the ripple\n  // speed factor has been removed in that version.\n  ruleEnabled = this.targetVersion === TargetVersion.V7;\n\n  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  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, template.start + match.index!, match[0].length,\n          `[matRippleAnimation]=\"{enterDuration: ${newEnterDuration}}\"`);\n    }\n\n    while ((match = speedFactorNotParseable.exec(template.content)) !== null) {\n      const newDurationExpression = createSpeedFactorConvertExpression(match[1]);\n      this._replaceText(\n          template.filePath, template.start + match.index!, match[0].length,\n          `[matRippleAnimation]=\"{enterDuration: (${newDurationExpression})}\"`);\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 = 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, leftExpression.name.getStart(), leftExpression.name.getWidth(), 'animation');\n\n        // Replace the value assignment with the new animation config.\n        this._replaceText(\n            filePath, expression.right.getStart(), expression.right.getWidth(),\n            `{enterDuration: ${newEnterDurationValue}}`);\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, leftExpression.name.getStart(), leftExpression.name.getWidth(), 'animation');\n\n        // Replace the value assignment with the new animation config and remove TODO.\n        this._replaceText(\n            filePath, expression.right.getStart(), expression.right.getWidth(),\n            `/** ${removeNote} */ {enterDuration: ${newExpression}}`);\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 = 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, initializer.getStart(), initializer.getWidth(),\n          `{enterDuration: ${newEnterDurationValue}}`);\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, initializer.getStart(), initializer.getWidth(),\n          `/** ${removeNote} */ {enterDuration: ${newExpression}}`);\n    }\n  }\n\n  private _replaceText(filePath: string, start: number, width: number, newText: string) {\n    const recorder = this.getUpdateRecorder(filePath);\n    recorder.remove(start, width);\n    recorder.insertRight(start, newText);\n  }\n}\n"]}