happy-css-modules 1.0.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "happy-css-modules",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Creates .d.ts files from CSS Modules .css files",
   "type": "module",
   "main": "dist/index.js",
@@ -30,14 +30,14 @@
     "@file-cache/core": "^1.1.3",
     "@file-cache/npm": "^1.1.3",
     "await-lock": "^2.2.2",
-    "camelcase": "^7.0.0",
+    "camelcase": "^7.0.1",
     "chalk": "^5.0.1",
     "chokidar": "^3.5.3",
     "enhanced-resolve": "^5.10.0",
     "glob": "^8.0.3",
     "import-meta-resolve": "^2.1.0",
-    "minimatch": "^5.1.0",
-    "postcss": "^8.4.17",
+    "minimatch": "^5.1.2",
+    "postcss": "^8.4.18",
     "postcss-load-config": "^4.0.1",
     "postcss-modules": "^4.3.1",
     "postcss-selector-parser": "^6.0.10",
@@ -50,8 +50,8 @@
     "@jest/types": "^29.0.3",
     "@mizdra/eslint-config-mizdra": "^1.2.0",
     "@mizdra/prettier-config-mizdra": "^1.0.0",
-    "@swc/core": "^1.3.8",
-    "@swc/jest": "^0.2.23",
+    "@swc/core": "^1.3.24",
+    "@swc/jest": "^0.2.24",
     "@types/dedent": "^0.7.0",
     "@types/glob": "^7.2.0",
     "@types/jest": "^29.0.0",
@@ -72,7 +72,7 @@
     "line-column": "^1.0.2",
     "npm-run-all": "^4.1.5",
     "postcss-import": "^15.0.0",
-    "postcss-simple-vars": "^7.0.0",
+    "postcss-simple-vars": "^7.0.1",
     "prettier": "~2.7.1",
     "sass": "^1.54.3",
     "tsc-watch": "^5.0.3",

package/src/cli.test.ts

@@ -65,8 +65,9 @@ describe('parseArgv', () => {
     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);
+  test('--logLevel', () => {
+    expect(parseArgv([...baseArgs, '1.css']).logLevel).toBe('info');
+    expect(parseArgv([...baseArgs, '1.css', '--logLevel', 'debug']).logLevel).toBe('debug');
+    expect(parseArgv([...baseArgs, '1.css', '--logLevel', 'silent']).logLevel).toBe('silent');
   });
 });

package/src/cli.ts

@@ -67,10 +67,10 @@ export function parseArgv(argv: string[]): RunnerOptions {
       default: 'content' as RunnerOptions['cacheStrategy'],
       describe: 'Strategy for the cache to use for detecting changed files.',
     })
