@wfp/icons-core/build/compiled/rollup.js

Themes for un core

'use strict';
const { babel } = require('@rollup/plugin-babel');
const commonjs = require('@rollup/plugin-commonjs');
const { nodeResolve } = require('@rollup/plugin-node-resolve');
const { pascalCase } = require('change-case');
const fs = require('fs-extra');
const path = require('path');
const { rollup } = require('rollup');
async function bundle(entrypoint, options = { name: 'Icon', globals: undefined }) {
    console.log('bundle rollup', entrypoint);
    const customGlobals = options.globals ? formatGlobals(options.globals) : {};
    const globals = options.globals ? formatGlobals(options.globals) : {};
    const { name } = options;
    const packageFolder = await findPackageFolder(entrypoint);
    const outputFolders = [
        {
            format: 'esm',
            directory: path.join(packageFolder, 'es'),
        },
        {
            format: 'cjs',
            directory: path.join(packageFolder, 'lib'),
        },
        {
            format: 'umd',
            directory: path.join(packageFolder, 'umd'),
        },
    ];
    await Promise.all(outputFolders.map(({ directory }) => fs.remove(directory)));
    const jsEntryPoints = outputFolders.map(({ directory, format }) => ({
        file: path.join(directory, 'index.js'),
        format,
    }));
    const packageJsonPath = path.join(packageFolder, 'package.json');
    const packageJson = await fs.readJson(packageJsonPath);
    const { dependencies = {}, peerDependencies = {} } = packageJson;
    const externalModules = [
        ...Object.keys(dependencies),
        ...Object.keys(peerDependencies),
        'react/jsx-runtime',
        'react/jsx-dev-runtime',
    ];
    // Ensure 'react' and 'react-dom' are in uniqueExternalModules if they are peers
    if (peerDependencies.react)
        externalModules.push('react');
    if (peerDependencies['react-dom'])
        externalModules.push('react-dom');
    const uniqueExternalModules = [...new Set(externalModules)];
    const bundle = await rollup({
        input: entrypoint,
        external: uniqueExternalModules,
        plugins: [
            babel({
                exclude: 'node_modules/**',
                babelrc: false,
                presets: [
                    [
                        '@babel/preset-env',
                        {
                            modules: false,
                            targets: {
                                browsers: ['last 1 version', 'ie >= 11', 'Firefox ESR'],
                            },
                        },
                    ],
                    [
                        '@babel/preset-react',
                        {
                            runtime: 'automatic',
                        },
                    ],
                ],
                babelHelpers: 'bundled',
            }),
            nodeResolve(),
            commonjs({
                include: [/node_modules/],
                extensions: ['.js', '.jsx'],
            }),
        ],
    });
    await Promise.all(jsEntryPoints.map(({ format, file }) => {
        const outputOptions = {
            format,
            file,
            exports: 'auto',
            name: 'not used',
            globals: undefined,
        };
        if (format === 'umd') {
            outputOptions.name = name;
            outputOptions.globals = {
                ...formatDependenciesIntoGlobals(dependencies),
                ...formatDependenciesIntoGlobals(peerDependencies),
                ...customGlobals,
            };
        }
        return bundle.write(outputOptions);
    }));
}
function formatGlobals(string) {
    const mappings = string.split(',').map((mapping) => {
        return mapping.split('=');
    });
    return mappings.reduce((acc, [pkg, global]) => ({
        ...acc,
        [pkg]: global,
    }), {});
}
function formatDependenciesIntoGlobals(dependencies) {
    return Object.keys(dependencies).reduce((acc, key) => {
        const parts = key.split('/').map((identifier, i) => {
            if (i === 0) {
                return identifier.replace(/@/, '');
            }
            return identifier;
        });
        return {
            ...acc,
            [key]: pascalCase(parts.join(' ')),
        };
    }, {});
}
async function findPackageFolder(entrypoint) {
    let packageFolder = entrypoint;
    while (packageFolder !== '/' && path.dirname(packageFolder) !== '/') {
        packageFolder = path.dirname(packageFolder);
        const packageJsonPath = path.join(packageFolder, 'package.json');
        if (await fs.pathExists(packageJsonPath)) {
            break;
        }
    }
    return packageFolder;
}
export default bundle;
//# sourceMappingURL=rollup.js.map