179 lines
8.4 KiB
JavaScript
Executable File
179 lines
8.4 KiB
JavaScript
Executable File
"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.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 jsonc_parser_1 = require("jsonc-parser");
|
|
const node_fs_1 = require("node:fs");
|
|
const node_module_1 = require("node:module");
|
|
const node_path_1 = require("node:path");
|
|
const node_vm_1 = require("node: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
|
|
const isFirstParty = /\/node_modules\/@(?:angular|schematics|nguniversal)\//.test(normalizedSchematicFile);
|
|
// Use value of defined option if present, otherwise default to first-party usage.
|
|
return schematicEncapsulation ?? isFirstParty;
|
|
}
|
|
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, node_path_1.resolve)(parentPath ?? process.cwd(), path) : path;
|
|
const referenceRequire = (0, node_module_1.createRequire)(__filename);
|
|
const schematicFile = referenceRequire.resolve(fullPath, { paths: [parentPath] });
|
|
if (shouldWrapSchematic(schematicFile, collectionDescription?.encapsulation)) {
|
|
const schematicPath = (0, node_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, node_module_1.createRequire)(__filename);
|
|
const schematicRequire = (0, node_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, node_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, node_fs_1.readFileSync)(schematicFile, 'utf8');
|
|
const script = new node_vm_1.Script(node_module_1.Module.wrap(schematicCode), {
|
|
filename: schematicFile,
|
|
lineOffset: 1,
|
|
});
|
|
const schematicModule = new node_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;
|
|
}
|