jiek 2.0.2-alpha.1 → 2.0.2-alpha.2

package/src/rollup/index.ts

@@ -0,0 +1,565 @@
+import fs from 'node:fs'
+import { dirname, extname, relative, resolve } from 'node:path'
+
+import type { RecursiveRecord } from '@jiek/pkger/entrypoints'
+import { getAllLeafs } from '@jiek/pkger/entrypoints'
+import { dts } from '@jiek/rollup-plugin-dts'
+import { getWorkspaceDir } from '@jiek/utils/getWorkspaceDir'
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import { nodeResolve } from '@rollup/plugin-node-resolve'
+import { sendMessage } from 'execa'
+import { isMatch } from 'micromatch'
+import type { InputPluginOption, OutputOptions, OutputPlugin, Plugin, RollupOptions } from 'rollup'
+import ts from 'typescript'
+
+import { recusiveListFiles } from '#~/utils/recusiveListFiles.ts'
+
+import { getExports, getOutDirs } from '../utils/getExports'
+import { loadConfig } from '../utils/loadConfig'
+import { getCompilerOptionsByFilePath } from '../utils/ts'
+import type { ConfigGenerateContext, RollupProgressEvent, TemplateOptions } from './base'
+import progress from './plugins/progress'
+import skip from './plugins/skip'
+import externalResolver from './utils/externalResolver'
+
+interface PackageJSON {
+  name?: string
+  type?: string
+  exports?: Record<string, unknown> | string | string[]
+}
+
+const {
+  JIEK_ROOT,
+  JIEK_NAME,
+  JIEK_BUILDER,
+  JIEK_ENTRIES,
+  JIEK_EXTERNAL,
+  JIEK_WITHOUT_JS,
+  JIEK_WITHOUT_DTS,
+  JIEK_WITHOUT_MINIFY,
+  JIEK_MINIFY_TYPE,
+  JIEK_CLEAN,
+  JIEK_ONLY_MINIFY,
+  JIEK_TSCONFIG,
+  JIEK_DTSCONFIG
+} = process.env
+
+const resolveArrayString = (str: string | undefined) => {
+  const arr = [
+    ...new Set(
+      str
+        ?.split(',')
+        .map(e => e.trim())
+        .filter(e => e.length > 0)
+        ?? []
+    )
+  ]
+  return arr?.length ? arr : undefined
+}
+
+const entries = resolveArrayString(JIEK_ENTRIES)?.map(e => ({ 'index': '.' }[e] ?? e))
+
+const commandExternal = resolveArrayString(JIEK_EXTERNAL)?.map(e => new RegExp(`^${e}$`))
+
+const WORKSPACE_ROOT = JIEK_ROOT ?? getWorkspaceDir()
+const COMMON_OPTIONS = {} satisfies RollupOptions
+const COMMON_PLUGINS = [
+  json()
+]
+
+const WITHOUT_JS = JIEK_WITHOUT_JS === 'true'
+const WITHOUT_DTS = JIEK_WITHOUT_DTS === 'true'
+const WITHOUT_MINIFY = JIEK_WITHOUT_MINIFY === 'true'
+
+const ONLY_MINIFY = JIEK_ONLY_MINIFY === 'true'
+
+const CLEAN = JIEK_CLEAN === 'true'
+
+const MINIFY_DEFAULT_VALUE = WITHOUT_MINIFY
+  ? false
+  : ONLY_MINIFY
+  ? 'only-minify'
+  : true
+
+type BuilderOptions = NonNullable<TemplateOptions['builder']>
+
+const BUILDER_OPTIONS = {
+  type: JIEK_BUILDER ?? 'esbuild'
+} as NonNullable<Exclude<BuilderOptions, string>>
+
+type MinifyOptions = NonNullable<TemplateOptions['output']>['minifyOptions']
+
+const MINIFY_OPTIONS = {
+  type: JIEK_MINIFY_TYPE ?? 'esbuild'
+} as NonNullable<Exclude<MinifyOptions, string>>
+
+const config = loadConfig({
+  root: WORKSPACE_ROOT
+}) ?? {}
+const { build = {} } = config
+const { js: jsOutdir, dts: dtsOutdir } = getOutDirs({
+  config,
+  pkgName: JIEK_NAME
+})
+
+if (CLEAN) {
+  fs.existsSync(jsOutdir) && fs.rmdirSync(jsOutdir, { recursive: true })
+  fs.existsSync(dtsOutdir) && fs.rmdirSync(dtsOutdir, { recursive: true })
+}
+
+const STYLE_REGEXP = /\.(css|s[ac]ss|less|styl)$/
+
+const resolveBuildPlugins = (context: ConfigGenerateContext, plugins: TemplateOptions['plugins']): {
+  js: InputPluginOption
+  dts: InputPluginOption
+} => {
+  if (plugins === false || plugins === undefined || plugins === null) {
+    return { js: [], dts: [] }
+  }
+  let js: InputPluginOption = []
+  let dts: InputPluginOption = []
+  switch (typeof plugins) {
+    case 'function':
+      js = plugins('js', context)
+      dts = plugins('dts', context)
+      break
+    case 'object':
+      if ('js' in plugins || 'dts' in plugins) {
+        js = plugins.js ?? []
+        dts = plugins.dts ?? []
+      } else {
+        js = plugins
+        dts = plugins
+      }
+      break
+  }
+  return { js, dts }
+}
+
+const resolveOutputControls = (
+  context: ConfigGenerateContext,
+  output: TemplateOptions['output']
+): { js: boolean; dts: boolean } => ({
+  js: typeof output?.js === 'boolean'
+    ? output.js
+    : typeof output?.js === 'function'
+    ? output.js(context)
+    : true,
+  dts: typeof output?.dts === 'boolean'
+    ? output.dts
+    : typeof output?.dts === 'function'
+    ? output.dts(context)
+    : true
+})
+
+const resolveWorkspacePath = (p: string) => resolve(WORKSPACE_ROOT, p)
+
+const pascalCase = (str: string) =>
+  str
+    .replace(/[@|/-](\w)/g, (_, $1) => $1.toUpperCase())
+    .replace(/(?:^|-)(\w)/g, (_, $1) => $1.toUpperCase())
+
+const reveal = (obj: string | Record<string, unknown>, keys: string[]) =>
+  keys.reduce((acc, key) => {
+    if (typeof acc === 'string') throw new Error('key not found in exports')
+    if (!(key in acc)) throw new Error(`key ${key} not found in exports`)
+    return acc[key] as string | Record<string, unknown>
+  }, obj)
+
+const resolveMinifyOptions = (minifyOptions: MinifyOptions): typeof MINIFY_OPTIONS =>
+  typeof minifyOptions === 'string'
+    ? { type: minifyOptions }
+    : minifyOptions ?? { type: 'esbuild' }
+
+const resolveBuilderOptions = (
+  builder: TemplateOptions['builder']
+): Exclude<TemplateOptions['builder'], string | undefined> =>
+  typeof builder === 'string'
+    ? { type: builder }
+    : builder ?? { type: 'esbuild' }
+
+const resolvedMinifyOptions = resolveMinifyOptions(build.output?.minifyOptions ?? MINIFY_OPTIONS)
+const { type: _resolvedMinifyOptionsType, ...noTypeResolvedMinifyOptions } = resolvedMinifyOptions
+const resolvedBuilderOptions = resolveBuilderOptions(build.builder ?? BUILDER_OPTIONS)
+const { type: _resolvedBuilderOptionsType, ...noTypeResolvedBuilderOptions } = resolvedBuilderOptions
+
+const withMinify = (
+  output: OutputOptions & {
+    plugins?: OutputPlugin[]
+  },
+  minify = build?.output?.minify ?? MINIFY_DEFAULT_VALUE
+): OutputOptions[] => {
+  if (minify === false) return [output]
+
+  const minifyPlugin = resolvedMinifyOptions.type === 'esbuild'
+    ? import('rollup-plugin-esbuild').then(({ minify }) => minify(noTypeResolvedMinifyOptions as any))
+    : resolvedMinifyOptions.type === 'swc'
+    ? import('rollup-plugin-swc3').then(({ minify }) => minify(noTypeResolvedMinifyOptions as any))
+    : import('@rollup/plugin-terser').then(({ default: minify }) => minify(noTypeResolvedMinifyOptions as any))
+  return minify === 'only-minify'
+    ? [{
+      ...output,
+      // TODO replace suffix when pubish to npm and the `build.output.minify` is 'only-minify'
+      // TODO resolve dts output file name
+      entryFileNames: chunkInfo =>
+        typeof output.entryFileNames === 'function'
+          ? output.entryFileNames(chunkInfo)
+          : (() => {
+            throw new Error('entryFileNames must be a function')
+          })(),
+      plugins: [
+        ...(output.plugins ?? []),
+        minifyPlugin
+      ]
+    }]
+    : [
+      output,
+      {
+        ...output,
+        entryFileNames: chunkInfo =>
+          typeof output.entryFileNames === 'function'
+            ? output.entryFileNames(chunkInfo).replace(/(\.[cm]?js)$/, '.min$1')
+            : (() => {
+              throw new Error('entryFileNames must be a function')
+            })(),
+        file: output.file?.replace(/(\.[cm]?js)$/, '.min$1'),
+        plugins: [
+          ...(output.plugins ?? []),
+          minifyPlugin
+        ]
+      }
+    ]
+}
+
+const generateConfigs = (context: ConfigGenerateContext, options: TemplateOptions = {}): RollupOptions[] => {
+  const {
+    path,
+    name,
+    input,
+    output,
+    external: inputExternal,
+    pkgIsModule,
+    conditionals
+  } = context
+  const external = [...inputExternal, ...(options.external ?? []), ...(commandExternal ?? [])]
+  const isModule = conditionals.includes('import')
+  const isCommonJS = conditionals.includes('require')
+  const isBrowser = conditionals.includes('browser')
+  const dtsTSConfigPaths = [
+    resolveWorkspacePath('tsconfig.json'),
+    resolveWorkspacePath('tsconfig.dts.json')
+  ]
+  JIEK_TSCONFIG && dtsTSConfigPaths.push(resolveWorkspacePath(JIEK_TSCONFIG))
+  JIEK_DTSCONFIG && dtsTSConfigPaths.push(resolveWorkspacePath(JIEK_DTSCONFIG))
+  const buildTSConfigPaths = [
+    ...dtsTSConfigPaths,
+    resolveWorkspacePath('tsconfig.build.json')
+  ]
+  // 这里重复写了俩次 JIEK_TSCONFIG 到 tsconfig 的加载列表中
+  // 目的是保证在 build 的时候，JIEK_TSCONFIG 的优先级高于 JIEK_DTSCONFIG
+  JIEK_TSCONFIG && buildTSConfigPaths.push(resolveWorkspacePath(JIEK_TSCONFIG))
+  let dtsTSConfigPath: string | undefined
+  dtsTSConfigPaths.forEach(p => {
+    if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+      dtsTSConfigPath = p
+    }
+  })
+  let buildTSConfigPath: string | undefined
+  buildTSConfigPaths.forEach(p => {
+    if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+      buildTSConfigPath = p
+    }
+  })
+  let compilerOptions: ts.CompilerOptions = {}
+  if (dtsTSConfigPath) {
+    const jsonCompilerOptions = getCompilerOptionsByFilePath(dtsTSConfigPath, resolve(input))
+    const { options, errors } = ts.convertCompilerOptionsFromJson(
+      jsonCompilerOptions,
+      dirname(dtsTSConfigPath)
+    )
+    if (errors.length > 0) {
+      throw new Error(errors.map(e => e.messageText).join('\n'))
+    }
+    compilerOptions = options
+    delete compilerOptions.composite
+  }
+  const exportConditions = [...conditionals, ...(compilerOptions.customConditions ?? [])]
+  const throughEventProps: RollupProgressEvent & { type: 'progress' } = {
+    type: 'progress',
+    data: { name, path, exportConditions, input }
+  }
+  const { js: jsPlugins, dts: dtsPlugins } = resolveBuildPlugins(context, build.plugins)
+  if (input.includes('**')) {
+    throw new Error(
+      'input should not include "**", please read the [documentation](https://nodejs.org/api/packages.html#subpath-patterns).'
+    )
+  }
+  const inputObj = !input.includes('*')
+    ? input
+    : recusiveListFiles(process.cwd())
+      .filter(p => /(?<!\.d)\.[cm]?tsx?$/.test(p))
+      .map(p => relative(process.cwd(), p))
+      .filter(p => isMatch(p, input.slice(2)))
+  const globCommonDir = input.includes('*')
+    ? input.split('*')[0].replace('./', '')
+    : ''
+  const pathCommonDir = path.includes('*')
+    ? path.split('*')[0].replace('./', '')
+    : ''
+  if (
+    (globCommonDir.length > 0 && pathCommonDir.length === 0)
+    || (globCommonDir.length === 0 && pathCommonDir.length > 0)
+  ) {
+    throw new Error('input and path should both include "*" or not include "*"')
+  }
+  const jsOutputSuffix = extname(output)
+  const tsOutputSuffix = jsOutputSuffix.replace(/(\.[cm]?)js$/, '.d$1ts')
+  const { js: jsOutput, dts: dtsOutput } = resolveOutputControls(context, build.output)
+  const rollupOptions: RollupOptions[] = []
+
+  const commonPlugins: Plugin[] = []
+  if (jsOutput && !WITHOUT_JS) {
+    const sourcemap = typeof options?.output?.sourcemap === 'object'
+      ? options.output.sourcemap.js
+      : options?.output?.sourcemap
+    const builder = resolvedBuilderOptions.type === 'esbuild'
+      ? import('rollup-plugin-esbuild').then(({ default: esbuild }) =>
+        esbuild({
+          sourceMap: sourcemap === 'hidden' ? false : !!sourcemap,
+          tsconfig: buildTSConfigPath,
+          ...noTypeResolvedBuilderOptions
+        })
+      )
+      : import('rollup-plugin-swc3').then(({ default: swc }) =>
+        swc({
+          sourceMaps: typeof sourcemap === 'boolean'
+            ? sourcemap
+            : typeof sourcemap === 'undefined'
+            ? undefined
+            : ({
+              hidden: false,
+              inline: 'inline'
+            } as const)[sourcemap] ?? undefined,
+          tsconfig: buildTSConfigPath,
+          ...noTypeResolvedBuilderOptions
+        })
+      )
+    rollupOptions.push({
+      input: inputObj,
+      external,
+      output: [
+        ...withMinify({
+          dir: jsOutdir,
+          name,
+          interop: 'auto',
+          entryFileNames: (chunkInfo) => (
+            Array.isArray(inputObj)
+              ? chunkInfo.facadeModuleId!.replace(`${process.cwd()}/`, '')
+                .replace(globCommonDir, pathCommonDir)
+                .replace(/(\.[cm]?)ts$/, jsOutputSuffix)
+              : output.replace(`${jsOutdir}/`, '')
+          ),
+          sourcemap,
+          format: isModule ? 'esm' : (
+            isCommonJS ? 'cjs' : (
+              isBrowser ? 'umd' : (
+                pkgIsModule ? 'esm' : 'cjs'
+              )
+            )
+          ),
+          strict: typeof options?.output?.strict === 'object'
+            ? options.output.strict.js
+            : options?.output?.strict
+        })
+      ],
+      plugins: [
+        ...commonPlugins,
+        nodeResolve({ exportConditions }),
+        import('rollup-plugin-postcss')
+          .then(({ default: postcss }) =>
+            postcss({
+              extract: resolve(output.replace(/\.[cm]?js$/, '.css')),
+              minimize: true
+            })
+          )
+          .catch(() => void 0),
+        builder,
+        commonjs(),
+        progress({
+          onEvent: (event, message) =>
+            sendMessage(
+              {
+                ...throughEventProps,
+                data: { ...throughEventProps.data, event, message, tags: ['js'] }
+              } satisfies RollupProgressEvent
+            )
+        }),
+        jsPlugins
+      ]
+    })
+  }
+
+  if (dtsOutput && !WITHOUT_DTS) {
+    rollupOptions.push({
+      input: inputObj,
+      external,
+      output: [
+        {
+          dir: dtsOutdir,
+          sourcemap: typeof options?.output?.sourcemap === 'object'
+            ? options.output.sourcemap.dts
+            : options?.output?.sourcemap,
+          entryFileNames: (chunkInfo) => (
+            Array.isArray(inputObj)
+              ? chunkInfo.facadeModuleId!.replace(`${process.cwd()}/`, '')
+                .replace(globCommonDir, pathCommonDir)
+                .replace(/(\.[cm]?)ts$/, tsOutputSuffix)
+              : output
+                .replace(`${jsOutdir}/`, '')
+                .replace(/(\.[cm]?)js$/, tsOutputSuffix)
+          ),
+          strict: typeof options?.output?.strict === 'object'
+            ? options.output.strict.dts
+            : options?.output?.strict
+        }
+      ],
+      plugins: [
+        ...commonPlugins,
+        nodeResolve({ exportConditions }),
+        skip({ patterns: [STYLE_REGEXP] }),
+        dts({
+          respectExternal: true,
+          compilerOptions: {
+            // temp directory, it not affect the output
+            // but if the user not set it and `declaration`, inputs can't generate any dts files when the input relative imports of `package.json`
+            outDir: 'dist',
+            declaration: true,
+            // https://github.com/Swatinem/rollup-plugin-dts/issues/143
+            preserveSymlinks: false,
+            // Expected '{', got 'type' (Note that you need plugins to import files that are not JavaScript)
+            // https://github.com/Swatinem/rollup-plugin-dts/issues/96
+            noEmit: false
+          },
+          tsconfig: dtsTSConfigPath
+        }),
+        progress({
+          onEvent: (event, message) =>
+            sendMessage(
+              {
+                ...throughEventProps,
+                data: { ...throughEventProps.data, event, message, tags: ['dts'] }
+              } satisfies RollupProgressEvent
+            )
+        }),
+        dtsPlugins
+      ]
+    })
+  }
+  if (rollupOptions.length > 0) {
+    // only push the first one a watcher plugin
+    rollupOptions[0].plugins = [
+      {
+        name: 'jiek-plugin-watcher',
+        watchChange: (id) =>
+          sendMessage(
+            {
+              type: 'watchChange',
+              data: { id, name: JIEK_NAME!, path, input }
+            } satisfies RollupProgressEvent
+          )
+      },
+      ...(rollupOptions[0].plugins as any)
+    ]
+  }
+  return rollupOptions
+}
+
+export function template(packageJSON: PackageJSON): RollupOptions[] {
+  const { name, type, exports: entrypoints } = packageJSON
+  const pkgIsModule = type === 'module'
+  if (!name) throw new Error('package.json name is required')
+  if (!entrypoints) throw new Error('package.json exports is required')
+
+  const packageName = pascalCase(name)
+
+  const external = externalResolver(packageJSON as Record<string, unknown>)
+
+  const [filteredResolvedEntrypoints, exports] = getExports({
+    entrypoints,
+    pkgIsModule,
+    entries,
+    pkgName: JIEK_NAME!,
+    outdir: jsOutdir,
+    config
+  })
+
+  const leafMap = new Map<string, string[][]>()
+  getAllLeafs(filteredResolvedEntrypoints as RecursiveRecord<string>, ({ keys, value }) => {
+    if (typeof value === 'string') {
+      const keysArr = leafMap.get(value) ?? []
+      leafMap.set(value, keysArr)
+      keysArr.push(keys)
+    }
+    return false
+  })
+
+  const configs: RollupOptions[] = []
+  leafMap.forEach((keysArr, input) =>
+    keysArr.forEach((keys) => {
+      const [path, ...conditionals] = keys
+
+      const name = packageName + (path === '.' ? '' : pascalCase(path))
+      const keyExports = reveal(exports, keys)
+      const commonOptions = {
+        path,
+        name,
+        input,
+        external,
+        pkgIsModule
+      }
+
+      switch (typeof keyExports) {
+        case 'string': {
+          configs.push(...generateConfigs({
+            ...commonOptions,
+            output: keyExports,
+            conditionals
+          }, build))
+          break
+        }
+        case 'object': {
+          getAllLeafs(keyExports as RecursiveRecord<string>, ({ keys: nextKeys, value }) => {
+            const allConditionals = [...new Set([...conditionals, ...nextKeys])]
+            if (typeof value === 'string') {
+              configs.push(...generateConfigs({
+                ...commonOptions,
+                output: value,
+                conditionals: allConditionals
+              }, build))
+            }
+            return false
+          })
+          break
+        }
+      }
+    })
+  )
+  sendMessage(
+    {
+      type: 'init',
+      data: {
+        leafMap,
+        targetsLength: configs.length
+      }
+    } satisfies RollupProgressEvent
+  )
+  return configs.map(c => ({
+    ...COMMON_OPTIONS,
+    ...c,
+    plugins: [
+      ...COMMON_PLUGINS,
+      c.plugins
+    ]
+  }))
+}

