@rxap/plugin-library
Version:
This package provides generators and executors for managing and maintaining Nx plugin libraries. It includes functionality for generating index exports, fixing dependencies, generating JSON schemas, and more. It helps streamline the development process fo
654 lines • 31.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveLatestPackageVersion = resolveLatestPackageVersion;
exports.replaceLatestPackageVersionForProject = replaceLatestPackageVersionForProject;
exports.removePackageFromDependencies = removePackageFromDependencies;
exports.removeSelfReferenceFromDependencies = removeSelfReferenceFromDependencies;
exports.fixDependenciesGenerator = fixDependenciesGenerator;
const tslib_1 = require("tslib");
const devkit_1 = require("@nx/devkit");
const node_utilities_1 = require("@rxap/node-utilities");
const ts_morph_1 = require("@rxap/ts-morph");
const utilities_1 = require("@rxap/utilities");
const workspace_ts_morph_1 = require("@rxap/workspace-ts-morph");
const workspace_utilities_1 = require("@rxap/workspace-utilities");
const path_1 = require("path");
require("colors");
function resolveProjectDependencies(projectGraph, project, resolved = []) {
if (resolved.includes(project)) {
return [];
}
const dependencies = [];
const projectDependencies = projectGraph.dependencies[project];
for (const dependency of projectDependencies) {
if (!dependency.target.startsWith('npm:')) {
dependencies.push(dependency.target);
dependencies.push(...resolveProjectDependencies(projectGraph, dependency.target, [...resolved, dependency.target, project]));
}
}
return dependencies.filter((value, index, array) => array.indexOf(value) === index);
}
function getPackageListFromSourceFiles(project) {
const packageList = [];
project.getSourceFiles().forEach(sourceFile => {
sourceFile.getImportDeclarations().forEach(importDeclaration => {
const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
if (moduleSpecifier.startsWith('.')) {
return;
}
const match = moduleSpecifier.match(/^([^@][^/]+)\/.+$/) || moduleSpecifier.match(/^(@[^/]+\/[^/]+)\/.+/);
let packageName;
if (match) {
packageName = match[1];
}
else {
packageName = moduleSpecifier;
}
if (!packageList.includes(packageName)) {
packageList.push(packageName);
console.log(`Add package ${packageName} from source file ${sourceFile.getFilePath()}`);
}
});
});
return packageList
.filter((value, index, array) => array.indexOf(value) === index)
.filter(packageName => !PACKAGE_ADD_BLACK_LIST.some(regexOrString => typeof regexOrString === 'string' ?
regexOrString === packageName :
regexOrString.test(packageName)));
}
const TESTING_FILE_EXTENSIONS = [
'cypress.config.ts',
'.spec.ts',
'.e2e-spec.ts',
'.stories.ts',
'test-setup.ts',
'.cy.ts',
];
const TESTING_FOLDERS = ['cypress', '.storybook', 'compodoc', 'docs', '.nyc_output', 'coverage', '.angular'];
const PACKAGE_REMOVE_BLACK_LIST = ['tslib'];
const PACKAGE_ADD_BLACK_LIST = [
/@firebase/,
'fs',
'path',
'child_process',
'os',
'crypto',
'util',
'events',
'stream',
'assert',
'tty',
'net',
'dns',
'tls',
'http',
'https',
'zlib',
'url',
'querystring',
'punycode',
'string_decoder',
'http2',
'perf_hooks',
'worker_threads',
'v8',
'vm',
'async_hooks',
'inspector',
'trace_events',
'console',
'buffer',
'constants',
'v8',
'domain',
'readline',
'repl',
'timers',
'module',
'process',
'cluster',
'dgram',
'fs/promises',
'perf_hooks',
'readline',
'repl',
'string_decoder',
'tls/promises',
'trace_events',
'tty',
'worker_threads',
'zlib/promises',
'assert',
'async_hooks',
'buffer',
'child_process',
'console',
'crypto',
'dns/promises',
'domain',
'events',
'fs',
'http',
'http2',
'https',
'net',
'os',
'path',
'querystring',
'stream',
'timers',
'tls',
'tty',
'url',
'util',
'v8',
'vm',
'zlib',
'glob',
'fs-extra',
'express',
'axios',
];
const PACKAGE_PEER_DEPENDENCIES_BLACK_LIST = ['tslib'];
const PACKAGE_FORCED_PEER_DEPENDENCIES = ['rxjs', /@angular\//, /@nestjs\//, /@storybook\//, /@types\//];
function addDependedProjects(projectGraph, tree, packageName, projectRoot, dependencies) {
const projectName = (0, workspace_utilities_1.PackageNameToProjectName)(packageName);
const dependedProjectList = resolveProjectDependencies(projectGraph, projectName);
for (const dependedProject of dependedProjectList) {
const dependedPackageName = (0, workspace_utilities_1.ProjectNameToPackageName)(dependedProject);
if (!dependencies[dependedPackageName]) {
dependencies[dependedPackageName] = findBasePackageVersion(dependedPackageName, projectRoot);
}
}
}
function getUsedPackagesFromSourceRoot(tree, projectSourceRoot) {
const project = (0, ts_morph_1.CreateProject)();
(0, workspace_ts_morph_1.AddDir)(tree, projectSourceRoot, project, (fileName, path) => !path.includes('node_modules') &&
fileName.endsWith('.ts') &&
!TESTING_FOLDERS.map(folder => (0, path_1.join)(projectSourceRoot, folder)).some(folder => path.includes(folder)) &&
!TESTING_FILE_EXTENSIONS.some(ext => fileName.endsWith(ext)));
return getPackageListFromSourceFiles(project);
}
function getProjectPackageVersion(tree, projectName) {
var _a;
const packageJson = (0, workspace_utilities_1.GetProjectPackageJson)(tree, projectName);
return (_a = packageJson.version) !== null && _a !== void 0 ? _a : '*';
}
function fixDependenciesWithTsMorphProject(project, tree, projectRoot, packageJson) {
var _a, _b, _c, _d;
let peerDependencyList = [];
let dependencyList = [];
if (tree.exists((0, path_1.join)(projectRoot, 'src'))) {
const projectSourceRoot = (0, path_1.join)(projectRoot, 'src');
if (tree.exists((0, path_1.join)(projectSourceRoot, 'lib'))) {
const packageList = getUsedPackagesFromSourceRoot(tree, (0, path_1.join)(projectSourceRoot, 'lib'));
peerDependencyList = peerDependencyList.concat(packageList);
}
if (tree.exists((0, path_1.join)(projectSourceRoot, 'generators'))) {
const packageList = getUsedPackagesFromSourceRoot(tree, (0, path_1.join)(projectSourceRoot, 'generators'));
dependencyList = dependencyList.concat(packageList);
}
if (tree.exists((0, path_1.join)(projectSourceRoot, 'migrations'))) {
const packageList = getUsedPackagesFromSourceRoot(tree, (0, path_1.join)(projectSourceRoot, 'migrations'));
dependencyList = dependencyList.concat(packageList);
}
if (tree.exists((0, path_1.join)(projectSourceRoot, 'schematics'))) {
const packageList = getUsedPackagesFromSourceRoot(tree, (0, path_1.join)(projectSourceRoot, 'schematics'));
dependencyList = dependencyList.concat(packageList);
}
if (tree.exists((0, path_1.join)(projectSourceRoot, 'executors'))) {
const packageList = getUsedPackagesFromSourceRoot(tree, (0, path_1.join)(projectSourceRoot, 'executors'));
dependencyList = dependencyList.concat(packageList);
}
}
console.log('Check secondary entry points'.cyan);
for (const ngPackageJsonFilePath of (0, workspace_utilities_1.ForEachSecondaryEntryPoint)(tree, projectRoot)) {
const path = (0, path_1.dirname)(ngPackageJsonFilePath);
console.log('Check secondary entry point: ' + path.blue);
if (tree.exists((0, path_1.join)(path, 'src'))) {
const entryPointSourceRoot = (0, path_1.join)(path, 'src');
if (tree.exists((0, path_1.join)(entryPointSourceRoot, 'lib'))) {
const packageList = getUsedPackagesFromSourceRoot(tree, (0, path_1.join)(entryPointSourceRoot, 'lib'));
peerDependencyList = peerDependencyList.concat(packageList);
}
}
}
peerDependencyList = peerDependencyList.filter(peerDependency => !dependencyList.includes(peerDependency));
peerDependencyList = peerDependencyList.filter((0, utilities_1.unique)());
dependencyList = dependencyList.filter((0, utilities_1.unique)());
const addedPackageList = [];
const changedPackageList = [];
const removedPackageList = [];
const unknownPackageList = [];
(_a = packageJson.peerDependencies) !== null && _a !== void 0 ? _a : (packageJson.peerDependencies = {});
(_b = packageJson.dependencies) !== null && _b !== void 0 ? _b : (packageJson.dependencies = {});
const { dependencies, peerDependencies, } = packageJson;
for (const packageName of Object.keys(peerDependencies)) {
if (!peerDependencyList.includes(packageName) && !PACKAGE_REMOVE_BLACK_LIST.includes(packageName)) {
removedPackageList.push(`${packageName}@${peerDependencies[packageName]} from peerDependencies`);
delete peerDependencies[packageName];
}
}
for (const packageName of Object.keys(dependencies)) {
if (!dependencyList.includes(packageName) && !PACKAGE_REMOVE_BLACK_LIST.includes(packageName)) {
removedPackageList.push(`${packageName}@${dependencies[packageName]} from dependencies`);
delete dependencies[packageName];
}
}
for (const packageName of peerDependencyList) {
if ((0, workspace_utilities_1.HasProjectWithPackageName)(packageName)) {
peerDependencies[packageName] = (_c = peerDependencies[packageName]) !== null && _c !== void 0 ? _c : '^' + getProjectPackageVersion(tree, (0, workspace_utilities_1.PackageNameToProjectName)(packageName));
}
else {
const version = findBasePackageVersion(packageName, projectRoot);
if (peerDependencies[packageName]) {
if (peerDependencies[packageName] !== version) {
changedPackageList.push(`${packageName}@${peerDependencies[packageName]} -> ${version}`);
peerDependencies[packageName] = version;
}
}
else {
addedPackageList.push(`${packageName}@${version}`);
peerDependencies[packageName] = version;
}
if (version === 'latest') {
unknownPackageList.push(packageName);
}
peerDependencies[packageName] = version;
}
}
for (const packageName of dependencyList) {
if ((0, workspace_utilities_1.HasProjectWithPackageName)(packageName)) {
dependencies[packageName] = (_d = dependencies[packageName]) !== null && _d !== void 0 ? _d : '^' + getProjectPackageVersion(tree, (0, workspace_utilities_1.PackageNameToProjectName)(packageName));
}
else {
const version = findBasePackageVersion(packageName, projectRoot);
if (dependencies[packageName]) {
if (dependencies[packageName] !== version) {
changedPackageList.push(`${packageName}@${dependencies[packageName]} -> ${version}`);
dependencies[packageName] = version;
}
}
else {
addedPackageList.push(`${packageName}@${version}`);
dependencies[packageName] = version;
}
if (version === 'latest') {
unknownPackageList.push(packageName);
}
dependencies[packageName] = version;
}
}
if ((0, workspace_utilities_1.IsAngularProject)(project)) {
if (!(0, workspace_utilities_1.HasNgPackageJson)(tree, projectRoot)) {
throw new Error('The project is an angular project but does not have a ng-package.json file');
}
(0, workspace_utilities_1.UpdateNgPackageJson)(tree, (ngPackageJson) => {
var _a;
(_a = ngPackageJson.allowedNonPeerDependencies) !== null && _a !== void 0 ? _a : (ngPackageJson.allowedNonPeerDependencies = []);
(0, utilities_1.CoerceArrayItems)(ngPackageJson.allowedNonPeerDependencies, dependencyList);
}, { projectRoot });
}
return {
addedPackageList,
changedPackageList,
removedPackageList,
unknownPackageList,
};
}
const PACKAGE_VERSION_MAP = {};
function parseJsonFile(tree_1, path_2) {
return tslib_1.__awaiter(this, arguments, void 0, function* (tree, path, retries = 3, sleep = 3000) {
if (!tree.exists(path)) {
throw new Error(`Cannot parse json object. File ${path} not found`);
}
let retryCount = 0;
let lastError;
do {
try {
const content = tree.read(path).toString('utf-8');
return JSON.parse(content);
}
catch (e) {
lastError = e;
retryCount++;
if (retryCount < retries) {
yield new Promise(resolve => setTimeout(resolve, sleep * retryCount));
}
}
} while (retryCount < retries);
throw new Error(`Failed to parse json file ${path}: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`);
});
}
function loadAvailablePackageVersion(tree, projectRoot) {
return tslib_1.__awaiter(this, void 0, void 0, function* () {
PACKAGE_VERSION_MAP[projectRoot] = {};
function updateMap(dependencies) {
for (const [packageName, version] of Object.entries(dependencies !== null && dependencies !== void 0 ? dependencies : {})) {
if (version !== '*' && !(0, workspace_utilities_1.HasProjectWithPackageName)(packageName)) {
if (!PACKAGE_VERSION_MAP[packageName]) {
PACKAGE_VERSION_MAP[projectRoot][packageName] = version;
}
}
}
}
function pinVersionToMajorRelease(versionMap) {
for (const [packageName, version] of Object.entries(versionMap)) {
if (version.startsWith('~')) {
versionMap[packageName] = version.replace('~', '^');
}
if (version.match(/^\d+/)) {
versionMap[packageName] = `^${version}`;
}
}
}
let workingDirectory = '/' + projectRoot;
let lastWorkingDirectory = '';
do {
if (tree.exists((0, path_1.join)(workingDirectory, 'package.json'))) {
const packageJson = yield parseJsonFile(tree, (0, path_1.join)(workingDirectory, 'package.json'));
updateMap(packageJson.dependencies);
updateMap(packageJson.peerDependencies);
updateMap(packageJson.devDependencies);
updateMap(packageJson.optionalDependencies);
}
lastWorkingDirectory = workingDirectory;
workingDirectory = (0, path_1.join)(workingDirectory, '..');
} while (workingDirectory !== lastWorkingDirectory);
pinVersionToMajorRelease(PACKAGE_VERSION_MAP[projectRoot]);
});
}
function findBasePackageVersion(packageName, projectRoot) {
if (!PACKAGE_VERSION_MAP[projectRoot]) {
throw new Error('Package version map not loaded. Ensure the loadAvailablePackageVersion function is called before.');
}
if (PACKAGE_VERSION_MAP[projectRoot][packageName]) {
return PACKAGE_VERSION_MAP[projectRoot][packageName];
}
return 'latest';
}
function printReport(projectName, { addedPackageList, changedPackageList, removedPackageList, unknownPackageList, }) {
console.log(`==================== Report for project ${projectName}`);
console.log('========== Peer dependencies:');
if (addedPackageList.length) {
console.log(`Added packages: ${addedPackageList.length}`);
console.log(addedPackageList.join('\n'));
}
if (changedPackageList.length) {
console.log(`Changed packages: ${changedPackageList.length}`);
console.log(changedPackageList.join('\n'));
}
if (removedPackageList.length) {
console.log(`Removed packages: ${removedPackageList.length}`);
console.log(removedPackageList.join('\n'));
}
if (unknownPackageList.length) {
console.log(`Unknown packages: ${unknownPackageList.length}`);
console.log(unknownPackageList.join('\n'));
}
}
function skipProject(tree, options, project, projectName) {
if (options.project === projectName) {
return false;
}
if ((0, workspace_utilities_1.SkipNonPublishableProject)(tree, options, project, projectName)) {
return true;
}
return false;
}
const RESOLVED_PACKAGE_VERSION_MAP = {};
function resolveLatestPackageVersion(packageName) {
return tslib_1.__awaiter(this, void 0, void 0, function* () {
if (RESOLVED_PACKAGE_VERSION_MAP[packageName]) {
return RESOLVED_PACKAGE_VERSION_MAP[packageName];
}
const latestVersion = yield (0, node_utilities_1.GetLatestPackageVersion)(packageName);
if (latestVersion) {
RESOLVED_PACKAGE_VERSION_MAP[packageName] = latestVersion;
}
return latestVersion;
});
}
function replaceLatestPackageVersionForProject(tree, projectName) {
return tslib_1.__awaiter(this, void 0, void 0, function* () {
console.log(`Replace latest package version for project ${projectName}`);
const projectRoot = (0, workspace_utilities_1.GetProjectRoot)(tree, projectName);
const packageJson = yield parseJsonFile(tree, (0, path_1.join)(projectRoot, 'package.json'));
const dependencies = packageJson.dependencies;
const peerDependencies = packageJson.peerDependencies;
const devDependencies = packageJson.devDependencies;
const optionalDependencies = packageJson.optionalDependencies;
function replaceLatestPackageVersion(dependencies) {
return tslib_1.__awaiter(this, void 0, void 0, function* () {
for (const [packageName, version] of Object.entries(dependencies !== null && dependencies !== void 0 ? dependencies : {})) {
if (version === 'latest') {
const resolvedVersion = yield resolveLatestPackageVersion(packageName);
if (resolvedVersion !== 'latest' && resolvedVersion) {
dependencies[packageName] = resolvedVersion;
console.log(`Replace latest version of ${packageName} with ${resolvedVersion}`);
}
}
}
});
}
yield replaceLatestPackageVersion(dependencies);
yield replaceLatestPackageVersion(peerDependencies);
yield replaceLatestPackageVersion(devDependencies);
yield replaceLatestPackageVersion(optionalDependencies);
(0, workspace_utilities_1.CoerceFile)(tree, (0, path_1.join)(projectRoot, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n', true);
});
}
function removePackageFromDependencies(packageName, dependencies) {
if (dependencies === null || dependencies === void 0 ? void 0 : dependencies[packageName]) {
delete dependencies[packageName];
}
}
function removeSelfReferenceFromDependencies(projectName, { dependencies, peerDependencies, devDependencies, optionalDependencies, }) {
const packageName = (0, workspace_utilities_1.ProjectNameToPackageName)(projectName);
removePackageFromDependencies(packageName, dependencies);
removePackageFromDependencies(packageName, peerDependencies);
removePackageFromDependencies(packageName, devDependencies);
removePackageFromDependencies(packageName, optionalDependencies);
}
function coerceTsLib(latestTsLibVersion, packageJson) {
var _a;
(_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : (packageJson.dependencies = {});
if (latestTsLibVersion && !packageJson.dependencies['tslib']) {
packageJson.dependencies['tslib'] = latestTsLibVersion;
}
}
function preferPackageAsPeerDependency(packageJson) {
var _a, _b;
(_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : (packageJson.dependencies = {});
(_b = packageJson.peerDependencies) !== null && _b !== void 0 ? _b : (packageJson.peerDependencies = {});
for (const [name] of Object.entries(packageJson.dependencies)) {
if (packageJson.peerDependencies[name]) {
delete packageJson.dependencies[name];
}
}
}
function removeBannedPeerDependencies(packageJson) {
var _a;
(_a = packageJson.peerDependencies) !== null && _a !== void 0 ? _a : (packageJson.peerDependencies = {});
for (const banned of PACKAGE_PEER_DEPENDENCIES_BLACK_LIST) {
if (packageJson.peerDependencies[banned]) {
delete packageJson.peerDependencies[banned];
}
}
}
function forceAllDependenciesAsDependencies(packageJson) {
packageJson.dependencies = Object.assign(Object.assign({}, packageJson.dependencies), packageJson.peerDependencies);
packageJson.peerDependencies = {};
}
function setDependencyVersionFromRootPackageJson(packageJson, rootPackageJson) {
var _a, _b, _c, _d, _e;
(_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : (packageJson.dependencies = {});
for (const [packageName, version] of Object.entries(packageJson.dependencies)) {
packageJson.dependencies[packageName] = (_e = (_c = (_b = rootPackageJson.dependencies) === null || _b === void 0 ? void 0 : _b[packageName]) !== null && _c !== void 0 ? _c : (_d = rootPackageJson.devDependencies) === null || _d === void 0 ? void 0 : _d[packageName]) !== null && _e !== void 0 ? _e : version;
}
}
function forcePeerDependencies(packageJson) {
var _a, _b;
(_a = packageJson.peerDependencies) !== null && _a !== void 0 ? _a : (packageJson.peerDependencies = {});
(_b = packageJson.dependencies) !== null && _b !== void 0 ? _b : (packageJson.dependencies = {});
for (const forcedPeerDependency of PACKAGE_FORCED_PEER_DEPENDENCIES) {
for (const [packageName, version] of Object.entries(packageJson.dependencies)) {
if (forcedPeerDependency instanceof RegExp ? forcedPeerDependency.test(packageName) : forcedPeerDependency === packageName) {
packageJson.peerDependencies[packageName] = version;
delete packageJson.dependencies[packageName];
}
}
}
}
function forcePackagesAsDependencies(tree, packageJson, packages, projectRoot) {
var _a, _b;
(_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : (packageJson.dependencies = {});
(_b = packageJson.peerDependencies) !== null && _b !== void 0 ? _b : (packageJson.peerDependencies = {});
for (const packageName of Object.keys(packageJson.peerDependencies)) {
if (packages.includes(packageName)) {
packageJson.dependencies[packageName] = packageJson.peerDependencies[packageName];
delete packageJson.peerDependencies[packageName];
}
}
for (const packageName of packages) {
if (!packageJson.dependencies[packageName]) {
if ((0, workspace_utilities_1.HasProjectWithPackageName)(packageName)) {
packageJson.dependencies[packageName] = getProjectPackageVersion(tree, (0, workspace_utilities_1.PackageNameToProjectName)(packageName));
}
else {
packageJson.dependencies[packageName] = findBasePackageVersion(packageName, projectRoot);
}
}
}
}
function forcePackagesAsPeerDependencies(tree, packageJson, packages, projectRoot) {
var _a, _b;
(_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : (packageJson.dependencies = {});
(_b = packageJson.peerDependencies) !== null && _b !== void 0 ? _b : (packageJson.peerDependencies = {});
for (const packageName of Object.keys(packageJson.dependencies)) {
if (packages.includes(packageName)) {
packageJson.peerDependencies[packageName] = packageJson.dependencies[packageName];
delete packageJson.dependencies[packageName];
}
}
for (const packageName of packages) {
if (!packageJson.peerDependencies[packageName]) {
if ((0, workspace_utilities_1.HasProjectWithPackageName)(packageName)) {
packageJson.peerDependencies[packageName] = getProjectPackageVersion(tree, (0, workspace_utilities_1.PackageNameToProjectName)(packageName));
}
else {
packageJson.peerDependencies[packageName] = findBasePackageVersion(packageName, projectRoot);
}
}
}
}
/**
* This generator tries to fix the dependencies in the project.json of the project
*
* 1. Load all not-test typescript files from the project
* 1.1. Find all import statements
* a. If a project with the package name exists add it to the peerDependencies with version '*'. (skip if the package is already in the dependencies)
* b. If external package add it to the peerDependencies with the version from a parent package.json or 'latest' if not found.
* 2. Load all test typescript files from the project
* 2.1. Find all import statements
* a. If a project with the package name exists add it to the devDependencies with version '*'. (skip if the package is already in the dependencies)
* - for each project that is use in the test files add it direct and indirect dependencies to the devDependencies TODO : check if that is required
* b. If external package add it to the devDependencies with the version from a parent package.json or 'latest' if not found.
*
* 3. print a report about the changes
*
* @param tree
* @param options
*/
function fixDependenciesGenerator(tree, options) {
return tslib_1.__awaiter(this, void 0, void 0, function* () {
console.log('Fix dependencies');
if (options.reset || options.resetAll) {
console.log('Reset dependencies');
for (const [projectName, project] of (0, devkit_1.getProjects)(tree).entries()) {
const projectRoot = project.root;
if (skipProject(tree, options, project, projectName)) {
continue;
}
const packageJson = yield parseJsonFile(tree, `${projectRoot}/package.json`);
if (options.resetAll) {
packageJson.dependencies = {};
}
packageJson.peerDependencies = {};
packageJson.devDependencies = {};
packageJson.optionalDependencies = {};
(0, workspace_utilities_1.CoerceFile)(tree, `${projectRoot}/package.json`, JSON.stringify(packageJson, null, 2) + '\n', true);
}
}
const rootPackageJson = (0, workspace_utilities_1.GetRootPackageJson)(tree);
console.log('Root package.json loaded');
const projectGraph = yield (0, devkit_1.createProjectGraphAsync)();
console.log('Project graph created');
(0, workspace_utilities_1.LoadProjectToPackageMapping)(tree, projectGraph);
const unknownPackageMap = {};
const latestTsLibVersion = yield resolveLatestPackageVersion('tslib');
console.log('Start fixing dependencies');
for (const [projectName, project] of (0, devkit_1.getProjects)(tree).entries()) {
const projectRoot = project.root;
if (skipProject(tree, options, project, projectName)) {
continue;
}
console.log(`Fix dependencies for project ${projectName}`);
yield loadAvailablePackageVersion(tree, projectRoot);
(0, workspace_utilities_1.UpdatePackageJson)(tree, packageJson => {
var _a, _b, _c, _d, _e, _f;
(_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : (packageJson.dependencies = {});
(_b = packageJson.peerDependencies) !== null && _b !== void 0 ? _b : (packageJson.peerDependencies = {});
(_c = packageJson.devDependencies) !== null && _c !== void 0 ? _c : (packageJson.devDependencies = {});
(_d = packageJson.optionalDependencies) !== null && _d !== void 0 ? _d : (packageJson.optionalDependencies = {});
preferPackageAsPeerDependency(packageJson);
coerceTsLib(latestTsLibVersion, packageJson);
const peerReport = fixDependenciesWithTsMorphProject(project, tree, projectRoot, packageJson);
removeSelfReferenceFromDependencies(projectName, packageJson);
removeBannedPeerDependencies(packageJson);
if (options.onlyDependencies) {
forceAllDependenciesAsDependencies(packageJson);
}
if ((_e = options.dependencies) === null || _e === void 0 ? void 0 : _e.length) {
forcePackagesAsDependencies(tree, packageJson, options.dependencies, projectRoot);
}
if ((_f = options.peerDependencies) === null || _f === void 0 ? void 0 : _f.length) {
forcePackagesAsPeerDependencies(tree, packageJson, options.peerDependencies, projectRoot);
}
setDependencyVersionFromRootPackageJson(packageJson, rootPackageJson);
forcePeerDependencies(packageJson);
printReport(projectName, peerReport);
unknownPackageMap[projectName] = peerReport.unknownPackageList.filter((packageName, index, self) => self.indexOf(packageName) === index);
}, { basePath: projectRoot });
}
console.log('Finished fixing dependencies');
const unknownPackageMapToProject = {};
for (const [projectName, packageList] of Object.entries(unknownPackageMap)) {
for (const packageName of packageList) {
if (!unknownPackageMapToProject[packageName]) {
unknownPackageMapToProject[packageName] = [];
}
unknownPackageMapToProject[packageName].push(projectName);
}
}
if (Object.keys(unknownPackageMapToProject).length) {
console.log(`============================================================`);
console.log(`Unknown packages: ${Object.keys(unknownPackageMapToProject).length}`);
console.log(Object.entries(unknownPackageMapToProject)
.map(([packageName, projectNameList]) => `${packageName}: ${projectNameList.join(', ')}`)
.join('\n'));
console.log('============================================================');
console.log('Use the option --resolve to replace all latest version with the latest version from npm');
if (options.strict) {
throw new Error('Packages with unknown version found');
}
}
if (options.resolve) {
for (const [projectName] of Object.entries(unknownPackageMap)) {
yield replaceLatestPackageVersionForProject(tree, projectName);
}
}
});
}
exports.default = fixDependenciesGenerator;
//# sourceMappingURL=generator.js.map