pkgbld 1.14.5 → 1.15.0

package/dist/index.js

@@ -10,529 +10,681 @@ var minimist = require('minimist');
 var refiner = require('@slimlib/refine-partition');
 var camelCase = require('lodash/camelCase');
 var kleur = require('kleur');
+var lodash = require('lodash');
+var fs$1 = require('fs');
 
-async function createSubpackages(inputs, config) {
-    for (const input of inputs) {
-        const basename = path.basename(input, '.ts');
-        if (basename !== 'index') {
-            const pkg = {
-                type: 'module',
-                types: `../${config.dir}/${basename}.d.ts`,
-                main: `../${config.dir}/${basename}.mjs`
-            };
-            await fs.mkdir(basename, { recursive: true });
-            await fs.writeFile(`${basename}/package.json`, JSON.stringify(pkg, null, 2));
-        }
-    }
+async function createSubpackages(inputs, config) {
+    for (const input of inputs) {
+        const basename = path.basename(input, '.ts');
+        if (basename !== 'index') {
+            const pkg = {
+                type: 'module',
+                types: `../${config.dir}/${basename}.d.ts`,
+                main: `../${config.dir}/${basename}.mjs`
+            };
+            await fs.mkdir(basename, { recursive: true });
+            await fs.writeFile(`${basename}/package.json`, JSON.stringify(pkg, null, 2));
+        }
+    }
 }
 
-const defaults = {
-    formats: ['es', 'cjs'],
-    umdInputs: [],
-    compressFormats: ['umd'],
-    sourcemapFormats: ['umd'],
-    preprocess: [],
-    dir: 'dist',
-    sourceDir: 'src',
-    includeExternals: false
-};
-function getCliOptions() {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
-    const parsedArgs = minimist(process.argv.slice(2));
-    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());
-    const includeExternals = (_p = parsedArgs['include-externals']) !== null && _p !== void 0 ? _p : defaults.includeExternals;
-    return {
-        umdInputs,
-        compressFormats,
-        sourcemapFormats,
-        formats,
-        formatsOverriden: 'formats' in parsedArgs,
-        preprocess,
-        dir,
-        sourceDir,
-        bin,
-        includeExternals
-    };
+const defaults = {
+    formats: ['es', 'cjs'],
+    umdInputs: [],
+    compressFormats: ['umd'],
+    sourcemapFormats: ['umd'],
+    preprocess: [],
+    dir: 'dist',
+    sourceDir: 'src',
+    includeExternals: false,
+    eject: false,
+    noTsConfig: false,
+    noUpdatePackageJson: false
+};
+function getCliOptions() {
+    const parsedArgs = minimist(process.argv.slice(2));
+    const umdInputs = parsedArgs.umd?.split(',').map((arg) => arg.trim()) ?? defaults.umdInputs;
+    const compressFormats = parsedArgs.compress?.split(',').map((arg) => arg.trim()) ?? defaults.compressFormats;
+    const sourcemapFormats = parsedArgs.sourcemaps?.split(',').map((arg) => arg.trim()) ?? defaults.sourcemapFormats;
+    const formats = parsedArgs.formats?.split(',').map((arg) => arg.trim()) ?? defaults.formats;
+    const preprocess = parsedArgs.preprocess?.split(',').map((arg) => arg.trim()) ?? defaults.preprocess;
+    const dir = parsedArgs.dir ?? defaults.dir;
+    const sourceDir = parsedArgs.sourceDir ?? defaults.sourceDir;
+    const bin = parsedArgs.bin?.split(',').map((arg) => arg.trim());
+    const includeExternals = parsedArgs['include-externals'] ?? defaults.includeExternals;
+    const eject = !!parsedArgs.eject ?? defaults.eject;
+    const noTsConfig = !!parsedArgs.noTsConfig ?? defaults.noTsConfig;
+    const noUpdatePackageJson = !!parsedArgs.noUpdatePackageJson ?? defaults.noUpdatePackageJson;
+    return {
+        umdInputs,
+        compressFormats,
+        sourcemapFormats,
+        formats,
+        formatsOverriden: 'formats' in parsedArgs,
+        preprocess,
+        dir,
+        sourceDir,
+        bin,
+        includeExternals,
+        eject,
+        noTsConfig,
+        noUpdatePackageJson
+    };
 }
 
-async function getPackage() {
-    const pkgPath = path.resolve('package.json');
-    const buffer = await fs.readFile(pkgPath);
-    return [pkgPath, JSON.parse(buffer.toString())];
+async function getPackage() {
+    const pkgPath = path.resolve('package.json');
+    const buffer = await fs.readFile(pkgPath);
+    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 clean (provider) {
+    const pluginClean = await provider.import('@rollup-extras/plugin-clean');
+    const pluginInstance = pluginClean();
+    provider.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 commonjs (provider) {
+    const pluginCommonjs = await provider.import('@rollup/plugin-commonjs');
+    provider.provide(() => pluginCommonjs(), 4000 /* Priotiry.commonjs */);
 }
 
-async function externals (provide, config, inputs) {
-    if (config.includeExternals) {
-        return;
-    }
-    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 externals (provider, config, inputs) {
+    if (config.includeExternals) {
+        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 /* Priotiry.externals */, { format });
+    }
+    if (!allowGenericUmd && config.umdInputs.length > 0) {
+        for (const currentInput of config.umdInputs) {
+            provider.provide(() => pluginExternals({
+                external: (id, external) => external || isExternalInput(currentInput, inputs, id, config)
+            }), 2000 /* Priotiry.externals */, { format: 'umd', inputs: [`./${config.sourceDir}/${currentInput}.ts`] });
+        }
+        // for eject config
+        provider.globalImport('path', 'path');
+        provider.globalSetupt(isExternalInput);
+    }
+}
+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 preprocess (provider, config) {
+    if (config.preprocess.length > 0) {
+        const pluginPreprocess = await provider.import('rollup-plugin-preprocess');
+        const include = config.preprocess.map(name => `${config.sourceDir}/${name}.ts`);
+        for (const format of config.formats) {
+            if (format !== 'umd') {
+                provider.provide(() => pluginPreprocess({ include, context: { [format]: true } }), 1000 /* Priotiry.preprocess */, { format });
+            }
+            else {
+                for (const currentInput of config.umdInputs) {
+                    provider.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 resolve (provider) {
+    const pluginResolve = await provider.import('@rollup/plugin-node-resolve');
+    provider.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 terser (provider, config) {
+    const filteredFormats = config.compressFormats.filter(format => config.formats.includes(format));
+    if (filteredFormats.length > 0) {
+        const pluginTerser = await provider.import('@rollup/plugin-terser');
+        const options = {
+            mangle: {
+                properties: {
+                    regex: /_$/
+                }
+            }
+        };
+        if (filteredFormats.length > 0) {
+            for (const format of filteredFormats) {
+                if (format !== 'umd') {
+                    provider.provide(() => pluginTerser(options), 10000 /* Priotiry.compress */, { format, outputPlugin: true });
+                }
+                else {
+                    for (const currentInput of config.umdInputs) {
+                        provider.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 typescript (provider) {
+    const pluginTypescript = await provider.import('rollup-plugin-typescript2');
+    provider.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 });
-    }
+async function binify (provider, config) {
+    if (config.bin != null) {
+        const pluginBinify = await provider.import('@rollup-extras/plugin-binify');
+        const format = {
+            'cjs': 'cjs',
+            'mjs': 'es'
+        }[path.extname(config.bin[0])] ?? 'cjs';
+        provider.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];
+const plugins = [
+    clean,
+    commonjs,
+    externals,
+    preprocess,
+    resolve,
+    terser,
+    typescript,
+    binify
+];
+const noop = () => undefined;
+function createProvider() {
+    const plugins = [];
+    return [{
+            provide: (plugin, priority, options) => {
+                plugins.push({ priority, plugin, format: options?.format, inputs: options?.inputs, outputPlugin: options?.outputPlugin });
+            },
+            import: async (name, exportName) => {
+                const result = await import(name);
+                return result[exportName ?? 'default'];
+            },
+            globalImport: noop,
+            globalSetupt: noop
+        }, plugins];
 }
 
-function getHelpers(name) {
-    function getGlobalName(anInput) {
-        return camelCase(path.join(name, path.basename(anInput, '.ts') !== 'index' ? path.basename(anInput, '.ts') : ''));
-    }
-    function getExternalGlobalName(id) {
-        if (path.isAbsolute(id)) {
-            return getGlobalName(path.relative(__dirname, id));
-        }
-        return camelCase(id);
-    }
-    return {
-        getGlobalName,
-        getExternalGlobalName
-    };
-}
-function toArray(object) {
-    if (Array.isArray(object)) {
-        return object;
-    }
-    if (object == null) {
-        return [];
-    }
-    return [object];
-}
-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
-    if (output == null) {
-        return '';
-    }
-    return (Array.isArray(output) ? output : [output !== null && output !== void 0 ? output : '']).map(item => kleur.cyan(item[field])).join(', ');
-}
-function getTimeDiff(starting) {
-    const now = Date.now();
-    if (now - starting > 1000) {
-        return `${((now - starting) / 1000).toFixed(1)}s`;
-    }
-    return `${now - starting}ms`;
-}
+function getHelpers(pkgName) {
+    function getGlobalName(anInput) {
+        return camelCase(path.join(pkgName, path.basename(anInput, '.ts') !== 'index' ? path.basename(anInput, '.ts') : ''));
+    }
+    function getExternalGlobalName(id) {
+        if (path.isAbsolute(id)) {
+            return getGlobalName(path.relative(__dirname, id));
+        }
+        return camelCase(id);
+    }
+    return {
+        getGlobalName,
+        getExternalGlobalName
+    };
+}
+function toArray(object) {
+    if (Array.isArray(object)) {
+        return object;
+    }
+    if (object == null) {
+        return [];
+    }
+    return [object];
+}
+function formatInput(input) {
+    return (Array.isArray(input) ? input : [input ?? '']).map(item => kleur.magenta(path.basename(item, '.ts'))).join(', ');
+}
+function formatOutput(output, field) {
+    //? can we avoid it
+    if (output == null) {
+        return '';
+    }
+    return (Array.isArray(output) ? output : [output ?? '']).map(item => kleur.cyan(item[field])).join(', ');
+}
+function getTimeDiff(starting) {
+    const now = Date.now();
+    if (now - starting > 1000) {
+        return `${((now - starting) / 1000).toFixed(1)}s`;
+    }
+    return `${now - starting}ms`;
+}
 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);
-                }
-            }
-        }
-    }
-    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: 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 fileNamePatterns = {
+    'es': '[name].mjs',
+    'cjs': '[name].cjs',
+    'umd': '[name].umd.js',
+};
+async function getRollupConfigs([provider, plugins$1], inputs, config, helpers) {
+    for (const factory of plugins) {
+        await factory(provider, config, inputs);
+    }
+    const expandInputs = new Set;
+    for (const plugin of plugins$1) {
+        if (plugin.format && plugin.inputs?.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);
+                }
+            }
+        }
+    }
+    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: formats.map(format => ({
+                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)) : ''}`;
 
-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);
-    }
-    if (typeof (pkg === null || pkg === void 0 ? void 0 : pkg.name) !== 'string') {
-        logger$1.finish('expecting name to be a string in package.json', 3 /* LogLevel.error */);
-        process.exit(-1);
-    }
-    if (!Array.isArray(pkg === null || pkg === void 0 ? void 0 : pkg.files)) {
-        pkg.files = [];
-    }
-    if (!pkg.files.includes(config.dir)) {
-        pkg.files.push(config.dir);
-    }
-    if (typeof pkg.exports !== 'object' && pkg.exports !== null) {
-        pkg.exports = {};
-    }
-    if (pkg.exports['.'] == null) {
-        pkg.exports['.'] = {};
-    }
-    pkg.exports['./package.json'] = './package.json';
-    if (allowUmd && typeof pkg.umd === 'string') {
-        pkg.umd = `./${config.dir}/index.umd.js`;
-        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;
-            }
-        }
-    }
-    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 (allowCjs && pkg.main !== pkg.exports['.'].require) {
-        pkg.exports['.'].require = pkg.main;
-    }
-    if (allowEsm && typeof pkg.module !== 'string') {
-        pkg.module = `./${config.dir}/index.mjs`;
-    }
-    if (allowEsm && pkg.module !== ((_a = pkg.exports['.']) === null || _a === void 0 ? void 0 : _a.default)) {
-        pkg.exports['.'].default = pkg.module;
-    }
-    if (allowUmd && config.umdInputs.includes('index')) {
-        pkg.unpkg = `./${config.dir}/index.umd.js`;
-    }
-    for (const id in pkg.exports) {
-        if (id === './package.json')
-            continue;
-        const basename = id == '.' ? 'index' : path.basename(id);
-        if (typeof pkg.exports[id] !== 'object') {
-            pkg.exports[id] = {};
-        }
-        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);
-            }
-        }
-        input.push(`./${config.sourceDir}/${basename}.ts`);
-    }
-    if (allowUmd && config.umdInputs.length > 0 && !config.formats.includes('umd')) {
-        config.formats.push('umd');
-    }
-    return input;
+function processPackage(pkg, config) {
+    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);
+    }
+    if (typeof pkg?.name !== 'string') {
+        logger$1.finish('expecting name to be a string in package.json', 3 /* LogLevel.error */);
+        process.exit(-1);
+    }
+    if (!Array.isArray(pkg?.files)) {
+        pkg.files = [];
+    }
+    if (!pkg.files.includes(config.dir)) {
+        pkg.files.push(config.dir);
+    }
+    if (typeof pkg.exports !== 'object' && pkg.exports !== null) {
+        pkg.exports = {};
+    }
+    if (pkg.exports['.'] == null) {
+        pkg.exports['.'] = {};
+    }
+    pkg.exports['./package.json'] = './package.json';
+    if (allowUmd && typeof pkg.umd === 'string') {
+        pkg.umd = `./${config.dir}/index.umd.js`;
+        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;
+            }
+        }
+    }
+    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 (allowCjs && pkg.main !== pkg.exports['.'].require) {
+        pkg.exports['.'].require = pkg.main;
+    }
+    if (allowEsm && typeof pkg.module !== 'string') {
+        pkg.module = `./${config.dir}/index.mjs`;
+    }
+    if (allowEsm && pkg.module !== pkg.exports['.']?.default) {
+        pkg.exports['.'].default = pkg.module;
+    }
+    if (allowUmd && config.umdInputs.includes('index')) {
+        pkg.unpkg = `./${config.dir}/index.umd.js`;
+    }
+    for (const id in pkg.exports) {
+        if (id === './package.json')
+            continue;
+        const basename = id == '.' ? 'index' : path.basename(id);
+        if (typeof pkg.exports[id] !== 'object') {
+            pkg.exports[id] = {};
+        }
+        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);
+            }
+        }
+        input.push(`./${config.sourceDir}/${basename}.ts`);
+    }
+    if (allowUmd && config.umdInputs.length > 0 && !config.formats.includes('umd')) {
+        config.formats.push('umd');
+    }
+    return input;
 }
 
-async function writePackage(pkgPath, pkg) {
-    await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+async function writeJson(path, json) {
+    await fs.writeFile(path, JSON.stringify(json, null, 2) + '\n');
 }
 
-async function execute() {
-    const time = Date.now();
-    const blank = logger.createLogger();
-    blank.update(' ');
-    const mainLogger = logger.createLogger();
-    mainLogger.update('preparing...');
-    try {
-        const [pkgPath, pkg] = await getPackage();
-        const options = getCliOptions();
-        const inputs = processPackage(pkg, options);
-        const helpers = getHelpers(pkg.name);
-        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)));
-        await writePackage(pkgPath, pkg);
-        await createSubpackages(inputs, options);
-        mainLogger.finish(updater(true));
-    }
-    catch (e) {
-        mainLogger.finish(`${e}}`, 3 /* LogLevel.error */);
-        process.exit(-1);
-    }
-    async function buildConfig(config, updater) {
-        const bundle = await rollup.rollup(config);
-        await Promise.all(toArray(config.output).map(config => bundle.write(config)));
-        await bundle.close();
-        mainLogger(`${kleur.green('✓')} ${formatInput(config.input)} [${formatOutput(config.output, 'format')}]`);
-        mainLogger.update(updater());
-    }
-}
+const imports = new Map;
+const setup = new Set;
+let generate, generateGlobals;
+async function createEjectProvider() {
+    const createMockProvider = (await import('@slimlib/smart-mock')).default;
+    const provider = createMockProvider();
+    const createMock = provider.createMock;
+    generate = provider.generate;
+    generateGlobals = provider.generateGlobals;
+    const plugins = [];
+    return [{
+            provide: (plugin, priority, options) => {
+                plugins.push({ priority, plugin, format: options?.format, inputs: options?.inputs, outputPlugin: options?.outputPlugin });
+            },
+            import: async (name, exportName) => {
+                const result = await import(name);
+                const exports = result[exportName ?? 'default'];
+                const mangledName = lodash.camelCase(name);
+                imports.set(name, mangledName);
+                return createMock(exports, mangledName);
+            },
+            globalImport: (module, exportName) => {
+                imports.set(module, exportName ?? 'default');
+            },
+            // eslint-disable-next-line @typescript-eslint/ban-types
+            globalSetupt: (code) => {
+                if (typeof code === 'function') {
+                    setup.add(code.toString());
+                }
+                setup.add(String(code));
+            }
+        }, plugins];
+}
+async function ejectConfig(config, pkgPath, options, inputs, helpers, pkg) {
+    const pkgName = pkg.name;
+    // generate from config
+    const text = generate(config);
+    setup.add(generateGlobals());
+    // generate globals for config functions
+    setup.add(`const config = ${generate(options)}`);
+    setup.add(`const inputs = ${generate(inputs)}`);
+    // generate helpers code
+    if (options.formats.includes('umd')) {
+        imports.set('path', 'path');
+        imports.set('lodash/camelCase', 'camelCase');
+        setup.add(`const pkgName = ${generate(pkgName)}`);
+        setup.add(helpers.getGlobalName.toString());
+    }
+    // imports
+    const importsString = Array.from(imports)
+        .map((value) => `import ${value[1]} from '${value[0]}';`)
+        .join('\n');
+    const setupString = Array.from(setup)
+        .join('\n');
+    const { minify } = await import('terser');
+    const result = await minify(`${importsString}\n${setupString}\nexport default ${text};`, {
+        module: true,
+        compress: {
+            booleans: false,
+            ecma: 2020,
+            module: true,
+            passes: 3,
+            unsafe: true
+        },
+        mangle: false,
+        output: {
+            beautify: true,
+            ecma: 2020,
+            quote_style: 1
+        }
+    });
+    await fs.writeFile(path.join(path.dirname(pkgPath), 'rollup.config.mjs'), result.code);
+    // this can be improved a lot
+    if (typeof pkg.devDependencies !== 'object') {
+        pkg.devDependencies = {};
+    }
+    const devDependencies = pkg.devDependencies;
+    if ('pkgbld' in devDependencies) {
+        delete devDependencies.pkgbld;
+    }
+    devDependencies['rollup'] = '*';
+    const isBuiltin = (await import('is-builtin-module')).default;
+    for (const key of imports.keys()) {
+        if (!isBuiltin(key)) {
+            devDependencies[key] = '*';
+        }
+    }
+}
+
+const defaultTsConfig = {
+    include: ['src', 'types'],
+    compilerOptions: {
+        lib: ['dom', 'esnext'],
+        target: 'esnext',
+        module: 'esnext',
+        esModuleInterop: true,
+        strict: true,
+        declaration: true,
+        moduleResolution: 'node'
+    }
+};
+async function checkTsConfig(options, mainLogger) {
+    if (options.noTsConfig) {
+        return;
+    }
+    const tsConfigPath = path.resolve('tsconfig.json');
+    if (fs$1.existsSync(tsConfigPath)) {
+        return;
+    }
+    mainLogger('no tsconfig.json and --no-ts-config not specified, writing tsconfig...');
+    await writeJson(tsConfigPath, defaultTsConfig);
+    mainLogger('done');
+}
+
+async function execute() {
+    const time = Date.now();
+    logger.createLogger().update(' '); // blank line
+    const mainLogger = logger.createLogger();
+    mainLogger.update('preparing...');
+    try {
+        const [pkgPath, pkg] = await getPackage();
+        const options = getCliOptions();
+        checkTsConfig(options, mainLogger);
+        const inputs = processPackage(pkg, options);
+        const helpers = getHelpers(pkg.name);
+        const provider = options.eject ? await createEjectProvider() : createProvider();
+        const rollupConfigs = await getRollupConfigs(provider, inputs, options, helpers);
+        if (options.eject) {
+            await ejectConfig(rollupConfigs, pkgPath, options, inputs, helpers, pkg);
+            mainLogger.finish(`ejected config in ${getTimeDiff(time)}`);
+            if (!options.noUpdatePackageJson) {
+                await writeJson(pkgPath, pkg);
+            }
+        }
+        else {
+            const updater = mainLoggerText(options.sourceDir, options.dir, rollupConfigs.length, time);
+            mainLogger.start(updater());
+            await Promise.all(rollupConfigs.map(config => buildConfig(config, updater)));
+            if (!options.noUpdatePackageJson) {
+                await writeJson(pkgPath, pkg);
+            }
+            await createSubpackages(inputs, options);
+            mainLogger.finish(updater(true));
+        }
+    }
+    catch (e) {
+        console.log(e);
+        mainLogger.finish(`${e}}`, 3 /* LogLevel.error */);
+        process.exit(-1);
+    }
+    async function buildConfig(config, updater) {
+        const bundle = await rollup.rollup(config);
+        await Promise.all(toArray(config.output).map(config => bundle.write(config)));
+        await bundle.close();
+        mainLogger(`${kleur.green('✓')} ${formatInput(config.input)} [${formatOutput(config.output, 'format')}]`);
+        mainLogger.update(updater());
+    }
+}
 execute();