@better-css-modules/core 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 k35o
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# @better-css-modules/core
+
+Core library for better-css-modules. Provides CSS Modules parsing, type definition generation, unused class detection, file watching, and a webpack loader.
+
+## Install
+
+```bash
+pnpm add -D @better-css-modules/core
+```
+
+## API
+
+```ts
+import {
+  defineConfig,
+  loadConfig,
+  extractClassNames,
+  parseFile,
+  generateDts,
+  writeDts,
+  generateAll,
+  scanUnusedClasses,
+  startWatcher,
+} from '@better-css-modules/core';
+
+// Extract class names from CSS
+const classNames = extractClassNames('.container { color: red; }');
+// => ['container']
+
+// Generate .d.ts content
+const dts = generateDts(classNames);
+
+// Generate all .d.ts files based on config
+const config = await loadConfig(process.cwd());
+await generateAll(config, process.cwd());
+
+// Detect unused class names
+const warnings = await scanUnusedClasses(process.cwd());
+```
+
+## webpack Loader
+
+A webpack-compatible loader is available at `@better-css-modules/core/loader`. This is used internally by `@better-css-modules/turbopack` for Turbopack integration.
+
+## Configuration
+
+```ts
+import { defineConfig } from '@better-css-modules/core';
+
+export default defineConfig({
+  include: ['src/**/*.module.css'],
+  exclude: [],
+  outDir: '__generated__',
+  watch: false,
+});
+```
+
+## License
+
+MIT

package/dist/generator-BMINjrx4.cjs

@@ -0,0 +1,178 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let jiti = require("jiti");
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let postcss = require("postcss");
+postcss = __toESM(postcss);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let fast_glob = require("fast-glob");
+fast_glob = __toESM(fast_glob);
+//#region src/config.ts
+const defaultConfig = {
+	include: ["src/**/*.module.css"],
+	exclude: [],
+	outDir: "__generated__",
+	watch: false
+};
+function defineConfig(config) {
+	return {
+		...defaultConfig,
+		...config
+	};
+}
+async function loadConfig(cwd = process.cwd()) {
+	const configFileName = "better-css-modules.config";
+	for (const ext of [
+		".ts",
+		".mts",
+		".cts",
+		".js",
+		".mjs",
+		".cjs"
+	]) {
+		const configPath = node_path.default.resolve(cwd, configFileName + ext);
+		if (node_fs.default.existsSync(configPath)) {
+			const mod = await (0, jiti.createJiti)(cwd).import(configPath);
+			const loaded = mod.default ?? mod;
+			return {
+				...defaultConfig,
+				...loaded
+			};
+		}
+	}
+	return defaultConfig;
+}
+//#endregion
+//#region src/parser.ts
+/**
+* Extract class names from CSS file contents.
+*/
+function extractClassNames(css) {
+	const root = postcss.default.parse(css);
+	const classNames = /* @__PURE__ */ new Set();
+	root.walkRules((rule) => {
+		const selectorParts = rule.selector.split(/\s*,\s*/);
+		for (const selector of selectorParts) {
+			const matches = selector.matchAll(/\.([a-zA-Z_-][\w-]*)/g);
+			for (const match of matches) classNames.add(match[1]);
+		}
+	});
+	return [...classNames].sort();
+}
+/**
+* Read a CSS Modules file and extract class names.
+*/
+async function parseFile(filePath) {
+	return extractClassNames(await node_fs_promises.default.readFile(filePath, "utf-8"));
+}
+//#endregion
+//#region src/generator.ts
+/**
+* Generate .d.ts content from an array of class names.
+*/
+function generateDts(classNames) {
+	return `declare const styles: {\n${classNames.map((name) => {
+		return `  readonly ${/^[a-zA-Z_$][\w$]*$/.test(name) ? name : `"${name}"`}: string;`;
+	}).join("\n")}\n};\nexport default styles;\n`;
+}
+/**
+* Generate and write a .d.ts file for a CSS Modules file.
+*
+* @param cssFilePath - Path to the source CSS Modules file
+* @param classNames - Array of extracted class names
+* @param outDir - Output directory
+* @param cwd - Working directory
+*/
+async function writeDts(cssFilePath, classNames, outDir, cwd = process.cwd()) {
+	const dtsFileName = node_path.default.relative(cwd, cssFilePath) + ".d.ts";
+	const dtsPath = node_path.default.resolve(cwd, outDir, dtsFileName);
+	await node_fs_promises.default.mkdir(node_path.default.dirname(dtsPath), { recursive: true });
+	await node_fs_promises.default.writeFile(dtsPath, generateDts(classNames), "utf-8");
+	return dtsPath;
+}
+/**
+* Batch-generate .d.ts files for all CSS Modules files based on the config.
+*/
+async function generateAll(config, cwd = process.cwd()) {
+	const files = await (0, fast_glob.default)(config.include, {
+		cwd,
+		ignore: config.exclude,
+		absolute: true
+	});
+	return await Promise.all(files.map(async (file) => {
+		return writeDts(file, await parseFile(file), config.outDir, cwd);
+	}));
+}
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "defineConfig", {
+	enumerable: true,
+	get: function() {
+		return defineConfig;
+	}
+});
+Object.defineProperty(exports, "extractClassNames", {
+	enumerable: true,
+	get: function() {
+		return extractClassNames;
+	}
+});
+Object.defineProperty(exports, "generateAll", {
+	enumerable: true,
+	get: function() {
+		return generateAll;
+	}
+});
+Object.defineProperty(exports, "generateDts", {
+	enumerable: true,
+	get: function() {
+		return generateDts;
+	}
+});
+Object.defineProperty(exports, "loadConfig", {
+	enumerable: true,
+	get: function() {
+		return loadConfig;
+	}
+});
+Object.defineProperty(exports, "parseFile", {
+	enumerable: true,
+	get: function() {
+		return parseFile;
+	}
+});
+Object.defineProperty(exports, "writeDts", {
+	enumerable: true,
+	get: function() {
+		return writeDts;
+	}
+});

