@rxap/xml-parser/src/generators/init/generator.js

Provides a set of decorators and services for parsing and serializing XML documents into TypeScript classes. It simplifies the process of mapping XML elements and attributes to class properties, handling data validation, and serializing objects back into

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.initGenerator = initGenerator;
const tslib_1 = require("tslib");
const devkit_1 = require("@nx/devkit");
const path_1 = require("path");
function initGenerator(tree, options) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        var _a, _b, _c, _d, _e;
        const packageJsonFilePath = (0, path_1.relative)(tree.root, (0, path_1.join)(__dirname, '..', '..', '..', 'package.json'));
        if (!tree.exists(packageJsonFilePath)) {
            console.error('package.json not found in: ' + packageJsonFilePath);
            return;
        }
        const { peerDependencies, name: packageName } = JSON.parse(tree.read(packageJsonFilePath, 'utf-8'));
        console.log(`Coerce peer dependencies for package: ${packageName}`);
        if (!peerDependencies || !Object.keys(peerDependencies).length) {
            console.log('No peer dependencies found');
            return;
        }
        console.log(`Peer dependencies: ${Object.keys(peerDependencies).join(', ')}`);
        const rootPackageJson = JSON.parse(tree.read('package.json', 'utf-8'));
        let isDevDependency = !!((_a = rootPackageJson.devDependencies) === null || _a === void 0 ? void 0 : _a[packageName]);
        if (isDevDependency &&
            [/^@rxap\/ngx/, /^@rxap\/nest/].some((rx) => rx.test(packageName))) {
            (_b = rootPackageJson.dependencies) !== null && _b !== void 0 ? _b : (rootPackageJson.dependencies = {});
            rootPackageJson.dependencies[packageName] =
                rootPackageJson.devDependencies[packageName];
            delete rootPackageJson.devDependencies[packageName];
            isDevDependency = false;
            tree.write('package.json', JSON.stringify(rootPackageJson, null, 2));
        }
        if (!isDevDependency && [
            /^@rxap\/plugin/,
            /^@rxap\/workspace/,
            /@rxap\/schematic/,
        ]) {
            (_c = rootPackageJson.devDependencies) !== null && _c !== void 0 ? _c : (rootPackageJson.devDependencies = {});
            rootPackageJson.devDependencies[packageName] =
                rootPackageJson.dependencies[packageName];
            delete rootPackageJson.dependencies[packageName];
            isDevDependency = true;
            tree.write('package.json', JSON.stringify(rootPackageJson, null, 2));
        }
        const missingPeerDependencies = Object.entries(peerDependencies)
            .filter(([dep]) => {
            var _a, _b;
            return !((_a = rootPackageJson.dependencies) === null || _a === void 0 ? void 0 : _a[dep]) &&
                !((_b = rootPackageJson.devDependencies) === null || _b === void 0 ? void 0 : _b[dep]);
        })
            .reduce((acc, [dep, version]) => (Object.assign(Object.assign({}, acc), { [dep]: version })), {});
        if (!Object.keys(missingPeerDependencies).length) {
            console.log('No missing peer dependencies');
            return;
        }
        if (isDevDependency) {
            (0, devkit_1.addDependenciesToPackageJson)(tree, {}, missingPeerDependencies);
        }
        else {
            (0, devkit_1.addDependenciesToPackageJson)(tree, missingPeerDependencies, {});
        }
        yield (0, devkit_1.formatFiles)(tree);
        (0, devkit_1.installPackagesTask)(tree);
        for (const peer of Object.keys(missingPeerDependencies)) {
            console.log(`Peer dependency ${peer} added to package.json`);
            const peerPackageJsonFilePath = (0, path_1.join)('node_modules', ...peer.split('/'), 'package.json');
            if (!tree.exists(peerPackageJsonFilePath)) {
                console.log(`Peer dependency ${peer} has no package.json`);
                continue;
            }
            const { generators, schematics } = JSON.parse(tree.read(peerPackageJsonFilePath, 'utf-8'));
            if (!generators && !schematics) {
                console.log(`Peer dependency ${peer} has no generators or schematics`);
                continue;
            }
            const configFile = generators || schematics;
            if (!tree.exists((0, path_1.join)('node_modules', ...peer.split('/'), configFile))) {
                console.log(`Peer dependency ${peer} has no generators or schematics file`);
                continue;
            }
            const config = JSON.parse(tree.read((0, path_1.join)('node_modules', ...peer.split('/'), configFile), 'utf-8'));
            if (!((_d = config.generators) === null || _d === void 0 ? void 0 : _d.init)) {
                console.log(`Peer dependency ${peer} has no init generator`);
                continue;
            }
            const initGeneratorFilePath = config.generators.init.factory;
            const fullInitGeneratorFilePath = (0, path_1.join)('node_modules', ...peer.split('/'), initGeneratorFilePath) + '.js';
            if (!tree.exists(fullInitGeneratorFilePath)) {
                console.log(`Peer dependency ${peer} has no init generator file: ` +
                    fullInitGeneratorFilePath);
                continue;
            }
            // eslint-disable-next-line @typescript-eslint/no-var-requires
            const initGenerator = (_e = require((0, path_1.join)('node_modules', ...peer.split('/'), initGeneratorFilePath))) === null || _e === void 0 ? void 0 : _e.default;
            if (typeof initGenerator !== 'function') {
                console.log(`Peer dependency ${peer} has no init generator function`);
                continue;
            }
            console.log(`Run init generator for peer dependency ${peer}`);
            yield initGenerator(tree, options);
        }
    });
}
exports.default = initGenerator;
//# sourceMappingURL=generator.js.map