rollup.config.js

// @ts-check
import path from 'path'
import ts from 'rollup-plugin-typescript2'
// import replace from '@rollup/plugin-replace'
import resolve from '@rollup/plugin-node-resolve'
import commonjs from '@rollup/plugin-commonjs'

const pkg = require('./package.json')
// const name = pkg.name

function getAuthors(pkg) {
  const { contributors, author } = pkg

  const authors = new Set()
  if (contributors && contributors)
    contributors.forEach((contributor) => {
      authors.add(contributor.name)
    })
  if (author) authors.add(author.name)

  return Array.from(authors).join(', ')
}

const banner = `/*!
  * ${pkg.name} v${pkg.version}
  * (c) ${new Date().getFullYear()} ${getAuthors(pkg)}
  * @license MIT
  */`

// ensure TS checks only once for each build
let hasTSChecked = false

const outputConfigs = {
  // each file name has the format: `dist/${name}.${format}.js`
  // format being a key of this object
  mjs: {
    file: pkg.module,
    format: `es`,
  },
  cjs: {
    file: pkg.module.replace('mjs', 'cjs'),
    format: `cjs`,
  },
  global: {
    file: pkg.unpkg,
    format: `iife`,
  },
  browser: {
    file: 'dist/index.esm-browser.js',
    format: `es`,
  },
}

const fetchConfigs = {
  mjs: {
    file: 'dist/fetch.mjs',
    format: `es`,
  },
  global: {
    file: 'dist/fetch.iife.js',
    format: `iife`,
  },
  browser: {
    file: 'dist/fetch.esm-browser.js',
    format: `es`,
  },
}

const xhrConfigs = {
  mjs: {
    file: 'dist/xhr.mjs',
    format: `es`,
  },
  global: {
    file: 'dist/xhr.iife.js',
    format: `iife`,
  },
  browser: {
    file: 'dist/xhr.esm-browser.js',
    format: `es`,
  },
}

const httpConfigs = {
  mjs: {
    file: 'dist/http.mjs',
    format: `es`,
  },
  cjs: {
    file: 'dist/http.cjs',
    format: `cjs`,
  },
}

const packageBuilds = Object.keys(outputConfigs)
const packageConfigs = packageBuilds.map((format) =>
  createConfig('src/index.ts', format, outputConfigs[format])
)

const fetchBuilds = Object.keys(fetchConfigs)
packageConfigs.push(...fetchBuilds.map((format) =>
  createConfig('implements/fetch/index.ts', format, fetchConfigs[format])
))

const xhrBuilds = Object.keys(xhrConfigs)
packageConfigs.push(...xhrBuilds.map((format) =>
  createConfig('implements/xhr/index.ts', format, xhrConfigs[format])
))

const httpBuilds = Object.keys(httpConfigs)
packageConfigs.push(...httpBuilds.map((format) =>
  createConfig('implements/http/index.ts', format, httpConfigs[format])
))

// only add the production ready if we are bundling the options
// packageBuilds.forEach((buildName) => {
//   if (buildName === 'cjs') {
//     packageConfigs.push(createProductionConfig(buildName))
//   } else if (buildName === 'global') {
//     packageConfigs.push(createMinifiedConfig(buildName))
//   }
// })

export default packageConfigs

