@lcap/builder/lib/commands/parse.js

lcap builder utils

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseNPM = void 0;
const fs_extra_1 = __importDefault(require("fs-extra"));
const path_1 = __importDefault(require("path"));
const picocolors_1 = __importDefault(require("picocolors"));
const material_parser_1 = require("@lcap/material-parser");
const creates_1 = require("../creates");
const project_1 = require("../utils/project");
const exec_1 = require("../utils/exec");
function setPkgLcapScheme(output) {
    return __awaiter(this, void 0, void 0, function* () {
        const pkgPath = path_1.default.resolve(process.cwd(), './package.json');
        if (!fs_extra_1.default.existsSync(pkgPath)) {
            return;
        }
        const pkg = yield fs_extra_1.default.readJSON(pkgPath);
        if (!pkg.lcap) {
            pkg.lcap = {};
        }
        pkg.lcap.schema = output;
        yield fs_extra_1.default.writeJSON(pkgPath, pkg, { spaces: 2 });
    });
}
function parseNPM(options) {
    return __awaiter(this, void 0, void 0, function* () {
        if (!options.name) {
            throw new Error('please input pkg name');
        }
        const { name, version, output = 'schema.json', tempDir, npmClient = 'npm' } = options, rest = __rest(options, ["name", "version", "output", "tempDir", "npmClient"]);
        const result = yield (0, material_parser_1.parse)(Object.assign({ name,
            version,
            tempDir,
            npmClient }, rest));
        yield fs_extra_1.default.ensureFile(output);
        yield fs_extra_1.default.writeJSON(output, result, { spaces: 2 });
        yield setPkgLcapScheme(output);
    });
}
exports.parseNPM = parseNPM;
function addPkg(root, pkgManager, pkg) {
    switch (pkgManager) {
        case 'npm':
            (0, exec_1.execSync)(`npm install ${pkg} --save`);
            break;
        case 'pnpm':
            (0, exec_1.execSync)(`pnpm add ${pkg}`);
            break;
        case 'yarn':
            (0, exec_1.execSync)(`yarn add ${pkg}`);
            break;
        default: break;
    }
}
function executeParse(rootPath, options) {
    return __awaiter(this, void 0, void 0, function* () {
        const { pkg, generate = false, npmClient = 'npm', local } = options, rest = __rest(options, ["pkg", "generate", "npmClient", "local"]);
        const i = pkg.indexOf('@');
        let name;
        let version = '';
        if (i > 0) {
            name = pkg.substring(0, i);
            version = pkg.substring(i + 1);
        }
        else {
            name = pkg;
        }
        const output = options.output || 'schema.json';
        try {
            console.log(picocolors_1.default.bgBlue(`开始解析包 ${pkg} ${local ? `(本地包: ${local})` : ''}`), options);
            yield parseNPM(Object.assign(Object.assign({}, rest), { name,
                version,
                output, npmClient: 'npm', isLocal: !!local, file: local }));
            console.log(picocolors_1.default.green(`解析包 ${pkg} 成功，生成文件 ${options.output || 'schema.json'}`));
        }
        catch (e) {
            console.log(picocolors_1.default.red(`解析包 ${pkg} 失败, ${e.message}`));
            console.log(e);
            process.exit(1);
        }
        if (!generate) {
            return;
        }
        addPkg(rootPath, npmClient, pkg);
        yield (0, creates_1.executeCreateForSchema)(rootPath, (0, project_1.getExtensionProjectMeta)(rootPath), output);
    });
}
exports.default = executeParse;