pkgbld 1.11.2 → 1.13.0

package/README.md

@@ -81,6 +81,14 @@ pkgbld --sourcedir=src
 
 Directory to search for input files.
 
+### bin
+
+```
+pkgbld --bin=./dist/index.cjs,./dist/index.mjs
+```
+
+File(s) to make executable. First entry will be added to package.json
+
 # License
 
 [MIT](./LICENSE)

package/dist/builtin-plugins/binify.d.ts

@@ -0,0 +1,3 @@
+import { getCliOptions } from '../get-cli-options';
+import { Provider } from '../types';
+export default function (provide: Provider, config: ReturnType<typeof getCliOptions>): Promise<void>;

package/dist/builtin-plugins/clean.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '../types';
+export default function (provide: Provider): Promise<void>;

package/dist/builtin-plugins/commonjs.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '../types';
+export default function (provide: Provider): Promise<void>;

package/dist/builtin-plugins/externals.d.ts

@@ -0,0 +1,3 @@
+import { getCliOptions } from '../get-cli-options';
+import { Provider } from '../types';
+export default function (provide: Provider, config: ReturnType<typeof getCliOptions>, inputs: string[]): Promise<void>;

package/dist/builtin-plugins/preprocess.d.ts

@@ -0,0 +1,3 @@
+import { getCliOptions } from '../get-cli-options';
+import { Provider } from '../types';
+export default function (provide: Provider, config: ReturnType<typeof getCliOptions>): Promise<void>;

package/dist/builtin-plugins/resolve.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '../types';
+export default function (provide: Provider): Promise<void>;

package/dist/builtin-plugins/terser.d.ts

@@ -0,0 +1,3 @@
+import { getCliOptions } from '../get-cli-options';
+import { Provider } from '../types';
+export default function (provide: Provider, config: ReturnType<typeof getCliOptions>): Promise<void>;

package/dist/builtin-plugins/typescript.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '../types';
+export default function (provide: Provider): Promise<void>;

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

@@ -1,9 +1,11 @@
 export declare function getCliOptions(): {
-    umdTargets: string[];
-    compressTargets: string[];
-    sourcemapTargets: string[];
+    umdInputs: string[];
+    compressFormats: string[];
+    sourcemapFormats: string[];
     formats: string[];
+    formatsOverriden: boolean;
     preprocess: string[];
     dir: string;
     sourceDir: string;
+    bin?: string[] | undefined;
 };

package/dist/get-plugins.d.ts

@@ -1,4 +1,11 @@
-import { InternalModuleFormat, Plugin } from 'rollup';
-import { getCliOptions } from './get-cli-options';
-export declare function getBuildPlugins(format: InternalModuleFormat, config: ReturnType<typeof getCliOptions>, inputs?: string[], currentInput?: string): Plugin[];
-export declare function getOutputPlugins(format: InternalModuleFormat, config: ReturnType<typeof getCliOptions>): Plugin[];
+import { Plugin, InternalModuleFormat } from 'rollup';
+import { Priotiry, Provider } from './types';
+import externals from './builtin-plugins/externals';
+export declare const plugins: (typeof externals)[];
+export declare function createProvider(): [Provider, {
+    plugin: () => Plugin;
+    priority: Priotiry;
+    format?: InternalModuleFormat | InternalModuleFormat[];
+    inputs?: string[];
+    outputPlugin?: true;
+}[]];

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