package/dist/generator-CZGTIPYk.mjs

@@ -0,0 +1,104 @@
+import { createJiti } from "jiti";
+import path from "node:path";
+import fs from "node:fs";
+import postcss from "postcss";
+import fs$1 from "node:fs/promises";
+import fg from "fast-glob";
+//#region src/config.ts
+const defaultConfig = {
+	include: ["src/**/*.module.css"],
+	exclude: [],
+	outDir: "__generated__",
+	watch: false
+};
+function defineConfig(config) {
+	return {
+		...defaultConfig,
+		...config
+	};
+}
+async function loadConfig(cwd = process.cwd()) {
+	const configFileName = "better-css-modules.config";
+	for (const ext of [
+		".ts",
+		".mts",
+		".cts",
+		".js",
+		".mjs",
+		".cjs"
+	]) {
+		const configPath = path.resolve(cwd, configFileName + ext);
+		if (fs.existsSync(configPath)) {
+			const mod = await createJiti(cwd).import(configPath);
+			const loaded = mod.default ?? mod;
+			return {
+				...defaultConfig,
+				...loaded
+			};
+		}
+	}
+	return defaultConfig;
+}
+//#endregion
+//#region src/parser.ts
+/**
+* Extract class names from CSS file contents.
+*/
+function extractClassNames(css) {
+	const root = postcss.parse(css);
+	const classNames = /* @__PURE__ */ new Set();
+	root.walkRules((rule) => {
+		const selectorParts = rule.selector.split(/\s*,\s*/);
+		for (const selector of selectorParts) {
+			const matches = selector.matchAll(/\.([a-zA-Z_-][\w-]*)/g);
+			for (const match of matches) classNames.add(match[1]);
+		}
+	});
+	return [...classNames].sort();
+}
+/**
+* Read a CSS Modules file and extract class names.
+*/
+async function parseFile(filePath) {
+	return extractClassNames(await fs$1.readFile(filePath, "utf-8"));
+}
+//#endregion
+//#region src/generator.ts
+/**
+* Generate .d.ts content from an array of class names.
+*/
+function generateDts(classNames) {
+	return `declare const styles: {\n${classNames.map((name) => {
+		return `  readonly ${/^[a-zA-Z_$][\w$]*$/.test(name) ? name : `"${name}"`}: string;`;
+	}).join("\n")}\n};\nexport default styles;\n`;
+}
+/**
+* Generate and write a .d.ts file for a CSS Modules file.
+*
+* @param cssFilePath - Path to the source CSS Modules file
+* @param classNames - Array of extracted class names
+* @param outDir - Output directory
+* @param cwd - Working directory
+*/
+async function writeDts(cssFilePath, classNames, outDir, cwd = process.cwd()) {
+	const dtsFileName = path.relative(cwd, cssFilePath) + ".d.ts";
+	const dtsPath = path.resolve(cwd, outDir, dtsFileName);
+	await fs$1.mkdir(path.dirname(dtsPath), { recursive: true });
+	await fs$1.writeFile(dtsPath, generateDts(classNames), "utf-8");
+	return dtsPath;
+}
+/**
+* Batch-generate .d.ts files for all CSS Modules files based on the config.
+*/
+async function generateAll(config, cwd = process.cwd()) {
+	const files = await fg(config.include, {
+		cwd,
+		ignore: config.exclude,
+		absolute: true
+	});
+	return await Promise.all(files.map(async (file) => {
+		return writeDts(file, await parseFile(file), config.outDir, cwd);
+	}));
+}
+//#endregion
+export { parseFile as a, extractClassNames as i, generateDts as n, defineConfig as o, writeDts as r, loadConfig as s, generateAll as t };