-    .option('silent', {
-      type: 'boolean',
-      default: false,
-      describe: 'Silent output. Do not show "files written" messages',
+    .option('logLevel', {
+      choices: ['debug', 'info', 'silent'] as const,
+      default: 'info' as RunnerOptions['logLevel'],
+      describe: 'What level of logs to report.',
     })
     .alias('h', 'help')
     .alias('v', 'version')
@@ -108,6 +108,6 @@ export function parseArgv(argv: string[]): RunnerOptions {
     postcssConfig: parsedArgv.postcssConfig,
     cache: parsedArgv.cache,
     cacheStrategy: parsedArgv.cacheStrategy,
-    silent: parsedArgv.silent,
+    logLevel: parsedArgv.logLevel,
   };
 }

package/src/emitter/dts.test.ts

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { SourceMapConsumer } from 'source-map';
 import { Locator } from '../locator/index.js';
-import { getFixturePath, createFixtures } from '../test/util.js';
+import { getFixturePath, createFixtures } from '../test-util/util.js';
 import { generateDtsContentWithSourceMap, getDtsFilePath } from './dts.js';
 import { type DtsFormatOptions } from './index.js';
 

package/src/emitter/file-system.test.ts

@@ -1,5 +1,5 @@
 import { readFile, rm, stat } from 'fs/promises';
-import { createFixtures, getFixturePath } from '../test/util.js';
+import { createFixtures, getFixturePath } from '../test-util/util.js';
 import { writeFileIfChanged } from './file-system.js';
 
 const TEST_FILE_PATH = getFixturePath('/test.txt');

package/src/emitter/index.test.ts

@@ -1,6 +1,6 @@
 import { readFile, stat } from 'fs/promises';
 import { jest } from '@jest/globals';
-import { createFixtures, exists, fakeToken, getFixturePath, waitForAsyncTask } from '../test/util.js';
+import { createFixtures, exists, fakeToken, getFixturePath, waitForAsyncTask } from '../test-util/util.js';
 import { emitGeneratedFiles, getRelativePath, isSubDirectoryFile } from './index.js';
 
 // eslint-disable-next-line @typescript-eslint/no-empty-function

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

@@ -1,13 +1,14 @@
 import dedent from 'dedent';
+import type { RunnerOptions } from '../runner.js';
 import { run } from '../runner.js';
-import { createTSServer } from '../test/tsserver.js';
-import { createFixtures, getFixturePath } from '../test/util.js';
+import { createTSServer } from '../test-util/tsserver.js';
+import { createFixtures, getFixturePath } from '../test-util/util.js';
 
 const server = await createTSServer();
 
-const defaultOptions = {
+const defaultOptions: RunnerOptions = {
   pattern: 'test/**/*.{css,scss}',
-  silent: true,
+  logLevel: 'silent',
   declarationMap: true,
   cwd: getFixturePath('/'),
   cache: false,

package/src/locator/index.test.ts

@@ -3,7 +3,7 @@ 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 { createFixtures, FIXTURE_DIR_PATH, getFixturePath } from '../test-util/util.js';
 import { sleepSync } from '../util.js';
 
 const readFileSpy = jest.spyOn(fs, 'readFile');

package/src/locator/postcss.test.ts

@@ -5,7 +5,7 @@ import {
   createAtImports,
   createComposesDeclarations,
   createFixtures,
-} from '../test/util.js';
+} from '../test-util/util.js';
 import {
   generateLocalTokenNames,
   getOriginalLocation,

package/src/logger.ts

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+type LogLevelLabel = 'debug' | 'info' | 'silent';
+type LogLevel = 2 | 1 | 0;
+const LOG_LEVEL: Record<LogLevelLabel, LogLevel> = {
+  debug: 2,
+  info: 1,
+  silent: 0,
+};
+
+export class Logger {
+  private logLevel: LogLevel;
+  constructor(logLevelLabel: LogLevelLabel) {
+    this.logLevel = LOG_LEVEL[logLevelLabel];
+  }
+  debug(message: unknown) {
+    if (this.logLevel >= LOG_LEVEL['debug']) {
+      // eslint-disable-next-line no-console
+      console.log('[debug]', message);
+    }
+  }
+  info(message: unknown) {
+    if (this.logLevel >= LOG_LEVEL['info']) {
+      // eslint-disable-next-line no-console
+      console.log(chalk.blue('[info]'), message);
+    }
+  }
+  error(message: unknown) {
+    // eslint-disable-next-line no-console
+    console.error(chalk.red('[error]'), message);
+  }
+}

package/src/regression-test/issue-168.test.ts

@@ -0,0 +1,34 @@
+import { symlink } from 'fs/promises';
+import { jest } from '@jest/globals';
+import type { RunnerOptions, Watcher } from '../runner.js';
+import { run } from '../runner.js';
+import { createFixtures, getFixturePath, waitForAsyncTask } from '../test-util/util.js';
+
+const defaultOptions: RunnerOptions = {
+  pattern: 'test/**/*.css',
+  cwd: getFixturePath('/'),
+  cache: false,
+  logLevel: 'silent',
+};
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+// Exit the watcher even if the test fails
+let watcher: Watcher | undefined;
+afterEach(async () => {
+  if (watcher) {
+    await watcher.close();
+  }
+});
+
+it('issue-168', async () => {
+  createFixtures({
+    '/test/css-file.css': '.a {}',
+    '/test/non-css-file.txt': 'text file',
+  });
+  await symlink(getFixturePath('/test/non-css-file.txt'), getFixturePath('/test/symlink.txt'));
+  watcher = await run({ ...defaultOptions, watch: true });
+  await waitForAsyncTask(300); // Wait for initial code generation to complete
+  expect(consoleErrorSpy).not.toBeCalled(); // If an error is output, then failed
+});

package/src/resolver/index.test.ts

@@ -1,4 +1,4 @@
-import { createFixtures, getFixturePath } from '../test/util.js';
+import { createFixtures, getFixturePath } from '../test-util/util.js';
 import { createDefaultResolver } from './index.js';
 
 const defaultResolver = createDefaultResolver();

package/src/resolver/node-resolver.test.ts

@@ -1,4 +1,4 @@
-import { createFixtures, getFixturePath } from '../test/util.js';
+import { createFixtures, getFixturePath } from '../test-util/util.js';
 import { createNodeResolver } from './node-resolver.js';
 
 const nodeResolver = createNodeResolver();

package/src/resolver/relative-resolver.test.ts

@@ -1,4 +1,4 @@
-import { getFixturePath } from '../test/util.js';
+import { getFixturePath } from '../test-util/util.js';
 import { createRelativeResolver } from './relative-resolver.js';
 
 const relativeResolver = createRelativeResolver();

package/src/resolver/webpack-resolver.test.ts

@@ -1,4 +1,4 @@
-import { createFixtures, getFixturePath } from '../test/util.js';
+import { createFixtures, getFixturePath } from '../test-util/util.js';
 import { createWebpackResolver } from './webpack-resolver.js';
 
 test('resolves specifier with css-loader mechanism', async () => {

package/src/runner.test.ts

@@ -1,14 +1,13 @@
-import { readFile, rm, writeFile } from 'fs/promises';
+import { readFile, rm, symlink, writeFile } from 'fs/promises';
 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 { jest } from '@jest/globals';
-import chalk from 'chalk';
 import dedent from 'dedent';
-import type { Watcher } from './runner.js';
-import { createFixtures, exists, getFixturePath, waitForAsyncTask } from './test/util.js';
+import type { RunnerOptions, Watcher } from './runner.js';
+import { createFixtures, exists, getFixturePath, waitForAsyncTask } from './test-util/util.js';
 
 const require = createRequire(import.meta.url);
 
@@ -24,10 +23,10 @@ const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
 // eslint-disable-next-line @typescript-eslint/no-empty-function
 const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
 
-const defaultOptions = {
+const defaultOptions: RunnerOptions = {
   pattern: 'test/**/*.{css,scss}',
   declarationMap: true,
-  silent: true,
+  logLevel: 'silent',
   cwd: getFixturePath('/'),
   cache: false,
 };
@@ -60,47 +59,119 @@ test('generates .d.ts and .d.ts.map', async () => {
   expect(await readFile(getFixturePath('/test/2.css.d.ts.map'), 'utf8')).toMatchSnapshot();
 });
 
-test('uses cache', async () => {
+test('uses cache in non-watch mode', async () => {
   createFixtures({
     '/test/1.css': '.a {}',
   });
-  await run({ ...defaultOptions, declarationMap: true, silent: false, cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(1);
-  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.stringContaining('generated'));
+  await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true });
+  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('generated'));
   consoleLogSpy.mockClear();
 
   // Skip generation
-  await run({ ...defaultOptions, declarationMap: true, silent: false, cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(1);
-  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.stringContaining('skipped'));
+  await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true });
+  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('skipped'));
   consoleLogSpy.mockClear();
 
   // Generates if generated files are missing
   await rm(getFixturePath('/test/1.css.d.ts'));
-  await run({ ...defaultOptions, declarationMap: true, silent: false, cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(1);
-  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.stringContaining('generated'));
+  await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true });
+  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('generated'));
   consoleLogSpy.mockClear();
 
   // Generates if options are changed
-  await run({ ...defaultOptions, declarationMap: false, silent: false, cache: true });
+  await run({ ...defaultOptions, declarationMap: false, logLevel: 'debug', cache: true });
+  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('generated'));
+  consoleLogSpy.mockClear();
+});
+
+test('uses cache in watch mode', async () => {
+  createFixtures({
+    '/test/1.css': '.a-1 {}',
+    '/test/2.css': '.b-1 {}',
+  });
+
+  // At first, process all files
+  watcher = await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true, watch: true });
+  await waitForAsyncTask(1000); // Wait until the watcher is ready
+  expect(consoleLogSpy).toBeCalledTimes(3);
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(
+    1,
+    expect.anything(),
+    expect.stringContaining('Watch test/**/*.{css,scss}...'),
+  );
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(
+    2,
+    expect.anything(),
+    expect.stringContaining('test/1.css (generated)'),
+  );
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(
+    3,
+    expect.anything(),
+    expect.stringContaining('test/2.css (generated)'),
+  );
+  consoleLogSpy.mockClear();
+
+  // Updating 1.css, it will only be processed
+  await writeFile(getFixturePath('/test/1.css'), '.a-2 {}');
+  await waitForAsyncTask(500); // Wait until the file is written
   expect(consoleLogSpy).toBeCalledTimes(1);
-  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.stringContaining('generated'));
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(
+    1,
+    expect.anything(),
+    expect.stringContaining('test/1.css (generated)'),
+  );
+
+  // Close the watcher
+  await watcher.close();
   consoleLogSpy.mockClear();
