happy-css-modules 2.1.2 → 3.0.1

package/src/locator/index.ts

@@ -4,14 +4,7 @@ import type { Resolver } from '../resolver/index.js';
 import { createDefaultResolver } from '../resolver/index.js';
 import { createDefaultTransformer, type Transformer } from '../transformer/index.js';
 import { unique, uniqueBy } from '../util.js';
-import {
-  getOriginalLocation,
-  generateLocalTokenNames,
-  parseAtImport,
-  type Location,
-  parseComposesDeclarationWithFromUrl,
-  collectNodes,
-} from './postcss.js';
+import { getOriginalLocation, generateLocalTokenNames, parseAtImport, type Location, collectNodes } from './postcss.js';
 
 export { collectNodes, type Location } from './postcss.js';
 
@@ -38,7 +31,7 @@ type CacheEntry = {
 
 /** The result of `Locator#load`. */
 export type LoadResult = {
-  /** The path of the file imported from the source file with `@import` or `composes`. */
+  /** The path of the file imported from the source file with `@import`. */
   dependencies: string[];
   /** The tokens exported by the source file. */
   tokens: Token[];
@@ -98,6 +91,7 @@ export class Locator {
     for (const dependency of dependencies) {
       const entry = this.cache.get(dependency);
       if (!entry) return true;
+      // eslint-disable-next-line no-await-in-loop
       const mtime = (await stat(dependency)).mtime.getTime();
       if (entry.mtime !== mtime) return true;
     }
@@ -124,7 +118,7 @@ export class Locator {
       dependencies: result.dependencies
         .map((dep) => {
           if (typeof dep === 'string') return dep;
-          if (dep.protocol !== 'file:') throw new Error('Unsupported protocol: ' + dep.protocol);
+          if (dep.protocol !== 'file:') throw new Error(`Unsupported protocol: ${dep.protocol}`);
           return dep.pathname;
         })
         .filter((dep) => {
@@ -164,14 +158,16 @@ export class Locator {
 
     const tokens: Token[] = [];
 
-    const { atImports, classSelectors, composesDeclarations } = collectNodes(ast);
+    const { atImports, classSelectors } = collectNodes(ast);
 
     // Load imported sheets recursively.
     for (const atImport of atImports) {
       const importedSheetPath = parseAtImport(atImport);
       if (!importedSheetPath) continue;
       if (isIgnoredSpecifier(importedSheetPath)) continue;
+      // eslint-disable-next-line no-await-in-loop
       const from = await this.resolver(importedSheetPath, { request: filePath });
+      // eslint-disable-next-line no-await-in-loop
       const result = await this._load(from);
       const externalTokens = result.tokens;
       dependencies.push(from, ...result.dependencies);
@@ -192,18 +188,6 @@ export class Locator {
       });
     }
 
-    // Load imported tokens by the names recursively.
-    for (const composesDeclaration of composesDeclarations) {
-      const declarationDetail = parseComposesDeclarationWithFromUrl(composesDeclaration);
-      if (!declarationDetail) continue;
-      if (isIgnoredSpecifier(declarationDetail.from)) continue;
-      const from = await this.resolver(declarationDetail.from, { request: filePath });
-      const result = await this._load(from);
-      const externalTokens = result.tokens.filter((token) => declarationDetail.tokenNames.includes(token.name));
-      dependencies.push(from, ...result.dependencies);
-      tokens.push(...externalTokens);
-    }
-
     const result: LoadResult = {
       dependencies: unique(dependencies).filter((dep) => dep !== filePath),
       tokens: normalizeTokens(tokens),

package/src/locator/postcss.test.ts

@@ -1,18 +1,6 @@
 import dedent from 'dedent';
-import {
-  createRoot,
-  createClassSelectors,
-  createAtImports,
-  createComposesDeclarations,
-  createFixtures,
-} from '../test-util/util.js';
-import {
-  generateLocalTokenNames,
-  getOriginalLocation,
-  parseAtImport,
-  parseComposesDeclarationWithFromUrl,
-  collectNodes,
-} from './postcss.js';
+import { createRoot, createClassSelectors, createAtImports, createFixtures } from '../test-util/util.js';
+import { generateLocalTokenNames, getOriginalLocation, parseAtImport, collectNodes } from './postcss.js';
 
 describe('generateLocalTokenNames', () => {
   test('basic', async () => {
@@ -39,10 +27,6 @@ describe('generateLocalTokenNames', () => {
           .local_class_name_3 {}
         }
         :local(.local_class_name_4) {}
-        .composes_target {}
-        .composes {
-          composes: composes_target;
-        }
         `),
       ),
     ).toStrictEqual([
@@ -62,8 +46,6 @@ describe('generateLocalTokenNames', () => {
       'local_class_name_2',
       'local_class_name_3',
       'local_class_name_4',
-      'composes_target',
-      'composes',
     ]);
   });
   test('does not track styles imported by @import in other file because it is not a local token', async () => {
@@ -236,23 +218,6 @@ describe('getOriginalLocation', () => {
       `{ filePath: "/test/test.css", start: { line: 6, column: 8 }, end: { line: 6, column: 26 } }`,
     );
   });
-  test('composes', () => {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    const [composes_target, composes] = createClassSelectors(
-      createRoot(dedent`
-      .composes_target {}
-      .composes {
-        composes: composes_target;
-      }
-      `),
-    );
-    expect(getOriginalLocation(composes_target!.rule, composes_target!.classSelector)).toMatchInlineSnapshot(
-      `{ filePath: "/test/test.css", start: { line: 1, column: 1 }, end: { line: 1, column: 16 } }`,
-    );
-    expect(getOriginalLocation(composes!.rule, composes!.classSelector)).toMatchInlineSnapshot(
-      `{ filePath: "/test/test.css", start: { line: 2, column: 1 }, end: { line: 2, column: 9 } }`,
-    );
-  });
   test('with_newline', () => {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     const [with_newline_1, with_newline_2, with_newline_3] = createClassSelectors(
@@ -280,23 +245,20 @@ test('collectNodes', () => {
     @import;
     @import "test.css";
     @ignored;
-    .a { ignored: "ignored"; composes: a; }
-    .b { ignored: "ignored"; composes: b; }
+    .a { ignored: "ignored"; }
+    .b { ignored: "ignored"; }
     `);
 
-  const { atImports, classSelectors, composesDeclarations } = collectNodes(ast);
+  const { atImports, classSelectors } = collectNodes(ast);
 
   expect(atImports).toHaveLength(2);
   expect(atImports[0]!.toString()).toEqual('@import');
   expect(atImports[1]!.toString()).toEqual('@import "test.css"');
   expect(classSelectors).toHaveLength(2);
-  expect(classSelectors[0]!.rule.toString()).toEqual('.a { ignored: "ignored"; composes: a; }');
+  expect(classSelectors[0]!.rule.toString()).toEqual('.a { ignored: "ignored"; }');
   expect(classSelectors[0]!.classSelector.toString()).toEqual('.a');
-  expect(classSelectors[1]!.rule.toString()).toEqual('.b { ignored: "ignored"; composes: b; }');
+  expect(classSelectors[1]!.rule.toString()).toEqual('.b { ignored: "ignored"; }');
   expect(classSelectors[1]!.classSelector.toString()).toEqual('.b');
-  expect(composesDeclarations).toHaveLength(2);
-  expect(composesDeclarations[0]!.toString()).toEqual('composes: a');
-  expect(composesDeclarations[1]!.toString()).toEqual('composes: b');
 });
 
 test('parseAtImport', () => {
@@ -315,32 +277,3 @@ test('parseAtImport', () => {
   expect(parseAtImport(atImports[3]!)).toBe('test.css');
   expect(parseAtImport(atImports[4]!)).toBe('test.css');
 });
-
-test('parseComposesDeclarationWithFromUrl', () => {
-  const composesDeclarations = createComposesDeclarations(
-    createRoot(dedent`
-    .a {
-      composes: a;
-      composes: a b c;
-      composes: a from "test.css";
-      composes: a b c from "test.css";
-      composes: from from from from "test.css";
-      /* NOTE: CSS Modules do not support '... from url("test.css")'. */
-    }
-    `),
-  );
-  expect(parseComposesDeclarationWithFromUrl(composesDeclarations[0]!)).toStrictEqual(undefined);
-  expect(parseComposesDeclarationWithFromUrl(composesDeclarations[1]!)).toStrictEqual(undefined);
-  expect(parseComposesDeclarationWithFromUrl(composesDeclarations[2]!)).toStrictEqual({
-    from: 'test.css',
-    tokenNames: ['a'],
-  });
-  expect(parseComposesDeclarationWithFromUrl(composesDeclarations[3]!)).toStrictEqual({
-    from: 'test.css',
-    tokenNames: ['a', 'b', 'c'],
-  });
-  expect(parseComposesDeclarationWithFromUrl(composesDeclarations[4]!)).toStrictEqual({
-    from: 'test.css',
-    tokenNames: ['from', 'from', 'from'], // do not deduplicate.
-  });
-});

package/src/locator/postcss.ts

@@ -54,9 +54,9 @@ export async function generateLocalTokenNames(ast: Root): Promise<string[]> {
     postcss
       .default()
       // postcss-modules collects tokens (i.e., includes external tokens) by following
-      // the dependencies specified in the @import and composes properties.
+      // the dependencies specified in the @import.
       // However, we do not want `generateLocalTokenNames` to return external tokens.
-      // So we remove the @import and composes properties beforehand.
+      // So we remove the @import beforehand.
       .use(removeDependenciesPlugin())
       .use(
         modules({
@@ -154,7 +154,6 @@ function isComposesDeclaration(node: Node): node is Declaration {
 type CollectNodesResult = {
   atImports: AtRule[];
   classSelectors: { rule: Rule; classSelector: ClassName }[];
-  composesDeclarations: Declaration[];
 };
 
 /**
@@ -164,7 +163,6 @@ type CollectNodesResult = {
 export function collectNodes(ast: Root): CollectNodesResult {
   const atImports: AtRule[] = [];
   const classSelectors: { rule: Rule; classSelector: ClassName }[] = [];
-  const composesDeclarations: Declaration[] = [];
   ast.walk((node) => {
     if (isAtImportNode(node)) {
       atImports.push(node);
@@ -183,11 +181,9 @@ export function collectNodes(ast: Root): CollectNodesResult {
           }
         });
       }).processSync(node);
-    } else if (isComposesDeclaration(node)) {
-      composesDeclarations.push(node);
     }
   });
-  return { atImports, classSelectors, composesDeclarations };
+  return { atImports, classSelectors };
 }
 
 /**
@@ -206,40 +202,3 @@ export function parseAtImport(atImport: AtRule): string | undefined {
   }
   return undefined;
 }
-
-/**
- * Parse `composes` declaration with `from <url>`.
- * If the declaration is not found or do not have `from <url>`, return `undefined`.
- * @param composesDeclaration The `composes` declaration to parse.
- * @returns The information of the declaration.
- */
-export function parseComposesDeclarationWithFromUrl(
-  composesDeclaration: Declaration,
-): { from: string; tokenNames: string[] } | undefined {
-  // NOTE: `composes` property syntax is...
-  // - syntax: `composes: <class-name> [...<class-name>] [from <url>];`
-  // - variables:
-  //   - `<class-name>`: `<sting>`
-  //   - `<url>`: `<string>`
-  // - ref:
-  //   - https://github.com/css-modules/css-modules#composition
-  //   - https://github.com/css-modules/css-modules#composing-from-other-files
-  //   - https://github.com/css-modules/postcss-modules-extract-imports#specification
-
-  const nodes = valueParser(composesDeclaration.value).nodes;
-  if (nodes.length < 5) return undefined;
-
-  const classNamesOrSpaces = nodes.slice(0, -3);
-  const [from, , url] = nodes.slice(-3);
-
-  const classNames = classNamesOrSpaces.filter((node) => node.type === 'word');
-
-  // validate nodes
-  if (from === undefined) return undefined;
-  if (from.type !== 'word' || from.value !== 'from') return undefined;
-  if (url === undefined) return undefined;
-  if (url.type !== 'string') return undefined;
-  if (classNames.length === 0) return undefined;
-
-  return { from: url.value, tokenNames: classNames.map((node) => node.value) };
-}

package/src/resolver/index.ts

@@ -11,7 +11,7 @@ export type ResolverOptions = {
 /**
  * The function to resolve the path of the imported file.
  * @returns The resolved path of the imported file. `false` means to skip resolving.
- * */
+ */
 export type Resolver = (specifier: string, options: ResolverOptions) => string | false | Promise<string | false>;
 
 export type DefaultResolverOptions = WebpackResolverOptions;
@@ -43,8 +43,10 @@ export const createDefaultResolver: (defaultResolverOptions?: DefaultResolverOpt
   return async (specifier, options) => {
     for (const resolver of resolvers) {
       try {
+        // eslint-disable-next-line no-await-in-loop
         const resolved = await resolver(specifier, options);
         if (resolved !== false) {
+          // eslint-disable-next-line no-await-in-loop
           const isExists = await exists(resolved);
           if (isExists) return resolved;
         }

package/src/resolver/node-resolver.ts

@@ -2,6 +2,6 @@ import { fileURLToPath, pathToFileURL } from 'url';
 import { resolve } from 'import-meta-resolve';
 import type { Resolver } from './index.js';
 
-export const createNodeResolver: () => Resolver = () => async (specifier, options) => {
-  return fileURLToPath(await resolve(specifier, pathToFileURL(options.request).href));
+export const createNodeResolver: () => Resolver = () => (specifier, options) => {
+  return fileURLToPath(resolve(specifier, pathToFileURL(options.request).href));
 };

package/src/resolver/webpack-resolver.ts

@@ -44,14 +44,13 @@ export const createWebpackResolver: (webpackResolverOptions?: WebpackResolverOpt
    * @see https://github.com/webpack-contrib/css-loader/blob/897e7dd250ccdb0d31e6c66d4cd0d009f2022a85/src/plugins/postcss-import-parser.js#L228-L235
    */
   const cssLoaderResolver = enhancedResolve.create.sync({
-    dependencyType: 'css',
     conditionNames: ['style'],
     // We are not sure how "..." affects behavior...
     mainFields: ['css', 'style', 'main', '...'],
     mainFiles: ['index', '...'],
     extensions: ['.css', '...'],
     preferRelative: true,
-    alias: webpackResolveAlias,
+    alias: webpackResolveAlias ?? {},
   });
 
   /**
@@ -60,14 +59,13 @@ export const createWebpackResolver: (webpackResolverOptions?: WebpackResolverOpt
    * @see https://github.com/webpack-contrib/sass-loader/blob/49a578a218574ddc92a597c7e365b6c21960717e/src/utils.js#L531-L539
    */
   const sassLoaderResolver = enhancedResolve.create.sync({
-    dependencyType: 'sass',
     conditionNames: ['sass', 'style'],
     mainFields: ['sass', 'style', 'main', '...'],
     mainFiles: ['_index', 'index', '...'],
     extensions: ['.sass', '.scss', '.css'],
-    restrictions: [/\.((sa|sc|c)ss)$/i],
+    restrictions: [/\.((sa|sc|c)ss)$/iu],
     preferRelative: true,
-    alias: webpackResolveAlias,
+    alias: webpackResolveAlias ?? {},
     modules: ['node_modules', ...(sassLoadPaths ?? [])],
   });
 
@@ -77,13 +75,12 @@ export const createWebpackResolver: (webpackResolverOptions?: WebpackResolverOpt
    * @see https://github.com/webpack-contrib/less-loader/blob/d74f740c100c4006b00dfb3e02c6d5aaf8713519/src/utils.js#L35-L42
    */
   const lessLoaderResolver = enhancedResolve.create.sync({
-    dependencyType: 'less',
     conditionNames: ['less', 'style'],
     mainFields: ['less', 'style', 'main', '...'],
     mainFiles: ['index', '...'],
     extensions: ['.less', '.css'],
     preferRelative: true,
-    alias: webpackResolveAlias,
+    alias: webpackResolveAlias ?? {},
     modules: ['node_modules', ...(lessIncludePaths ?? [])],
   });
 
@@ -96,6 +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
     if (specifier.startsWith('~')) specifier = specifier.slice(1);
 
     for (const resolver of resolvers) {
@@ -104,13 +102,14 @@ export const createWebpackResolver: (webpackResolverOptions?: WebpackResolverOpt
           ? // Support partial import for sass
             // https://sass-lang.com/documentation/at-rules/import#partials
             // https://github.com/webpack-contrib/sass-loader/blob/0e9494074f69a6b6d47efea6c083a02a31a5ae84/test/sass/import-with-underscore.sass
-            [join(dirname(specifier), '_' + basename(specifier)), specifier]
+            [join(dirname(specifier), `_${basename(specifier)}`), specifier]
           : [specifier];
 
       for (const specifierVariant of specifierVariants) {
         try {
           const resolved = resolver(dirname(options.request), specifierVariant);
           if (resolved !== false) {
+            // eslint-disable-next-line no-await-in-loop
             const isExists = await exists(resolved);
             if (isExists) return resolved;
           }

package/src/runner.test.ts

@@ -3,23 +3,22 @@ import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import * as fileCacheNpm from '@file-cache/npm';
+import * as fileCacheCore from '@file-cache/core';
+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';
 
-const packageRootDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-
 const require = createRequire(import.meta.url);
 
-jest.unstable_mockModule('@file-cache/npm', () => ({
-  ...fileCacheNpm, // Inherit native functions
-  createNpmPackageKey: () => 'mocked-key',
-}));
-
-jest.unstable_mockModule('pkg-dir', () => ({
-  packageDirectory: () => packageRootDir,
+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);
+  },
 }));
 
 const { run } = await import('./runner.js');
@@ -144,6 +143,7 @@ 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);
@@ -187,7 +187,7 @@ test('does not emit declaration map if declarationMap is false', async () => {
   });
   await run({ ...defaultOptions, declarationMap: false });
   await expect(readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).resolves.not.toThrow();
-  await expect(readFile(getFixturePath('/test/1.css.d.ts.map'), 'utf8')).rejects.toThrow(/ENOENT/);
+  await expect(readFile(getFixturePath('/test/1.css.d.ts.map'), 'utf8')).rejects.toThrow(/ENOENT/u);
 });
 test('supports transformer', async () => {
   createFixtures({
@@ -205,17 +205,17 @@ test('watches for changes in files', async () => {
 
   await writeFile(getFixturePath('/test/1.css'), '.a-1 {}');
   await waitForAsyncTask(500); // Wait until the file is written
-  expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatch(/a-1/);
+  expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatch(/a-1/u);
 
   await writeFile(getFixturePath('/test/1.css'), '.a-2 {}');
   await waitForAsyncTask(500); // Wait until the file is written
-  expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatch(/a-2/);
+  expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatch(/a-2/u);
 
   await writeFile(getFixturePath('/test/2.css'), '.b {}');
   await writeFile(getFixturePath('/test/3.css'), '.c {}');
   await waitForAsyncTask(500); // Wait until the file is written
-  expect(await readFile(getFixturePath('/test/2.css.d.ts'), 'utf8')).toMatch(/b/);
-  expect(await readFile(getFixturePath('/test/3.css.d.ts'), 'utf8')).toMatch(/c/);
+  expect(await readFile(getFixturePath('/test/2.css.d.ts'), 'utf8')).toMatch(/b/u);
+  expect(await readFile(getFixturePath('/test/3.css.d.ts'), 'utf8')).toMatch(/c/u);
 });
 test('returns an error if the file fails to process in non-watch mode', async () => {
   createFixtures({
@@ -230,8 +230,8 @@ 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/2.css:1:1: Unknown word`);
-  expect(error.errors[1]).toMatchInlineSnapshot(`<fixtures>/test/3.css:1:1: Unknown word`);
+  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`);
 
   // The valid files are emitted.
   expect(await exists(getFixturePath('/test/1.css.d.ts'))).toBe(true);

package/src/runner.ts

@@ -1,12 +1,11 @@
 import { resolve, relative } from 'path';
 import * as process from 'process';
-import * as util from '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 { glob } from 'glob';
 import { DEFAULT_ARBITRARY_EXTENSIONS } from './config.js';
 import { isGeneratedFilesExist, emitGeneratedFiles } from './emitter/index.js';
 import { Locator } from './locator/index.js';
@@ -16,8 +15,6 @@ import { createDefaultResolver } from './resolver/index.js';
 import { createDefaultTransformer, type Transformer } from './transformer/index.js';
 import { getInstalledPeerDependencies, isMatchByGlob } from './util.js';
 
-const glob = util.promisify(_glob);
-
 export type Watcher = {
   close: () => Promise<void>;
 };
@@ -94,6 +91,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 logger = new Logger(options.logLevel ?? 'info');
 
@@ -108,8 +106,9 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
     });
   const transformer = options.transformer ?? createDefaultTransformer({ cwd, postcssConfig: options.postcssConfig });
 
-  const installedPeerDependencies = await getInstalledPeerDependencies();
+  const installedPeerDependencies = getInstalledPeerDependencies();
   const cache = await createCache({
+    name: 'happy-css-modules',
     mode: options.cacheStrategy ?? 'content',
     keys: [
       () => createNpmPackageKey(['happy-css-modules', ...installedPeerDependencies]),
@@ -128,6 +127,7 @@ 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
       if (result.error) throw result.error;
       return result.changed;
     }
@@ -175,6 +175,7 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
 
     const errors: unknown[] = [];
     for (const filePath of filePaths) {
+      // eslint-disable-next-line no-await-in-loop
       await processFile(filePath).catch((e) => errors.push(e));
     }
 
@@ -184,13 +185,13 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
   }
 
   if (!options.watch) {
-    logger.info('Generate .d.ts for ' + options.pattern + '...');
+    logger.info(`Generate .d.ts for ${options.pattern}...`);
     await processAllFiles();
     // Write cache state to file for persistence
   } else {
     // First, watch files.
-    logger.info('Watch ' + options.pattern + '...');
-    const watcher = chokidar.watch([options.pattern.replace(/\\/g, '/')], { cwd });
+    logger.info(`Watch ${options.pattern}...`);
+    const watcher = chokidar.watch([options.pattern.replace(/\\/gu, '/')], { cwd });
     watcher.on('all', (eventName, relativeFilePath) => {
       const filePath = resolve(cwd, relativeFilePath);
 

package/src/test-util/jest/resolver.cjs

@@ -1,3 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
 const nativeModule = require('node:module');
 
 // workaround for https://github.com/facebook/jest/issues/12270#issuecomment-1194746382
@@ -14,7 +15,7 @@ const nativeModule = require('node:module');
  * pathFilter?: (pkg: any, path: string, relativePath: string) => string;
  * rootDir?: string;
  * }} ResolverOptions
- * */
+ */
 
 /** @type {(path: string, options: ResolverOptions) => string} */
 function resolver(module, options) {
@@ -22,7 +23,7 @@ function resolver(module, options) {
   try {
     return defaultResolver(module, options);
     // eslint-disable-next-line no-unused-vars
-  } catch (error) {
+  } catch (_error) {
     return nativeModule.createRequire(basedir).resolve(module);
   }
 }

package/src/test-util/tsserver.ts

@@ -2,14 +2,12 @@ import { readFileSync } from 'fs';
 import { mkdir, writeFile as nativeWriteFile } from 'fs/promises';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { promisify } from 'util';
 import serverHarness from '@typescript/server-harness';
-import _glob from 'glob';
+import { glob } from 'glob';
 import { resolve } from 'import-meta-resolve';
 import lineColumn from 'line-column';
 import type { server } from 'typescript/lib/tsserverlibrary.js';
 import { getFixturePath } from './util.js';
-const glob = promisify(_glob);
 
 async function writeFile(path: string, content: string): Promise<void> {
   await mkdir(dirname(path), { recursive: true });
@@ -37,14 +35,11 @@ type Definition = {
   };
 };
 
-export async function createTSServer() {
-  const server = serverHarness.launchServer(
-    fileURLToPath(await resolve('typescript/lib/tsserver.js', import.meta.url)),
-    [
-      // ATA generates some extra network traffic and isn't usually relevant when profiling
-      '--disableAutomaticTypingAcquisition',
-    ],
-  );
+export function createTSServer() {
+  const server = serverHarness.launchServer(fileURLToPath(resolve('typescript/lib/tsserver.js', import.meta.url)), [
+    // ATA generates some extra network traffic and isn't usually relevant when profiling
+    '--disableAutomaticTypingAcquisition',
+  ]);
 
   return {
     async getIdentifierDefinitions(filePath: string, identifier: string): Promise<Definition[]> {
@@ -67,6 +62,7 @@ export async function createTSServer() {
       const results: { identifier: string; definitions: Definition[] }[] = [];
 
       for (let i = 0; i < identifiers.length; i++) {
+        // eslint-disable-next-line no-await-in-loop
         const response: server.protocol.DefinitionResponse = await server.message({
           seq: 0,
           type: 'request',

package/src/test-util/util.ts

@@ -2,7 +2,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 postcss, { type Root, type Rule, type AtRule, type Declaration } from 'postcss';
+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';
 import { sleepSync } from '../util.js';
@@ -25,10 +25,6 @@ export function createClassSelectors(root: Root): { rule: Rule; classSelector: C
   return collectNodes(root).classSelectors;
 }
 
-export function createComposesDeclarations(root: Root): Declaration[] {
-  return collectNodes(root).composesDeclarations;
-}
-
 export function fakeToken(args: {
   name: Token['name'];
   originalLocations: { filePath?: Location['filePath']; start?: Location['start'] }[];
@@ -53,7 +49,9 @@ export function fakeToken(args: {
 }
 
 export async function waitForAsyncTask(ms?: number): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, ms ?? 0));
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms ?? 0);
+  });
 }
 
 export async function exists(path: string): Promise<boolean> {

package/src/transformer/index.ts

@@ -7,7 +7,7 @@ import { createScssTransformer } from './scss-transformer.js';
 /**
  * The value returned from the transformer.
  * `false` means to skip transpiling on that file.
- * */
+ */
 export type TransformResult =
   | {
       /** The transformed code. */