ts-project-builder/dist/cli.mjs

Rollup-based TypeScript builder with multi-format output and built-in common plugins.

#!/usr/bin/env node

import { cli } from 'cleye';
import { version, name } from './package.json.mjs';
import { defaultOutputPreserveModulesRoot, defaultOutputDir, defaultConfigFilePath, Builder } from './builder.mjs';
import { parseCliArgString } from './utils/index.mjs';
import { handleError } from './utils/rollup/logging.mjs';

function BooleanOrModuleFormats(value) {
    if (value === '')
        return true;
    return new Set(value.split(',').map((value) => value.trim().toLowerCase()));
}
function parseSourcemapFlagValue(value) {
    if (!value || value === 'true')
        return true;
    if (value === 'false')
        return false;
    if (value === 'hidden' || value === 'inline')
        return value;
    throw new Error(`Invalid sourcemap option: '${value}'. Valid options are 'true', 'false', 'hidden', or 'inline'.`);
}
const args = cli({
    flags: {
        clean: {
            description: 'Clean the target directory or files before output.',
            type: BooleanOrModuleFormats,
        },
        config: {
            alias: 'c',
            default: defaultConfigFilePath,
            description: 'The path to the config file.',
            type: String,
        },
        forceClean: {
            description: 'Force clean the target directory or files before output.',
            type: BooleanOrModuleFormats,
        },
        formats: {
            alias: 'f',
            default: 'cjs,esm',
            description: 'The output formats.',
            type: String,
        },
        minify: {
            alias: 'm',
            description: 'Enable minify output.',
            type: BooleanOrModuleFormats,
        },
        outDirs: {
            default: defaultOutputDir,
            description: 'The output directory paths.',
            type: String,
        },
        outExts: {
            description: 'The output file extensions.',
            type: String,
        },
        outFiles: {
            description: 'The output file paths.',
            type: String,
        },
        preserveModules: { type: BooleanOrModuleFormats },
        preserveModulesRoots: {
            default: defaultOutputPreserveModulesRoot,
            type: String,
        },
        sourcemaps: {
            description: 'The output sourcemap options.',
            type: String,
        },
    },
    help: { usage: `${name} <inputs...> [flags...]` },
    name,
    parameters: ['<inputs...>'],
    version,
});
const inputs = args._.inputs;
if (!inputs.length)
    inputs.push('./src/index.ts');
try {
    await new Builder({
        configFilePath: args.flags.config,
        inputs,
        output: {
            clean: args.flags.clean,
            dirs: parseCliArgString(args.flags.outDirs),
            exts: parseCliArgString(args.flags.outExts || ''),
            files: parseCliArgString(args.flags.outFiles || ''),
            forceClean: args.flags.forceClean,
            formats: new Set(args.flags.formats.split(',')),
            minify: args.flags.minify,
            preserveModules: args.flags.preserveModules,
            preserveModulesRoots: parseCliArgString(args.flags.preserveModulesRoots),
            sourcemaps: (() => {
                if (args.flags.sourcemaps === undefined)
                    return;
                const parseResult = parseCliArgString(args.flags.sourcemaps);
                const sourcemaps = {};
                for (const key in parseResult) {
                    // eslint-disable-next-line style/max-len
                    sourcemaps[key] = parseSourcemapFlagValue(parseResult[key]);
                }
                sourcemaps.default ??= true;
                return sourcemaps;
            })(),
        },
    }).build();
}
catch (error) {
    handleError(error);
    process.exit(1);
}
//# sourceMappingURL=cli.mjs.map