+
+  // Update 1.css
+  await writeFile(getFixturePath('/test/1.css'), '.a-1 {}');
+  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.
+  watcher = await run({ ...defaultOptions, declarationMap: true, logLevel: 'debug', cache: true, watch: true });
+  await waitForAsyncTask(1000); // Wait until the watcher is ready
+  expect(consoleLogSpy).toBeCalledTimes(3);
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(
+    1,
+    expect.anything(),
+    expect.stringContaining('Watch test/**/*.{css,scss}...'),
+  );
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(
+    2,
+    expect.anything(),
+    expect.stringContaining('test/1.css (generated)'),
+  );
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(3, expect.anything(), expect.stringContaining('test/2.css (skipped)'));
 });
 
 test('outputs logs', async () => {
   createFixtures({
     '/test/1.css': '.a {}',
   });
-  await run({ ...defaultOptions, silent: false, cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(1);
-  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, `${chalk.green('test/1.css')} (generated)`);
+  await run({ ...defaultOptions, logLevel: 'debug', cache: true });
+  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(
+    2,
+    expect.anything(),
+    expect.stringContaining('test/1.css (generated)'),
+  );
   consoleLogSpy.mockClear();
 
-  await run({ ...defaultOptions, silent: false, cache: true });
-  expect(consoleLogSpy).toBeCalledTimes(1);
-  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, `${chalk.gray('test/1.css (skipped)')}`);
+  await run({ ...defaultOptions, logLevel: 'debug', cache: true });
+  expect(consoleLogSpy).toBeCalledTimes(2);
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(1, expect.anything(), expect.stringContaining('Generate .d.ts for'));
+  expect(consoleLogSpy).toHaveBeenNthCalledWith(2, expect.anything(), expect.stringContaining('test/1.css (skipped)'));
 });
 
 test.todo('changes dts format with localsConvention options');