@@ -1,4 +1,54 @@
-import { RollupOptions } from 'rollup';
-import { getCliOptions } from './get-cli-options';
-import { getHelpers } from './helpers';
-export declare function getRollupConfigs(inputs: string[], config: ReturnType<typeof getCliOptions>, helpers: ReturnType<typeof getHelpers>): RollupOptions[];
+import type { getCliOptions } from './get-cli-options';
+import type { getHelpers } from './helpers';
+export declare function getRollupConfigs(inputs: string[], config: ReturnType<typeof getCliOptions>, helpers: ReturnType<typeof getHelpers>): Promise<{
+    input: string[];
+    output: {
+        amd?: import("rollup").AmdOptions | undefined;
+        assetFileNames?: string | ((chunkInfo: import("rollup").PreRenderedAsset) => string) | undefined;
+        banner?: string | import("rollup").AddonFunction | undefined;
+        chunkFileNames?: string | ((chunkInfo: import("rollup").PreRenderedChunk) => string) | undefined;
+        compact?: boolean | undefined;
+        dir: string;
+        dynamicImportFunction?: string | undefined;
+        dynamicImportInCjs?: boolean | undefined;
+        entryFileNames: string | ((chunkInfo: import("rollup").PreRenderedChunk) => string);
+        esModule?: boolean | "if-default-prop" | undefined;
+        experimentalMinChunkSize?: number | undefined;
+        exports?: "default" | "named" | "none" | "auto" | undefined;
+        extend?: boolean | undefined;
+        externalImportAssertions?: boolean | undefined;
+        externalLiveBindings?: boolean | undefined;
+        file?: string | undefined;
+        footer?: string | import("rollup").AddonFunction | undefined;
+        format: "amd" | "cjs" | "es" | "iife" | "system" | "umd" | "commonjs" | "esm" | "module" | "systemjs";
+        freeze?: boolean | undefined;
+        generatedCode?: import("rollup").GeneratedCodePreset | import("rollup").GeneratedCodeOptions | undefined;
+        globals?: import("rollup").GlobalsOption | undefined;
+        hoistTransitiveImports?: boolean | undefined;
+        indent?: string | boolean | undefined;
+        inlineDynamicImports?: boolean | undefined;
+        interop?: import("rollup").InteropType | import("rollup").GetInterop | undefined;
+        intro?: string | import("rollup").AddonFunction | undefined;
+        manualChunks?: import("rollup").ManualChunksOption | undefined;
+        minifyInternalExports?: boolean | undefined;
+        name?: string | undefined;
+        namespaceToStringTag?: boolean | undefined;
+        noConflict?: boolean | undefined;
+        outro?: string | import("rollup").AddonFunction | undefined;
+        paths?: import("rollup").OptionsPaths | undefined;
+        plugins: false | import("rollup").OutputPlugin | import("rollup").OutputPluginOption[] | Promise<false | import("rollup").OutputPlugin | import("rollup").NullValue | import("rollup").OutputPluginOption[]> | null;
+        preferConst?: boolean | undefined;
+        preserveModules?: boolean | undefined;
+        preserveModulesRoot?: string | undefined;
+        sanitizeFileName?: boolean | ((fileName: string) => string) | undefined;
+        sourcemap: boolean | "inline" | "hidden";
+        sourcemapBaseUrl?: string | undefined;
+        sourcemapExcludeSources?: boolean | undefined;
+        sourcemapFile?: string | undefined;
+        sourcemapPathTransform?: import("rollup").SourcemapPathTransformOption | undefined;
+        strict?: boolean | undefined;
+        systemNullSetters?: boolean | undefined;
+        validate?: boolean | undefined;
+    }[];
+    plugins: import("rollup").Plugin[];
+}[]>;

package/dist/helpers.d.ts

@@ -1,16 +1,13 @@
-import { getCliOptions } from './get-cli-options';
 import { OutputOptions } from 'rollup';
 export declare function getHelpers(name: string): {
     getGlobalName: (anInput: string) => string;
     getExternalGlobalName: (id: string) => string;
-    umdFilter: typeof umdFilter;
 };
-export declare function umdFilter(config: ReturnType<typeof getCliOptions>, filename: string): boolean;
 export declare function toArray<T>(object: T | T[] | undefined): T[];
-export declare function isExternalInput(id: string, inputs: string | string[], currentInput: string, config: ReturnType<typeof getCliOptions>): boolean;
 export declare function formatInput(input: string[] | string): string;
 export declare function formatOutput(output: OutputOptions | OutputOptions[] | undefined, field: 'dir' | 'format'): string;
 export declare function getTimeDiff(starting: number): string;
 export declare function getDefaultExport<T extends {
     default?: unknown;
 }>(importedModule: T): {};
+export declare const areSetsEqual: <T>(a: Set<T>, b: Set<T>) => boolean;

package/dist/index.js

@@ -7,13 +7,7 @@ var rollup = require('rollup');
 var fs = require('fs/promises');
 var path = require('path');
 var minimist = require('minimist');
-var typescript = require('rollup-plugin-typescript2');
-var commonjs = require('@rollup/plugin-commonjs');
-var resolve = require('@rollup/plugin-node-resolve');
-var preprocess = require('rollup-plugin-preprocess');
-var terser = require('@rollup/plugin-terser');
-var cleanFactory = require('@rollup-extras/plugin-clean');
-var externals = require('@rollup-extras/plugin-externals');
+var refiner = require('@slimlib/refine-partition');
 var camelCase = require('lodash/camelCase');
 var kleur = require('kleur');
 
