@tsed/cli-core/lib/esm/packageManagers/PackageManagersModule.js

Build your CLI with TypeScript and Decorators

import { __decorate, __metadata, __param } from "tslib";
import { Inject, Injectable } from "@tsed/di";
import { EMPTY, throwError } from "rxjs";
import { catchError } from "rxjs/operators";
import { ProjectPackageJson } from "../services/ProjectPackageJson.js";
import { isValidVersion } from "../utils/isValidVersion.js";
import { BaseManager } from "./supports/BaseManager.js";
import { BunManager } from "./supports/BunManager.js";
import { NpmManager } from "./supports/NpmManager.js";
import { PNpmManager } from "./supports/PNpmManager.js";
import { YarnBerryManager } from "./supports/YarnBerryManager.js";
import { YarnManager } from "./supports/YarnManager.js";
function mapPackagesWithInvalidVersion(deps) {
    const toString = (info) => {
        return info[1] === "latest" ? info[0] : info.join("@");
    };
    return Object.entries(deps)
        .filter(([, version]) => !isValidVersion(version))
        .map(toString);
}
let PackageManagersModule = class PackageManagersModule {
    constructor(packageManagers) {
        this.packageManagers = packageManagers;
        this.packageManagers = packageManagers.filter((manager) => manager.has());
    }
    init(options = {}) {
        const packageManager = this.get(options.packageManager);
        options.packageManager = packageManager.name;
        options = {
            ...options,
            cwd: this.projectPackageJson.dir,
            env: {
                ...process.env,
                GH_TOKEN: this.projectPackageJson.GH_TOKEN
            }
        };
        this.projectPackageJson.write();
        this.projectPackageJson.rewrite = true;
        return packageManager.init(options);
    }
    install(options = {}) {
        const packageManager = this.get(options.packageManager);
        options.packageManager = packageManager.name;
        const devDeps = mapPackagesWithInvalidVersion(this.projectPackageJson.devDependencies);
        const deps = mapPackagesWithInvalidVersion(this.projectPackageJson.dependencies);
        options = {
            ...options,
            cwd: this.projectPackageJson.dir,
            env: {
                ...process.env,
                GH_TOKEN: this.projectPackageJson.GH_TOKEN
            }
        };
        const errorPipe = () => catchError((error) => {
            if (error.stderr.startsWith("error Your lockfile needs to be updated")) {
                return throwError(new Error(`yarn.lock file is outdated. Run ${packageManager.name}, commit the updated lockfile and try again.`));
            }
            return throwError(error);
        });
        return [
            {
                title: "Write package.json",
                enabled: () => this.projectPackageJson.rewrite,
                task: () => {
                    this.projectPackageJson.write();
                }
            },
            {
                title: `Installing dependencies using ${packageManager.name}`,
                skip: () => !this.projectPackageJson.reinstall,
                task: () => packageManager.install(options) // .pipe(errorPipe())
            },
            {
                title: `Add dependencies using ${packageManager.name}`,
                skip: () => !deps.length,
                task: () => packageManager.add(deps, options) //.pipe(errorPipe())
            },
            {
                title: `Add devDependencies using ${packageManager.name}`,
                skip: () => !devDeps.length,
                task: () => packageManager.addDev(devDeps, options) //.pipe(errorPipe())
            },
            {
                title: "Refresh",
                task: () => {
                    this.projectPackageJson.refresh();
                }
            }
        ];
    }
    list() {
        return this.packageManagers.map((manager) => manager.name);
    }
    get(name) {
        if (this.projectPackageJson.preferences.packageManager) {
            name = this.projectPackageJson.preferences.packageManager;
        }
        name = name || "yarn";
        let selectedPackageManager = this.packageManagers.find((manager) => manager.name === name);
        if (!selectedPackageManager) {
            selectedPackageManager = this.packageManagers.find((manager) => manager.name === "npm");
        }
        this.projectPackageJson.setPreference("packageManager", selectedPackageManager.name);
        return selectedPackageManager;
    }
    runScript(scriptName, { ignoreError, ...opts } = {}) {
        const options = {
            cwd: this.projectPackageJson.dir,
            ...opts
        };
        const errorPipe = () => catchError((error) => {
            if (ignoreError) {
                return EMPTY;
            }
            return throwError(error);
        });
        return this.get().runScript(scriptName, options).pipe(errorPipe());
    }
};
__decorate([
    Inject(),
    __metadata("design:type", ProjectPackageJson)
], PackageManagersModule.prototype, "projectPackageJson", void 0);
PackageManagersModule = __decorate([
    Injectable({
        imports: [YarnManager, YarnBerryManager, NpmManager, PNpmManager, BunManager]
    }),
    __param(0, Inject("package:manager")),
    __metadata("design:paramtypes", [Array])
], PackageManagersModule);
export { PackageManagersModule };