feat: support regex pattern

Author: sxzz

src/core/options.ts

@@ -1,8 +1,17 @@
 import type { FilterPattern } from '@rollup/pluginutils'
 
-type Replacement = string | ((id: string) => string)
+export type Replacement =
+  | string
+  | ((id: string, match: RegExpExecArray) => string)
+export type ReplaceItem<F = string | RegExp> = {
+  find: F
+  replacement: Replacement
+}
+export type ReplaceMap = {
+  [str: string]: Replacement
+}
 
-interface BaseOptions {
+export interface BaseOptions {
   /**
    * A picomatch pattern, or array of patterns, of files that should be
    * processed by this plugin (if omitted, all files are included by default)
@@ -34,8 +43,7 @@ interface BaseOptions {
   /**
    * You can separate values to replace from other options.
    */
-  values?: { [str: string]: Replacement }
-
+  values?: ReplaceMap | ReplaceItem[]
   enforce?: 'pre' | 'post' | undefined
 }
 
@@ -56,10 +64,11 @@ export type OptionsResolved = Overwrite<
   Required<BaseOptions>,
   {
     enforce: BaseOptions['enforce']
+    values: ReplaceItem[]
   }
 >
 
-export function resolveOption(options: Options): OptionsResolved {
+export function resolveOptions(options: Options): OptionsResolved {
   return {
     include: options.include || [/\.[cm]?[jt]sx?$/],
     exclude: options.exclude || [/node_modules/],
@@ -73,15 +82,26 @@ export function resolveOption(options: Options): OptionsResolved {
 
   function getReplacements() {
     if (options.values) {
-      return Object.assign({}, options.values)
+      if (Array.isArray(options.values)) {
+        return options.values
+      }
+      return normalizeObjectValues(options.values)
     }
+
     const values = Object.assign({}, options)
     delete values.delimiters
     delete values.include
     delete values.exclude
     delete values.sourcemap
     delete values.sourceMap
     delete values.objectGuards
-    return values as OptionsResolved['values']
+    return normalizeObjectValues(values as ReplaceMap)
+  }
+
+  function normalizeObjectValues(values: ReplaceMap): ReplaceItem[] {
+    return Object.entries(values).map(([find, replacement]) => ({
+      find,
+      replacement,
+    }))
   }
 }

src/index.ts

@@ -1,7 +1,7 @@
 import { type TransformResult, createUnplugin } from 'unplugin'
 import { createFilter } from '@rollup/pluginutils'
 import MagicString from 'magic-string'
-import { type Options, resolveOption } from './core/options'
+import { type Options, type ReplaceItem, resolveOptions } from './core/options'
 
 export default createUnplugin<Options | undefined, false>((rawOptions = {}) => {
   let {
@@ -13,16 +13,25 @@ export default createUnplugin<Options | undefined, false>((rawOptions = {}) => {
     delimiters,
     values,
     enforce,
-  } = resolveOption(rawOptions)
+  } = resolveOptions(rawOptions)
   const filter = createFilter(include, exclude)
 
-  if (objectGuards) expandTypeofReplacements(values)
-  const functionValues = mapToFunctions(values)
-  // eslint-disable-next-line unicorn/no-array-callback-reference
-  const keys = Object.keys(functionValues).sort(longest).map(escape)
+  const stringValues = values.filter(
+    (value): value is ReplaceItem<string> => typeof value.find === 'string',
+  )
+  const regexpValues = values.filter(
+    (value): value is ReplaceItem<RegExp> => value.find instanceof RegExp,
+  )
+
+  if (objectGuards) expandTypeofReplacements(stringValues)
+  const escapedKeys = stringValues
+    .map(({ find }) => find)
+    .sort(longest)
+    // eslint-disable-next-line unicorn/no-array-callback-reference
+    .map(escape)
   const lookahead = preventAssignment ? '(?!\\s*(=[^=]|:[^:]))' : ''
   const pattern = new RegExp(
-    `${delimiters[0]}(${keys.join('|')})${delimiters[1]}${lookahead}`,
+    `${delimiters[0]}(${escapedKeys.join('|')})${delimiters[1]}${lookahead}`,
     'g',
   )
 
@@ -40,7 +49,7 @@ export default createUnplugin<Options | undefined, false>((rawOptions = {}) => {
     },
 
     transformInclude(id) {
-      if (keys.length === 0) return false
+      if (escapedKeys.length === 0 && regexpValues.length === 0) return false
       return filter(id)
     },
 
@@ -73,18 +82,32 @@ export default createUnplugin<Options | undefined, false>((rawOptions = {}) => {
     id: string,
     magicString: MagicString,
   ) {
-    let result = false
-    let match
+    let has = false
+    let match: RegExpExecArray | null
+
+    const values: ReplaceItem<RegExp>[] = [...regexpValues]
+    if (escapedKeys.length > 0)
+      values.push({ find: pattern, replacement: null! })
+
+    for (const { find, replacement } of values) {
+      while ((match = find.exec(code))) {
+        has = true
+
+        const start = match.index
+        const end = start + match[0].length
 
-    while ((match = pattern.exec(code))) {
-      result = true
+        const finalReplacement =
+          find === pattern
+            ? stringValues.find(({ find }) => find === match![1])!.replacement
+            : replacement
+        const result = String(ensureFunction(finalReplacement)(id, match))
+        magicString.overwrite(start, end, result)
 
-      const start = match.index
-      const end = start + match[0].length
-      const replacement = String(functionValues[match[1]](id))
-      magicString.overwrite(start, end, replacement)
+        if (!find.global) break
+      }
     }
-    return result
+
+    return has
   }
 })
 
@@ -93,7 +116,9 @@ function escape(str: string) {
   return str.replace(/[$()*+./?[\\\]^{|}-]/g, '\\$&')
 }
 
-function ensureFunction(functionOrValue: any): () => any {
+function ensureFunction(
+  functionOrValue: any,
+): (id: string, match: RegExpExecArray) => any {
   if (typeof functionOrValue === 'function') return functionOrValue
   return () => functionOrValue
 }
@@ -102,47 +127,51 @@ function longest(a: string, b: string) {
   return b.length - a.length
 }
 
-function mapToFunctions(object: Record<string, any>): Record<string, Function> {
-  return Object.keys(object).reduce((fns, key) => {
-    const functions: Record<string, Function> = Object.assign({}, fns)
-    functions[key] = ensureFunction(object[key])
-    return functions
-  }, {})
-}
-
 const objKeyRegEx =
   /^([$A-Z_a-z\u00A0-\uFFFF][\w$\u00A0-\uFFFF]*)(\.([$A-Z_a-z\u00A0-\uFFFF][\w$\u00A0-\uFFFF]*))+$/
-function expandTypeofReplacements(replacements: Record<string, any>) {
-  Object.keys(replacements).forEach((key) => {
-    const objMatch = key.match(objKeyRegEx)
+function expandTypeofReplacements(values: ReplaceItem<string>[]) {
+  values.forEach(({ find }) => {
+    const objMatch = find.match(objKeyRegEx)
     if (!objMatch) return
     let dotIndex = objMatch[1].length
     let lastIndex = 0
     do {
-      // eslint-disable-next-line no-param-reassign
-      replacements[`typeof ${key.slice(lastIndex, dotIndex)} ===`] =
-        '"object" ==='
-      // eslint-disable-next-line no-param-reassign
-      replacements[`typeof ${key.slice(lastIndex, dotIndex)} !==`] =
-        '"object" !=='
-      // eslint-disable-next-line no-param-reassign
-      replacements[`typeof ${key.slice(lastIndex, dotIndex)}===`] =
-        '"object"==='
-      // eslint-disable-next-line no-param-reassign
-      replacements[`typeof ${key.slice(lastIndex, dotIndex)}!==`] =
-        '"object"!=='
-      // eslint-disable-next-line no-param-reassign
-      replacements[`typeof ${key.slice(lastIndex, dotIndex)} ==`] =
-        '"object" ==='
-      // eslint-disable-next-line no-param-reassign
-      replacements[`typeof ${key.slice(lastIndex, dotIndex)} !=`] =
-        '"object" !=='
-      // eslint-disable-next-line no-param-reassign
-      replacements[`typeof ${key.slice(lastIndex, dotIndex)}==`] = '"object"==='
-      // eslint-disable-next-line no-param-reassign
-      replacements[`typeof ${key.slice(lastIndex, dotIndex)}!=`] = '"object"!=='
+      values.push(
+        {
+          find: `typeof ${find.slice(lastIndex, dotIndex)} ===`,
+          replacement: '"object" ===',
+        },
+        {
+          find: `typeof ${find.slice(lastIndex, dotIndex)} !==`,
+          replacement: '"object" !==',
+        },
+        {
+          find: `typeof ${find.slice(lastIndex, dotIndex)}===`,
+          replacement: '"object"===',
+        },
+        {
+          find: `typeof ${find.slice(lastIndex, dotIndex)}!==`,
+          replacement: '"object"!==',
+        },
+        {
+          find: `typeof ${find.slice(lastIndex, dotIndex)} ==`,
+          replacement: '"object" ===',
+        },
+        {
+          find: `typeof ${find.slice(lastIndex, dotIndex)} !=`,
+          replacement: '"object" !==',
+        },
+        {
+          find: `typeof ${find.slice(lastIndex, dotIndex)}==`,
+          replacement: '"object"===',
+        },
+        {
+          find: `typeof ${find.slice(lastIndex, dotIndex)}!=`,
+          replacement: '"object"!==',
+        },
+      )
       lastIndex = dotIndex + 1
-      dotIndex = key.indexOf('.', lastIndex)
+      dotIndex = find.indexOf('.', lastIndex)
     } while (dotIndex !== -1)
   })
 }

tests/__snapshots__/esbuild.test.ts.snap

@@ -4,6 +4,7 @@ exports[`esbuild 1`] = `
 "// tests/fixtures/main.js
 var platform = "darwin";
 console.log('hello "darwin"', platform);
+console.log(DEV);
 export {
   platform
 };

tests/__snapshots__/rollup.test.ts.snap

@@ -1,11 +1,24 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`rollup 1`] = `
+exports[`rollup > find regexp 1`] = `
+"import 'node:process';
+
+const platform = null;
+
+console.info('hello null', platform);
+console.info(dEV);
+
+export { platform };
+"
+`;
+
+exports[`rollup > find string 1`] = `
 "import 'node:process';
 
 const platform = "darwin";
 
 console.log('hello "darwin"', platform);
+console.log(DEV);
 
 export { platform };
 "

tests/__snapshots__/vite.test.ts.snap

@@ -4,5 +4,6 @@ exports[`vite 1`] = `
 "import "node:process";
 const platform = "darwin";
 console.log('hello "darwin"', platform);
+console.log(DEV);
 "
 `;

tests/__snapshots__/webpack.test.ts.snap

@@ -15,6 +15,7 @@ const external_node_process_namespaceObject = require("node:process");
 const platform = "darwin"
 
 console.log('hello "darwin"', platform)
+console.log(DEV)
 
 /******/ })()
 ;"

tests/esbuild.test.ts

@@ -17,4 +17,6 @@ test('esbuild', async () => {
     ],
   })
   expect(outputFiles[0].text).toMatchSnapshot()
+  expect(outputFiles[0].text).not.contains('process.platform')
+  expect(outputFiles[0].text).contains('"darwin"')
 })

tests/fixtures/main.js

@@ -3,3 +3,4 @@ import process from 'node:process'
 export const platform = process.platform
 
 console.log('hello process.platform', platform)
+console.log(DEV)

tests/rollup.test.ts

@@ -1,16 +1,45 @@
 import path from 'node:path'
-import { expect, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { rollupBuild } from '@vue-macros/test-utils'
+
 import UnpluginReplace from '../src/rollup'
 
-test('rollup', async () => {
-  const result = await rollupBuild(
-    path.resolve(__dirname, 'fixtures/main.js'),
-    [
-      UnpluginReplace({
-        'process.platform': '"darwin"',
-      }),
-    ],
-  )
-  expect(result).toMatchSnapshot()
+describe('rollup', () => {
+  test('find string', async () => {
+    const result = await rollupBuild(
+      path.resolve(__dirname, 'fixtures/main.js'),
+      [
+        UnpluginReplace({
+          'process.platform': '"darwin"',
+        }),
+      ],
+    )
+    expect(result).toMatchSnapshot()
+    expect(result).not.contains('process.platform')
+    expect(result).contains('"darwin"')
+  })
+
+  test('find regexp', async () => {
+    const result = await rollupBuild(
+      path.resolve(__dirname, 'fixtures/main.js'),
+      [
+        UnpluginReplace({
+          values: [
+            { find: /process\.\w+/g, replacement: 'null' },
+            {
+              find: /[A-Z]/,
+              replacement: (id, match) => match[0].toLowerCase(),
+            },
+            {
+              find: /console\.\w+/g,
+              replacement: () => `console.info`,
+            },
+          ],
+        }),
+      ],
+    )
+    expect(result).toMatchSnapshot()
+    expect(result).contains('console.info(dEV)')
+    expect(result).contains(`console.info('hello null', platform)`)
+  })
 })

tests/vite.test.ts

@@ -25,4 +25,6 @@ test('vite', async () => {
     ],
   })) as RollupOutput
   expect(output[0].code).toMatchSnapshot()
+  expect(output[0].code).not.contains('process.platform')
+  expect(output[0].code).contains('"darwin"')
 })