@@ -34,31 +28,34 @@ async function createSubpackages(inputs, config) {
 
 const defaults = {
     formats: ['es', 'cjs'],
-    umdTargets: [],
-    compressTargets: ['umd'],
-    sourcemapTargets: ['umd'],
+    umdInputs: [],
+    compressFormats: ['umd'],
+    sourcemapFormats: ['umd'],
     preprocess: [],
     dir: 'dist',
     sourceDir: 'src'
 };
 function getCliOptions() {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     const parsedArgs = minimist(process.argv.slice(2));
-    const umdTargets = (_b = (_a = parsedArgs.umd) === null || _a === void 0 ? void 0 : _a.split(',').map((arg) => arg.trim())) !== null && _b !== void 0 ? _b : defaults.umdTargets;
-    const compressTargets = (_d = (_c = parsedArgs.compress) === null || _c === void 0 ? void 0 : _c.split(',').map((arg) => arg.trim())) !== null && _d !== void 0 ? _d : defaults.compressTargets;
-    const sourcemapTargets = (_f = (_e = parsedArgs.sourcemaps) === null || _e === void 0 ? void 0 : _e.split(',').map((arg) => arg.trim())) !== null && _f !== void 0 ? _f : defaults.sourcemapTargets;
+    const umdInputs = (_b = (_a = parsedArgs.umd) === null || _a === void 0 ? void 0 : _a.split(',').map((arg) => arg.trim())) !== null && _b !== void 0 ? _b : defaults.umdInputs;
+    const compressFormats = (_d = (_c = parsedArgs.compress) === null || _c === void 0 ? void 0 : _c.split(',').map((arg) => arg.trim())) !== null && _d !== void 0 ? _d : defaults.compressFormats;
+    const sourcemapFormats = (_f = (_e = parsedArgs.sourcemaps) === null || _e === void 0 ? void 0 : _e.split(',').map((arg) => arg.trim())) !== null && _f !== void 0 ? _f : defaults.sourcemapFormats;
     const formats = (_h = (_g = parsedArgs.formats) === null || _g === void 0 ? void 0 : _g.split(',').map((arg) => arg.trim())) !== null && _h !== void 0 ? _h : defaults.formats;
     const preprocess = (_k = (_j = parsedArgs.preprocess) === null || _j === void 0 ? void 0 : _j.split(',').map((arg) => arg.trim())) !== null && _k !== void 0 ? _k : defaults.preprocess;
     const dir = (_l = parsedArgs.dir) !== null && _l !== void 0 ? _l : defaults.dir;
     const sourceDir = (_m = parsedArgs.sourceDir) !== null && _m !== void 0 ? _m : defaults.sourceDir;
+    const bin = (_o = parsedArgs.bin) === null || _o === void 0 ? void 0 : _o.split(',').map((arg) => arg.trim());
     return {
-        umdTargets,
-        compressTargets,
-        sourcemapTargets,
+        umdInputs,
+        compressFormats,
+        sourcemapFormats,
         formats,
+        formatsOverriden: 'formats' in parsedArgs,
         preprocess,
         dir,
-        sourceDir
+        sourceDir,
+        bin
     };
 }
 
@@ -68,6 +65,136 @@ async function getPackage() {
     return [pkgPath, JSON.parse(buffer.toString())];
 }
 
+async function clean (provide) {
+    const { default: pluginClean } = await import('@rollup-extras/plugin-clean');
+    const pluginInstance = pluginClean();
+    provide(pluginFactory, 1000 /* Priotiry.cleanup */, { outputPlugin: true });
+    let firstPluginInstance = true;
+    function pluginFactory() {
+        const result = firstPluginInstance ? pluginInstance : pluginInstance.api.addInstance();
+        firstPluginInstance = false;
+        return result;
+    }
+}
+
+async function commonjs (provide) {
+    const { default: pluginCommonjs } = await import('@rollup/plugin-commonjs');
+    provide(() => pluginCommonjs(), 4000 /* Priotiry.commonjs */);
+}
+
+async function externals (provide, config, inputs) {
+    const { default: pluginExternals } = await 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'));
+        provide(() => pluginExternals(), 2000 /* Priotiry.externals */, { format });
+    }
+    if (!allowGenericUmd && config.umdInputs.length > 0) {
+        for (const currentInput of config.umdInputs) {
+            provide(() => pluginExternals({
+                external: (id, external) => external || isExternalInput(currentInput, inputs, id, config)
+            }), 2000 /* Priotiry.externals */, { format: 'umd', inputs: [`./${config.sourceDir}/${currentInput}.ts`] });
+        }
+    }
+}
+function isExternalInput(currentInput, inputs, id, config) {
+    let normalizedPath;
+    if (path.isAbsolute(currentInput)) {
+        normalizedPath = './' + path.relative(process.cwd(), currentInput);
+    }
+    else {
+        normalizedPath = './' + path.join(config.sourceDir, currentInput + '.ts');
+    }
+    if (path.isAbsolute(id)) {
+        id = './' + path.relative(process.cwd(), id);
+    }
+    return normalizedPath !== id && inputs.includes(normalizedPath);
+}
+
+async function preprocess (provide, config) {
+    if (config.preprocess.length > 0) {
+        const { default: pluginPreprocess } = await import('rollup-plugin-preprocess');
+        const include = config.preprocess.map(name => `${config.sourceDir}/${name}.ts`);
+        for (const format of config.formats) {
+            if (format !== 'umd') {
+                provide(() => pluginPreprocess({ include, context: { [format]: true } }), 1000 /* Priotiry.preprocess */, { format });
+            }
+            else {
+                for (const currentInput of config.umdInputs) {
+                    provide(() => pluginPreprocess({ include, context: { umd: true } }), 1000 /* Priotiry.preprocess */, { format, inputs: [`./${config.sourceDir}/${currentInput}.ts`] });
+                }
+            }
+        }
+    }
+}
+
+async function resolve (provide) {
+    const { default: pluginResolve } = await import('@rollup/plugin-node-resolve');
+    provide(() => pluginResolve(), 3000 /* Priotiry.resolve */);
+}
+
+async function terser (provide, config) {
+    if (config.compressFormats.length > 0) {
+        const { default: pluginTerser } = await import('@rollup/plugin-terser');
+        const options = {
+            mangle: {
+                properties: {
+                    regex: /_$/
+                }
+            }
+        };
+        const filteredFormats = config.compressFormats.filter(format => config.formats.includes(format));
+        if (filteredFormats.length > 0) {
+            for (const format of filteredFormats) {
+                if (format !== 'umd') {
+                    provide(() => pluginTerser(options), 10000 /* Priotiry.compress */, { format, outputPlugin: true });
+                }
+                else {
+                    for (const currentInput of config.umdInputs) {
+                        provide(() => pluginTerser(options), 10000 /* Priotiry.compress */, { format, outputPlugin: true, inputs: [`./${config.sourceDir}/${currentInput}.ts`] });
+                    }
+                }
+            }
+        }
+    }
+}
+
+async function typescript (provide) {
+    const { default: pluginTypescript } = await import('rollup-plugin-typescript2');
+    provide(() => pluginTypescript(), 6000 /* Priotiry.transpile */);
+}
+
+async function binify (provide, config) {
+    var _a;
+    if (config.bin != null) {
+        const { default: pluginBinify } = await import('@rollup-extras/plugin-binify');
+        const format = (_a = {
+            'cjs': 'cjs',
+            'mjs': 'es'
+        }[path.extname(config.bin[0])]) !== null && _a !== void 0 ? _a : 'cjs';
+        provide(() => pluginBinify({
+            filter: (item) => item.type === 'chunk' && item.isEntry && config.bin.some(input => input === `./${config.dir}/${item.fileName}`)
+        }), 20000 /* Priotiry.finalize */, { outputPlugin: true, format });
+    }
+}
+
+const plugins = [
+    clean,
+    commonjs,
+    externals,
+    preprocess,
+    resolve,
+    terser,
+    typescript,
+    binify
+];
+function createProvider() {
+    const plugins = [];
+    return [(plugin, priority, options) => {
+            plugins.push({ priority, plugin, format: options === null || options === void 0 ? void 0 : options.format, inputs: options === null || options === void 0 ? void 0 : options.inputs, outputPlugin: options === null || options === void 0 ? void 0 : options.outputPlugin });
+        }, plugins];
+}
+
 function getHelpers(name) {
     function getGlobalName(anInput) {
         return camelCase(path.join(name, path.basename(anInput, '.ts') !== 'index' ? path.basename(anInput, '.ts') : ''));
@@ -80,14 +207,9 @@ function getHelpers(name) {
     }
     return {
         getGlobalName,
-        getExternalGlobalName,
-        umdFilter
+        getExternalGlobalName
     };
 }
-function umdFilter(config, filename) {
-    const id = path.basename(filename, '.ts');
-    return config.umdTargets.includes(id);
-}
 function toArray(object) {
     if (Array.isArray(object)) {
         return object;
@@ -97,21 +219,11 @@ function toArray(object) {
     }
     return [object];
 }
-function isExternalInput(id, inputs, currentInput, config) {
-    let normalizedPath;
-    if (path.isAbsolute(id)) {
-        normalizedPath = './' + path.relative(process.cwd(), id);
-    }
-    else {
-        normalizedPath = './' + path.join(config.sourceDir, id + '.ts');
-    }
-    return normalizedPath !== currentInput && inputs.includes(normalizedPath);
-}
 function formatInput(input) {
     return (Array.isArray(input) ? input : [input !== null && input !== void 0 ? input : '']).map(item => kleur.magenta(path.basename(item, '.ts'))).join(', ');
 }
 function formatOutput(output, field) {
-    // can we avoid it?
+    //? can we avoid it
     if (output == null) {
         return '';
     }
@@ -123,89 +235,164 @@ function getTimeDiff(starting) {
         return `${((now - starting) / 1000).toFixed(1)}s`;
     }
     return `${now - starting}ms`;
-}
-
-const clean = cleanFactory();
-function getBuildPlugins(format, config, inputs, currentInput) {
-    const result = [
-        externals({
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            external: (id, external) => external || (format === 'umd' ? isExternalInput(id, inputs, currentInput, config) : false)
-        }),
-        resolve(),
-        commonjs(),
-        typescript()
-    ];
-    if (config.preprocess.length) {
-        const context = { [format]: true };
-        result.unshift(preprocess({ include: config.preprocess.map(name => `${config.sourceDir}/${name}.ts`), context }));
-    }
-    return result;
 }
-function getOutputPlugins(format, config) {
-    const result = [
-        clean
-    ];
-    if (config.compressTargets.includes(format)) {
-        result.push(terser({
-            mangle: {
-                properties: {
-                    regex: /_$/
+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(inputs, config, helpers) {
+    var _a;
+    const [provide, plugins$1] = createProvider();
+    for (const factory of plugins) {
+        await factory(provide, config, inputs);
+    }
+    const expandInputs = new Set;
+    for (const plugin of plugins$1) {
+        if (plugin.format && ((_a = plugin.inputs) === null || _a === void 0 ? void 0 : _a.length) && !plugin.outputPlugin) {
+            for (const format of toArray(plugin.format)) {
+                expandInputs.add(format);
+            }
+        }
+    }
+    const refineNext = refiner();
+    refineNext(doExpandInputs(toArray(config.formats)));
+    for (const plugin of plugins$1) {
+        if (plugin.format && !plugin.outputPlugin) {
+            const formats = toArray(plugin.format);
+            if (!plugin.inputs || plugin.inputs.length === 0) {
+                refineNext(doExpandInputs(formats));
+            }
+            else {
+                if (inputs.length === 1) {
+                    refineNext(formats);
+                }
+                else {
+                    const expanded = [];
+                    for (const format of formats) {
+                        for (const input of plugin.inputs) {
+                            expanded.push(`${format}.${input}`);
+                        }
+                    }
+                    refineNext(expanded);
                 }
             }
-        }));
+        }
     }
-    return result;
-}
-
-function getRollupConfigs(inputs, config, helpers) {
-    const configs = [];
-    if (config.formats.includes('es')) {
-        configs.push({
-            input: inputs,
-            output: {
-                format: 'es',
-                dir: config.dir,
-                entryFileNames: '[name].mjs',
-                chunkFileNames: '[name].mjs',
-                plugins: getOutputPlugins('es', config),
-                sourcemap: config.sourcemapTargets.includes('es')
-            },
-            plugins: getBuildPlugins('es', config)
-        });
-    }
-    if (config.formats.includes('cjs')) {
-        configs.push({
+    const refined = refineNext();
+    const partitions = [];
+    for (const partition of refined) {
+        const result = [];
+        for (const format of partition) {
+            if (format.includes('.')) {
+                const [, realFormat, input] = format.split(/(.*?)\.(.*)/gm);
+                result.push({ format: realFormat, input });
+            }
+            else {
+                result.push({ format });
+            }
+        }
+        const mapFormatInputs = new Map;
+        const formatsWithoutInputs = new Set;
+        for (const { format, input } of result) {
+            if (input) {
+                if (mapFormatInputs.has(format)) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    mapFormatInputs.get(format).add(input);
+                }
+                else {
+                    mapFormatInputs.set(format, new Set([input]));
+                }
+            }
+            else {
+                formatsWithoutInputs.add(format);
+            }
+        }
+        for (const format of formatsWithoutInputs) {
+            if (mapFormatInputs.has(format)) {
+                throw new Error(`${format} is both used with inputs and without in plugins configuration and was not expanded / handled correctly. Please file an issue for pkgbld.`);
+            }
+            mapFormatInputs.set(format, new Set(inputs));
+        }
+        let prevInputs;
+        for (const inputs of mapFormatInputs.values()) {
+            if (prevInputs) {
+                if (!areSetsEqual(inputs, prevInputs)) {
+                    throw new Error(`unbalanced inputs for partition: ${JSON.stringify(partition)}`);
+                }
+            }
+            prevInputs = inputs;
+        }
+        partitions.push({ formats: [...mapFormatInputs.keys()], inputs: [...prevInputs] });
+    }
+    return partitions.map(({ formats, inputs }) => {
+        return {
             input: inputs,
-            output: {
-                format: 'cjs',
-                dir: config.dir,
-                entryFileNames: '[name].cjs',
-                chunkFileNames: '[name].cjs',
-                exports: 'auto',
-                plugins: getOutputPlugins('cjs', config),
-                sourcemap: config.sourcemapTargets.includes('cjs')
-            },
-            plugins: getBuildPlugins('cjs', config)
-        });
-    }
-    const umdConfigs = inputs.filter((input) => umdFilter(config, input)).map(currentInput => ({
-        input: currentInput,
-        output: {
-            format: 'umd',
-            dir: config.dir,
-            entryFileNames: '[name].umd.js',
-            name: helpers.getGlobalName(currentInput),
-            globals: helpers.getExternalGlobalName,
-            plugins: getOutputPlugins('umd', config),
-            sourcemap: config.sourcemapTargets.includes('umd')
-        },
-        plugins: getBuildPlugins('umd', config, inputs, currentInput)
-    }));
-    if (umdConfigs.length) {
-        configs.push(...umdConfigs);
-    }
-    return configs;
+            output: formats.map(format => (Object.assign({ format, dir: config.dir, entryFileNames: fileNamePatterns[format], plugins: getPlugins([format], inputs, true), sourcemap: config.sourcemapFormats.includes(format) }, getExtraOutputSettings(format, inputs)))),
+            plugins: getPlugins(formats, inputs, false)
+        };
+    });
+    function getExtraOutputSettings(format, inputs) {
+        switch (format) {
+            case 'cjs':
+            case 'es':
+                return { chunkFileNames: fileNamePatterns[format] };
+            case 'umd':
+                if (inputs.length <= 0) {
+                    break;
+                }
+                if (inputs.length > 1) {
+                    throw new Error(`Cannot produce global name for mutliple umd inputs in one output: ${inputs}`);
+                }
+                return {
+                    name: helpers.getGlobalName(inputs[0]),
+                    globals: helpers.getExternalGlobalName,
+                };
+        }
+        return {};
+    }
+    function getPlugins(formats, inputs, outputPlugin) {
+        const filteredPlugins = [];
+        for (const plugin of plugins$1) {
+            if ((!!plugin.outputPlugin) === outputPlugin) {
+                if ((!plugin.format || toArray(plugin.format).some(format => formats.includes(format)))
+                    && (!plugin.inputs || plugin.inputs.every(input => inputs.includes(input)))) {
+                    filteredPlugins.push({
+                        instance: plugin.plugin(),
+                        priority: plugin.priority
+                    });
+                }
+            }
+        }
+        filteredPlugins.sort((a, b) => a.priority - b.priority);
+        return filteredPlugins.map(plugin => plugin.instance);
+    }
+    function doExpandInputs(formats) {
+        if (inputs.length === 1) {
+            return formats;
+        }
+        const expanded = [];
+        for (const format of formats) {
+            if (expandInputs.has(format)) {
+                if (format !== 'umd') {
+                    for (const input of inputs) {
+                        expanded.push(`${format}.${input}`);
+                    }
+                }
+                else {
+                    for (const input of config.umdInputs) {
+                        expanded.push(`${format}../${config.sourceDir}/${input}.ts`);
+                    }
+                }
+            }
+            else {
+                expanded.push(format);
+            }
+        }
+        return expanded;
+    }
 }
 
 const mainLoggerText = (sourceDir, dir, configsCount, startingTime, finishedCount = 0) => (final = false) => `${sourceDir} → ${dir} ${final ? configsCount : finishedCount++} / ${configsCount}${final ? (' in ' + getTimeDiff(startingTime)) : ''}`;
@@ -214,6 +401,9 @@ function processPackage(pkg, config) {
     var _a;
     const input = [];
     const logger$1 = logger.createLogger();
+    const allowEsm = (config.formatsOverriden && config.formats.includes('es') || !config.formatsOverriden);
+    const allowCjs = (config.formatsOverriden && config.formats.includes('cjs') || !config.formatsOverriden);
+    const allowUmd = (config.formatsOverriden && config.formats.includes('umd') || !config.formatsOverriden || config.umdInputs);
     if (typeof pkg !== 'object' || Array.isArray(pkg)) {
         logger$1.finish('expecting object on top level of package.json', 3 /* LogLevel.error */);
         process.exit(-1);
@@ -235,25 +425,47 @@ function processPackage(pkg, config) {
         pkg.exports['.'] = {};
     }
     pkg.exports['./package.json'] = './package.json';
-    if (typeof pkg.umd === 'string') {
+    if (allowUmd && typeof pkg.umd === 'string') {
         pkg.umd = `./${config.dir}/index.umd.js`;
-        if (!config.umdTargets.includes('index')) {
-            config.umdTargets.push('index');
+        if (!config.umdInputs.includes('index')) {
+            config.umdInputs.push('index');
+        }
+    }
+    if (config.bin) {
+        if (config.bin.length > 0) {
+            if (config.bin[0] === '') {
+                delete pkg.bin;
+            }
+            else {
+                pkg.bin = config.bin[0];
+            }
+            config.bin = config.bin.filter(Boolean);
+            if (config.bin.length === 0) {
+                delete config.bin;
+            }
         }
     }
-    if (typeof pkg.main !== 'string') {
+    else {
+        if (typeof pkg.bin === 'string') {
+            config.bin = [pkg.bin];
+        }
+        else {
+            delete pkg.bin;
+        }
+    }
+    if (allowCjs && typeof pkg.main !== 'string') {
         pkg.main = `./${config.dir}/index.cjs`;
     }
-    if (pkg.main !== pkg.exports['.'].require) {
+    if (allowCjs && pkg.main !== pkg.exports['.'].require) {
         pkg.exports['.'].require = pkg.main;
     }
-    if (typeof pkg.module !== 'string') {
+    if (allowEsm && typeof pkg.module !== 'string') {
         pkg.module = `./${config.dir}/index.mjs`;
     }
-    if (pkg.module !== ((_a = pkg.exports['.']) === null || _a === void 0 ? void 0 : _a.default)) {
+    if (allowEsm && pkg.module !== ((_a = pkg.exports['.']) === null || _a === void 0 ? void 0 : _a.default)) {
         pkg.exports['.'].default = pkg.module;
     }
-    if (umdFilter(config, 'index')) {
+    if (allowUmd && config.umdInputs.includes('index')) {
         pkg.unpkg = `./${config.dir}/index.umd.js`;
     }
     for (const id in pkg.exports) {
@@ -263,8 +475,12 @@ function processPackage(pkg, config) {
         if (typeof pkg.exports[id] !== 'object') {
             pkg.exports[id] = {};
         }
-        pkg.exports[id].require = `./${config.dir}/${basename}.cjs`;
-        pkg.exports[id].default = `./${config.dir}/${basename}.mjs`;
+        if (allowCjs) {
+            pkg.exports[id].require = `./${config.dir}/${basename}.cjs`;
+        }
+        if (allowEsm) {
+            pkg.exports[id].default = `./${config.dir}/${basename}.mjs`;
+        }
         if (basename !== 'index') {
             if (!pkg.files.includes(basename)) {
                 pkg.files.push(basename);
@@ -272,6 +488,9 @@ function processPackage(pkg, config) {
         }
         input.push(`./${config.sourceDir}/${basename}.ts`);
     }
+    if (allowUmd && config.umdInputs.length > 0 && !config.formats.includes('umd')) {
+        config.formats.push('umd');
+    }
     return input;
 }
 
@@ -290,7 +509,7 @@ async function execute() {
         const options = getCliOptions();
         const inputs = processPackage(pkg, options);
         const helpers = getHelpers(pkg.name);
-        const rollupConfigs = getRollupConfigs(inputs, options, helpers);
+        const rollupConfigs = await getRollupConfigs(inputs, options, helpers);
         const updater = mainLoggerText(options.sourceDir, options.dir, rollupConfigs.length, time);
         mainLogger.start(updater());
         await Promise.all(rollupConfigs.map(config => buildConfig(config, updater)));

package/dist/types.d.ts

@@ -1,7 +1,24 @@
-export interface Replacer {
+import { Plugin, InternalModuleFormat } from 'rollup';
+/**
+ * export interface Replacer {
     name: string;
     used: () => void;
-}
+}*/
 export type Json = null | string | number | boolean | Json[] | {
     [name: string]: Json;
 };
+export declare const enum Priotiry {
+    preprocess = 1000,
+    cleanup = 1000,
+    externals = 2000,
+    resolve = 3000,
+    commonjs = 4000,
+    transpile = 6000,
+    compress = 10000,
+    finalize = 20000
+}
+export type Provider = (factory: () => Plugin, priority: Priotiry, options?: {
+    format?: InternalModuleFormat | InternalModuleFormat[];
+    inputs?: string[];
+    outputPlugin?: true;
+}) => void;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.11.2",
+  "version": "1.13.0",
   "license": "MIT",
   "name": "pkgbld",
   "author": {
@@ -9,7 +9,8 @@
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "engines": {
     "node": ">=16"
@@ -34,32 +35,33 @@
     "semantic-release": "npx semantic-release"
   },
   "devDependencies": {
-    "@semantic-release/changelog": "6.0.1",
+    "@semantic-release/changelog": "6.0.2",
     "@semantic-release/commit-analyzer": "9.0.2",
     "@semantic-release/git": "10.0.1",
-    "@semantic-release/npm": "9.0.1",
+    "@semantic-release/npm": "9.0.2",
     "@semantic-release/release-notes-generator": "10.0.3",
-    "@types/lodash": "4.14.190",
-    "@typescript-eslint/eslint-plugin": "5.44.0",
-    "@typescript-eslint/parser": "5.44.0",
+    "@types/lodash": "4.14.191",
+    "@typescript-eslint/eslint-plugin": "5.48.1",
+    "@typescript-eslint/parser": "5.48.1",
     "conventional-changelog-angular": "5.0.13",
-    "eslint": "8.28.0",
+    "eslint": "8.33.0",
     "semantic-release": "19.0.5",
-    "@rollup-extras/plugin-binify": "1.1.5",
     "@types/node": "18.11.18"
   },
   "dependencies": {
     "@niceties/logger": "1.1.10",
     "@niceties/draftlog-appender": "1.3.0",
     "lodash": "4.17.21",
-    "rollup": "3.9.1",
+    "rollup": "3.12.0",
     "rollup-plugin-typescript2": "0.34.1",
     "rollup-plugin-preprocess": "0.0.4",
-    "@rollup/plugin-commonjs": "24.0.0",
-    "@rollup/plugin-terser": "0.3.0",
+    "@rollup/plugin-commonjs": "24.0.1",
+    "@rollup/plugin-terser": "0.4.0",
     "@rollup/plugin-node-resolve": "15.0.1",
     "@rollup-extras/plugin-clean": "1.3.4",
+    "@rollup-extras/plugin-binify": "1.1.5",
     "@rollup-extras/plugin-externals": "1.1.7",
+    "@slimlib/refine-partition": "1.0.0",
     "typescript": "4.9.4",
     "minimist": "1.2.7",
     "kleur": "4.1.5"