classnames-minifier 0.0.0-experimental-6b8a553

package/dist/cjs/lib/validateDist.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const configuration_1 = require("./constants/configuration");
+const readManifest = (manifestPath) => {
+    try {
+        const prevData = fs_1.default.readFileSync(manifestPath, { encoding: "utf-8" });
+        return JSON.parse(prevData);
+    }
+    catch (_a) {
+        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_1.default.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 !== configuration_1.CODE_VERSION) {
+            configDiffMessages.push(`Different package version: "${prevData.version}" -> "${configuration_1.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;
+};
+exports.default = validateDist;

package/dist/esm/ClassnamesMinifier.d.ts

@@ -0,0 +1,21 @@
+import type { LoaderContext } from "webpack";
+import type { Config } from "./lib/types/plugin";
+import ConverterMinified from "./lib/ConverterMinified";
+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";
+class ClassnamesMinifier {
+    converterMinified;
+    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,207 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
+import { v4 as uuidv4 } from "uuid";
+import path from "path";
+class ConverterMinified {
+    cacheDir;
+    prefix;
+    reservedNames;
+    syncFreedNames;
+    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",
+    ];
+    dirtyСache = {};
+    freeClasses = [];
+    lastIndex = 0;
+    nextLoopEndsWith = 26;
+    currentLoopLength = 0;
+    nameMap = [0];
+    constructor({ cacheDir, prefix = "", reservedNames = [], experimental }) {
+        this.prefix = prefix;
+        this.reservedNames = reservedNames;
+        this.syncFreedNames = Boolean(experimental?.syncFreedNames);
+        if (cacheDir)
+            this.invalidateCache(path.join(cacheDir, "ncm"));
+    }
+    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);
+        }
+    };
+    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;
+    };
+    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?.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,50 @@
+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) => {
+    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 (prevData.reservedNames?.length !== reservedNames?.length ||
+            prevData.reservedNames?.some((name) => !reservedNames?.includes(name))) {
+            configDiffMessages.push(`Different "reservedNames": "${prevData.reservedNames?.join(", ")}" -> "${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?.()) {
+        configurationError = `Can not find the package cache manifest at ${manifestPath}\n`;
+    }
+    return configurationError;
+};
+export default validateDist;