@@ -156,13 +227,6 @@ test('returns an error if the file fails to process in non-watch mode', async ()
   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`);
 
-  // The error is logged to console.error.
-  expect(consoleErrorSpy).toHaveBeenCalledTimes(2);
-  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-  expect(consoleErrorSpy).toHaveBeenNthCalledWith(1, chalk.red('[Error] ' + error.errors[0]!.stack));
-  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-  expect(consoleErrorSpy).toHaveBeenNthCalledWith(2, chalk.red('[Error] ' + error.errors[1].stack));
-
   // The valid files are emitted.
   expect(await exists(getFixturePath('/test/1.css.d.ts'))).toBe(true);
   expect(await exists(getFixturePath('/test/1.css.d.ts.map'))).toBe(true);
@@ -251,3 +315,33 @@ test('postcssConfig', async () => {
   });
   await run({ ...defaultOptions, postcssConfig }); // not throw
 });
+
+test('support symlink', async () => {
+  createFixtures({
+    '/external/1.css': '.a {}',
+    '/external/2.css': '.b {}',
+    '/test': {}, // empty directory
+  });
+  await symlink(getFixturePath('/external/1.css'), getFixturePath('/test/1.css'));
+  await symlink(getFixturePath('/external/2.css'), getFixturePath('/test/2.txt'));
+
+  await run({ ...defaultOptions, watch: false });
+
+  // Symlinks that do not match the pattern are not processed.
+  expect(await exists(getFixturePath('/test/1.css.d.ts'))).toBe(true);
+  expect(await exists(getFixturePath('/test/2.css.d.ts'))).toBe(false);
+  expect(await exists(getFixturePath('/test/2.txt.d.ts'))).toBe(false);
+
+  // The path referred to by sourceMappingURL or sources field is the path before symlink resolution.
+  expect(await readFile(getFixturePath('/test/1.css.d.ts'), 'utf8')).toMatchInlineSnapshot(`
+    "declare const styles:
+      & Readonly<{ "a": string }>
+    ;
+    export default styles;
+    //# sourceMappingURL=./1.css.d.ts.map
+    "
+  `);
+  expect(await readFile(getFixturePath('/test/1.css.d.ts.map'), 'utf8')).toMatchInlineSnapshot(
+    `"{"version":3,"sources":["./1.css"],"names":["a"],"mappings":"AAAA;AAAA,E,aAAAA,G,WAAA;AAAA;AAAA","file":"1.css.d.ts","sourceRoot":""}"`,
+  );
+});

package/src/runner.ts

@@ -9,6 +9,7 @@ import * as chokidar from 'chokidar';
 import _glob from 'glob';
 import { isGeneratedFilesExist, emitGeneratedFiles } from './emitter/index.js';
 import { Locator } from './locator/index.js';
+import { Logger } from './logger.js';
 import type { Resolver } from './resolver/index.js';
 import { createDefaultResolver } from './resolver/index.js';
 import { createDefaultTransformer, type Transformer } from './transformer/index.js';
@@ -65,10 +66,10 @@ export interface RunnerOptions {
    */
   cacheStrategy?: 'content' | 'metadata' | undefined;
   /**
-   * Silent output. Do not show "files written" messages.
-   * @default false
+   * What level of logs to report.
+   * @default 'info'
    */
-  silent?: boolean | undefined;
+  logLevel?: 'debug' | 'info' | 'silent' | undefined;
   /** Working directory path. */
   cwd?: string | undefined;
 }
@@ -84,9 +85,9 @@ export async function run(options: OverrideProp<RunnerOptions, 'watch', true>):
 export async function run(options: RunnerOptions): Promise<void>;
 export async function run(options: RunnerOptions): Promise<Watcher | void> {
   const lock = new AwaitLock.default();
+  const logger = new Logger(options.logLevel ?? 'info');
 
   const cwd = options.cwd ?? process.cwd();
-  const silent = options.silent ?? false;
   const resolver =
     options.resolver ??
     createDefaultResolver({
@@ -115,9 +116,24 @@ 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);
+      if (result.error) throw result.error;
+      return result.changed;
+    }
+
+    // Locator#load cannot be called concurrently. Therefore, it takes a lock and waits.
+    await lock.acquireAsync();
+
     try {
-      // Locator#load cannot be called concurrently. Therefore, it takes a lock and waits.
-      await lock.acquireAsync();
+      const _isGeneratedFilesExist = await isGeneratedFilesExist(filePath, options.declarationMap);
+      const _isChangedFile = await isChangedFile(filePath);
+      // Generate .d.ts and .d.ts.map only when the file has been updated.
+      // However, if .d.ts or .d.ts.map has not yet been generated, always generate.
+      if (_isGeneratedFilesExist && !_isChangedFile) {
+        logger.debug(chalk.gray(`${relative(cwd, filePath)} (skipped)`));
+        return;
+      }
 
       const result = await locator.load(filePath);
       await emitGeneratedFiles({
@@ -129,62 +145,52 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
         },
         isExternalFile,
       });
-      if (!silent) console.log(`${chalk.green(relative(cwd, filePath))} (generated)`);
-    } catch (error) {
-      if (error instanceof Error) {
-        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-        console.error(chalk.red('[Error] ' + error.stack));
-      } else {
-        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-        console.error(chalk.red('[Error] ' + error));
-      }
-      throw error;
+      logger.info(chalk.green(`${relative(cwd, filePath)} (generated)`));
+
+      await cache.reconcile(); // Update cache for the file
     } finally {
       lock.release();
     }
   }
 
-  async function isChangedFile(filePath: string) {
-    const result = await cache.getAndUpdateCache(filePath);
-    if (result.error) throw result.error;
-    return result.changed;
-  }
-
-  if (options.watch) {
-    if (!silent) console.log('Watch ' + options.pattern + '...');
-    const watcher = chokidar.watch([options.pattern.replace(/\\/g, '/')], { cwd });
-    watcher.on('all', (eventName, filePath) => {
-      if (eventName === 'add' || eventName === 'change') {
-        processFile(resolve(cwd, filePath)).catch(() => {
-          // TODO: Emit a error by `Watcher#onerror`
-        });
-      }
-    });
-    return { close: async () => watcher.close() };
-  } else {
+  async function processAllFiles() {
     const filePaths = (await glob(options.pattern, { dot: true, cwd }))
       // convert relative path to absolute path
       .map((file) => resolve(cwd, file));
 
     const errors: unknown[] = [];
     for (const filePath of filePaths) {
-      try {
-        const _isGeneratedFilesExist = await isGeneratedFilesExist(filePath, options.declarationMap);
-        const _isChangedFile = await isChangedFile(filePath);
-        // Generate .d.ts and .d.ts.map only when the file has been updated.
-        // However, if .d.ts or .d.ts.map has not yet been generated, always generate.
-        if (!_isGeneratedFilesExist || _isChangedFile) {
-          await processFile(filePath);
-        } else {
-          if (!silent) console.log(chalk.gray(`${relative(cwd, filePath)} (skipped)`));
-        }
-      } catch (e: unknown) {
-        errors.push(e);
-      }
+      await processFile(filePath).catch((e) => errors.push(e));
+    }
+
+    if (errors.length > 0) {
+      throw new AggregateError(errors, 'Failed to process files');
     }
-    if (errors.length > 0) throw new AggregateError(errors, 'Failed to process files');
   }
 
-  // Write cache state to file for persistence
-  await cache.reconcile();
+  if (!options.watch) {
+    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 });
+    watcher.on('all', (eventName, relativeFilePath) => {
+      const filePath = resolve(cwd, relativeFilePath);
+
+      // There is a bug in chokidar that matches symlinks that do not match the pattern.
+      // ref: https://github.com/paulmillr/chokidar/issues/967
+      if (isExternalFile(filePath)) return;
+
+      if (eventName !== 'add' && eventName !== 'change') return;
+
+      processFile(filePath).catch((e) => {
+        logger.error(e);
+        // TODO: Emit a error by `Watcher#onerror`
+      });
+    });
+
+    return { close: async () => watcher.close() };
+  }
 }