function createConfig(entry, buildName, output, plugins = []) {
  if (!output) {
    console.log(require('chalk').yellow(`invalid format: "${buildName}"`))
    process.exit(1)
  }

  output.sourcemap = !!process.env.SOURCE_MAP
  output.banner = banner
  output.externalLiveBindings = false
  output.globals = {
    // 'vue-demi': 'VueDemi',
    // vue: 'Vue',
    // '@vue/composition-api': 'vueCompositionApi',
  }

  // const isProductionBuild = /\.prod\.[cm]?js$/.test(output.file)
  const isGlobalBuild = buildName === 'global'
  // const isRawESMBuild = buildName === 'browser'
  // const isNodeBuild = buildName === 'cjs'
  // const isBundlerESMBuild = buildName === 'browser' || buildName === 'mjs'

  if (isGlobalBuild) output.name = 'TypedRequest'

  const shouldEmitDeclarations = !hasTSChecked

  const tsPlugin = ts({
    check: !hasTSChecked,
    tsconfig: path.resolve(__dirname, './tsconfig.json'),
    cacheRoot: path.resolve(__dirname, './node_modules/.rts2_cache'),
    tsconfigOverride: {
      compilerOptions: {
        sourceMap: output.sourcemap,
        declaration: shouldEmitDeclarations,
        declarationMap: shouldEmitDeclarations,
      },
      exclude: ['packages/*/__tests__', 'packages/*/test-dts'],
    },
  })
  // we only need to check TS and generate declarations once for each build.
  // it also seems to run into weird issues when checking multiple times
  // during a single build.
  hasTSChecked = true

  // const external = ['vue-demi', 'vue', '@vue/composition-api']
  const external = []
  if (!isGlobalBuild) {
    external.push('@vue/devtools-api')
  }

  const nodePlugins = [resolve(), commonjs()]

  return {
    input: entry,
    // Global and Browser ESM builds inlines everything so that they can be
    // used alone.
    external,
    plugins: [
      tsPlugin,
      // createReplacePlugin(
      //   isProductionBuild,
      //   isBundlerESMBuild,
      //   // isBrowserBuild?
      //   isGlobalBuild || isRawESMBuild || isBundlerESMBuild,
      //   isGlobalBuild,
      //   isNodeBuild
      // ),
      ...nodePlugins,
      ...plugins,
    ],
    output,
    // onwarn: (msg, warn) => {
    //   if (!/Circular/.test(msg)) {
    //     warn(msg)
    //   }
    // },
  }
}

// function createReplacePlugin(
//   isProduction,
//   isBundlerESMBuild,
//   isBrowserBuild,
//   isGlobalBuild,
//   isNodeBuild
// ) {
//   const replacements = {
//     __COMMIT__: `"${process.env.COMMIT}"`,
//     __VERSION__: `"${pkg.version}"`,
//     __DEV__:
//       isBundlerESMBuild || (isNodeBuild && !isProduction)
//         ? // preserve to be handled by bundlers
//           `(process.env.NODE_ENV !== 'production')`
//         : // hard coded dev/prod builds
//           JSON.stringify(!isProduction),
//     // this is only used during tests
//     __TEST__:
//       isBundlerESMBuild || isNodeBuild
//         ? `(process.env.NODE_ENV === 'test')`
//         : 'false',
//     // If the build is expected to run directly in the browser (global / esm builds)
//     __BROWSER__: JSON.stringify(isBrowserBuild),
//     // is targeting bundlers?
//     __BUNDLER__: JSON.stringify(isBundlerESMBuild),
//     __GLOBAL__: JSON.stringify(isGlobalBuild),
//     // is targeting Node (SSR)?
//     __NODE_JS__: JSON.stringify(isNodeBuild),
//   }
//   // allow inline overrides like
//   //__RUNTIME_COMPILE__=true yarn build
//   Object.keys(replacements).forEach((key) => {
//     if (key in process.env) {
//       replacements[key] = process.env[key]
//     }
//   })
//   return replace({
//     preventAssignment: true,
//     values: replacements,
//   })
// }

// function createProductionConfig(format) {
//   const extension = format === 'cjs' ? 'cjs' : 'js'
//   const descriptor = format === 'cjs' ? '' : `.${format}`
//   return createConfig(format, {
//     file: `dist/${name}${descriptor}.prod.${extension}`,
//     format: outputConfigs[format].format,
//   })
// }

// function createMinifiedConfig(format) {
//   const { terser } = require('rollup-plugin-terser')
//   return createConfig(
//     format,
//     {
//       file: `dist/${name}.${format === 'global' ? 'iife' : format}.prod.js`,
//       format: outputConfigs[format].format,
//     },
//     [
//       terser({
//         module: /^esm/.test(format),
//         compress: {
//           ecma: 2015,
//           pure_getters: true,
//         },
//       }),
//     ]
//   )
// }