@angular/material/schematics/ng-update/migrations/theming-api-v12/migration.mjs

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.migrateFileContent = void 0;
const config_1 = require("./config");
/**
 * Migrates the content of a file to the new theming API. Note that this migration is using plain
 * string manipulation, rather than the AST from PostCSS and the schematics string manipulation
 * APIs, because it allows us to run it inside g3 and to avoid introducing new dependencies.
 * @param content Content of the file.
 * @param oldMaterialPrefix Prefix with which the old Material imports should start.
 *   Has to end with a slash. E.g. if `@import '~@angular/material/theming'` should be
 *   matched, the prefix would be `~@angular/material/`.
 * @param oldCdkPrefix Prefix with which the old CDK imports should start.
 *   Has to end with a slash. E.g. if `@import '~@angular/cdk/overlay'` should be
 *   matched, the prefix would be `~@angular/cdk/`.
 * @param newMaterialImportPath New import to the Material theming API (e.g. `~@angular/material`).
 * @param newCdkImportPath New import to the CDK Sass APIs (e.g. `~@angular/cdk`).
 */
function migrateFileContent(content, oldMaterialPrefix, oldCdkPrefix, newMaterialImportPath, newCdkImportPath) {
    const materialResults = detectImports(content, oldMaterialPrefix);
    const cdkResults = detectImports(content, oldCdkPrefix);
    // Try to migrate the symbols even if there are no imports. This is used
    // to cover the case where the Components symbols were used transitively.
    content = migrateMaterialSymbols(content, newMaterialImportPath, materialResults);
    content = migrateCdkSymbols(content, newCdkImportPath, cdkResults);
    content = replaceRemovedVariables(content, config_1.removedMaterialVariables);
    // We can assume that the migration has taken care of any Components symbols that were
    // imported transitively so we can always drop the old imports. We also assume that imports
    // to the new entry points have been added already.
    if (materialResults.imports.length) {
        content = replaceRemovedVariables(content, config_1.unprefixedRemovedVariables);
        content = removeStrings(content, materialResults.imports);
    }
    if (cdkResults.imports.length) {
        content = removeStrings(content, cdkResults.imports);
    }
    return content;
}
exports.migrateFileContent = migrateFileContent;
/**
 * Counts the number of imports with a specific prefix and extracts their namespaces.
 * @param content File content in which to look for imports.
 * @param prefix Prefix that the imports should start with.
 */
function detectImports(content, prefix) {
    if (prefix[prefix.length - 1] !== '/') {
        // Some of the logic further down makes assumptions about the import depth.
        throw Error(`Prefix "${prefix}" has to end in a slash.`);
    }
    // List of `@use` namespaces from which Angular CDK/Material APIs may be referenced.
    // Since we know that the library doesn't have any name collisions, we can treat all of these
    // namespaces as equivalent.
    const namespaces = [];
    const imports = [];
    const pattern = new RegExp(`@(import|use) +['"]${escapeRegExp(prefix)}.*['"].*;?\n`, 'g');
    let match = null;
    while (match = pattern.exec(content)) {
        const [fullImport, type] = match;
        if (type === 'use') {
            const namespace = extractNamespaceFromUseStatement(fullImport);
            if (namespaces.indexOf(namespace) === -1) {
                namespaces.push(namespace);
            }
        }
        imports.push(fullImport);
    }
    return { imports, namespaces };
}
/** Migrates the Material symbols in a file. */
function migrateMaterialSymbols(content, importPath, detectedImports) {
    const initialContent = content;
    const namespace = 'mat';
    // Migrate the mixins.
    content = renameSymbols(content, config_1.materialMixins, detectedImports.namespaces, mixinKeyFormatter, getMixinValueFormatter(namespace));
    // Migrate the functions.
    content = renameSymbols(content, config_1.materialFunctions, detectedImports.namespaces, functionKeyFormatter, getFunctionValueFormatter(namespace));
    // Migrate the variables.
    content = renameSymbols(content, config_1.materialVariables, detectedImports.namespaces, variableKeyFormatter, getVariableValueFormatter(namespace));
    if (content !== initialContent) {
        // Add an import to the new API only if any of the APIs were being used.
        content = insertUseStatement(content, importPath, detectedImports.imports, namespace);
    }
    return content;
}
/** Migrates the CDK symbols in a file. */
function migrateCdkSymbols(content, importPath, detectedImports) {
    const initialContent = content;
    const namespace = 'cdk';
    // Migrate the mixins.
    content = renameSymbols(content, config_1.cdkMixins, detectedImports.namespaces, mixinKeyFormatter, getMixinValueFormatter(namespace));
    // Migrate the variables.
    content = renameSymbols(content, config_1.cdkVariables, detectedImports.namespaces, variableKeyFormatter, getVariableValueFormatter(namespace));
    // Previously the CDK symbols were exposed through `material/theming`, but now we have a
    // dedicated entrypoint for the CDK. Only add an import for it if any of the symbols are used.
    if (content !== initialContent) {
        content = insertUseStatement(content, importPath, detectedImports.imports, namespace);
    }
    return content;
}
/**
 * Renames all Sass symbols in a file based on a pre-defined mapping.
 * @param content Content of a file to be migrated.
 * @param mapping Mapping between symbol names and their replacements.
 * @param namespaces Names to iterate over and pass to getKeyPattern.
 * @param getKeyPattern Function used to turn each of the keys into a regex.
 * @param formatValue Formats the value that will replace any matches of the pattern returned by
 *  `getKeyPattern`.
 */
