test-forbidden-regex/dist/index.js

Test helper for testing forbidden regex

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.relativeImportStartedFromTwoDots = exports.noImportsInFolder = exports.testForbiddenRegex = void 0;
require("colors");
const fs = require("fs");
const path = require("path");
const DEF_CB = () => { };
function testForbiddenRegex(regularExpressions, folderPath = 'src', errorText = 'Error', cb = DEF_CB) {
    const basePath = process.cwd();
    const folderPathArr = typeof folderPath === 'string' ? [folderPath] : folderPath;
    const srcPath = path.join(basePath, ...folderPathArr);
    const errors = [];
    let counter = 0;
    const regexs = Array.isArray(regularExpressions)
        ? regularExpressions
        : [regularExpressions];
    const scanFile = (pathStr) => {
        return new Promise((resolve, reject) => {
            fs.readFile(pathStr, 'utf8', function (err, contents) {
                if (err) {
                    reject(err);
                    return;
                }
                const localErrors = [];
                regexs.forEach((regex) => {
                    if (contents.match(regex)) {
                        localErrors.push('File file://' +
                            `${pathStr}`.underline +
                            ' contains ' +
                            `${regex}`.red +
                            '. \n' +
                            `${errorText
                                .replace('$folder', folderPathArr.join('/'))
                                .replace('$file', pathStr)}`.yellow);
                    }
                });
                if (localErrors.length) {
                    resolve(localErrors.join(`\n`));
                }
                else {
                    resolve(false);
                }
            });
        });
    };
    const scanDirectory = (pathStr) => {
        return new Promise((resolve, reject) => {
            fs.readdir(pathStr, function (err, files) {
                if (err) {
                    reject(err);
                    return;
                }
                resolve(toPaths(pathStr, files));
            });
        });
    };
    const toPaths = (directory, files) => {
        return files.map((el) => path.resolve(directory, el));
    };
    function scanSrc(directoryPath) {
        return __awaiter(this, void 0, void 0, function* () {
            const files = yield scanDirectory(directoryPath);
            while (files.length) {
                const nestedPath = files.pop();
                if (fs.lstatSync(nestedPath).isDirectory()) {
                    files.push(...(yield scanDirectory(nestedPath)));
                }
                else {
                    const fileExtension = path.extname(nestedPath);
                    if (['.js', '.jsx', '.ts', '.tsx'].includes(fileExtension)) {
                        counter++;
                        const error = yield scanFile(nestedPath);
                        if (error) {
                            errors.push(error);
                        }
                    }
                }
            }
        });
    }
    scanSrc(srcPath).then(() => {
        if (errors.length) {
            const finalError = `\n    ${errors.length} Error${errors.length === 1 ? ' was' : 's where'} found in ${counter} scanned file${counter > 1 ? 's' : ''}:\n\n`.red +
                errors.join(`\n`);
            if (cb) {
                cb(finalError);
            }
            else {
                console.error(finalError);
            }
            process.exitCode = 1;
        }
        else {
            if (cb) {
                cb();
            }
            else {
                console.info(`    ${counter} Files was scanned. No ${regexs.join(', ')} Errors\n`
                    .green);
            }
        }
    });
}
exports.testForbiddenRegex = testForbiddenRegex;
const messageText = (forbiddenImport) => `We could not use `.yellow +
    forbiddenImport.red +
    ` inside ./$folder folder. Please, move it according to project docs`.yellow;
const noImportsInFolder = (folder, pattern, noSrc = false) => {
    const folderPath = folder.split('/');
    if (folderPath[0] !== 'src' && !noSrc) {
        folderPath.unshift('src');
    }
    const patternArr = Array.isArray(pattern)
        ? pattern
        : [pattern];
    const patternRegExpArr = patternArr.map((p) => {
        if (typeof p === 'string') {
            return new RegExp(p, 'g');
        }
        return p;
    });
    return (done) => {
        testForbiddenRegex(patternRegExpArr, folderPath, messageText(patternArr.map((p) => `import ... from ${p}`).join(', ')), done);
    };
};
exports.noImportsInFolder = noImportsInFolder;
exports.relativeImportStartedFromTwoDots = /import (.* from )?['"]\.\.\//gs;