fix(core): refactor pre-compiling glob patterns into a reusable GlobMatcher closure, eliminating repeated regex compilation in hot paths

alilaa · alilaa · commit a9a3d6688a46 · 2026-05-19T09:32:12.000+02:00
diff --git a/packages/core/src/lib/main/parse-project.ts b/packages/core/src/lib/main/parse-project.ts
@@ -9,6 +9,7 @@ import { TsData } from '../file-info/ts-data';
 import { Module } from '../modules/module';
 import { Configuration } from '../config/configuration';
 import { findModulePaths } from '../modules/find-module-paths';
+import { createGlobMatcher } from '../util/match-glob';
 
 export type ParsedResult = {
   fileInfo: FileInfo;
@@ -39,12 +40,18 @@ export const parseProject = (
   const getFileInfo = (path: FsPath) =>
     throwIfNull(fileInfoMap.get(path), `cannot find FileInfo for ${path}`);
 
-  const modulePaths = findModulePaths(projectDirs, rootDir, config);
+  const isBarrelMatch = createGlobMatcher(config.barrelFileName);
+  const modulePaths = findModulePaths(
+    projectDirs,
+    rootDir,
+    config,
+    isBarrelMatch,
+  );
 
   const modules = createModules(modulePaths, fileInfoMap, getFileInfo, {
     entryFileInfo: unassignedFileInfo,
     rootDir,
-    barrelFile: config.barrelFileName,
+    isBarrelMatch,
   });
   fillFileInfoMap(fileInfoMap, modules);
 
diff --git a/packages/core/src/lib/modules/create-modules.ts b/packages/core/src/lib/modules/create-modules.ts
@@ -11,18 +11,19 @@ import {
   keys,
   values,
 } from '../util/typed-object-functions';
+import { GlobMatcher } from '../util/match-glob';
 
 interface CreateModulesContext {
   entryFileInfo: UnassignedFileInfo;
   rootDir: FsPath;
-  barrelFile: string[];
+  isBarrelMatch: GlobMatcher;
 }
 
 export function createModules(
   modulePathMap: ModulePathMap,
   fileInfoMap: Map<FsPath, FileInfo>,
   getFileInfo: (path: FsPath) => FileInfo,
-  { entryFileInfo, rootDir, barrelFile }: CreateModulesContext,
+  { entryFileInfo, rootDir, isBarrelMatch }: CreateModulesContext,
 ): Module[] {
   const moduleMap = fromEntries(
     entries(modulePathMap).map(([path, hasBarrel]) => [
@@ -33,7 +34,7 @@ export function createModules(
         getFileInfo,
         false,
         hasBarrel,
-        barrelFile,
+        isBarrelMatch,
       ),
     ]),
   );
@@ -44,7 +45,7 @@ export function createModules(
     getFileInfo,
     true,
     false,
-    barrelFile,
+    isBarrelMatch,
   );
 
   const modulePaths = keys(moduleMap);
diff --git a/packages/core/src/lib/modules/find-module-paths.ts b/packages/core/src/lib/modules/find-module-paths.ts
@@ -2,6 +2,7 @@ import { FsPath } from '../file-info/fs-path';
 import { findModulePathsWithBarrel } from './internal/find-module-paths-with-barrel';
 import { findModulePathsWithoutBarrel } from './internal/find-module-paths-without-barrel';
 import { Configuration } from '../config/configuration';
+import { GlobMatcher } from '../util/match-glob';
 
 export type ModulePathMap = Record<FsPath, boolean>;
 
@@ -15,14 +16,11 @@ export function findModulePaths(
   projectDirs: FsPath[],
   rootDir: FsPath,
   sheriffConfig: Configuration,
+  isBarrelMatch: GlobMatcher,
 ): ModulePathMap {
-  const {
-    modules,
-    enableBarrelLess,
-    barrelFileName
-  } = sheriffConfig;
+  const { modules, enableBarrelLess, barrelFileName } = sheriffConfig;
   const modulesWithoutBarrel = enableBarrelLess
-    ? findModulePathsWithoutBarrel(modules, rootDir, barrelFileName)
+    ? findModulePathsWithoutBarrel(modules, rootDir, isBarrelMatch)
     : [];
   const modulesWithBarrel = findModulePathsWithBarrel(
     projectDirs,
diff --git a/packages/core/src/lib/modules/internal/find-module-paths-without-barrel.ts b/packages/core/src/lib/modules/internal/find-module-paths-without-barrel.ts
@@ -8,7 +8,7 @@ import * as path from 'path';
 import getFs from '../../fs/getFs';
 import { FOLDER_CHARACTERS_REGEX_STRING } from '../../tags/calc-tags-for-module';
 import { flattenModules } from './flatten-modules';
-import { matchGlob } from '../../util/match-glob';
+import { GlobMatcher } from '../../util/match-glob';
 
 /**
  * The current criterion for finding modules is via
@@ -20,11 +20,15 @@ import { matchGlob } from '../../util/match-glob';
 export function findModulePathsWithoutBarrel(
   moduleConfig: ModuleConfig,
   rootDir: FsPath,
-  barrelFileNames: string[]
+  isBarrelMatch: GlobMatcher,
 ): Set<FsPath> {
   const paths = flattenModules(moduleConfig, '');
   const modulePathsPatternTree = createModulePathPatternsTree(paths);
-  const modules = traverseAndMatch(modulePathsPatternTree, rootDir, barrelFileNames);
+  const modules = traverseAndMatch(
+    modulePathsPatternTree,
+    rootDir,
+    isBarrelMatch,
+  );
   return new Set<FsPath>(modules);
 }
 
@@ -34,14 +38,14 @@ export function findModulePathsWithoutBarrel(
 function traverseAndMatch(
   groupedPatterns: ModulePathPatternsTree,
   basePath: FsPath,
-  barrelFileNames: string[]
+  isBarrelMatch: GlobMatcher,
 ): FsPath[] {
   const fs = getFs();
   const matchedDirectories: FsPath[] = [];
 
   // Check if the current directory should be matched
   if ('' in groupedPatterns) {
-    addAsModuleIfWithoutBarrel(matchedDirectories, basePath, barrelFileNames);
+    addAsModuleIfWithoutBarrel(matchedDirectories, basePath, isBarrelMatch);
   }
 
   const subDirectories = fs.readDirectory(basePath, 'directory');
@@ -55,11 +59,23 @@ function traverseAndMatch(
 
     if (matchingPattern) {
       if (Object.keys(groupedPatterns[matchingPattern]).length === 0) {
-        addAsModuleIfWithoutBarrel(matchedDirectories, subDirectory, barrelFileNames);
+        addAsModuleIfWithoutBarrel(
+          matchedDirectories,
+          subDirectory,
+          isBarrelMatch,
+        );
       } else {
-        const newDirectories = traverseAndMatch(groupedPatterns[matchingPattern], subDirectory, barrelFileNames);
+        const newDirectories = traverseAndMatch(
+          groupedPatterns[matchingPattern],
+          subDirectory,
+          isBarrelMatch,
+        );
         for (const newDirectory of newDirectories) {
-          addAsModuleIfWithoutBarrel(matchedDirectories, newDirectory, barrelFileNames);
+          addAsModuleIfWithoutBarrel(
+            matchedDirectories,
+            newDirectory,
+            isBarrelMatch,
+          );
         }
       }
     }
@@ -91,22 +107,21 @@ function matchPattern(pattern: string, pathSegment: string): boolean {
 function addAsModuleIfWithoutBarrel(
   modulePaths: FsPath[],
   directory: FsPath,
-  barrelFileNames: string[],
+  isBarrelMatch: GlobMatcher,
 ) {
-  if (hasBarrelFile(directory, barrelFileNames)) {
+  if (hasBarrelFile(directory, isBarrelMatch)) {
     return;
   }
 
   modulePaths.push(directory);
 }
 
-function hasBarrelFile(directory: FsPath, barrelFileNames: string[]): boolean {
+function hasBarrelFile(directory: FsPath, isBarrelMatch: GlobMatcher): boolean {
   const fs = getFs();
   const children = fs.readDirectory(directory);
   return children.some((child) => {
     if (fs.isFile(child)) {
-      const fileName = path.basename(child);
-      return barrelFileNames.some((pattern) => matchGlob(pattern, fileName));
+      return isBarrelMatch(path.basename(child));
     }
     return false;
   });
diff --git a/packages/core/src/lib/modules/module.ts b/packages/core/src/lib/modules/module.ts
@@ -3,7 +3,7 @@ import { FileInfo } from './file.info';
 import * as path from 'path';
 import { FsPath } from '../file-info/fs-path';
 import getFs from '../fs/getFs';
-import { matchGlob } from '../util/match-glob';
+import { GlobMatcher } from '../util/match-glob';
 
 /**
  * Since modules are constructed incrementally with in-place
@@ -19,7 +19,7 @@ export class Module {
     private readonly getFileInfo: (fsPath: FsPath) => FileInfo,
     public readonly isRoot: boolean,
     public readonly hasBarrel: boolean,
-    private readonly barrelFilePatterns: string[],
+    private readonly isBarrelMatch: GlobMatcher,
   ) {
   }
 
@@ -40,14 +40,11 @@ export class Module {
    */
   isBarrelFile(filePath: FsPath): boolean {
     const fileDir = getFs().getParent(filePath);
-    const fileName = path.basename(filePath);
 
     if (fileDir !== this.path) {
       return false;
     }
 
-    return this.barrelFilePatterns.some((pattern) =>
-      matchGlob(pattern, fileName),
-    );
+    return this.isBarrelMatch(path.basename(filePath));
   }
 }
diff --git a/packages/core/src/lib/modules/tests/create-module.spec.ts b/packages/core/src/lib/modules/tests/create-module.spec.ts
@@ -16,6 +16,7 @@ import { FileInfo } from '../file.info';
 import { buildFileInfo } from '../../test/build-file-info';
 import { fromEntries } from '../../util/typed-object-functions';
 import { ModulePathMap } from '../find-module-paths';
+import { createGlobMatcher } from '../../util/match-glob';
 
 interface TestParameter {
   fileInfo: UnassignedFileInfo;
@@ -226,10 +227,11 @@ function assertModule(createTestParams: () => TestParameter) {
   const modulePathMap: ModulePathMap = fromEntries(
     barrelFiles.map((path) => [toFsPath(path.replace('/index.ts', '')), true]),
   );
+  const isBarrelMatch = createGlobMatcher(['index.ts']);
   const modules = createModules(modulePathMap, fileInfoMap, getFileInfo, {
     entryFileInfo: fileInfo,
     rootDir: toFsPath('/'),
-    barrelFile: ['index.ts'],
+    isBarrelMatch,
   });
 
   const expectedModules = testParams.expectedModules.map((mi) => {
@@ -245,7 +247,7 @@ function assertModule(createTestParams: () => TestParameter) {
       getFileInfo,
       mi.path === '/',
       mi.path !== '/',
-      ['index.ts'],
+      isBarrelMatch,
     );
     for (const fi of fileInfos) {
       module.addFileInfo(fi);
diff --git a/packages/core/src/lib/modules/tests/find-module-paths-without-barrel.spec.ts b/packages/core/src/lib/modules/tests/find-module-paths-without-barrel.spec.ts
@@ -5,6 +5,7 @@ import { createProject } from '../../test/project-creator';
 import { findModulePathsWithoutBarrel } from '../internal/find-module-paths-without-barrel';
 import { useVirtualFs } from '../../fs/getFs';
 import { toFsPath } from '../../file-info/fs-path';
+import { createGlobMatcher } from '../../util/match-glob';
 
 function assertProject(fileTree: FileTree) {
   return {
@@ -18,7 +19,7 @@ function assertProject(fileTree: FileTree) {
           const actualModulePaths = findModulePathsWithoutBarrel(
             moduleConfig,
             toFsPath('/project'),
-            ['index.ts'],
+            createGlobMatcher(['index.ts']),
           );
           expect(Array.from(actualModulePaths)).toEqual(absoluteModulePaths);
         },
diff --git a/packages/core/src/lib/modules/tests/module-is-barrel-file.spec.ts b/packages/core/src/lib/modules/tests/module-is-barrel-file.spec.ts
@@ -3,6 +3,7 @@ import { Module } from '../module';
 import { FsPath, toFsPath } from '../../file-info/fs-path';
 import { FileInfo } from '../file.info';
 import getFs, { useVirtualFs } from '../../fs/getFs';
+import { createGlobMatcher } from '../../util/match-glob';
 
 describe('Module.isBarrelFile', () => {
   beforeAll(() => {
@@ -34,7 +35,7 @@ describe('Module.isBarrelFile', () => {
       getFileInfo,
       false,
       true,
-      barrelFilePatterns,
+      createGlobMatcher(barrelFilePatterns),
     );
   }
 
diff --git a/packages/core/src/lib/util/match-glob.ts b/packages/core/src/lib/util/match-glob.ts
@@ -1,3 +1,33 @@
+export type GlobMatcher = (text: string) => boolean;
+
+/**
+ * Creates a pre-compiled matcher function for the given glob patterns.
+ *
+ * Supported wildcards:
+ * - `*` matches zero or more characters
+ * - `?` matches exactly one character
+ *
+ * All other characters are matched literally.
+ * The matching is **case-insensitive**.
+ *
+ * @param patterns - The glob patterns to match against.
+ * @returns A function that returns `true` if the text matches any pattern.
+ */
+export function createGlobMatcher(patterns: string[]): GlobMatcher {
+  const literals = patterns
+    .filter((p) => !p.includes('*') && !p.includes('?'))
+    .map((p) => p.toLowerCase());
+
+  const regexes = patterns
+    .filter((p) => p.includes('*') || p.includes('?'))
+    .map((p) => new RegExp(`^${globToRegexString(p)}$`, 'i'));
+
+  return (text: string): boolean => {
+    const lower = text.toLowerCase();
+    return literals.includes(lower) || regexes.some((re) => re.test(text));
+  };
+}
+
 /**
  * Matches a text string against a glob pattern.
  *
