happy-css-modules 2.1.1 → 3.0.0

package/src/locator/index.ts

@@ -98,6 +98,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 +125,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) => {
@@ -171,7 +172,9 @@ export class Locator {
       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);
@@ -197,7 +200,9 @@ export class Locator {
       const declarationDetail = parseComposesDeclarationWithFromUrl(composesDeclaration);
       if (!declarationDetail) continue;
       if (isIgnoredSpecifier(declarationDetail.from)) continue;
+      // eslint-disable-next-line no-await-in-loop
       const from = await this.resolver(declarationDetail.from, { request: filePath });
+      // eslint-disable-next-line no-await-in-loop
       const result = await this._load(from);
       const externalTokens = result.tokens.filter((token) => declarationDetail.tokenNames.includes(token.name));
       dependencies.push(from, ...result.dependencies);

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

@@ -53,7 +53,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. */

package/src/transformer/less-transformer.ts

@@ -44,6 +44,7 @@ function createLessPluginResolver(Less: typeof import('less'), options: Transfor
 export const createLessTransformer: () => Transformer = () => {
   let less: typeof import('less');
   return async (source, options) => {
+    // eslint-disable-next-line require-atomic-updates
     less ??= (await import('less').catch(handleImportError('less'))).default;
     const result = await less.render(source, {
       filename: options.from,

package/src/transformer/postcss-transformer.ts

@@ -8,7 +8,7 @@ const require = createRequire(import.meta.url);
 
 const postcssrc: typeof import('postcss-load-config') = require('postcss-load-config');
 
-//ref: https://github.com/postcss/postcss-import#dependency-message-support
+// ref: https://github.com/postcss/postcss-import#dependency-message-support
 interface DependencyMessage extends Message {
   type: 'dependency';
   file: string;

package/src/transformer/scss-transformer.ts

@@ -22,7 +22,8 @@ function promisifySassRender(sass: typeof import('sass')) {
 export const createScssTransformer: () => Transformer = () => {
   let sass: typeof import('sass');
   return async (source, options) => {
-    sass ??= (await import('sass').catch(handleImportError('sass'))).default;
+    // eslint-disable-next-line require-atomic-updates
+    sass ??= await import('sass').catch(handleImportError('sass'));
     const render = promisifySassRender(sass);
     const result = await render({
       data: source,

package/src/util.ts

@@ -3,7 +3,7 @@ import { access } from 'fs/promises';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { resolve as importMetaResolve } from 'import-meta-resolve';
-import minimatch from 'minimatch';
+import { minimatch } from 'minimatch';
 
 /**
  * The SystemError type of Node.js.
@@ -73,14 +73,17 @@ export function getPackageJson() {
   return JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf-8'));
 }
 
-export async function getInstalledPeerDependencies(): Promise<string[]> {
+export function getInstalledPeerDependencies(): string[] {
   const pkgJson = getPackageJson();
   const result = [];
   for (const deps of Object.keys(pkgJson.peerDependencies)) {
-    const isInstalled = await importMetaResolve(deps, import.meta.url)
-      .then(() => true)
-      .catch(() => false);
-    if (isInstalled) result.push(deps);
+    try {
+      importMetaResolve(deps, import.meta.url);
+      // If the package is installed, push it to the result array.
+      result.push(deps);
+    } catch {
+      // If the package is not installed, do nothing.
+    }
   }
   return result;
 }