package/src/rollup/plugins/progress.ts

@@ -0,0 +1,26 @@
+import type { PluginImpl } from 'rollup'
+
+interface Options {
+  onEvent?: (event: string, message?: string) => void
+}
+
+export default ((options = {}) => {
+  const { onEvent } = options
+  return {
+    name: 'progress',
+    buildStart: () => onEvent?.('start', 'Start building...'),
+    buildEnd: () => onEvent?.('end', 'Build completed!'),
+    resolveId: {
+      order: 'post',
+      handler: source => onEvent?.('resolve', `Resolving ${source}...`)
+    },
+    load: {
+      order: 'post',
+      handler: id => onEvent?.('load', `Loading ${id}...`)
+    },
+    transform: {
+      order: 'post',
+      handler: (_, id) => onEvent?.('transform', `Transforming ${id}...`)
+    }
+  }
+}) as PluginImpl<Options>

package/src/rollup/plugins/skip.ts

@@ -0,0 +1,21 @@
+import type { PluginImpl } from 'rollup'
+
+interface Options {
+  patterns?: (string | RegExp)[]
+}
+
+export default ((options = {}) => ({
+  name: 'skip',
+  // skip the specified files by `options.patterns`
+  load(id) {
+    if (
+      options.patterns?.some((pattern) =>
+        typeof pattern === 'string'
+          ? id.includes(pattern)
+          : pattern.test(id)
+      )
+    ) {
+      return ''
+    }
+  }
+})) as PluginImpl<Options>

