@schematics/angular 16.1.0-next.2 → 16.1.0

package/utility/standalone/rules.js

@@ -0,0 +1,190 @@
+"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.addRootProvider = exports.addRootImport = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const ast_utils_1 = require("../ast-utils");
+const change_1 = require("../change");
+const ng_ast_utils_1 = require("../ng-ast-utils");
+const app_config_1 = require("./app_config");
+const code_block_1 = require("./code_block");
+const util_1 = require("./util");
+/**
+ * Adds an import to the root of the project.
+ * @param project Name of the project to which to add the import.
+ * @param callback Function that generates the code block which should be inserted.
+ * @example
+ *
+ * ```ts
+ * import { Rule } from '@angular-devkit/schematics';
+ * import { addRootImport } from '@schematics/angular/utility';
+ *
+ * export default function(): Rule {
+ *   return addRootImport('default', ({code, external}) => {
+ *     return code`${external('MyModule', '@my/module')}.forRoot({})`;
+ *   });
+ * }
+ * ```
+ */
+function addRootImport(project, callback) {
+    return getRootInsertionRule(project, callback, 'imports', {
+        name: 'importProvidersFrom',
+        module: '@angular/core',
+    });
+}
+exports.addRootImport = addRootImport;
+/**
+ * Adds a provider to the root of the project.
+ * @param project Name of the project to which to add the import.
+ * @param callback Function that generates the code block which should be inserted.
+ * @example
+ *
+ * ```ts
+ * import { Rule } from '@angular-devkit/schematics';
+ * import { addRootProvider } from '@schematics/angular/utility';
+ *
+ * export default function(): Rule {
+ *   return addRootProvider('default', ({code, external}) => {
+ *     return code`${external('provideLibrary', '@my/library')}({})`;
+ *   });
+ * }
+ * ```
+ */
+function addRootProvider(project, callback) {
+    return getRootInsertionRule(project, callback, 'providers');
+}
+exports.addRootProvider = addRootProvider;
+/**
+ * Creates a rule that inserts code at the root of either a standalone or NgModule-based project.
+ * @param project Name of the project into which to inser tthe code.
+ * @param callback Function that generates the code block which should be inserted.
+ * @param ngModuleField Field of the root NgModule into which the code should be inserted, if the
+ * app is based on NgModule
+ * @param standaloneWrapperFunction Function with which to wrap the code if the app is standalone.
+ */
+function getRootInsertionRule(project, callback, ngModuleField, standaloneWrapperFunction) {
+    return async (host) => {
+        const mainFilePath = await (0, util_1.getMainFilePath)(host, project);
+        const codeBlock = new code_block_1.CodeBlock();
+        if ((0, ng_ast_utils_1.isStandaloneApp)(host, mainFilePath)) {
+            return (tree) => addProviderToStandaloneBootstrap(tree, callback(codeBlock), mainFilePath, standaloneWrapperFunction);
+        }
+        const modulePath = (0, ng_ast_utils_1.getAppModulePath)(host, mainFilePath);
+        const pendingCode = code_block_1.CodeBlock.transformPendingCode(callback(codeBlock), modulePath);
+        return (0, schematics_1.chain)([
+            ...pendingCode.rules,
+            (tree) => {
+                const changes = (0, ast_utils_1.addSymbolToNgModuleMetadata)((0, util_1.getSourceFile)(tree, modulePath), modulePath, ngModuleField, pendingCode.code.expression, 
+                // Explicitly set the import path to null since we deal with imports here separately.
+                null);
+                (0, util_1.applyChangesToFile)(tree, modulePath, changes);
+            },
+        ]);
+    };
+}
+/**
+ * Adds a provider to the root of a standalone project.
+ * @param host Tree of the root rule.
+ * @param pendingCode Code that should be inserted.
+ * @param mainFilePath Path to the project's main file.
+ * @param wrapperFunction Optional function with which to wrap the provider.
+ */
+function addProviderToStandaloneBootstrap(host, pendingCode, mainFilePath, wrapperFunction) {
+    const bootstrapCall = (0, util_1.findBootstrapApplicationCall)(host, mainFilePath);
+    const fileToEdit = (0, app_config_1.findAppConfig)(bootstrapCall, host, mainFilePath)?.filePath || mainFilePath;
+    const { code, rules } = code_block_1.CodeBlock.transformPendingCode(pendingCode, fileToEdit);
+    return (0, schematics_1.chain)([
+        ...rules,
+        () => {
+            let wrapped;
+            let additionalRules;
+            if (wrapperFunction) {
+                const block = new code_block_1.CodeBlock();
+                const result = code_block_1.CodeBlock.transformPendingCode(block.code `${block.external(wrapperFunction.name, wrapperFunction.module)}(${code.expression})`, fileToEdit);
+                wrapped = result.code;
+                additionalRules = result.rules;
+            }
+            else {
+                wrapped = code;
+                additionalRules = [];
+            }
+            return (0, schematics_1.chain)([
+                ...additionalRules,
+                (tree) => insertStandaloneRootProvider(tree, mainFilePath, wrapped.expression),
+            ]);
+        },
+    ]);
+}
+/**
+ * Inserts a string expression into the root of a standalone project.
+ * @param tree File tree used to modify the project.
+ * @param mainFilePath Path to the main file of the project.
+ * @param expression Code expression to be inserted.
+ */
+function insertStandaloneRootProvider(tree, mainFilePath, expression) {
+    const bootstrapCall = (0, util_1.findBootstrapApplicationCall)(tree, mainFilePath);
+    const appConfig = (0, app_config_1.findAppConfig)(bootstrapCall, tree, mainFilePath);
+    if (bootstrapCall.arguments.length === 0) {
+        throw new schematics_1.SchematicsException(`Cannot add provider to invalid bootstrapApplication call in ${bootstrapCall.getSourceFile().fileName}`);
+    }
+    if (appConfig) {
+        addProvidersExpressionToAppConfig(tree, appConfig, expression);
+        return;
+    }
+    const newAppConfig = `, {\n${core_1.tags.indentBy(2) `providers: [${expression}]`}\n}`;
+    let targetCall;
+    if (bootstrapCall.arguments.length === 1) {
+        targetCall = bootstrapCall;
+    }
+    else if ((0, util_1.isMergeAppConfigCall)(bootstrapCall.arguments[1])) {
+        targetCall = bootstrapCall.arguments[1];
+    }
+    else {
+        throw new schematics_1.SchematicsException(`Cannot statically analyze bootstrapApplication call in ${bootstrapCall.getSourceFile().fileName}`);
+    }
+    (0, util_1.applyChangesToFile)(tree, mainFilePath, [
+        (0, ast_utils_1.insertAfterLastOccurrence)(targetCall.arguments, newAppConfig, mainFilePath, targetCall.getEnd() - 1),
+    ]);
+}
+/**
+ * Adds a string expression to an app config object.
+ * @param tree File tree used to modify the project.
+ * @param appConfig Resolved configuration object of the project.
+ * @param expression Code expression to be inserted.
+ */
+function addProvidersExpressionToAppConfig(tree, appConfig, expression) {
+    const { node, filePath } = appConfig;
+    const configProps = node.properties;
+    const providersLiteral = (0, util_1.findProvidersLiteral)(node);
+    // If there's a `providers` property, we can add the provider
+    // to it, otherwise we need to declare it ourselves.
+    if (providersLiteral) {
+        const hasTrailingComma = providersLiteral.elements.hasTrailingComma;
+        (0, util_1.applyChangesToFile)(tree, filePath, [
+            (0, ast_utils_1.insertAfterLastOccurrence)(providersLiteral.elements, (hasTrailingComma || providersLiteral.elements.length === 0 ? '' : ', ') + expression, filePath, providersLiteral.getStart() + 1),
+        ]);
+    }
+    else {
+        const prop = core_1.tags.indentBy(2) `providers: [${expression}]`;
+        let toInsert;
+        let insertPosition;
+        if (configProps.length === 0) {
+            toInsert = '\n' + prop + '\n';
+            insertPosition = node.getEnd() - 1;
+        }
+        else {
+            const hasTrailingComma = configProps.hasTrailingComma;
+            toInsert = (hasTrailingComma ? '' : ',') + '\n' + prop;
+            insertPosition = configProps[configProps.length - 1].getEnd() + (hasTrailingComma ? 1 : 0);
+        }
+        (0, util_1.applyChangesToFile)(tree, filePath, [new change_1.InsertChange(filePath, insertPosition, toInsert)]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../../../../../../../packages/schematics/angular/utility/standalone/rules.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 { tags } from '@angular-devkit/core';\nimport { Rule, SchematicsException, Tree, chain } from '@angular-devkit/schematics';\nimport ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';\nimport { addSymbolToNgModuleMetadata, insertAfterLastOccurrence } from '../ast-utils';\nimport { InsertChange } from '../change';\nimport { getAppModulePath, isStandaloneApp } from '../ng-ast-utils';\nimport { ResolvedAppConfig, findAppConfig } from './app_config';\nimport { CodeBlock, CodeBlockCallback, PendingCode } from './code_block';\nimport {\n  applyChangesToFile,\n  findBootstrapApplicationCall,\n  findProvidersLiteral,\n  getMainFilePath,\n  getSourceFile,\n  isMergeAppConfigCall,\n} from './util';\n\n/**\n * Adds an import to the root of the project.\n * @param project Name of the project to which to add the import.\n * @param callback Function that generates the code block which should be inserted.\n * @example\n *\n * ```ts\n * import { Rule } from '@angular-devkit/schematics';\n * import { addRootImport } from '@schematics/angular/utility';\n *\n * export default function(): Rule {\n *   return addRootImport('default', ({code, external}) => {\n *     return code`${external('MyModule', '@my/module')}.forRoot({})`;\n *   });\n * }\n * ```\n */\nexport function addRootImport(project: string, callback: CodeBlockCallback): Rule {\n  return getRootInsertionRule(project, callback, 'imports', {\n    name: 'importProvidersFrom',\n    module: '@angular/core',\n  });\n}\n\n/**\n * Adds a provider to the root of the project.\n * @param project Name of the project to which to add the import.\n * @param callback Function that generates the code block which should be inserted.\n * @example\n *\n * ```ts\n * import { Rule } from '@angular-devkit/schematics';\n * import { addRootProvider } from '@schematics/angular/utility';\n *\n * export default function(): Rule {\n *   return addRootProvider('default', ({code, external}) => {\n *     return code`${external('provideLibrary', '@my/library')}({})`;\n *   });\n * }\n * ```\n */\nexport function addRootProvider(project: string, callback: CodeBlockCallback): Rule {\n  return getRootInsertionRule(project, callback, 'providers');\n}\n\n/**\n * Creates a rule that inserts code at the root of either a standalone or NgModule-based project.\n * @param project Name of the project into which to inser tthe code.\n * @param callback Function that generates the code block which should be inserted.\n * @param ngModuleField Field of the root NgModule into which the code should be inserted, if the\n * app is based on NgModule\n * @param standaloneWrapperFunction Function with which to wrap the code if the app is standalone.\n */\nfunction getRootInsertionRule(\n  project: string,\n  callback: CodeBlockCallback,\n  ngModuleField: string,\n  standaloneWrapperFunction?: { name: string; module: string },\n): Rule {\n  return async (host) => {\n    const mainFilePath = await getMainFilePath(host, project);\n    const codeBlock = new CodeBlock();\n\n    if (isStandaloneApp(host, mainFilePath)) {\n      return (tree) =>\n        addProviderToStandaloneBootstrap(\n          tree,\n          callback(codeBlock),\n          mainFilePath,\n          standaloneWrapperFunction,\n        );\n    }\n\n    const modulePath = getAppModulePath(host, mainFilePath);\n    const pendingCode = CodeBlock.transformPendingCode(callback(codeBlock), modulePath);\n\n    return chain([\n      ...pendingCode.rules,\n      (tree) => {\n        const changes = addSymbolToNgModuleMetadata(\n          getSourceFile(tree, modulePath),\n          modulePath,\n          ngModuleField,\n          pendingCode.code.expression,\n          // Explicitly set the import path to null since we deal with imports here separately.\n          null,\n        );\n\n        applyChangesToFile(tree, modulePath, changes);\n      },\n    ]);\n  };\n}\n\n/**\n * Adds a provider to the root of a standalone project.\n * @param host Tree of the root rule.\n * @param pendingCode Code that should be inserted.\n * @param mainFilePath Path to the project's main file.\n * @param wrapperFunction Optional function with which to wrap the provider.\n */\nfunction addProviderToStandaloneBootstrap(\n  host: Tree,\n  pendingCode: PendingCode,\n  mainFilePath: string,\n  wrapperFunction?: { name: string; module: string },\n): Rule {\n  const bootstrapCall = findBootstrapApplicationCall(host, mainFilePath);\n  const fileToEdit = findAppConfig(bootstrapCall, host, mainFilePath)?.filePath || mainFilePath;\n  const { code, rules } = CodeBlock.transformPendingCode(pendingCode, fileToEdit);\n\n  return chain([\n    ...rules,\n    () => {\n      let wrapped: PendingCode;\n      let additionalRules: Rule[];\n\n      if (wrapperFunction) {\n        const block = new CodeBlock();\n        const result = CodeBlock.transformPendingCode(\n          block.code`${block.external(wrapperFunction.name, wrapperFunction.module)}(${\n            code.expression\n          })`,\n          fileToEdit,\n        );\n\n        wrapped = result.code;\n        additionalRules = result.rules;\n      } else {\n        wrapped = code;\n        additionalRules = [];\n      }\n\n      return chain([\n        ...additionalRules,\n        (tree) => insertStandaloneRootProvider(tree, mainFilePath, wrapped.expression),\n      ]);\n    },\n  ]);\n}\n\n/**\n * Inserts a string expression into the root of a standalone project.\n * @param tree File tree used to modify the project.\n * @param mainFilePath Path to the main file of the project.\n * @param expression Code expression to be inserted.\n */\nfunction insertStandaloneRootProvider(tree: Tree, mainFilePath: string, expression: string): void {\n  const bootstrapCall = findBootstrapApplicationCall(tree, mainFilePath);\n  const appConfig = findAppConfig(bootstrapCall, tree, mainFilePath);\n\n  if (bootstrapCall.arguments.length === 0) {\n    throw new SchematicsException(\n      `Cannot add provider to invalid bootstrapApplication call in ${\n        bootstrapCall.getSourceFile().fileName\n      }`,\n    );\n  }\n\n  if (appConfig) {\n    addProvidersExpressionToAppConfig(tree, appConfig, expression);\n\n    return;\n  }\n\n  const newAppConfig = `, {\\n${tags.indentBy(2)`providers: [${expression}]`}\\n}`;\n  let targetCall: ts.CallExpression;\n\n  if (bootstrapCall.arguments.length === 1) {\n    targetCall = bootstrapCall;\n  } else if (isMergeAppConfigCall(bootstrapCall.arguments[1])) {\n    targetCall = bootstrapCall.arguments[1];\n  } else {\n    throw new SchematicsException(\n      `Cannot statically analyze bootstrapApplication call in ${\n        bootstrapCall.getSourceFile().fileName\n      }`,\n    );\n  }\n\n  applyChangesToFile(tree, mainFilePath, [\n    insertAfterLastOccurrence(\n      targetCall.arguments,\n      newAppConfig,\n      mainFilePath,\n      targetCall.getEnd() - 1,\n    ),\n  ]);\n}\n\n/**\n * Adds a string expression to an app config object.\n * @param tree File tree used to modify the project.\n * @param appConfig Resolved configuration object of the project.\n * @param expression Code expression to be inserted.\n */\nfunction addProvidersExpressionToAppConfig(\n  tree: Tree,\n  appConfig: ResolvedAppConfig,\n  expression: string,\n): void {\n  const { node, filePath } = appConfig;\n  const configProps = node.properties;\n  const providersLiteral = findProvidersLiteral(node);\n\n  // If there's a `providers` property, we can add the provider\n  // to it, otherwise we need to declare it ourselves.\n  if (providersLiteral) {\n    const hasTrailingComma = providersLiteral.elements.hasTrailingComma;\n\n    applyChangesToFile(tree, filePath, [\n      insertAfterLastOccurrence(\n        providersLiteral.elements,\n        (hasTrailingComma || providersLiteral.elements.length === 0 ? '' : ', ') + expression,\n        filePath,\n        providersLiteral.getStart() + 1,\n      ),\n    ]);\n  } else {\n    const prop = tags.indentBy(2)`providers: [${expression}]`;\n    let toInsert: string;\n    let insertPosition: number;\n\n    if (configProps.length === 0) {\n      toInsert = '\\n' + prop + '\\n';\n      insertPosition = node.getEnd() - 1;\n    } else {\n      const hasTrailingComma = configProps.hasTrailingComma;\n      toInsert = (hasTrailingComma ? '' : ',') + '\\n' + prop;\n      insertPosition = configProps[configProps.length - 1].getEnd() + (hasTrailingComma ? 1 : 0);\n    }\n\n    applyChangesToFile(tree, filePath, [new InsertChange(filePath, insertPosition, toInsert)]);\n  }\n}\n"]}

package/utility/standalone/util.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @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 { Tree } from '@angular-devkit/schematics';
+import ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
+import { Change } from '../change';
+/**
+ * Finds the main file of a project.
+ * @param tree File tree for the project.
+ * @param projectName Name of the project in which to search.
+ */
+export declare function getMainFilePath(tree: Tree, projectName: string): Promise<string>;
+/**
+ * Gets a TypeScript source file at a specific path.
+ * @param tree File tree of a project.
+ * @param path Path to the file.
+ */
+export declare function getSourceFile(tree: Tree, path: string): ts.SourceFile;
+/** Finds the call to `bootstrapApplication` within a file. */
+export declare function findBootstrapApplicationCall(tree: Tree, mainFilePath: string): ts.CallExpression;
+/**
+ * Applies a set of changes to a file.
+ * @param tree File tree of the project.
+ * @param path Path to the file that is being changed.
+ * @param changes Changes that should be applied to the file.
+ */
+export declare function applyChangesToFile(tree: Tree, path: string, changes: Change[]): void;
+/** Checks whether a node is a call to `mergeApplicationConfig`. */
+export declare function isMergeAppConfigCall(node: ts.Node): node is ts.CallExpression;
+/** Finds the `providers` array literal within an application config. */
+export declare function findProvidersLiteral(config: ts.ObjectLiteralExpression): ts.ArrayLiteralExpression | null;

package/utility/standalone/util.js

@@ -0,0 +1,134 @@
+"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.findProvidersLiteral = exports.isMergeAppConfigCall = exports.applyChangesToFile = exports.findBootstrapApplicationCall = exports.getSourceFile = exports.getMainFilePath = void 0;
+const schematics_1 = require("@angular-devkit/schematics");
+const typescript_1 = __importDefault(require("../../third_party/github.com/Microsoft/TypeScript/lib/typescript"));
+const change_1 = require("../change");
+const project_targets_1 = require("../project-targets");
+const workspace_1 = require("../workspace");
+/**
+ * Finds the main file of a project.
+ * @param tree File tree for the project.
+ * @param projectName Name of the project in which to search.
+ */
+async function getMainFilePath(tree, projectName) {
+    const workspace = await (0, workspace_1.getWorkspace)(tree);
+    const project = workspace.projects.get(projectName);
+    const buildTarget = project?.targets.get('build');
+    if (!buildTarget) {
+        throw (0, project_targets_1.targetBuildNotFoundError)();
+    }
+    return (buildTarget.options || {}).main;
+}
+exports.getMainFilePath = getMainFilePath;
+/**
+ * Gets a TypeScript source file at a specific path.
+ * @param tree File tree of a project.
+ * @param path Path to the file.
+ */
+function getSourceFile(tree, path) {
+    const content = tree.readText(path);
+    const source = typescript_1.default.createSourceFile(path, content, typescript_1.default.ScriptTarget.Latest, true);
+    return source;
+}
+exports.getSourceFile = getSourceFile;
+/** Finds the call to `bootstrapApplication` within a file. */
+function findBootstrapApplicationCall(tree, mainFilePath) {
+    const sourceFile = getSourceFile(tree, mainFilePath);
+    const localName = findImportLocalName(sourceFile, 'bootstrapApplication', '@angular/platform-browser');
+    if (localName) {
+        let result = null;
+        sourceFile.forEachChild(function walk(node) {
+            if (typescript_1.default.isCallExpression(node) &&
+                typescript_1.default.isIdentifier(node.expression) &&
+                node.expression.text === localName) {
+                result = node;
+            }
+            if (!result) {
+                node.forEachChild(walk);
+            }
+        });
+        if (result) {
+            return result;
+        }
+    }
+    throw new schematics_1.SchematicsException(`Could not find bootstrapApplication call in ${mainFilePath}`);
+}
+exports.findBootstrapApplicationCall = findBootstrapApplicationCall;
+/**
+ * Finds the local name of an imported symbol. Could be the symbol name itself or its alias.
+ * @param sourceFile File within which to search for the import.
+ * @param name Actual name of the import, not its local alias.
+ * @param moduleName Name of the module from which the symbol is imported.
+ */
+function findImportLocalName(sourceFile, name, moduleName) {
+    for (const node of sourceFile.statements) {
+        // Only look for top-level imports.
+        if (!typescript_1.default.isImportDeclaration(node) ||
+            !typescript_1.default.isStringLiteral(node.moduleSpecifier) ||
+            node.moduleSpecifier.text !== moduleName) {
+            continue;
+        }
+        // Filter out imports that don't have the right shape.
+        if (!node.importClause ||
+            !node.importClause.namedBindings ||
+            !typescript_1.default.isNamedImports(node.importClause.namedBindings)) {
+            continue;
+        }
+        // Look through the elements of the declaration for the specific import.
+        for (const element of node.importClause.namedBindings.elements) {
+            if ((element.propertyName || element.name).text === name) {
+                // The local name is always in `name`.
+                return element.name.text;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Applies a set of changes to a file.
+ * @param tree File tree of the project.
+ * @param path Path to the file that is being changed.
+ * @param changes Changes that should be applied to the file.
+ */
+function applyChangesToFile(tree, path, changes) {
+    if (changes.length > 0) {
+        const recorder = tree.beginUpdate(path);
+        (0, change_1.applyToUpdateRecorder)(recorder, changes);
+        tree.commitUpdate(recorder);
+    }
+}
+exports.applyChangesToFile = applyChangesToFile;
+/** Checks whether a node is a call to `mergeApplicationConfig`. */
+function isMergeAppConfigCall(node) {
+    if (!typescript_1.default.isCallExpression(node)) {
+        return false;
+    }
+    const localName = findImportLocalName(node.getSourceFile(), 'mergeApplicationConfig', '@angular/core');
+    return !!localName && typescript_1.default.isIdentifier(node.expression) && node.expression.text === localName;
+}
+exports.isMergeAppConfigCall = isMergeAppConfigCall;
+/** Finds the `providers` array literal within an application config. */
+function findProvidersLiteral(config) {
+    for (const prop of config.properties) {
+        if (typescript_1.default.isPropertyAssignment(prop) &&
+            typescript_1.default.isIdentifier(prop.name) &&
+            prop.name.text === 'providers' &&
+            typescript_1.default.isArrayLiteralExpression(prop.initializer)) {
+            return prop.initializer;
+        }
+    }
+    return null;
+}
+exports.findProvidersLiteral = findProvidersLiteral;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../packages/schematics/angular/utility/standalone/util.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 { SchematicsException, Tree } from '@angular-devkit/schematics';\nimport ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';\nimport { Change, applyToUpdateRecorder } from '../change';\nimport { targetBuildNotFoundError } from '../project-targets';\nimport { getWorkspace } from '../workspace';\nimport { BrowserBuilderOptions } from '../workspace-models';\n\n/**\n * Finds the main file of a project.\n * @param tree File tree for the project.\n * @param projectName Name of the project in which to search.\n */\nexport async function getMainFilePath(tree: Tree, projectName: string): Promise<string> {\n  const workspace = await getWorkspace(tree);\n  const project = workspace.projects.get(projectName);\n  const buildTarget = project?.targets.get('build');\n\n  if (!buildTarget) {\n    throw targetBuildNotFoundError();\n  }\n\n  return ((buildTarget.options || {}) as unknown as BrowserBuilderOptions).main;\n}\n\n/**\n * Gets a TypeScript source file at a specific path.\n * @param tree File tree of a project.\n * @param path Path to the file.\n */\nexport function getSourceFile(tree: Tree, path: string): ts.SourceFile {\n  const content = tree.readText(path);\n  const source = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);\n\n  return source;\n}\n\n/** Finds the call to `bootstrapApplication` within a file. */\nexport function findBootstrapApplicationCall(tree: Tree, mainFilePath: string): ts.CallExpression {\n  const sourceFile = getSourceFile(tree, mainFilePath);\n  const localName = findImportLocalName(\n    sourceFile,\n    'bootstrapApplication',\n    '@angular/platform-browser',\n  );\n\n  if (localName) {\n    let result: ts.CallExpression | null = null;\n\n    sourceFile.forEachChild(function walk(node) {\n      if (\n        ts.isCallExpression(node) &&\n        ts.isIdentifier(node.expression) &&\n        node.expression.text === localName\n      ) {\n        result = node;\n      }\n\n      if (!result) {\n        node.forEachChild(walk);\n      }\n    });\n\n    if (result) {\n      return result;\n    }\n  }\n\n  throw new SchematicsException(`Could not find bootstrapApplication call in ${mainFilePath}`);\n}\n\n/**\n * Finds the local name of an imported symbol. Could be the symbol name itself or its alias.\n * @param sourceFile File within which to search for the import.\n * @param name Actual name of the import, not its local alias.\n * @param moduleName Name of the module from which the symbol is imported.\n */\nfunction findImportLocalName(\n  sourceFile: ts.SourceFile,\n  name: string,\n  moduleName: string,\n): string | null {\n  for (const node of sourceFile.statements) {\n    // Only look for top-level imports.\n    if (\n      !ts.isImportDeclaration(node) ||\n      !ts.isStringLiteral(node.moduleSpecifier) ||\n      node.moduleSpecifier.text !== moduleName\n    ) {\n      continue;\n    }\n\n    // Filter out imports that don't have the right shape.\n    if (\n      !node.importClause ||\n      !node.importClause.namedBindings ||\n      !ts.isNamedImports(node.importClause.namedBindings)\n    ) {\n      continue;\n    }\n\n    // Look through the elements of the declaration for the specific import.\n    for (const element of node.importClause.namedBindings.elements) {\n      if ((element.propertyName || element.name).text === name) {\n        // The local name is always in `name`.\n        return element.name.text;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Applies a set of changes to a file.\n * @param tree File tree of the project.\n * @param path Path to the file that is being changed.\n * @param changes Changes that should be applied to the file.\n */\nexport function applyChangesToFile(tree: Tree, path: string, changes: Change[]) {\n  if (changes.length > 0) {\n    const recorder = tree.beginUpdate(path);\n    applyToUpdateRecorder(recorder, changes);\n    tree.commitUpdate(recorder);\n  }\n}\n\n/** Checks whether a node is a call to `mergeApplicationConfig`. */\nexport function isMergeAppConfigCall(node: ts.Node): node is ts.CallExpression {\n  if (!ts.isCallExpression(node)) {\n    return false;\n  }\n\n  const localName = findImportLocalName(\n    node.getSourceFile(),\n    'mergeApplicationConfig',\n    '@angular/core',\n  );\n\n  return !!localName && ts.isIdentifier(node.expression) && node.expression.text === localName;\n}\n\n/** Finds the `providers` array literal within an application config. */\nexport function findProvidersLiteral(\n  config: ts.ObjectLiteralExpression,\n): ts.ArrayLiteralExpression | null {\n  for (const prop of config.properties) {\n    if (\n      ts.isPropertyAssignment(prop) &&\n      ts.isIdentifier(prop.name) &&\n      prop.name.text === 'providers' &&\n      ts.isArrayLiteralExpression(prop.initializer)\n    ) {\n      return prop.initializer;\n    }\n  }\n\n  return null;\n}\n"]}

package/utility/workspace-models.js

@@ -12,7 +12,7 @@ var ProjectType;
 (function (ProjectType) {
     ProjectType["Application"] = "application";
     ProjectType["Library"] = "library";
-})(ProjectType = exports.ProjectType || (exports.ProjectType = {}));
+})(ProjectType || (exports.ProjectType = ProjectType = {}));
 /**
  * An enum of the official Angular builders.
  * Each enum value provides the fully qualified name of the associated builder.
@@ -31,5 +31,5 @@ var Builders;
     Builders["DevServer"] = "@angular-devkit/build-angular:dev-server";
     Builders["ExtractI18n"] = "@angular-devkit/build-angular:extract-i18n";
     Builders["Protractor"] = "@angular-devkit/build-angular:protractor";
-})(Builders = exports.Builders || (exports.Builders = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLW1vZGVscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NjaGVtYXRpY3MvYW5ndWxhci91dGlsaXR5L3dvcmtzcGFjZS1tb2RlbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7O0FBRUgsSUFBWSxXQUdYO0FBSEQsV0FBWSxXQUFXO0lBQ3JCLDBDQUEyQixDQUFBO0lBQzNCLGtDQUFtQixDQUFBO0FBQ3JCLENBQUMsRUFIVyxXQUFXLEdBQVgsbUJBQVcsS0FBWCxtQkFBVyxRQUd0QjtBQUVEOzs7OztHQUtHO0FBQ0gsSUFBWSxRQVdYO0FBWEQsV0FBWSxRQUFRO0lBQ2xCLGdFQUFvRCxDQUFBO0lBQ3BELDJEQUErQyxDQUFBO0lBQy9DLDZEQUFpRCxDQUFBO0lBQ2pELHlEQUE2QyxDQUFBO0lBQzdDLDJEQUErQyxDQUFBO0lBQy9DLDBFQUE4RCxDQUFBO0lBQzlELGtFQUFzRCxDQUFBO0lBQ3RELGtFQUFzRCxDQUFBO0lBQ3RELHNFQUEwRCxDQUFBO0lBQzFELG1FQUF1RCxDQUFBO0FBQ3pELENBQUMsRUFYVyxRQUFRLEdBQVIsZ0JBQVEsS0FBUixnQkFBUSxRQVduQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgZW51bSBQcm9qZWN0VHlwZSB7XG4gIEFwcGxpY2F0aW9uID0gJ2FwcGxpY2F0aW9uJyxcbiAgTGlicmFyeSA9ICdsaWJyYXJ5Jyxcbn1cblxuLyoqXG4gKiBBbiBlbnVtIG9mIHRoZSBvZmZpY2lhbCBBbmd1bGFyIGJ1aWxkZXJzLlxuICogRWFjaCBlbnVtIHZhbHVlIHByb3ZpZGVzIHRoZSBmdWxseSBxdWFsaWZpZWQgbmFtZSBvZiB0aGUgYXNzb2NpYXRlZCBidWlsZGVyLlxuICogVGhpcyBlbnVtIGNhbiBiZSB1c2VkIHdoZW4gYW5hbHl6aW5nIHRoZSBgYnVpbGRlcmAgZmllbGRzIG9mIHByb2plY3QgY29uZmlndXJhdGlvbnMgZnJvbSB0aGVcbiAqIGBhbmd1bGFyLmpzb25gIHdvcmtzcGFjZSBmaWxlLlxuICovXG5leHBvcnQgZW51bSBCdWlsZGVycyB7XG4gIEFwcFNoZWxsID0gJ0Bhbmd1bGFyLWRldmtpdC9idWlsZC1hbmd1bGFyOmFwcC1zaGVsbCcsXG4gIFNlcnZlciA9ICdAYW5ndWxhci1kZXZraXQvYnVpbGQtYW5ndWxhcjpzZXJ2ZXInLFxuICBCcm93c2VyID0gJ0Bhbmd1bGFyLWRldmtpdC9idWlsZC1hbmd1bGFyOmJyb3dzZXInLFxuICBLYXJtYSA9ICdAYW5ndWxhci1kZXZraXQvYnVpbGQtYW5ndWxhcjprYXJtYScsXG4gIFRzTGludCA9ICdAYW5ndWxhci1kZXZraXQvYnVpbGQtYW5ndWxhcjp0c2xpbnQnLFxuICBEZXByZWNhdGVkTmdQYWNrYWdyID0gJ0Bhbmd1bGFyLWRldmtpdC9idWlsZC1uZy1wYWNrYWdyOmJ1aWxkJyxcbiAgTmdQYWNrYWdyID0gJ0Bhbmd1bGFyLWRldmtpdC9idWlsZC1hbmd1bGFyOm5nLXBhY2thZ3InLFxuICBEZXZTZXJ2ZXIgPSAnQGFuZ3VsYXItZGV2a2l0L2J1aWxkLWFuZ3VsYXI6ZGV2LXNlcnZlcicsXG4gIEV4dHJhY3RJMThuID0gJ0Bhbmd1bGFyLWRldmtpdC9idWlsZC1hbmd1bGFyOmV4dHJhY3QtaTE4bicsXG4gIFByb3RyYWN0b3IgPSAnQGFuZ3VsYXItZGV2a2l0L2J1aWxkLWFuZ3VsYXI6cHJvdHJhY3RvcicsXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRmlsZVJlcGxhY2VtZW50cyB7XG4gIHJlcGxhY2U6IHN0cmluZztcbiAgd2l0aDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJyb3dzZXJCdWlsZGVyQmFzZU9wdGlvbnMge1xuICBtYWluOiBzdHJpbmc7XG4gIHRzQ29uZmlnOiBzdHJpbmc7XG4gIGZpbGVSZXBsYWNlbWVudHM/OiBGaWxlUmVwbGFjZW1lbnRzW107XG4gIG91dHB1dFBhdGg/OiBzdHJpbmc7XG4gIGluZGV4Pzogc3RyaW5nO1xuICBwb2x5ZmlsbHM6IHN0cmluZztcbiAgYXNzZXRzPzogKG9iamVjdCB8IHN0cmluZylbXTtcbiAgc3R5bGVzPzogKG9iamVjdCB8IHN0cmluZylbXTtcbiAgc2NyaXB0cz86IChvYmplY3QgfCBzdHJpbmcpW107XG4gIHNvdXJjZU1hcD86IGJvb2xlYW47XG59XG5cbmV4cG9ydCB0eXBlIE91dHB1dEhhc2hpbmcgPSAnYWxsJyB8ICdtZWRpYScgfCAnbm9uZScgfCAnYnVuZGxlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQnJvd3NlckJ1aWxkZXJPcHRpb25zIGV4dGVuZHMgQnJvd3NlckJ1aWxkZXJCYXNlT3B0aW9ucyB7XG4gIHNlcnZpY2VXb3JrZXI/OiBib29sZWFuO1xuICBvcHRpbWl6YXRpb24/OiBib29sZWFuO1xuICBvdXRwdXRIYXNoaW5nPzogT3V0cHV0SGFzaGluZztcbiAgcmVzb3VyY2VzT3V0cHV0UGF0aD86IHN0cmluZztcbiAgbmFtZWRDaHVua3M/OiBib29sZWFuO1xuICBhb3Q/OiBib29sZWFuO1xuICBleHRyYWN0TGljZW5zZXM/OiBib29sZWFuO1xuICB2ZW5kb3JDaHVuaz86IGJvb2xlYW47XG4gIGJ1aWxkT3B0aW1pemVyPzogYm9vbGVhbjtcbiAgbmdzd0NvbmZpZ1BhdGg/OiBzdHJpbmc7XG4gIGJ1ZGdldHM/OiB7XG4gICAgdHlwZTogc3RyaW5nO1xuICAgIG1heGltdW1XYXJuaW5nPzogc3RyaW5nO1xuICAgIG1heGltdW1FcnJvcj86IHN0cmluZztcbiAgfVtdO1xuICB3ZWJXb3JrZXJUc0NvbmZpZz86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTZXJ2ZUJ1aWxkZXJPcHRpb25zIHtcbiAgYnJvd3NlclRhcmdldDogc3RyaW5nO1xufVxuZXhwb3J0IGludGVyZmFjZSBMaWJyYXJ5QnVpbGRlck9wdGlvbnMge1xuICB0c0NvbmZpZzogc3RyaW5nO1xuICBwcm9qZWN0OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VydmVyQnVpbGRlck9wdGlvbnMge1xuICBvdXRwdXRQYXRoOiBzdHJpbmc7XG4gIHRzQ29uZmlnOiBzdHJpbmc7XG4gIG1haW46IHN0cmluZztcbiAgZmlsZVJlcGxhY2VtZW50cz86IEZpbGVSZXBsYWNlbWVudHNbXTtcbiAgb3B0aW1pemF0aW9uPzpcbiAgICB8IGJvb2xlYW5cbiAgICB8IHtcbiAgICAgICAgc2NyaXB0cz86IGJvb2xlYW47XG4gICAgICAgIHN0eWxlcz86IGJvb2xlYW47XG4gICAgICB9O1xuICBzb3VyY2VNYXA/OlxuICAgIHwgYm9vbGVhblxuICAgIHwge1xuICAgICAgICBzY3JpcHRzPzogYm9vbGVhbjtcbiAgICAgICAgc3R5bGVzPzogYm9vbGVhbjtcbiAgICAgICAgaGlkZGVuPzogYm9vbGVhbjtcbiAgICAgICAgdmVuZG9yPzogYm9vbGVhbjtcbiAgICAgIH07XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQXBwU2hlbGxCdWlsZGVyT3B0aW9ucyB7XG4gIGJyb3dzZXJUYXJnZXQ6IHN0cmluZztcbiAgc2VydmVyVGFyZ2V0OiBzdHJpbmc7XG4gIHJvdXRlOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGVzdEJ1aWxkZXJPcHRpb25zIGV4dGVuZHMgUGFydGlhbDxCcm93c2VyQnVpbGRlckJhc2VPcHRpb25zPiB7XG4gIGthcm1hQ29uZmlnOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXh0cmFjdEkxOG5PcHRpb25zIHtcbiAgYnJvd3NlclRhcmdldDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEUyRU9wdGlvbnMge1xuICBwcm90cmFjdG9yQ29uZmlnOiBzdHJpbmc7XG4gIGRldlNlcnZlclRhcmdldDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJ1aWxkZXJUYXJnZXQ8VEJ1aWxkZXIgZXh0ZW5kcyBCdWlsZGVycywgVE9wdGlvbnM+IHtcbiAgYnVpbGRlcjogVEJ1aWxkZXI7XG4gIG9wdGlvbnM6IFRPcHRpb25zO1xuICBjb25maWd1cmF0aW9ucz86IHtcbiAgICBwcm9kdWN0aW9uOiBQYXJ0aWFsPFRPcHRpb25zPjtcbiAgICBba2V5OiBzdHJpbmddOiBQYXJ0aWFsPFRPcHRpb25zPjtcbiAgfTtcbn1cblxuZXhwb3J0IHR5cGUgTGlicmFyeUJ1aWxkZXJUYXJnZXQgPSBCdWlsZGVyVGFyZ2V0PEJ1aWxkZXJzLk5nUGFja2FnciwgTGlicmFyeUJ1aWxkZXJPcHRpb25zPjtcbmV4cG9ydCB0eXBlIEJyb3dzZXJCdWlsZGVyVGFyZ2V0ID0gQnVpbGRlclRhcmdldDxCdWlsZGVycy5Ccm93c2VyLCBCcm93c2VyQnVpbGRlck9wdGlvbnM+O1xuZXhwb3J0IHR5cGUgU2VydmVyQnVpbGRlclRhcmdldCA9IEJ1aWxkZXJUYXJnZXQ8QnVpbGRlcnMuU2VydmVyLCBTZXJ2ZXJCdWlsZGVyT3B0aW9ucz47XG5leHBvcnQgdHlwZSBBcHBTaGVsbEJ1aWxkZXJUYXJnZXQgPSBCdWlsZGVyVGFyZ2V0PEJ1aWxkZXJzLkFwcFNoZWxsLCBBcHBTaGVsbEJ1aWxkZXJPcHRpb25zPjtcbmV4cG9ydCB0eXBlIFRlc3RCdWlsZGVyVGFyZ2V0ID0gQnVpbGRlclRhcmdldDxCdWlsZGVycy5LYXJtYSwgVGVzdEJ1aWxkZXJPcHRpb25zPjtcbmV4cG9ydCB0eXBlIFNlcnZlQnVpbGRlclRhcmdldCA9IEJ1aWxkZXJUYXJnZXQ8QnVpbGRlcnMuRGV2U2VydmVyLCBTZXJ2ZUJ1aWxkZXJPcHRpb25zPjtcbmV4cG9ydCB0eXBlIEV4dHJhY3RJMThuQnVpbGRlclRhcmdldCA9IEJ1aWxkZXJUYXJnZXQ8QnVpbGRlcnMuRXh0cmFjdEkxOG4sIEV4dHJhY3RJMThuT3B0aW9ucz47XG5leHBvcnQgdHlwZSBFMkVCdWlsZGVyVGFyZ2V0ID0gQnVpbGRlclRhcmdldDxCdWlsZGVycy5Qcm90cmFjdG9yLCBFMkVPcHRpb25zPjtcblxuaW50ZXJmYWNlIFdvcmtzcGFjZUNMSVNjaGVtYSB7XG4gIHdhcm5pbmdzPzogUmVjb3JkPHN0cmluZywgYm9vbGVhbj47XG4gIHNjaGVtYXRpY0NvbGxlY3Rpb25zPzogc3RyaW5nW107XG59XG5leHBvcnQgaW50ZXJmYWNlIFdvcmtzcGFjZVNjaGVtYSB7XG4gIHZlcnNpb246IDE7XG4gIGNsaT86IFdvcmtzcGFjZUNMSVNjaGVtYTtcbiAgcHJvamVjdHM6IHtcbiAgICBba2V5OiBzdHJpbmddOiBXb3Jrc3BhY2VQcm9qZWN0PFByb2plY3RUeXBlLkFwcGxpY2F0aW9uIHwgUHJvamVjdFR5cGUuTGlicmFyeT47XG4gIH07XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgV29ya3NwYWNlUHJvamVjdDxUUHJvamVjdFR5cGUgZXh0ZW5kcyBQcm9qZWN0VHlwZSA9IFByb2plY3RUeXBlLkFwcGxpY2F0aW9uPiB7XG4gIC8qKlxuICAgKiBQcm9qZWN0IHR5cGUuXG4gICAqL1xuICBwcm9qZWN0VHlwZTogUHJvamVjdFR5cGU7XG5cbiAgcm9vdDogc3RyaW5nO1xuICBzb3VyY2VSb290OiBzdHJpbmc7XG4gIHByZWZpeDogc3RyaW5nO1xuXG4gIGNsaT86IFdvcmtzcGFjZUNMSVNjaGVtYTtcblxuICAvKipcbiAgICogVG9vbCBvcHRpb25zLlxuICAgKi9cbiAgYXJjaGl0ZWN0PzogV29ya3NwYWNlVGFyZ2V0czxUUHJvamVjdFR5cGU+O1xuICAvKipcbiAgICogVG9vbCBvcHRpb25zLlxuICAgKi9cbiAgdGFyZ2V0cz86IFdvcmtzcGFjZVRhcmdldHM8VFByb2plY3RUeXBlPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXb3Jrc3BhY2VUYXJnZXRzPFRQcm9qZWN0VHlwZSBleHRlbmRzIFByb2plY3RUeXBlID0gUHJvamVjdFR5cGUuQXBwbGljYXRpb24+IHtcbiAgYnVpbGQ/OiBUUHJvamVjdFR5cGUgZXh0ZW5kcyBQcm9qZWN0VHlwZS5MaWJyYXJ5ID8gTGlicmFyeUJ1aWxkZXJUYXJnZXQgOiBCcm93c2VyQnVpbGRlclRhcmdldDtcbiAgc2VydmVyPzogU2VydmVyQnVpbGRlclRhcmdldDtcbiAgdGVzdD86IFRlc3RCdWlsZGVyVGFyZ2V0O1xuICBzZXJ2ZT86IFNlcnZlQnVpbGRlclRhcmdldDtcbiAgZTJlPzogRTJFQnVpbGRlclRhcmdldDtcbiAgJ2FwcC1zaGVsbCc/OiBBcHBTaGVsbEJ1aWxkZXJUYXJnZXQ7XG4gICdleHRyYWN0LWkxOG4nPzogRXh0cmFjdEkxOG5CdWlsZGVyVGFyZ2V0O1xuICAvLyBUT0RPKGhhbnMpOiBjaGFuZ2UgdGhpcyBhbnkgdG8gdW5rbm93biB3aGVuIGdvb2dsZTMgc3VwcG9ydHMgVHlwZVNjcmlwdCAzLjAuXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZXhwbGljaXQtYW55XG4gIFtrZXk6IHN0cmluZ106IGFueTtcbn1cbiJdfQ==
+})(Builders || (exports.Builders = Builders = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/workspace/schema.js

@@ -12,5 +12,5 @@ var PackageManager;
     PackageManager["Npm"] = "npm";
     PackageManager["Pnpm"] = "pnpm";
     PackageManager["Yarn"] = "yarn";
-})(PackageManager = exports.PackageManager || (exports.PackageManager = {}));
-//# sourceMappingURL=data:application/json;base64,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
+})(PackageManager || (exports.PackageManager = PackageManager = {}));
+//# sourceMappingURL=data:application/json;base64,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