fix: align plugin hook filter behavior with pluginutils (#19736)

Author: sapphi-red

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

@@ -25,15 +25,15 @@ describe('hook filter with plugin container', async () => {
     {
       name: 'test',
       resolveId: {
-        filter: { id: '*.js' },
+        filter: { id: /\.js$/ },
         handler: resolveId,
       },
       load: {
-        filter: { id: '*.js' },
+        filter: { id: '**/*.js' },
         handler: load,
       },
       transform: {
-        filter: { id: '*.js' },
+        filter: { id: '**/*.js' },
         handler: transformWithId,
       },
     },
@@ -97,15 +97,15 @@ describe('hook filter with build', async () => {
       {
         name: 'test',
         resolveId: {
-          filter: { id: '*.js' },
+          filter: { id: /\.js$/ },
           handler: resolveId,
         },
         load: {
-          filter: { id: '*.js' },
+          filter: { id: '**/*.js' },
           handler: load,
         },
         transform: {
-          filter: { id: '*.js' },
+          filter: { id: '**/*.js' },
           handler: transformWithId,
         },
       },

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

@@ -17,7 +17,6 @@ describe('createIdFilter', () => {
       cases: [
         { id: 'foo.js', expected: true },
         { id: 'foo.ts', expected: FALLBACK_FALSE },
-        { id: path.resolve('foo.js'), expected: true },
         { id: '\0foo.js', expected: FALLBACK_FALSE },
         { id: '\0' + path.resolve('foo.js'), expected: FALLBACK_FALSE },
       ],
@@ -111,11 +110,15 @@ describe('createIdFilter', () => {
         { id: 'foo.ts', expected: false },
       ],
     },
+    {
+      inputFilter: '/virtual/foo',
+      cases: [{ id: '/virtual/foo', expected: true }],
+    },
   ]
 
   for (const filter of filters) {
     test(`${util.inspect(filter.inputFilter)}`, () => {
-      const idFilter = createIdFilter(filter.inputFilter)
+      const idFilter = createIdFilter(filter.inputFilter, '')
       if (!filter.cases) {
         expect(idFilter).toBeUndefined()
         return
@@ -264,7 +267,11 @@ describe('createFilterForTransform', () => {
   for (const filter of filters) {
     test(`${util.inspect(filter.inputFilter)}`, () => {
       const [idFilter, codeFilter] = filter.inputFilter
-      const filterForTransform = createFilterForTransform(idFilter, codeFilter)
+      const filterForTransform = createFilterForTransform(
+        idFilter,
+        codeFilter,
+        '',
+      )
       if (!filter.cases) {
         expect(filterForTransform).toBeUndefined()
         return

packages/vite/src/node/plugin.ts

@@ -141,7 +141,7 @@ export interface Plugin<A = any> extends RollupPlugin<A> {
         isEntry: boolean
       },
     ) => Promise<ResolveIdResult> | ResolveIdResult,
-    { filter?: { id?: StringFilter } }
+    { filter?: { id?: StringFilter<RegExp> } }
   >
   load?: ObjectHook<
     (

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

@@ -13,21 +13,32 @@ export type PluginFilterWithFallback = (
 ) => boolean | FallbackValues
 export type TransformHookFilter = (id: string, code: string) => boolean
 
-export type StringFilter =
-  | string
-  | RegExp
-  | Array<string | RegExp>
+export type StringFilter<Value = string | RegExp> =
+  | Value
+  | Array<Value>
   | {
-      include?: string | RegExp | Array<string | RegExp>
-      exclude?: string | RegExp | Array<string | RegExp>
+      include?: Value | Array<Value>
+      exclude?: Value | Array<Value>
     }
 
 type NormalizedStringFilter = {
   include?: Array<string | RegExp>
   exclude?: Array<string | RegExp>
 }
 
-function patternToIdFilter(pattern: string | RegExp): PluginFilter {
+function getMatcherString(glob: string, cwd: string) {
+  if (glob.startsWith('**') || path.isAbsolute(glob)) {
+    return slash(glob)
+  }
+
+  const resolved = path.join(cwd, glob)
+  return slash(resolved)
+}
+
+function patternToIdFilter(
+  pattern: string | RegExp,
+  cwd: string,
+): PluginFilter {
   if (pattern instanceof RegExp) {
     return (id: string) => {
       const normalizedId = slash(id)
@@ -37,10 +48,10 @@ function patternToIdFilter(pattern: string | RegExp): PluginFilter {
     }
   }
 
-  const cwd = process.cwd()
-  const matcher = picomatch(pattern, { dot: true })
+  const glob = getMatcherString(pattern, cwd)
+  const matcher = picomatch(glob, { dot: true })
   return (id: string) => {
-    const normalizedId = slash(path.relative(cwd, id))
+    const normalizedId = slash(id)
     return matcher(normalizedId)
   }
 }
@@ -94,11 +105,12 @@ function normalizeFilter(filter: StringFilter): NormalizedStringFilter {
 
 export function createIdFilter(
   filter: StringFilter | undefined,
+  cwd = process.cwd(),
 ): PluginFilterWithFallback | undefined {
   if (!filter) return
   const { exclude, include } = normalizeFilter(filter)
-  const excludeFilter = exclude?.map(patternToIdFilter)
-  const includeFilter = include?.map(patternToIdFilter)
+  const excludeFilter = exclude?.map((p) => patternToIdFilter(p, cwd))
+  const includeFilter = include?.map((p) => patternToIdFilter(p, cwd))
   return createFilter(excludeFilter, includeFilter)
 }
 
@@ -115,9 +127,10 @@ export function createCodeFilter(
 export function createFilterForTransform(
   idFilter: StringFilter | undefined,
   codeFilter: StringFilter | undefined,
+  cwd?: string,
 ): TransformHookFilter | undefined {
   if (!idFilter && !codeFilter) return
-  const idFilterFn = createIdFilter(idFilter)
+  const idFilterFn = createIdFilter(idFilter, cwd)
   const codeFilterFn = createCodeFilter(codeFilter)
   return (id, code) => {
     let fallback = true