happy-css-modules 1.0.1 → 2.1.0

package/src/emitter/dts.test.ts

@@ -9,7 +9,10 @@ const locator = new Locator();
 const isExternalFile = () => false;
 
 test('getDtsFilePath', () => {
-  expect(getDtsFilePath('/app/src/dir/1.css')).toBe('/app/src/dir/1.css.d.ts');
+  expect(getDtsFilePath('/app/src/dir/1.css', false)).toBe('/app/src/dir/1.css.d.ts');
+  expect(getDtsFilePath('/app/src/dir/1.scss', false)).toBe('/app/src/dir/1.scss.d.ts');
+  expect(getDtsFilePath('/app/src/dir/1.css', true)).toBe('/app/src/dir/1.d.css.ts');
+  expect(getDtsFilePath('/app/src/dir/1.scss', true)).toBe('/app/src/dir/1.d.scss.ts');
 });
 
 describe('generateDtsContentWithSourceMap', () => {

package/src/emitter/dts.ts

@@ -1,5 +1,5 @@
 import { EOL } from 'os';
-import { basename } from 'path';
+import { basename, parse, join } from 'path';
 import camelcase from 'camelcase';
 import { SourceNode, type CodeWithSourceMap } from '../library/source-map/index.js';
 import { type Token } from '../locator/index.js';
@@ -9,10 +9,16 @@ 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 arbitraryExtensions Generate `.d.css.ts` instead of `.css.d.ts`.
  * @returns The path to the .d.ts file. It is absolute.
  */
-export function getDtsFilePath(filePath: string): string {
-  return filePath + '.d.ts';
+export function getDtsFilePath(filePath: string, arbitraryExtensions: boolean): string {
+  if (arbitraryExtensions) {
+    const { dir, name, ext } = parse(filePath);
+    return join(dir, name + '.d' + ext + '.ts');
+  } else {
+    return filePath + '.d.ts';
+  }
 }
 
 function dashesCamelCase(str: string): string {

package/src/emitter/index.ts

@@ -1,4 +1,5 @@
 import { dirname, isAbsolute, relative } from 'path';
+import { DEFAULT_ARBITRARY_EXTENSIONS } from '../config.js';
 import { type Token } from '../locator/index.js';
 import { type LocalsConvention } from '../runner.js';
 import { exists } from '../util.js';
@@ -20,7 +21,16 @@ export function isSubDirectoryFile(fromDirectory: string, toFilePath: string): b
 }
 
 export type DtsFormatOptions = {
+  /**
+   * Style of exported class names.
+   * @default undefined
+   */
   localsConvention?: LocalsConvention;
+  /**
+   * Generate `.d.css.ts` instead of `.css.d.ts`.
+   * @default false
+   */
+  arbitraryExtensions?: boolean | undefined;
 };
 
 /** The options for emitter. */
@@ -44,8 +54,9 @@ export async function emitGeneratedFiles({
   dtsFormatOptions,
   isExternalFile,
 }: EmitterOptions): Promise<void> {
-  const dtsFilePath = getDtsFilePath(filePath);
-  const sourceMapFilePath = getSourceMapFilePath(filePath);
+  const arbitraryExtensions = dtsFormatOptions?.arbitraryExtensions ?? DEFAULT_ARBITRARY_EXTENSIONS;
+  const dtsFilePath = getDtsFilePath(filePath, arbitraryExtensions);
+  const sourceMapFilePath = getSourceMapFilePath(filePath, arbitraryExtensions);
   const { dtsContent, sourceMap } = generateDtsContentWithSourceMap(
     filePath,
     dtsFilePath,
@@ -72,9 +83,10 @@ export async function emitGeneratedFiles({
 export async function isGeneratedFilesExist(
   filePath: string,
   emitDeclarationMap: boolean | undefined,
+  arbitraryExtensions: boolean,
 ): Promise<boolean> {
-  const dtsFilePath = getDtsFilePath(filePath);
-  const sourceMapFilePath = getSourceMapFilePath(filePath);
+  const dtsFilePath = getDtsFilePath(filePath, arbitraryExtensions);
+  const sourceMapFilePath = getSourceMapFilePath(filePath, arbitraryExtensions);
   if (emitDeclarationMap && !(await exists(sourceMapFilePath))) {
     return false;
   }

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

@@ -2,7 +2,10 @@ import { EOL } from 'os';
 import { getSourceMapFilePath, generateSourceMappingURLComment } from './source-map.js';
 
 test('getSourceMapFilePath', () => {
-  expect(getSourceMapFilePath('/app/src/dir/1.css')).toBe('/app/src/dir/1.css.d.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.css', false)).toBe('/app/src/dir/1.css.d.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.scss', false)).toBe('/app/src/dir/1.scss.d.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.css', true)).toBe('/app/src/dir/1.d.css.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.scss', true)).toBe('/app/src/dir/1.d.scss.ts.map');
 });
 
 test('generateSourceMappingURLComment', () => {

package/src/emitter/source-map.ts

@@ -5,10 +5,11 @@ 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 arbitraryExtensions Generate `.d.css.ts` instead of `.css.d.ts`.
  * @returns The path to the .d.ts.map file. It is absolute.
  */
-export function getSourceMapFilePath(filePath: string): string {
-  return getDtsFilePath(filePath) + '.map';
+export function getSourceMapFilePath(filePath: string, arbitraryExtensions: boolean): string {
+  return getDtsFilePath(filePath, arbitraryExtensions) + '.map';
 }
 
 export function generateSourceMappingURLComment(dtsFilePath: string, sourceMapFilePath: string): string {

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-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/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

@@ -8,7 +8,7 @@ const defaultOptions: RunnerOptions = {
   pattern: 'test/**/*.css',
   cwd: getFixturePath('/'),
   cache: false,
-  silent: true,
+  logLevel: 'silent',
 };
 
 // eslint-disable-next-line @typescript-eslint/no-empty-function

package/src/runner.test.ts

@@ -5,9 +5,8 @@ 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 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);

package/src/runner.ts

@@ -7,8 +7,10 @@ import AwaitLock from 'await-lock';
 import chalk from 'chalk';
 import * as chokidar from 'chokidar';
 import _glob from 'glob';
+import { DEFAULT_ARBITRARY_EXTENSIONS } from './config.js';
 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';
@@ -25,6 +27,10 @@ export type LocalsConvention = 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashe
 export interface RunnerOptions {
   pattern: string;
   watch?: boolean | undefined;
+  /**
+   * Style of exported class names.
+   * @default undefined
+   */
   localsConvention?: LocalsConvention | undefined;
   declarationMap?: boolean | undefined;
   transformer?: Transformer | undefined;
@@ -54,6 +60,11 @@ export interface RunnerOptions {
    * @example '/home/user/repository/src'
    */
   postcssConfig?: string | undefined;
+  /**
+   * Generate `.d.css.ts` instead of `.css.d.ts`.
+   * @default false
+   */
+  arbitraryExtensions?: boolean | undefined;
   /**
    * Only generate .d.ts and .d.ts.map for changed files.
    * @default true
@@ -65,10 +76,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 +95,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 +126,28 @@ 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,
+        options.arbitraryExtensions ?? DEFAULT_ARBITRARY_EXTENSIONS,
+      );
+      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({
@@ -126,32 +156,40 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
         emitDeclarationMap: options.declarationMap,
         dtsFormatOptions: {
           localsConvention: options.localsConvention,
+          arbitraryExtensions: options.arbitraryExtensions,
         },
         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;
+  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) {
+      await processFile(filePath).catch((e) => errors.push(e));
+    }
+
+    if (errors.length > 0) {
+      throw new AggregateError(errors, 'Failed to process files');
+    }
   }
 
-  if (options.watch) {
-    if (!silent) console.log('Watch ' + options.pattern + '...');
+  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);
@@ -162,35 +200,12 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
 
       if (eventName !== 'add' && eventName !== 'change') return;
 
-      processFile(filePath).catch(() => {
+      processFile(filePath).catch((e) => {
+        logger.error(e);
         // TODO: Emit a error by `Watcher#onerror`
       });
     });
-    return { close: async () => watcher.close() };
-  } else {
-    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);
-      }
-    }
-    if (errors.length > 0) throw new AggregateError(errors, 'Failed to process files');
+    return { close: async () => watcher.close() };
   }
-
-  // Write cache state to file for persistence
-  await cache.reconcile();
 }

package/src/test-util/tsserver.ts

@@ -7,9 +7,8 @@ import serverHarness from '@typescript/server-harness';
 import _glob from 'glob';
 import { resolve } from 'import-meta-resolve';
 import lineColumn from 'line-column';
-import type { UpdateOpenRequest, DefinitionResponse, DefinitionRequest } from 'typescript/lib/protocol.js';
+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> {
@@ -68,7 +67,7 @@ export async function createTSServer() {
       const results: { identifier: string; definitions: Definition[] }[] = [];
 
       for (let i = 0; i < identifiers.length; i++) {
-        const response: DefinitionResponse = await server.message({
+        const response: server.protocol.DefinitionResponse = await server.message({
           seq: 0,
           type: 'request',
           command: 'definition',
@@ -77,7 +76,7 @@ export async function createTSServer() {
             line: i + 2, // line, 1-based
             offset: 8, // column, 1-based
           },
-        } as DefinitionRequest);
+        } as server.protocol.DefinitionRequest);
         const definitions: Definition[] = response.body!.map((definition) => {
           const { file, start, end } = definition;
           const fileContent = readFileSync(file, 'utf-8');
@@ -100,7 +99,7 @@ export async function createTSServer() {
 
       await this.refreshCache();
 
-      const response: DefinitionResponse = await server.message({
+      const response: server.protocol.DefinitionResponse = await server.message({
         seq: 0,
         type: 'request',
         command: 'definition',
@@ -109,7 +108,7 @@ export async function createTSServer() {
           line: 1, // line, 1-based
           offset: 20, // column, 1-based
         },
-      } as DefinitionRequest);
+      } as server.protocol.DefinitionRequest);
       const definitions: Definition[] = response.body!.map((definition) => {
         const { file, start, end } = definition;
         const fileContent = readFileSync(file, 'utf-8');
@@ -127,12 +126,14 @@ export async function createTSServer() {
 
       const fixtureFilePaths = await glob(getFixturePath('/**/*.ts'), { dot: true });
       // latest contents
-      const openFiles: UpdateOpenRequest['arguments']['openFiles'] = fixtureFilePaths.map((filePath) => ({
-        file: filePath,
-        fileContent: readFileSync(filePath, 'utf-8'),
-        projectRootPath: getFixturePath('/server-harness'),
-        scriptKindName: 'TS', // It's easy to get this wrong when copy-pasting
-      }));
+      const openFiles: server.protocol.UpdateOpenRequest['arguments']['openFiles'] = fixtureFilePaths.map(
+        (filePath) => ({
+          file: filePath,
+          fileContent: readFileSync(filePath, 'utf-8'),
+          projectRootPath: getFixturePath('/server-harness'),
+          scriptKindName: 'TS', // It's easy to get this wrong when copy-pasting
+        }),
+      );
 
       // override the cache
       await server.message({
@@ -144,7 +145,7 @@ export async function createTSServer() {
           closedFiles: [],
           openFiles,
         },
-      } as UpdateOpenRequest);
+      } as server.protocol.UpdateOpenRequest);
     },
     exit: async () => {
       await server.message({ command: 'exit' });

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/postcss-transformer.ts

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import { resolve } from 'node:path';
-import { default as postcss, type Message } from 'postcss';
+import postcss, { type Message } from 'postcss';
 import type { Result } from 'postcss-load-config';
 import type { Transformer } from '../index.js';
 
@@ -44,7 +44,7 @@ export const createPostcssTransformer: (postcssTransformerOptions?: PostcssTrans
     });
     if (postcssConfig === undefined) return false;
 
-    const result = await postcss(postcssConfig.plugins).process(source, {
+    const result = await postcss.default(postcssConfig.plugins).process(source, {
       ...postcssConfig.options,
       from: options.from,
       map: { inline: false, absolute: true },