Rollup TypeScript: dichiarazioni in dist + cjs + es

Sto cercando di confezionare una libreria TypeScript usando rollup con file di dichiarazione (d.ts), e voglio generare sia versioni cjs che es.

Quindi ho ideato questa configurazione di rollup:

const {nodeResolve} = require('@rollup/plugin-node-resolve')
const nodeExternals = require('rollup-plugin-node-externals');
const json = require('@rollup/plugin-json');
const commonjs = require('@rollup/plugin-commonjs');
const typescript = require('rollup-plugin-typescript2');
const packagePlugin = require('@mpen/rollup-plugin-package');
const cleanPlugin = require('@mpen/rollup-plugin-clean');
const findUp = require('find-up');
const {readFileSync} = require('fs');

module.exports = function rollupPresetTslib(opts = {}) {
    const tsconfigFile = findUp.sync(opts.tsconfig ?? 'tsconfig.json')
    const tsconfig = JSON.parse(readFileSync(tsconfigFile))

    return {
        input: tsconfig.files,
        plugins: [
            commonjs({
                include: 'node_modules/**',
            }),
            nodeExternals({
                builtins: true,
                deps: true,
                devDeps: false,
                peerDeps: true,
                optDeps: false,
            }),
            json(),
            typescript({
                abortOnError: process.env.NODE_ENV === 'production',
                tsconfig: tsconfigFile,
                ...opts.typescriptOptions,
            }),
            nodeResolve({
                extensions: ['.ts', '.json']
            }),
            packagePlugin(),
            cleanPlugin(),
            ...opts.plugins ?? [],
        ],
        watch: {
            buildDelay: 200,
            ...opts.watch,
        },
        preserveSymlinks: true,  // https://www.npmjs.com/package/@rollup/plugin-commonjs#usage-with-symlinks
        preserveModules: false,  // outputs multiple files
        output: {
            dir: 'dist',
            format: 'cjs',
            sourcemap: true,
            inlineDynamicImports: false,
        },
    }
}

Questo produce un output abbastanza buono ma compila solo in cjs:

Quindi ho provato a esportare in entrambi i formati cambiando output in questo modo:

        output: ['cjs', 'es'].map(format => ({
            dir: `dist/${format}`,
            format: format,
            sourcemap: true,
            inlineDynamicImports: false,
        })),

Ma ora ricevo due copie dei file .d.ts che non voglio:

Quindi come faccio a ottenere una copia dei file d.ts più una build cjs ed es?

Risposta n. 1

Ho configurato rollup per generare un singolo file in dist/index.d.ts, aggiungendo il contenuto del mio declarations.d.ts ad esso usando uno script postbuild:

cat declarations.d.ts >> dist/index.d.ts

Questo è il contenuto del mio rollup.config.js:

import commonjs from '@rollup/plugin-commonjs';
import clear from 'rollup-plugin-clear';
import ts from 'rollup-plugin-ts';
import styles from 'rollup-plugin-styles';
import image from '@rollup/plugin-image';
import { builtinModules } from 'module';
import pkg from './package.json';

module.exports = {
  input: pkg.source,
  output: [
    { file: pkg.main, format: 'cjs', sourcemap: true },
    { file: pkg.module, format: 'esm', sourcemap: true }
  ],
  external: [
    ...builtinModules,
    ...(pkg.dependencies ? Object.keys(pkg.dependencies) : []),
    ...(pkg.devDependencies ? Object.keys(pkg.devDependencies) : []),
    ...(pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : [])
  ],
  watch: {
    include: 'lib/**'
  },
  plugins: [
    clear({
      targets: ['dist'],
      watch: false
    }),
    ts({
      hook: {
        // Always rename declaration files to index.d.ts to avoid emitting two declaration files with identical contents
        outputPath: (path, kind) =>
          kind === 'declaration' ? './dist/index.d.ts' : path
      }
    }),
    image(),
    styles({
      modules: true,
      autoModules: /\.module\.\S+$/
    }),
    commonjs()
  ]
};

Spero che questo aiuti chiunque stia cercando una soluzione.