classnames-minifier 1.0.0 → 4.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Alexander Savelyev <vordgi1@gmail.com>
+Copyright (c) 2021 Alex Savelyev <dev@alexdln.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,19 +4,20 @@
 
 Library for configuring style _(css/scss/sass)_ modules to generate compressed classes (`.header` -> `.a`, `.nav` -> `.b`, ..., `.footer` -> `.aad`, etc.) with support for changes and rebuilding without clearing the built application.
 
-*The logic of minifying is taken out of the [next-classnames-minifier](https://github.com/vordgi/next-classnames-minifier) library.*
-
 ## Reasons
-*Compressing classes* can reduce the size of the generated html and css by up to *20%*, which will have a positive effect on page rendering and metrics (primarily [FCP](https://web.dev/first-contentful-paint/))
+
+_Compressing classes_ can reduce the size of the generated html and css by up to _20%_, which will have a positive effect on page rendering and metrics (primarily [FCP](https://web.dev/first-contentful-paint/))
 
 ## Installation
 
 **Using npm:**
+
 ```bash
 npm i classnames-minifier
 ```
 
 **Using yarn:**
+
 ```bash
 yarn add classnames-minifier
 ```
@@ -25,32 +26,31 @@ yarn add classnames-minifier
 
 ### Options
 
-* `prefix` - custom prefix that will be added to each updated class;
-* `reservedNames` - array of reserved names that should not be used by this package (must include prefix);
-* `cacheDir` - directory where this library will write the cache. Passing this parameter will enable caching. Use this option only if your framework really needs it;
-* `distDir` - directory where the project is being assembled. Used only when caching is enabled to synchronize caches between this library and the project;
-* `disableDistDeletion` - option that allows you to disable the automatic deletion of the dist folder if necessary (*f.e. differences in package setup in cache and now or first launch*);
+- `prefix` - custom prefix that will be added to each updated class;
+- `reservedNames` - array of reserved names that should not be used by this package (must include prefix);
+- `cacheDir` - directory where this library will write the cache. Passing this parameter will enable caching. Use this option only if your framework really needs it;
+- `distDir` - directory where the project is being assembled. Used only when caching is enabled to synchronize caches between this library and the project;
+- `disableDistDeletion` - option that allows you to disable the automatic deletion of the dist folder if necessary (_f.e. differences in package setup in cache and now or first launch_);
 
 Configuration example:
+
 ```js
 // webpack.config.js
 const classnamesMinifier = new ClassnamesMinifier({
-    prefix: '_',
-    reservedNames: ['_en', '_de'],
+  prefix: "_",
+  reservedNames: ["_en", "_de"],
 });
 // ...
-loaders.push(
-    {
-        loader: require.resolve('css-loader'),
-        options: {
-            importLoaders: 3,
-            modules: {
-                mode: 'local',
-                getLocalIdent: classnamesMinifier.getLocalIdent,
-            },
-        },
+loaders.push({
+  loader: require.resolve("css-loader"),
+  options: {
+    importLoaders: 3,
+    modules: {
+      mode: "local",
+      getLocalIdent: classnamesMinifier.getLocalIdent,
     },
-);
+  },
+});
 ```
 
 If the framework you are using utilizes component caching between builds, you can configure caching in classnames-minifier as well. As a result, module classes between builds will use the same compressed classes.
@@ -58,26 +58,26 @@ If the framework you are using utilizes component caching between builds, you ca
 ```js
 // webpack.config.js
 const classnamesMinifier = new ClassnamesMinifier({
-    distDir: path.join(process.cwd(), 'build'),
-    cacheDir: path.join(process.cwd(), 'build/cache'),
+  distDir: path.join(process.cwd(), "build"),
+  cacheDir: path.join(process.cwd(), "build/cache"),
 });
 // ...
 loaders.push(
-    classnamesMinifier.postLoader,
-    {
-        loader: require.resolve('css-loader'),
-        options: {
-            importLoaders: 3,
-            modules: {
-                mode: 'local',
-                getLocalIdent: classnamesMinifier.getLocalIdent,
-            },
-        },
+  classnamesMinifier.postLoader,
+  {
+    loader: require.resolve("css-loader"),
+    options: {
+      importLoaders: 3,
+      modules: {
+        mode: "local",
+        getLocalIdent: classnamesMinifier.getLocalIdent,
+      },
     },
-    classnamesMinifier.preLoader,
+  },
+  classnamesMinifier.preLoader
 );
 ```
 
 ## License
 
-[MIT](https://github.com/vordgi/classnames-minifier/blob/main/LICENSE)
+[MIT](https://github.com/alexdln/classnames-minifier/blob/main/LICENSE)

package/dist/{ClassnamesMinifier.d.ts → cjs/ClassnamesMinifier.d.ts}

@@ -1,6 +1,7 @@
 import type { LoaderContext } from "webpack";
 import type { Config } from "./lib/types/plugin";
 import ConverterMinified from "./lib/ConverterMinified";
+export * from "./lib/types/plugin";
 declare class ClassnamesMinifier {
     converterMinified: ConverterMinified;
     constructor(config: Config);

package/dist/{ClassnamesMinifier.js → cjs/ClassnamesMinifier.js}

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,6 +24,7 @@ const validateConfig_1 = __importDefault(require("./lib/validateConfig"));
 const ConverterMinified_1 = __importDefault(require("./lib/ConverterMinified"));
 const validateDist_1 = __importDefault(require("./lib/validateDist"));
 const removeDist_1 = __importDefault(require("./lib/removeDist"));
+__exportStar(require("./lib/types/plugin"), exports);
 class ClassnamesMinifier {
     constructor(config) {
         (0, validateConfig_1.default)(config);
@@ -57,7 +72,7 @@ class ClassnamesMinifier {
             }
             if (!fs_1.default.existsSync(manifestDir))
                 fs_1.default.mkdirSync(manifestDir, { recursive: true });
-            fs_1.default.writeFileSync(manifestPath, JSON.stringify(Object.assign(Object.assign({}, config), { version: configuration_1.CODE_VERSION })), { encoding: "utf-8" });
+            fs_1.default.writeFileSync(manifestPath, JSON.stringify({ ...config, version: configuration_1.CODE_VERSION }), { encoding: "utf-8" });
         }
     }
     get getLocalIdent() {

package/dist/{lib → cjs/lib}/validateConfig.js

@@ -13,12 +13,12 @@ const validateIsObject = (config) => {
     if (!config)
         return false;
     if (typeof config !== "object" || Array.isArray(config)) {
-        console.error(`classnames-minifier: Invalid configuration. Expected object, received ${typeof config}. See https://github.com/vordgi/classnames-minifier#configuration`);
+        console.error(`classnames-minifier: Invalid configuration. Expected object, received ${typeof config}. See https://github.com/alexdln/classnames-minifier#configuration`);
         process.exit();
     }
     const isValidKeys = Object.keys(config).every((key) => validKeys.includes(key));
     if (!isValidKeys) {
-        console.error(`classnames-minifier: Invalid configuration. Valid keys are: ${validKeys.join(", ")}. See https://github.com/vordgi/classnames-minifier#configuration`);
+        console.error(`classnames-minifier: Invalid configuration. Valid keys are: ${validKeys.join(", ")}. See https://github.com/alexdln/classnames-minifier#configuration`);
         process.exit();
     }
     return true;
@@ -27,7 +27,7 @@ const validateConfig = (config = {}) => {
     if (!validateIsObject(config))
         return {};
     if (config.prefix && !config.prefix.match(/^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/)) {
-        console.error(`classnames-minifier: Invalid prefix. It should match following rule: "^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$". See https://github.com/vordgi/classnames-minifier#configuration`);
+        console.error(`classnames-minifier: Invalid prefix. It should match following rule: "^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$". See https://github.com/alexdln/classnames-minifier#configuration`);
         process.exit();
     }
     return config;

package/dist/{lib → cjs/lib}/validateDist.js

@@ -10,7 +10,7 @@ const readManifest = (manifestPath) => {
         const prevData = fs_1.default.readFileSync(manifestPath, { encoding: "utf-8" });
         return JSON.parse(prevData);
     }
-    catch (_a) {
+    catch {
         return {};
     }
 };

package/dist/esm/ClassnamesMinifier.d.ts

@@ -0,0 +1,22 @@
+import type { LoaderContext } from "webpack";
+import type { Config } from "./lib/types/plugin";
+import ConverterMinified from "./lib/ConverterMinified";
+export * from "./lib/types/plugin";
+declare class ClassnamesMinifier {
+    converterMinified: ConverterMinified;
+    constructor(config: Config);
+    get getLocalIdent(): ({ resourcePath }: LoaderContext<any>, _localIdent: string, origName: string) => string;
+    get preLoader(): {
+        loader: string;
+        options: {
+            classnamesMinifier: ConverterMinified;
+        };
+    };
+    get postLoader(): {
+        loader: string;
+        options: {
+            classnamesMinifier: ConverterMinified;
+        };
+    };
+}
+export default ClassnamesMinifier;

package/dist/esm/ClassnamesMinifier.js

@@ -0,0 +1,79 @@
+import fs from "fs";
+import path from "path";
+import { CODE_VERSION } from "./lib/constants/configuration";
+import validateConfig from "./lib/validateConfig";
+import ConverterMinified from "./lib/ConverterMinified";
+import validateDist from "./lib/validateDist";
+import removeDist from "./lib/removeDist";
+export * from "./lib/types/plugin";
+class ClassnamesMinifier {
+    constructor(config) {
+        validateConfig(config);
+        this.converterMinified = new ConverterMinified(config);
+        if (!config.cacheDir || !config.distDir) {
+            console.log("classnames-minifier: Failed to check the dist folder because cacheDir or distDir is not specified");
+        }
+        else {
+            const manifestDir = path.join(config.cacheDir, "ncm-meta");
+            const manifestPath = path.join(manifestDir, "manifest.json");
+            const { distDeletionPolicy = "error" } = config;
+            let distCleared = false;
+            if (config.cacheDir) {
+                const errors = validateDist(config, manifestPath);
+                if (errors) {
+                    console.log(`classnames-minifier: "distDeletionPolicy" option was set to "${distDeletionPolicy}"`);
+                    if (distDeletionPolicy === "auto") {
+                        removeDist(config.distDir, errors);
+                        distCleared = true;
+                    }
+                    else if (distDeletionPolicy === "error") {
+                        throw new Error(`classnames-minifier: Please, remove dist dir manually. ${errors}`);
+                    }
+                    else {
+                        console.warn(`classnames-minifier: Please, remove dist dir manually. ${errors}`);
+                    }
+                }
+            }
+            const { syncFreedNames, freedNamesLimit = 100000 } = config.experimental || {};
+            if (!syncFreedNames && this.converterMinified.freeClasses.length > freedNamesLimit && config.distDir) {
+                console.log(`classnames-minifier: "distDeletionPolicy" option was set to "${distDeletionPolicy}"`);
+                if (distDeletionPolicy === "auto") {
+                    removeDist(config.distDir, `Freed names exceeds the limit (${freedNamesLimit})`);
+                    distCleared = true;
+                }
+                else if (distDeletionPolicy === "error") {
+                    throw new Error(`Please, remove dist dir manually. Freed names exceeds the limit (${freedNamesLimit})`);
+                }
+                else {
+                    console.warn(`Please, remove dist dir manually. Freed names exceeds the limit (${freedNamesLimit})`);
+                }
+            }
+            if (distCleared) {
+                this.converterMinified.reset();
+            }
+            if (!fs.existsSync(manifestDir))
+                fs.mkdirSync(manifestDir, { recursive: true });
+            fs.writeFileSync(manifestPath, JSON.stringify({ ...config, version: CODE_VERSION }), { encoding: "utf-8" });
+        }
+    }
+    get getLocalIdent() {
+        return this.converterMinified.getLocalIdent.bind(this.converterMinified);
+    }
+    get preLoader() {
+        return {
+            loader: path.join(__dirname, "./lib/classnames-minifier-preloader.js"),
+            options: {
+                classnamesMinifier: this.converterMinified,
+            },
+        };
+    }
+    get postLoader() {
+        return {
+            loader: path.join(__dirname, "./lib/classnames-minifier-postloader.js"),
+            options: {
+                classnamesMinifier: this.converterMinified,
+            },
+        };
+    }
+}
+export default ClassnamesMinifier;

package/dist/esm/lib/ConverterMinified.d.ts

@@ -0,0 +1,31 @@
+import type { LoaderContext } from "webpack";
+import type { Config } from "./types/plugin";
+type CacheType = {
+    [resourcePath: string]: {
+        cachePath: string;
+        matchings: {
+            [origClass: string]: string;
+        };
+        type: "new" | "updated" | "old";
+    };
+};
+declare class ConverterMinified {
+    private cacheDir?;
+    private prefix;
+    private reservedNames;
+    private syncFreedNames;
+    private symbols;
+    dirtyСache: CacheType;
+    freeClasses: string[];
+    lastIndex: number;
+    private nextLoopEndsWith;
+    private currentLoopLength;
+    private nameMap;
+    constructor({ cacheDir, prefix, reservedNames, experimental }: Config);
+    reset: () => void;
+    private invalidateCache;
+    private generateClassName;
+    private getTargetClassName;
+    getLocalIdent({ resourcePath }: LoaderContext<any>, _localIdent: string, origName: string): string;
+}
+export default ConverterMinified;

package/dist/esm/lib/ConverterMinified.js

@@ -0,0 +1,203 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
+import { v4 as uuidv4 } from "uuid";
+import path from "path";
+class ConverterMinified {
+    constructor({ cacheDir, prefix = "", reservedNames = [], experimental }) {
+        this.symbols = [
+            "a",
+            "b",
+            "c",
+            "d",
+            "e",
+            "f",
+            "g",
+            "h",
+            "i",
+            "j",
+            "k",
+            "l",
+            "m",
+            "n",
+            "o",
+            "p",
+            "q",
+            "r",
+            "s",
+            "t",
+            "u",
+            "v",
+            "w",
+            "x",
+            "y",
+            "z",
+            "A",
+            "B",
+            "C",
+            "D",
+            "E",
+            "F",
+            "G",
+            "H",
+            "I",
+            "J",
+            "K",
+            "L",
+            "M",
+            "N",
+            "O",
+            "P",
+            "Q",
+            "R",
+            "S",
+            "T",
+            "U",
+            "V",
+            "W",
+            "X",
+            "Y",
+            "Z",
+            "0",
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9",
+        ];
+        this.dirtyСache = {};
+        this.freeClasses = [];
+        this.lastIndex = 0;
+        this.nextLoopEndsWith = 26;
+        this.currentLoopLength = 0;
+        this.nameMap = [0];
+        this.reset = () => {
+            this.dirtyСache = {};
+            this.freeClasses = [];
+            this.lastIndex = 0;
+            this.nextLoopEndsWith = 26;
+            this.currentLoopLength = 0;
+            this.nameMap = [0];
+            if (this.cacheDir) {
+                this.invalidateCache(this.cacheDir);
+            }
+        };
+        this.invalidateCache = (cacheDir) => {
+            this.cacheDir = cacheDir;
+            if (!existsSync(cacheDir))
+                mkdirSync(cacheDir, { recursive: true });
+            const cachedFiles = readdirSync(cacheDir);
+            if (cachedFiles.length) {
+                console.log("classnames-minifier: Restoring pairs of classes...");
+            }
+            else {
+                return;
+            }
+            const usedClassNames = [];
+            const dirtyСache = {};
+            let prevLastIndex = 0;
+            cachedFiles.forEach((file) => {
+                const filePath = path.join(cacheDir, file);
+                const dirtyCacheFile = readFileSync(filePath, { encoding: "utf8" });
+                const [resourcePath, lastIndex, ...classnames] = dirtyCacheFile.split(",");
+                if (lastIndex && +lastIndex > prevLastIndex)
+                    prevLastIndex = +lastIndex;
+                if (existsSync(resourcePath)) {
+                    const cachedMatchings = classnames.reduce((acc, cur) => {
+                        const [origClass, newClass] = cur.split("=");
+                        acc[origClass] = newClass;
+                        if (!usedClassNames.includes(newClass)) {
+                            usedClassNames.push(newClass);
+                        }
+                        return acc;
+                    }, {});
+                    dirtyСache[resourcePath] = {
+                        cachePath: filePath,
+                        matchings: cachedMatchings,
+                        type: "old",
+                    };
+                }
+                else {
+                    rmSync(filePath);
+                }
+            });
+            for (let i = 0; i <= prevLastIndex; i++) {
+                const newClass = this.generateClassName();
+                this.lastIndex += 1;
+                const usedClassNameIndex = usedClassNames.indexOf(newClass);
+                if (usedClassNameIndex !== -1) {
+                    usedClassNames.splice(usedClassNameIndex, 1);
+                }
+                else if (!this.reservedNames.includes(newClass)) {
+                    this.freeClasses.push(newClass);
+                }
+            }
+            if (cachedFiles.length) {
+                console.log("classnames-minifier: Pairs restored");
+            }
+            this.dirtyСache = dirtyСache;
+        };
+        this.prefix = prefix;
+        this.reservedNames = reservedNames;
+        this.syncFreedNames = Boolean(experimental === null || experimental === void 0 ? void 0 : experimental.syncFreedNames);
+        if (cacheDir)
+            this.invalidateCache(path.join(cacheDir, "ncm"));
+    }
+    generateClassName() {
+        const symbolsCount = 62;
+        if (this.lastIndex >= this.nextLoopEndsWith) {
+            if (this.nextLoopEndsWith === 26)
+                this.nextLoopEndsWith = 62 * symbolsCount;
+            else
+                this.nextLoopEndsWith = this.nextLoopEndsWith * symbolsCount;
+            this.nameMap.push(0);
+            this.currentLoopLength += 1;
+        }
+        const currentClassname = this.prefix + this.nameMap.map((e) => this.symbols[e]).join("");
+        for (let i = this.currentLoopLength; i >= 0; i--) {
+            if (this.nameMap[i] === symbolsCount - 1 || (i === 0 && this.nameMap[i] === 25)) {
+                this.nameMap[i] = 0;
+            }
+            else {
+                this.nameMap[i] += 1;
+                break;
+            }
+        }
+        return currentClassname;
+    }
+    getTargetClassName(origName) {
+        let targetClassName;
+        if (this.freeClasses.length && this.syncFreedNames) {
+            targetClassName = this.freeClasses.shift();
+        }
+        else {
+            targetClassName = this.generateClassName();
+        }
+        if (this.reservedNames.includes(targetClassName)) {
+            targetClassName = this.getTargetClassName(origName);
+            this.lastIndex += 1;
+        }
+        return targetClassName;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getLocalIdent({ resourcePath }, _localIdent, origName) {
+        if (!this.dirtyСache[resourcePath]) {
+            this.dirtyСache[resourcePath] = {
+                cachePath: this.cacheDir ? path.join(this.cacheDir, uuidv4()) : "",
+                matchings: {},
+                type: "new",
+            };
+        }
+        const currentCache = this.dirtyСache[resourcePath];
+        if (currentCache.matchings[origName])
+            return currentCache.matchings[origName];
+        const targetClassName = this.getTargetClassName(origName);
+        currentCache.matchings[origName] = targetClassName;
+        currentCache.type = "updated";
+        this.lastIndex += 1;
+        return targetClassName;
+    }
+}
+export default ConverterMinified;

package/dist/esm/lib/classnames-minifier-postloader.d.ts

@@ -0,0 +1,5 @@
+import type { LoaderContext } from "webpack";
+import type ConverterMinified from "./ConverterMinified";
+export default function (this: LoaderContext<{
+    classnamesMinifier: ConverterMinified;
+}>, source: string, map: any, meta: any): void;

package/dist/esm/lib/classnames-minifier-postloader.js

@@ -0,0 +1,14 @@
+import fs from "fs";
+export default function (source, map, meta) {
+    const options = this.getOptions();
+    const classnamesMinifier = options.classnamesMinifier;
+    Object.entries(classnamesMinifier.dirtyСache).forEach(([resourcePath, data]) => {
+        if (data.type !== "old") {
+            fs.writeFileSync(data.cachePath, `${resourcePath},${classnamesMinifier.lastIndex},${Object.entries(data.matchings)
+                .map(([key, value]) => `${key}=${value}`)
+                .join(",")}`);
+        }
+    });
+    this.callback(null, source, map, meta);
+    return;
+}

package/dist/esm/lib/classnames-minifier-preloader.d.ts

@@ -0,0 +1,5 @@
+import type { LoaderContext } from "webpack";
+import type ConverterMinified from "./ConverterMinified";
+export default function (this: LoaderContext<{
+    classnamesMinifier: ConverterMinified;
+}>, source: string, map: any, meta: any): void;

package/dist/esm/lib/classnames-minifier-preloader.js

@@ -0,0 +1,16 @@
+export default function (source, map, meta) {
+    const options = this.getOptions();
+    const classnamesMinifier = options.classnamesMinifier;
+    const maybeClassesList = source.match(/\.-?[_a-zA-Z]+[_a-zA-Z0-9-]*/g);
+    const cache = classnamesMinifier.dirtyСache[this.resourcePath];
+    /**
+     * if some class has ceased to be used since the last time the file was loaded, we remove it from the cache
+     */
+    if (cache && cache.matchings) {
+        cache.matchings = maybeClassesList
+            ? Object.fromEntries(Object.entries(cache.matchings).filter(([key]) => maybeClassesList === null || maybeClassesList === void 0 ? void 0 : maybeClassesList.includes(`.${key}`)))
+            : {};
+    }
+    this.callback(null, source, map, meta);
+    return;
+}

package/dist/esm/lib/constants/configuration.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Just a version of the code whose change means that the logic has a critical update
+ * and minifying the previous version is not compatible with the current one,
+ * which would mean that we should clean dist folder
+ */
+export declare const CODE_VERSION = "parrot";

package/dist/esm/lib/constants/configuration.js

@@ -0,0 +1,6 @@
+/**
+ * Just a version of the code whose change means that the logic has a critical update
+ * and minifying the previous version is not compatible with the current one,
+ * which would mean that we should clean dist folder
+ */
+export const CODE_VERSION = "parrot";

package/dist/esm/lib/removeDist.d.ts

@@ -0,0 +1,2 @@
+declare const removeDist: (distDir: string, message: string) => void;
+export default removeDist;

package/dist/esm/lib/removeDist.js

@@ -0,0 +1,7 @@
+import { rmSync } from "fs";
+const removeDist = (distDir, message) => {
+    console.log(`classnames-minifier: ${message}Cleaning the dist folder...`);
+    rmSync(distDir, { recursive: true, force: true });
+    console.log("classnames-minifier: Dist folder cleared");
+};
+export default removeDist;

package/dist/esm/lib/types/plugin.d.ts

@@ -0,0 +1,60 @@
+export type Config = {
+    /**
+     * The directory where the package cache will be written
+     */
+    cacheDir?: string;
+    /**
+     * Directory where the project is built
+     */
+    distDir?: string;
+    /**
+     * Prefix which will be added to each generated name
+     */
+    prefix?: string;
+    /**
+     * Reserved minified names. Use this option if you are adding short classes manually
+     */
+    reservedNames?: string[];
+    /**
+     * Package policy to resolve potential problems with minified classes
+     *
+     * This may happen due to the following reasons:
+     *
+     * 1. Launching the package for the first time. Package need clean next.js cache to put everything in the correct order
+     * 2. Changing the package configuration. Package need clean next.js cache to rebuild it with classes according to the new rules
+     * 3. Exceeding the limit on freed classes (these are classes that were used before, but are now *probably* no longer used)
+     *
+     * @param "warning" - a warning message will simply be displayed.
+     * With this option, there is a high risk of errors and duplicates of generated classes.
+     *
+     * @param "error" - an error will be thrown, and as a result the build will stop.
+     * If this option occurs, delete the next.js cache manually and restart the build.
+     *
+     * @param "auto" - the package will automatically delete the next.js cache directory.
+     *
+     * @default "error"
+     */
+    distDeletionPolicy?: "warning" | "error" | "auto";
+    /**
+     * Additional check of the dist directory for freshness
+     */
+    checkDistFreshness?: () => boolean;
+    experimental?: {
+        /**
+         * Automatically synchronize freed classes (for example, if you deleted the original styles)
+         * Such classes will be reused in new locations. In this case, there may be situations that the package
+         * will mistakenly consider them freed and reuse the class again, thereby creating duplicates.
+         *
+         * Be careful using this option
+         * @default false
+         */
+        syncFreedNames?: boolean;
+        /**
+         * Limit of unused minified classes. Such classes are not reused by default,
+         * since the package cannot be sure of this at this time.
+         *
+         * @default 100000
+         */
+        freedNamesLimit?: number;
+    };
+};

package/dist/esm/lib/types/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/lib/validateConfig.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from "./types/plugin";
+declare const validateConfig: (config?: unknown) => Config;
+export default validateConfig;

package/dist/esm/lib/validateConfig.js

@@ -0,0 +1,33 @@
+const validKeys = [
+    "prefix",
+    "reservedNames",
+    "cacheDir",
+    "distDir",
+    "distDeletionPolicy",
+    "experimental",
+    "checkDistFreshness",
+];
+const validateIsObject = (config) => {
+    if (!config)
+        return false;
+    if (typeof config !== "object" || Array.isArray(config)) {
+        console.error(`classnames-minifier: Invalid configuration. Expected object, received ${typeof config}. See https://github.com/alexdln/classnames-minifier#configuration`);
+        process.exit();
+    }
+    const isValidKeys = Object.keys(config).every((key) => validKeys.includes(key));
+    if (!isValidKeys) {
+        console.error(`classnames-minifier: Invalid configuration. Valid keys are: ${validKeys.join(", ")}. See https://github.com/alexdln/classnames-minifier#configuration`);
+        process.exit();
+    }
+    return true;
+};
+const validateConfig = (config = {}) => {
+    if (!validateIsObject(config))
+        return {};
+    if (config.prefix && !config.prefix.match(/^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/)) {
+        console.error(`classnames-minifier: Invalid prefix. It should match following rule: "^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$". See https://github.com/alexdln/classnames-minifier#configuration`);
+        process.exit();
+    }
+    return config;
+};
+export default validateConfig;

package/dist/esm/lib/validateDist.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from "./types/plugin";
+declare const validateDist: (pluginOptions: Config, manifestPath: string) => string | undefined;
+export default validateDist;

package/dist/esm/lib/validateDist.js

@@ -0,0 +1,51 @@
+import fs from "fs";
+import { CODE_VERSION } from "./constants/configuration";
+const readManifest = (manifestPath) => {
+    try {
+        const prevData = fs.readFileSync(manifestPath, { encoding: "utf-8" });
+        return JSON.parse(prevData);
+    }
+    catch {
+        return {};
+    }
+};
+const validateDist = (pluginOptions, manifestPath) => {
+    var _a, _b, _c;
+    const { cacheDir, distDir, prefix, reservedNames, distDeletionPolicy, checkDistFreshness } = pluginOptions;
+    if (!cacheDir || !distDir) {
+        console.log("classnames-minifier: Failed to check the dist folder because cacheDir or distDir is not specified");
+        return;
+    }
+    let configurationError = "";
+    if (fs.existsSync(manifestPath)) {
+        const prevData = readManifest(manifestPath);
+        const configDiffMessages = [];
+        if (prevData.prefix !== prefix) {
+            configDiffMessages.push(`Different "prefix": "${prevData.prefix}" -> "${prefix}"`);
+        }
+        if (prevData.cacheDir !== cacheDir) {
+            configDiffMessages.push(`Different "cacheDir": "${prevData.cacheDir}" -> "${cacheDir}"`);
+        }
+        if (prevData.distDir !== distDir) {
+            configDiffMessages.push(`Different "distDir": "${prevData.distDir}" -> "${distDir}"`);
+        }
+        if (((_a = prevData.reservedNames) === null || _a === void 0 ? void 0 : _a.length) !== (reservedNames === null || reservedNames === void 0 ? void 0 : reservedNames.length) ||
+            ((_b = prevData.reservedNames) === null || _b === void 0 ? void 0 : _b.some((name) => !(reservedNames === null || reservedNames === void 0 ? void 0 : reservedNames.includes(name))))) {
+            configDiffMessages.push(`Different "reservedNames": "${(_c = prevData.reservedNames) === null || _c === void 0 ? void 0 : _c.join(", ")}" -> "${reservedNames === null || reservedNames === void 0 ? void 0 : reservedNames.join(", ")}"`);
+        }
+        if (prevData.version !== CODE_VERSION) {
+            configDiffMessages.push(`Different package version: "${prevData.version}" -> "${CODE_VERSION}"`);
+        }
+        if (prevData.distDeletionPolicy && !distDeletionPolicy) {
+            configDiffMessages.push(`"distDeletionPolicy" set to "${distDeletionPolicy}"`);
+        }
+        if (configDiffMessages.length) {
+            configurationError = `Changes found in package configuration: \n${configDiffMessages.map((message) => `- ${message};\n`).join("")}`;
+        }
+    }
+    else if (!(checkDistFreshness === null || checkDistFreshness === void 0 ? void 0 : checkDistFreshness())) {
+        configurationError = `Can not find the package cache manifest at ${manifestPath}\n`;
+    }
+    return configurationError;
+};
+export default validateDist;

package/package.json

@@ -1,18 +1,29 @@
 {
   "name": "classnames-minifier",
-  "version": "1.0.0",
+  "version": "4.1.0",
   "description": "Library for configuring style modules to generate compressed classes",
-  "main": "./dist/ClassnamesMinifier.js",
-  "types": "./dist/ClassnamesMinifier.d.ts",
+  "main": "dist/cjs/ClassnamesMinifier.js",
+  "module": "dist/esm/ClassnamesMinifier.mjs",
+  "types": "dist/cjs/ClassnamesMinifier.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "pnpm run build:cjs && pnpm run build:esm",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
     "lint": "eslint .",
     "eslint": "eslint",
     "prepare": "husky"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/cjs/ClassnamesMinifier.d.ts",
+      "import": "./dist/esm/ClassnamesMinifier.mjs",
+      "require": "./dist/cjs/ClassnamesMinifier.js",
+      "default": "./dist/esm/ClassnamesMinifier.mjs"
+    }
+  },
   "keywords": [
     "classname",
     "class",
@@ -26,31 +37,25 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/vordgi/classnames-minifier.git"
+    "url": "git://github.com/alexdln/nimpl-classnames-minifier.git"
   },
   "author": {
-    "name": "Savelyev Alexander",
-    "email": "vordgi1@gmail.com",
-    "url": "https://github.com/vordgi/"
+    "name": "Alex Savelyev",
+    "email": "dev@alexdln.com",
+    "url": "https://github.com/alexdln/"
   },
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "16.11.12",
-    "@types/uuid": "9.0.7",
-    "@types/webpack": "5.28.0",
-    "css-loader": "6.9.0",
-    "typescript": "5.2.2",
-    "eslint": "8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "husky": "^9.0.11",
-    "prettier": "^3.2.5",
-    "typescript-eslint": "^7.6.0"
+    "@types/node": "25.0.3",
+    "@types/uuid": "11.0.0",
+    "@types/webpack": "5.28.5",
+    "css-loader": "7.1.2",
+    "typescript": "5.9.3"
   },
   "peerDependencies": {
     "css-loader": ">=4.0.0"
   },
   "dependencies": {
-    "uuid": "9.0.1"
+    "uuid": "13.0.0"
   }
-}
+}

package/dist/{lib → cjs/lib}/classnames-minifier-postloader.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
 const fs_1 = __importDefault(require("fs"));
 function default_1(source, map, meta) {
     const options = this.getOptions();
@@ -17,4 +18,3 @@ function default_1(source, map, meta) {
     this.callback(null, source, map, meta);
     return;
 }
-exports.default = default_1;

package/dist/{lib → cjs/lib}/classnames-minifier-preloader.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
 function default_1(source, map, meta) {
     const options = this.getOptions();
     const classnamesMinifier = options.classnamesMinifier;
@@ -16,4 +17,3 @@ function default_1(source, map, meta) {
     this.callback(null, source, map, meta);
     return;
 }
-exports.default = default_1;