rollup.config.js

const resolve = require('@rollup/plugin-node-resolve');
const commonjs = require('@rollup/plugin-commonjs');
const typescript = require('@rollup/plugin-typescript');
const fs = require('fs');
const glob = require('glob');
const path = require('path');

/**
 * Guarantees that any files imported from a peer dependency are treated as an external.
 *
 * For example, if we import `chart.js/auto`, that would not normally
 * match the "chart.js" we pass to the "externals" config. This plugin
 * catches that case and adds it as an external.
 *
 * Inspired by https://github.com/oat-sa/rollup-plugin-wildcard-external
 */
const wildcardExternalsPlugin = (peerDependencies) => ({
    name: 'wildcard-externals',
    resolveId(source, importer) {
        if (importer) {
            let matchesExternal = false;
            peerDependencies.forEach((peerDependency) => {
                if (source.includes(`/${peerDependency}/`)) {
                    matchesExternal = true;
                }
            });

            if (matchesExternal) {
                return {
                    id: source,
                    external: true,
                    moduleSideEffects: true
                };
            }
        }

        return null; // other ids should be handled as usually
    }
});

/**
 * Moves the generated TypeScript declaration files to the correct location.
 *
 * This could probably be configured in the TypeScript plugin.
 */
const moveTypescriptDeclarationsPlugin = (packagePath) => ({
    name: 'move-ts-declarations',
    writeBundle: async () => {
        const files = glob.sync(path.join(packagePath, 'dist', '*', 'assets', 'src', '**/*.d.ts'));
        files.forEach((file) => {
            // a bit odd, but remove first 7 directories, which will leave
            // only the relative path to the file
            const relativePath = file.split('/').slice(7).join('/');

            const targetFile = path.join(packagePath, 'dist', relativePath);
            if (!fs.existsSync(path.dirname(targetFile))) {
                fs.mkdirSync(path.dirname(targetFile), { recursive: true });
            }
            fs.renameSync(file, targetFile);
        });
    }
});

const file = process.env.INPUT_FILE;
const packageRoot = path.join(file, '..', '..');
const packagePath = path.join(packageRoot, 'package.json');
const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
const peerDependencies = [
    '@hotwired/stimulus',
    ...(packageData.peerDependencies ? Object.keys(packageData.peerDependencies) : [])
];

// custom handling for StimulusBundle
if (file.includes('StimulusBundle/assets/src/loader.ts')) {
    peerDependencies.push('./controllers.js');
}
// React, Vue
if (file.includes('assets/src/loader.ts')) {
    peerDependencies.push('./components.js');
}

module.exports = {
    input: file,
    output: {
        file: path.join(packageRoot, 'dist', path.basename(file, '.ts') + '.js'),
        format: 'esm',
    },
    external: peerDependencies,
    plugins: [
        resolve(),
        typescript({
            filterRoot: packageRoot,
            include: ['src/**/*.ts'],
            compilerOptions: {
                outDir: 'dist',
                declaration: true,
                emitDeclarationOnly: true,
            }
        }),
        commonjs(),
        wildcardExternalsPlugin(peerDependencies),
        moveTypescriptDeclarationsPlugin(packageRoot),
    ],
};