@growing-web/esm-pack-core
Version:
esm pack build core.
1,128 lines (1,096 loc) • 34.9 kB
JavaScript
;
Object.defineProperty(exports, '__esModule', { value: true });
const nodePolyfills = require('rollup-plugin-node-polyfills');
const commonjs = require('@rollup/plugin-commonjs');
const resolve$1 = require('@rollup/plugin-node-resolve');
const esbuild = require('rollup-plugin-esbuild');
const rollupJSONPlugin = require('@rollup/plugin-json');
const path$1 = require('pathe');
const fs$1 = require('fs-extra');
const rollup = require('rollup');
const fs = require('fs');
const path = require('path');
const execa = require('execa');
const isValidIdentifier = require('is-valid-identifier');
const resolve = require('resolve');
const inject = require('@rollup/plugin-inject');
const pkgTypes = require('pkg-types');
const fg = require('fast-glob');
const _ = require('lodash');
const cjsEsmExports = require('cjs-esm-exports');
const esModuleLexer = require('es-module-lexer');
const peerDepsExternal = require('rollup-plugin-peer-deps-external');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
const nodePolyfills__default = /*#__PURE__*/_interopDefaultLegacy(nodePolyfills);
const commonjs__default = /*#__PURE__*/_interopDefaultLegacy(commonjs);
const resolve__default$1 = /*#__PURE__*/_interopDefaultLegacy(resolve$1);
const esbuild__default = /*#__PURE__*/_interopDefaultLegacy(esbuild);
const rollupJSONPlugin__default = /*#__PURE__*/_interopDefaultLegacy(rollupJSONPlugin);
const path__default$1 = /*#__PURE__*/_interopDefaultLegacy(path$1);
const fs__default$1 = /*#__PURE__*/_interopDefaultLegacy(fs$1);
const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
const execa__default = /*#__PURE__*/_interopDefaultLegacy(execa);
const isValidIdentifier__default = /*#__PURE__*/_interopDefaultLegacy(isValidIdentifier);
const resolve__default = /*#__PURE__*/_interopDefaultLegacy(resolve);
const inject__default = /*#__PURE__*/_interopDefaultLegacy(inject);
const fg__default = /*#__PURE__*/_interopDefaultLegacy(fg);
const ___default = /*#__PURE__*/_interopDefaultLegacy(_);
const peerDepsExternal__default = /*#__PURE__*/_interopDefaultLegacy(peerDepsExternal);
const APP_NAME = "esm-pack";
const EXTENSIONS = [
".ts",
".tsx",
".mjs",
".cjs",
".js",
".jsx",
".json"
];
const FILE_EXCLUDES = [
"tsconfig.json",
"eslint",
"tslint",
"prettier",
"stylelint",
"commitlint",
"turbo",
"main.package",
"vetur",
".vscode",
"build-info.json",
"build.json",
".env",
".gitignore",
".npmrc",
".yarnrc",
"pnpm-lock.yaml",
"package-lock.json",
"yarn.lock",
"nginx.conf"
];
const FILES_IGNORE = [
"**/src/**",
"**/bin/**",
"**/node_modules/**",
"**/vetur/**",
"**/.vscode/**",
"**/.idea/**",
"**/.changeset/**",
"**/.husky/**",
"**/.esmd/**",
"**/pnpm-lock.yaml/**",
"**/yarn.lock/**",
"**/package-lock.json/**",
"**/.prettierrc.json/**",
"**/.commitlintrc.json/**",
"**/ecosystem.config.js/**",
"**/scripts/**",
"**/.dockerignore/**",
"**/Dockerfile/**",
"**/.eslintrc.json/**",
"**/nest-cli.json/**",
"**/nodemon.json/**",
"**/nginx.conf/**",
"**/yarnrc/**",
"**/.gitignore/**",
"**/.markdownlint.yml/**"
];
const FILE_EXTENSIONS = [
...EXTENSIONS,
".less",
".scss",
".css",
".sass",
".postcss"
];
const { parse } = require("cjs-module-lexer");
function createTransformTarget(specifier, all = true) {
return {
specifier,
all,
default: false,
namespace: false,
named: []
};
}
function normalizePath(p) {
return p.split(path__default.win32.sep).join(path__default.posix.sep);
}
function isJavaScript(pathname) {
const ext = path__default.extname(pathname).toLowerCase();
return ext === ".js" || ext === ".mjs" || ext === ".cjs";
}
function isRemoteUrl(val) {
return /\w+:\/\//.test(val) || val.startsWith("//");
}
function isTruthy(item) {
return Boolean(item);
}
function isValidNamedExport(name) {
return name !== "default" && name !== "__esModule" && isValidIdentifier__default(name);
}
function rollupPluginWrapTargets(isTreeshake = false, target) {
if (!target) {
return null;
}
const installTargetSummaries = {};
const cjsScannedNamedExports = /* @__PURE__ */ new Map();
const transformTarget = createTransformTarget(target);
function cjsAutoDetectExportsStatic(filename, visited = /* @__PURE__ */ new Set()) {
const isMainEntrypoint = visited.size === 0;
if (visited.has(filename)) {
return [];
} else {
visited.add(filename);
}
const fileContents = fs__default.readFileSync(filename, "utf8");
try {
const { exports: exports2, reexports } = parse(fileContents);
let resolvedReexports = [];
if (reexports.length > 0) {
resolvedReexports = [].concat.apply([], reexports.map((e) => cjsAutoDetectExportsStatic(resolve__default.sync(e, { basedir: path__default.dirname(filename) }), visited)).filter(isTruthy));
}
const resolvedExports = Array.from(/* @__PURE__ */ new Set([...exports2, ...resolvedReexports])).filter(isValidNamedExport);
return isMainEntrypoint && resolvedExports.length === 0 ? void 0 : resolvedExports;
} catch (err) {
return void 0;
}
}
function cjsAutoDetectExportsRuntimeTrusted(normalizedFileName) {
try {
const { stdout } = execa__default.sync(`node`, ["-p", `JSON.stringify(Object.keys(require('${normalizedFileName}')))`], {
cwd: __dirname,
extendEnv: false
});
return JSON.parse(stdout).filter(isValidNamedExport);
} catch (err) {
return void 0;
}
}
function cjsAutoDetectExportsRuntimeUntrusted() {
try {
return exports.filter((identifier) => isValidIdentifier__default(identifier));
} catch (err) {
return void 0;
}
}
return {
name: "rollup-plugin-wrap-exports",
buildStart(inputOptions) {
const input = inputOptions.input;
for (const [key, val] of Object.entries(input)) {
if (isRemoteUrl(val)) {
continue;
}
if (!isJavaScript(val)) {
continue;
}
installTargetSummaries[val] = transformTarget;
const normalizedFileLoc = normalizePath(val);
const cjsExports = cjsAutoDetectExportsStatic(val) || cjsAutoDetectExportsRuntimeTrusted(normalizedFileLoc) || cjsAutoDetectExportsRuntimeUntrusted();
if (cjsExports && cjsExports.length > 0) {
cjsScannedNamedExports.set(normalizedFileLoc, cjsExports);
input[key] = `${APP_NAME}:${val}`;
}
}
},
resolveId(id) {
if (id.startsWith(`${APP_NAME}:`)) {
return id;
}
return null;
},
load(id) {
if (!id.startsWith(`${APP_NAME}:`)) {
return null;
}
const fileLoc = id.substring(`${APP_NAME}:`.length);
const installTargetSummary = installTargetSummaries[fileLoc];
let uniqueNamedExports = Array.from(new Set(installTargetSummary.named));
const normalizedFileLoc = normalizePath(fileLoc);
const scannedNamedExports = cjsScannedNamedExports.get(normalizedFileLoc);
if (scannedNamedExports && (!isTreeshake || installTargetSummary.namespace)) {
uniqueNamedExports = scannedNamedExports || [];
installTargetSummary.default = true;
}
const result = `
${installTargetSummary.namespace ? `export * from '${normalizedFileLoc}';` : ""}
${installTargetSummary.default ? `import _web_default_export_for_treeshaking__ from '${normalizedFileLoc}'; export default _web_default_export_for_treeshaking__;` : ""}
${`export {${uniqueNamedExports.join(",")}} from '${normalizedFileLoc}';`}
`;
return result;
}
};
}
function generateProcessPolyfill(env) {
return `/* ESM-PACK PROCESS POLYFILL (based on https://github.com/calvinmetcalf/node-process-es6) */
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
throw new Error('clearTimeout has not been defined');
}
var cachedSetTimeout = defaultSetTimout;
var cachedClearTimeout = defaultClearTimeout;
var globalContext;
if (typeof window !== 'undefined') {
globalContext = window;
} else if (typeof self !== 'undefined') {
globalContext = self;
} else {
globalContext = {};
}
if (typeof globalContext.setTimeout === 'function') {
cachedSetTimeout = setTimeout;
}
if (typeof globalContext.clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
}
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
//normal enviroments in sane situations
return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout(fun, 0);
} catch(e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout.call(null, fun, 0);
} catch(e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout(marker);
} catch (e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedClearTimeout.call(null, marker);
} catch (e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
function nextTick(fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
}
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
var title = 'browser';
var platform = 'browser';
var browser = true;
var env = {};
var argv = [];
var version = ''; // empty string to avoid regexp issues
var versions = {};
var release = {};
var config = {};
function noop() {}
var on = noop;
var addListener = noop;
var once = noop;
var off = noop;
var removeListener = noop;
var removeAllListeners = noop;
var emit = noop;
function binding(name) {
throw new Error('process.binding is not supported');
}
function cwd () { return '/' }
function chdir (dir) {
throw new Error('process.chdir is not supported');
}function umask() { return 0; }
// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
var performance = globalContext.performance || {};
var performanceNow =
performance.now ||
performance.mozNow ||
performance.msNow ||
performance.oNow ||
performance.webkitNow ||
function(){ return (new Date()).getTime() };
// generate timestamp or delta
// see http://nodejs.org/api/process.html#process_process_hrtime
function hrtime(previousTimestamp){
var clocktime = performanceNow.call(performance)*1e-3;
var seconds = Math.floor(clocktime);
var nanoseconds = Math.floor((clocktime%1)*1e9);
if (previousTimestamp) {
seconds = seconds - previousTimestamp[0];
nanoseconds = nanoseconds - previousTimestamp[1];
if (nanoseconds<0) {
seconds--;
nanoseconds += 1e9;
}
}
return [seconds,nanoseconds]
}
var startTime = new Date();
function uptime() {
var currentTime = new Date();
var dif = currentTime - startTime;
return dif / 1000;
}
export default {
nextTick: nextTick,
title: title,
browser: browser,
env: ${JSON.stringify(env)},
argv: argv,
version: version,
versions: versions,
on: on,
addListener: addListener,
once: once,
off: off,
removeListener: removeListener,
removeAllListeners: removeAllListeners,
emit: emit,
binding: binding,
cwd: cwd,
chdir: chdir,
umask: umask,
hrtime: hrtime,
platform: platform,
release: release,
config: config,
uptime: uptime
};
export { addListener, argv, binding, browser, chdir, config, cwd, emit, env, hrtime, nextTick, off, on, once, platform, release, removeAllListeners, removeListener, title, umask, uptime, version, versions };
`;
}
const PROCESS_MODULE_NAME = "process";
function rollupPluginNodeProcessPolyfill(env = {}) {
const injectPlugin = inject__default({
process: PROCESS_MODULE_NAME,
include: /\.(cjs|js|jsx|mjs|ts|tsx)$/
});
return {
...injectPlugin,
name: "snowpack:rollup-plugin-node-process-polyfill",
resolveId(source) {
if (source === PROCESS_MODULE_NAME) {
return PROCESS_MODULE_NAME;
}
return null;
},
load(id) {
if (id === PROCESS_MODULE_NAME) {
return { code: generateProcessPolyfill(env), moduleSideEffects: false };
}
return null;
}
};
}
function fileResolveByExtension(pathname) {
if (fs__default$1.existsSync(pathname)) {
return pathname;
}
for (const ext of EXTENSIONS) {
const extFile = `${pathname}${ext}`;
if (fs__default$1.existsSync(extFile)) {
return extFile;
}
}
return null;
}
function fileReader(path) {
return fs__default$1.readFileSync(path, {
encoding: "utf-8"
});
}
function recursionExportsValues(exp) {
const files = [];
for (const value of Object.values(exp)) {
if (___default.isString(value)) {
if (!value.endsWith("d.ts")) {
files.push(value);
}
} else if (___default.isObject(value)) {
files.push(...recursionExportsValues(value));
}
}
return Array.from(new Set(files));
}
const DEFAULT_ENTRY = "index.js";
const IGNORE_KEYS = ["default", "types", "typings", "development", "browser"];
const JS_RE = /\.[m]?js$/;
async function resolvePackage(cachePath) {
const pkg = await pkgTypes.readPackageJSON(cachePath);
if (pkg.__ESMD__ === true) {
return pkg;
}
const pkgExports = await resolveExports(pkg, cachePath);
const files = await resolveFiles(pkg, cachePath, pkgExports);
pkg.exports = pkgExports;
pkg.files = files;
Object.assign(pkg, await resolveImports(pkg));
pkg.__ESMD__ = true;
return pkg;
}
async function resolveImports(pkg) {
const { browser } = pkg;
if (!browser || !___default.isObject(browser)) {
return {};
}
const pkgBrowser = browser;
const resultImport = pkgBrowser?.import ?? {};
for (const [key, value] of Object.entries(pkgBrowser)) {
const importKey = `#${key.replace(/^((\.+)?\/?)/, "")}`;
if (resultImport[importKey]) {
continue;
}
Object.assign(resultImport, {
[importKey]: {
browser: normalizeExport(value),
default: normalizeExport(key)
}
});
}
return { imports: resultImport };
}
async function resolveExports(pkg, root) {
let {
exports: pkgExports,
module: pkgModule,
main: pkgMain,
browser: pkgBrowser,
files: pkgFiles = []
} = pkg;
const cjsMainFiles = [];
const unStandard = !pkgExports && !pkgMain && !pkgModule;
if (pkgExports !== void 0 && pkgExports !== null) {
if (___default.isObject(pkgExports)) {
if (pkgExports["./*"] === "./*") {
const result3 = await addCjsFiledToExports({
root,
pkgExports,
cjsMainFiles
});
return await developmentifyExports(result3, root);
}
pkgExports["./package.json"] = "./package.json.js";
}
if (___default.isString(pkgExports)) {
pkgExports = { ".": pkgExports };
}
for (const [key, pattern] of Object.entries(pkgExports)) {
if (key.includes("*") && ___default.isString(pattern) && pattern.includes("*") || key.endsWith("/") && ___default.isString(pattern) && pattern.endsWith("/")) {
await addMatchFileToExports(pattern, pkgExports, root);
continue;
}
if (___default.isObject(pattern)) {
await handleObjectPattern({
root,
pkgExports,
key,
pattern
});
}
}
const result2 = await addCjsFiledToExports({
root,
pkgExports,
cjsMainFiles
});
return await developmentifyExports(result2, root);
} else if (!pkgExports) {
const resultExports = {};
if (!pkgModule && !pkgMain) {
const normalizePkgMain = normalizeExport(guessEntryFile(root, pkgFiles));
const addonCjsMainFiles = await createCjsMainFiles(root, normalizePkgMain);
cjsMainFiles.push(...addonCjsMainFiles);
Object.assign(resultExports, {
".": normalizePkgMain
});
} else if (pkgModule && pkgMain) {
const normalizePkgMain = normalizeExport(pkgMain);
const normalizepkgModule = normalizeExport(pkgModule);
const addonCjsMainFiles = await createCjsMainFiles(root, normalizePkgMain);
cjsMainFiles.push(...addonCjsMainFiles);
Object.assign(resultExports, {
".": await resolveMainAndModule(root, normalizePkgMain, normalizepkgModule, pkgBrowser)
});
if (!pkgBrowser) {
Object.assign(resultExports, await joinFilesToExports(root, pkgFiles));
}
resultExports["./package.json"] = "./package.json.js";
Object.assign(resultExports, {
[normalizePkgMain]: await resolveMain(root, normalizePkgMain),
[normalizepkgModule]: normalizepkgModule
});
} else if (!pkgModule && pkgMain) {
const normalizePkgMain = normalizeExport(pkgMain);
const addonCjsMainFiles = await createCjsMainFiles(root, normalizePkgMain);
cjsMainFiles.push(...addonCjsMainFiles);
Object.assign(resultExports, {
".": await resolveMain(root, normalizePkgMain),
[normalizePkgMain]: await resolveMain(root, normalizePkgMain)
});
resultExports["./package.json"] = "./package.json.js";
Object.assign(resultExports, await joinFilesToExports(root, pkgFiles));
}
pkgExports = resultExports;
}
if (unStandard) {
pkgExports["./package.json"] = "./package.json.js";
}
let result = await addCjsFiledToExports({ root, pkgExports, cjsMainFiles });
result = await handlerPkgBrowser(pkgBrowser, result);
return await developmentifyExports(result, root);
}
async function resolveFiles(pkg, root, pkgExports) {
let { files = [] } = pkg;
files = [];
files.push(...["", ".js"].map((item) => `package.json${item}`));
const values = recursionExportsValues(pkgExports);
files.push(...values.map((item) => {
return item.replace(/^\.?\//, "");
}));
files.forEach((item) => {
if (/\.[m|c]?js$/.test(item) && !item.includes("*")) {
files.push(`${item}.map`);
}
});
const matchFiles = await fg__default(["license", "readme.md", "changelog.md"], {
cwd: root,
caseSensitiveMatch: false
});
const matchTsFiles = await fg__default("./*.d.ts", {
cwd: root,
caseSensitiveMatch: false
});
files.push(...matchFiles, ...matchTsFiles);
files = files.filter((item) => !["*", ".", "./", "./*"].includes(item));
return Array.from(new Set(files)).sort();
}
async function developmentifyExports(pkgExports, root) {
for (const [key, value] of Object.entries(pkgExports)) {
const ext = path__default.extname(key);
if (!ext || key.endsWith(".prod.cjs") || ![".js", ".cjs"].includes(ext) || !___default.isString(value) || key === "./index.js") {
continue;
}
const filepath = path__default.join(root, key);
if (!fs__default$1.existsSync(filepath)) {
continue;
}
const { isEsm } = await getFileType(root, key);
if (isEsm) {
continue;
}
const content = fileReader(filepath);
const dynamicEntry = await isDynamicEntry(content);
if (dynamicEntry) {
const devKeys = await resolveDevFilename(key);
const itemExports = {
default: key,
development: devKeys
};
pkgExports[key] = itemExports;
const unExtKey = key.substring(0, key.length - ext.length);
if (pkgExports[unExtKey]) {
pkgExports[unExtKey] = itemExports;
}
}
}
return pkgExports;
}
async function joinFilesToExports(root, pkgFiles) {
const resultExports = {};
const getFiles = await findPkgFiles(root, pkgFiles);
getFiles.forEach((file) => {
const fileKey = normalizeExport(file);
if (!fileKey.endsWith(".cjs.js")) {
resultExports[fileKey] = fileKey;
if (JS_RE.test(fileKey)) {
resultExports[removeFileExt(fileKey)] = fileKey;
}
}
});
return resultExports;
}
async function handlerPkgBrowser(pkgBrowser, pkgExports) {
if (!pkgBrowser || ___default.isString(pkgBrowser)) {
return pkgExports;
}
const resultExports = pkgExports;
for (const [key, value] of Object.entries(pkgBrowser)) {
if (!resultExports[key] || ___default.isString(resultExports[key])) {
resultExports[removeFileExt(key)] = resultExports[key] = {
default: normalizeExport(key),
browser: normalizeExport(value)
};
}
}
return resultExports;
}
async function createCjsMainFiles(root, pkgMain) {
const { isCjs } = await getFileType(root, pkgMain);
const cjsMainFiles = [];
if (isCjs) {
cjsMainFiles.push(...[pkgMain]);
}
return cjsMainFiles;
}
async function findPkgFiles(root, pkgFiles = []) {
const pattern = pkgFiles.length === 0 ? "**/**" : pkgFiles.map((item) => {
if (item.includes("*") || path__default.extname(item)) {
return item;
} else {
const filepath = path__default.join(root, item);
if (fs__default$1.existsSync(filepath) && fs__default$1.statSync(filepath).isFile()) {
return item;
}
return `${item}${item.endsWith("/") ? "" : "/"}**/**.js`;
}
});
const files = await fg__default(pattern, { cwd: root, ignore: FILES_IGNORE });
const pkg = await pkgTypes.readPackageJSON(root);
return files.filter((item) => {
const ext = path__default.extname(item);
if (!ext || ext === ".ts" || excludeFiles(pkg, item)) {
return false;
}
return FILE_EXTENSIONS.includes(ext);
});
}
function excludeFiles(pkg, file) {
return FILE_EXCLUDES.some((item) => file.includes(item)) || file.endsWith(".min.js") || file.endsWith(".prod.js") || file.endsWith(".development.js") || file.endsWith(".dev.js") || file.endsWith(".global.js");
}
async function handleObjectPattern({
root,
pkgExports,
key,
pattern
}) {
for (const [pkey, pval] of Object.entries(pattern)) {
if (IGNORE_KEYS.includes(pkey)) {
continue;
}
if (___default.isString(pval)) {
if (pattern.import && pattern.require && ___default.isString(pattern.import) && ___default.isString(pattern.require) && pattern.require !== pattern.import) {
continue;
}
pkgExports[key][pkey] = await resolveMain(root, pval);
} else if (___default.isObject(pval)) {
for (const [ik, iv] of Object.entries(pval)) {
if (IGNORE_KEYS.includes(ik)) {
continue;
}
if (___default.isString(iv)) {
pkgExports[key][pkey][ik] = await resolveMain(root, iv);
}
}
}
}
}
async function addMatchFileToExports(pattern, pkgExports, cwd) {
const files = fg__default.sync(pattern.endsWith("/") ? `${pattern}*` : pattern, {
cwd
});
for (const key of files) {
pkgExports[key] = normalizeExport(key);
}
}
async function addCjsFiledToExports({
root,
pkgExports,
cjsMainFiles
}) {
for (const [key, value] of Object.entries(pkgExports)) {
if (___default.isObject(value)) {
const requireFile = value.require;
if (requireFile) {
if (___default.isString(requireFile)) {
pkgExports[`${requireFile}!cjs`] = requireFile;
} else if (___default.isObject(requireFile)) {
for (const rval of Object.values(requireFile)) {
pkgExports[`${rval}!cjs`] = rval;
}
}
}
} else {
try {
if (!key.includes("*") && !key.startsWith(".ts")) {
if (JS_RE.test(key)) {
const { isCjs } = await getFileType(root, key);
if (isCjs) {
pkgExports[`${key}!cjs`] = key;
}
} else if (key.endsWith("package.json")) {
pkgExports[`${value}!cjs`] = value;
}
}
} catch (error) {
}
}
}
for (const cjsMainFile of cjsMainFiles) {
pkgExports[`${cjsMainFile}!cjs`] = cjsMainFile;
}
return pkgExports;
}
function guessEntryFile(root, pkgFiles) {
let indexFile = pkgFiles.find((file) => path__default.basename(file) === "index");
if (indexFile) {
indexFile = path__default.basename(indexFile);
} else {
indexFile = "index";
}
const entryFile = fileResolveByExtension(path__default.join(root || "", indexFile));
if (entryFile) {
return path__default.relative(root, entryFile);
}
return DEFAULT_ENTRY;
}
async function resolveMainAndModule(root, pkgMain, pkgModule, pkgBrowser) {
const result = {
module: normalizeExport(pkgModule),
default: await resolveMain(root, pkgMain)
};
if (___default.isString(pkgBrowser)) {
Object.assign(result, {
browser: normalizeExport(pkgBrowser)
});
}
return result;
}
async function resolveMain(root, pkgMain) {
const normalizeMain = normalizeExport(pkgMain);
const isDynamicEntry2 = await getIsDynamic(root, pkgMain);
const { isUmd } = await getFileType(root, pkgMain);
if (isUmd || pkgMain.endsWith(".mjs") || !isDynamicEntry2) {
return normalizeMain;
}
return {
development: !isDynamicEntry2 ? normalizeMain : await resolveDevFilename(normalizeMain),
default: normalizeMain
};
}
async function resolveDevFilename(filename) {
const basename = path__default.basename(filename);
const newBaseName = basename.replace(/^(\.?\/?)*/, (m, $1) => `${$1 || ""}dev.`);
return filename.replace(basename, newBaseName);
}
async function getIsDynamic(root, filepath) {
const mainContent = fileReader(path__default.join(root, filepath));
let isDynamic = false;
if (JS_RE.test(filepath)) {
isDynamic = await isDynamicEntry(mainContent);
}
return isDynamic;
}
async function isDynamicEntry(source) {
try {
return source.replace(/\s*/g, "").includes(`process.env.NODE_ENV==`) || source.replace(/\s*/g, "").includes(`process.env.NODE_ENV!=`);
} catch (error) {
return false;
}
}
async function getFileType(root, filepath) {
if (!JS_RE.test(filepath)) {
return { isCjs: false, isEsm: false, isUmd: false };
}
const pkg = await pkgTypes.readPackageJSON(root);
await esModuleLexer.init;
const source = fileReader(path__default.join(root, filepath));
const [importer, exporter] = esModuleLexer.parse(source);
const { reexports } = cjsEsmExports.parse(filepath, source, "production");
const isCjs = pkg.type !== "module" && importer.length === 0 && exporter.length === 0 && !filepath.endsWith(".mjs");
if (isCjs) {
const isUmd = !exporter.length && !importer.length && reexports.length === 0;
return {
isCjs: true,
isEsm: false,
isUmd
};
}
const isEsm = importer.length !== 0 || exporter.length !== 0 || pkg.type === "module" || filepath.endsWith(".mjs");
return {
isCjs,
isEsm,
isUmd: isCjs && exporter.length === 0
};
}
function normalizeExport(str) {
if (str?.startsWith("./")) {
return str;
}
if (str?.startsWith("/")) {
return `.${str}`;
}
return `./${str}`;
}
function removeFileExt(file) {
const lastIndex = file.lastIndexOf(path__default.extname(file));
return file.substring(0, lastIndex);
}
process.setMaxListeners(0);
async function build({
buildFiles,
outputPath,
sourcePath,
sourcemap = true
}) {
const inputMap = {};
const pkg = await pkgTypes.readPackageJSON(sourcePath);
const devBuildFiles = [];
await Promise.all(buildFiles.map(async (file) => {
const dynamicEntry = await isDynamicEntry(fs__default$1.readFileSync(file, { encoding: "utf8" }));
if (dynamicEntry) {
devBuildFiles.push(file);
}
}));
for (const file of buildFiles) {
let n = file.split("/").pop();
if (!n) {
continue;
}
const extIndex = n.lastIndexOf(".");
if (extIndex !== -1)
n = n.slice(0, extIndex);
if (inputMap[n]) {
const _n = n;
let i = 1;
while (inputMap[n])
n = _n + ++i;
}
inputMap[n] = file;
}
await Promise.all([
doBuildMultipleEntry({
input: inputMap,
outputPath,
sourcePath,
env: "production",
name: pkg.name,
sourcemap
}),
Promise.all(devBuildFiles.map((input) => doBuildSingleEntry({
input,
outputPath,
sourcePath,
env: "development",
name: pkg.name,
sourcemap
})))
]);
}
async function doBuildMultipleEntry({
input,
sourcePath,
outputPath,
env,
name,
sourcemap
}) {
const inputKeys = Object.keys(input);
const bundle = await rollup.rollup({
input,
treeshake: { moduleSideEffects: true },
onwarn: onWarning,
external: (id) => !inputKeys.includes(path__default$1.join(sourcePath, id)) && !needExternal(id),
plugins: createRollupPlugins(name, env)
});
fs__default$1.ensureDirSync(outputPath);
const { output } = await bundle.generate({
dir: outputPath,
format: "esm",
exports: "named",
sourcemap,
entryFileNames: (chunk) => {
let id = chunk.facadeModuleId;
if (id?.startsWith(`${APP_NAME}:`)) {
id = id.replace(`${APP_NAME}:`, "");
}
id = id?.replace(sourcePath, "") ?? "";
id = id.replace(/^\//, "");
if (id.endsWith(".js") || id.endsWith(".mjs")) {
return id;
}
return `${id}.js`;
},
chunkFileNames: "[hash].js"
});
await Promise.all(output.map((chunk) => {
if (chunk.type === "chunk") {
const map = chunk.map?.toString();
const encoding = {
encoding: "utf8"
};
const filename = chunk.fileName;
return Promise.all([
fs__default$1.outputFile(path__default$1.join(outputPath, filename), chunk.code, encoding),
map && fs__default$1.outputFile(path__default$1.join(outputPath, `${filename}.map`), map, encoding)
]);
}
return () => {
};
}));
}
async function doBuildSingleEntry({
input,
sourcePath,
outputPath,
env,
name,
sourcemap,
devPrefix = "dev."
}) {
try {
const bundle = await rollup.rollup({
input,
treeshake: { moduleSideEffects: true },
onwarn: onWarning,
external: (id) => path__default$1.join(id) !== path__default$1.join(input) && !needExternal(id),
plugins: createRollupPlugins(name, env)
});
fs__default$1.ensureDirSync(outputPath);
let file = path__default$1.join(outputPath, path__default$1.relative(sourcePath, input));
const basename = path__default$1.basename(input);
if (basename === "package.json") {
file = path__default$1.join(outputPath, "package.json.js");
}
if (env === "development") {
file = file.replace(basename, `${devPrefix}${basename}`);
}
await bundle.write({
file,
exports: "named",
sourcemap
});
} catch (error) {
throw new Error(error);
}
}
function createRollupPlugins(name, env) {
return [
peerDepsExternal__default(),
resolve__default$1({
preferBuiltins: false,
browser: true,
extensions: [".mjs", ".cjs", ".js", ".json"]
}),
rollupJSONPlugin__default({
preferConst: true,
indent: " ",
compact: false,
namedExports: true
}),
commonjs__default({
extensions: [".js", ".cjs"],
esmExternals: true,
requireReturnsDefault: "auto"
}),
rollupPluginWrapTargets(false, name),
esbuild__default({
minify: true,
define: {
"process.env.NODE_ENV": JSON.stringify(env),
"process.env.VUE_ENV": JSON.stringify("browser")
}
}),
rollupPluginNodeProcessPolyfill({
NODE_ENV: env
}),
nodePolyfills__default()
].filter(Boolean);
}
function needExternal(id) {
return id.startsWith(`${APP_NAME}:`) || id.startsWith(`node:`) || id[0] === "." || path__default$1.isAbsolute(id) || ["process", "Buffer", "module"].includes(id) || path__default$1.basename(id) === "package.json";
}
function onWarning(warning, handler) {
if (["THIS_IS_UNDEFINED", "UNRESOLVED_IMPORT", "SOURCEMAP_ERROR"].includes(warning.code)) {
return;
}
handler(warning);
}
exports.build = build;
exports.doBuildMultipleEntry = doBuildMultipleEntry;
exports.doBuildSingleEntry = doBuildSingleEntry;
exports.isDynamicEntry = isDynamicEntry;
exports.normalizeExport = normalizeExport;
exports.removeFileExt = removeFileExt;
exports.resolveDevFilename = resolveDevFilename;
exports.resolveExports = resolveExports;
exports.resolveFiles = resolveFiles;
exports.resolveImports = resolveImports;
exports.resolvePackage = resolvePackage;