siroc
Version:
Zero-config build tooling for Node
1,002 lines (988 loc) • 34.5 kB
JavaScript
;
Object.defineProperty(exports, '__esModule', { value: true });
const upath = require('upath');
const chalk = require('chalk');
const fsExtra = require('fs-extra');
const mkdist = require('mkdist');
const rollup = require('rollup');
const consola = require('consola');
const _glob = require('glob');
const _jiti = require('jiti');
const aliasPlugin = require('@rollup/plugin-alias');
const commonjsPlugin = require('@rollup/plugin-commonjs');
const jsonPlugin = require('@rollup/plugin-json');
const replacePlugin = require('@rollup/plugin-replace');
const nodeResolvePlugin = require('@rollup/plugin-node-resolve');
const defu = require('defu');
const dts = require('rollup-plugin-dts');
const esbuild = require('rollup-plugin-esbuild');
const detectIndent = require('detect-indent');
const execa = require('execa');
const sortPackageJson = require('sort-package-json');
const Module = require('module');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
const _glob__default = /*#__PURE__*/_interopDefaultLegacy(_glob);
const _jiti__default = /*#__PURE__*/_interopDefaultLegacy(_jiti);
const aliasPlugin__default = /*#__PURE__*/_interopDefaultLegacy(aliasPlugin);
const commonjsPlugin__default = /*#__PURE__*/_interopDefaultLegacy(commonjsPlugin);
const jsonPlugin__default = /*#__PURE__*/_interopDefaultLegacy(jsonPlugin);
const replacePlugin__default = /*#__PURE__*/_interopDefaultLegacy(replacePlugin);
const nodeResolvePlugin__default = /*#__PURE__*/_interopDefaultLegacy(nodeResolvePlugin);
const defu__default = /*#__PURE__*/_interopDefaultLegacy(defu);
const dts__default = /*#__PURE__*/_interopDefaultLegacy(dts);
const esbuild__default = /*#__PURE__*/_interopDefaultLegacy(esbuild);
const detectIndent__default = /*#__PURE__*/_interopDefaultLegacy(detectIndent);
const execa__default = /*#__PURE__*/_interopDefaultLegacy(execa);
const sortPackageJson__default = /*#__PURE__*/_interopDefaultLegacy(sortPackageJson);
const Module__default = /*#__PURE__*/_interopDefaultLegacy(Module);
function loadAllSettled() {
Promise.allSettled = function(values) {
return Promise.all(Array.from(values).map((promise) => {
if (promise instanceof Promise) {
return promise.then((value) => ({
status: "fulfilled",
value
})).catch((reason) => ({
status: "rejected",
reason
}));
}
return {
status: "fulfilled",
value: promise
};
}));
};
}
function loadFromEntries() {
Object.fromEntries = function(entries) {
const newObject = {};
for (const [key, value] of entries) {
if (typeof key === "string")
newObject[key] = value;
}
return newObject;
};
}
var __async$2 = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
const jiti = _jiti__default['default']();
if (!Object.fromEntries)
loadFromEntries();
if (!Promise.allSettled)
loadAllSettled();
const glob = (pattern) => new Promise((resolve, reject) => _glob__default['default'](pattern, (err, matches) => {
if (err)
return reject(err);
resolve(matches);
}));
const sortObjectKeys = (obj) => Object.fromEntries(Object.entries(obj).sort(([key1], [key2]) => +key2 - +key1));
const tryJSON = (id) => {
try {
return fsExtra.readJSONSync(id);
} catch (e) {
return void 0;
}
};
const tryRequire = (id) => {
try {
if (upath.extname(id) === "json")
return tryJSON(id);
const contents = jiti(id);
if ("default" in contents)
return contents.default;
return contents;
} catch (e) {
return void 0;
}
};
const ensureUnique = (items) => Array.from(new Set(items));
const groupBy = (collection, key) => {
const groups = {};
collection.forEach((entry) => {
groups[entry[key]] = groups[entry[key]] || [];
groups[entry[key]].push(entry);
});
return groups;
};
const includeDefinedProperties = (options) => Object.fromEntries(Object.entries(options).filter(([_, value]) => value !== void 0));
const includeIf = (test, itemFactory) => test ? [itemFactory(test)] : [];
const runInParallel = (items, cb) => __async$2(undefined, null, function* () {
if (Array.isArray(items))
return Promise.allSettled(items.map((item, index2) => __async$2(this, null, function* () {
return cb(item, index2);
}))).then((results) => results.map((result) => {
if (result.status === "rejected")
consola__default['default'].error(result.reason);
return result;
}));
const promises = [];
let index = 0;
for (const item of items) {
try {
promises.push(Promise.resolve(cb(item, index)));
} catch (e) {
promises.push(Promise.reject(e));
}
index++;
}
return Promise.allSettled(promises).then((results) => results.map((result) => {
if (result.status === "rejected")
consola__default['default'].error(result.reason);
return result;
}));
});
const asArray = (item) => item !== void 0 ? Array.isArray(item) ? item : [item] : [];
const walkDownDirectory = (pathname) => pathname.split(upath.sep).slice(1).join(upath.sep);
const getEntrypointPaths = (path) => {
if (path.startsWith("./"))
path = path.slice(2);
const filenames = new Set();
let cwd = path;
do {
filenames.add(cwd);
cwd = walkDownDirectory(cwd);
} while (cwd);
return Array.from(filenames);
};
const getEntrypointFilenames = (path) => {
if (path.startsWith("./"))
path = path.slice(2);
const filenames = new Set();
let cwd = path;
do {
const basefile = cwd.split(".").slice(0, -1).join(".");
const withoutType = basefile.split(".").slice(0, 1).join("");
[
basefile,
`${basefile}/index`,
withoutType,
`${withoutType}/index`
].forEach((name) => filenames.add(name));
cwd = walkDownDirectory(cwd);
} while (cwd);
filenames.add("index");
return Array.from(filenames).map((name) => [`${name}.ts`, `${name}.js`]).reduce((names, arr) => {
arr.forEach((name) => names.push(name));
return names;
}, []);
};
const getFlatValues = (obj) => {
return Object.values(obj).map((ex) => typeof ex === "string" ? ex : Object.values(ex)).reduce((flatArray, item) => {
if (Array.isArray(item))
return [...flatArray, ...item];
flatArray.push(item);
return flatArray;
}, []);
};
var __defProp$2 = Object.defineProperty;
var __defProps$1 = Object.defineProperties;
var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$2 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$2.call(b, prop))
__defNormalProp$2(a, prop, b[prop]);
if (__getOwnPropSymbols$2)
for (var prop of __getOwnPropSymbols$2(b)) {
if (__propIsEnum$2.call(b, prop))
__defNormalProp$2(a, prop, b[prop]);
}
return a;
};
var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
var __async$1 = (__this, __arguments, generator) => {
return new Promise((resolve2, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
const defineSirocConfig = (options) => options;
const configPaths = [
"siroc.config.ts",
"siroc.config.js",
"siroc.config.json",
"package.js"
];
const DEFAULTS = {
rootDir: process.cwd(),
build: true,
suffix: process.env.PACKAGE_SUFFIX ? `-${process.env.PACKAGE_SUFFIX}` : "",
hooks: {},
commands: {},
mkdist: {}
};
class Package {
constructor(options = {}) {
this.options = Object.assign({}, DEFAULTS, options);
this.logger = consola__default['default'];
const blob = this.loadPackageJSON(false);
this.pkg = JSON.parse(blob);
this.options.pkgIndent = this.options.pkgIndent || detectIndent__default['default'](blob).indent;
this.logger = consola__default['default'].withTag(this.pkg.name);
this.loadConfig();
}
loadPackageJSON(parse = true) {
try {
const blob = fsExtra.readFileSync(this.resolvePath("package.json"), "utf8");
if (parse)
return JSON.parse(blob);
return blob;
} catch (e) {
if (this.options.rootDir === "/") {
this.logger.error(`Could not locate a ${chalk.bold("package.json")} in ${chalk.bold(DEFAULTS.rootDir)} or its parent directories.`);
throw new Error(`Could not locate a package.json in ${DEFAULTS.rootDir} or its parent directories.`);
}
this.options.rootDir = this.resolvePath("..");
return this.loadPackageJSON();
}
}
resolvePath(...pathSegments) {
return upath.resolve(this.options.rootDir, ...pathSegments);
}
loadConfig() {
configPaths.some((path) => {
const configPath = this.resolvePath(path);
const config = tryRequire(configPath);
if (!config)
return false;
Object.assign(this.options, config);
return true;
});
}
callHook(name, options) {
return __async$1(this, null, function* () {
const fns = this.options.hooks[name];
if (!fns)
return;
const fnArray = Array.isArray(fns) ? fns : [fns];
try {
yield runInParallel(fnArray, (fn) => __async$1(this, null, function* () {
return fn(this, options);
}));
} catch (e) {
this.logger.error(`Couldn't run hook for ${this.pkg.name}.`);
}
});
}
load(relativePath, opts) {
return new Package(Object.assign({
rootDir: this.resolvePath(relativePath)
}, opts));
}
writePackage() {
return __async$1(this, null, function* () {
const pkgPath = this.resolvePath("package.json");
this.logger.debug("Writing", pkgPath);
yield fsExtra.writeFile(pkgPath, JSON.stringify(this.pkg, null, this.options.pkgIndent) + "\n");
});
}
get version() {
const date = Math.round(Date.now() / (1e3 * 60));
const gitCommit = this.shortCommit;
const baseVersion = this.pkg.version.split("-")[0];
return `${baseVersion}-${date}.${gitCommit}`;
}
suffixAndVersion() {
this.logger.info(`Adding suffix ${this.options.suffix}`);
const oldPkgName = this.pkg.name;
if (!oldPkgName.includes(this.options.suffix)) {
this.pkg.name += this.options.suffix;
}
if (this.pkg.dependencies) {
for (const oldName of this.options.linkedDependencies || []) {
const name = oldName + this.options.suffix;
const version = this.pkg.dependencies[oldName] || this.pkg.dependencies[name];
delete this.pkg.dependencies[oldName];
this.pkg.dependencies[name] = version;
}
}
if (typeof this.pkg.bin === "string") {
const { bin } = this.pkg;
this.pkg.bin = {
[oldPkgName]: bin,
[this.pkg.name]: bin
};
}
this.pkg.version = this.version;
}
syncLinkedDependencies() {
for (const _name of this.options.linkedDependencies || []) {
const name = _name + (this.options.suffix || "");
const pkg = tryJSON(`${name}/package.json`) || tryJSON(`${_name}/package.json`);
if (!pkg || !pkg.version || !this.pkg.dependencies || !this.pkg.dependencies[name]) {
continue;
}
const currentVersion = this.pkg.dependencies[name];
const caret = currentVersion[0] === "^";
this.pkg.dependencies[name] = caret ? `^${pkg.version}` : pkg.version;
}
}
publish(tag = "latest") {
this.logger.info(`publishing ${this.pkg.name}@${this.pkg.version} with tag ${tag}`);
this.exec(`npm publish --tag ${tag}`);
}
copyFieldsFrom(source, fields = []) {
for (const field of fields) {
this.pkg[field] = source.pkg[field];
}
}
setBinaryPermissions() {
return __async$1(this, null, function* () {
yield Promise.all(this.binaries.map(([binary]) => fsExtra.chmod(binary, 511)));
});
}
createBinaryStubs() {
return __async$1(this, null, function* () {
yield runInParallel(this.binaries, (_0) => __async$1(this, [_0], function* ([binary, entrypoint]) {
if (!entrypoint)
return;
const outDir = upath.dirname(binary);
if (!fsExtra.existsSync(outDir))
yield fsExtra.mkdirp(outDir);
const absPath = entrypoint.replace(/(\.[jt]s)$/, "");
yield fsExtra.writeFile(binary, [
`#!/usr/bin/env node`,
`const jiti = require('jiti')()`,
`module.exports = jiti('${absPath}')`
].join("\n"));
yield this.setBinaryPermissions();
}));
});
}
createStub(path, cjs = false) {
return __async$1(this, null, function* () {
if (!path || !this.entrypoint || !this.options.build)
return;
const outFile = this.resolvePath(path);
const outDir = upath.dirname(outFile);
if (!fsExtra.existsSync(outDir))
yield fsExtra.mkdirp(outDir);
const relativeEntrypoint = upath.relative(outDir, this.entrypoint).replace(/(\.[cm]?[jt]s)$/, "");
const stub = cjs ? [
`const jiti = require('jiti')()`,
`module.exports = jiti('./${relativeEntrypoint}')`
].join("\n") : `export * from './${relativeEntrypoint}'`;
yield fsExtra.writeFile(outFile, stub);
});
}
createStubs() {
return __async$1(this, null, function* () {
return Promise.all([
this.createBinaryStubs(),
this.createStub(this.pkg.main, true),
this.createStub(this.pkg.module),
this.createStub(this.pkg.types)
]);
});
}
copyFilesFrom(source, files) {
return __async$1(this, null, function* () {
for (const file of files || source.pkg.files || []) {
const src = upath.resolve(source.options.rootDir, file);
const dst = upath.resolve(this.options.rootDir, file);
yield fsExtra.copy(src, dst);
}
});
}
autoFix() {
this.pkg = sortPackageJson__default['default'](this.pkg);
if (this.options.sortDependencies)
this.sortDependencies();
}
sortDependencies() {
if (this.pkg.dependencies) {
this.pkg.dependencies = sortObjectKeys(this.pkg.dependencies);
}
if (this.pkg.devDependencies) {
this.pkg.devDependencies = sortObjectKeys(this.pkg.devDependencies);
}
}
execInteractive(command) {
const options = {
cwd: this.options.rootDir,
env: process.env,
shell: true,
stdio: "inherit"
};
return execa__default['default'].command(command, options);
}
get exports() {
const { exports } = this.pkg;
const filterExports = (item) => ![
this.pkg.main,
this.pkg.module,
this.pkg.browser,
`./${this.pkg.main}`,
`./${this.pkg.module}`,
`./${this.pkg.browser}`
].includes(item) && !item.endsWith("/") && !item.includes("*");
if (!exports)
return [];
if (typeof exports === "string")
return [exports].filter(filterExports);
if (Array.isArray(exports))
return exports.filter(filterExports);
return getFlatValues(exports).filter(filterExports);
}
get folderExports() {
const { exports } = this.pkg;
const filterExports = (item) => /[a-z]\/\*(\.[a-z]*)?$/.test(item);
if (!exports)
return [];
if (typeof exports === "string")
return [exports].filter(filterExports);
if (Array.isArray(exports))
return exports.filter(filterExports);
return getFlatValues(exports).filter(filterExports);
}
exec(command, { silent = false } = {}) {
const options = {
cwd: this.options.rootDir,
env: process.env
};
const r = execa__default['default'].commandSync(command, options);
if (!silent) {
if (r.failed) {
this.logger.error(command, r.stderr.trim());
} else {
this.logger.success(command, r.stdout.trim());
}
}
return {
signal: r.signal,
stdout: String(r.stdout).trim(),
stderr: String(r.stderr).trim()
};
}
resolveEntrypoint(path = this.pkg.main) {
if (!path)
return void 0;
let input;
const filenames = getEntrypointFilenames(path);
filenames.some((filename) => {
input = this.resolvePath("src", filename);
return fsExtra.existsSync(input);
});
return input;
}
resolveEntrypointFolder(path = this.pkg.main) {
if (!path)
return void 0;
let input;
const paths = getEntrypointPaths(path);
paths.some((path2) => {
input = this.resolvePath("src", path2);
return fsExtra.pathExistsSync(input);
});
return input;
}
parsePerson(person) {
const [_matchedName, name] = person.match(/(^[^<(]*[^ <(])/) || [];
const [_matchedEmail, email] = person.match(/<(.*)>/) || [];
const [_matchedUrl, url] = person.match(/\((.*)\)/) || [];
return { name, email, url };
}
get contributors() {
if (!this.pkg.contributors)
return [];
return this.pkg.contributors.map((person) => {
if (typeof person === "string")
return this.parsePerson(person);
return person;
});
}
get entrypoint() {
return this.resolveEntrypoint();
}
get binaries() {
const { bin } = this.pkg;
const files = !bin ? [] : typeof bin === "string" ? [bin] : Object.values(bin);
return Array.from(new Set(files.map((file) => [
this.resolvePath(file),
this.resolveEntrypoint(file)
])));
}
getWorkspacePackages(packageNames) {
return __async$1(this, null, function* () {
const dirs = new Set();
yield runInParallel(this.pkg.workspaces || ["."], (workspace) => __async$1(this, null, function* () {
;
(yield glob(workspace)).forEach((dir) => dirs.add(dir));
}));
const packages = yield runInParallel(dirs, (dir) => {
if (!fsExtra.existsSync(this.resolvePath(dir, "package.json"))) {
throw new Error("Not a package directory.");
}
const pkg = new Package(__spreadProps$1(__spreadValues$2({}, this.options), {
rootDir: this.resolvePath(dir)
}));
if (packageNames && !packageNames.includes(pkg.pkg.name)) {
throw new Error("Not a selected package.");
}
return pkg;
});
return packages.filter((pkg) => pkg.status === "fulfilled").map((pkg) => pkg.value);
});
}
get shortCommit() {
const { stdout } = this.exec("git rev-parse --short HEAD", {
silent: true
});
return stdout;
}
get branch() {
const { stdout } = this.exec("git rev-parse --abbrev-ref HEAD", {
silent: true
});
return stdout;
}
get lastGitTag() {
const { stdout } = this.exec("git --no-pager tag -l --sort=taggerdate", {
silent: true
});
const r = stdout.split("\n");
return r[r.length - 1];
}
}
const blacklist = ["sys"];
const builtins = Module__default['default'].builtinModules.filter((x) => !/^_|^(internal|v8|node-inspect)\/|\//.test(x) && !blacklist.includes(x)).sort();
const getNameFunction = (rootDir, packageName) => (filename, defaultSuffix = "", defaultFormat) => {
return {
dir: filename ? upath.resolve(rootDir, upath.dirname(filename)) : upath.resolve(rootDir, "dist"),
entryFileNames: filename ? upath.basename(filename) : `${packageName}${defaultSuffix}.js`,
chunkFileNames: filename ? `${upath.basename(filename)}-[name].js` : `${packageName}-[name]${defaultSuffix}.js`,
format: formatForName(filename ? upath.basename(filename) : `${packageName}${defaultSuffix}.js`, defaultFormat)
};
};
const formats = [
"amd",
"cjs",
"es",
"iife",
"system",
"umd",
"commonjs",
"esm",
"module",
"systemjs"
];
const formatForName = (filename, defaultFormat = "cjs") => {
const parts = filename.split(".");
if (parts.length > 2) {
const format = parts[parts.length - 2];
if (formats.includes(format))
return format;
}
if (parts[parts.length - 1] === "mjs")
return "module";
return defaultFormat;
};
const shouldMinify = (filename) => {
return !!filename.match(/\.min\.\w+$/);
};
const convertToUMDName = (name) => {
const unnamspacedName = name.split("/").pop();
return (unnamspacedName || name).replace(/-./g, (r) => r[1].toUpperCase()).replace(/^./, (r) => r.toUpperCase());
};
var __defProp$1 = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$1 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$1.call(b, prop))
__defNormalProp$1(a, prop, b[prop]);
if (__getOwnPropSymbols$1)
for (var prop of __getOwnPropSymbols$1(b)) {
if (__propIsEnum$1.call(b, prop))
__defNormalProp$1(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols$1)
for (var prop of __getOwnPropSymbols$1(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
target[prop] = source[prop];
}
return target;
};
const __NODE_ENV__ = process.env.NODE_ENV;
function regexpForPackage(name) {
name = name.replace(/[\\/]/g, "[\\\\/]");
return new RegExp(`(^|node_modules[\\\\/])${name}([\\\\/]|$)`, "i");
}
function regexpForPackages(packages) {
return Object.keys(packages || {}).map(regexpForPackage);
}
function getRollupConfig(_a, pkg = new Package(), override) {
var _b = _a, {
input,
replace = {},
alias = {},
externals = [],
dev = false,
resolve: resolveOptions = {
resolveOnly: [/^((?!node_modules).)*$/],
preferBuiltins: true
},
plugins = [],
esbuildOptions
} = _b, options = __objRest(_b, [
"input",
"replace",
"alias",
"externals",
"dev",
"resolve",
"plugins",
"esbuildOptions"
]);
const {
binaries,
entrypoint,
exports,
pkg: pkgConfig,
options: { rootDir, suffix }
} = pkg;
const resolvePath = (...path) => upath.resolve(rootDir, ...path);
input = input ? resolvePath(input) : entrypoint;
if (!input && !binaries.length && !exports.length)
return [];
const name = upath.basename(pkgConfig.name.replace(suffix, ""));
const getFilenames = getNameFunction(rootDir, name);
const external = [
...regexpForPackages(pkgConfig.dependencies),
...regexpForPackages(pkgConfig.optionalDependencies),
...regexpForPackages(pkgConfig.peerDependencies),
...builtins,
...externals
];
const getDeclarationPlugins = () => [
jsonPlugin__default['default'](),
dts__default['default']({
compilerOptions: {
allowJs: true
}
})
];
const getPlugins = (filename) => [
aliasPlugin__default['default']({
entries: alias
}),
replacePlugin__default['default']({
exclude: "node_modules/**",
preventAssignment: true,
delimiters: ["", ""],
values: __spreadValues$1(__spreadValues$1({}, includeDefinedProperties({ __NODE_ENV__ })), replace)
}),
nodeResolvePlugin__default['default'](resolveOptions),
commonjsPlugin__default['default']({ include: /node_modules/ }),
esbuild__default['default'](__spreadValues$1({
target: "es2018",
minify: shouldMinify(filename)
}, esbuildOptions)),
jsonPlugin__default['default'](),
...plugins
];
const defaultOutputs = [
__spreadProps(__spreadValues$1({}, getFilenames(pkgConfig.main)), {
preferConst: true,
exports: "auto"
}),
...includeIf(!dev && pkgConfig.module, (pkgModule) => __spreadProps(__spreadValues$1({}, getFilenames(pkgModule, ".es", "es")), {
exports: "auto"
})),
...includeIf(!dev && pkgConfig.browser, (pkgBrowser) => __spreadProps(__spreadValues$1({}, getFilenames(pkgBrowser, ".umd", "umd")), {
name: convertToUMDName(pkgConfig.name),
exports: "auto"
}))
];
if (override) {
return [
{
input: override.input,
output: __spreadProps(__spreadValues$1(__spreadValues$1({}, getFilenames(override.output, override.format)), override.format === "umd" ? { name: convertToUMDName(pkgConfig.name) } : {}), {
preferConst: true,
exports: "auto",
format: override.format
}),
external,
plugins: getPlugins(override.output)
}
];
}
const typeEntrypoint = (pkgConfig.types || pkgConfig.typings) && pkg.resolveEntrypoint(pkgConfig.types || pkgConfig.typings);
return [
...binaries.map(([binary, input2]) => defu__default['default']({}, options, {
input: input2,
output: __spreadProps(__spreadValues$1({}, getFilenames(binary, "", "cjs")), {
preferConst: true,
exports: "auto",
banner: "#!/usr/bin/env node\n"
}),
external,
plugins: getPlugins(binary)
})),
...input ? defaultOutputs.map((output) => defu__default['default']({}, options, {
input,
output,
external,
plugins: getPlugins(output.entryFileNames)
})) : [],
...includeIf(typeEntrypoint, (input2) => ({
input: input2,
output: {
file: resolvePath(pkgConfig.types || pkgConfig.typings),
format: "es",
exports: "auto"
},
external,
plugins: getDeclarationPlugins()
})),
...exports.filter((outfile) => outfile && !outfile.match(/\.json$/)).map((outfile) => defu__default['default']({}, options, {
input: pkg.resolveEntrypoint(outfile),
output: __spreadProps(__spreadValues$1({}, getFilenames(outfile)), {
preferConst: true,
exports: "auto"
}),
external,
plugins: getPlugins(outfile)
})),
...exports.filter((outfile) => outfile && !outfile.match(/\.json$/) && pkg.resolveEntrypoint(outfile) !== typeEntrypoint).map((outfile) => defu__default['default']({}, options, {
input: pkg.resolveEntrypoint(outfile),
output: {
file: resolvePath(outfile.replace(/(\.es)?\.m?js$/, ".d.ts")),
format: "es",
exports: "auto"
},
external,
plugins: getDeclarationPlugins()
}))
];
}
function hl(str) {
return chalk__default['default'].green(str);
}
function prettyPath(p, highlight = true) {
p = upath.relative(process.cwd(), p);
return highlight ? hl(p) : p;
}
const logRollupConfig = (pkg, config) => {
config.forEach((item) => {
const input = typeof item.input === "string" ? prettyPath(item.input, false).padEnd(30) + " \u2192 " : item.input;
const output = Array.isArray(item.output) ? item.output : [item.output];
output.forEach((out) => {
const outfile = (out == null ? void 0 : out.file) || ((out == null ? void 0 : out.dir) ? out.dir + "/" : "") + String(out == null ? void 0 : out.entryFileNames) || "";
const format = outfile.endsWith(".d.ts") ? "(dts)" : (out == null ? void 0 : out.format) ? `(${out.format})` : "";
pkg.logger.debug(input, prettyPath(outfile), format);
});
});
};
var __defProp = Object.defineProperty;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
function removeBuildFolders(pkg) {
return __async(this, null, function* () {
const directories = ensureUnique([
...pkg.binaries.map(([bin]) => bin),
...includeIf(pkg.pkg.main, (main) => main)
].map((file) => upath.dirname(file)).filter((dir) => !dir.includes("src") && ![".", "./"].includes(dir)));
yield runInParallel(directories, (dir) => fsExtra.remove(dir));
});
}
const build = (_0, ..._1) => __async(undefined, [_0, ..._1], function* (pkg, { watch: shouldWatch = false, dev = shouldWatch, override } = {}) {
const {
options: { suffix, linkedDependencies, rootDir, rollup: rollupOptions }
} = pkg;
const config = __spreadValues({
alias: {},
replace: {},
dev
}, rollupOptions);
if (suffix) {
for (const _name of linkedDependencies || []) {
const name = _name + suffix;
config.replace[`'${_name}'`] = `'${name}'`;
config.alias[_name] = name;
}
}
yield pkg.callHook("build:extend", { config });
const rollupConfig = getRollupConfig(config, pkg, override);
yield pkg.callHook("build:extendRollup", {
rollupConfig
});
logRollupConfig(pkg, rollupConfig);
yield runInParallel(pkg.folderExports, (folder) => {
const { 1: distDir = folder, 3: ext } = folder.match(/^([^*]+[^*/])[*/]+(\.([a-z]+))?$/) || [];
const sourceFolder = pkg.resolveEntrypointFolder(distDir);
if (!sourceFolder)
return;
const srcDir = upath.relative(pkg.options.rootDir, sourceFolder);
pkg.logger.info(`Transpiling \`./${srcDir}\` to \`${distDir}\` with ${chalk.bold("mkdist")}.`);
mkdist.mkdist(__spreadValues({
srcDir,
distDir: distDir.slice(2),
rootDir: pkg.options.rootDir,
ext: ["mjs", "ts", "js"].includes(ext) ? ext : void 0
}, pkg.options.mkdist));
});
if (shouldWatch) {
const watcher = rollup.watch(rollupConfig);
watcher.on("event", (event) => {
switch (event.code) {
case "START":
return pkg.logger.debug(`Watching ${pkg.pkg.name} for changes`);
case "BUNDLE_START":
return pkg.logger.debug(`Building ${pkg.pkg.name}`);
case "BUNDLE_END":
return;
case "END":
return pkg.logger.success(`Built ${chalk.bold(pkg.pkg.name)}`);
case "ERROR":
formatError(rootDir, event.error);
return pkg.logger.error(event.error);
default:
const _event = event;
return pkg.logger.info(JSON.stringify(_event));
}
});
} else {
pkg.logger.debug(`Building ${pkg.pkg.name}`);
yield runInParallel(rollupConfig, (config2) => __async(this, null, function* () {
try {
const bundle = yield rollup.rollup(config2);
yield runInParallel(asArray(config2.output), (outputConfig) => __async(this, null, function* () {
if (!outputConfig) {
pkg.logger.error("No build defined in generated config.");
process.exit(1);
}
const { output } = yield bundle.write(outputConfig);
const { fileName } = output[0];
let size;
try {
const filePath = outputConfig.dir ? upath.join(outputConfig.dir, fileName) : outputConfig.file || fileName;
const { size: bytes } = yield fsExtra.stat(filePath);
if (bytes > 500) {
size = chalk.green(" " + chalk.bold((bytes / 1024).toFixed(1).padStart(5)) + " kB");
} else {
size = chalk.green(" " + chalk.bold(String(bytes).padStart(5)) + " B");
}
} catch (e) {
}
pkg.logger.success(`Built ${chalk.bold(pkg.pkg.name.padEnd(15))} ${chalk.gray(fileName.padStart(15))}${size}`);
}));
yield pkg.callHook("build:done", { bundle });
} catch (err) {
const formattedError = formatError(rootDir, err);
throw pkg.logger.error(formattedError);
}
}));
}
});
const formatError = (rootDir, error) => {
let loc = rootDir;
if (error.loc) {
const { file, column, line } = error.loc;
loc = `${file}:${line}:${column}`;
}
error.message = `[${error.code}] ${error.message}
at ${loc}`;
return error;
};
exports.Package = Package;
exports.asArray = asArray;
exports.build = build;
exports.defineSirocConfig = defineSirocConfig;
exports.ensureUnique = ensureUnique;
exports.getRollupConfig = getRollupConfig;
exports.glob = glob;
exports.groupBy = groupBy;
exports.includeDefinedProperties = includeDefinedProperties;
exports.includeIf = includeIf;
exports.logRollupConfig = logRollupConfig;
exports.regexpForPackage = regexpForPackage;
exports.removeBuildFolders = removeBuildFolders;
exports.runInParallel = runInParallel;
exports.sortObjectKeys = sortObjectKeys;
exports.tryJSON = tryJSON;
exports.tryRequire = tryRequire;