package/src/rollup/utils/commonOptions.ts

@@ -0,0 +1,9 @@
+import type { OutputOptions } from 'rollup'
+
+const defineOutput = <O extends OutputOptions>(output: O) => output
+
+export const commonOutputOptions = defineOutput({
+  exports: 'named',
+  interop: 'auto',
+  sourcemap: true
+})

package/src/rollup/utils/externalResolver.ts

@@ -0,0 +1,35 @@
+import fs from 'node:fs'
+import { builtinModules } from 'node:module'
+
+const EXCLUDE_SUFFIX = [
+  'te?xt',
+  'json',
+  '(css|s[ac]ss|less|styl)'
+]
+
+export default function(json: Record<string, unknown>): (string | RegExp)[]
+export default function(path?: string): (string | RegExp)[]
+export default function(jsonOrPath: string | Record<string, unknown> = process.cwd()): (string | RegExp)[] {
+  const pkg = typeof jsonOrPath === 'string'
+    ? fs.existsSync(`${jsonOrPath}/package.json`)
+      ? JSON.parse(fs.readFileSync(`${jsonOrPath}/package.json`, 'utf-8'))
+      : {}
+    : jsonOrPath
+  const { name, dependencies = {}, peerDependencies = {}, optionalDependencies = {} } = pkg
+  if (!name) {
+    throw new Error('package.json must have a name field')
+  }
+
+  const external = <(string | RegExp)[]> Object
+    .keys(dependencies)
+    .concat(Object.keys(peerDependencies))
+    .concat(Object.keys(optionalDependencies))
+    .concat(builtinModules)
+
+  return [...new Set(external)]
+    .map(dep => new RegExp(`^${dep}(/.*)?$`))
+    .concat([
+      new RegExp(`^${name}(/.*)?(?<!${EXCLUDE_SUFFIX.map(suffix => `\\.${suffix}`).join('|')})$`),
+      /^node:/
+    ])
+}

package/src/rollup/utils/globalResolver.ts

@@ -0,0 +1,13 @@
+export default function (external: string) {
+  // a/b      => AB
+  // a-b      => AB
+  // a@b      => AB
+  // a@b/c    => ABC
+  // node:a   => a
+  // node:a_b => a_b
+  if (external.startsWith('node:')) {
+    return external.slice(5)
+  }
+  return external
+    .replace(/[@|/-](\w)/g, (_, $1) => $1.toUpperCase())
+}

package/src/rollup/utils/withMinify.ts

@@ -0,0 +1,18 @@
+import terser from '@rollup/plugin-terser'
+import type { OutputOptions, OutputPlugin } from 'rollup'
+
+export default function(
+  output: OutputOptions & {
+    entryFileNames?: string
+    plugins?: OutputPlugin[]
+  }
+): OutputOptions[] {
+  return [
+    output,
+    {
+      ...output,
+      entryFileNames: output.entryFileNames?.replace(/(\.[cm]?js)$/, '.min$1'),
+      plugins: [...(output.plugins ?? []), terser()]
+    }
+  ]
+}