package/dist/index.cjs

@@ -0,0 +1,98 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_generator = require("./generator-BMINjrx4.cjs");
+let node_path = require("node:path");
+node_path = require_generator.__toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_generator.__toESM(node_fs_promises);
+let fast_glob = require("fast-glob");
+fast_glob = require_generator.__toESM(fast_glob);
+let chokidar = require("chokidar");
+//#region src/scanner.ts
+/**
+* Scan TS/TSX file contents for CSS Modules class name usage.
+* Detects patterns like styles.foo / styles["foo"] / styles['foo'].
+*/
+function findUsedClassNames(tsContent) {
+	const used = /* @__PURE__ */ new Set();
+	for (const match of tsContent.matchAll(/styles\.([a-zA-Z_$][\w$]*)/g)) used.add(match[1]);
+	for (const match of tsContent.matchAll(/styles\[["']([^"']+)["']\]/g)) used.add(match[1]);
+	return used;
+}
+/**
+* Identify the source file of a CSS Modules import.
+* Detects patterns like import styles from './Foo.module.css'.
+*/
+function findCssModuleImports(tsContent) {
+	const imports = [];
+	for (const match of tsContent.matchAll(/import\s+\w+\s+from\s+['"]([^'"]+\.module\.css)['"]/g)) imports.push(match[1]);
+	return imports;
+}
+/**
+* Scan TS/TSX files under the specified directory
+* and detect unused CSS Modules class names.
+*/
+async function scanUnusedClasses(cwd) {
+	const tsFiles = await (0, fast_glob.default)([
+		"**/*.{ts,tsx,js,jsx}",
+		"!node_modules",
+		"!dist",
+		"!__generated__"
+	], {
+		cwd,
+		absolute: true
+	});
+	const warnings = [];
+	for (const tsFile of tsFiles) {
+		const content = await node_fs_promises.default.readFile(tsFile, "utf-8");
+		const cssImports = findCssModuleImports(content);
+		if (cssImports.length === 0) continue;
+		const usedNames = findUsedClassNames(content);
+		for (const cssImport of cssImports) {
+			const cssPath = node_path.default.resolve(node_path.default.dirname(tsFile), cssImport);
+			try {
+				const classNames = await require_generator.parseFile(cssPath);
+				for (const className of classNames) if (!usedNames.has(className)) warnings.push({
+					cssFile: cssPath,
+					className
+				});
+			} catch {}
+		}
+	}
+	return warnings;
+}
+//#endregion
+//#region src/watcher.ts
+function startWatcher(config, cwd = process.cwd()) {
+	const watcher = (0, chokidar.watch)(config.include, {
+		cwd,
+		ignored: config.exclude,
+		ignoreInitial: false
+	});
+	watcher.on("add", async (filePath) => {
+		await regenerate(filePath, config.outDir, cwd);
+	});
+	watcher.on("change", async (filePath) => {
+		await regenerate(filePath, config.outDir, cwd);
+	});
+	watcher.on("unlink", () => {});
+	return watcher;
+}
+async function regenerate(relativePath, outDir, cwd) {
+	const absolutePath = new URL(relativePath, `file://${cwd}/`).pathname;
+	try {
+		const dtsPath = await require_generator.writeDts(absolutePath, await require_generator.parseFile(absolutePath), outDir, cwd);
+		console.log(`[better-css-modules] generated: ${dtsPath}`);
+	} catch (err) {
+		console.error(`[better-css-modules] error processing ${relativePath}:`, err);
+	}
+}
+//#endregion
+exports.defineConfig = require_generator.defineConfig;
+exports.extractClassNames = require_generator.extractClassNames;
+exports.generateAll = require_generator.generateAll;
+exports.generateDts = require_generator.generateDts;
+exports.loadConfig = require_generator.loadConfig;
+exports.parseFile = require_generator.parseFile;
+exports.scanUnusedClasses = scanUnusedClasses;
+exports.startWatcher = startWatcher;
+exports.writeDts = require_generator.writeDts;

