@css-modules-kit/core 0.0.1

package/dist/path.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbsolute = exports.matchesGlob = void 0;
+exports.slash = slash;
+exports.join = join;
+exports.resolve = resolve;
+exports.relative = relative;
+exports.dirname = dirname;
+exports.basename = basename;
+exports.parse = parse;
+// eslint-disable-next-line no-restricted-imports
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+function slash(path) {
+    return typescript_1.default.server.toNormalizedPath(path);
+}
+function join(...paths) {
+    return slash(node_path_1.default.join(...paths));
+}
+function resolve(...paths) {
+    return slash(node_path_1.default.resolve(...paths));
+}
+function relative(from, to) {
+    return slash(node_path_1.default.relative(from, to));
+}
+function dirname(path) {
+    return slash(node_path_1.default.dirname(path));
+}
+function basename(path) {
+    return slash(node_path_1.default.basename(path));
+}
+function parse(path) {
+    const { root, dir, base, name, ext } = node_path_1.default.parse(path);
+    return { root: slash(root), dir: slash(dir), base, name, ext };
+}
+// eslint-disable-next-line n/no-unsupported-features/node-builtins, @typescript-eslint/unbound-method
+exports.matchesGlob = node_path_1.default.matchesGlob;
+// eslint-disable-next-line @typescript-eslint/unbound-method
+exports.isAbsolute = node_path_1.default.isAbsolute;
+//# sourceMappingURL=path.js.map

package/dist/path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.js","sourceRoot":"","sources":["../src/path.ts"],"names":[],"mappings":";;;;;;AAMA,sBAEC;AAED,oBAEC;AAED,0BAEC;AAED,4BAEC;AAED,0BAEC;AAED,4BAEC;AAED,sBAGC;AA/BD,iDAAiD;AACjD,0DAAiC;AACjC,4DAA4B;AAE5B,SAAgB,KAAK,CAAC,IAAY;IAChC,OAAO,oBAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;AAC1C,CAAC;AAED,SAAgB,IAAI,CAAC,GAAG,KAAe;IACrC,OAAO,KAAK,CAAC,mBAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;AACxC,CAAC;AAED,SAAgB,OAAO,CAAC,GAAG,KAAe;IACxC,OAAO,KAAK,CAAC,mBAAQ,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;AAC3C,CAAC;AAED,SAAgB,QAAQ,CAAC,IAAY,EAAE,EAAU;IAC/C,OAAO,KAAK,CAAC,mBAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED,SAAgB,OAAO,CAAC,IAAY;IAClC,OAAO,KAAK,CAAC,mBAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;AACvC,CAAC;AAED,SAAgB,QAAQ,CAAC,IAAY;IACnC,OAAO,KAAK,CAAC,mBAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACxC,CAAC;AAED,SAAgB,KAAK,CAAC,IAAY;IAChC,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,mBAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC5D,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AACjE,CAAC;AAED,sGAAsG;AACzF,QAAA,WAAW,GAAG,mBAAQ,CAAC,WAAW,CAAC;AAEhD,6DAA6D;AAChD,QAAA,UAAU,GAAG,mBAAQ,CAAC,UAAU,CAAC"}

package/dist/resolver.d.ts

@@ -0,0 +1,13 @@
+export interface ResolverOptions {
+    /** The file that imports the specifier. It is a absolute path. */
+    request: string;
+}
+/**
+ * A resolver function that resolves import specifiers.
+ * @param specifier The import specifier.
+ * @param options The options.
+ * @returns The resolved import specifier. It is a absolute path. If the import specifier cannot be resolved, return `undefined`.
+ */
+export type Resolver = (specifier: string, options: ResolverOptions) => string | undefined;
+export declare function createResolver(paths: Record<string, string[]>): Resolver;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,KAAK,MAAM,GAAG,SAAS,CAAC;AAE3F,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,QAAQ,CA+BxE"}

