happy-css-modules 0.5.0 → 0.6.0

package/src/cli.test.ts

@@ -10,10 +10,6 @@ describe('parseArgv', () => {
     // TODO: Support multiple patterns
     // parseArgv([...baseArgs, 'foo', 'bar']);
   });
-  test('--outDir', () => {
-    expect(parseArgv([...baseArgs, '1.css', '--outDir', 'foo']).outDir).toStrictEqual('foo');
-    expect(parseArgv([...baseArgs, '1.css', '--outDir', '1']).outDir).toStrictEqual('1');
-  });
   test('--watch', () => {
     expect(parseArgv([...baseArgs, '1.css', '--watch']).watch).toBe(true);
     expect(parseArgv([...baseArgs, '1.css', '--no-watch']).watch).toBe(false);
@@ -60,6 +56,15 @@ describe('parseArgv', () => {
       'postcss.config.js',
     );
   });
+  test('--cache', () => {
+    expect(parseArgv([...baseArgs, '1.css']).cache).toBe(true);
+    expect(parseArgv([...baseArgs, '1.css', '--cache']).cache).toBe(true);
+    expect(parseArgv([...baseArgs, '1.css', '--no-cache']).cache).toBe(false);
+  });
+  test('--cacheStrategy', () => {
+    expect(parseArgv([...baseArgs, '1.css']).cacheStrategy).toBe('content');
+    expect(parseArgv([...baseArgs, '1.css', '--cacheStrategy', 'metadata']).cacheStrategy).toBe('metadata');
+  });
   test('--silent', () => {
     expect(parseArgv([...baseArgs, '1.css', '--silent']).silent).toBe(true);
     expect(parseArgv([...baseArgs, '1.css', '--no-silent']).silent).toBe(false);

package/src/cli.ts

@@ -1,21 +1,18 @@
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { type RunnerOptions } from './runner.js';
-
-const pkgJson = JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf-8'));
+import { getPackageJson } from './util.js';
 
 /**
  * Parse command line arguments.
  * @returns Runner options.
  */
 export function parseArgv(argv: string[]): RunnerOptions {
+  const pkgJson = getPackageJson();
   const parsedArgv = yargs(hideBin(argv))
     .wrap(Math.min(140, process.stdout.columns))
     .scriptName('hcm')
-    .usage('Create .d.ts and .d.ts.map from CSS modules *.css files.\n\n$0 [options] <glob>')
+    .usage('Generate .d.ts and .d.ts.map for CSS modules.\n\n$0 [options] <glob>')
     .example("$0 'src/**/*.module.css'", 'Generate .d.ts and .d.ts.map.')
     .example("$0 'src/**/*.module.{css,scss,less}'", 'Also generate files for sass and less.')
     .example("$0 'src/**/*.module.css' --watch", 'Watch for changes and generate .d.ts and .d.ts.map.')
@@ -23,11 +20,8 @@ export function parseArgv(argv: string[]): RunnerOptions {
     .example("$0 'src/**/*.module.css' --sassLoadPaths=src/style", "Run with sass's `--load-path`.")
     .example("$0 'src/**/*.module.css' --lessIncludePaths=src/style", "Run with less's `--include-path`.")
     .example('$0 \'src/**/*.module.css\' --webpackResolveAlias=\'{"@": "src"}\'', "Run with webpack's `resolve.alias`.")
+    .example("$0 'src/**/*.module.css' --cache=false", 'Disable cache.')
     .detectLocale(false)
-    .option('outDir', {
-      type: 'string',
-      describe: 'Output directory',
-    })
     .option('watch', {
       type: 'boolean',
       alias: 'w',
@@ -62,6 +56,17 @@ export function parseArgv(argv: string[]): RunnerOptions {
       string: true,
       describe: "The option compatible with postcss's `--config`.",
     })
+    .option('cache', {
+      type: 'boolean',
+      default: true,
+      describe: 'Only generate .d.ts and .d.ts.map for changed files.',
+    })
+    .option('cacheStrategy', {
+      choices: ['content', 'metadata'] as const,
+      // NOTE: This is a workaround for `parsedArgv.cacheStrategy` type breaks.
+      default: 'content' as RunnerOptions['cacheStrategy'],
+      describe: 'Strategy for the cache to use for detecting changed files.',
+    })
     .option('silent', {
       type: 'boolean',
       default: false,
@@ -94,7 +99,6 @@ export function parseArgv(argv: string[]): RunnerOptions {
   const patterns: string[] = parsedArgv._.map((pattern) => pattern.toString());
   return {
     pattern: patterns[0]!,
-    outDir: parsedArgv.outDir,
     watch: parsedArgv.watch,
     localsConvention: parsedArgv.localsConvention,
     declarationMap: parsedArgv.declarationMap,
@@ -102,6 +106,8 @@ export function parseArgv(argv: string[]): RunnerOptions {
     lessIncludePaths: parsedArgv.lessIncludePaths?.map((item) => item.toString()),
     webpackResolveAlias: parsedArgv.webpackResolveAlias ? JSON.parse(parsedArgv.webpackResolveAlias) : undefined,
     postcssConfig: parsedArgv.postcssConfig,
+    cache: parsedArgv.cache,
+    cacheStrategy: parsedArgv.cacheStrategy,
     silent: parsedArgv.silent,
   };
 }

package/src/emitter/dts.test.ts

@@ -1,20 +1,15 @@
 import dedent from 'dedent';
 import { SourceMapConsumer } from 'source-map';
-import { Loader } from '../loader/index.js';
+import { Locator } from '../locator/index.js';
 import { getFixturePath, createFixtures } from '../test/util.js';
 import { generateDtsContentWithSourceMap, getDtsFilePath } from './dts.js';
 import { type DtsFormatOptions } from './index.js';
 
-const loader = new Loader();
+const locator = new Locator();
 const isExternalFile = () => false;
 
 test('getDtsFilePath', () => {
-  expect(getDtsFilePath('/app/src/dir/1.css', undefined)).toBe('/app/src/dir/1.css.d.ts');
-  expect(getDtsFilePath('/app/src/dir/1.css', { rootDir: '/app', outDir: '/app/dist' })).toBe(
-    '/app/dist/src/dir/1.css.d.ts',
-  );
-  expect(() => getDtsFilePath('/tmp/src/dir/1.css', { rootDir: '/app', outDir: '/app/dist' })).toThrow();
-  expect(() => getDtsFilePath('/app/src/dir/1.css', { rootDir: '/app', outDir: '/tmp/dist' })).toThrow();
+  expect(getDtsFilePath('/app/src/dir/1.css')).toBe('/app/src/dir/1.css.d.ts');
 });
 
 describe('generateDtsContentWithSourceMap', () => {
@@ -40,7 +35,7 @@ describe('generateDtsContentWithSourceMap', () => {
       .d {}
       `,
     });
-    const result = await loader.load(filePath);
+    const result = await locator.load(filePath);
     const { dtsContent, sourceMap } = generateDtsContentWithSourceMap(
       filePath,
       dtsFilePath,
@@ -94,7 +89,7 @@ describe('generateDtsContentWithSourceMap', () => {
         .foo_bar {}
         `,
       });
-      return await loader.load(filePath);
+      return await locator.load(filePath);
     }
     test('undefined', async () => {
       const result = await getResult(filePath);
@@ -215,7 +210,7 @@ describe('generateDtsContentWithSourceMap', () => {
     createFixtures({
       '/test/1.css': `.a {}`,
     });
-    const result = await loader.load(filePath);
+    const result = await locator.load(filePath);
     const { dtsContent, sourceMap } = generateDtsContentWithSourceMap(
       getFixturePath('/test/src/1.css'),
       getFixturePath('/test/dist/1.css.d.ts'),
@@ -244,7 +239,7 @@ describe('generateDtsContentWithSourceMap', () => {
       '/test/2.css': `.b {}`,
       '/test/3.css': `.c {}`,
     });
-    const result = await loader.load(filePath);
+    const result = await locator.load(filePath);
     const { dtsContent } = generateDtsContentWithSourceMap(
       filePath,
       dtsFilePath,

package/src/emitter/dts.ts

@@ -1,27 +1,18 @@
 import { EOL } from 'os';
-import { join, relative, basename } from 'path';
+import { basename } from 'path';
 import camelcase from 'camelcase';
 import { SourceNode, type CodeWithSourceMap } from '../library/source-map/index.js';
-import { type Token } from '../loader/index.js';
+import { type Token } from '../locator/index.js';
 import { type LocalsConvention } from '../runner.js';
-import { type DistOptions, getRelativePath, isSubDirectoryFile, type DtsFormatOptions } from './index.js';
+import { getRelativePath, type DtsFormatOptions } from './index.js';
 
 /**
  * Get .d.ts file path.
  * @param filePath The path to the source file (i.e. `/dir/foo.css`). It is absolute.
- * @param distOptions The distribution option.
  * @returns The path to the .d.ts file. It is absolute.
  */
-export function getDtsFilePath(filePath: string, distOptions: DistOptions | undefined): string {
-  if (distOptions) {
-    if (!isSubDirectoryFile(distOptions.rootDir, filePath))
-      throw new Error(`The filePath(${filePath}) is not a subdirectory of rootDir(${distOptions.rootDir}).`);
-    if (!isSubDirectoryFile(distOptions.rootDir, distOptions.outDir))
-      throw new Error(`The outDir(${distOptions.outDir}) is not a subdirectory of rootDir(${distOptions.rootDir}).`);
-    return join(distOptions.outDir, relative(distOptions.rootDir, filePath) + '.d.ts');
-  } else {
-    return filePath + '.d.ts';
-  }
+export function getDtsFilePath(filePath: string): string {
+  return filePath + '.d.ts';
 }
 
 function dashesCamelCase(str: string): string {

package/src/emitter/index.test.ts

@@ -1,6 +1,5 @@
 import { readFile, stat } from 'fs/promises';
 import { jest } from '@jest/globals';
-import chalk from 'chalk';
 import { createFixtures, exists, fakeToken, getFixturePath, waitForAsyncTask } from '../test/util.js';
 import { emitGeneratedFiles, getRelativePath, isSubDirectoryFile } from './index.js';
 
@@ -27,10 +26,8 @@ describe('emitGeneratedFiles', () => {
   const defaultArgs = {
     filePath: getFixturePath('/test/1.css'),
     tokens: [fakeToken({ name: 'foo', originalLocations: [{ start: { line: 1, column: 1 } }] })],
-    distOptions: undefined,
     emitDeclarationMap: true,
     dtsFormatOptions: undefined,
-    silent: true,
     cwd: getFixturePath('/test'),
     isExternalFile: () => false,
   };
@@ -78,53 +75,4 @@ describe('emitGeneratedFiles', () => {
     expect(mtimeForDts1).not.toEqual(mtimeForDts3); // not skipped
     expect(mtimeForSourceMap1).not.toEqual(mtimeForSourceMap3); // not skipped
   });
-  test('outputs write log', async () => {
-    await emitGeneratedFiles({
-      ...defaultArgs,
-      filePath: getFixturePath('/test/1.css'),
-      emitDeclarationMap: true,
-      silent: false,
-    });
-    expect(consoleLogSpy).toHaveBeenCalledTimes(2);
-    expect(consoleLogSpy).toHaveBeenNthCalledWith(1, `Wrote ${chalk.green('1.css.d.ts')}`);
-    expect(consoleLogSpy).toHaveBeenNthCalledWith(2, `Wrote ${chalk.green('1.css.d.ts.map')}`);
-    consoleLogSpy.mockClear();
-
-    await emitGeneratedFiles({
-      ...defaultArgs,
-      filePath: getFixturePath('/test/2.css'),
-      emitDeclarationMap: false,
-      silent: false,
-    });
-    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
-    expect(consoleLogSpy).toHaveBeenNthCalledWith(1, `Wrote ${chalk.green('2.css.d.ts')}`);
-    consoleLogSpy.mockClear();
-
-    await emitGeneratedFiles({
-      ...defaultArgs,
-      filePath: getFixturePath('/test/3.css'),
-      emitDeclarationMap: false,
-      silent: true,
-    });
-    expect(consoleLogSpy).toHaveBeenCalledTimes(0);
-  });
-  test('changes working directory by cwd', async () => {
-    await emitGeneratedFiles({
-      ...defaultArgs,
-      filePath: getFixturePath('/test/1.css'),
-      emitDeclarationMap: false,
-      silent: false,
-      cwd: getFixturePath('/test'),
-    });
-    await emitGeneratedFiles({
-      ...defaultArgs,
-      filePath: getFixturePath('/test/1.css'),
-      emitDeclarationMap: false,
-      silent: false,
-      cwd: getFixturePath('/'),
-    });
-    expect(consoleLogSpy).toHaveBeenCalledTimes(2);
-    expect(consoleLogSpy).toHaveBeenNthCalledWith(1, `Wrote ${chalk.green('1.css.d.ts')}`);
-    expect(consoleLogSpy).toHaveBeenNthCalledWith(2, `Wrote ${chalk.green('test/1.css.d.ts')}`);
-  });
 });

package/src/emitter/index.ts

@@ -1,7 +1,7 @@
 import { dirname, isAbsolute, relative } from 'path';
-import chalk from 'chalk';
-import { type Token } from '../loader/index.js';
+import { type Token } from '../locator/index.js';
 import { type LocalsConvention } from '../runner.js';
+import { exists } from '../util.js';
 import { generateDtsContentWithSourceMap, getDtsFilePath } from './dts.js';
 import { writeFileIfChanged } from './file-system.js';
 import { generateSourceMappingURLComment, getSourceMapFilePath } from './source-map.js';
@@ -19,18 +19,6 @@ export function isSubDirectoryFile(fromDirectory: string, toFilePath: string): b
   return isAbsolute(toFilePath) && toFilePath.startsWith(fromDirectory);
 }
 
-function outputWriteLog(cwd: string, filePath: string) {
-  console.log('Wrote ' + chalk.green(relative(cwd, filePath)));
-}
-
-/** The distribution option. */
-export type DistOptions = {
-  /** Root directory. It is absolute. */
-  rootDir: string;
-  /** The path to the output directory. It is absolute. */
-  outDir: string;
-};
-
 export type DtsFormatOptions = {
   localsConvention?: LocalsConvention;
 };
@@ -41,16 +29,10 @@ export type EmitterOptions = {
   filePath: string;
   /** The tokens exported by the source file. */
   tokens: Token[];
-  /** The distribution option. */
-  distOptions: DistOptions | undefined;
   /** Whether to output declaration map (i.e. `/dir/foo.css.d.ts.map`) or not. */
   emitDeclarationMap: boolean | undefined;
   /** The options for formatting the type definition. */
   dtsFormatOptions: DtsFormatOptions | undefined;
-  /** Silent output. Do not show "files written" messages */
-  silent: boolean;
-  /** Working directory path. */
-  cwd: string;
   /** Whether the file is from an external library or not. */
   isExternalFile: (filePath: string) => boolean;
 };
@@ -58,15 +40,12 @@ export type EmitterOptions = {
 export async function emitGeneratedFiles({
   filePath,
   tokens,
-  distOptions,
   emitDeclarationMap,
   dtsFormatOptions,
-  silent,
-  cwd,
   isExternalFile,
 }: EmitterOptions): Promise<void> {
-  const dtsFilePath = getDtsFilePath(filePath, distOptions);
-  const sourceMapFilePath = getSourceMapFilePath(filePath, distOptions);
+  const dtsFilePath = getDtsFilePath(filePath);
+  const sourceMapFilePath = getSourceMapFilePath(filePath);
   const { dtsContent, sourceMap } = generateDtsContentWithSourceMap(
     filePath,
     dtsFilePath,
@@ -79,14 +58,28 @@ export async function emitGeneratedFiles({
   if (emitDeclarationMap) {
     const sourceMappingURLComment = generateSourceMappingURLComment(dtsFilePath, sourceMapFilePath);
     await writeFileIfChanged(dtsFilePath, dtsContent + sourceMappingURLComment);
-    if (!silent) outputWriteLog(cwd, dtsFilePath);
-
     // NOTE: tsserver does not support inline declaration maps. Therefore, sourcemap files must be output.
     // blocked by: https://github.com/microsoft/TypeScript/issues/38966
     await writeFileIfChanged(sourceMapFilePath, sourceMap.toString());
-    if (!silent) outputWriteLog(cwd, sourceMapFilePath);
   } else {
     await writeFileIfChanged(dtsFilePath, dtsContent);
-    if (!silent) outputWriteLog(cwd, dtsFilePath);
   }
 }
+
+/**
+ * Returns true if .d.ts (and .d.ts.map) files are generated for the given file.
+ */
+export async function isGeneratedFilesExist(
+  filePath: string,
+  emitDeclarationMap: boolean | undefined,
+): Promise<boolean> {
+  const dtsFilePath = getDtsFilePath(filePath);
+  const sourceMapFilePath = getSourceMapFilePath(filePath);
+  if (emitDeclarationMap && !(await exists(sourceMapFilePath))) {
+    return false;
+  }
+  if (!(await exists(dtsFilePath))) {
+    return false;
+  }
+  return true;
+}

package/src/emitter/source-map.test.ts

@@ -2,12 +2,7 @@ import { EOL } from 'os';
 import { getSourceMapFilePath, generateSourceMappingURLComment } from './source-map.js';
 
 test('getSourceMapFilePath', () => {
-  expect(getSourceMapFilePath('/app/src/dir/1.css', undefined)).toBe('/app/src/dir/1.css.d.ts.map');
-  expect(getSourceMapFilePath('/app/src/dir/1.css', { rootDir: '/app', outDir: '/app/dist' })).toBe(
-    '/app/dist/src/dir/1.css.d.ts.map',
-  );
-  expect(() => getSourceMapFilePath('/tmp/src/dir/1.css', { rootDir: '/app', outDir: '/app/dist' })).toThrow();
-  expect(() => getSourceMapFilePath('/app/src/dir/1.css', { rootDir: '/app', outDir: '/tmp/dist' })).toThrow();
+  expect(getSourceMapFilePath('/app/src/dir/1.css')).toBe('/app/src/dir/1.css.d.ts.map');
 });
 
 test('generateSourceMappingURLComment', () => {

package/src/emitter/source-map.ts

@@ -1,15 +1,14 @@
 import { EOL } from 'os';
 import { getDtsFilePath } from './dts.js';
-import { type DistOptions, getRelativePath } from './index.js';
+import { getRelativePath } from './index.js';
 
 /**
  * Get .d.ts.map file path.
  * @param filePath The path to the source file (i.e. `foo.css`). It is absolute.
- * @param distOptions The distribution option.
  * @returns The path to the .d.ts.map file. It is absolute.
  */
-export function getSourceMapFilePath(filePath: string, distOptions: DistOptions | undefined): string {
-  return getDtsFilePath(filePath, distOptions) + '.map';
+export function getSourceMapFilePath(filePath: string): string {
+  return getDtsFilePath(filePath) + '.map';
 }
 
 export function generateSourceMappingURLComment(dtsFilePath: string, sourceMapFilePath: string): string {

package/src/index.ts

@@ -7,3 +7,4 @@ export {
   createDefaultTransformer,
 } from './transformer/index.js';
 export { type Resolver, type ResolverOptions, createDefaultResolver } from './resolver/index.js';
+export { Locator, type LocatorOptions, type LoadResult, type Token, type Location } from './locator/index.js';

package/src/integration-test/go-to-definition.test.ts

@@ -10,6 +10,7 @@ const defaultOptions = {
   silent: true,
   declarationMap: true,
   cwd: getFixturePath('/'),
+  cache: false,
 };
 
 afterAll(async () => {

package/src/{loader → locator}/index.test.ts

@@ -15,10 +15,10 @@ jest.unstable_mockModule('fs/promises', () => ({
 
 // After the mock of fs/promises is complete, . /index.js after the mock of fs/promises is complete.
 // ref: https://www.coolcomputerclub.com/posts/jest-hoist-await/
-const { Loader } = await import('./index.js');
+const { Locator } = await import('./index.js');
 // NOTE: ../test/util.js depends on . /index.js, so it must also be imported dynamically...
 
-const loader = new Loader();
+const locator = new Locator();
 
 afterEach(() => {
   readFileSpy.mockClear();
@@ -31,7 +31,7 @@ test('basic', async () => {
     .b {}
     `,
   });
-  const result = await loader.load(getFixturePath('/test/1.css'));
+  const result = await locator.load(getFixturePath('/test/1.css'));
   expect(result).toMatchInlineSnapshot(`
     {
       dependencies: [],
@@ -77,7 +77,7 @@ test('tracks other files when `@import` is present', async () => {
     .d {}
     `,
   });
-  const result = await loader.load(getFixturePath('/test/1.css'));
+  const result = await locator.load(getFixturePath('/test/1.css'));
   expect(result).toMatchInlineSnapshot(`
     {
       dependencies: [
@@ -137,7 +137,7 @@ test('tracks other files when `composes` is present', async () => {
     .e {}
     `,
   });
-  const result = await loader.load(getFixturePath('/test/1.css'));
+  const result = await locator.load(getFixturePath('/test/1.css'));
   expect(result).toMatchInlineSnapshot(`
     {
       dependencies: ["<fixtures>/test/2.css", "<fixtures>/test/3.css", "<fixtures>/test/4.css"],
@@ -201,7 +201,7 @@ test('normalizes tokens', async () => {
     .c {}
     `,
   });
-  const result = await loader.load(getFixturePath('/test/1.css'));
+  const result = await locator.load(getFixturePath('/test/1.css'));
   expect(result).toMatchInlineSnapshot(`
     {
       dependencies: ["<fixtures>/test/2.css", "<fixtures>/test/3.css"],
@@ -250,7 +250,7 @@ test.failing('returns the result from the cache when the file has not been modif
     .d {}
     `,
   });
-  await loader.load(getFixturePath('/test/1.css'));
+  await locator.load(getFixturePath('/test/1.css'));
   expect(readFileSpy).toHaveBeenCalledTimes(3);
   expect(readFileSpy).toHaveBeenNthCalledWith(1, '/test/1.css', 'utf-8');
   expect(readFileSpy).toHaveBeenNthCalledWith(2, '/test/2.css', 'utf-8');
@@ -262,17 +262,17 @@ test.failing('returns the result from the cache when the file has not been modif
   await writeFile(getFixturePath('/test/2.css'), await readFile(getFixturePath('/test/2.css'), 'utf-8'));
 
   // `3.css` is not updated, so the cache is used. Therefore, `readFile` is not called.
-  await loader.load(getFixturePath('/test/3.css'));
+  await locator.load(getFixturePath('/test/3.css'));
   expect(readFileSpy).toHaveBeenCalledTimes(0);
 
   // `1.css` is not updated, but dependencies are updated, so the cache is used. Therefore, `readFile` is called.
-  await loader.load(getFixturePath('/test/1.css'));
+  await locator.load(getFixturePath('/test/1.css'));
   expect(readFileSpy).toHaveBeenCalledTimes(2);
   expect(readFileSpy).toHaveBeenNthCalledWith(1, '/test/1.css', 'utf-8');
   expect(readFileSpy).toHaveBeenNthCalledWith(2, '/test/2.css', 'utf-8');
 
   // ``2.css` is updated, but the cache is already available because it was updated in the previous step. Therefore, `readFile` is not called.
-  await loader.load(getFixturePath('/test/2.css'));
+  await locator.load(getFixturePath('/test/2.css'));
   expect(readFileSpy).toHaveBeenCalledTimes(2);
 });
 
@@ -291,7 +291,7 @@ test('ignores the composition of non-existent tokens', async () => {
     .b {}
     `,
   });
-  const result = await loader.load(getFixturePath('/test/1.css'));
+  const result = await locator.load(getFixturePath('/test/1.css'));
   expect(result.tokens.map((t) => t.name)).toStrictEqual(['a', 'b']);
 });
 
@@ -306,7 +306,7 @@ test('throws error the composition of non-existent file', async () => {
     `,
   });
   await expect(async () => {
-    await loader.load(getFixturePath('/test/1.css')).catch((e) => {
+    await locator.load(getFixturePath('/test/1.css')).catch((e) => {
       e.message = e.message.replace(FIXTURE_DIR_PATH, '<fixtures>');
       throw e;
     });
@@ -316,7 +316,7 @@ test('throws error the composition of non-existent file', async () => {
 describe('supports sourcemap', () => {
   test('restores original locations from sourcemap', async () => {
     const transformer = createDefaultTransformer();
-    const loader = new Loader({ transformer });
+    const locator = new Locator({ transformer });
     createFixtures({
       '/test/1.scss': dedent`
       .nesting {
@@ -327,7 +327,7 @@ describe('supports sourcemap', () => {
       }
       `,
     });
-    const result = await loader.load(getFixturePath('/test/1.scss'));
+    const result = await locator.load(getFixturePath('/test/1.scss'));
     expect(result).toMatchInlineSnapshot(`
       {
         dependencies: [],
@@ -365,8 +365,8 @@ describe('supports sourcemap', () => {
       `,
     });
     const transformer = createDefaultTransformer({ postcssConfig: getFixturePath(`/${uuid}/postcss.config.js`) });
-    const loader = new Loader({ transformer });
-    const result = await loader.load(getFixturePath('/test/1.css'));
+    const locator = new Locator({ transformer });
+    const result = await locator.load(getFixturePath('/test/1.css'));
     expect(result).toMatchInlineSnapshot(`
       {
         dependencies: [],
@@ -398,6 +398,15 @@ test('ignores http(s) protocol file', async () => {
     @import 'https://example.com/path/https.css';
     `,
   });
-  const result = await loader.load(getFixturePath('/test/1.css'));
+  const result = await locator.load(getFixturePath('/test/1.css'));
   expect(result.dependencies).toStrictEqual([]);
 });
+
+test('block concurrent calls to load method', async () => {
+  createFixtures({
+    '/test/1.css': `.a {}`,
+  });
+  await expect(async () => {
+    await Promise.all([locator.load(getFixturePath('/test/1.css')), locator.load(getFixturePath('/test/1.css'))]);
+  }).rejects.toThrowError('Cannot call `Locator#load` concurrently.');
+});

package/src/{loader → locator}/index.ts

@@ -36,7 +36,7 @@ type CacheEntry = {
   result: LoadResult;
 };
 
-/** The result of `Loader#load`. */
+/** The result of `Locator#load`. */
 export type LoadResult = {
   /** The path of the file imported from the source file with `@import` or `composes`. */
   dependencies: string[];
@@ -60,7 +60,7 @@ function normalizeTokens(tokens: Token[]): Token[] {
   }));
 }
 
-export type LoaderOptions = {
+export type LocatorOptions = {
   /** The function to transform source code. */
   transformer?: Transformer | undefined;
   /** The function to resolve the path of the imported file. */
@@ -71,12 +71,13 @@ export type LoaderOptions = {
 export type StrictlyResolver = (...args: Parameters<Resolver>) => Promise<string>;
 
 /** This class collects information on tokens exported from CSS Modules files. */
-export class Loader {
+export class Locator {
   private readonly cache: Map<string, CacheEntry> = new Map();
   private readonly transformer: Transformer | undefined;
   private readonly resolver: StrictlyResolver;
+  private loading = false;
 
-  constructor(options?: LoaderOptions) {
+  constructor(options?: LocatorOptions) {
     this.transformer = options?.transformer ?? createDefaultTransformer();
     this.resolver = async (specifier, resolverOptions) => {
       const resolver = options?.resolver ?? createDefaultResolver();
@@ -137,8 +138,15 @@ export class Loader {
 
   /** Returns information about the tokens exported from the CSS Modules file. */
   async load(filePath: string): Promise<LoadResult> {
-    // NOTE: Loader does not support concurrent calls.
-    // TODO: Throw an error if called concurrently.
+    if (this.loading) throw new Error('Cannot call `Locator#load` concurrently.');
+    this.loading = true;
+    const result = await this._load(filePath).finally(() => {
+      this.loading = false;
+    });
+    return result;
+  }
+
+  private async _load(filePath: string): Promise<LoadResult> {
     if (!(await this.isCacheOutdated(filePath))) {
       const cacheEntry = this.cache.get(filePath)!;
       return cacheEntry.result;
@@ -164,7 +172,7 @@ export class Loader {
       if (!importedSheetPath) continue;
       if (isIgnoredSpecifier(importedSheetPath)) continue;
       const from = await this.resolver(importedSheetPath, { request: filePath });
-      const result = await this.load(from);
+      const result = await this._load(from);
       const externalTokens = result.tokens;
       dependencies.push(from, ...result.dependencies);
       tokens.push(...externalTokens);
@@ -190,7 +198,7 @@ export class Loader {
       if (!declarationDetail) continue;
       if (isIgnoredSpecifier(declarationDetail.from)) continue;
       const from = await this.resolver(declarationDetail.from, { request: filePath });
-      const result = await this.load(from);
+      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);