package/dist/index.d.cts

@@ -0,0 +1,60 @@
+import * as chokidar from "chokidar";
+
+//#region src/config.d.ts
+interface Config {
+  /** Glob patterns for target files */
+  include: string[];
+  /** Exclusion patterns */
+  exclude: string[];
+  /** Output directory */
+  outDir: string;
+  /** Watch mode (for CLI) */
+  watch: boolean;
+}
+declare function defineConfig(config: Partial<Config>): Config;
+declare function loadConfig(cwd?: string): Promise<Config>;
+//#endregion
+//#region src/parser.d.ts
+/**
+ * Extract class names from CSS file contents.
+ */
+declare function extractClassNames(css: string): string[];
+/**
+ * Read a CSS Modules file and extract class names.
+ */
+declare function parseFile(filePath: string): Promise<string[]>;
+//#endregion
+//#region src/generator.d.ts
+/**
+ * Generate .d.ts content from an array of class names.
+ */
+declare function generateDts(classNames: string[]): string;
+/**
+ * Generate and write a .d.ts file for a CSS Modules file.
+ *
+ * @param cssFilePath - Path to the source CSS Modules file
+ * @param classNames - Array of extracted class names
+ * @param outDir - Output directory
+ * @param cwd - Working directory
+ */
+declare function writeDts(cssFilePath: string, classNames: string[], outDir: string, cwd?: string): Promise<string>;
+/**
+ * Batch-generate .d.ts files for all CSS Modules files based on the config.
+ */
+declare function generateAll(config: Config, cwd?: string): Promise<string[]>;
+//#endregion
+//#region src/scanner.d.ts
+interface UnusedClassWarning {
+  cssFile: string;
+  className: string;
+}
+/**
+ * Scan TS/TSX files under the specified directory
+ * and detect unused CSS Modules class names.
+ */
+declare function scanUnusedClasses(cwd: string): Promise<UnusedClassWarning[]>;
+//#endregion
+//#region src/watcher.d.ts
+declare function startWatcher(config: Config, cwd?: string): chokidar.FSWatcher;
+//#endregion
+export { type Config, type UnusedClassWarning, defineConfig, extractClassNames, generateAll, generateDts, loadConfig, parseFile, scanUnusedClasses, startWatcher, writeDts };

package/dist/index.d.mts