package/dist/resolver.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResolver = createResolver;
+const node_url_1 = require("node:url");
+const typescript_1 = __importDefault(require("typescript"));
+const path_js_1 = require("./path.js");
+function createResolver(paths) {
+    return (_specifier, options) => {
+        let specifier = _specifier;
+        const host = {
+            ...typescript_1.default.sys,
+            fileExists: (fileName) => {
+                if (fileName.endsWith('.module.d.css.ts')) {
+                    return typescript_1.default.sys.fileExists(fileName.replace(/\.module\.d\.css\.ts$/u, '.module.css'));
+                }
+                return typescript_1.default.sys.fileExists(fileName);
+            },
+        };
+        const { resolvedModule } = typescript_1.default.resolveModuleName(specifier, options.request, { paths }, host);
+        if (resolvedModule) {
+            // TODO: Logging that the paths is used.
+            specifier = resolvedModule.resolvedFileName.replace(/\.module\.d\.css\.ts$/u, '.module.css');
+        }
+        if ((0, path_js_1.isAbsolute)(specifier)) {
+            return (0, path_js_1.resolve)(specifier);
+        }
+        else if (isRelativeSpecifier(specifier)) {
+            // Convert the specifier to an absolute path
+            // NOTE: Node.js resolves relative specifier with standard relative URL resolution semantics. So we will follow that here as well.
+            // ref: https://nodejs.org/docs/latest-v23.x/api/esm.html#terminology
+            return (0, path_js_1.resolve)((0, node_url_1.fileURLToPath)(new URL(specifier, (0, node_url_1.pathToFileURL)(options.request)).href));
+        }
+        else {
+            // Do not support URL or bare specifiers
+            // TODO: Logging that the specifier could not resolve.
+            return undefined;
+        }
+    };
+}
+/**
+ * Check if the specifier is a relative specifier.
+ * @see https://nodejs.org/docs/latest-v23.x/api/esm.html#terminology
+ */
+function isRelativeSpecifier(specifier) {
+    return specifier.startsWith('./') || specifier.startsWith('../');
+}
+//# sourceMappingURL=resolver.js.map

package/dist/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":";;;;;AAiBA,wCA+BC;AAhDD,uCAAwD;AACxD,4DAA4B;AAC5B,uCAAgD;AAehD,SAAgB,cAAc,CAAC,KAA+B;IAC5D,OAAO,CAAC,UAAkB,EAAE,OAAwB,EAAE,EAAE;QACtD,IAAI,SAAS,GAAG,UAAU,CAAC;QAE3B,MAAM,IAAI,GAA4B;YACpC,GAAG,oBAAE,CAAC,GAAG;YACT,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE;gBACvB,IAAI,QAAQ,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;oBAC1C,OAAO,oBAAE,CAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,wBAAwB,EAAE,aAAa,CAAC,CAAC,CAAC;gBACtF,CAAC;gBACD,OAAO,oBAAE,CAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YACrC,CAAC;SACF,CAAC;QACF,MAAM,EAAE,cAAc,EAAE,GAAG,oBAAE,CAAC,iBAAiB,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,CAAC;QAC7F,IAAI,cAAc,EAAE,CAAC;YACnB,wCAAwC;YACxC,SAAS,GAAG,cAAc,CAAC,gBAAgB,CAAC,OAAO,CAAC,wBAAwB,EAAE,aAAa,CAAC,CAAC;QAC/F,CAAC;QACD,IAAI,IAAA,oBAAU,EAAC,SAAS,CAAC,EAAE,CAAC;YAC1B,OAAO,IAAA,iBAAO,EAAC,SAAS,CAAC,CAAC;QAC5B,CAAC;aAAM,IAAI,mBAAmB,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1C,4CAA4C;YAC5C,kIAAkI;YAClI,qEAAqE;YACrE,OAAO,IAAA,iBAAO,EAAC,IAAA,wBAAa,EAAC,IAAI,GAAG,CAAC,SAAS,EAAE,IAAA,wBAAa,EAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACzF,CAAC;aAAM,CAAC;YACN,wCAAwC;YACxC,sDAAsD;YACtD,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,mBAAmB,CAAC,SAAiB;IAC5C,OAAO,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;AACnE,CAAC"}

package/dist/semantic-builder.d.ts

