jiek 2.0.2-alpha.2 → 2.0.2-alpha.4

package/src/rollup/index.ts

@@ -1,565 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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()]
-    }
-  ]
-}