function renameSymbols(content, mapping, namespaces, getKeyPattern, formatValue) {
    // The null at the end is so that we make one last pass to cover non-namespaced symbols.
    [...namespaces.slice().sort(sortLengthDescending), null].forEach(namespace => {
        // Migrate the longest keys first so that our regex-based replacements don't accidentally
        // capture keys that contain other keys. E.g. `$mat-blue` is contained within `$mat-blue-grey`.
        Object.keys(mapping).sort(sortLengthDescending).forEach(key => {
            const pattern = getKeyPattern(namespace, key);
            // Sanity check since non-global regexes will only replace the first match.
            if (pattern.flags.indexOf('g') === -1) {
                throw Error('Replacement pattern must be global.');
            }
            content = content.replace(pattern, formatValue(mapping[key]));
        });
    });
    return content;
}
/** Inserts an `@use` statement in a string. */
function insertUseStatement(content, importPath, importsToIgnore, namespace) {
    // We want to find the first import that isn't in the list of ignored imports or find nothing,
    // because the imports being replaced might be the only ones in the file and they can be further
    // down. An easy way to do this is to replace the imports with a random character and run
    // `indexOf` on the result. This isn't the most efficient way of doing it, but it's more compact
    // and it allows us to easily deal with things like comment nodes.
    const contentToSearch = importsToIgnore.reduce((accumulator, current) => accumulator.replace(current, '◬'.repeat(current.length)), content);
    // Sass has a limitation that all `@use` declarations have to come before `@import` so we have
    // to find the first import and insert before it. Technically we can get away with always
    // inserting at 0, but the file may start with something like a license header.
    const newImportIndex = Math.max(0, contentToSearch.indexOf('@import '));
    return content.slice(0, newImportIndex) + `@use '${importPath}' as ${namespace};\n` +
        content.slice(newImportIndex);
}
/** Formats a migration key as a Sass mixin invocation. */
function mixinKeyFormatter(namespace, name) {
    // Note that adding a `(` at the end of the pattern would be more accurate, but mixin
    // invocations don't necessarily have to include the parentheses. We could add `[(;]`,
    // but then we won't know which character to include in the replacement string.
    return new RegExp(`@include +${escapeRegExp((namespace ? namespace + '.' : '') + name)}`, 'g');
}
/** Returns a function that can be used to format a Sass mixin replacement. */
function getMixinValueFormatter(namespace) {
    // Note that adding a `(` at the end of the pattern would be more accurate,
    // but mixin invocations don't necessarily have to include the parentheses.
    return name => `@include ${namespace}.${name}`;
}
/** Formats a migration key as a Sass function invocation. */
function functionKeyFormatter(namespace, name) {
    return new RegExp(escapeRegExp(`${namespace ? namespace + '.' : ''}${name}(`), 'g');
}
/** Returns a function that can be used to format a Sass function replacement. */
function getFunctionValueFormatter(namespace) {
    return name => `${namespace}.${name}(`;
}
/** Formats a migration key as a Sass variable. */
function variableKeyFormatter(namespace, name) {
    return new RegExp(escapeRegExp(`${namespace ? namespace + '.' : ''}$${name}`), 'g');
}
/** Returns a function that can be used to format a Sass variable replacement. */
function getVariableValueFormatter(namespace) {
    return name => `${namespace}.$${name}`;
}
/** Escapes special regex characters in a string. */
function escapeRegExp(str) {
    return str.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
}
/** Used with `Array.prototype.sort` to order strings in descending length. */
function sortLengthDescending(a, b) {
    return b.length - a.length;
}
/** Removes all strings from another string. */
function removeStrings(content, toRemove) {
    return toRemove
        .reduce((accumulator, current) => accumulator.replace(current, ''), content)
        .replace(/^\s+/, '');
}
/** Parses out the namespace from a Sass `@use` statement. */
function extractNamespaceFromUseStatement(fullImport) {
    const closeQuoteIndex = Math.max(fullImport.lastIndexOf(`"`), fullImport.lastIndexOf(`'`));
    if (closeQuoteIndex > -1) {
        const asExpression = 'as ';
        const asIndex = fullImport.indexOf(asExpression, closeQuoteIndex);
        // If we found an ` as ` expression, we consider the rest of the text as the namespace.
        if (asIndex > -1) {
            return fullImport.slice(asIndex + asExpression.length).split(';')[0].trim();
        }
        // Otherwise the namespace is the name of the file that is being imported.
        const lastSlashIndex = fullImport.lastIndexOf('/', closeQuoteIndex);
        if (lastSlashIndex > -1) {
            const fileName = fullImport.slice(lastSlashIndex + 1, closeQuoteIndex)
                // Sass allows for leading underscores to be omitted and it technically supports .scss.
                .replace(/^_|(\.import)?\.scss$|\.import$/g, '');
            // Sass ignores `/index` and infers the namespace as the next segment in the path.
            if (fileName === 'index') {
                const nextSlashIndex = fullImport.lastIndexOf('/', lastSlashIndex - 1);
                if (nextSlashIndex > -1) {
                    return fullImport.slice(nextSlashIndex + 1, lastSlashIndex);
                }
            }
            else {
                return fileName;
            }
        }
    }
    throw Error(`Could not extract namespace from import "${fullImport}".`);
}
/**
 * Replaces variables that have been removed with their values.
 * @param content Content of the file to be migrated.
 * @param variables Mapping between variable names and their values.
 */