@@ -0,0 +1,23 @@
+import type { MatchesPattern } from './file.js';
+import type { CSSModule } from './parser/css-module-parser.js';
+export interface SemanticBuilderHost {
+    matchesPattern: MatchesPattern;
+    getCSSModule: (path: string) => CSSModule | undefined;
+    getCSSModuleVersion: (path: string) => string | undefined;
+}
+/**
+ * The semantic record for a CSS module.
+ */
+export interface SemanticRecord {
+    /** The version of the source code. It should be updated when the source code changes. */
+    version: string;
+    /** The all exported tokens of the CSS module. */
+    allTokens: string[];
+}
+export declare class SemanticBuilder {
+    readonly records: Map<string, SemanticRecord>;
+    readonly host: SemanticBuilderHost;
+    constructor(host: SemanticBuilderHost);
+    build(cssModule: CSSModule): SemanticRecord;
+}
+//# sourceMappingURL=semantic-builder.d.ts.map

package/dist/semantic-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-builder.d.ts","sourceRoot":"","sources":["../src/semantic-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE/D,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,CAAC;IACtD,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC3D;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,yFAAyF;IACzF,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,qBAAa,eAAe;IAC1B,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAa;IAC1D,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;gBACvB,IAAI,EAAE,mBAAmB;IAIrC,KAAK,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc;CAmB5C"}

package/dist/semantic-builder.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticBuilder = void 0;
+class SemanticBuilder {
+    records = new Map();
+    host;
+    constructor(host) {
+        this.records = new Map();
+        this.host = host;
+    }
+    build(cssModule) {
+        const cached = this.records.get(cssModule.fileName);
+        const version = this.host.getCSSModuleVersion(cssModule.fileName) ?? '1';
+        if (cached && version === cached.version)
+            return cached;
+        const result = { version, allTokens: [...cssModule.localTokens.map((t) => t.name)] };
+        for (const tokenImporter of cssModule.tokenImporters) {
+            if (!this.host.matchesPattern(tokenImporter.from))
+                continue;
+            const imported = this.host.getCSSModule(tokenImporter.from);
+            if (!imported)
+                continue;
+            const importedResult = this.build(imported);
+            if (tokenImporter.type === 'import') {
+                result.allTokens.push(...importedResult.allTokens);
+            }
+        }
+        this.records.set(cssModule.fileName, result);
+        return result;
+    }
+}
+exports.SemanticBuilder = SemanticBuilder;
+//# sourceMappingURL=semantic-builder.js.map

package/dist/semantic-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-builder.js","sourceRoot":"","sources":["../src/semantic-builder.ts"],"names":[],"mappings":";;;AAmBA,MAAa,eAAe;IACjB,OAAO,GAAgC,IAAI,GAAG,EAAE,CAAC;IACjD,IAAI,CAAsB;IACnC,YAAY,IAAyB;QACnC,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IACD,KAAK,CAAC,SAAoB;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC;QACzE,IAAI,MAAM,IAAI,OAAO,KAAK,MAAM,CAAC,OAAO;YAAE,OAAO,MAAM,CAAC;QACxD,MAAM,MAAM,GAAmB,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;QAErG,KAAK,MAAM,aAAa,IAAI,SAAS,CAAC,cAAc,EAAE,CAAC;YACrD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,IAAI,CAAC;gBAAE,SAAS;YAC5D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAC5D,IAAI,CAAC,QAAQ;gBAAE,SAAS;YAExB,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAC5C,IAAI,aAAa,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACpC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC;YACrD,CAAC;QACH,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC7C,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AA1BD,0CA0BC"}

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export declare function isPosixRelativePath(path: string): boolean;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD"}

package/dist/util.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPosixRelativePath = isPosixRelativePath;
+function isPosixRelativePath(path) {
+    return path.startsWith(`./`) || path.startsWith(`../`);
+}
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;AAAA,kDAEC;AAFD,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;AACzD,CAAC"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@css-modules-kit/core",
+  "description": "The core of css-modules-kit",
+  "version": "0.0.1",
+  "type": "commonjs",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mizdra/css-modules-kit.git",
+    "directory": "packages/core"
+  },
+  "author": "mizdra <pp.mizdra@gmail.com>",
+  "license": "MIT",
+  "private": false,
+  "exports": {
+    ".": {
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "css-modules",
+    "typescript"
+  ],
+  "files": [
+    "bin",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/__snapshots__",
+    "!src/test",
+    "dist"
+  ],
+  "dependencies": {
+    "postcss": "^8.4.49",
+    "postcss-safe-parser": "^7.0.1",
+    "postcss-selector-parser": "^7.1.0",
+    "postcss-value-parser": "^4.2.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.7.3"
+  }
+}

package/src/checker.ts

@@ -0,0 +1,66 @@
+import type { SemanticDiagnostic } from './diagnostic.js';
+import type { ExportBuilder } from './export-builder.js';
+import type { MatchesPattern } from './file.js';
+import type {
+  AtValueTokenImporter,
+  AtValueTokenImporterValue,
+  CSSModule,
+  TokenImporter,
+} from './parser/css-module-parser.js';
+import type { Resolver } from './resolver.js';
+
+export function checkCSSModule(
+  cssModule: CSSModule,
+  exportBuilder: ExportBuilder,
+  matchesPattern: MatchesPattern,
+  resolver: Resolver,
+  getCSSModule: (path: string) => CSSModule | undefined,
+): SemanticDiagnostic[] {
+  const diagnostics: SemanticDiagnostic[] = [];
+
+  for (const tokenImporter of cssModule.tokenImporters) {
+    const from = resolver(tokenImporter.from, { request: cssModule.fileName });
+    if (!from || !matchesPattern(from)) continue;
+    const imported = getCSSModule(from);
+    if (!imported) {
+      diagnostics.push(createCannotImportModuleDiagnostic(cssModule, tokenImporter));
+      continue;
+    }
+
+    if (tokenImporter.type === 'value') {
+      const exportRecord = exportBuilder.build(imported);
+      for (const value of tokenImporter.values) {
+        if (!exportRecord.allTokens.includes(value.name)) {
+          diagnostics.push(createModuleHasNoExportedTokenDiagnostic(cssModule, tokenImporter, value));
+        }
+      }
+    }
+  }
+  return diagnostics;
+}
+
+function createCannotImportModuleDiagnostic(cssModule: CSSModule, tokenImporter: TokenImporter): SemanticDiagnostic {
+  return {
+    type: 'semantic',
+    text: `Cannot import module '${tokenImporter.from}'`,
+    category: 'error',
+    fileName: cssModule.fileName,
+    start: { line: tokenImporter.fromLoc.start.line, column: tokenImporter.fromLoc.start.column },
+    end: { line: tokenImporter.fromLoc.end.line, column: tokenImporter.fromLoc.end.column },
+  };
+}
+
+function createModuleHasNoExportedTokenDiagnostic(
+  cssModule: CSSModule,
+  tokenImporter: AtValueTokenImporter,
+  value: AtValueTokenImporterValue,
+): SemanticDiagnostic {
+  return {
+    type: 'semantic',
+    text: `Module '${tokenImporter.from}' has no exported token '${value.name}'.`,
+    category: 'error',
+    fileName: cssModule.fileName,
+    start: { line: value.loc.start.line, column: value.loc.start.column },
+    end: { line: value.loc.end.line, column: value.loc.end.column },
+  };
+}

package/src/config.ts

@@ -0,0 +1,285 @@
+import ts from 'typescript';
+import type { SemanticDiagnostic } from './diagnostic.js';
+import { TsConfigFileNotFoundError } from './error.js';
+import { basename, dirname, join, resolve } from './path.js';
+
+// https://github.com/microsoft/TypeScript/blob/caf1aee269d1660b4d2a8b555c2d602c97cb28d7/src/compiler/commandLineParser.ts#L3006
+const DEFAULT_INCLUDE_SPEC = '**/*';
+
+type RemoveUndefined<T> = {
+  [K in keyof T]: Exclude<T[K], undefined>;
+};
+
+/**
+ * The config used by css-modules-kit.
+ * This is normalized. Paths are resolved from relative to absolute, and default values are set for missing options.
+ */
+export interface CMKConfig {
+  includes: string[];
+  excludes: string[];
+  paths: Record<string, string[]>;
+  dtsOutDir: string;
+  arbitraryExtensions: boolean;
+  dashedIdents: boolean;
+  /**
+   * A root directory to resolve relative path entries in the config file to.
+   * This is an absolute path.
+   *
+   * This is also used to determine the output directory of the d.ts file.
+   * For example, let’s say you have some input files:
+   * ```
+   * /app
+   * ├── tsconfig.json
+   * ├── src
+   * │   ├── a.module.css
+   * │   ├── b.module.css
+   * │   ├── sub
+   * │   │   ├── c.module.css
+   * ```
+   *
+   * If you set `basePath` to `/app/src`, the output files will be:
+   * ```
+   * /app
+   * ├── dist
+   * │   ├── a.module.css.d.ts
+   * │   ├── b.module.css.d.ts
+   * │   ├── sub
+   * │   │   ├── c.module.css.d.ts
+   * ```
+   *
+   * If you set `basePath` to `/app`, the output files will be:
+   * ```
+   * /app
+   * ├── dist
+   * │   ├── src
+   * │   │   ├── a.module.css.d.ts
+   * │   │   ├── b.module.css.d.ts
+   * │   │   ├── sub
+   * │   │   │   ├── c.module.css.d.ts
+   * ```
+   */
+  basePath: string;
+  configFileName: string;
+  /** The diagnostics that occurred while reading the config file. */
+  diagnostics: SemanticDiagnostic[];
+}
+
+/**
+ * The config loaded from `tsconfig.json`.
+ * This is unnormalized. Paths are relative, and some options may be omitted.
+ */
+interface UnnormalizedCMKConfig {
+  includes: string[] | undefined;
+  excludes: string[] | undefined;
+  paths: Record<string, string[]> | undefined;
+  dtsOutDir: string | undefined;
+  arbitraryExtensions: boolean | undefined;
+}
+
+/**
+ * The validated data of `ts.ParsedCommandLine['raw']`.
+ */
+interface ParsedRawData {
+  config: UnnormalizedCMKConfig;
+  diagnostics: SemanticDiagnostic[];
+}
+
+// eslint-disable-next-line complexity
+function parseRawData(raw: unknown, configFileName: string): ParsedRawData {
+  const result: ParsedRawData = {
+    config: {
+      includes: undefined,
+      excludes: undefined,
+      paths: undefined,
+      dtsOutDir: undefined,
+      arbitraryExtensions: undefined,
+    },
+    diagnostics: [],
+  };
+  if (typeof raw !== 'object' || raw === null) return result;
+
+  // `tsConfigSourceFile.configFileSpecs` contains `includes` and `excludes`. However, it is an internal API.
+  // So we collect `includes` and `excludes` from `parsedCommandLine.raw` without the internal API.
+
+  if ('include' in raw) {
+    if (Array.isArray(raw.include)) {
+      const includes = raw.include.filter((i) => typeof i === 'string');
+      result.config.includes = includes;
+    }
+    // MEMO: The errors for this option are reported by `tsc` or `tsserver`, so we don't need to report.
+  }
+  if ('exclude' in raw) {
+    if (Array.isArray(raw.exclude)) {
+      const excludes = raw.exclude.filter((e) => typeof e === 'string');
+      result.config.excludes = excludes;
+    }
+    // MEMO: The errors for this option are reported by `tsc` or `tsserver`, so we don't need to report.
+  }
+  if ('compilerOptions' in raw && typeof raw.compilerOptions === 'object' && raw.compilerOptions !== null) {
+    if ('paths' in raw.compilerOptions) {
+      if (typeof raw.compilerOptions.paths === 'object' && raw.compilerOptions.paths !== null) {
+        const paths: Record<string, string[]> = {};
+        for (const [key, value] of Object.entries(raw.compilerOptions.paths)) {
+          if (Array.isArray(value)) {
+            const resolvedValue = value.filter((v) => typeof v === 'string');
+            paths[key] = resolvedValue;
+          }
+        }
+        result.config.paths = paths;
+      }
+      // MEMO: The errors for this option are reported by `tsc` or `tsserver`, so we don't need to report.
+    }
+  }
+  if ('cmkOptions' in raw && typeof raw.cmkOptions === 'object' && raw.cmkOptions !== null) {
+    if ('dtsOutDir' in raw.cmkOptions) {
+      if (typeof raw.cmkOptions.dtsOutDir === 'string') {
+        result.config.dtsOutDir = raw.cmkOptions.dtsOutDir;
+      } else {
+        result.diagnostics.push({
+          type: 'semantic',
+          category: 'error',
+          text: '`dtsOutDir` must be a string.',
+          fileName: configFileName,
+        });
+      }
+    }
+    if ('arbitraryExtensions' in raw.cmkOptions) {
+      if (typeof raw.cmkOptions.arbitraryExtensions === 'boolean') {
+        result.config.arbitraryExtensions = raw.cmkOptions.arbitraryExtensions;
+      } else {
+        result.diagnostics.push({
+          type: 'semantic',
+          category: 'error',
+          text: '`arbitraryExtensions` must be a boolean.',
+          fileName: configFileName,
+        });
+      }
+    }
+  }
+  return result;
+}
+export { parseRawData as parseRawDataForTest };
+
+/**
+ * Reads the `tsconfig.json` file and returns the normalized config.
+ * Even if the `tsconfig.json` file contains syntax or semantic errors,
+ * this function attempts to parse as much as possible and still returns a valid config.
+ *
+ * @param project The absolute path to the project directory or the path to `tsconfig.json`.
+ * @throws {TsConfigFileNotFoundError}
+ */
+export function readConfigFile(project: string): CMKConfig {
+  const { configFileName, config, diagnostics } = readTsConfigFile(project);
+  const basePath = dirname(configFileName);
+  return {
+    ...normalizeConfig(config, basePath),
+    basePath,
+    configFileName,
+    diagnostics,
+  };
+}
+
+export function findTsConfigFile(project: string): string | undefined {
+  const configFile =
+    ts.sys.directoryExists(project) ?
+      ts.findConfigFile(project, ts.sys.fileExists.bind(ts.sys), 'tsconfig.json')
+    : ts.findConfigFile(dirname(project), ts.sys.fileExists.bind(ts.sys), basename(project));
+  if (!configFile) return undefined;
+  return resolve(configFile);
+}
+
+function mergeParsedRawData(base: ParsedRawData, overrides: ParsedRawData): ParsedRawData {
+  const result: ParsedRawData = { config: { ...base.config }, diagnostics: [...base.diagnostics] };
+  if (overrides.config.includes !== undefined) result.config.includes = overrides.config.includes;
+  if (overrides.config.excludes !== undefined) result.config.excludes = overrides.config.excludes;
+  if (overrides.config.paths !== undefined) result.config.paths = overrides.config.paths;
+  if (overrides.config.dtsOutDir !== undefined) result.config.dtsOutDir = overrides.config.dtsOutDir;
+  if (overrides.config.arbitraryExtensions !== undefined)
+    result.config.arbitraryExtensions = overrides.config.arbitraryExtensions;
+  result.diagnostics.push(...overrides.diagnostics);
+  return result;
+}
+
+/**
+ * @throws {TsConfigFileNotFoundError}
+ */
+// TODO: Allow `extends` options to inherit `cmkOptions`
+export function readTsConfigFile(project: string): {
+  configFileName: string;
+} & ParsedRawData {
+  const configFileName = findTsConfigFile(project);
+  if (!configFileName) throw new TsConfigFileNotFoundError();
+
+  const tsConfigSourceFile = ts.readJsonConfigFile(configFileName, ts.sys.readFile.bind(ts.sys));
+  // MEMO: `tsConfigSourceFile.parseDiagnostics` (Internal API) contains a syntax error for `tsconfig.json`.
+  // However, it is ignored so that ts-plugin will work even if `tsconfig.json` is somewhat broken.
+  // Also, this error is reported to the user by `tsc` or `tsserver`.
+  // We discard it since there is no need to report it from css-modules-kit.
+
+  const parsedCommandLine = ts.parseJsonSourceFileConfigFileContent(
+    tsConfigSourceFile,
+    ts.sys,
+    dirname(configFileName),
+    undefined,
+    configFileName,
+    undefined,
+    [
+      {
+        extension: 'css',
+        isMixedContent: false,
+        scriptKind: ts.ScriptKind.Deferred,
+      },
+    ],
+  );
+  // Read options from `parsedCommandLine.raw`
+  let parsedRawData = parseRawData(parsedCommandLine.raw, configFileName);
+
+  // The options read from `parsedCommandLine.raw` do not inherit values from the file specified in `extends`.
+  // So here we read the options from those files and merge them into `parsedRawData`.
+  if (tsConfigSourceFile.extendedSourceFiles) {
+    for (const extendedSourceFile of tsConfigSourceFile.extendedSourceFiles) {
+      let base: ParsedRawData;
+      try {
+        base = readTsConfigFile(extendedSourceFile);
+      } catch (error) {
+        if (error instanceof TsConfigFileNotFoundError) continue;
+        throw error;
+      }
+      parsedRawData = mergeParsedRawData(base, parsedRawData);
+    }
+  }
+
+  return {
+    configFileName,
+    ...parsedRawData,
+  };
+}
+
+function resolvePaths(paths: Record<string, string[]> | undefined, cwd: string): Record<string, string[]> {
+  if (paths === undefined) return {};
+  const resolvedPaths: Record<string, string[]> = {};
+  for (const [key, value] of Object.entries(paths)) {
+    resolvedPaths[key] = value.map((path) => join(cwd, path));
+  }
+  return resolvedPaths;
+}
+
+/**
+ * Normalize the config. Resolve relative paths to absolute paths, and set default values for missing options.
+ * @param basePath A root directory to resolve relative path entries in the config file to.
+ */
+export function normalizeConfig(
+  config: UnnormalizedCMKConfig,
+  basePath: string,
+): RemoveUndefined<UnnormalizedCMKConfig> & { dashedIdents: boolean } {
+  return {
+    // If `include` is not specified, fallback to the default include spec.
+    // ref: https://github.com/microsoft/TypeScript/blob/caf1aee269d1660b4d2a8b555c2d602c97cb28d7/src/compiler/commandLineParser.ts#L3102
+    includes: (config.includes ?? [DEFAULT_INCLUDE_SPEC]).map((i) => join(basePath, i)),
+    excludes: (config.excludes ?? []).map((e) => join(basePath, e)),
+    paths: resolvePaths(config.paths, basePath),
+    dtsOutDir: join(basePath, config.dtsOutDir ?? 'generated'),
+    arbitraryExtensions: config.arbitraryExtensions ?? false,
+    dashedIdents: false, // TODO: Support dashedIdents
+  };
+}

