dfa-test - npm Package Compare versions

Comparing version 0.0.1 to 0.0.2

dist/index.d.ts

@@ -1,29 +0,3 @@
-import cliProgress from 'cli-progress';
-import { IDfaModule } from './types';
-declare type IConfigs = {
-    type: 'generate';
-    random?: {
-        total: number;
-        minLength: number;
-        maxLength: number;
-    };
-    range?: undefined | null;
-} | {
-    type: 'generate';
-    range: {
-        bitLimit: number;
-    };
-    random?: undefined | null;
-} | {
-    type: 'file';
-    filePath: string;
-};
-export declare class DfaTest {
-    #private;
-    dfas: IDfaModule[];
-    cliProgressBar: cliProgress.SingleBar;
-    logsPath: string;
-    constructor(dfas: IDfaModule[], logsPath: string);
-    test(configs: IConfigs): Promise<void>;
-}
+export * from './libs';
 export * from './types';
+export * from './utils';

dist/index.js

@@ -12,122 +12,5 @@ "use strict";
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DfaTest = void 0;
-const cli_progress_1 = __importDefault(require("cli-progress"));
-const colors_1 = __importDefault(require("colors"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const utils_1 = require("./utils");
-class DfaTest {
-    dfas;
-    cliProgressBar;
-    logsPath;
-    constructor(dfas, logsPath) {
-        this.dfas = dfas;
-        this.cliProgressBar = new cli_progress_1.default.SingleBar({
-            stopOnComplete: true,
-            format: colors_1.default.green('{bar}') + '| {percentage}% || {value}/{total} Chunks',
-        }, cli_progress_1.default.Presets.shades_classic);
-        this.logsPath = logsPath;
-        if (!fs_1.default.existsSync(logsPath)) {
-            fs_1.default.mkdirSync(logsPath);
-        }
-    }
-    #createFileWriteStreams(dfaLabel) {
-        const generatedStreams = [
-            `${dfaLabel}.txt`,
-            `${dfaLabel}.incorrect.txt`,
-            `${dfaLabel}.correct.txt`,
-            `${dfaLabel}.input.txt`,
-        ].map((fileName) => fs_1.default.createWriteStream(path_1.default.resolve(this.logsPath, fileName)));
-        return {
-            streams: generatedStreams,
-            endStreams() {
-                generatedStreams.forEach((generatedStream) => generatedStream.end());
-            },
-        };
-    }
-    #testDfas(dfaModuleInfos, writeStreams, binaryStrings, post) {
-        this.dfas.forEach((dfaModule, dfaModuleIndex) => {
-            const [dfaWriteStream, dfaIncorrectStringsWriteStream, dfaCorrectStringsWriteStream, dfaInputStringsWriteStream,] = writeStreams[dfaModuleIndex];
-            const dfaModuleInfo = dfaModuleInfos[dfaModuleIndex];
-            for (let i = 0; i < binaryStrings.length; i++) {
-                const binaryString = binaryStrings[i].replace('\r', '');
-                const logicTestResult = dfaModule.testLogic(binaryString);
-                const dfaModuleResult = (0, utils_1.testDfa)(dfaModule.DFA, binaryString);
-                const isWrong = dfaModuleResult !== logicTestResult;
-                if (!isWrong) {
-                    if (dfaModuleResult === false && logicTestResult === false) {
-                        dfaModuleInfo.trueNegatives += 1;
-                    }
-                    else {
-                        dfaModuleInfo.truePositives += 1;
-                    }
-                    dfaCorrectStringsWriteStream.write(binaryString + ' ' + dfaModuleResult + ' ' + logicTestResult + '\n');
-                }
-                else {
-                    if (dfaModuleResult && !logicTestResult) {
-                        dfaModuleInfo.falsePositives += 1;
-                    }
-                    else {
-                        dfaModuleInfo.falseNegatives += 1;
-                    }
-                    dfaIncorrectStringsWriteStream.write(binaryString + ' ' + dfaModuleResult + ' ' + logicTestResult + '\n');
-                }
-                dfaInputStringsWriteStream.write(binaryString + '\n');
-                const { withoutColors } = (0, utils_1.generateCaseMessage)(isWrong, binaryString, dfaModuleResult, logicTestResult);
-                dfaWriteStream.write(withoutColors + '\n');
-                this.cliProgressBar.increment(1);
-            }
-            post && post(dfaModule, dfaModuleIndex);
-        });
-    }
-    #postTest(dfaModule, dfaModuleInfo, dfaModuleWriteStreams) {
-        const { streams: [dfaWriteStream], endStreams, } = dfaModuleWriteStreams;
-        const { withoutColors, withColors } = (0, utils_1.generateAggregateMessage)(dfaModule.DFA.label, dfaModule.DFA.description, dfaModuleInfo.falsePositives, dfaModuleInfo.falseNegatives, dfaModuleInfo.truePositives, dfaModuleInfo.trueNegatives);
-        console.log('\n' + withColors);
-        dfaWriteStream.write(withoutColors);
-        endStreams();
-    }
-    async test(configs) {
-        const writeStreams = this.dfas.map((dfaModule) => this.#createFileWriteStreams(dfaModule.DFA.label));
-        const readStream = configs.type === 'file' ? fs_1.default.createReadStream(configs.filePath) : null;
-        const dfaModuleInfos = this.dfas.map(() => ({
-            falsePositives: 0,
-            falseNegatives: 0,
-            truePositives: 0,
-            trueNegatives: 0,
-        }));
-        if (configs.type === 'file' && readStream) {
-            this.cliProgressBar.start(2097712 * this.dfas.length, 0, {
-                speed: 'N/A',
-            });
-            for await (const chunks of readStream) {
-                const binaryStrings = chunks.toString().split('\n');
-                this.#testDfas(dfaModuleInfos, writeStreams.map(({ streams }) => streams), binaryStrings);
-            }
-            this.dfas.forEach((dfaModule, dfaModuleIndex) => {
-                this.#postTest(dfaModule, dfaModuleInfos[dfaModuleIndex], writeStreams[dfaModuleIndex]);
-            });
-        }
-        else if (configs.type === 'generate') {
-            let binaryStrings = [];
-            if (configs.random) {
-                binaryStrings = (0, utils_1.generateRandomBinaryStrings)(configs.random.total, configs.random.minLength, configs.random.maxLength);
-            }
-            else if (configs.range) {
-                binaryStrings = (0, utils_1.generateBinaryStrings)(configs.range.bitLimit);
-            }
-            this.cliProgressBar.start(binaryStrings.length * this.dfas.length, 0, {
-                speed: 'N/A',
-            });
-            this.#testDfas(dfaModuleInfos, writeStreams.map(({ streams }) => streams), binaryStrings, (dfaModule, dfaModuleIndex) => {
-                this.#postTest(dfaModule, dfaModuleInfos[dfaModuleIndex], writeStreams[dfaModuleIndex]);
-            });
-        }
-    }
-}
-exports.DfaTest = DfaTest;
+__exportStar(require("./libs"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

dist/utils/index.d.ts

@@ -0,6 +1,5 @@
+import countFileLines from './countFileLines';
 import generateAggregateMessage from './generateAggregateMessage';
-import generateBinaryStrings from './generateBinaryStrings';
 import generateCaseMessage from './generateCaseMessage';
-import generateRandomBinaryStrings from './generateRandomBinaryStrings';
 import testDfa from './testDfa';
-export { generateAggregateMessage, generateRandomBinaryStrings, generateCaseMessage, generateBinaryStrings, testDfa, };
+export { countFileLines, generateAggregateMessage, generateCaseMessage, testDfa };

dist/utils/index.js

@@ -6,12 +6,10 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testDfa = exports.generateBinaryStrings = exports.generateCaseMessage = exports.generateRandomBinaryStrings = exports.generateAggregateMessage = void 0;
+exports.testDfa = exports.generateCaseMessage = exports.generateAggregateMessage = exports.countFileLines = void 0;
+const countFileLines_1 = __importDefault(require("./countFileLines"));
+exports.countFileLines = countFileLines_1.default;
 const generateAggregateMessage_1 = __importDefault(require("./generateAggregateMessage"));
 exports.generateAggregateMessage = generateAggregateMessage_1.default;
-const generateBinaryStrings_1 = __importDefault(require("./generateBinaryStrings"));
-exports.generateBinaryStrings = generateBinaryStrings_1.default;
 const generateCaseMessage_1 = __importDefault(require("./generateCaseMessage"));
 exports.generateCaseMessage = generateCaseMessage_1.default;
-const generateRandomBinaryStrings_1 = __importDefault(require("./generateRandomBinaryStrings"));
-exports.generateRandomBinaryStrings = generateRandomBinaryStrings_1.default;
 const testDfa_1 = __importDefault(require("./testDfa"));
 exports.testDfa = testDfa_1.default;

package.json

 {
   "name": "dfa-test",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A small library to get an insight and test any Deterministic finite automaton(DFA) with binary alphabets",
@@ -5,0 +5,0 @@ "main": "dist/index.js",

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

21019

increased by8.99%

Number of package files

24

increased by20%

Lines of code

419

increased by13.24%

Worsened metrics

Number of low supply chain risk alerts

3

increased by50%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes