@angular-devkit/build-angular 16.1.0-rc.0 → 16.1.0

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

@@ -0,0 +1,354 @@
+"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"));
+const helper_split_export_declaration_1 = __importDefault(require("@babel/helper-split-export-declaration"));
+/**
+ * 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;
+/**
+ * Determines whether a property and its initializer value can be safely wrapped in a pure
+ * annotated IIFE. Values that may cause side effects are not considered safe to wrap.
+ * Wrapping such values may cause runtime errors and/or incorrect runtime behavior.
+ *
+ * @param propertyName The name of the property to analyze.
+ * @param assignmentValue The initializer value that will be assigned to the property.
+ * @returns If the property can be safely wrapped, then true; otherwise, false.
+ */
+function canWrapProperty(propertyName, assignmentValue) {
+    if (angularStaticsToWrap.has(propertyName)) {
+        return true;
+    }
+    const { leadingComments } = assignmentValue.node;
+    if (leadingComments?.some(
+    // `@pureOrBreakMyCode` is used by closure and is present in Angular code
+    ({ value }) => value.includes('@__PURE__') ||
+        value.includes('#__PURE__') ||
+        value.includes('@pureOrBreakMyCode'))) {
+        return true;
+    }
+    return assignmentValue.isPure();
+}
+/**
+ * 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) {
+    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 (angularStaticsToElide[propertyName]?.(assignmentValue)) {
+            nextStatement.remove();
+            --i;
+        }
+        else if (canWrapProperty(propertyName, assignmentValue)) {
+            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 classes 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 map of classes that have already been analyzed during the default export splitting step.
+ * This is used to avoid analyzing a class declaration twice if it is a direct default export.
+ */
+const exportDefaultAnalysis = new WeakMap();
+/**
+ * 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.
+ */
+// eslint-disable-next-line max-lines-per-function
+function default_1() {
+    return {
+        visitor: {
+            // When a class is converted to a variable declaration, the default export must be moved
+            // to a subsequent statement to prevent a JavaScript syntax error.
+            ExportDefaultDeclaration(path, state) {
+                const declaration = path.get('declaration');
+                if (!declaration.isClassDeclaration()) {
+                    return;
+                }
+                const { wrapDecorators } = state.opts;
+                const analysis = analyzeClassSiblings(path, declaration.node.id, wrapDecorators);
+                exportDefaultAnalysis.set(declaration.node, analysis);
+                // Splitting the export declaration is not needed if the class will not be wrapped
+                if (analysis.hasPotentialSideEffects) {
+                    return;
+                }
+                (0, helper_split_export_declaration_1.default)(path);
+            },
+            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 origin = parentPath.isExportNamedDeclaration() ? parentPath : path;
+                const { wrapStatementPaths, hasPotentialSideEffects } = exportDefaultAnalysis.get(classNode) ??
+                    analyzeClassSiblings(origin, classNode.id, wrapDecorators);
+                visitedClasses.add(classNode);
+                if (hasPotentialSideEffects) {
+                    return;
+                }
+                // If no statements to wrap, check for static class properties.
+                // Static class properties may be downleveled at later stages in the build pipeline
+                // which results in additional function calls outside the class body. These calls
+                // then cause the class to be referenced and not eligible for removal. Since it is
+                // not known at this stage whether the class needs to be downleveled, the transform
+                // wraps classes preemptively to allow for potential removal within the optimization
+                // stages.
+                if (wrapStatementPaths.length === 0) {
+                    let shouldWrap = false;
+                    for (const element of path.get('body').get('body')) {
+                        if (element.isClassProperty()) {
+                            // Only need to analyze static properties
+                            if (!element.node.static) {
+                                continue;
+                            }
+                            // Check for potential side effects.
+                            // These checks are conservative and could potentially be expanded in the future.
+                            const elementKey = element.get('key');
+                            const elementValue = element.get('value');
+                            if (elementKey.isIdentifier() &&
+                                (!elementValue.isExpression() ||
+                                    canWrapProperty(elementKey.node.name, elementValue))) {
+                                shouldWrap = true;
+                            }
+                            else {
+                                // Not safe to wrap
+                                shouldWrap = false;
+                                break;
+                            }
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        }
+                        else if (element.isStaticBlock()) {
+                            // Only need to analyze static blocks
+                            const body = element.get('body');
+                            if (Array.isArray(body) && body.length > 1) {
+                                // Not safe to wrap
+                                shouldWrap = false;
+                                break;
+                            }
+                            const expression = body.find((n) => n.isExpressionStatement());
+                            const assignmentExpression = expression?.get('expression');
+                            if (assignmentExpression?.isAssignmentExpression()) {
+                                const left = assignmentExpression.get('left');
+                                if (!left.isMemberExpression()) {
+                                    continue;
+                                }
+                                if (!left.get('object').isThisExpression()) {
+                                    // Not safe to wrap
+                                    shouldWrap = false;
+                                    break;
+                                }
+                                const element = left.get('property');
+                                const right = assignmentExpression.get('right');
+                                if (element.isIdentifier() &&
+                                    (!right.isExpression() || canWrapProperty(element.node.name, right))) {
+                                    shouldWrap = true;
+                                }
+                                else {
+                                    // Not safe to wrap
+                                    shouldWrap = false;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!shouldWrap) {
+                        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), []);
+                (0, 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),
+                ]);
+                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), []);
+                (0, 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;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adjust-static-class-members.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/babel/plugins/adjust-static-class-members.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 { NodePath, PluginObj, PluginPass, types } from '@babel/core';\nimport annotateAsPure from '@babel/helper-annotate-as-pure';\nimport splitExportDeclaration from '@babel/helper-split-export-declaration';\n\n/**\n * The name of the Typescript decorator helper function created by the TypeScript compiler.\n */\nconst TSLIB_DECORATE_HELPER_NAME = '__decorate';\n\n/**\n * The set of Angular static fields that should always be wrapped.\n * These fields may appear to have side effects but are safe to remove if the associated class\n * is otherwise unused within the output.\n */\nconst angularStaticsToWrap = new Set([\n  'ɵcmp',\n  'ɵdir',\n  'ɵfac',\n  'ɵinj',\n  'ɵmod',\n  'ɵpipe',\n  'ɵprov',\n  'INJECTOR_KEY',\n]);\n\n/**\n * An object map of static fields and related value checks for discovery of Angular generated\n * JIT related static fields.\n */\nconst angularStaticsToElide: Record<string, (path: NodePath<types.Expression>) => boolean> = {\n  'ctorParameters'(path) {\n    return path.isFunctionExpression() || path.isArrowFunctionExpression();\n  },\n  'decorators'(path) {\n    return path.isArrayExpression();\n  },\n  'propDecorators'(path) {\n    return path.isObjectExpression();\n  },\n};\n\n/**\n * Provides one or more keywords that if found within the content of a source file indicate\n * that this plugin should be used with a source file.\n *\n * @returns An a string iterable containing one or more keywords.\n */\nexport function getKeywords(): Iterable<string> {\n  return ['class'];\n}\n\n/**\n * Determines whether a property and its initializer value can be safely wrapped in a pure\n * annotated IIFE. Values that may cause side effects are not considered safe to wrap.\n * Wrapping such values may cause runtime errors and/or incorrect runtime behavior.\n *\n * @param propertyName The name of the property to analyze.\n * @param assignmentValue The initializer value that will be assigned to the property.\n * @returns If the property can be safely wrapped, then true; otherwise, false.\n */\nfunction canWrapProperty(propertyName: string, assignmentValue: NodePath): boolean {\n  if (angularStaticsToWrap.has(propertyName)) {\n    return true;\n  }\n\n  const { leadingComments } = assignmentValue.node as { leadingComments?: { value: string }[] };\n  if (\n    leadingComments?.some(\n      // `@pureOrBreakMyCode` is used by closure and is present in Angular code\n      ({ value }) =>\n        value.includes('@__PURE__') ||\n        value.includes('#__PURE__') ||\n        value.includes('@pureOrBreakMyCode'),\n    )\n  ) {\n    return true;\n  }\n\n  return assignmentValue.isPure();\n}\n\n/**\n * Analyze the sibling nodes of a class to determine if any downlevel elements should be\n * wrapped in a pure annotated IIFE. Also determines if any elements have potential side\n * effects.\n *\n * @param origin The starting NodePath location for analyzing siblings.\n * @param classIdentifier The identifier node that represents the name of the class.\n * @param allowWrappingDecorators Whether to allow decorators to be wrapped.\n * @returns An object containing the results of the analysis.\n */\nfunction analyzeClassSiblings(\n  origin: NodePath,\n  classIdentifier: types.Identifier,\n  allowWrappingDecorators: boolean,\n): { hasPotentialSideEffects: boolean; wrapStatementPaths: NodePath<types.Statement>[] } {\n  const wrapStatementPaths: NodePath<types.Statement>[] = [];\n  let hasPotentialSideEffects = false;\n  for (let i = 1; ; ++i) {\n    const nextStatement = origin.getSibling(+origin.key + i);\n    if (!nextStatement.isExpressionStatement()) {\n      break;\n    }\n\n    // Valid sibling statements for class declarations are only assignment expressions\n    // and TypeScript decorator helper call expressions\n    const nextExpression = nextStatement.get('expression');\n    if (nextExpression.isCallExpression()) {\n      if (\n        !types.isIdentifier(nextExpression.node.callee) ||\n        nextExpression.node.callee.name !== TSLIB_DECORATE_HELPER_NAME\n      ) {\n        break;\n      }\n\n      if (allowWrappingDecorators) {\n        wrapStatementPaths.push(nextStatement);\n      } else {\n        // Statement cannot be safely wrapped which makes wrapping the class unneeded.\n        // The statement will prevent even a wrapped class from being optimized away.\n        hasPotentialSideEffects = true;\n      }\n\n      continue;\n    } else if (!nextExpression.isAssignmentExpression()) {\n      break;\n    }\n\n    // Valid assignment expressions should be member access expressions using the class\n    // name as the object and an identifier as the property for static fields or only\n    // the class name for decorators.\n    const left = nextExpression.get('left');\n    if (left.isIdentifier()) {\n      if (\n        !left.scope.bindingIdentifierEquals(left.node.name, classIdentifier) ||\n        !types.isCallExpression(nextExpression.node.right) ||\n        !types.isIdentifier(nextExpression.node.right.callee) ||\n        nextExpression.node.right.callee.name !== TSLIB_DECORATE_HELPER_NAME\n      ) {\n        break;\n      }\n\n      if (allowWrappingDecorators) {\n        wrapStatementPaths.push(nextStatement);\n      } else {\n        // Statement cannot be safely wrapped which makes wrapping the class unneeded.\n        // The statement will prevent even a wrapped class from being optimized away.\n        hasPotentialSideEffects = true;\n      }\n\n      continue;\n    } else if (\n      !left.isMemberExpression() ||\n      !types.isIdentifier(left.node.object) ||\n      !left.scope.bindingIdentifierEquals(left.node.object.name, classIdentifier) ||\n      !types.isIdentifier(left.node.property)\n    ) {\n      break;\n    }\n\n    const propertyName = left.node.property.name;\n    const assignmentValue = nextExpression.get('right');\n    if (angularStaticsToElide[propertyName]?.(assignmentValue)) {\n      nextStatement.remove();\n      --i;\n    } else if (canWrapProperty(propertyName, assignmentValue)) {\n      wrapStatementPaths.push(nextStatement);\n    } else {\n      // Statement cannot be safely wrapped which makes wrapping the class unneeded.\n      // The statement will prevent even a wrapped class from being optimized away.\n      hasPotentialSideEffects = true;\n    }\n  }\n\n  return { hasPotentialSideEffects, wrapStatementPaths };\n}\n\n/**\n * The set of classes already visited and analyzed during the plugin's execution.\n * This is used to prevent adjusted classes from being repeatedly analyzed which can lead\n * to an infinite loop.\n */\nconst visitedClasses = new WeakSet<types.Class>();\n\n/**\n * A map of classes that have already been analyzed during the default export splitting step.\n * This is used to avoid analyzing a class declaration twice if it is a direct default export.\n */\nconst exportDefaultAnalysis = new WeakMap<types.Class, ReturnType<typeof analyzeClassSiblings>>();\n\n/**\n * A babel plugin factory function for adjusting classes; primarily with Angular metadata.\n * The adjustments include wrapping classes with known safe or no side effects with pure\n * annotations to support dead code removal of unused classes. Angular compiler generated\n * metadata static fields not required in AOT mode are also elided to better support bundler-\n * level treeshaking.\n *\n * @returns A babel plugin object instance.\n */\n// eslint-disable-next-line max-lines-per-function\nexport default function (): PluginObj {\n  return {\n    visitor: {\n      // When a class is converted to a variable declaration, the default export must be moved\n      // to a subsequent statement to prevent a JavaScript syntax error.\n      ExportDefaultDeclaration(path: NodePath<types.ExportDefaultDeclaration>, state: PluginPass) {\n        const declaration = path.get('declaration');\n        if (!declaration.isClassDeclaration()) {\n          return;\n        }\n\n        const { wrapDecorators } = state.opts as { wrapDecorators: boolean };\n        const analysis = analyzeClassSiblings(path, declaration.node.id, wrapDecorators);\n        exportDefaultAnalysis.set(declaration.node, analysis);\n\n        // Splitting the export declaration is not needed if the class will not be wrapped\n        if (analysis.hasPotentialSideEffects) {\n          return;\n        }\n\n        splitExportDeclaration(path);\n      },\n      ClassDeclaration(path: NodePath<types.ClassDeclaration>, state: PluginPass) {\n        const { node: classNode, parentPath } = path;\n        const { wrapDecorators } = state.opts as { wrapDecorators: boolean };\n\n        if (visitedClasses.has(classNode)) {\n          return;\n        }\n\n        // Analyze sibling statements for elements of the class that were downleveled\n        const origin = parentPath.isExportNamedDeclaration() ? parentPath : path;\n        const { wrapStatementPaths, hasPotentialSideEffects } =\n          exportDefaultAnalysis.get(classNode) ??\n          analyzeClassSiblings(origin, classNode.id, wrapDecorators);\n\n        visitedClasses.add(classNode);\n\n        if (hasPotentialSideEffects) {\n          return;\n        }\n\n        // If no statements to wrap, check for static class properties.\n        // Static class properties may be downleveled at later stages in the build pipeline\n        // which results in additional function calls outside the class body. These calls\n        // then cause the class to be referenced and not eligible for removal. Since it is\n        // not known at this stage whether the class needs to be downleveled, the transform\n        // wraps classes preemptively to allow for potential removal within the optimization\n        // stages.\n        if (wrapStatementPaths.length === 0) {\n          let shouldWrap = false;\n          for (const element of path.get('body').get('body')) {\n            if (element.isClassProperty()) {\n              // Only need to analyze static properties\n              if (!element.node.static) {\n                continue;\n              }\n\n              // Check for potential side effects.\n              // These checks are conservative and could potentially be expanded in the future.\n              const elementKey = element.get('key');\n              const elementValue = element.get('value');\n              if (\n                elementKey.isIdentifier() &&\n                (!elementValue.isExpression() ||\n                  canWrapProperty(elementKey.node.name, elementValue))\n              ) {\n                shouldWrap = true;\n              } else {\n                // Not safe to wrap\n                shouldWrap = false;\n                break;\n              }\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            } else if ((element as any).isStaticBlock()) {\n              // Only need to analyze static blocks\n              const body = element.get('body');\n\n              if (Array.isArray(body) && body.length > 1) {\n                // Not safe to wrap\n                shouldWrap = false;\n                break;\n              }\n\n              const expression = body.find((n: NodePath<types.Node>) =>\n                n.isExpressionStatement(),\n              ) as NodePath<types.ExpressionStatement> | undefined;\n\n              const assignmentExpression = expression?.get('expression');\n              if (assignmentExpression?.isAssignmentExpression()) {\n                const left = assignmentExpression.get('left');\n                if (!left.isMemberExpression()) {\n                  continue;\n                }\n\n                if (!left.get('object').isThisExpression()) {\n                  // Not safe to wrap\n                  shouldWrap = false;\n                  break;\n                }\n\n                const element = left.get('property');\n                const right = assignmentExpression.get('right');\n                if (\n                  element.isIdentifier() &&\n                  (!right.isExpression() || canWrapProperty(element.node.name, right))\n                ) {\n                  shouldWrap = true;\n                } else {\n                  // Not safe to wrap\n                  shouldWrap = false;\n                  break;\n                }\n              }\n            }\n          }\n          if (!shouldWrap) {\n            return;\n          }\n        }\n\n        const wrapStatementNodes: types.Statement[] = [];\n        for (const statementPath of wrapStatementPaths) {\n          wrapStatementNodes.push(statementPath.node);\n          statementPath.remove();\n        }\n\n        // Wrap class and safe static assignments in a pure annotated IIFE\n        const container = types.arrowFunctionExpression(\n          [],\n          types.blockStatement([\n            classNode,\n            ...wrapStatementNodes,\n            types.returnStatement(types.cloneNode(classNode.id)),\n          ]),\n        );\n        const replacementInitializer = types.callExpression(\n          types.parenthesizedExpression(container),\n          [],\n        );\n        annotateAsPure(replacementInitializer);\n\n        // Replace class with IIFE wrapped class\n        const declaration = types.variableDeclaration('let', [\n          types.variableDeclarator(types.cloneNode(classNode.id), replacementInitializer),\n        ]);\n        path.replaceWith(declaration);\n      },\n      ClassExpression(path: NodePath<types.ClassExpression>, state: PluginPass) {\n        const { node: classNode, parentPath } = path;\n        const { wrapDecorators } = state.opts as { wrapDecorators: boolean };\n\n        // Class expressions are used by TypeScript to represent downlevel class/constructor decorators.\n        // If not wrapping decorators, they do not need to be processed.\n        if (!wrapDecorators || visitedClasses.has(classNode)) {\n          return;\n        }\n\n        if (\n          !classNode.id ||\n          !parentPath.isVariableDeclarator() ||\n          !types.isIdentifier(parentPath.node.id) ||\n          parentPath.node.id.name !== classNode.id.name\n        ) {\n          return;\n        }\n\n        const origin = parentPath.parentPath;\n        if (!origin.isVariableDeclaration() || origin.node.declarations.length !== 1) {\n          return;\n        }\n\n        const { wrapStatementPaths, hasPotentialSideEffects } = analyzeClassSiblings(\n          origin,\n          parentPath.node.id,\n          wrapDecorators,\n        );\n\n        visitedClasses.add(classNode);\n\n        if (hasPotentialSideEffects || wrapStatementPaths.length === 0) {\n          return;\n        }\n\n        const wrapStatementNodes: types.Statement[] = [];\n        for (const statementPath of wrapStatementPaths) {\n          wrapStatementNodes.push(statementPath.node);\n          statementPath.remove();\n        }\n\n        // Wrap class and safe static assignments in a pure annotated IIFE\n        const container = types.arrowFunctionExpression(\n          [],\n          types.blockStatement([\n            types.variableDeclaration('let', [\n              types.variableDeclarator(types.cloneNode(classNode.id), classNode),\n            ]),\n            ...wrapStatementNodes,\n            types.returnStatement(types.cloneNode(classNode.id)),\n          ]),\n        );\n        const replacementInitializer = types.callExpression(\n          types.parenthesizedExpression(container),\n          [],\n        );\n        annotateAsPure(replacementInitializer);\n\n        // Add the wrapped class directly to the variable declaration\n        parentPath.get('init').replaceWith(replacementInitializer);\n      },\n    },\n  };\n}\n"]}

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

@@ -0,0 +1,124 @@
+"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) {
+                const { parentPath, node } = path;
+                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;
+                }
+                const enumCalleeParam = enumCallee.node.params[0];
+                const isEnumCalleeMatching = core_1.types.isIdentifier(enumCalleeParam) && enumCalleeParam.name === declarationId.name;
+                let enumAssignments;
+                if (isEnumCalleeMatching) {
+                    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?.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), []);
+                (0, 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;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adjust-typescript-enums.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/babel/plugins/adjust-typescript-enums.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 { NodePath, PluginObj, types } from '@babel/core';\nimport annotateAsPure from '@babel/helper-annotate-as-pure';\n\n/**\n * Provides one or more keywords that if found within the content of a source file indicate\n * that this plugin should be used with a source file.\n *\n * @returns An a string iterable containing one or more keywords.\n */\nexport function getKeywords(): Iterable<string> {\n  return ['var'];\n}\n\n/**\n * A babel plugin factory function for adjusting TypeScript emitted enums.\n *\n * @returns A babel plugin object instance.\n */\nexport default function (): PluginObj {\n  return {\n    visitor: {\n      VariableDeclaration(path: NodePath<types.VariableDeclaration>) {\n        const { parentPath, node } = path;\n        if (node.kind !== 'var' || node.declarations.length !== 1) {\n          return;\n        }\n\n        const declaration = path.get('declarations')[0];\n        if (declaration.node.init) {\n          return;\n        }\n\n        const declarationId = declaration.node.id;\n        if (!types.isIdentifier(declarationId)) {\n          return;\n        }\n\n        const hasExport =\n          parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration();\n        const origin = hasExport ? parentPath : path;\n        const nextStatement = origin.getSibling(+origin.key + 1);\n        if (!nextStatement.isExpressionStatement()) {\n          return;\n        }\n\n        const nextExpression = nextStatement.get('expression');\n        if (!nextExpression.isCallExpression() || nextExpression.node.arguments.length !== 1) {\n          return;\n        }\n\n        const enumCallArgument = nextExpression.node.arguments[0];\n        if (!types.isLogicalExpression(enumCallArgument, { operator: '||' })) {\n          return;\n        }\n\n        // Check if identifiers match var declaration\n        if (\n          !types.isIdentifier(enumCallArgument.left) ||\n          !nextExpression.scope.bindingIdentifierEquals(enumCallArgument.left.name, declarationId)\n        ) {\n          return;\n        }\n\n        const enumCallee = nextExpression.get('callee');\n        if (!enumCallee.isFunctionExpression() || enumCallee.node.params.length !== 1) {\n          return;\n        }\n\n        const enumCalleeParam = enumCallee.node.params[0];\n        const isEnumCalleeMatching =\n          types.isIdentifier(enumCalleeParam) && enumCalleeParam.name === declarationId.name;\n\n        let enumAssignments: types.ExpressionStatement[] | undefined;\n        if (isEnumCalleeMatching) {\n          enumAssignments = [];\n        }\n\n        // Check if all enum member values are pure.\n        // If not, leave as-is due to potential side efects\n        let hasElements = false;\n        for (const enumStatement of enumCallee.get('body').get('body')) {\n          if (!enumStatement.isExpressionStatement()) {\n            return;\n          }\n\n          const enumValueAssignment = enumStatement.get('expression');\n          if (\n            !enumValueAssignment.isAssignmentExpression() ||\n            !enumValueAssignment.get('right').isPure()\n          ) {\n            return;\n          }\n\n          hasElements = true;\n          enumAssignments?.push(enumStatement.node);\n        }\n\n        // If there are no enum elements then there is nothing to wrap\n        if (!hasElements) {\n          return;\n        }\n\n        // Remove existing enum initializer\n        const enumInitializer = nextExpression.node;\n        nextExpression.remove();\n\n        // Create IIFE block contents\n        let blockContents;\n        if (enumAssignments) {\n          // Loose mode\n          blockContents = [\n            types.expressionStatement(\n              types.assignmentExpression(\n                '=',\n                types.cloneNode(declarationId),\n                types.logicalExpression(\n                  '||',\n                  types.cloneNode(declarationId),\n                  types.objectExpression([]),\n                ),\n              ),\n            ),\n            ...enumAssignments,\n          ];\n        } else {\n          blockContents = [types.expressionStatement(enumInitializer)];\n        }\n\n        // Wrap existing enum initializer in a pure annotated IIFE\n        const container = types.arrowFunctionExpression(\n          [],\n          types.blockStatement([\n            ...blockContents,\n            types.returnStatement(types.cloneNode(declarationId)),\n          ]),\n        );\n        const replacementInitializer = types.callExpression(\n          types.parenthesizedExpression(container),\n          [],\n        );\n        annotateAsPure(replacementInitializer);\n\n        // Add the wrapped enum initializer directly to the variable declaration\n        declaration.get('init').replaceWith(replacementInitializer);\n      },\n    },\n  };\n}\n"]}

package/src/tools/babel/plugins/elide-angular-metadata.js

@@ -0,0 +1,68 @@
+"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.getKeywords = void 0;
+const core_1 = require("@babel/core");
+/**
+ * The name of the Angular class metadata function created by the Angular compiler.
+ */
+const SET_CLASS_METADATA_NAME = 'ɵsetClassMetadata';
+/**
+ * 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 [SET_CLASS_METADATA_NAME];
+}
+exports.getKeywords = getKeywords;
+/**
+ * A babel plugin factory function for eliding the Angular class metadata function (`ɵsetClassMetadata`).
+ *
+ * @returns A babel plugin object instance.
+ */
+function default_1() {
+    return {
+        visitor: {
+            CallExpression(path) {
+                const callee = path.node.callee;
+                // The function being called must be the metadata function name
+                let calleeName;
+                if (core_1.types.isMemberExpression(callee) && core_1.types.isIdentifier(callee.property)) {
+                    calleeName = callee.property.name;
+                }
+                else if (core_1.types.isIdentifier(callee)) {
+                    calleeName = callee.name;
+                }
+                if (calleeName !== SET_CLASS_METADATA_NAME) {
+                    return;
+                }
+                // There must be four arguments that meet the following criteria:
+                // * First must be an identifier
+                // * Second must be an array literal
+                const callArguments = path.node.arguments;
+                if (callArguments.length !== 4 ||
+                    !core_1.types.isIdentifier(callArguments[0]) ||
+                    !core_1.types.isArrayExpression(callArguments[1])) {
+                    return;
+                }
+                // The metadata function is always emitted inside a function expression
+                if (!path.getFunctionParent()?.isFunctionExpression()) {
+                    return;
+                }
+                // Replace the metadata function with `void 0` which is the equivalent return value
+                // of the metadata function.
+                path.replaceWith(path.scope.buildUndefinedNode());
+            },
+        },
+    };
+}
+exports.default = default_1;
+//# sourceMappingURL=data:application/json;base64,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