package/src/diagnostic.ts

@@ -0,0 +1,37 @@
+export type DiagnosticCategory = 'error' | 'warning';
+
+export interface DiagnosticPosition {
+  /** The line number in the source file. It is 1-based. */
+  line: number;
+  /** The column number in the source file. It is 1-based. */
+  column: number;
+}
+
+export type Diagnostic = SemanticDiagnostic | SyntacticDiagnostic;
+
+interface DiagnosticBase {
+  /** Text of diagnostic message. */
+  text: string;
+  /** The category of the diagnostic message. */
+  category: DiagnosticCategory;
+}
+
+export interface SemanticDiagnostic extends DiagnosticBase {
+  type: 'semantic';
+  /** The filename of the file in which the diagnostic occurred */
+  fileName?: string;
+  /** Starting file position at which text applies. It is inclusive. */
+  start?: DiagnosticPosition;
+  /**  The last file position at which the text applies. It is exclusive. */
+  end?: DiagnosticPosition;
+}
+
+export interface SyntacticDiagnostic extends DiagnosticBase {
+  type: 'syntactic';
+  /** The filename of the file in which the diagnostic occurred */
+  fileName: string;
+  /** Starting file position at which text applies. It is inclusive. */
+  start: DiagnosticPosition;
+  /**  The last file position at which the text applies. It is exclusive. */
+  end?: DiagnosticPosition;
+}