function replaceRemovedVariables(content, variables) {
    Object.keys(variables).sort(sortLengthDescending).forEach(variableName => {
        // Note that the pattern uses a negative lookahead to exclude
        // variable assignments, because they can't be migrated.
        const regex = new RegExp(`\\$${escapeRegExp(variableName)}(?!\\s+:|:)`, 'g');
        content = content.replace(regex, variables[variableName]);
    });
    return content;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migration.js","sourceRoot":"","sources":["../../../../../../../../../src/material/schematics/ng-update/migrations/theming-api-v12/migration.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 {\n  materialMixins,\n  materialFunctions,\n  materialVariables,\n  cdkMixins,\n  cdkVariables,\n  removedMaterialVariables,\n  unprefixedRemovedVariables\n} from './config';\n\n/** The result of a search for imports and namespaces in a file. */\ninterface DetectImportResult {\n  imports: string[];\n  namespaces: string[];\n}\n\n/**\n * Migrates the content of a file to the new theming API. Note that this migration is using plain\n * string manipulation, rather than the AST from PostCSS and the schematics string manipulation\n * APIs, because it allows us to run it inside g3 and to avoid introducing new dependencies.\n * @param content Content of the file.\n * @param oldMaterialPrefix Prefix with which the old Material imports should start.\n *   Has to end with a slash. E.g. if `@import '~@angular/material/theming'` should be\n *   matched, the prefix would be `~@angular/material/`.\n * @param oldCdkPrefix Prefix with which the old CDK imports should start.\n *   Has to end with a slash. E.g. if `@import '~@angular/cdk/overlay'` should be\n *   matched, the prefix would be `~@angular/cdk/`.\n * @param newMaterialImportPath New import to the Material theming API (e.g. `~@angular/material`).\n * @param newCdkImportPath New import to the CDK Sass APIs (e.g. `~@angular/cdk`).\n */\nexport function migrateFileContent(content: string,\n                                   oldMaterialPrefix: string,\n                                   oldCdkPrefix: string,\n                                   newMaterialImportPath: string,\n                                   newCdkImportPath: string): string {\n  const materialResults = detectImports(content, oldMaterialPrefix);\n  const cdkResults = detectImports(content, oldCdkPrefix);\n\n  // Try to migrate the symbols even if there are no imports. This is used\n  // to cover the case where the Components symbols were used transitively.\n  content = migrateMaterialSymbols(content, newMaterialImportPath, materialResults);\n  content = migrateCdkSymbols(content, newCdkImportPath, cdkResults);\n  content = replaceRemovedVariables(content, removedMaterialVariables);\n\n  // We can assume that the migration has taken care of any Components symbols that were\n  // imported transitively so we can always drop the old imports. We also assume that imports\n  // to the new entry points have been added already.\n  if (materialResults.imports.length) {\n    content = replaceRemovedVariables(content, unprefixedRemovedVariables);\n    content = removeStrings(content, materialResults.imports);\n  }\n\n  if (cdkResults.imports.length) {\n    content = removeStrings(content, cdkResults.imports);\n  }\n\n  return content;\n}\n\n/**\n * Counts the number of imports with a specific prefix and extracts their namespaces.\n * @param content File content in which to look for imports.\n * @param prefix Prefix that the imports should start with.\n */\nfunction detectImports(content: string, prefix: string): DetectImportResult {\n  if (prefix[prefix.length - 1] !== '/') {\n    // Some of the logic further down makes assumptions about the import depth.\n    throw Error(`Prefix \"${prefix}\" has to end in a slash.`);\n  }\n\n  // List of `@use` namespaces from which Angular CDK/Material APIs may be referenced.\n  // Since we know that the library doesn't have any name collisions, we can treat all of these\n  // namespaces as equivalent.\n  const namespaces: string[] = [];\n  const imports: string[] = [];\n  const pattern = new RegExp(`@(import|use) +['\"]${escapeRegExp(prefix)}.*['\"].*;?\\n`, 'g');\n  let match: RegExpExecArray | null = null;\n\n  while (match = pattern.exec(content)) {\n    const [fullImport, type] = match;\n\n    if (type === 'use') {\n      const namespace = extractNamespaceFromUseStatement(fullImport);\n\n      if (namespaces.indexOf(namespace) === -1) {\n        namespaces.push(namespace);\n      }\n    }\n\n    imports.push(fullImport);\n  }\n\n  return {imports, namespaces};\n}\n\n/** Migrates the Material symbols in a file. */\nfunction migrateMaterialSymbols(content: string, importPath: string,\n                                detectedImports: DetectImportResult): string {\n  const initialContent = content;\n  const namespace = 'mat';\n\n  // Migrate the mixins.\n  content = renameSymbols(content, materialMixins, detectedImports.namespaces, mixinKeyFormatter,\n    getMixinValueFormatter(namespace));\n\n  // Migrate the functions.\n  content = renameSymbols(content, materialFunctions, detectedImports.namespaces,\n    functionKeyFormatter, getFunctionValueFormatter(namespace));\n\n  // Migrate the variables.\n  content = renameSymbols(content, materialVariables, detectedImports.namespaces,\n    variableKeyFormatter, getVariableValueFormatter(namespace));\n\n  if (content !== initialContent) {\n    // Add an import to the new API only if any of the APIs were being used.\n    content = insertUseStatement(content, importPath, detectedImports.imports, namespace);\n  }\n\n  return content;\n}\n\n/** Migrates the CDK symbols in a file. */\nfunction migrateCdkSymbols(content: string, importPath: string,\n                           detectedImports: DetectImportResult): string {\n  const initialContent = content;\n  const namespace = 'cdk';\n\n  // Migrate the mixins.\n  content = renameSymbols(content, cdkMixins, detectedImports.namespaces, mixinKeyFormatter,\n    getMixinValueFormatter(namespace));\n\n  // Migrate the variables.\n  content = renameSymbols(content, cdkVariables, detectedImports.namespaces, variableKeyFormatter,\n    getVariableValueFormatter(namespace));\n\n  // Previously the CDK symbols were exposed through `material/theming`, but now we have a\n  // dedicated entrypoint for the CDK. Only add an import for it if any of the symbols are used.\n  if (content !== initialContent) {\n    content = insertUseStatement(content, importPath, detectedImports.imports, namespace);\n  }\n\n  return content;\n}\n\n/**\n * Renames all Sass symbols in a file based on a pre-defined mapping.\n * @param content Content of a file to be migrated.\n * @param mapping Mapping between symbol names and their replacements.\n * @param namespaces Names to iterate over and pass to getKeyPattern.\n * @param getKeyPattern Function used to turn each of the keys into a regex.\n * @param formatValue Formats the value that will replace any matches of the pattern returned by\n *  `getKeyPattern`.\n */\nfunction renameSymbols(content: string,\n                       mapping: Record<string, string>,\n                       namespaces: string[],\n                       getKeyPattern: (namespace: string|null, key: string) => RegExp,\n                       formatValue: (key: string) => string): string {\n  // The null at the end is so that we make one last pass to cover non-namespaced symbols.\n  [...namespaces.slice().sort(sortLengthDescending), null].forEach(namespace => {\n    // Migrate the longest keys first so that our regex-based replacements don't accidentally\n    // capture keys that contain other keys. E.g. `$mat-blue` is contained within `$mat-blue-grey`.\n    Object.keys(mapping).sort(sortLengthDescending).forEach(key => {\n      const pattern = getKeyPattern(namespace, key);\n\n      // Sanity check since non-global regexes will only replace the first match.\n      if (pattern.flags.indexOf('g') === -1) {\n        throw Error('Replacement pattern must be global.');\n      }\n\n      content = content.replace(pattern, formatValue(mapping[key]));\n    });\n  });\n\n  return content;\n}\n\n/** Inserts an `@use` statement in a string. */\nfunction insertUseStatement(content: string, importPath: string, importsToIgnore: string[],\n                            namespace: string): string {\n  // We want to find the first import that isn't in the list of ignored imports or find nothing,\n  // because the imports being replaced might be the only ones in the file and they can be further\n  // down. An easy way to do this is to replace the imports with a random character and run\n  // `indexOf` on the result. This isn't the most efficient way of doing it, but it's more compact\n  // and it allows us to easily deal with things like comment nodes.\n  const contentToSearch = importsToIgnore.reduce((accumulator, current) =>\n    accumulator.replace(current, '◬'.repeat(current.length)), content);\n\n  // Sass has a limitation that all `@use` declarations have to come before `@import` so we have\n  // to find the first import and insert before it. Technically we can get away with always\n  // inserting at 0, but the file may start with something like a license header.\n  const newImportIndex = Math.max(0, contentToSearch.indexOf('@import '));\n\n  return content.slice(0, newImportIndex) + `@use '${importPath}' as ${namespace};\\n` +\n         content.slice(newImportIndex);\n}\n\n/** Formats a migration key as a Sass mixin invocation. */\nfunction mixinKeyFormatter(namespace: string|null, name: string): RegExp {\n  // Note that adding a `(` at the end of the pattern would be more accurate, but mixin\n  // invocations don't necessarily have to include the parentheses. We could add `[(;]`,\n  // but then we won't know which character to include in the replacement string.\n  return new RegExp(`@include +${escapeRegExp((namespace ? namespace + '.' : '') + name)}`, 'g');\n}\n\n/** Returns a function that can be used to format a Sass mixin replacement. */\nfunction getMixinValueFormatter(namespace: string): (name: string) => string {\n  // Note that adding a `(` at the end of the pattern would be more accurate,\n  // but mixin invocations don't necessarily have to include the parentheses.\n  return name => `@include ${namespace}.${name}`;\n}\n\n/** Formats a migration key as a Sass function invocation. */\nfunction functionKeyFormatter(namespace: string|null, name: string): RegExp {\n  return new RegExp(escapeRegExp(`${namespace ? namespace + '.' : ''}${name}(`), 'g');\n}\n\n/** Returns a function that can be used to format a Sass function replacement. */\nfunction getFunctionValueFormatter(namespace: string): (name: string) => string {\n  return name => `${namespace}.${name}(`;\n}\n\n/** Formats a migration key as a Sass variable. */\nfunction variableKeyFormatter(namespace: string|null, name: string): RegExp {\n  return new RegExp(escapeRegExp(`${namespace ? namespace + '.' : ''}$${name}`), 'g');\n}\n\n/** Returns a function that can be used to format a Sass variable replacement. */\nfunction getVariableValueFormatter(namespace: string): (name: string) => string {\n  return name => `${namespace}.$${name}`;\n}\n\n/** Escapes special regex characters in a string. */\nfunction escapeRegExp(str: string): string {\n  return str.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n}\n\n/** Used with `Array.prototype.sort` to order strings in descending length. */\nfunction sortLengthDescending(a: string, b: string) {\n  return b.length - a.length;\n}\n\n/** Removes all strings from another string. */\nfunction removeStrings(content: string, toRemove: string[]): string {\n  return toRemove\n    .reduce((accumulator, current) => accumulator.replace(current, ''), content)\n    .replace(/^\\s+/, '');\n}\n\n/** Parses out the namespace from a Sass `@use` statement. */\nfunction extractNamespaceFromUseStatement(fullImport: string): string {\n  const closeQuoteIndex = Math.max(fullImport.lastIndexOf(`\"`), fullImport.lastIndexOf(`'`));\n\n  if (closeQuoteIndex > -1) {\n    const asExpression = 'as ';\n    const asIndex = fullImport.indexOf(asExpression, closeQuoteIndex);\n\n    // If we found an ` as ` expression, we consider the rest of the text as the namespace.\n    if (asIndex > -1) {\n      return fullImport.slice(asIndex + asExpression.length).split(';')[0].trim();\n    }\n\n    // Otherwise the namespace is the name of the file that is being imported.\n    const lastSlashIndex = fullImport.lastIndexOf('/', closeQuoteIndex);\n\n    if (lastSlashIndex > -1) {\n      const fileName = fullImport.slice(lastSlashIndex + 1, closeQuoteIndex)\n        // Sass allows for leading underscores to be omitted and it technically supports .scss.\n        .replace(/^_|(\\.import)?\\.scss$|\\.import$/g, '');\n\n      // Sass ignores `/index` and infers the namespace as the next segment in the path.\n      if (fileName === 'index') {\n        const nextSlashIndex = fullImport.lastIndexOf('/', lastSlashIndex - 1);\n\n        if (nextSlashIndex > -1) {\n          return fullImport.slice(nextSlashIndex + 1, lastSlashIndex);\n        }\n      } else {\n        return fileName;\n      }\n    }\n  }\n\n  throw Error(`Could not extract namespace from import \"${fullImport}\".`);\n}\n\n/**\n * Replaces variables that have been removed with their values.\n * @param content Content of the file to be migrated.\n * @param variables Mapping between variable names and their values.\n */\nfunction replaceRemovedVariables(content: string, variables: Record<string, string>): string {\n  Object.keys(variables).sort(sortLengthDescending).forEach(variableName => {\n    // Note that the pattern uses a negative lookahead to exclude\n    // variable assignments, because they can't be migrated.\n    const regex = new RegExp(`\\\\$${escapeRegExp(variableName)}(?!\\\\s+:|:)`, 'g');\n    content = content.replace(regex, variables[variableName]);\n  });\n\n  return content;\n}\n"]}