package/src/transformer/index.test.ts

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import dedent from 'dedent';
 import { Locator } from '../locator/index.js';
-import { createFixtures, getFixturePath } from '../test/util.js';
+import { createFixtures, getFixturePath } from '../test-util/util.js';
 import { createDefaultTransformer } from './index.js';
 
 const require = createRequire(import.meta.url);

package/src/transformer/index.ts

@@ -33,9 +33,9 @@ export type TransformerOptions = {
 /** The function to transform source code. */
 export type Transformer = (source: string, options: TransformerOptions) => TransformResult | Promise<TransformResult>;
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO: pass `e` to Error's cause option
 export const handleImportError = (packageName: string) => (e: unknown) => {
-  console.error(`${packageName} import failed. Did you forget to \`npm install -D ${packageName}\`?`);
-  throw e;
+  throw new Error(`${packageName} import failed. Did you forget to \`npm install -D ${packageName}\`?`);
 };
 
 export type DefaultTransformerOptions = PostcssTransformerOptions;

package/src/transformer/less-transformer.test.ts

@@ -1,7 +1,7 @@
 import { jest } from '@jest/globals';
 import dedent from 'dedent';
 import { Locator } from '../locator/index.js';
-import { createFixtures, getFixturePath } from '../test/util.js';
+import { createFixtures, getFixturePath } from '../test-util/util.js';
 import { createLessTransformer } from './less-transformer.js';
 
 const locator = new Locator({ transformer: createLessTransformer() });