rollup.config.js

import commonjs from "@rollup/plugin-commonjs"
import resolve from "@rollup/plugin-node-resolve"
import replace from "@rollup/plugin-replace"
import pascalcase from "pascalcase"
import path from "path"
import dts from "rollup-plugin-dts"
import ignoreImport from "rollup-plugin-ignore-import"
import postcss from "rollup-plugin-postcss"
import ts from "rollup-plugin-typescript2"

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

const 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 = {
  "esm-bundler": {
    file: pkg.module,
    format: `es`,
  },
  cjs: {
    file: pkg.main,
    format: `cjs`,
  },
  global: {
    file: pkg.unpkg,
    format: `iife`,
  },
  dts: {
    file: pkg.types,
    format: `es`,
  },
  esm: {
    file: pkg.module.replace("-bundler.js", "-browser.js"),
    format: `es`,
  },
}

const createConfig = (format, output, plugins = []) => {
  if (!output) {
    console.log(`invalid format: "${format}"`)
    process.exit(1)
  }

  const external = ["vue-demi"]

  output.sourcemap = !!process.env.SOURCE_MAP
  output.banner = banner
  output.externalLiveBindings = false
  output.globals = {
    vue: "Vue",
    "vue-demi": "VueDemi",
  }
  output.exports = "auto"

  if (format === "dts") {
    return {
      input: `src/index.ts`,
      plugins: [
        ignoreImport({
          include: ["**/*.css"],
        }),
        dts(),
      ],
      output,
    }
  }

  const isProductionBuild = /\.prod\.js$/.test(output.file)
  const isGlobalBuild = format === "global"
  const isRawESMBuild = format === "esm"
  const isNodeBuild = format === "cjs"
  const isBundlerESMBuild = /esm-bundler/.test(format)

  if (isGlobalBuild) output.name = pascalcase(pkg.name)

  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: false,
        declarationMap: false,
      },
    },
  })

  // 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 nodePlugins = [resolve(), commonjs()]

  return {
    input: `src/index.ts`,
    // Global and Browser ESM builds inlines everything so that they can be
    // used alone.
    external,
    plugins: [
      postcss(),
      tsPlugin,
      createReplacePlugin(
        isProductionBuild,
        isBundlerESMBuild,
        isGlobalBuild || isRawESMBuild || isBundlerESMBuild,
        isGlobalBuild,
        isNodeBuild
      ),
      ...nodePlugins,
      ...plugins,
    ],
    output,
  }
}

const createReplacePlugin = (
  isProduction,
  isBundlerESMBuild,
  isBrowserBuild,
  isGlobalBuild,
  isNodeBuild
) => {
  const replacements = {
    preventAssignment: true,
    __COMMIT__: `"${process.env.COMMIT}"`,
    __VERSION__: `"${pkg.version}"`,
    __DEV__: isBundlerESMBuild
      ? // preserve to be handled by bundlers
        `(process.env.NODE_ENV !== 'production')`
      : // hard coded dev/prod builds
        !isProduction,
    // this is only used during tests
    __TEST__: isBundlerESMBuild ? `(process.env.NODE_ENV === 'test')` : false,
    // If the build is expected to run directly in the browser (global / esm builds)
    __BROWSER__: isBrowserBuild,
    // is targeting bundlers?
    __BUNDLER__: isBundlerESMBuild,
    __GLOBAL__: isGlobalBuild,
    // is targeting Node (SSR)?
    __NODE_JS__: 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(replacements)
}

const createMinifiedConfig = (format) => {
  const { terser } = require("rollup-plugin-terser")

  return createConfig(
    format,
    {
      file: `dist/index.${format}.prod.js`,
      format: outputConfigs[format].format,
    },
    [
      terser({
        module: /^esm/.test(format),
        compress: {
          ecma: 2015,
          pure_getters: true,
        },
      }),
    ]
  )
}

const allFormats = Object.keys(outputConfigs)
const packageFormats = allFormats
const packageConfigs = packageFormats.map((format) => createConfig(format, outputConfigs[format]))

// only add the production ready if we are bundling the options
packageFormats.forEach((format) => {
  if (format === "global") {
    packageConfigs.push(createMinifiedConfig(format))
  }
})

export default packageConfigs