fix: correct the behavior when multiple transform filter options are specified (#19818)

Author: sapphi-red

packages/vite/src/node/__tests__/plugins/pluginFilter.spec.ts

@@ -2,8 +2,6 @@ import util from 'node:util'
 import path from 'node:path'
 import { describe, expect, test } from 'vitest'
 import {
-  FALLBACK_FALSE,
-  FALLBACK_TRUE,
   createCodeFilter,
   createFilterForTransform,
   createIdFilter,
@@ -16,37 +14,37 @@ describe('createIdFilter', () => {
       inputFilter: 'foo.js',
       cases: [
         { id: 'foo.js', expected: true },
-        { id: 'foo.ts', expected: FALLBACK_FALSE },
-        { id: '\0foo.js', expected: FALLBACK_FALSE },
-        { id: '\0' + path.resolve('foo.js'), expected: FALLBACK_FALSE },
+        { id: 'foo.ts', expected: false },
+        { id: '\0foo.js', expected: false },
+        { id: '\0' + path.resolve('foo.js'), expected: false },
       ],
     },
     {
       inputFilter: ['foo.js'],
       cases: [
         { id: 'foo.js', expected: true },
-        { id: 'foo.ts', expected: FALLBACK_FALSE },
+        { id: 'foo.ts', expected: false },
       ],
     },
     {
       inputFilter: { include: 'foo.js' },
       cases: [
         { id: 'foo.js', expected: true },
-        { id: 'foo.ts', expected: FALLBACK_FALSE },
+        { id: 'foo.ts', expected: false },
       ],
     },
     {
       inputFilter: { include: '*.js' },
       cases: [
         { id: 'foo.js', expected: true },
-        { id: 'foo.ts', expected: FALLBACK_FALSE },
+        { id: 'foo.ts', expected: false },
       ],
     },
     {
       inputFilter: { include: /\.js$/ },
       cases: [
         { id: 'foo.js', expected: true },
-        { id: 'foo.ts', expected: FALLBACK_FALSE },
+        { id: 'foo.ts', expected: false },
       ],
     },
     {
@@ -56,50 +54,50 @@ describe('createIdFilter', () => {
         ...(process.platform === 'win32'
           ? [{ id: 'a\\foo.js', expected: true }]
           : []),
-        { id: 'a_foo.js', expected: FALLBACK_FALSE },
+        { id: 'a_foo.js', expected: false },
       ],
     },
     {
       inputFilter: { include: [/\.js$/] },
       cases: [
         { id: 'foo.js', expected: true },
-        { id: 'foo.ts', expected: FALLBACK_FALSE },
+        { id: 'foo.ts', expected: false },
       ],
     },
     {
       inputFilter: { exclude: 'foo.js' },
       cases: [
         { id: 'foo.js', expected: false },
-        { id: 'foo.ts', expected: FALLBACK_TRUE },
+        { id: 'foo.ts', expected: true },
       ],
     },
     {
       inputFilter: { exclude: '*.js' },
       cases: [
         { id: 'foo.js', expected: false },
-        { id: 'foo.ts', expected: FALLBACK_TRUE },
+        { id: 'foo.ts', expected: true },
       ],
     },
     {
       inputFilter: { exclude: /\.js$/ },
       cases: [
         { id: 'foo.js', expected: false },
-        { id: 'foo.ts', expected: FALLBACK_TRUE },
+        { id: 'foo.ts', expected: true },
       ],
     },
     {
       inputFilter: { exclude: [/\.js$/] },
       cases: [
         { id: 'foo.js', expected: false },
-        { id: 'foo.ts', expected: FALLBACK_TRUE },
+        { id: 'foo.ts', expected: true },
       ],
     },
     {
       inputFilter: { include: 'foo.js', exclude: 'bar.js' },
       cases: [
         { id: 'foo.js', expected: true },
         { id: 'bar.js', expected: false },
-        { id: 'baz.js', expected: FALLBACK_FALSE },
+        { id: 'baz.js', expected: false },
       ],
     },
     {
@@ -140,64 +138,64 @@ describe('createCodeFilter', () => {
       inputFilter: 'import.meta',
       cases: [
         { code: 'import.meta', expected: true },
-        { code: 'import_meta', expected: FALLBACK_FALSE },
+        { code: 'import_meta', expected: false },
       ],
     },
     {
       inputFilter: ['import.meta'],
       cases: [
         { code: 'import.meta', expected: true },
-        { code: 'import_meta', expected: FALLBACK_FALSE },
+        { code: 'import_meta', expected: false },
       ],
     },
     {
       inputFilter: { include: 'import.meta' },
       cases: [
         { code: 'import.meta', expected: true },
-        { code: 'import_meta', expected: FALLBACK_FALSE },
+        { code: 'import_meta', expected: false },
       ],
     },
     {
       inputFilter: { include: /import\.\w+/ },
       cases: [
         { code: 'import.meta', expected: true },
-        { code: 'import_meta', expected: FALLBACK_FALSE },
+        { code: 'import_meta', expected: false },
       ],
     },
     {
       inputFilter: { include: [/import\.\w+/] },
       cases: [
         { code: 'import.meta', expected: true },
-        { code: 'import_meta', expected: FALLBACK_FALSE },
+        { code: 'import_meta', expected: false },
       ],
     },
     {
       inputFilter: { exclude: 'import.meta' },
       cases: [
         { code: 'import.meta', expected: false },
-        { code: 'import_meta', expected: FALLBACK_TRUE },
+        { code: 'import_meta', expected: true },
       ],
     },
     {
       inputFilter: { exclude: /import\.\w+/ },
       cases: [
         { code: 'import.meta', expected: false },
-        { code: 'import_meta', expected: FALLBACK_TRUE },
+        { code: 'import_meta', expected: true },
       ],
     },
     {
       inputFilter: { exclude: [/import\.\w+/] },
       cases: [
         { code: 'import.meta', expected: false },
-        { code: 'import_meta', expected: FALLBACK_TRUE },
+        { code: 'import_meta', expected: true },
       ],
     },
     {
       inputFilter: { include: 'import.meta', exclude: 'import_meta' },
       cases: [
         { code: 'import.meta', expected: true },
         { code: 'import_meta', expected: false },
-        { code: 'importmeta', expected: FALLBACK_FALSE },
+        { code: 'importmeta', expected: false },
       ],
     },
     {
@@ -259,7 +257,30 @@ describe('createFilterForTransform', () => {
         { id: 'foo.js', code: 'import.meta', expected: false },
         { id: 'foo.js', code: 'import_meta', expected: false },
         { id: 'foo.ts', code: 'import.meta', expected: true },
-        { id: 'foo.ts', code: 'import_meta', expected: true },
+        { id: 'foo.ts', code: 'import_meta', expected: false },
+      ],
+    },
+    {
+      inputFilter: [
+        { include: 'a*', exclude: '*b' },
+        { include: 'a', exclude: 'b' },
+      ],
+      cases: [
+        { id: 'ab', code: '', expected: false },
+        { id: 'a', code: 'b', expected: false },
+        { id: 'a', code: '', expected: false },
+        { id: 'c', code: 'a', expected: false },
+        { id: 'a', code: 'a', expected: true },
+      ],
+    },
+    {
+      inputFilter: [{ include: 'a*', exclude: '*b' }, { exclude: 'b' }],
+      cases: [
+        { id: 'ab', code: '', expected: false },
+        { id: 'a', code: 'b', expected: false },
+        { id: 'a', code: '', expected: true },
+        { id: 'c', code: 'a', expected: false },
+        { id: 'a', code: 'a', expected: true },
       ],
     },
   ]

packages/vite/src/node/plugins/index.ts

@@ -23,7 +23,7 @@ import { metadataPlugin } from './metadata'
 import { dynamicImportVarsPlugin } from './dynamicImportVars'
 import { importGlobPlugin } from './importMetaGlob'
 import {
-  type PluginFilterWithFallback,
+  type PluginFilter,
   type TransformHookFilter,
   createFilterForTransform,
   createIdFilter,
@@ -165,8 +165,8 @@ export function getHookHandler<T extends ObjectHook<Function>>(
 }
 
 type FilterForPluginValue = {
-  resolveId?: PluginFilterWithFallback | undefined
-  load?: PluginFilterWithFallback | undefined
+  resolveId?: PluginFilter | undefined
+  load?: PluginFilter | undefined
   transform?: TransformHookFilter | undefined
 }
 const filterForPlugin = new WeakMap<Plugin, FilterForPluginValue>()
@@ -184,7 +184,7 @@ export function getCachedFilterForPlugin<
     filterForPlugin.set(plugin, filters)
   }
 
-  let filter: PluginFilterWithFallback | TransformHookFilter | undefined
+  let filter: PluginFilter | TransformHookFilter | undefined
   switch (hookName) {
     case 'resolveId': {
       const rawFilter =

packages/vite/src/node/plugins/pluginFilter.ts

@@ -3,14 +3,7 @@ import picomatch from 'picomatch'
 import { arraify } from '../utils'
 import { slash } from '../../shared/utils'
 
-export const FALLBACK_TRUE = 1
-export const FALLBACK_FALSE = 0
-type FallbackValues = typeof FALLBACK_TRUE | typeof FALLBACK_FALSE
-
 export type PluginFilter = (input: string) => boolean
-export type PluginFilterWithFallback = (
-  input: string,
-) => boolean | FallbackValues
 export type TransformHookFilter = (id: string, code: string) => boolean
 
 export type StringFilter<Value = string | RegExp> =
@@ -70,7 +63,7 @@ function patternToCodeFilter(pattern: string | RegExp): PluginFilter {
 function createFilter(
   exclude: Array<PluginFilter> | undefined,
   include: Array<PluginFilter> | undefined,
-): PluginFilterWithFallback | undefined {
+): PluginFilter | undefined {
   if (!exclude && !include) {
     return
   }
@@ -82,7 +75,7 @@ function createFilter(
     if (include?.some((filter) => filter(input))) {
       return true
     }
-    return !!include && include.length > 0 ? FALLBACK_FALSE : FALLBACK_TRUE
+    return !!include && include.length > 0 ? false : true
   }
 }
 
@@ -106,7 +99,7 @@ function normalizeFilter(filter: StringFilter): NormalizedStringFilter {
 export function createIdFilter(
   filter: StringFilter | undefined,
   cwd = process.cwd(),
-): PluginFilterWithFallback | undefined {
+): PluginFilter | undefined {
   if (!filter) return
   const { exclude, include } = normalizeFilter(filter)
   const excludeFilter = exclude?.map((p) => patternToIdFilter(p, cwd))
@@ -116,7 +109,7 @@ export function createIdFilter(
 
 export function createCodeFilter(
   filter: StringFilter | undefined,
-): PluginFilterWithFallback | undefined {
+): PluginFilter | undefined {
   if (!filter) return
   const { exclude, include } = normalizeFilter(filter)
   const excludeFilter = exclude?.map(patternToCodeFilter)
@@ -135,18 +128,14 @@ export function createFilterForTransform(
   return (id, code) => {
     let fallback = true
     if (idFilterFn) {
-      const idResult = idFilterFn(id)
-      if (typeof idResult === 'boolean') {
-        return idResult
-      }
-      fallback &&= !!idResult
+      fallback &&= idFilterFn(id)
+    }
+    if (!fallback) {
+      return false
     }
+
     if (codeFilterFn) {
-      const codeResult = codeFilterFn(code)
-      if (typeof codeResult === 'boolean') {
-        return codeResult
-      }
-      fallback &&= !!codeResult
+      fallback &&= codeFilterFn(code)
     }
     return fallback
   }