happy-css-modules 0.4.0 → 0.6.0

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 {
@@ -65,7 +56,16 @@ function generateTokenDeclarations(
     // This is due to the sourcemap specification. Therefore, we output multiple type definitions
     // with the same name and assign a separate original position to each.
 
-    for (const originalLocation of token.originalLocations) {
+    for (let originalLocation of token.originalLocations) {
+      if (originalLocation.filePath === undefined) {
+        // If the original location is not specified, fallback to the source file.
+        originalLocation = {
+          filePath: filePath,
+          start: { line: 1, column: 1 },
+          end: { line: 1, column: 1 },
+        };
+      }
+
       result.push(
         originalLocation.filePath === filePath || isExternalFile(originalLocation.filePath)
           ? new SourceNode(null, null, null, [

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

@@ -1,3 +1,10 @@
 export { parseArgv } from './cli.js';
-export { run } from './runner.js';
-export { type Transformer } from './transformer/index.js';
+export { run, type LocalsConvention } from './runner.js';
+export {
+  type Transformer,
+  type TransformerOptions,
+  type TransformResult,
+  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

@@ -1,6 +1,8 @@
 import fs, { readFile, writeFile } from 'fs/promises';
+import { randomUUID } from 'node:crypto';
 import { jest } from '@jest/globals';
 import dedent from 'dedent';
+import { createDefaultTransformer } from '../index.js';
 import { createFixtures, FIXTURE_DIR_PATH, getFixturePath } from '../test/util.js';
 import { sleepSync } from '../util.js';
 
@@ -13,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();
@@ -29,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: [],
@@ -75,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: [
@@ -135,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"],
@@ -199,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"],
@@ -248,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');
@@ -260,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);
 });
 
@@ -289,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']);
 });
 
@@ -304,14 +306,90 @@ 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;
     });
   }).rejects.toThrowError(`Could not resolve './2.css' in '<fixtures>/test/1.css'`);
 });
 
-test.todo('supports sourcemap file and inline sourcemap');
+describe('supports sourcemap', () => {
+  test('restores original locations from sourcemap', async () => {
+    const transformer = createDefaultTransformer();
+    const locator = new Locator({ transformer });
+    createFixtures({
+      '/test/1.scss': dedent`
+      .nesting {
+        dummy: '';
+        .nesting_child {
+          dummy: '';
+        }
+      }
+      `,
+    });
+    const result = await locator.load(getFixturePath('/test/1.scss'));
+    expect(result).toMatchInlineSnapshot(`
+      {
+        dependencies: [],
+        tokens: [
+          {
+            name: "nesting",
+            originalLocations: [
+              { filePath: "<fixtures>/test/1.scss", start: { line: 1, column: 1 }, end: { line: 1, column: 8 } },
+              { filePath: "<fixtures>/test/1.scss", start: { line: 3, column: 3 }, end: { line: 3, column: 10 } },
+            ],
+          },
+          {
+            name: "nesting_child",
+            originalLocations: [
+              { filePath: "<fixtures>/test/1.scss", start: { line: 3, column: 3 }, end: { line: 3, column: 16 } },
+            ],
+          },
+        ],
+      }
+    `);
+  });
+  test('treats originalLocation as empty if sourcemap is broken', async () => {
+    const uuid = randomUUID();
+    createFixtures({
+      [`/${uuid}/postcss.config.js`]: dedent`
+      module.exports = {
+        plugins: [],
+      };
+      `,
+      '/test/1.css': dedent`
+      .selector_list_a_1, .selector_list_a_2 {}
+      /* In postcss, including newlines in the selector list breaks the sourcemap. */
+      .selector_list_b_1,
+      .selector_list_b_2 {}
+      `,
+    });
+    const transformer = createDefaultTransformer({ postcssConfig: getFixturePath(`/${uuid}/postcss.config.js`) });
+    const locator = new Locator({ transformer });
+    const result = await locator.load(getFixturePath('/test/1.css'));
+    expect(result).toMatchInlineSnapshot(`
+      {
+        dependencies: [],
+        tokens: [
+          {
+            name: "selector_list_a_1",
+            originalLocations: [
+              { filePath: "<fixtures>/test/1.css", start: { line: 1, column: 1 }, end: { line: 1, column: 18 } },
+            ],
+          },
+          {
+            name: "selector_list_a_2",
+            originalLocations: [
+              { filePath: "<fixtures>/test/1.css", start: { line: 1, column: 1 }, end: { line: 1, column: 18 } },
+            ],
+          },
+          { name: "selector_list_b_1", originalLocations: [{}] },
+          { name: "selector_list_b_2", originalLocations: [{}] },
+        ],
+      }
+    `);
+  });
+});
 
 test('ignores http(s) protocol file', async () => {
   createFixtures({
@@ -320,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);