classnames-minifier 0.1.0 → 0.1.2-canary.0

package/dist/ClassnamesMinifier.d.ts

@@ -0,0 +1,20 @@
+import type { Config } from './lib/types/plugin';
+import ConverterMinified from './lib/ConverterMinified';
+declare class ClassnamesMinifier {
+    converterMinified: ConverterMinified;
+    constructor(config: Config);
+    get getLocalIdent(): ({ resourcePath }: import("webpack").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/ClassnamesMinifier.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const validateConfig_1 = __importDefault(require("./lib/validateConfig"));
+const ConverterMinified_1 = __importDefault(require("./lib/ConverterMinified"));
+const validateDist_1 = __importDefault(require("./lib/validateDist"));
+class ClassnamesMinifier {
+    constructor(config) {
+        (0, validateConfig_1.default)(config);
+        if (config.cacheDir) {
+            (0, validateDist_1.default)(config);
+        }
+        this.converterMinified = new ConverterMinified_1.default(config);
+    }
+    get getLocalIdent() {
+        return this.converterMinified.getLocalIdent.bind(this.converterMinified);
+    }
+    get preLoader() {
+        return {
+            loader: path_1.default.join(__dirname, './lib/classnames-minifier-preloader.js'),
+            options: {
+                classnamesMinifier: this.converterMinified,
+            },
+        };
+    }
+    get postLoader() {
+        return {
+            loader: path_1.default.join(__dirname, './lib/classnames-minifier-postloader.js'),
+            options: {
+                classnamesMinifier: this.converterMinified,
+            },
+        };
+    }
+}
+;
+exports.default = ClassnamesMinifier;

package/dist/lib/ConverterMinified.d.ts

@@ -0,0 +1,29 @@
+import type { LoaderContext } from 'webpack/types';
+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;
+    dirtyСache: CacheType;
+    private symbols;
+    private freeClasses;
+    lastIndex: number;
+    private nextLoopEndsWith;
+    private currentLoopLength;
+    private nameMap;
+    constructor({ cacheDir, prefix, reservedNames }: Config);
+    private recycleCache;
+    private generateClassName;
+    private getTargetClassName;
+    getLocalIdent({ resourcePath }: LoaderContext<any>, _localIdent: string, origName: string): string;
+}
+export default ConverterMinified;

package/dist/lib/ConverterMinified.js

@@ -0,0 +1,136 @@
+"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 = require("fs");
+const uuid_1 = require("uuid");
+const path_1 = __importDefault(require("path"));
+class ConverterMinified {
+    constructor({ cacheDir, prefix = '', reservedNames = [] }) {
+        this.dirtyСache = {};
+        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.freeClasses = [];
+        this.lastIndex = 0;
+        this.nextLoopEndsWith = 26;
+        this.currentLoopLength = 0;
+        this.nameMap = [0];
+        this.recycleCache = (cacheDir) => {
+            this.cacheDir = cacheDir;
+            if (!(0, fs_1.existsSync)(cacheDir))
+                (0, fs_1.mkdirSync)(cacheDir, { recursive: true });
+            const cachedFiles = (0, fs_1.readdirSync)(cacheDir);
+            if (cachedFiles.length) {
+                console.log('classnames-minifier: Restoring pairs of classes...');
+            }
+            const usedClassNames = [];
+            const dirtyСache = {};
+            let prevLastIndex = 0;
+            cachedFiles.forEach((file) => {
+                const filePath = path_1.default.join(cacheDir, file);
+                const dirtyCacheFile = (0, fs_1.readFileSync)(filePath, { encoding: 'utf8' });
+                const [resourcePath, lastIndex, ...classnames] = dirtyCacheFile.split(',');
+                if (lastIndex && +lastIndex > prevLastIndex)
+                    prevLastIndex = +lastIndex;
+                if ((0, fs_1.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 {
+                    (0, fs_1.rmSync)(filePath);
+                }
+            });
+            let unfoundClassNamesLength = usedClassNames.length;
+            for (let i = 0; i <= prevLastIndex; i++) {
+                const newClass = this.generateClassName();
+                this.lastIndex += 1;
+                const usedClassNameIndex = usedClassNames.indexOf(newClass);
+                if (usedClassNameIndex !== -1) {
+                    unfoundClassNamesLength -= 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;
+        if (cacheDir)
+            this.recycleCache(path_1.default.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) {
+            targetClassName = this.freeClasses.shift();
+        }
+        else {
+            targetClassName = this.generateClassName();
+        }
+        if (this.reservedNames.includes(targetClassName)) {
+            targetClassName = this.getTargetClassName(origName);
+            this.lastIndex += 1;
+        }
+        return targetClassName;
+    }
+    getLocalIdent({ resourcePath }, _localIdent, origName) {
+        if (!this.dirtyСache[resourcePath]) {
+            this.dirtyСache[resourcePath] = {
+                cachePath: this.cacheDir ? path_1.default.join(this.cacheDir, (0, uuid_1.v4)()) : '',
+                matchings: {},
+                type: 'new',
+            };
+        }
+        const currentCache = this.dirtyСache[resourcePath];
+        if (currentCache.matchings[origName])
+            return currentCache.matchings[origName];
+        let targetClassName = this.getTargetClassName(origName);
+        currentCache.matchings[origName] = targetClassName;
+        currentCache.type = 'updated';
+        this.lastIndex += 1;
+        return targetClassName;
+    }
+}
+;
+exports.default = ConverterMinified;

package/dist/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/lib/classnames-minifier-postloader.js

@@ -0,0 +1,18 @@
+"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"));
+function default_1(source, map, meta) {
+    const options = this.getOptions();
+    const classnamesMinifier = options.classnamesMinifier;
+    Object.entries(classnamesMinifier.dirtyСache).forEach(([resourcePath, data]) => {
+        if (data.type !== 'old') {
+            fs_1.default.writeFileSync(data.cachePath, `${resourcePath},${classnamesMinifier.lastIndex},${Object.entries(data.matchings).map(([key, value]) => (`${key}=${value}`)).join(',')}`);
+        }
+    });
+    this.callback(null, source, map, meta);
+    return;
+}
+exports.default = default_1;

package/dist/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/lib/classnames-minifier-preloader.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(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;
+}
+exports.default = default_1;

package/dist/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 = "rabbit";

package/dist/lib/constants/configuration.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODE_VERSION = void 0;
+/**
+ * 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
+ */
+exports.CODE_VERSION = 'rabbit';

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

@@ -0,0 +1,6 @@
+export type Config = {
+    cacheDir?: string;
+    distDir?: string;
+    prefix?: string;
+    reservedNames?: string[];
+};

package/dist/lib/types/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/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/lib/validateConfig.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validKeys = ['prefix', 'reservedNames', 'cacheDir', 'distDir'];
+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`);
+        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`);
+        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/vordgi/classnames-minifier#configuration`);
+        process.exit();
+    }
+    return config;
+};
+exports.default = validateConfig;

package/dist/lib/validateDist.d.ts

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

package/dist/lib/validateDist.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+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) => {
+    var _a, _b;
+    const { cacheDir, distDir, prefix, reservedNames } = pluginOptions;
+    if (!cacheDir || !distDir) {
+        console.log('classnames-minifier: Failed to check the dist folder because cacheDir or distDir is not specified');
+        return;
+    }
+    const manifestDir = path_1.default.join(cacheDir, 'ncm-meta');
+    const manifestPath = path_1.default.join(manifestDir, 'manifest.json');
+    let isImpreciseDist = false;
+    if (fs_1.default.existsSync(manifestPath)) {
+        const prevData = readManifest(manifestPath);
+        if (prevData.prefix !== prefix
+            || prevData.cacheDir !== cacheDir
+            || prevData.distDir !== distDir
+            || ((_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))))
+            || prevData.version !== configuration_1.CODE_VERSION) {
+            isImpreciseDist = true;
+        }
+    }
+    else {
+        isImpreciseDist = true;
+    }
+    if (isImpreciseDist) {
+        console.log('classnames-minifier: Changes found in package configuration. Cleaning the dist folder...');
+        fs_1.default.rmSync(distDir, { recursive: true, force: true });
+        console.log('classnames-minifier: Changes found in package configuration. Dist folder cleared');
+    }
+    if (!fs_1.default.existsSync(manifestDir))
+        fs_1.default.mkdirSync(manifestDir, { recursive: true });
+    fs_1.default.writeFileSync(manifestPath, JSON.stringify(Object.assign(Object.assign({}, pluginOptions), { version: configuration_1.CODE_VERSION })), { encoding: 'utf-8' });
+};
+exports.default = validateDist;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "classnames-minifier",
-  "version": "0.1.0",
+  "version": "0.1.2-canary.0",
   "description": "Library for configuring style modules to generate compressed classes",
   "main": "./dist/ClassnamesMinifier.js",
   "types": "./dist/ClassnamesMinifier.d.ts",