@@ -0,0 +1,60 @@
+import * as chokidar from "chokidar";
+
+//#region src/config.d.ts
+interface Config {
+  /** Glob patterns for target files */
+  include: string[];
+  /** Exclusion patterns */
+  exclude: string[];
+  /** Output directory */
+  outDir: string;
+  /** Watch mode (for CLI) */
+  watch: boolean;
+}
+declare function defineConfig(config: Partial<Config>): Config;
+declare function loadConfig(cwd?: string): Promise<Config>;
+//#endregion
+//#region src/parser.d.ts
+/**
+ * Extract class names from CSS file contents.
+ */
+declare function extractClassNames(css: string): string[];
+/**
+ * Read a CSS Modules file and extract class names.
+ */
+declare function parseFile(filePath: string): Promise<string[]>;
+//#endregion
+//#region src/generator.d.ts
+/**
+ * Generate .d.ts content from an array of class names.
+ */
+declare function generateDts(classNames: string[]): string;
+/**
+ * Generate and write a .d.ts file for a CSS Modules file.
+ *
+ * @param cssFilePath - Path to the source CSS Modules file
+ * @param classNames - Array of extracted class names
+ * @param outDir - Output directory
+ * @param cwd - Working directory
+ */
+declare function writeDts(cssFilePath: string, classNames: string[], outDir: string, cwd?: string): Promise<string>;
+/**
+ * Batch-generate .d.ts files for all CSS Modules files based on the config.
+ */
+declare function generateAll(config: Config, cwd?: string): Promise<string[]>;
+//#endregion
+//#region src/scanner.d.ts
+interface UnusedClassWarning {
+  cssFile: string;
+  className: string;
+}
+/**
+ * Scan TS/TSX files under the specified directory
+ * and detect unused CSS Modules class names.
+ */
+declare function scanUnusedClasses(cwd: string): Promise<UnusedClassWarning[]>;
+//#endregion
+//#region src/watcher.d.ts
+declare function startWatcher(config: Config, cwd?: string): chokidar.FSWatcher;
+//#endregion
+export { type Config, type UnusedClassWarning, defineConfig, extractClassNames, generateAll, generateDts, loadConfig, parseFile, scanUnusedClasses, startWatcher, writeDts };

package/dist/index.mjs

@@ -0,0 +1,86 @@
+import { a as parseFile, i as extractClassNames, n as generateDts, o as defineConfig, r as writeDts, s as loadConfig, t as generateAll } from "./generator-CZGTIPYk.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import fg from "fast-glob";
+import { watch } from "chokidar";
+//#region src/scanner.ts
+/**
+* Scan TS/TSX file contents for CSS Modules class name usage.
+* Detects patterns like styles.foo / styles["foo"] / styles['foo'].
+*/
+function findUsedClassNames(tsContent) {
+	const used = /* @__PURE__ */ new Set();
+	for (const match of tsContent.matchAll(/styles\.([a-zA-Z_$][\w$]*)/g)) used.add(match[1]);
+	for (const match of tsContent.matchAll(/styles\[["']([^"']+)["']\]/g)) used.add(match[1]);
+	return used;
+}
+/**
+* Identify the source file of a CSS Modules import.
+* Detects patterns like import styles from './Foo.module.css'.
+*/
+function findCssModuleImports(tsContent) {
+	const imports = [];
+	for (const match of tsContent.matchAll(/import\s+\w+\s+from\s+['"]([^'"]+\.module\.css)['"]/g)) imports.push(match[1]);
+	return imports;
+}
+/**
+* Scan TS/TSX files under the specified directory
+* and detect unused CSS Modules class names.
+*/
+async function scanUnusedClasses(cwd) {
+	const tsFiles = await fg([
+		"**/*.{ts,tsx,js,jsx}",
+		"!node_modules",
+		"!dist",
+		"!__generated__"
+	], {
+		cwd,
+		absolute: true
+	});
+	const warnings = [];
+	for (const tsFile of tsFiles) {
+		const content = await fs.readFile(tsFile, "utf-8");
+		const cssImports = findCssModuleImports(content);
+		if (cssImports.length === 0) continue;
+		const usedNames = findUsedClassNames(content);
+		for (const cssImport of cssImports) {
+			const cssPath = path.resolve(path.dirname(tsFile), cssImport);
+			try {
+				const classNames = await parseFile(cssPath);
+				for (const className of classNames) if (!usedNames.has(className)) warnings.push({
+					cssFile: cssPath,
+					className
+				});
+			} catch {}
+		}
+	}
+	return warnings;
+}
+//#endregion
+//#region src/watcher.ts
+function startWatcher(config, cwd = process.cwd()) {
+	const watcher = watch(config.include, {
+		cwd,
+		ignored: config.exclude,
+		ignoreInitial: false
+	});
+	watcher.on("add", async (filePath) => {
+		await regenerate(filePath, config.outDir, cwd);
+	});
+	watcher.on("change", async (filePath) => {
+		await regenerate(filePath, config.outDir, cwd);
+	});
+	watcher.on("unlink", () => {});
+	return watcher;
+}
+async function regenerate(relativePath, outDir, cwd) {
+	const absolutePath = new URL(relativePath, `file://${cwd}/`).pathname;
+	try {
+		const dtsPath = await writeDts(absolutePath, await parseFile(absolutePath), outDir, cwd);
+		console.log(`[better-css-modules] generated: ${dtsPath}`);
+	} catch (err) {
+		console.error(`[better-css-modules] error processing ${relativePath}:`, err);
+	}
+}
+//#endregion
+export { defineConfig, extractClassNames, generateAll, generateDts, loadConfig, parseFile, scanUnusedClasses, startWatcher, writeDts };

