@css-modules-kit/codegen 0.6.0 → 0.7.0

package/src/runner.ts

@@ -1,61 +1,18 @@
-import { readFile, rm } from 'node:fs/promises';
-import type {
-  CMKConfig,
-  CSSModule,
-  Diagnostic,
-  DiagnosticWithLocation,
-  MatchesPattern,
-  ParseCSSModuleResult,
-  Resolver,
-} from '@css-modules-kit/core';
-import {
-  checkCSSModule,
-  createDts,
-  createExportBuilder,
-  createMatchesPattern,
-  createResolver,
-  getFileNamesByPattern,
-  parseCSSModule,
-  readConfigFile,
-} from '@css-modules-kit/core';
-import ts from 'typescript';
-import type { ParsedArgs } from './cli.js';
-import { writeDtsFile } from './dts-writer.js';
-import { ReadCSSModuleFileError } from './error.js';
+import type { Stats } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import chokidar, { type FSWatcher } from 'chokidar';
 import type { Logger } from './logger/logger.js';
+import { createProject, type Project } from './project.js';
 
-/**
- * @throws {ReadCSSModuleFileError} When failed to read CSS Module file.
- */
-async function parseCSSModuleByFileName(fileName: string, config: CMKConfig): Promise<ParseCSSModuleResult> {
-  let text: string;
-  try {
-    text = await readFile(fileName, 'utf-8');
-  } catch (error) {
-    throw new ReadCSSModuleFileError(fileName, error);
-  }
-  return parseCSSModule(text, { fileName, safe: false, keyframes: config.keyframes });
+interface RunnerArgs {
+  project: string;
+  clean: boolean;
 }
 
-/**
- * @throws {WriteDtsFileError}
- */
-async function writeDtsByCSSModule(
-  cssModule: CSSModule,
-  { dtsOutDir, basePath, arbitraryExtensions, namedExports, prioritizeNamedImports }: CMKConfig,
-  resolver: Resolver,
-  matchesPattern: MatchesPattern,
-): Promise<void> {
-  const dts = createDts(
-    cssModule,
-    { resolver, matchesPattern },
-    { namedExports, prioritizeNamedImports, forTsPlugin: false },
-  );
-  await writeDtsFile(dts.text, cssModule.fileName, {
-    outDir: dtsOutDir,
-    basePath,
-    arbitraryExtensions,
-  });
+export interface Watcher {
+  /** Exported for testing purposes */
+  project: Project;
+  close(): Promise<void>;
 }
 
 /**
@@ -63,70 +20,144 @@ async function writeDtsByCSSModule(
  * @param project The absolute path to the project directory or the path to `tsconfig.json`.
  * @throws {ReadCSSModuleFileError} When failed to read CSS Module file.
  * @throws {WriteDtsFileError}
+ * @returns Whether the process succeeded without errors.
  */
-export async function runCMK(args: ParsedArgs, logger: Logger): Promise<void> {
-  const config = readConfigFile(args.project);
-  if (config.diagnostics.length > 0) {
-    logger.logDiagnostics(config.diagnostics);
-    // eslint-disable-next-line n/no-process-exit
-    process.exit(1);
+export async function runCMK(args: RunnerArgs, logger: Logger): Promise<boolean> {
+  const project = createProject(args);
+  if (args.clean) {
+    await rm(project.config.dtsOutDir, { recursive: true, force: true });
   }
+  await project.emitDtsFiles();
+  const diagnostics = project.getDiagnostics();
+  if (diagnostics.length > 0) {
+    logger.logDiagnostics(diagnostics);
+    return false;
+  }
+  return true;
+}
 
-  const getCanonicalFileName = (fileName: string) =>
-    ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
-  const moduleResolutionCache = ts.createModuleResolutionCache(
-    config.basePath,
-    getCanonicalFileName,
-    config.compilerOptions,
-  );
-  const resolver = createResolver(config.compilerOptions, moduleResolutionCache);
-  const matchesPattern = createMatchesPattern(config);
-
-  const cssModuleMap = new Map<string, CSSModule>();
-  const syntacticDiagnostics: DiagnosticWithLocation[] = [];
+/**
+ * Run css-modules-kit .d.ts generation in watch mode.
+ *
+ * The promise resolves when the initial diagnostics report, emit, and watcher initialization are complete.
+ * Errors are reported through the logger.
+ *
+ * NOTE: For implementation simplicity, config file changes are not watched.
+ * @param project The absolute path to the project directory or the path to `tsconfig.json`.
+ * @throws {TsConfigFileNotFoundError}
+ * @throws {ReadCSSModuleFileError}
+ * @throws {WriteDtsFileError}
+ */
+export async function runCMKInWatchMode(args: RunnerArgs, logger: Logger): Promise<Watcher> {
+  const fsWatchers: FSWatcher[] = [];
+  const project = createProject(args);
+  let emitAndReportDiagnosticsTimer: NodeJS.Timeout | undefined = undefined;
 
-  const fileNames = getFileNamesByPattern(config);
-  if (fileNames.length === 0) {
-    logger.logDiagnostics([
-      {
-        category: 'warning',
-        text: `The file specified in tsconfig.json not found.`,
-      },
-    ]);
-    return;
-  }
-  const parseResults = await Promise.all(fileNames.map(async (fileName) => parseCSSModuleByFileName(fileName, config)));
-  for (const parseResult of parseResults) {
-    cssModuleMap.set(parseResult.cssModule.fileName, parseResult.cssModule);
-    syntacticDiagnostics.push(...parseResult.diagnostics);
+  if (args.clean) {
+    await rm(project.config.dtsOutDir, { recursive: true, force: true });
   }
+  await emitAndReportDiagnostics();
+
+  // Watch project files and report diagnostics on changes
+  const readyPromises: Promise<void>[] = [];
+  for (const wildcardDirectory of project.config.wildcardDirectories) {
+    const { promise, resolve } = promiseWithResolvers<void>();
+    readyPromises.push(promise);
+    fsWatchers.push(
+      chokidar
+        .watch(wildcardDirectory.fileName, {
+          ignored: (fileName: string, stats?: Stats) => {
+            // The ignored function is called twice for the same path. The first time with stats undefined,
+            // and the second time with stats provided.
+            // In the first call, we can't determine if the path is a directory or file.
+            // So we include it in the watch target considering it might be a directory.
+            if (!stats) return false;
 
-  if (syntacticDiagnostics.length > 0) {
-    logger.logDiagnostics(syntacticDiagnostics);
-    // eslint-disable-next-line n/no-process-exit
-    process.exit(1);
+            // In the second call, we include directories or files that match wildcards in the watch target.
+            // However, `dtsOutDir` is excluded from the watch target.
+            if (stats.isDirectory()) {
+              return fileName === project.config.dtsOutDir;
+            } else {
+              return !project.isWildcardMatchedFile(fileName);
+            }
+          },
+          ignoreInitial: true,
+          ...(wildcardDirectory.recursive ? {} : { depth: 0 }),
+        })
+        .on('add', (fileName) => {
+          try {
+            project.addFile(fileName);
+          } catch (e) {
+            logger.logError(e);
+            return;
+          }
+          scheduleEmitAndReportDiagnostics();
+        })
+        .on('change', (fileName) => {
+          try {
+            project.updateFile(fileName);
+          } catch (e) {
+            logger.logError(e);
+            return;
+          }
+          scheduleEmitAndReportDiagnostics();
+        })
+        .on('unlink', (fileName: string) => {
+          project.removeFile(fileName);
+          scheduleEmitAndReportDiagnostics();
+        })
+        .on('error', (e) => logger.logError(e))
+        .on('ready', () => resolve()),
+    );
   }
+  await Promise.all(readyPromises);
+
+  function scheduleEmitAndReportDiagnostics() {
+    // Switching between git branches results in numerous file changes occurring rapidly.
+    // Reporting diagnostics for each file change would overwhelm users.
+    // Therefore, we batch the processing.
 
-  const getCSSModule = (path: string) => cssModuleMap.get(path);
-  const exportBuilder = createExportBuilder({ getCSSModule, matchesPattern, resolver });
-  const semanticDiagnostics: Diagnostic[] = [];
-  for (const { cssModule } of parseResults) {
-    const diagnostics = checkCSSModule(cssModule, config, exportBuilder, matchesPattern, resolver, getCSSModule);
-    semanticDiagnostics.push(...diagnostics);
+    if (emitAndReportDiagnosticsTimer !== undefined) clearTimeout(emitAndReportDiagnosticsTimer);
+
+    emitAndReportDiagnosticsTimer = setTimeout(() => {
+      emitAndReportDiagnosticsTimer = undefined;
+      emitAndReportDiagnostics().catch(logger.logError.bind(logger));
+    }, 250);
   }
 
-  if (semanticDiagnostics.length > 0) {
-    logger.logDiagnostics(semanticDiagnostics);
-    // eslint-disable-next-line n/no-process-exit
-    process.exit(1);
+  /**
+   * @throws {WriteDtsFileError}
+   */
+  async function emitAndReportDiagnostics() {
+    logger.clearScreen();
+    await project.emitDtsFiles();
+    const diagnostics = project.getDiagnostics();
+    if (diagnostics.length > 0) {
+      logger.logDiagnostics(diagnostics);
+    }
+    logger.logMessage(
+      `Found ${diagnostics.length} error${diagnostics.length === 1 ? '' : 's'}. Watching for file changes.`,
+      { time: true },
+    );
   }
 
-  if (args.clean) {
-    await rm(config.dtsOutDir, { recursive: true, force: true });
+  async function close() {
+    await Promise.all(fsWatchers.map(async (watcher) => watcher.close()));
   }
-  await Promise.all(
-    parseResults.map(async (parseResult) =>
-      writeDtsByCSSModule(parseResult.cssModule, config, resolver, matchesPattern),
-    ),
-  );
+
+  return { project, close };
+}
+
+function promiseWithResolvers<T>() {
+  let resolve;
+  let reject;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve: resolve as unknown as (value: T) => void,
+    reject: reject as unknown as (reason?: unknown) => void,
+  };
 }