@pika/pack/dist-src/index.js

package building, reimagined.

import * as path from 'path';
import chalk from 'chalk';
import * as fs from 'fs';
import invariant from 'invariant';
import loudRejection from 'loud-rejection';
import { ConsoleReporter, JSONReporter } from './reporters/index.js';
import * as buildCommand from './commands/build.js';
import { MessageError } from '@pika/types';
import Config from './config.js';
import handleSignals from './util/signal-handler.js';
import { boolifyWithDefault } from './util/conversion.js';
import map from './util/map.js';
import stripBOM from 'strip-bom';
import uri2path from 'file-uri-to-path';
import yargs from 'yargs-parser';
// @ts-ignore
const currentFilename = uri2path(import.meta.url);
function getVersion() {
    const packageJsonContent = fs.readFileSync(path.resolve(currentFilename, '../../package.json'), { encoding: 'utf-8' });
    const { version } = map(JSON.parse(stripBOM(packageJsonContent)));
    return version;
}
function printHelp() {
    console.log(`
${chalk.bold(`@pika/pack`)} - Build npm packages without the mess.
${chalk.bold('Options:')}
    --cwd               Set the current working directory.
    --out               Set the output directory. Defaults to "pkg/".
    --pipeline          Set a build pipeline via JSON string.
    --force             Continue with the build when a build plugin fails or throws an exception.
    --json              Log output as JSON.
    --verbose           Log additional debugging information.
    --silent            Log almost nothing.
    --help              Print help.
    --version, -v       Print version.
    `.trim());
}
export async function cli(args) {
    const version = getVersion();
    loudRejection();
    handleSignals();
    // Handle special flags
    if (args.find(arg => arg === '--version' || arg === '-v')) {
        console.log(version.trim());
        process.exitCode = 0;
        return;
    }
    if (args.find(arg => arg === '--help')) {
        printHelp();
        process.exitCode = 0;
        return;
    }
    // Handle the legacy CLI interface
    if (args[2] === 'publish') {
        console.log(`The publish flow has moved to the @pika/cli package (included with this package).
Update your publish script to: ${chalk.bold('pika publish [flags]')}
`);
        process.exitCode = 1;
        return;
    }
    if (args[2] === 'build') {
        console.log(chalk.yellow(`Note: This CLI was recently deprecated. Update your build script to: ${chalk.bold('pika build [flags]')}`));
        args.splice(2, 1);
    }
    const flags = yargs(args);
    const cwd = flags.cwd || process.cwd();
    const Reporter = flags.json ? JSONReporter : ConsoleReporter;
    const reporter = new Reporter({
        emoji: true,
        verbose: flags.verbose,
        isSilent: boolifyWithDefault(process.env.PIKA_SILENT, false) || flags.silent,
    });
    const exit = (exitCode = 0) => {
        process.exitCode = exitCode;
        reporter.close();
    };
    const command = buildCommand;
    reporter.initPeakMemoryCounter();
    const outputWrapperEnabled = boolifyWithDefault(process.env.PIKA_WRAP_OUTPUT, true);
    const shouldWrapOutput = outputWrapperEnabled && !flags.json && command.hasWrapper();
    if (shouldWrapOutput) {
        reporter.header({ name: '@pika/pack', version });
    }
    const run = () => {
        invariant(command, 'missing command');
        return command.run(config, reporter, flags, args).then(exitCode => {
            if (shouldWrapOutput) {
                reporter.footer(false);
            }
            return exitCode;
        });
    };
    function onUnexpectedError(err) {
        function indent(str) {
            return '\n  ' + str.trim().split('\n').join('\n  ');
        }
        const log = [];
        log.push(`Arguments: ${indent(process.argv.join(' '))}`);
        log.push(`PATH: ${indent(process.env.PATH || 'undefined')}`);
        log.push(`Pika version: ${indent(version)}`);
        log.push(`Node version: ${indent(process.versions.node)}`);
        log.push(`Platform: ${indent(process.platform + ' ' + process.arch)}`);
        log.push(`Trace: ${indent(err.stack)}`);
        reporter.error(reporter.lang('unexpectedError', err.message));
    }
    const config = new Config(reporter, cwd, flags);
    await config.loadPackageManifest();
    try {
        // option "no-progress" stored in pika config
        const noProgressConfig = false; //config.registries.pika.getOption('no-progress');
        if (noProgressConfig) {
            reporter.disableProgress();
        }
        // verbose logs outputs process.uptime() with this line we can sync uptime to absolute time on the computer
        reporter.verbose(`current time: ${new Date().toISOString()}`);
        return run().then(exit);
    }
    catch (err) {
        reporter.verbose(err.stack);
        if (err instanceof MessageError) {
            reporter.error(err.message);
        }
        else {
            onUnexpectedError(err);
        }
        return exit(1);
    }
}