@angular/core 19.0.0-next.2 → 19.0.0-next.4

package/schematics/bundles/explicit-standalone-flag.js

@@ -0,0 +1,157 @@
+'use strict';
+/**
+ * @license Angular v19.0.0-next.4
+ * (c) 2010-2024 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var schematics = require('@angular-devkit/schematics');
+var p = require('path');
+var project_tsconfig_paths = require('./project_tsconfig_paths-e9ccccbf.js');
+var compiler_host = require('./compiler_host-ca7ba733.js');
+var ts = require('typescript');
+var imports = require('./imports-4ac08251.js');
+require('@angular-devkit/core');
+require('os');
+require('fs');
+require('module');
+require('url');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+
+const CORE = '@angular/core';
+const DIRECTIVE = 'Directive';
+const COMPONENT = 'Component';
+const PIPE = 'Pipe';
+function migrateFile(sourceFile, rewriteFn) {
+    const changeTracker = new compiler_host.ChangeTracker(ts__default["default"].createPrinter());
+    // Check if there are any imports of the `AfterRenderPhase` enum.
+    const coreImports = imports.getNamedImports(sourceFile, CORE);
+    if (!coreImports) {
+        return;
+    }
+    const directive = imports.getImportSpecifier(sourceFile, CORE, DIRECTIVE);
+    const component = imports.getImportSpecifier(sourceFile, CORE, COMPONENT);
+    const pipe = imports.getImportSpecifier(sourceFile, CORE, PIPE);
+    if (!directive && !component && !pipe) {
+        return;
+    }
+    ts__default["default"].forEachChild(sourceFile, function visit(node) {
+        ts__default["default"].forEachChild(node, visit);
+        // First we need to check for class declarations
+        // Decorators will come after
+        if (!ts__default["default"].isClassDeclaration(node)) {
+            return;
+        }
+        ts__default["default"].getDecorators(node)?.forEach((decorator) => {
+            if (!ts__default["default"].isDecorator(decorator)) {
+                return;
+            }
+            const callExpression = decorator.expression;
+            if (!ts__default["default"].isCallExpression(callExpression)) {
+                return;
+            }
+            const decoratorIdentifier = callExpression.expression;
+            if (!ts__default["default"].isIdentifier(decoratorIdentifier)) {
+                return;
+            }
+            // Checking the identifier of the decorator by comparing to the import specifier
+            switch (decoratorIdentifier.text) {
+                case directive?.name.text:
+                case component?.name.text:
+                case pipe?.name.text:
+                    break;
+                default:
+                    // It's not a decorator to migrate
+                    return;
+            }
+            const [firstArg] = callExpression.arguments;
+            if (!firstArg || !ts__default["default"].isObjectLiteralExpression(firstArg)) {
+                return;
+            }
+            const properties = firstArg.properties;
+            const standaloneProp = getStandaloneProperty(properties);
+            // Need to take care of 3 cases
+            // - standalone: true  => remove the property
+            // - standalone: false => nothing
+            // - No standalone property => add a standalone: false property
+            let newProperties;
+            if (!standaloneProp) {
+                const standaloneFalseProperty = ts__default["default"].factory.createPropertyAssignment('standalone', ts__default["default"].factory.createFalse());
+                newProperties = [...properties, standaloneFalseProperty];
+            }
+            else if (standaloneProp.value === ts__default["default"].SyntaxKind.TrueKeyword) {
+                newProperties = properties.filter((p) => p !== standaloneProp.property);
+            }
+            if (newProperties) {
+                // At this point we know that we need to add standalone: false or
+                // remove an existing standalone: true property.
+                const newPropsArr = ts__default["default"].factory.createNodeArray(newProperties);
+                const newFirstArg = ts__default["default"].factory.createObjectLiteralExpression(newPropsArr, true);
+                changeTracker.replaceNode(firstArg, newFirstArg);
+            }
+        });
+    });
+    // Write the changes.
+    for (const changesInFile of changeTracker.recordChanges().values()) {
+        for (const change of changesInFile) {
+            rewriteFn(change.start, change.removeLength ?? 0, change.text);
+        }
+    }
+}
+function getStandaloneProperty(properties) {
+    for (const prop of properties) {
+        if (ts__default["default"].isPropertyAssignment(prop) &&
+            ts__default["default"].isIdentifier(prop.name) &&
+            prop.name.text === 'standalone' &&
+            (prop.initializer.kind === ts__default["default"].SyntaxKind.TrueKeyword ||
+                prop.initializer.kind === ts__default["default"].SyntaxKind.FalseKeyword)) {
+            return { property: prop, value: prop.initializer.kind };
+        }
+    }
+    return undefined;
+}
+
+function migrate() {
+    return async (tree) => {
+        const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(tree);
+        const basePath = process.cwd();
+        const allPaths = [...buildPaths, ...testPaths];
+        if (!allPaths.length) {
+            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run the standalone:false migration.');
+        }
+        for (const tsconfigPath of allPaths) {
+            runMigration(tree, tsconfigPath, basePath);
+        }
+    };
+}
+function runMigration(tree, tsconfigPath, basePath) {
+    const program = compiler_host.createMigrationProgram(tree, tsconfigPath, basePath);
+    const sourceFiles = program
+        .getSourceFiles()
+        .filter((sourceFile) => compiler_host.canMigrateFile(basePath, sourceFile, program));
+    for (const sourceFile of sourceFiles) {
+        let update = null;
+        const rewriter = (startPos, width, text) => {
+            if (update === null) {
+                // Lazily initialize update, because most files will not require migration.
+                update = tree.beginUpdate(p.relative(basePath, sourceFile.fileName));
+            }
+            update.remove(startPos, width);
+            if (text !== null) {
+                update.insertLeft(startPos, text);
+            }
+        };
+        migrateFile(sourceFile, rewriter);
+        if (update !== null) {
+            tree.commitUpdate(update);
+        }
+    }
+}
+
+exports.migrate = migrate;

package/schematics/bundles/imports-4ac08251.js

@@ -0,0 +1,110 @@
+'use strict';
+/**
+ * @license Angular v19.0.0-next.4
+ * (c) 2010-2024 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+var ts = require('typescript');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+
+/** Gets import information about the specified identifier by using the Type checker. */
+function getImportOfIdentifier(typeChecker, node) {
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    if (!symbol || symbol.declarations === undefined || !symbol.declarations.length) {
+        return null;
+    }
+    const decl = symbol.declarations[0];
+    if (!ts__default["default"].isImportSpecifier(decl)) {
+        return null;
+    }
+    const importDecl = decl.parent.parent.parent;
+    if (!ts__default["default"].isImportDeclaration(importDecl) || !ts__default["default"].isStringLiteral(importDecl.moduleSpecifier)) {
+        return null;
+    }
+    return {
+        // Handles aliased imports: e.g. "import {Component as myComp} from ...";
+        name: decl.propertyName ? decl.propertyName.text : decl.name.text,
+        importModule: importDecl.moduleSpecifier.text,
+        node: importDecl,
+    };
+}
+/**
+ * Gets a top-level import specifier with a specific name that is imported from a particular module.
+ * E.g. given a file that looks like:
+ *
+ * ```
+ * import { Component, Directive } from '@angular/core';
+ * import { Foo } from './foo';
+ * ```
+ *
+ * Calling `getImportSpecifier(sourceFile, '@angular/core', 'Directive')` will yield the node
+ * referring to `Directive` in the top import.
+ *
+ * @param sourceFile File in which to look for imports.
+ * @param moduleName Name of the import's module.
+ * @param specifierName Original name of the specifier to look for. Aliases will be resolved to
+ *    their original name.
+ */
+function getImportSpecifier(sourceFile, moduleName, specifierName) {
+    return getImportSpecifiers(sourceFile, moduleName, specifierName)[0] ?? null;
+}
+function getImportSpecifiers(sourceFile, moduleName, specifierOrSpecifiers) {
+    const matches = [];
+    for (const node of sourceFile.statements) {
+        if (!ts__default["default"].isImportDeclaration(node) || !ts__default["default"].isStringLiteral(node.moduleSpecifier)) {
+            continue;
+        }
+        const namedBindings = node.importClause?.namedBindings;
+        const isMatch = typeof moduleName === 'string'
+            ? node.moduleSpecifier.text === moduleName
+            : moduleName.test(node.moduleSpecifier.text);
+        if (!isMatch || !namedBindings || !ts__default["default"].isNamedImports(namedBindings)) {
+            continue;
+        }
+        if (typeof specifierOrSpecifiers === 'string') {
+            const match = findImportSpecifier(namedBindings.elements, specifierOrSpecifiers);
+            if (match) {
+                matches.push(match);
+            }
+        }
+        else {
+            for (const specifierName of specifierOrSpecifiers) {
+                const match = findImportSpecifier(namedBindings.elements, specifierName);
+                if (match) {
+                    matches.push(match);
+                }
+            }
+        }
+    }
+    return matches;
+}
+function getNamedImports(sourceFile, moduleName) {
+    for (const node of sourceFile.statements) {
+        if (ts__default["default"].isImportDeclaration(node) && ts__default["default"].isStringLiteral(node.moduleSpecifier)) {
+            const isMatch = typeof moduleName === 'string'
+                ? node.moduleSpecifier.text === moduleName
+                : moduleName.test(node.moduleSpecifier.text);
+            const namedBindings = node.importClause?.namedBindings;
+            if (isMatch && namedBindings && ts__default["default"].isNamedImports(namedBindings)) {
+                return namedBindings;
+            }
+        }
+    }
+    return null;
+}
+/** Finds an import specifier with a particular name. */
+function findImportSpecifier(nodes, specifierName) {
+    return nodes.find((element) => {
+        const { name, propertyName } = element;
+        return propertyName ? propertyName.text === specifierName : name.text === specifierName;
+    });
+}
+
+exports.getImportOfIdentifier = getImportOfIdentifier;
+exports.getImportSpecifier = getImportSpecifier;
+exports.getNamedImports = getNamedImports;