package/dist/loader.cjs

@@ -0,0 +1,16 @@
+const require_generator = require("./generator-BMINjrx4.cjs");
+//#region src/loader.ts
+let configPromise;
+function getConfig(cwd) {
+	if (!configPromise) configPromise = require_generator.loadConfig(cwd);
+	return configPromise;
+}
+async function betterCssModulesLoader(source) {
+	const resourcePath = this.resourcePath;
+	const cwd = this.rootContext || process.cwd();
+	const config = await getConfig(cwd);
+	await require_generator.writeDts(resourcePath, require_generator.extractClassNames(source), config.outDir, cwd);
+	return source;
+}
+//#endregion
+module.exports = betterCssModulesLoader;

package/dist/loader.d.cts

@@ -0,0 +1,3 @@
+//#region src/loader.d.ts
+declare function betterCssModulesLoader(source: string): Promise<string>;
+export = betterCssModulesLoader;

package/dist/loader.d.mts

@@ -0,0 +1,4 @@
+//#region src/loader.d.ts
+declare function betterCssModulesLoader(source: string): Promise<string>;
+//#endregion
+export { betterCssModulesLoader as default };

package/dist/loader.mjs

@@ -0,0 +1,16 @@
+import { i as extractClassNames, r as writeDts, s as loadConfig } from "./generator-CZGTIPYk.mjs";
+//#region src/loader.ts
+let configPromise;
+function getConfig(cwd) {
+	if (!configPromise) configPromise = loadConfig(cwd);
+	return configPromise;
+}
+async function betterCssModulesLoader(source) {
+	const resourcePath = this.resourcePath;
+	const cwd = this.rootContext || process.cwd();
+	const config = await getConfig(cwd);
+	await writeDts(resourcePath, extractClassNames(source), config.outDir, cwd);
+	return source;
+}
+//#endregion
+export { betterCssModulesLoader as default };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@better-css-modules/core",
+  "version": "0.1.1",
+  "license": "MIT",
+  "author": "k8o",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/k35o/better-css-modules.git",
+    "directory": "packages/core"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./loader": {
+      "import": "./dist/loader.mjs",
+      "require": "./dist/loader.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chokidar": "5.0.0",
+    "fast-glob": "3.3.3",
+    "jiti": "2.6.1",
+    "postcss": "8.5.8"
+  },
+  "scripts": {
+    "test": "vp test",
+    "typecheck": "tsc --noEmit"
+  }
+}