tachybase_todo/packages/father-build/src/build.ts
2021-05-23 08:38:08 +08:00

243 lines
6.5 KiB
TypeScript
Executable File

import { existsSync, readFileSync } from 'fs';
import { join } from 'path';
import rimraf from 'rimraf';
import * as assert from 'assert';
import { merge } from 'lodash';
import signale from 'signale';
import chalk from 'chalk';
import { getPackages } from '@lerna/project';
import { IOpts, IBundleOptions, IBundleTypeOutput, ICjs, IEsm, Dispose } from './types';
import babel from './babel';
import rollup from './rollup';
import registerBabel from './registerBabel';
import { getExistFile } from './utils';
import getUserConfig, { CONFIG_FILES } from './getUserConfig';
import randomColor from "./randomColor";
export function getBundleOpts(opts: IOpts): IBundleOptions[] {
const { cwd, buildArgs = {}, rootConfig = {} } = opts;
const entry = getExistFile({
cwd,
files: ['src/index.tsx', 'src/index.ts', 'src/index.jsx', 'src/index.js'],
returnRelative: true,
});
const userConfig = getUserConfig({ cwd });
const userConfigs = Array.isArray(userConfig) ? userConfig : [userConfig];
return (userConfigs as any).map(userConfig => {
const bundleOpts = merge(
{
entry,
},
rootConfig,
userConfig,
buildArgs,
);
// Support config esm: 'rollup' and cjs: 'rollup'
if (typeof bundleOpts.esm === 'string') {
bundleOpts.esm = { type: bundleOpts.esm };
}
if (typeof bundleOpts.cjs === 'string') {
bundleOpts.cjs = { type: bundleOpts.cjs };
}
return bundleOpts;
});
}
function validateBundleOpts(bundleOpts: IBundleOptions, { cwd, rootPath }) {
if (bundleOpts.runtimeHelpers) {
const pkgPath = join(cwd, 'package.json');
assert.ok(existsSync(pkgPath), `@babel/runtime dependency is required to use runtimeHelpers`);
const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
assert.ok(
(pkg.dependencies || {})['@babel/runtime'],
`@babel/runtime dependency is required to use runtimeHelpers`,
);
}
if (bundleOpts.cjs && (bundleOpts.cjs as ICjs).lazy && (bundleOpts.cjs as ICjs).type === 'rollup') {
throw new Error(`
cjs.lazy don't support rollup.
`.trim());
}
if (!bundleOpts.esm && !bundleOpts.cjs && !bundleOpts.umd) {
throw new Error(
`
None format of ${chalk.cyan(
'cjs | esm | umd',
)} is configured, checkout https://github.com/umijs/father for usage details.
`.trim(),
);
}
if (bundleOpts.entry) {
const tsConfigPath = join(cwd, 'tsconfig.json');
const tsConfig = existsSync(tsConfigPath)
|| (rootPath && existsSync(join(rootPath, 'tsconfig.json')));
if (
!tsConfig && (
(Array.isArray(bundleOpts.entry) && bundleOpts.entry.some(isTypescriptFile)) ||
(!Array.isArray(bundleOpts.entry) && isTypescriptFile(bundleOpts.entry))
)
) {
signale.info(
`Project using ${chalk.cyan('typescript')} but tsconfig.json not exists. Use default config.`
);
}
}
}
function isTypescriptFile(filePath) {
return filePath.endsWith('.ts') || filePath.endsWith('.tsx')
}
interface IExtraBuildOpts {
pkg?: string | { name?: string };
}
export async function build(opts: IOpts, extraOpts: IExtraBuildOpts = {}) {
const { cwd, rootPath, watch } = opts;
const { pkg } = extraOpts;
const dispose: Dispose[] = [];
// register babel for config files
registerBabel({
cwd,
only: CONFIG_FILES,
});
const pkgName = (typeof pkg === 'string' ? pkg : pkg?.name) || 'unknown';
function log(msg) {
console.log(`${pkg ? `${randomColor(`${pkgName}`)}: ` : ''}${msg}`);
}
// Get user config
const bundleOptsArray = getBundleOpts(opts);
for (const bundleOpts of bundleOptsArray) {
validateBundleOpts(bundleOpts, { cwd, rootPath });
// Clean dist
log(chalk.gray(`Clean dist directory`));
rimraf.sync(join(cwd, 'dist'));
// Build umd
if (bundleOpts.umd) {
log(`Build umd`);
await rollup({
cwd,
rootPath,
log,
type: 'umd',
entry: bundleOpts.entry,
watch,
dispose,
bundleOpts,
});
}
// Build cjs
if (bundleOpts.cjs) {
const cjs = bundleOpts.cjs as IBundleTypeOutput;
log(`Build cjs with ${cjs.type}`);
if (cjs.type === 'babel') {
await babel({ cwd, rootPath, watch, dispose, type: 'cjs', log, bundleOpts });
} else {
await rollup({
cwd,
rootPath,
log,
type: 'cjs',
entry: bundleOpts.entry,
watch,
dispose,
bundleOpts,
});
}
}
// Build esm
if (bundleOpts.esm) {
const esm = bundleOpts.esm as IEsm;
log(`Build esm with ${esm.type}`);
const importLibToEs = esm && esm.importLibToEs;
if (esm && esm.type === 'babel') {
await babel({ cwd, rootPath, watch, dispose, type: 'esm', importLibToEs, log, bundleOpts });
} else {
await rollup({
cwd,
rootPath,
log,
type: 'esm',
entry: bundleOpts.entry,
importLibToEs,
watch,
dispose,
bundleOpts,
});
}
}
}
return dispose;
}
export async function buildForLerna(opts: IOpts) {
const { cwd } = opts;
// register babel for config files
registerBabel({
cwd,
only: CONFIG_FILES,
});
const userConfig = merge(getUserConfig({ cwd }), opts.rootConfig || {});
let pkgs = await getPackages(cwd);
// support define pkgs in lerna
// TODO: 使用lerna包解决依赖编译问题
if (userConfig.pkgs) {
pkgs = userConfig.pkgs
.map((item) => {
return pkgs.find(pkg => pkg.contents.endsWith(item))
})
.filter(Boolean);
}
const dispose: Dispose[] = [];
for (const pkg of pkgs) {
if (process.env.PACKAGE && pkg !== process.env.PACKAGE) continue;
// build error when .DS_Store includes in packages root
const pkgPath = pkg.contents;
assert.ok(
existsSync(join(pkgPath, 'package.json')),
`package.json not found in packages/${pkg}`,
);
process.chdir(pkgPath);
dispose.push(...await build(
{
// eslint-disable-line
...opts,
buildArgs: opts.buildArgs,
rootConfig: userConfig,
cwd: pkgPath,
rootPath: cwd,
},
{
pkg,
},
));
}
return dispose;
}
export default async function(opts: IOpts) {
const useLerna = existsSync(join(opts.cwd, 'lerna.json'));
const isLerna = useLerna && process.env.LERNA !== 'none';
const dispose = isLerna ? await buildForLerna(opts) : await build(opts);
return () => dispose.forEach(e => e());
}