pkgbld 1.17.1 → 1.19.0

package/README.md

@@ -118,7 +118,13 @@ File(s) to make executable. The first entry will be added to package.json
 pkgbld --include-externals
 ```
 
-Bundles all externals into a package.
+or
+
+```
+pkgbld --include-externals=lodash
+```
+
+Bundles all or specified externals into a package.
 
 ### eject
 
@@ -140,6 +146,30 @@ pkgbld --no-update-package-json
 
 Do not write package.json.
 
+### commonjs-pattern
+
+```
+pkgbld --commonjs-pattern=[name].js
+```
+
+Defines the pattern for commonjs output files. Default is `[name].cjs`.
+
+### esm-pattern
+
+```
+pkgbld --esm-pattern=[name].js
+```
+
+Defines the pattern for esm output files. Default is `[name].mjs`.
+
+### umd-pattern
+
+```
+pkgbld --umd-pattern=[name].js
+```
+
+Defines the pattern for umd output files. Default is `[name].umd.js`.
+
 ## Plugin API
 
 `pkgbld` reads all installed packages named `pkgbld-plugin-*` and assumes they are plugins

package/dist/index.js

@@ -41,11 +41,23 @@ const defaults = {
     includeExternals: false,
     eject: false,
     noTsConfig: false,
-    noUpdatePackageJson: false
+    noUpdatePackageJson: false,
+    commonjsPattern: '[name].cjs',
+    esPattern: '[name].mjs',
+    umdPattern: '[name].umd.js'
 };
 function CommaSeparatedString(value) {
     return value.split(',').map((arg) => arg.trim());
 }
+function CommaSeparatedStringOrBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value) && value.length === 0) {
+        return true;
+    }
+    return CommaSeparatedString(value);
+}
 function getCliOptions(plugins, pkg) {
     const cliOptions = cleye.cli({
         name: 'pkgbld',
@@ -91,14 +103,14 @@ function getCliOptions(plugins, pkg) {
                 description: 'Executable files'
             },
             includeExternals: {
-                type: Boolean,
-                description: 'Include all externals into result bundle(s)',
+                type: CommaSeparatedStringOrBoolean,
+                description: 'Include all/specified externals into result bundle(s)',
                 default: defaults.includeExternals
             },
             eject: {
                 type: Boolean,
                 description: 'Eject config',
-                default: defaults.includeExternals
+                default: defaults.eject
             },
             noTsConfig: {
                 type: Boolean,
@@ -109,6 +121,21 @@ function getCliOptions(plugins, pkg) {
                 type: Boolean,
                 description: 'Do not create / update package.json',
                 default: defaults.noUpdatePackageJson
+            },
+            commonjsPattern: {
+                type: String,
+                description: 'CommonJS output file name pattern',
+                default: defaults.commonjsPattern
+            },
+            esmPattern: {
+                type: String,
+                description: 'ES output file name pattern',
+                default: defaults.esPattern
+            },
+            umdPattern: {
+                type: String,
+                description: 'UMD output file name pattern',
+                default: defaults.umdPattern
             }
         }
     });
@@ -126,7 +153,10 @@ function getCliOptions(plugins, pkg) {
         includeExternals: flags.includeExternals,
         eject: flags.eject,
         noTsConfig: flags.noTsConfig,
-        noUpdatePackageJson: flags.noUpdatePackageJson
+        noUpdatePackageJson: flags.noUpdatePackageJson,
+        commonjsPattern: flags.commonjsPattern,
+        esPattern: flags.esmPattern,
+        umdPattern: flags.umdPattern
     };
     for (const plugin of plugins) {
         plugin.options?.(flags, options);
@@ -158,28 +188,54 @@ async function commonjs (provider) {
 }
 
 async function externals (provider, config, inputs) {
-    if (config.includeExternals) {
+    if (config.includeExternals === true) {
         return;
     }
     const pluginExternals = await provider.import('@rollup-extras/plugin-externals');
     const allowGenericUmd = config.umdInputs.length === 1 && inputs.length === 1;
     if (config.formats.length > 0) {
         const format = (allowGenericUmd ? undefined : config.formats.filter(format => format !== 'umd'));
-        provider.provide(() => pluginExternals(), 2000 /* Priority.externals */, { format });
+        provider.provide(() => pluginExternals({
+            external: (id, external, importer) => includeExternals(importer, external, id, config)
+        }), 2000 /* Priority.externals */, { format });
+        // for eject config
+        provider.globalImport('path', 'path');
+        provider.globalSetup(includeExternals);
     }
     if (!allowGenericUmd && config.umdInputs.length > 0) {
         const curry = (await provider.import('lodash/curry.js'));
         for (const currentInput of config.umdInputs) {
-            const isExternal = curry((currentInput, id, external) => external || isExternalInput(currentInput, inputs, id, config))(currentInput);
+            const isExternal = curry((currentInput, id, external, importer) => includeExternals(importer, external, id, config) || isExternalInput(currentInput, inputs, id, config))(currentInput);
             provider.provide(() => pluginExternals({
                 external: isExternal
             }), 2000 /* Priority.externals */, { format: 'umd', inputs: [`./${config.sourceDir}/${currentInput}.ts`] });
         }
         // for eject config
-        provider.globalImport('path', 'path');
+        if (config.formats.length === 0) {
+            provider.globalImport('path', 'path');
+            provider.globalSetup(includeExternals);
+        }
         provider.globalSetup(isExternalInput);
     }
 }
+function includeExternals(importer, external, id, config) {
+    if (config.includeExternals === false)
+        return external;
+    if (!external)
+        return false;
+    if (path.isAbsolute(id)) {
+        id = './' + path.relative(process.cwd(), id);
+    }
+    const internals = config.includeExternals;
+    if (internals.includes(id) || internals.some(internal => id.startsWith(internal))) {
+        return false;
+    }
+    const relative = path.relative('.', path.resolve(importer ?? '.', id));
+    if (internals.some(internal => relative.includes(`node_modules/${internal}/`))) {
+        return false;
+    }
+    return true;
+}
 function isExternalInput(currentInput, inputs, id, config) {
     let normalizedPath;
     if (path.isAbsolute(currentInput)) {
@@ -329,13 +385,13 @@ function getTimeDiff(starting) {
 }
 const areSetsEqual = (a, b) => a.size === b.size ? [...a].every(value => b.has(value)) : false;
 
-const fileNamePatterns = {
-    'es': '[name].mjs',
-    'cjs': '[name].cjs',
-    'umd': '[name].umd.js',
-};
 async function getRollupConfigs([provider, plugins$1], inputs, config, helpers, externalPlugins) {
     const factoryInProgress = [];
+    const fileNamePatterns = {
+        'es': config.esPattern,
+        'cjs': config.commonjsPattern,
+        'umd': config.umdPattern
+    };
     for (const factory of plugins) {
         factoryInProgress.push(factory(provider, config, inputs));
     }
@@ -537,7 +593,7 @@ function processPackage(pkg, config, plugins) {
     }
     pkg.types = `./${config.dir}/index.d.ts`;
     if (allowUmd && typeof pkg.umd === 'string') {
-        pkg.umd = `./${config.dir}/index.umd.js`;
+        pkg.umd = `./${config.dir}/${patternToName(config.umdPattern, 'index')}`;
         if (!config.umdInputs.includes('index')) {
             config.umdInputs.push('index');
         }
@@ -562,23 +618,23 @@ function processPackage(pkg, config, plugins) {
     else {
         delete pkg.bin;
     }
-    if (allowCjs && typeof pkg.main !== 'string') {
-        pkg.main = `./${config.dir}/index.cjs`;
+    if (allowCjs) {
+        pkg.main = `./${config.dir}/${patternToName(config.commonjsPattern, 'index')}`;
     }
-    if (allowEsm && !allowCjs && typeof pkg.main !== 'string') {
-        pkg.main = `./${config.dir}/index.mjs`;
+    if (allowEsm && !allowCjs) {
+        pkg.main = `./${config.dir}/${patternToName(config.esPattern, 'index')}`;
     }
     if (allowCjs && pkg.main !== pkg.exports['.'].require) {
         pkg.exports['.'].require = pkg.main;
     }
     if (allowCjs && allowEsm && typeof pkg.module !== 'string') {
-        pkg.module = `./${config.dir}/index.mjs`;
+        pkg.module = `./${config.dir}/${patternToName(config.esPattern, 'index')}`;
     }
     if (pkg.module !== pkg.exports['.']?.default) {
         pkg.exports['.'].default = pkg.module;
     }
     if (allowUmd && config.umdInputs.includes('index')) {
-        pkg.unpkg = `./${config.dir}/index.umd.js`;
+        pkg.unpkg = `./${config.dir}/${patternToName(config.umdPattern, 'index')}`;
     }
     for (const id in pkg.exports) {
         if (id === './package.json')
@@ -588,10 +644,10 @@ function processPackage(pkg, config, plugins) {
             pkg.exports[id] = {};
         }
         if (allowCjs) {
-            pkg.exports[id].require = `./${config.dir}/${basename}.cjs`;
+            pkg.exports[id].require = `./${config.dir}/${patternToName(config.commonjsPattern, basename)}`;
         }
         if (allowEsm) {
-            pkg.exports[id].default = `./${config.dir}/${basename}.mjs`;
+            pkg.exports[id].default = `./${config.dir}/${patternToName(config.esPattern, basename)}`;
         }
         if (basename !== 'index') {
             if (!pkg.files.includes(basename)) {
@@ -608,12 +664,15 @@ function processPackage(pkg, config, plugins) {
     }
     return inputs;
 }
+function patternToName(pattern, input) {
+    return pattern.replace('[name]', input);
+}
 
 async function writeJson(path, json) {
     await fs.writeFile(path, JSON.stringify(json, null, 2) + '\n');
 }
 
-var version = "1.17.1";
+var version = "1.19.0";
 var name = "pkgbld";
 var license = "MIT";
 var author = "Konstantin Shutkin";

package/dist/src/get-cli-options.d.ts

@@ -9,8 +9,11 @@ export declare function getCliOptions(plugins: Partial<PkgbldPlugin>[], pkg: Pac
     dir: string;
     sourceDir: string;
     bin?: string[] | undefined;
-    includeExternals: boolean;
+    includeExternals: boolean | string[];
     eject: boolean;
     noTsConfig: boolean;
     noUpdatePackageJson: boolean;
+    commonjsPattern: string;
+    esPattern: string;
+    umdPattern: string;
 };

package/dist/src/get-rollup-configs.d.ts

@@ -21,7 +21,7 @@ export declare function getRollupConfigs([provider, plugins]: [Provider, PkgbldR
         externalLiveBindings?: boolean | undefined;
         file?: string | undefined;
         footer?: string | import("rollup").AddonFunction | undefined;
-        format: "amd" | "cjs" | "es" | "iife" | "system" | "umd" | "commonjs" | "esm" | "module" | "systemjs";
+        format: "umd" | "es" | "cjs" | "amd" | "iife" | "system" | "commonjs" | "esm" | "module" | "systemjs";
         freeze?: boolean | undefined;
         generatedCode?: import("rollup").GeneratedCodePreset | import("rollup").GeneratedCodeOptions | undefined;
         globals?: import("rollup").GlobalsOption | undefined;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.17.1",
+  "version": "1.19.0",
   "name": "pkgbld",
   "license": "MIT",
   "author": "Konstantin Shutkin",