@angular/cli
Version:
CLI tool for Angular
181 lines (180 loc) • 8.54 kB
JavaScript
;
/**
* @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.dev/license
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.SchematicEngineHost = void 0;
const schematics_1 = require("@angular-devkit/schematics");
const tools_1 = require("@angular-devkit/schematics/tools");
const fs_1 = require("fs");
const jsonc_parser_1 = require("jsonc-parser");
const module_1 = require("module");
const path_1 = require("path");
const vm_1 = require("vm");
const error_1 = require("../../utilities/error");
/**
* Environment variable to control schematic package redirection
*/
const schematicRedirectVariable = process.env['NG_SCHEMATIC_REDIRECT']?.toLowerCase();
function shouldWrapSchematic(schematicFile, schematicEncapsulation) {
// Check environment variable if present
switch (schematicRedirectVariable) {
case '0':
case 'false':
case 'off':
case 'none':
return false;
case 'all':
return true;
}
const normalizedSchematicFile = schematicFile.replace(/\\/g, '/');
// Never wrap the internal update schematic when executed directly
// It communicates with the update command via `global`
// But we still want to redirect schematics located in `@angular/cli/node_modules`.
if (normalizedSchematicFile.includes('node_modules/@angular/cli/') &&
!normalizedSchematicFile.includes('node_modules/@angular/cli/node_modules/')) {
return false;
}
// @angular/pwa uses dynamic imports which causes `[1] 2468039 segmentation fault` when wrapped.
// We should remove this when make `importModuleDynamically` work.
// See: https://nodejs.org/docs/latest-v14.x/api/vm.html
if (normalizedSchematicFile.includes('@angular/pwa')) {
return false;
}
// Check for first-party Angular schematic packages
// Angular schematics are safe to use in the wrapped VM context
if (/\/node_modules\/@(?:angular|schematics|nguniversal)\//.test(normalizedSchematicFile)) {
return true;
}
// Otherwise use the value of the schematic collection's encapsulation option (current default of false)
return schematicEncapsulation;
}
class SchematicEngineHost extends tools_1.NodeModulesEngineHost {
_resolveReferenceString(refString, parentPath, collectionDescription) {
const [path, name] = refString.split('#', 2);
// Mimic behavior of ExportStringRef class used in default behavior
const fullPath = path[0] === '.' ? (0, path_1.resolve)(parentPath ?? process.cwd(), path) : path;
const referenceRequire = (0, module_1.createRequire)(__filename);
const schematicFile = referenceRequire.resolve(fullPath, { paths: [parentPath] });
if (shouldWrapSchematic(schematicFile, !!collectionDescription?.encapsulation)) {
const schematicPath = (0, path_1.dirname)(schematicFile);
const moduleCache = new Map();
const factoryInitializer = wrap(schematicFile, schematicPath, moduleCache, name || 'default');
const factory = factoryInitializer();
if (!factory || typeof factory !== 'function') {
return null;
}
return { ref: factory, path: schematicPath };
}
// All other schematics use default behavior
return super._resolveReferenceString(refString, parentPath, collectionDescription);
}
}
exports.SchematicEngineHost = SchematicEngineHost;
/**
* Minimal shim modules for legacy deep imports of `@schematics/angular`
*/
const legacyModules = {
'@schematics/angular/utility/config': {
getWorkspace(host) {
const path = '/.angular.json';
const data = host.read(path);
if (!data) {
throw new schematics_1.SchematicsException(`Could not find (${path})`);
}
return (0, jsonc_parser_1.parse)(data.toString(), [], { allowTrailingComma: true });
},
},
'@schematics/angular/utility/project': {
buildDefaultPath(project) {
const root = project.sourceRoot ? `/${project.sourceRoot}/` : `/${project.root}/src/`;
return `${root}${project.projectType === 'application' ? 'app' : 'lib'}`;
},
},
};
/**
* Wrap a JavaScript file in a VM context to allow specific Angular dependencies to be redirected.
* This VM setup is ONLY intended to redirect dependencies.
*
* @param schematicFile A JavaScript schematic file path that should be wrapped.
* @param schematicDirectory A directory that will be used as the location of the JavaScript file.
* @param moduleCache A map to use for caching repeat module usage and proper `instanceof` support.
* @param exportName An optional name of a specific export to return. Otherwise, return all exports.
*/
function wrap(schematicFile, schematicDirectory, moduleCache, exportName) {
const hostRequire = (0, module_1.createRequire)(__filename);
const schematicRequire = (0, module_1.createRequire)(schematicFile);
const customRequire = function (id) {
if (legacyModules[id]) {
// Provide compatibility modules for older versions of @angular/cdk
return legacyModules[id];
}
else if (id.startsWith('schematics:')) {
// Schematics built-in modules use the `schematics` scheme (similar to the Node.js `node` scheme)
const builtinId = id.slice(11);
const builtinModule = loadBuiltinModule(builtinId);
if (!builtinModule) {
throw new Error(`Unknown schematics built-in module '${id}' requested from schematic '${schematicFile}'`);
}
return builtinModule;
}
else if (id.startsWith('@angular-devkit/') || id.startsWith('@schematics/')) {
// Files should not redirect `@angular/core` and instead use the direct
// dependency if available. This allows old major version migrations to continue to function
// even though the latest major version may have breaking changes in `@angular/core`.
if (id.startsWith('@angular-devkit/core')) {
try {
return schematicRequire(id);
}
catch (e) {
(0, error_1.assertIsError)(e);
if (e.code !== 'MODULE_NOT_FOUND') {
throw e;
}
}
}
// Resolve from inside the `@angular/cli` project
return hostRequire(id);
}
else if (id.startsWith('.') || id.startsWith('@angular/cdk')) {
// Wrap relative files inside the schematic collection
// Also wrap `@angular/cdk`, it contains helper utilities that import core schematic packages
// Resolve from the original file
const modulePath = schematicRequire.resolve(id);
// Use cached module if available
const cachedModule = moduleCache.get(modulePath);
if (cachedModule) {
return cachedModule;
}
// Do not wrap vendored third-party packages or JSON files
if (!/[/\\]node_modules[/\\]@schematics[/\\]angular[/\\]third_party[/\\]/.test(modulePath) &&
!modulePath.endsWith('.json')) {
// Wrap module and save in cache
const wrappedModule = wrap(modulePath, (0, path_1.dirname)(modulePath), moduleCache)();
moduleCache.set(modulePath, wrappedModule);
return wrappedModule;
}
}
// All others are required directly from the original file
return schematicRequire(id);
};
// Setup a wrapper function to capture the module's exports
const schematicCode = (0, fs_1.readFileSync)(schematicFile, 'utf8');
const script = new vm_1.Script(module_1.Module.wrap(schematicCode), {
filename: schematicFile,
lineOffset: 1,
});
const schematicModule = new module_1.Module(schematicFile);
const moduleFactory = script.runInThisContext();
return () => {
moduleFactory(schematicModule.exports, customRequire, schematicModule, schematicFile, schematicDirectory);
return exportName ? schematicModule.exports[exportName] : schematicModule.exports;
};
}
function loadBuiltinModule(id) {
return undefined;
}