happy-css-modules 3.2.0 → 5.0.0

package/src/resolver/index.ts

@@ -27,7 +27,7 @@ export type DefaultResolverOptions = WebpackResolverOptions;
  * @param options The options to resolve
  * @returns The resolved path (absolute). `false` means to skip resolving.
  */
-export const createDefaultResolver: (defaultResolverOptions?: DefaultResolverOptions | undefined) => Resolver = (
+export const createDefaultResolver: (defaultResolverOptions?: DefaultResolverOptions) => Resolver = (
   defaultResolverOptions,
 ) => {
   const relativeResolver = createRelativeResolver();
@@ -43,14 +43,14 @@ export const createDefaultResolver: (defaultResolverOptions?: DefaultResolverOpt
   return async (specifier, options) => {
     for (const resolver of resolvers) {
       try {
-        // eslint-disable-next-line no-await-in-loop
+        // oxlint-disable-next-line no-await-in-loop
         const resolved = await resolver(specifier, options);
         if (resolved !== false) {
-          // eslint-disable-next-line no-await-in-loop
+          // oxlint-disable-next-line no-await-in-loop
           const isExists = await exists(resolved);
           if (isExists) return resolved;
         }
-      } catch (e) {
+      } catch {
         // noop
       }
     }

package/src/resolver/node-resolver.ts

@@ -1,4 +1,4 @@
-import { fileURLToPath, pathToFileURL } from 'url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { resolve } from 'import-meta-resolve';
 import type { Resolver } from './index.js';
 

package/src/resolver/relative-resolver.ts

@@ -1,4 +1,4 @@
-import { dirname, resolve } from 'path';
+import { dirname, resolve } from 'node:path';
 import type { Resolver } from './index.js';
 
 export const createRelativeResolver: () => Resolver = () => (specifier, options) => {

package/src/resolver/webpack-resolver.ts

@@ -1,4 +1,4 @@
-import { basename, dirname, join, resolve } from 'path';
+import { basename, dirname, join, resolve } from 'node:path';
 import enhancedResolve from 'enhanced-resolve';
 import { exists } from '../util.js';
 import type { Resolver } from './index.js';
@@ -27,7 +27,7 @@ export type WebpackResolverOptions = {
 };
 
 // TODO: Support `resolve.alias` for Node.js API
-export const createWebpackResolver: (webpackResolverOptions?: WebpackResolverOptions | undefined) => Resolver = (
+export const createWebpackResolver: (webpackResolverOptions?: WebpackResolverOptions) => Resolver = (
   webpackResolverOptions,
 ) => {
   const cwd = webpackResolverOptions?.cwd ?? process.cwd();
@@ -93,7 +93,7 @@ export const createWebpackResolver: (webpackResolverOptions?: WebpackResolverOpt
     // ref: https://github.com/webpack-contrib/css-loader/blob/5e6cf91fd3f0c8b5fb4b91197b98dc56abdef4bf/src/utils.js#L92-L95
     // ref: https://github.com/webpack-contrib/sass-loader/blob/49a578a218574ddc92a597c7e365b6c21960717e/src/utils.js#L368-L370
     // ref: https://github.com/webpack-contrib/less-loader/blob/d74f740c100c4006b00dfb3e02c6d5aaf8713519/src/utils.js#L72-L75
-    // eslint-disable-next-line no-param-reassign
+    // oxlint-disable-next-line no-param-reassign
     if (specifier.startsWith('~')) specifier = specifier.slice(1);
 
     for (const resolver of resolvers) {
@@ -109,11 +109,11 @@ export const createWebpackResolver: (webpackResolverOptions?: WebpackResolverOpt
         try {
           const resolved = resolver(dirname(options.request), specifierVariant);
           if (resolved !== false) {
-            // eslint-disable-next-line no-await-in-loop
+            // oxlint-disable-next-line no-await-in-loop
             const isExists = await exists(resolved);
             if (isExists) return resolved;
           }
-        } catch (e) {
+        } catch {
           // noop
         }
       }

package/src/runner.test.ts

@@ -1,32 +1,52 @@
-import { readFile, rm, symlink, writeFile } from 'fs/promises';
 import { randomUUID } from 'node:crypto';
+import { readFile, rm, symlink, writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
-import { dirname, join, resolve } from 'path';
-import { fileURLToPath } from 'url';
-import * as fileCacheCore from '@file-cache/core';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import type { CreateCacheOptions } from '@file-cache/core';
-import { jest } from '@jest/globals';
 import dedent from 'dedent';
 import type { RunnerOptions, Watcher } from './runner.js';
-import { createFixtures, exists, getFixturePath, waitForAsyncTask } from './test-util/util.js';
+import { createFixtures, exists, getFixturePath, replaceFixtureDir, waitForAsyncTask } from './test-util/util.js';
 
 const require = createRequire(import.meta.url);
 
 const uuid = randomUUID();
-jest.unstable_mockModule('@file-cache/core', () => ({
-  ...fileCacheCore, // Inherit native functions
-  createCache: async (options: CreateCacheOptions) => {
-    options.keys.push(() => uuid); // Add a random key to avoid cache collision
-    return fileCacheCore.createCache(options);
-  },
-}));
+vi.mock(import('@file-cache/core'), async (importOriginal) => {
+  const fileCacheCore = await importOriginal();
+  return {
+    ...fileCacheCore, // Inherit native functions
+    createCache: async (options: CreateCacheOptions) => {
+      options.keys.push(() => uuid); // Add a random key to avoid cache collision
+      return fileCacheCore.createCache(options);
+    },
+  };
+});
+
+// `createNpmPackageKey` resolves the version of `happy-css-modules` from node_modules, but this
+// repository is the `happy-css-modules` package itself and does not install itself into node_modules.
+// Stub it so the cache key can be computed without the package being installed.
+vi.mock(import('@file-cache/npm'), async (importOriginal) => {
+  const fileCacheNpm = await importOriginal();
+  return {
+    ...fileCacheNpm,
+    createNpmPackageKey: () => '__happy-css-modules',
+  };
+});
+
+vi.mock('sass', async (importOriginal) => {
+  const sass = await importOriginal<typeof import('sass')>();
+  return {
+    ...sass,
+    // Suppress the warning: `Sass @import rules are deprecated and will be removed in Dart Sass 3.0.0.`
+    compileStringAsync: async (source: string, options?: Parameters<typeof sass.compileStringAsync>[1]) =>
+      sass.compileStringAsync(source, { silenceDeprecations: ['import'], ...options }),
+  };
+});
 
 const { run } = await import('./runner.js');
 
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
 const defaultOptions: RunnerOptions = {
   pattern: 'test/**/*.{css,scss}',
@@ -69,14 +89,14 @@ test('uses cache in non-watch mode', async () => {
     '/test/1.css': '.a {}',
   });
   await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(2);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
   expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('generated'));
   consoleLogSpy.mockClear();
 
   // Skip generation
   await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(2);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
   expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('skipped'));
   consoleLogSpy.mockClear();
@@ -84,20 +104,20 @@ test('uses cache in non-watch mode', async () => {
   // Generates if generated files are missing
   await rm(getFixturePath('/test/1.css.d.ts'));
   await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(2);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
   expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('generated'));
   consoleLogSpy.mockClear();
 
   // Generates if options are changed
   await run({ ...defaultOptions, declarationMap: false, logLevel: 'debug', cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(2);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
   expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('generated'));
   consoleLogSpy.mockClear();
 });
 
-test('uses cache in watch mode', async () => {
+test('uses cache in watch mode', { retry: 5 }, async () => {
   createFixtures({
     '/test/1.css': '.a-1 {}',
     '/test/2.css': '.b-1 {}',
@@ -106,7 +126,7 @@ test('uses cache in watch mode', async () => {
   // At first, process all files
   watcher = await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true, watch: true });
   await waitForAsyncTask(1000); // Wait until the watcher is ready
-  expect(consoleLogSpy).toBeCalledTimes(3);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(3);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(
     1,
     expect.anything(),
@@ -127,7 +147,7 @@ test('uses cache in watch mode', async () => {
   // Updating 1.css, it will only be processed
   await writeFile(getFixturePath('/test/1.css'), '.a-2 {}');
   await waitForAsyncTask(500); // Wait until the file is written
-  expect(consoleLogSpy).toBeCalledTimes(1);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(1);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(
     1,
     expect.anything(),
@@ -143,10 +163,9 @@ test('uses cache in watch mode', async () => {
   await waitForAsyncTask(500); // Wait until the file is written
 
   // The updated 1.css will be processed, and the non-updated 2.css will be skipped.
-  // eslint-disable-next-line require-atomic-updates
   watcher = await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true, watch: true });
   await waitForAsyncTask(1000); // Wait until the watcher is ready
-  expect(consoleLogSpy).toBeCalledTimes(3);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(3);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(
     1,
     expect.anything(),
@@ -165,7 +184,7 @@ test('outputs logs', async () => {
     '/test/1.css': '.a {}',
   });
   await run({ ...defaultOptions, logLevel: 'debug', cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(2);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
   expect(consoleLogSpy).toHaveBeenNthCalledWith(
     2,
@@ -175,7 +194,7 @@ test('outputs logs', async () => {
   consoleLogSpy.mockClear();
 
   await run({ ...defaultOptions, logLevel: 'debug', cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenCalledTimes(2);
   expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
   expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('test/1.css (skipped)'));
 });
@@ -230,8 +249,12 @@ test('returns an error if the file fails to process in non-watch mode', async ()
   const error = maybeError as AggregateError;
   expect(error.message).toMatchInlineSnapshot(`"Failed to process files"`);
   expect(error.errors).toHaveLength(2);
-  expect(error.errors[0]).toMatchInlineSnapshot(`<fixtures>/test/3.css:1:1: Unknown word`);
-  expect(error.errors[1]).toMatchInlineSnapshot(`<fixtures>/test/2.css:1:1: Unknown word`);
+  expect(replaceFixtureDir((error.errors[0] as Error).message)).toMatchInlineSnapshot(
+    `"<fixtures>/test/2.css:1:1: Unknown word INVALID"`,
+  );
+  expect(replaceFixtureDir((error.errors[1] as Error).message)).toMatchInlineSnapshot(
+    `"<fixtures>/test/3.css:1:1: Unknown word INVALID"`,
+  );
 
   // The valid files are emitted.
   expect(await exists(getFixturePath('/test/1.css.d.ts'))).toBe(true);
@@ -241,9 +264,9 @@ describe('handles external files', () => {
   beforeEach(() => {
     createFixtures({
       '/test/1.css': dedent`
-      @import './2.css';
-      @import 'external-library';
-      .a {}
+        @import './2.css';
+        @import 'external-library';
+        .a {}
       `,
       '/test/2.css': `.b {}`,
       '/node_modules/external-library/index.css': `.c {}`,
@@ -274,7 +297,7 @@ test('sassLoadPaths', async () => {
   const sassLoadPaths = ['test/relative'];
   createFixtures({
     '/test/1.scss': dedent`
-    @import '2.scss';
+      @import '2.scss';
     `,
     '/test/relative/2.scss': `.a { dummy: ''; }`,
   });
@@ -285,7 +308,7 @@ test('lessIncludePaths', async () => {
   const lessIncludePaths = ['test/relative'];
   createFixtures({
     '/test/1.less': dedent`
-    @import '2.less';
+      @import '2.less';
     `,
     '/test/relative/2.less': `.a { dummy: ''; }`,
   });
@@ -296,7 +319,7 @@ test('webpackResolveAlias', async () => {
   const webpackResolveAlias = { '@relative': 'test/relative' };
   createFixtures({
     '/test/1.less': dedent`
-    @import '@relative/2.less';
+      @import '@relative/2.less';
     `,
     '/test/relative/2.less': `.a { dummy: ''; }`,
   });
@@ -308,15 +331,15 @@ test('postcssConfig', async () => {
   const postcssConfig = `${uuid}/postcss.config.js`;
   createFixtures({
     [`/${uuid}/postcss.config.js`]: dedent`
-    module.exports = {
-      plugins: [
-        require('${require.resolve('postcss-simple-vars')}'),
-      ],
-    };
+      module.exports = {
+        plugins: [
+          require('${require.resolve('postcss-simple-vars')}'),
+        ],
+      };
     `,
     '/test/1.css': dedent`
-    $prefix: foo;
-    .$(prefix)_bar {}
+      $prefix: foo;
+      .$(prefix)_bar {}
     `,
   });
   await run({ ...defaultOptions, postcssConfig }); // not throw

package/src/runner.ts

@@ -1,11 +1,11 @@
-import { resolve, relative } from 'path';
-import * as process from 'process';
+import type { Stats } from 'node:fs';
+import { glob } from 'node:fs/promises';
+import { resolve, relative, basename } from 'node:path';
+import * as process from 'node:process';
+import { styleText } from 'node:util';
 import { createCache } from '@file-cache/core';
 import { createNpmPackageKey } from '@file-cache/npm';
-import AwaitLock from 'await-lock';
-import chalk from 'chalk';
-import * as chokidar from 'chokidar';
-import { glob } from 'glob';
+import chokidar from 'chokidar';
 import { DEFAULT_ARBITRARY_EXTENSIONS } from './config.js';
 import { isGeneratedFilesExist, emitGeneratedFiles } from './emitter/index.js';
 import { Locator } from './locator/index.js';
@@ -15,6 +15,31 @@ import { createDefaultResolver } from './resolver/index.js';
 import { createDefaultTransformer, type Transformer } from './transformer/index.js';
 import { getInstalledPeerDependencies, isMatchByGlob } from './util.js';
 
+class Mutex {
+  private _queue: (() => void)[] = [];
+  private _locked = false;
+
+  async acquire(): Promise<void> {
+    await new Promise<void>((resolve) => {
+      if (!this._locked) {
+        this._locked = true;
+        resolve();
+      } else {
+        this._queue.push(resolve);
+      }
+    });
+  }
+
+  release(): void {
+    const next = this._queue.shift();
+    if (next) {
+      next();
+    } else {
+      this._locked = false;
+    }
+  }
+}
+
 export type Watcher = {
   close: () => Promise<void>;
 };
@@ -93,8 +118,7 @@ type OverrideProp<T, K extends keyof T, V extends T[K]> = Omit<T, K> & { [P in K
 export async function run(options: OverrideProp<RunnerOptions, 'watch', true>): Promise<Watcher>;
 export async function run(options: RunnerOptions): Promise<void>;
 export async function run(options: RunnerOptions): Promise<Watcher | void> {
-  // eslint-disable-next-line new-cap
-  const lock = new AwaitLock.default();
+  const lock = new Mutex();
   const logger = new Logger(options.logLevel ?? 'info');
 
   const cwd = options.cwd ?? process.cwd();
@@ -129,13 +153,13 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
   async function processFile(filePath: string) {
     async function isChangedFile(filePath: string) {
       const result = await cache.getAndUpdateCache(filePath);
-      // eslint-disable-next-line @typescript-eslint/no-throw-literal
+      // oxlint-disable-next-line typescript/only-throw-error
       if (result.error) throw result.error;
       return result.changed;
     }
 
     // Locator#load cannot be called concurrently. Therefore, it takes a lock and waits.
-    await lock.acquireAsync();
+    await lock.acquire();
 
     try {
       const _isGeneratedFilesExist = await isGeneratedFilesExist(
@@ -149,7 +173,7 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
       // Generate .d.ts and .d.ts.map only when the file has been updated.
       // However, if .d.ts or .d.ts.map has not yet been generated, always generate.
       if (_isGeneratedFilesExist && !_isChangedFile) {
-        logger.debug(chalk.gray(`${relative(cwd, filePath)} (skipped)`));
+        logger.debug(styleText('gray', `${relative(cwd, filePath)} (skipped)`));
         return;
       }
 
@@ -166,7 +190,7 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
         outDir: options.outDir,
         cwd,
       });
-      logger.info(chalk.green(`${relative(cwd, filePath)} (generated)`));
+      logger.info(styleText('green', `${relative(cwd, filePath)} (generated)`));
 
       await cache.reconcile(); // Update cache for the file
     } finally {
@@ -175,13 +199,13 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
   }
 
   async function processAllFiles() {
-    const filePaths = (await glob(options.pattern, { dot: true, cwd }))
+    const filePaths = (await Array.fromAsync(glob(options.pattern, { cwd })))
       // convert relative path to absolute path
       .map((file) => resolve(cwd, file));
 
     const errors: unknown[] = [];
     for (const filePath of filePaths) {
-      // eslint-disable-next-line no-await-in-loop
+      // oxlint-disable-next-line no-await-in-loop
       await processFile(filePath).catch((e) => errors.push(e));
     }
 
@@ -197,14 +221,21 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
   } else {
     // First, watch files.
     logger.info(`Watch ${options.pattern}...`);
-    const watcher = chokidar.watch([options.pattern.replace(/\\/gu, '/')], { cwd });
-    watcher.on('all', (eventName, relativeFilePath) => {
-      const filePath = resolve(cwd, relativeFilePath);
-
-      // There is a bug in chokidar that matches symlinks that do not match the pattern.
-      // ref: https://github.com/paulmillr/chokidar/issues/967
-      if (isExternalFile(filePath)) return;
-
+    const watcher = chokidar.watch(cwd, {
+      ignored: (filePath: string, stats?: Stats) => {
+        // The ignored function is called twice for the same path. The first time with stats undefined,
+        // and the second time with stats provided.
+        // In the first call, we can't determine if the path is a directory or file,
+        // so we include it considering it might be a directory.
+        if (!stats) return false;
+        if (stats.isDirectory()) {
+          const name = basename(filePath);
+          return name === 'node_modules' || name === '.git';
+        }
+        return isExternalFile(filePath);
+      },
+    });
+    watcher.on('all', (eventName, filePath) => {
       if (eventName !== 'add' && eventName !== 'change') return;
 
       processFile(filePath).catch((e) => {

package/src/test-util/line-column.test.ts

@@ -0,0 +1,21 @@
+import { getIndexFromLineColumn } from './line-column.js';
+
+describe('getIndexFromLineColumn', () => {
+  test('returns 0 for the first character', () => {
+    expect(getIndexFromLineColumn('abc', 1, 1)).toBe(0);
+  });
+  test('returns the index of a column in the middle of the first line', () => {
+    expect(getIndexFromLineColumn('abc', 1, 3)).toBe(2);
+  });
+  test('returns the index of the head of the second line', () => {
+    expect(getIndexFromLineColumn('abc\ndef', 2, 1)).toBe(4);
+  });
+  test('returns the index of a column in the middle of the second line', () => {
+    expect(getIndexFromLineColumn('abc\ndef', 2, 3)).toBe(6);
+  });
+  test('handles empty lines', () => {
+    // 'abc\n\ndef' => a=0 b=1 c=2 \n=3 \n=4 d=5 e=6 f=7
+    expect(getIndexFromLineColumn('abc\n\ndef', 2, 1)).toBe(4);
+    expect(getIndexFromLineColumn('abc\n\ndef', 3, 1)).toBe(5);
+  });
+});

package/src/test-util/line-column.ts

@@ -0,0 +1,15 @@
+/**
+ * Convert a 1-based line and column into a 0-based index in a string.
+ *
+ * @param str - The string to search in.
+ * @param line - The line number, 1-based.
+ * @param column - The column number, 1-based.
+ * @returns The 0-based index.
+ */
+export function getIndexFromLineColumn(str: string, line: number, column: number): number {
+  const offsetToLine = str
+    .split('\n')
+    .slice(0, line - 1)
+    .reduce((offset, precedingLine) => offset + precedingLine.length + 1 /* '\n'.length */, 0);
+  return offsetToLine + (column - 1);
+}

package/src/test-util/tsserver.ts

@@ -1,12 +1,11 @@
-import { readFileSync } from 'fs';
-import { mkdir, writeFile as nativeWriteFile } from 'fs/promises';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { readFileSync } from 'node:fs';
+import { mkdir, writeFile as nativeWriteFile, glob } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import serverHarness from '@typescript/server-harness';
-import { glob } from 'glob';
 import { resolve } from 'import-meta-resolve';
-import lineColumn from 'line-column';
 import type { server } from 'typescript/lib/tsserverlibrary.js';
+import { getIndexFromLineColumn } from './line-column.js';
 import { getFixturePath } from './util.js';
 
 async function writeFile(path: string, content: string): Promise<void> {
@@ -62,7 +61,7 @@ export function createTSServer() {
       const results: { identifier: string; definitions: Definition[] }[] = [];
 
       for (let i = 0; i < identifiers.length; i++) {
-        // eslint-disable-next-line no-await-in-loop
+        // oxlint-disable-next-line no-await-in-loop
         const response: server.protocol.DefinitionResponse = await server.message({
           seq: 0,
           type: 'request',
@@ -76,8 +75,8 @@ export function createTSServer() {
         const definitions: Definition[] = response.body!.map((definition) => {
           const { file, start, end } = definition;
           const fileContent = readFileSync(file, 'utf-8');
-          const startIndex = lineColumn(fileContent).toIndex(start.line, start.offset);
-          const endIndex = lineColumn(fileContent).toIndex(end.line, end.offset);
+          const startIndex = getIndexFromLineColumn(fileContent, start.line, start.offset);
+          const endIndex = getIndexFromLineColumn(fileContent, end.line, end.offset);
           const text = fileContent.slice(startIndex, endIndex);
           return { file, text, start, end };
         });
@@ -108,8 +107,8 @@ export function createTSServer() {
       const definitions: Definition[] = response.body!.map((definition) => {
         const { file, start, end } = definition;
         const fileContent = readFileSync(file, 'utf-8');
-        const startIndex = lineColumn(fileContent).toIndex(start.line, start.offset);
-        const endIndex = lineColumn(fileContent).toIndex(end.line, end.offset);
+        const startIndex = getIndexFromLineColumn(fileContent, start.line, start.offset);
+        const endIndex = getIndexFromLineColumn(fileContent, end.line, end.offset);
         const text = fileContent.slice(startIndex, endIndex);
         return { file, text, start, end };
       });
@@ -120,7 +119,7 @@ export function createTSServer() {
       // When a file is updated, its cache remains with the old content.
       // Therefore we need to overwrite the cache with the latest content.
 
-      const fixtureFilePaths = await glob(getFixturePath('/**/*.ts'), { dot: true });
+      const fixtureFilePaths = await Array.fromAsync(glob(getFixturePath('/**/*.ts')));
       // latest contents
       const openFiles: server.protocol.UpdateOpenRequest['arguments']['openFiles'] = fixtureFilePaths.map(
         (filePath) => ({

package/src/test-util/util.ts

@@ -1,7 +1,7 @@
-import { constants, mkdirSync, realpathSync, rmSync, writeFileSync } from 'fs';
-import { access } from 'fs/promises';
-import { tmpdir } from 'os';
-import { dirname, join, resolve } from 'path';
+import { constants, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { access } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
 import postcss, { type Root, type Rule, type AtRule } from 'postcss';
 import { type ClassName } from 'postcss-selector-parser';
 import { type Token, collectNodes, type Location } from '../locator/index.js';
@@ -10,7 +10,7 @@ import { sleepSync } from '../util.js';
 export const FIXTURE_DIR_PATH = resolve(
   realpathSync(tmpdir()),
   'happy-css-modules/fixtures',
-  process.env['JEST_WORKER_ID']!,
+  process.env['VITEST_POOL_ID']!,
 );
 
 export function createRoot(code: string, from?: string): Root {
@@ -63,7 +63,7 @@ export async function exists(path: string): Promise<boolean> {
   try {
     await access(path, constants.F_OK);
     return true;
-  } catch (e) {
+  } catch {
     return false;
   }
 }
@@ -107,3 +107,21 @@ export function removeFixtures(): void {
 export function getFixturePath(path: string): string {
   return join(FIXTURE_DIR_PATH, path);
 }
+
+/**
+ * Deeply clone `value` and replace all occurrences of `FIXTURE_DIR_PATH` in strings with `<fixtures>`.
+ * `FIXTURE_DIR_PATH` varies for each test run, so it must be replaced with a fixed string to make snapshots deterministic.
+ * For errors, pass `error.message` instead of the error itself.
+ */
+export function replaceFixtureDir<T>(value: T): T {
+  if (typeof value === 'string') {
+    return value.replaceAll(FIXTURE_DIR_PATH, '<fixtures>') as T;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => replaceFixtureDir(item)) as T;
+  }
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, replaceFixtureDir(item)])) as T;
+  }
+  return value;
+}