@angular-devkit/build-angular 12.1.0-next.3 → 12.1.0

package/package.json

@@ -1,89 +1,90 @@
 {
   "name": "@angular-devkit/build-angular",
-  "version": "12.1.0-next.3",
+  "version": "12.1.0",
   "description": "Angular Webpack Build Facade",
   "main": "src/index.js",
   "typings": "src/index.d.ts",
   "builders": "builders.json",
   "dependencies": {
-    "@angular-devkit/architect": "0.1201.0-next.3",
-    "@angular-devkit/build-optimizer": "0.1201.0-next.3",
-    "@angular-devkit/build-webpack": "0.1201.0-next.3",
-    "@angular-devkit/core": "12.1.0-next.3",
-    "@babel/core": "7.14.3",
-    "@babel/generator": "7.14.3",
-    "@babel/plugin-transform-async-to-generator": "7.13.0",
-    "@babel/plugin-transform-runtime": "7.14.3",
-    "@babel/preset-env": "7.14.2",
-    "@babel/runtime": "7.14.0",
-    "@babel/template": "7.12.13",
+    "@angular-devkit/architect": "0.1201.0",
+    "@angular-devkit/build-optimizer": "0.1201.0",
+    "@angular-devkit/build-webpack": "0.1201.0",
+    "@angular-devkit/core": "12.1.0",
+    "@babel/core": "7.14.6",
+    "@babel/generator": "7.14.5",
+    "@babel/helper-annotate-as-pure": "7.14.5",
+    "@babel/plugin-transform-async-to-generator": "7.14.5",
+    "@babel/plugin-transform-runtime": "7.14.5",
+    "@babel/preset-env": "7.14.7",
+    "@babel/runtime": "7.14.6",
+    "@babel/template": "7.14.5",
     "@discoveryjs/json-ext": "0.5.3",
     "@jsdevtools/coverage-istanbul-loader": "3.0.5",
-    "@ngtools/webpack": "12.1.0-next.3",
+    "@ngtools/webpack": "12.1.0",
     "ansi-colors": "4.1.1",
     "babel-loader": "8.2.2",
     "browserslist": "^4.9.1",
-    "cacache": "15.0.6",
+    "cacache": "15.2.0",
     "caniuse-lite": "^1.0.30001032",
     "circular-dependency-plugin": "5.2.2",
     "copy-webpack-plugin": "9.0.0",
-    "core-js": "3.12.1",
+    "core-js": "3.15.1",
     "critters": "0.0.10",
-    "css-loader": "5.2.4",
-    "css-minimizer-webpack-plugin": "3.0.0",
+    "css-loader": "5.2.6",
+    "css-minimizer-webpack-plugin": "3.0.1",
     "find-cache-dir": "3.3.1",
     "glob": "7.1.7",
     "https-proxy-agent": "5.0.0",
-    "inquirer": "8.0.0",
-    "jest-worker": "27.0.1",
+    "inquirer": "8.1.1",
+    "jest-worker": "27.0.2",
     "karma-source-map-support": "1.4.0",
     "less": "4.1.1",
-    "less-loader": "9.0.0",
-    "license-webpack-plugin": "2.3.18",
+    "less-loader": "10.0.0",
+    "license-webpack-plugin": "2.3.19",
     "loader-utils": "2.0.0",
     "mini-css-extract-plugin": "1.6.0",
     "minimatch": "3.0.4",
-    "open": "8.0.9",
-    "ora": "5.4.0",
+    "open": "8.2.1",
+    "ora": "5.4.1",
     "parse5-html-rewriting-stream": "6.0.1",
-    "postcss": "8.2.15",
+    "postcss": "8.3.5",
     "postcss-import": "14.0.2",
-    "postcss-loader": "5.3.0",
+    "postcss-loader": "6.1.0",
     "postcss-preset-env": "6.7.0",
     "raw-loader": "4.0.2",
     "regenerator-runtime": "0.13.7",
     "resolve-url-loader": "4.0.0",
-    "rimraf": "3.0.2",
     "rxjs": "6.6.7",
-    "sass": "1.32.13",
-    "sass-loader": "11.1.1",
+    "sass": "1.35.1",
+    "sass-loader": "12.1.0",
     "semver": "7.3.5",
     "source-map": "0.7.3",
     "source-map-loader": "3.0.0",
     "source-map-support": "0.5.19",
     "style-loader": "2.0.0",
     "stylus": "0.54.8",
-    "stylus-loader": "6.0.0",
+    "stylus-loader": "6.1.0",
     "terser": "5.7.0",
-    "terser-webpack-plugin": "5.1.2",
+    "terser-webpack-plugin": "5.1.3",
     "text-table": "0.2.0",
     "tree-kill": "1.2.2",
-    "webpack": "5.37.0",
-    "webpack-dev-middleware": "4.2.0",
+    "tslib": "2.3.0",
+    "webpack": "5.40.0",
+    "webpack-dev-middleware": "5.0.0",
     "webpack-dev-server": "3.11.2",
-    "webpack-merge": "5.7.3",
+    "webpack-merge": "5.8.0",
     "webpack-subresource-integrity": "1.5.2"
   },
   "peerDependencies": {
-    "@angular/compiler-cli": "^12.0.0-next",
-    "@angular/localize": "^12.0.0-next",
-    "@angular/service-worker": "^12.0.0-next",
+    "@angular/compiler-cli": "^12.0.0 || ^12.1.0-next",
+    "@angular/localize": "^12.0.0 || ^12.1.0-next",
+    "@angular/service-worker": "^12.0.0 || ^12.1.0-next",
     "karma": "^6.3.0",
-    "ng-packagr": "^12.0.0-next",
+    "ng-packagr": "^12.0.0 || ^12.1.0-next",
     "protractor": "^7.0.0",
     "tailwindcss": "^2.0.0",
     "tslint": "^6.1.0",
-    "typescript": "~4.2.3"
+    "typescript": "~4.2.3 || ~4.3.2"
   },
   "peerDependenciesMeta": {
     "@angular/localize": {
@@ -120,7 +121,7 @@
     "url": "https://github.com/angular/angular-cli.git"
   },
   "engines": {
-    "node": "^12.14.1 || ^14.0.0",
+    "node": "^12.14.1 || >=14.0.0",
     "npm": "^6.11.0 || ^7.5.6",
     "yarn": ">= 1.13.0"
   },

package/src/app-shell/index.js

@@ -6,11 +6,30 @@
  * 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
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const architect_1 = require("@angular-devkit/architect");
 const core_1 = require("@angular-devkit/core");
-const fs = require("fs");
-const path = require("path");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const utils_1 = require("../utils");
 const inline_critical_css_1 = require("../utils/index-file/inline-critical-css");
 const service_worker_1 = require("../utils/service-worker");
@@ -24,7 +43,7 @@ async function _renderUniversal(options, context, browserResult, serverResult, s
     // Initialize zone.js
     const root = context.workspaceRoot;
     const zonePackage = require.resolve('zone.js', { paths: [root] });
-    await Promise.resolve().then(() => require(zonePackage));
+    await Promise.resolve().then(() => __importStar(require(zonePackage)));
     const projectName = context.target && context.target.project;
     if (!projectName) {
         throw new Error('The builder requires a target.');
@@ -43,7 +62,7 @@ async function _renderUniversal(options, context, browserResult, serverResult, s
         const browserIndexOutputPath = path.join(outputPath, 'index.html');
         const indexHtml = await fs.promises.readFile(browserIndexOutputPath, 'utf8');
         const serverBundlePath = await _getServerModuleBundlePath(options, context, serverResult, localeDirectory);
-        const { AppServerModule, renderModule } = await Promise.resolve().then(() => require(serverBundlePath));
+        const { AppServerModule, renderModule } = await Promise.resolve().then(() => __importStar(require(serverBundlePath)));
         const renderModuleFn = renderModule;
         if (!(renderModuleFn && AppServerModule)) {
             throw new Error(`renderModule method and/or AppServerModule were not exported from: ${serverBundlePath}.`);
@@ -111,9 +130,10 @@ async function _appShellBuilder(options, context) {
     });
     let spinner;
     try {
+        // Using `.result` instead of `.output` causes Webpack FS cache not to be created.
         const [browserResult, serverResult] = await Promise.all([
-            browserTargetRun.result,
-            serverTargetRun.result,
+            browserTargetRun.output.toPromise(),
+            serverTargetRun.output.toPromise(),
         ]);
         if (browserResult.success === false || browserResult.baseOutputPath === undefined) {
             return browserResult;
@@ -132,8 +152,8 @@ async function _appShellBuilder(options, context) {
         return { success: false, error: err.message };
     }
     finally {
-        // Just be good citizens and stop those jobs.
-        await Promise.all([browserTargetRun.stop(), serverTargetRun.stop()]);
+        // workaround for [tsetse] All Promises in async functions must either be awaited or used in an expression.
+        const _ = Promise.all([browserTargetRun.stop(), serverTargetRun.stop()]);
     }
 }
 exports.default = architect_1.createBuilder(_appShellBuilder);

package/src/babel/plugins/adjust-static-class-members.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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
+ */
+import { PluginObj } from '@babel/core';
+/**
+ * Provides one or more keywords that if found within the content of a source file indicate
+ * that this plugin should be used with a source file.
+ *
+ * @returns An a string iterable containing one or more keywords.
+ */
+export declare function getKeywords(): Iterable<string>;
+/**
+ * A babel plugin factory function for adjusting classes; primarily with Angular metadata.
+ * The adjustments include wrapping classes with known safe or no side effects with pure
+ * annotations to support dead code removal of unused classes. Angular compiler generated
+ * metadata static fields not required in AOT mode are also elided to better support bundler-
+ * level treeshaking.
+ *
+ * @returns A babel plugin object instance.
+ */
+export default function (): PluginObj;

package/src/babel/plugins/adjust-static-class-members.js

@@ -0,0 +1,251 @@
+"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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeywords = void 0;
+const core_1 = require("@babel/core");
+const helper_annotate_as_pure_1 = __importDefault(require("@babel/helper-annotate-as-pure"));
+/**
+ * The name of the Typescript decorator helper function created by the TypeScript compiler.
+ */
+const TSLIB_DECORATE_HELPER_NAME = '__decorate';
+/**
+ * The set of Angular static fields that should always be wrapped.
+ * These fields may appear to have side effects but are safe to remove if the associated class
+ * is otherwise unused within the output.
+ */
+const angularStaticsToWrap = new Set([
+    'ɵcmp',
+    'ɵdir',
+    'ɵfac',
+    'ɵinj',
+    'ɵmod',
+    'ɵpipe',
+    'ɵprov',
+    'INJECTOR_KEY',
+]);
+/**
+ * An object map of static fields and related value checks for discovery of Angular generated
+ * JIT related static fields.
+ */
+const angularStaticsToElide = {
+    'ctorParameters'(path) {
+        return path.isFunctionExpression() || path.isArrowFunctionExpression();
+    },
+    'decorators'(path) {
+        return path.isArrayExpression();
+    },
+    'propDecorators'(path) {
+        return path.isObjectExpression();
+    },
+};
+/**
+ * Provides one or more keywords that if found within the content of a source file indicate
+ * that this plugin should be used with a source file.
+ *
+ * @returns An a string iterable containing one or more keywords.
+ */
+function getKeywords() {
+    return ['class'];
+}
+exports.getKeywords = getKeywords;
+/**
+ * Analyze the sibling nodes of a class to determine if any downlevel elements should be
+ * wrapped in a pure annotated IIFE. Also determines if any elements have potential side
+ * effects.
+ *
+ * @param origin The starting NodePath location for analyzing siblings.
+ * @param classIdentifier The identifier node that represents the name of the class.
+ * @param allowWrappingDecorators Whether to allow decorators to be wrapped.
+ * @returns An object containing the results of the analysis.
+ */
+function analyzeClassSiblings(origin, classIdentifier, allowWrappingDecorators) {
+    var _a;
+    const wrapStatementPaths = [];
+    let hasPotentialSideEffects = false;
+    for (let i = 1;; ++i) {
+        const nextStatement = origin.getSibling(+origin.key + i);
+        if (!nextStatement.isExpressionStatement()) {
+            break;
+        }
+        // Valid sibling statements for class declarations are only assignment expressions
+        // and TypeScript decorator helper call expressions
+        const nextExpression = nextStatement.get('expression');
+        if (nextExpression.isCallExpression()) {
+            if (!core_1.types.isIdentifier(nextExpression.node.callee) ||
+                nextExpression.node.callee.name !== TSLIB_DECORATE_HELPER_NAME) {
+                break;
+            }
+            if (allowWrappingDecorators) {
+                wrapStatementPaths.push(nextStatement);
+            }
+            else {
+                // Statement cannot be safely wrapped which makes wrapping the class unneeded.
+                // The statement will prevent even a wrapped class from being optimized away.
+                hasPotentialSideEffects = true;
+            }
+            continue;
+        }
+        else if (!nextExpression.isAssignmentExpression()) {
+            break;
+        }
+        // Valid assignment expressions should be member access expressions using the class
+        // name as the object and an identifier as the property for static fields or only
+        // the class name for decorators.
+        const left = nextExpression.get('left');
+        if (left.isIdentifier()) {
+            if (!left.scope.bindingIdentifierEquals(left.node.name, classIdentifier) ||
+                !core_1.types.isCallExpression(nextExpression.node.right) ||
+                !core_1.types.isIdentifier(nextExpression.node.right.callee) ||
+                nextExpression.node.right.callee.name !== TSLIB_DECORATE_HELPER_NAME) {
+                break;
+            }
+            if (allowWrappingDecorators) {
+                wrapStatementPaths.push(nextStatement);
+            }
+            else {
+                // Statement cannot be safely wrapped which makes wrapping the class unneeded.
+                // The statement will prevent even a wrapped class from being optimized away.
+                hasPotentialSideEffects = true;
+            }
+            continue;
+        }
+        else if (!left.isMemberExpression() ||
+            !core_1.types.isIdentifier(left.node.object) ||
+            !left.scope.bindingIdentifierEquals(left.node.object.name, classIdentifier) ||
+            !core_1.types.isIdentifier(left.node.property)) {
+            break;
+        }
+        const propertyName = left.node.property.name;
+        const assignmentValue = nextExpression.get('right');
+        if ((_a = angularStaticsToElide[propertyName]) === null || _a === void 0 ? void 0 : _a.call(angularStaticsToElide, assignmentValue)) {
+            nextStatement.remove();
+            --i;
+        }
+        else if (angularStaticsToWrap.has(propertyName) || assignmentValue.isPure()) {
+            wrapStatementPaths.push(nextStatement);
+        }
+        else {
+            // Statement cannot be safely wrapped which makes wrapping the class unneeded.
+            // The statement will prevent even a wrapped class from being optimized away.
+            hasPotentialSideEffects = true;
+        }
+    }
+    return { hasPotentialSideEffects, wrapStatementPaths };
+}
+/**
+ * The set of classed already visited and analyzed during the plugin's execution.
+ * This is used to prevent adjusted classes from being repeatedly analyzed which can lead
+ * to an infinite loop.
+ */
+const visitedClasses = new WeakSet();
+/**
+ * A babel plugin factory function for adjusting classes; primarily with Angular metadata.
+ * The adjustments include wrapping classes with known safe or no side effects with pure
+ * annotations to support dead code removal of unused classes. Angular compiler generated
+ * metadata static fields not required in AOT mode are also elided to better support bundler-
+ * level treeshaking.
+ *
+ * @returns A babel plugin object instance.
+ */
+function default_1() {
+    return {
+        visitor: {
+            ClassDeclaration(path, state) {
+                const { node: classNode, parentPath } = path;
+                const { wrapDecorators } = state.opts;
+                if (visitedClasses.has(classNode)) {
+                    return;
+                }
+                // Analyze sibling statements for elements of the class that were downleveled
+                const hasExport = parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration();
+                const origin = hasExport ? parentPath : path;
+                const { wrapStatementPaths, hasPotentialSideEffects } = analyzeClassSiblings(origin, classNode.id, wrapDecorators);
+                visitedClasses.add(classNode);
+                if (hasPotentialSideEffects || wrapStatementPaths.length === 0) {
+                    return;
+                }
+                const wrapStatementNodes = [];
+                for (const statementPath of wrapStatementPaths) {
+                    wrapStatementNodes.push(statementPath.node);
+                    statementPath.remove();
+                }
+                // Wrap class and safe static assignments in a pure annotated IIFE
+                const container = core_1.types.arrowFunctionExpression([], core_1.types.blockStatement([
+                    classNode,
+                    ...wrapStatementNodes,
+                    core_1.types.returnStatement(core_1.types.cloneNode(classNode.id)),
+                ]));
+                const replacementInitializer = core_1.types.callExpression(core_1.types.parenthesizedExpression(container), []);
+                helper_annotate_as_pure_1.default(replacementInitializer);
+                // Replace class with IIFE wrapped class
+                const declaration = core_1.types.variableDeclaration('let', [
+                    core_1.types.variableDeclarator(core_1.types.cloneNode(classNode.id), replacementInitializer),
+                ]);
+                if (parentPath.isExportDefaultDeclaration()) {
+                    // When converted to a variable declaration, the default export must be moved
+                    // to a subsequent statement to prevent a JavaScript syntax error.
+                    parentPath.replaceWithMultiple([
+                        declaration,
+                        core_1.types.exportNamedDeclaration(undefined, [
+                            core_1.types.exportSpecifier(core_1.types.cloneNode(classNode.id), core_1.types.identifier('default')),
+                        ]),
+                    ]);
+                }
+                else {
+                    path.replaceWith(declaration);
+                }
+            },
+            ClassExpression(path, state) {
+                const { node: classNode, parentPath } = path;
+                const { wrapDecorators } = state.opts;
+                // Class expressions are used by TypeScript to represent downlevel class/constructor decorators.
+                // If not wrapping decorators, they do not need to be processed.
+                if (!wrapDecorators || visitedClasses.has(classNode)) {
+                    return;
+                }
+                if (!classNode.id ||
+                    !parentPath.isVariableDeclarator() ||
+                    !core_1.types.isIdentifier(parentPath.node.id) ||
+                    parentPath.node.id.name !== classNode.id.name) {
+                    return;
+                }
+                const origin = parentPath.parentPath;
+                if (!origin.isVariableDeclaration() || origin.node.declarations.length !== 1) {
+                    return;
+                }
+                const { wrapStatementPaths, hasPotentialSideEffects } = analyzeClassSiblings(origin, parentPath.node.id, wrapDecorators);
+                visitedClasses.add(classNode);
+                if (hasPotentialSideEffects || wrapStatementPaths.length === 0) {
+                    return;
+                }
+                const wrapStatementNodes = [];
+                for (const statementPath of wrapStatementPaths) {
+                    wrapStatementNodes.push(statementPath.node);
+                    statementPath.remove();
+                }
+                // Wrap class and safe static assignments in a pure annotated IIFE
+                const container = core_1.types.arrowFunctionExpression([], core_1.types.blockStatement([
+                    core_1.types.variableDeclaration('let', [
+                        core_1.types.variableDeclarator(core_1.types.cloneNode(classNode.id), classNode),
+                    ]),
+                    ...wrapStatementNodes,
+                    core_1.types.returnStatement(core_1.types.cloneNode(classNode.id)),
+                ]));
+                const replacementInitializer = core_1.types.callExpression(core_1.types.parenthesizedExpression(container), []);
+                helper_annotate_as_pure_1.default(replacementInitializer);
+                // Add the wrapped class directly to the variable declaration
+                parentPath.get('init').replaceWith(replacementInitializer);
+            },
+        },
+    };
+}
+exports.default = default_1;

package/src/babel/plugins/adjust-typescript-enums.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+import { PluginObj } from '@babel/core';
+/**
+ * Provides one or more keywords that if found within the content of a source file indicate
+ * that this plugin should be used with a source file.
+ *
+ * @returns An a string iterable containing one or more keywords.
+ */
+export declare function getKeywords(): Iterable<string>;
+/**
+ * A babel plugin factory function for adjusting TypeScript emitted enums.
+ *
+ * @returns A babel plugin object instance.
+ */
+export default function (): PluginObj;

package/src/babel/plugins/adjust-typescript-enums.js

@@ -0,0 +1,123 @@
+"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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeywords = void 0;
+const core_1 = require("@babel/core");
+const helper_annotate_as_pure_1 = __importDefault(require("@babel/helper-annotate-as-pure"));
+/**
+ * Provides one or more keywords that if found within the content of a source file indicate
+ * that this plugin should be used with a source file.
+ *
+ * @returns An a string iterable containing one or more keywords.
+ */
+function getKeywords() {
+    return ['var'];
+}
+exports.getKeywords = getKeywords;
+/**
+ * A babel plugin factory function for adjusting TypeScript emitted enums.
+ *
+ * @returns A babel plugin object instance.
+ */
+function default_1() {
+    return {
+        visitor: {
+            VariableDeclaration(path, state) {
+                const { parentPath, node } = path;
+                const { loose } = state.opts;
+                if (node.kind !== 'var' || node.declarations.length !== 1) {
+                    return;
+                }
+                const declaration = path.get('declarations')[0];
+                if (declaration.node.init) {
+                    return;
+                }
+                const declarationId = declaration.node.id;
+                if (!core_1.types.isIdentifier(declarationId)) {
+                    return;
+                }
+                const hasExport = parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration();
+                const origin = hasExport ? parentPath : path;
+                const nextStatement = origin.getSibling(+origin.key + 1);
+                if (!nextStatement.isExpressionStatement()) {
+                    return;
+                }
+                const nextExpression = nextStatement.get('expression');
+                if (!nextExpression.isCallExpression() || nextExpression.node.arguments.length !== 1) {
+                    return;
+                }
+                const enumCallArgument = nextExpression.node.arguments[0];
+                if (!core_1.types.isLogicalExpression(enumCallArgument, { operator: '||' })) {
+                    return;
+                }
+                // Check if identifiers match var declaration
+                if (!core_1.types.isIdentifier(enumCallArgument.left) ||
+                    !nextExpression.scope.bindingIdentifierEquals(enumCallArgument.left.name, declarationId)) {
+                    return;
+                }
+                const enumCallee = nextExpression.get('callee');
+                if (!enumCallee.isFunctionExpression() || enumCallee.node.params.length !== 1) {
+                    return;
+                }
+                // Loose mode rewrites the enum to a shorter but less TypeScript-like form
+                let enumAssignments;
+                if (loose) {
+                    enumAssignments = [];
+                }
+                // Check if all enum member values are pure.
+                // If not, leave as-is due to potential side efects
+                let hasElements = false;
+                for (const enumStatement of enumCallee.get('body').get('body')) {
+                    if (!enumStatement.isExpressionStatement()) {
+                        return;
+                    }
+                    const enumValueAssignment = enumStatement.get('expression');
+                    if (!enumValueAssignment.isAssignmentExpression() ||
+                        !enumValueAssignment.get('right').isPure()) {
+                        return;
+                    }
+                    hasElements = true;
+                    enumAssignments === null || enumAssignments === void 0 ? void 0 : enumAssignments.push(enumStatement.node);
+                }
+                // If there are no enum elements then there is nothing to wrap
+                if (!hasElements) {
+                    return;
+                }
+                // Remove existing enum initializer
+                const enumInitializer = nextExpression.node;
+                nextExpression.remove();
+                // Create IIFE block contents
+                let blockContents;
+                if (enumAssignments) {
+                    // Loose mode
+                    blockContents = [
+                        core_1.types.expressionStatement(core_1.types.assignmentExpression('=', core_1.types.cloneNode(declarationId), core_1.types.logicalExpression('||', core_1.types.cloneNode(declarationId), core_1.types.objectExpression([])))),
+                        ...enumAssignments,
+                    ];
+                }
+                else {
+                    blockContents = [core_1.types.expressionStatement(enumInitializer)];
+                }
+                // Wrap existing enum initializer in a pure annotated IIFE
+                const container = core_1.types.arrowFunctionExpression([], core_1.types.blockStatement([
+                    ...blockContents,
+                    core_1.types.returnStatement(core_1.types.cloneNode(declarationId)),
+                ]));
+                const replacementInitializer = core_1.types.callExpression(core_1.types.parenthesizedExpression(container), []);
+                helper_annotate_as_pure_1.default(replacementInitializer);
+                // Add the wrapped enum initializer directly to the variable declaration
+                declaration.get('init').replaceWith(replacementInitializer);
+            },
+        },
+    };
+}
+exports.default = default_1;

package/src/babel/plugins/elide-angular-metadata.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+import { PluginObj } from '@babel/core';
+/**
+ * Provides one or more keywords that if found within the content of a source file indicate
+ * that this plugin should be used with a source file.
+ *
+ * @returns An a string iterable containing one or more keywords.
+ */
+export declare function getKeywords(): Iterable<string>;
+/**
+ * A babel plugin factory function for eliding the Angular class metadata function (`ɵsetClassMetadata`).
+ *
+ * @returns A babel plugin object instance.
+ */
+export default function (): PluginObj;